4. Python - operatory - Kama Kaczmarek

Operatory to symbole lub słowa kluczowe służące do wykonywania operacji na wartościach i zmiennych. Są fundamentalnym elementem każdego języka programowania, umożliwiającym przeprowadzanie obliczeń, porównań i operacji logicznych.

Python oferuje bogatą paletę operatorów pogrupowanych w kategorie:

Operatory arytmetyczne (obliczenia matematyczne)
Operatory przypisania (nadawanie wartości)
Operatory porównania (sprawdzanie relacji)
Operatory logiczne (łączenie warunków)
Operatory specjalne (szczególne zastosowania)

STOSOWANIE OPERATORÓW

OPERATORY ARYTMETYCZNE

Operatory arytmetyczne służą do wykonywania podstawowych operacji matematycznych.

a = 10
b = 3

# Dodawanie
wynik = a + b
print(f"{a} + {b} = {wynik}")  # 10 + 3 = 13

# Odejmowanie
wynik = a - b
print(f"{a} - {b} = {wynik}")  # 10 - 3 = 7

# Mnożenie
wynik = a * b
print(f"{a} * {b} = {wynik}")  # 10 * 3 = 30

# Dzielenie (zwraca float)
wynik = a / b
print(f"{a} / {b} = {wynik}")  # 10 / 3 = 3.3333333333333335

Dzielenie całkowite. Dzielenie całkowite zwraca tylko część całkowitą wyniku, odrzucając resztę.

a = 10
b = 3

# Dzielenie całkowite
wynik = a // b
print(f"{a} // {b} = {wynik}")  # 10 // 3 = 3

# Porównanie z normalnym dzieleniem
print(f"{a} / {b} = {a / b}")   # 10 / 3 = 3.333...
print(f"{a} // {b} = {a // b}") # 10 // 3 = 3

