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:

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:

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:

Ć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:

1. 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:

1. Wartość końcowa inwestycji wynosi: 1159.27 PLN