Szybki quiz – przypomnienie poprzedniej lekcji

Pytanie 1. Które z nazw zmiennych są poprawne? Wybierz wszystkie.

a) 2liczba b) moja_liczba c) moja liczba d) liczba2

Pytanie 2. Co zostanie wyświetlone?

x = 5
x = "pięć"
print(x)

Pytanie 3. Dlaczego ten kod nie wyświetli imienia?

imie = "Ola"
print(Imie)

Pytanie 4. Co zostanie wyświetlone?

x, y, z = "Orange", "Banana", "Cherry"
print(y, z)

x = y = z = "Kiwi"
print(x, y, z)

Banana Cherry
Kiwi Kiwi Kiwi

Pytanie 5. Uzupełnij kod tak, aby wyświetlił Witaj Kama na mojej stronie. Podaj dwa sposoby.

user = "Kama"
print(......)

Pytanie 6. Co zostanie wyświetlone?

print("summer", "time", "holiday", sep="#")

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)  # False - a == 7 & b == 2 jest czytane jako a == (7 & b) == 2
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

POSUMOWANIE

Rodzaje operatorów w tej lekcji: arytmetyczne, przypisania, porównania, logiczne, łączenia ciągów oraz bitowe (tylko podstawy).

Operatory arytmetyczne

• / zawsze zwraca float (10 / 2 daje 5.0).
• // zwraca część całkowitą dzielenia, a % resztę z dzielenia.
• ** to potęgowanie. Potęga ułamkowa daje pierwiastek (9 ** 0.5 daje 3.0).
• * działa też na napisach i listach: "ab" * 3 daje ababab, a [0] * 3 daje [0, 0, 0].

Kolejność działań: nawiasy, **, negacja -x, * / // %, + -. Przy wątpliwościach używaj nawiasów.

• Pułapka: -4 ** 2 daje -16, bo to -(4 ** 2), a (-4) ** 2 daje 16.

Przypisanie

• = przypisuje wartość, a == porównuje.
• Operatory łączone (+=, -=, *=, /=, //=, %=, **=) to skrócony zapis, np. c += 5 oznacza c = c + 5.
• W Pythonie nie ma i++ ani i--. Zapisujemy i += 1 i i -= 1.
• x /= 2 zamienia x na float.

Łączenie ciągów

• Przecinek w print() wstawia spację i nie wymaga konwersji typów.
• + łączy tylko napisy z napisami. Napis z liczbą trzeba połączyć przez str(liczba), w przeciwnym razie wystąpi TypeError.

Porównania zwracają True lub False: ==, !=, >, <, >=, <=.

• is sprawdza, czy to ten sam obiekt w pamięci, a == sprawdza, czy wartości są równe.
• Z None porównujemy przez is None lub is not None.

Operatory logiczne

• and daje True, gdy oba warunki są prawdziwe.
• or daje True, gdy przynajmniej jeden jest prawdziwy.
• not odwraca wartość.
• Kolejność: not, potem and, potem or.

Operatory bitowe &, |, ^ działają na bitach liczb. W lekcji są wprowadzone jako zagadnienie rzadko używane w codziennym programowaniu.

• Do łączenia warunków używamy and / or, a nie & / |.

Minimum, które powinno wejść w pamięć

Jeżeli masz zapamiętać tylko kilka rzeczy z tej lekcji, zapamiętaj te:

1. = przypisuje, == porównuje.
2. / daje float, // daje część całkowitą, % daje resztę.
3. Kolejność działań: nawiasy, **, -x, * / // %, + -. Pułapka: -4 ** 2 daje -16.
4. W Pythonie nie ma i++. Zapisujemy i += 1.
5. Napisu nie dodasz do liczby przez +. Użyj str() albo przecinka w print().
6. == porównuje wartości, a is porównuje obiekty. Z None używamy is None.
7. and, or, not: kolejność not, and, or. W razie wątpliwości stawiaj nawiasy.
8. Wynik każdego porównania to True lub False.
9. Warunki łączymy przez and / or, a nie & / |.

Ściągawka – najważniejsze polecenia i składnia

Arytmetyczne (dla a = 10, b = 3)

Przypisanie

Porównania i tożsamość (wynik: True / False)

== równe | != różne | > < >= <= | is ten sam obiekt | is not inny obiekt

Logiczne

not A odwraca wartość. Kolejność: not, and, or.

Bitowe (liczby): a & b (AND), a | b (OR), a ^ b (XOR).

Łączenie ciągów

print("Imię:", name, "Wiek:", age)   # przecinek: spacja automatycznie
print("Wiek: " + str(age))           # plus: tylko napisy, liczbę zamień przez str()
print("=" * 20)                      # mnożenie napisu

Przydatne schematy

liczba % 2 == 0          # czy liczba jest parzysta
wiek >= 18 and wiek <= 65   # zakres z obiema granicami
x is None                # porównanie z None

Quiz – sprawdź się

Pytanie 1 (teoria). Czym różni się = od ==? Podaj po jednym przykładzie.

Pytanie 2 (co zostanie wyświetlone).

a = 17
print(a // 5, a % 5, a / 5)

Pytanie 3 (precedencja). Podaj wynik każdego wyrażenia:

print(2 + 3 * 2 ** 2)
print(-3 ** 2)
print((-3) ** 2)

Pytanie 4 (znajdź błąd). Ten kod powoduje błąd. Wskaż go i popraw.

i = 0
i++
print(i)

Pytanie 5 (znajdź błąd). Dlaczego ten kod nie działa? Podaj dwa sposoby naprawy.

age = 17
print("Wiek: " + age)

Pytanie 6 (przewidywanie wyniku). Jaką wartość będzie miał x na końcu?

x = 10
x += 5
x *= 2
x %= 7
print(x)

Pytanie 7 (uzupełnij kod). Uzupełnij ___ tak, aby program wyświetlał True, gdy liczba jest parzysta:

liczba = 8
print(liczba % ___ == 0)

Co wyświetli się dla liczba = 7?

Pytanie 8 (operatory logiczne). Co zostanie wyświetlone?

a = 7
b = 2
print(a > 5 and b != 2)
print(a > 5 or b != 2)
print(not(a == 7))

Pytanie 9 (== czy is). Co zostanie wyświetlone?

a = [1, 2]
b = [1, 2]
c = a
print(a == b, a is b, a is c)

Pytanie 10 (wybór poprawnej składni). Który zapis poprawnie sprawdza, czy wiek mieści się w przedziale od 18 do 65 włącznie?

a) wiek >= 18 and wiek <= 65
b) wiek >= 18 or wiek <= 65
c) wiek => 18 and wiek =< 65
d) wiek >= 18 & wiek <= 65

Pytanie 11 (napisy i listy). Co zostanie wyświetlone?

print("ab" * 2, [1] * 3)

Pytanie 12 (operatory bitowe). Co zostanie wyświetlone?

print(6 & 3, 4 | 1)
print(True ^ True)

Pytanie 13 (krótkie zadanie praktyczne). Napisz program, który zamieni temperaturę 25 stopni Celsjusza na Fahrenheita według wzoru F = C * 9 / 5 + 32 i wyświetli: 25 C to 77.0 F. Użyj zmiennych i f-stringa.

c = 25
f = c * 9 / 5 + 32
print(f"{c} C to {f} F")