# Inne przykłady
print(17 // 5)   # 3
print(20 // 6)   # 3
print(100 // 7)  # 14

Modulo (reszta z dzielenia). Operator modulo % zwraca resztę z dzielenia.

a = 10
b = 3

wynik = a % b
print(f"{a} % {b} = {wynik}")  # 10 % 3 = 1

# Inne przykłady
print(17 % 5)   # 2  (17 = 5*3 + 2)
print(20 % 6)   # 2  (20 = 6*3 + 2)
print(100 % 7)  # 2  (100 = 7*14 + 2)

Potęgowanie. Operator ** podnosi liczbę do potęgi.

a = 10
b = 3

wynik = a ** b
print(f"{a} ** {b} = {wynik}")  # 10 ** 3 = 1000

# Inne przykłady
print(2 ** 8)    # 256
print(3 ** 4)    # 81
print(5 ** 2)    # 25

# Pierwiastek (potęga ułamkowa)
print(9 ** 0.5)   # 3.0 (pierwiastek kwadratowy)
print(27 ** (1/3)) # 3.0 (pierwiastek sześcienny)

Uwaga na precedencję:

# Potęgowanie ma WYŻSZĄ precedencję niż negacja
print(-4 ** 2)    # -16 (interpretowane jako -(4**2))
print((-4) ** 2)  # 16  (najpierw negacja, potem potęga)

# Bezpieczniej używaj nawiasów

Negacja. Operator - przed liczbą zmienia jej znak.

a = 10
wynik = -a
print(f"-{a} = {wynik}")  # -10 = -10

# Podwójna negacja
b = -5
print(-b)  # 5

# W wyrażeniach
x = 10
y = -x + 5
print(y)  # -5

Mnożenie stringów i list. Operator * ma specjalne zastosowanie dla stringów i list.

# Mnożenie stringa
napis = "Python"
print(napis * 3)  # PythonPythonPython

# Praktyczne zastosowania
print("=" * 40)  # ========================================
print("-" * 20)  # --------------------

# Mnożenie listy
lista = [1, 2, 3]
print(lista * 2)  # [1, 2, 3, 1, 2, 3]

# Tworzenie pustych list
zeros = [0] * 10
print(zeros)  # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Kolejność wykonywania operacji (precedencja)

Python wykonuje operacje według określonej kolejności:

Nawiasy ()
Potęgowanie **
Negacja -x
Mnożenie, dzielenie, modulo *, /, //, %
Dodawanie, odejmowanie +, -

# Przykłady precedencji
wynik = 2 + 3 * 4
print(wynik)  # 14 (najpierw 3*4=12, potem 2+12=14)

wynik = (2 + 3) * 4
print(wynik)  # 20 (nawiasy mają najwyższy priorytet)

wynik = 10 + 5 * 2 ** 3
print(wynik)  # 50 (2**3=8, 5*8=40, 10+40=50)

# Używaj nawiasów dla czytelności
wynik = 10 + (5 * (2 ** 3))  # To samo, ale czytelniejsze

OPERATOR PRZYPISANIA

Podstawowy operator przypisania to =, który nadaje wartość zmiennej.

# Podstawowe przypisanie
x = 5
y = 10
name = "Jan"

# Wyświetlanie
print(x)     # 5
print(y)     # 10
print(name)  # Jan

Uwaga: Operator = to przypisanie, nie równość! Równość sprawdzamy operatorem ==.

x = 5      # Przypisanie wartości 5 do zmiennej x
x == 5     # Sprawdzenie czy x równa się 5 (zwraca True)

ŁĄCZONE OPERATORY PRZYPISANIA

Skrócony zapis łączący operację z przypisaniem.

Operator +=

# Długi zapis
c = 10
c = c + 5
print(c)  # 15

# Skrócony zapis
c = 10
c += 5
print(c)  # 15

Operator -=

c = 10
c -= 3
print(c)  # 7
# To samo co: c = c - 3

Operator *=

c = 10
c *= 2
print(c)  # 20
# To samo co: c = c * 2

Operator /=

c = 10
c /= 2
print(c)  # 5.0
# To samo co: c = c / 2

Operator //=

c = 10
c //= 3
print(c)  # 3
# To samo co: c = c // 3

Operator %=

c = 10
c %= 3
print(c)  # 1
# To samo co: c = c % 3

Operator **=

c = 2
c **= 3
print(c)  # 8
# To samo co: c = c ** 3

Zestawienie operatorów przypisania

x = 10

x += 5   # x = x + 5    → x = 15
x -= 3   # x = x - 3    → x = 12
x *= 2   # x = x * 2    → x = 24
x /= 4   # x = x / 4    → x = 6.0
x //= 2  # x = x // 2   → x = 3.0
x %= 2   # x = x % 2    → x = 1.0
x **= 3  # x = x ** 3   → x = 1.0

PRE- I POSTINKREMENTACJA ORAZ DEKREMENTACJA

Te operatory w Python nie istnieją. Spotykane w innych językach operatory i++ lub ++i oraz i– lub –i nie mają tutaj zastosowania.

Korzystamy z zapisu i+=1 lub i=i+1

# ŹLE - to nie działa w Pythonie!
i++   # SyntaxError
++i   # Nie robi tego co myślisz
i--   # SyntaxError
--i   # Nie robi tego co myślisz

# DOBRZE - używaj w Pythonie
i = 0
i += 1  # Zwiększenie o 1
i -= 1  # Zmniejszenie o 1

# Lub pełny zapis
i = i + 1
i = i - 1

OPERATORY ŁĄCZENIA CIĄGÓW

Operator przecinka (spacja automatyczna)

a = 10
b = 3

print(a, b)  # 10 3 (automatyczna spacja)

# Więcej wartości
name = "Jan"
age = 25
print("Imię:", name, "Wiek:", age)
# Wynik: Imię: Jan Wiek: 25

Operator + (konkatenacja)

first_name = "Jan"
last_name = "Kowalski"

full_name = first_name + " " + last_name
print(full_name)  # Jan Kowalski

# UWAGA: Nie możesz łączyć string z liczbą!
age = 25
# print("Wiek: " + age)  # TypeError!

# Musisz skonwertować
print("Wiek: " + str(age))  # Działa

OPERATORY PORÓWNANIA

Operatory porównania zwracają wartość logiczną: True lub False.

Równość ==

a = 10
b = 3

print(a == b)   # False (10 nie równa się 3)
print(a == 10)  # True  (10 równa się 10)

# Dla stringów
name = "Jan"
print(name == "Jan")   # True
print(name == "Anna")  # False

Nierówność !=

a = 10
b = 3

print(a != b)   # True  (10 jest różne od 3)
print(a != 10)  # False (10 nie jest różne od 10)

Uwaga: Operator <> (alternatywa dla !=) był używany w Python 2, ale w Python 3 został usunięty. Używaj !=.

Większe >

a = 10
b = 3

print(a > b)   # True  (10 jest większe od 3)
print(b > a)   # False (3 nie jest większe od 10)
print(a > 10)  # False (10 nie jest większe od 10)

Mniejsze <

a = 10
b = 3

print(a < b)   # False (10 nie jest mniejsze od 3)
print(b < a)   # True  (3 jest mniejsze od 10)
print(a < 10)  # False (10 nie jest mniejsze od 10)

Większe lub równe >=

a = 10
b = 3

print(a >= b)   # True (10 jest większe od 3)
print(a >= 10)  # True (10 równa się 10)
print(a >= 20)  # False (10 nie jest większe lub równe 20)

Mniejsze lub równe <=

a = 10
b = 3

print(a <= b)   # False (10 nie jest mniejsze od 3)
print(a <= 10)  # True  (10 równa się 10)
print(b <= 5)   # True  (3 jest mniejsze od 5)

Operator is (identyczność)

Operator is sprawdza czy dwie zmienne odnoszą się do tego samego obiektu w pamięci.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True (zawartość jest taka sama)
print(a is b)  # False (to są różne obiekty w pamięci)
print(a is c)  # True (c wskazuje na ten sam obiekt co a)

Praktyczne zastosowanie – porównanie z None:

x = None

# DOBRZE - używaj is dla None
if x is None:
    print("x jest None")

# ŹLE - nie używaj == dla None
if x == None:
    print("Działa, ale niezgodne z konwencją")

Operator is not

a = [1, 2, 3]
b = [1, 2, 3]

print(a is not b)  # True (to są różne obiekty)

# Praktyczne zastosowanie
x = 5
if x is not None:
    print("x ma wartość")

OPERATORY LOGICZNE

Operatory logiczne łączą warunki i zwracają True lub False.

Operator and (i) – zwraca True tylko gdy OBA warunki są prawdziwe.

a = 7
b = 2

# Oba warunki muszą być True
print(a < 10 and b != 2)  # False (a < 10 to True, ale b != 2 to False)
print(a < 10 and b == 2)  # True  (oba warunki są True)

# Praktyczny przykład
age = 25
if age >= 18 and age <= 65:
    print("Wiek roboczy")

Tabela prawdy dla AND:

A	B	A and B
True	True	True
True	False	False
False	True	False
False	False	False

Operator or (lub) – zwraca True gdy PRZYNAJMNIEJ JEDEN warunek jest prawdziwy.

a = 7

# Wystarczy że jeden warunek jest True
print(a >= 5 or a > 10)  # True (a >= 5 to True)
print(a == 10 or a > 20) # False (oba warunki są False)

# Praktyczny przykład
day = "sobota"
if day == "sobota" or day == "niedziela":
    print("Weekend!")

Tabela prawdy dla OR:

A	B	A or B
True	True	True
True	False	True
False	True	True
False	False	False

Operator not (negacja)

x = 5

print(not(x < 5))   # True (x < 5 to False, not False to True)
print(not(x == 5))  # False (x == 5 to True, not True to False)

# Praktyczny przykład
is_logged_in = False
if not is_logged_in:
    print("Zaloguj się!")

Łączenie operatorów logicznych

age = 25
is_student = True
has_id = True

# Złożone warunki
if age >= 18 and (is_student or has_id):
    print("Dostęp przyznany")

# Kolejność wykonywania: not → and → or
# Używaj nawiasów dla czytelności
result = (a > 5 and b < 10) or (c == 20 and not d)

Operatory bitowe

Operatory bitowe działają na poziomie bitów liczby. Rzadko używane w codziennym programowaniu.

Operator & (bitowe AND)

a = 7   # 0111 w binarnym
b = 2   # 0010 w binarnym

print(a & b)  # 2 (0010 w binarnym)

# Sprawdzanie warunku (podobnie jak and)
print(a == 7 & b == 2)  # True

Operator | (bitowe OR)

a = 5   # 0101 w binarnym
b = 3   # 0011 w binarnym

print(a | b)  # 7 (0111 w binarnym)

# Sprawdzanie warunku (podobnie jak or)
print(10 == 5 | 2 > 6)  # False

Operator ^ (bitowe XOR) – zwraca True gdy DOKŁADNIE JEDEN warunek jest prawdziwy.

a = 5
b = 3

print(a == 5 ^ b == 3)  # False (oba True, więc XOR zwraca False)
print(a == 5 ^ b == 10) # True (pierwszy True, drugi False)
print(a == 1 ^ b == 3)  # True (pierwszy False, drugi True)

Tabela prawdy dla XOR:

A	B	A ^ B
True	True	False
True	False	True
False	True	True
False	False	False

Ćwiczenie 1

Napisz program, który obliczy pole koła o promieniu 5 cm.

Przyjmij w przybliżeniu wartość liczby pi: pi = 3.14

Oczekiwany wynik:

Pole koła wynosi: 78.5 cm2

Ćwiczenie 2

Napisz program, który wyznaczy wartość przyszłą kwoty 1000 PLN przy rocznej stopie procentowej 3%, kapitalizacji rocznej oraz 5-letnim okresie inwestycji. Wynik zaokrąglij do pełnych groszy.

Oczekiwany wynik:

Wartość końcowa inwestycji wynosi: 1159.27 PLN

Kama Kaczmarek

Strona z materiałami dla uczniów i nauczycieli

Strona z materiałami dla uczniów i nauczycieli

4. Python – operatory

STOSOWANIE OPERATORÓW

OPERATORY ARYTMETYCZNE

Kolejność wykonywania operacji (precedencja)

OPERATOR PRZYPISANIA

ŁĄCZONE OPERATORY PRZYPISANIA

PRE- I POSTINKREMENTACJA ORAZ DEKREMENTACJA

OPERATORY ŁĄCZENIA CIĄGÓW

OPERATORY PORÓWNANIA

OPERATORY LOGICZNE

Operatory bitowe