Dlaczego generatory?

• Oszczędność pamięci (nie trzymają wszystkich wartości)
• Efektywność dla dużych zbiorów danych
• Nieskończone sekwencje
• Pipeline’y przetwarzania danych

Kluczowe słowo: yield (zamiast return)

Zwykła funkcja vs Generator

Zwykła funkcja:

def liczby_zwykla():
    """Zwraca listę - wszystko naraz w pamięci"""
    wynik = []
    for i in range(5):
        wynik.append(i)
    return wynik

print(liczby_zwykla())  # [0, 1, 2, 3, 4]

Generator:

def liczby_generator():
    """Generator - zwraca po kolei"""
    for i in range(5):
        yield i  # yield zamiast append/return

# Generator nie wykonuje się od razu
gen = liczby_generator()
print(gen)  # <generator object liczby_generator at 0x...>

# Pobierz wartości po kolei
print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 2

# Lub w pętli
for liczba in liczby_generator():
    print(liczba)
# 0, 1, 2, 3, 4

Jak działa yield

def prosty_generator():
    print("Start")
    yield 1
    print("Między 1 a 2")
    yield 2
    print("Między 2 a 3")
    yield 3
    print("Koniec")

gen = prosty_generator()

print("Pierwsza wartość:")
print(next(gen))
# Start
# 1

print("Druga wartość:")
print(next(gen))
# Między 1 a 2
# 2

print("Trzecia wartość:")
print(next(gen))
# Między 2 a 3
# 3

print("Próba czwartej:")
# next(gen)  # StopIteration - generator się wyczerpał

Kluczowe:

• Generator „zatrzymuje się” po każdym yield
• Przy następnym next() kontynuuje od miejsca zatrzymania
• Zapamiętuje stan (zmienne lokalne)

Pierwszy praktyczny generator

def liczby_parzyste(n):
    """Generuje liczby parzyste od 0 do n"""
    for i in range(n + 1):
        if i % 2 == 0:
            yield i

# Użycie
for liczba in liczby_parzyste(10):
    print(liczba)
# 0, 2, 4, 6, 8, 10

Generator vs Lista – porównanie pamięci

import sys

# Lista - wszystko w pamięci
lista = [x for x in range(1000000)]
print(f"Lista zajmuje: {sys.getsizeof(lista)} bajtów")
# Lista zajmuje: 8000056 bajtów

# Generator - tylko instrukcje
generator = (x for x in range(1000000))
print(f"Generator zajmuje: {sys.getsizeof(generator)} bajtów")
# Generator zajmuje: 104 bajty

# Generator jest ~77000 razy mniejszy!

Generator expressions (wyrażenia generatorowe)

Podobne do list comprehensions, ale z () zamiast []:

# List comprehension - lista w pamięci
lista = [x**2 for x in range(10)]
print(lista)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Generator expression - generator
generator = (x**2 for x in range(10))
print(generator)  # <generator object ...>

# Użycie
for wartosc in generator:
    print(wartosc)

Nieskończone generatory

def liczby_naturalne():
    """Nieskończony generator liczb naturalnych"""
    n = 0
    while True:  # Nieskończona pętla!
        yield n
        n += 1

# Użycie - pobierz pierwsze 10
gen = liczby_naturalne()
for i in range(10):
    print(next(gen))
# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Generator Fibonacciego

def fibonacci():
    """Nieskończony generator liczb Fibonacciego"""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Pierwsze 10 liczb
gen = fibonacci()
for i in range(10):
    print(next(gen))
# 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Generator z limitem

def fibonacci_limit(limit):
    """Generator Fibonacciego do limitu"""
    a, b = 0, 1
    while a <= limit:
        yield a
        a, b = b, a + b

# Wszystkie liczby Fibonacciego <= 100
for liczba in fibonacci_limit(100):
    print(liczba)
# 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89

Generator odczytujący plik

def czytaj_linie(nazwa_pliku):
    """Generator czytający plik linia po linii"""
    with open(nazwa_pliku, 'r', encoding='utf-8') as plik:
        for linia in plik:
            yield linia.strip()

# Użycie - oszczędność pamięci dla dużych plików
for linia in czytaj_linie('duzy_plik.txt'):
    print(linia)
    # Przetwarza jedną linię na raz, nie cały plik!

Generator z filtrowaniem

def wiersze_z_slowem(nazwa_pliku, slowo):
    """Generator zwracający wiersze zawierające słowo"""
    with open(nazwa_pliku, 'r', encoding='utf-8') as plik:
        for linia in plik:
            if slowo in linia:
                yield linia.strip()

# Znajdź wszystkie linie z "Python"
for linia in wiersze_z_slowem('log.txt', 'Python'):
    print(linia)

Generator liczb pierwszych

def liczby_pierwsze(limit):
    """Generator liczb pierwszych do limitu"""
    def czy_pierwsza(n):
        if n < 2:
            return False
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True
    
    for n in range(2, limit + 1):
        if czy_pierwsza(n):
            yield n

# Wszystkie liczby pierwsze <= 50
for liczba in liczby_pierwsze(50):
    print(liczba)
# 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47

Generator z yield from

yield from deleguje do innego generatora:

def generator1():
    yield 1
    yield 2
    yield 3

def generator2():
    yield 4
    yield 5
    yield 6

def polaczony():
    yield from generator1()
    yield from generator2()

for wartosc in polaczony():
    print(wartosc)
# 1, 2, 3, 4, 5, 6

Generator zagnieżdżonych list

def splaszcz(lista):
    """Spłaszcza zagnieżdżoną listę"""
    for element in lista:
        if isinstance(element, list):
            yield from splaszcz(element)  # Rekurencja!
        else:
            yield element

zagniezdzona = [1, [2, 3, [4, 5]], 6, [7, [8, 9]]]
for element in splaszcz(zagniezdzona):
    print(element)
# 1, 2, 3, 4, 5, 6, 7, 8, 9

Praktyczne przykłady

Przykład 1: Przetwarzanie CSV

def czytaj_csv(nazwa_pliku):
    """Generator wierszy CSV"""
    with open(nazwa_pliku, 'r', encoding='utf-8') as plik:
        naglowki = next(plik).strip().split(',')
        
        for linia in plik:
            wartosci = linia.strip().split(',')
            yield dict(zip(naglowki, wartosci))

# Użycie
for rekord in czytaj_csv('dane.csv'):
    print(rekord)
    # {'Imie': 'Jan', 'Wiek': '25', 'Miasto': 'Warszawa'}

Przykład 2: Batching (grupowanie)

def batches(iterable, rozmiar_batcha):
    """Dzieli iterable na batche o określonym rozmiarze"""
    batch = []
    for element in iterable:
        batch.append(element)
        if len(batch) == rozmiar_batcha:
            yield batch
            batch = []
    
    # Ostatni batch (może być mniejszy)
    if batch:
        yield batch

# Użycie
dane = range(1, 11)  # 1 do 10
for batch in batches(dane, 3):
    print(batch)
# [1, 2, 3]
# [4, 5, 6]
# [7, 8, 9]
# [10]

Przykład 3: Sliding window

def okno_przesuwne(iterable, rozmiar):
    """Generator okna przesuwnego"""
    from collections import deque
    okno = deque(maxlen=rozmiar)
    
    for element in iterable:
        okno.append(element)
        if len(okno) == rozmiar:
            yield list(okno)

# Użycie
dane = [1, 2, 3, 4, 5, 6, 7]
for okno in okno_przesuwne(dane, 3):
    print(okno)
# [1, 2, 3]
# [2, 3, 4]
# [3, 4, 5]
# [4, 5, 6]
# [5, 6, 7]

Przykład 4: Pipeline przetwarzania

def czytaj_liczby(nazwa_pliku):
    """Krok 1: Czytaj liczby z pliku"""
    with open(nazwa_pliku, 'r') as plik:
        for linia in plik:
            yield int(linia.strip())

def filtruj_parzyste(liczby):
    """Krok 2: Filtruj parzyste"""
    for liczba in liczby:
        if liczba % 2 == 0:
            yield liczba

def pomnoz_przez_2(liczby):
    """Krok 3: Pomnóż przez 2"""
    for liczba in liczby:
        yield liczba * 2

# Pipeline
liczby = czytaj_liczby('liczby.txt')
parzyste = filtruj_parzyste(liczby)
podwojone = pomnoz_przez_2(parzyste)

# Wszystko działa leniwie - przetwarza po jednej liczbie!
for wynik in podwojone:
    print(wynik)

Przykład 5: Generator losowych danych

import random

def losowe_liczby(ile, min_val, max_val):
    """Generator losowych liczb"""
    for _ in range(ile):
        yield random.randint(min_val, max_val)

def losowe_imiona(ile):
    """Generator losowych imion"""
    imiona = ['Jan', 'Anna', 'Piotr', 'Ewa', 'Tomasz', 'Kasia']
    for _ in range(ile):
        yield random.choice(imiona)

# Użycie
for liczba in losowe_liczby(5, 1, 100):
    print(liczba)
# 42, 17, 89, 5, 63

for imie in losowe_imiona(3):
    print(imie)
# Anna, Piotr, Jan

Send i Close

Generatory mogą również przyjmować wartości!

send()

def kalkulator():
    """Generator jako kalkulator"""
    wynik = 0
    while True:
        operacja = yield wynik
        if operacja is None:
            break
        
        akcja, liczba = operacja
        if akcja == 'dodaj':
            wynik += liczba
        elif akcja == 'odejmij':
            wynik -= liczba

# Użycie
kalk = kalkulator()
next(kalk)  # Uruchom generator

print(kalk.send(('dodaj', 10)))     # 10
print(kalk.send(('dodaj', 5)))      # 15
print(kalk.send(('odejmij', 3)))    # 12

close()

def nieskonczone_liczby():
    n = 0
    try:
        while True:
            yield n
            n += 1
    finally:
        print("Generator zamknięty - sprzątam")

gen = nieskonczone_liczby()
print(next(gen))  # 0
print(next(gen))  # 1
gen.close()       # Generator zamknięty - sprzątam
# print(next(gen))  # StopIteration

Itertools – moduł z generatorami

Python ma wbudowany moduł itertools z potężnymi generatorami:

import itertools

# count - nieskończone liczenie
for i in itertools.count(10, 2):
    if i > 20:
        break
    print(i)
# 10, 12, 14, 16, 18, 20

# cycle - cykliczne powtarzanie
kolory = itertools.cycle(['czerwony', 'zielony', 'niebieski'])
for i, kolor in enumerate(kolory):
    if i >= 6:
        break
    print(kolor)
# czerwony, zielony, niebieski, czerwony, zielony, niebieski

# repeat - powtarzanie n razy
for x in itertools.repeat('Python', 3):
    print(x)
# Python, Python, Python

# chain - łączenie iteratorów
for x in itertools.chain([1, 2, 3], ['a', 'b', 'c']):
    print(x)
# 1, 2, 3, a, b, c

# islice - wycinki
for x in itertools.islice(range(100), 5, 15, 2):
    print(x)
# 5, 7, 9, 11, 13

# combinations - kombinacje
for combo in itertools.combinations([1, 2, 3, 4], 2):
    print(combo)
# (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)

# permutations - permutacje
for perm in itertools.permutations([1, 2, 3], 2):
    print(perm)
# (1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)

Generator vs Iterator

Iterator to obiekt implementujący metody __iter__() i __next__():

class LicznikIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current >= self.limit:
            raise StopIteration
        self.current += 1
        return self.current

# Użycie
for i in LicznikIterator(5):
    print(i)
# 1, 2, 3, 4, 5

Generator to prostsza składnia dla iteratora:

def licznik_generator(limit):
    for i in range(1, limit + 1):
        yield i

# To samo, krócej!
for i in licznik_generator(5):
    print(i)
# 1, 2, 3, 4, 5

Podsumowanie Generatorów

Definicja:

• Funkcja z yield zamiast return
• Zwraca iterator
• Leniwa ewaluacja

Kluczowe słowa:

• yield – zwróć wartość i zatrzymaj
• yield from – deleguj do innego generatora
• next() – pobierz następną wartość
• send() – wyślij wartość do generatora
• close() – zamknij generator

Zalety:

• Oszczędność pamięci
• Efektywność dla dużych danych
• Nieskończone sekwencje
• Pipeline’y przetwarzania

Zastosowania:

• Przetwarzanie dużych plików
• Strumienie danych
• Pipeline’y transformacji
• Nieskończone sekwencje

Generator expressions:

• (x for x in range(10)) – jak list comprehension ale z ()

Ćwiczenia

Generatory

1. Napisz generator liczb od n do m z krokiem k.
2. Napisz generator liczb parzystych.
3. Napisz generator liczb nieparzystych.
4. Napisz generator Fibonacciego do limitu.
5. Napisz generator liczb pierwszych.
6. Napisz generator kwadratów liczb.
7. Napisz generator odwracający string znak po znaku.
8. Napisz generator czytający plik linia po linii.
9. Napisz generator filtrujący puste linie z pliku.
10. Napisz generator countdown (odliczanie).

Generatory – zaawansowane

11. Napisz generator spłaszczający zagnieżdżoną listę.
12. Napisz generator grupujący elementy w batche.
13. Napisz generator okna przesuwnego (sliding window).
14. Napisz generator permutacji listy.
15. Napisz generator kombinacji elementów.
16. Napisz generator kartezjańskiego iloczynu.
17. Napisz generator nieskończonych liczb Fibonacciego.
18. Napisz generator losowych liczb w zakresie.
19. Napisz generator dat między dwoma datami.
20. Napisz generator tokenów z tekstu.

Generator expressions

21. Stwórz generator expression kwadratów liczb 1-10.
22. Stwórz generator expression parzystych z listy.
23. Filtruj listę stringów (długość > 5) przez generator.
24. Stwórz generator sumujący elementy dwóch list.
25. Generator expression dla wielkich liter z tekstu.

Pipeline’y

26. Stwórz pipeline: czytaj liczby → filtruj parzyste → pomnóż × 2.
27. Pipeline: czytaj plik → filtruj linie ze słowem → zlicz.
28. Pipeline: generator liczb → filtruj pierwsze → sumuj.
29. Pipeline: czytaj CSV → przekształć dane → filtruj.
30. Pipeline: generuj losowe → filtruj zakres → agreguj.

Praktyczne zastosowania

31. Generator odczytujący duży plik CSV.
32. Generator przetwarzający logi (filtruj ERROR).
33. Generator paginacji (strony wyników).
34. Generator krokowy (skip n elementów).
35. Generator unikalnych elementów.
36. Generator zip dla wielu iteratorów.
37. Generator grupujący po kluczu.
38. Generator akumulujący (cumsum).
39. Generator take/drop (weź n, pomiń n).
40. Generator iterujący po drzewie katalogów.

Artykuł 23. Python – Generatory pochodzi z serwisu Kama Kaczmarek.

Kluczowe elementy:

• Funkcja zagnieżdżona (wewnątrz innej funkcji)
• Funkcja wewnętrzna odwołuje się do zmiennych zewnętrznych
• Funkcja zewnętrzna zwraca funkcję wewnętrzną

Dlaczego closures są ważne?

• Enkapsulacja danych
• Tworzenie funkcji fabryk
• Dekoratory
• Callbacks i event handlery

Podstawy – funkcje zagnieżdżone

def zewnetrzna():
    """Funkcja zewnętrzna"""
    wiadomosc = "Hello"
    
    def wewnetrzna():
        """Funkcja wewnętrzna"""
        print(wiadomosc)  # Dostęp do zmiennej zewnętrznej
    
    wewnetrzna()

zewnetrzna()  # Hello

Zwracanie funkcji wewnętrznej

def zewnetrzna():
    wiadomosc = "Hello"
    
    def wewnetrzna():
        print(wiadomosc)
    
    return wewnetrzna  # Zwracamy funkcję (bez nawiasów!)

# Przypisz funkcję do zmiennej
funkcja = zewnetrzna()

# Wywołaj
funkcja()  # Hello

Ważne: Funkcja wewnetrzna „zapamiętała” zmienną wiadomosc mimo że zewnetrzna() już się zakończyła!

Pierwszy prawdziwy closure

def stworz_powitanie(pozdrowienie):
    """Funkcja fabrykująca - tworzy spersonalizowane powitania"""
    
    def powitaj(imie):
        return f"{pozdrowienie}, {imie}!"
    
    return powitaj

# Stwórz różne funkcje powitań
hello = stworz_powitanie("Hello")
czesc = stworz_powitanie("Cześć")
hola = stworz_powitanie("Hola")

# Użycie
print(hello("Anna"))   # Hello, Anna!
print(czesc("Jan"))    # Cześć, Jan!
print(hola("Maria"))   # Hola, Maria!

Co się dzieje:

1. stworz_powitanie("Hello") tworzy funkcję powitaj która „pamięta” pozdrowienie = "Hello"
2. Każde wywołanie tworzy niezależne closure z własną wartością

Closure z wieloma zmiennymi

def licznik(start=0):
    """Tworzy licznik zaczynający od start"""
    count = start
    
    def increment():
        nonlocal count  # Pozwala modyfikować zmienną zewnętrzną
        count += 1
        return count
    
    return increment

# Stwórz liczniki
licznik1 = licznik(0)
licznik2 = licznik(100)

print(licznik1())  # 1
print(licznik1())  # 2
print(licznik1())  # 3

print(licznik2())  # 101
print(licznik2())  # 102

Kluczowe słowo nonlocal:

• Bez nonlocal – Python tworzy nową lokalną zmienną
• Z nonlocal – modyfikuje zmienną z zakresu zewnętrznego

Przykład: Mnożnik

def stworz_mnoznik(n):
    """Tworzy funkcję mnożącą przez n"""
    
    def mnoz(x):
        return x * n
    
    return mnoz

# Stwórz różne mnożniki
razy_2 = stworz_mnoznik(2)
razy_5 = stworz_mnoznik(5)
razy_10 = stworz_mnoznik(10)

print(razy_2(10))   # 20
print(razy_5(10))   # 50
print(razy_10(10))  # 100

Przykład: Funkcja potęgująca

def stworz_potege(wykladnik):
    """Tworzy funkcję podnoszącą do potęgi"""
    
    def poteguj(podstawa):
        return podstawa ** wykladnik
    
    return poteguj

# Różne potęgi
kwadrat = stworz_potege(2)
szescian = stworz_potege(3)
czwarta = stworz_potege(4)

print(kwadrat(5))   # 25
print(szescian(5))  # 125
print(czwarta(2))   # 16

Closure ze stanem

def stworz_konto(wlasciciel, saldo_poczatkowe=0):
    """Tworzy konto bankowe z enkapsulacją"""
    saldo = saldo_poczatkowe
    
    def wplata(kwota):
        nonlocal saldo
        if kwota > 0:
            saldo += kwota
            return f"{wlasciciel}: Wpłata {kwota}. Saldo: {saldo}"
        return "Kwota musi być dodatnia"
    
    def wyplata(kwota):
        nonlocal saldo
        if kwota > saldo:
            return f"{wlasciciel}: Brak środków. Saldo: {saldo}"
        if kwota > 0:
            saldo -= kwota
            return f"{wlasciciel}: Wypłata {kwota}. Saldo: {saldo}"
        return "Kwota musi być dodatnia"
    
    def sprawdz_saldo():
        return f"{wlasciciel}: Saldo: {saldo}"
    
    # Zwróć słownik funkcji
    return {
        'wplata': wplata,
        'wyplata': wyplata,
        'saldo': sprawdz_saldo
    }

# Stwórz konta
konto_jan = stworz_konto("Jan", 1000)
konto_anna = stworz_konto("Anna", 500)

# Użycie
print(konto_jan['saldo']())        # Jan: Saldo: 1000
print(konto_jan['wplata'](500))    # Jan: Wpłata 500. Saldo: 1500
print(konto_jan['wyplata'](200))   # Jan: Wypłata 200. Saldo: 1300

print(konto_anna['saldo']())       # Anna: Saldo: 500

Zalety:

• Dane są prywatne (nie można bezpośrednio modyfikować saldo)
• Każde konto ma niezależny stan
• Enkapsulacja bez klas

Closure vs Klasy

Z klasą:

class Licznik:
    def __init__(self, start=0):
        self.count = start
    
    def increment(self):
        self.count += 1
        return self.count

licznik = Licznik(0)
print(licznik.increment())  # 1

Z closure:

def licznik(start=0):
    count = start
    
    def increment():
        nonlocal count
        count += 1
        return count
    
    return increment

licznik = licznik(0)
print(licznik())  # 1

Kiedy używać:

• Closure – proste przypadki, enkapsulacja jednej funkcji
• Klasy – złożone obiekty, wiele metod, dziedziczenie

Praktyczne zastosowania

1. Dekoratory (najczęstsze!)

def mierz_czas(funkcja):
    """Dekorator mierzący czas wykonania"""
    import time
    
    def wrapper(*args, **kwargs):
        start = time.time()
        wynik = funkcja(*args, **kwargs)
        koniec = time.time()
        print(f"{funkcja.__name__} wykonała się w {koniec - start:.4f}s")
        return wynik
    
    return wrapper

@mierz_czas
def wolna_funkcja():
    import time
    time.sleep(1)
    return "Gotowe"

wynik = wolna_funkcja()
# wolna_funkcja wykonała się w 1.0012s

2. Funkcje fabrykujące

def stworz_validator(min_dlugosc, max_dlugosc):
    """Tworzy validator długości"""
    
    def waliduj(tekst):
        dlugosc = len(tekst)
        if dlugosc < min_dlugosc:
            return False, f"Za krótkie (min: {min_dlugosc})"
        if dlugosc > max_dlugosc:
            return False, f"Za długie (max: {max_dlugosc})"
        return True, "OK"
    
    return waliduj

# Stwórz różne validatory
waliduj_haslo = stworz_validator(8, 20)
waliduj_nick = stworz_validator(3, 15)

print(waliduj_haslo("abc"))      # (False, 'Za krótkie (min: 8)')
print(waliduj_haslo("Python123")) # (True, 'OK')
print(waliduj_nick("Jo"))        # (False, 'Za krótkie (min: 3)')

3. Callbacks z kontekstem

def stworz_button_handler(button_id):
    """Tworzy handler dla przycisku"""
    klikniecia = 0
    
    def on_click():
        nonlocal klikniecia
        klikniecia += 1
        print(f"Przycisk {button_id} kliknięty {klikniecia} razy")
    
    return on_click

# Stwórz handlery
button1_click = stworz_button_handler("Zapisz")
button2_click = stworz_button_handler("Anuluj")

# Symulacja kliknięć
button1_click()  # Przycisk Zapisz kliknięty 1 razy
button1_click()  # Przycisk Zapisz kliknięty 2 razy
button2_click()  # Przycisk Anuluj kliknięty 1 razy

4. Memoizacja (cache wyników)

def memoize(funkcja):
    """Closure cache'ujące wyniki funkcji"""
    cache = {}
    
    def wrapper(*args):
        if args in cache:
            print(f"Zwracam z cache dla {args}")
            return cache[args]
        
        print(f"Obliczam dla {args}")
        wynik = funkcja(*args)
        cache[args] = wynik
        return wynik
    
    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(5))
# Obliczam dla (5,)
# Obliczam dla (4,)
# Obliczam dla (3,)
# Obliczam dla (2,)
# Obliczam dla (1,)
# Obliczam dla (0,)
# Zwracam z cache dla (1,)
# Zwracam z cache dla (2,)
# Zwracam z cache dla (3,)
# 5

5. Rate limiting

def rate_limiter(max_calls, time_window):
    """Ogranicza liczbę wywołań funkcji w czasie"""
    import time
    calls = []
    
    def decorator(funkcja):
        def wrapper(*args, **kwargs):
            nonlocal calls
            teraz = time.time()
            
            # Usuń stare wywołania
            calls = [c for c in calls if teraz - c < time_window]
            
            if len(calls) >= max_calls:
                return f"Za dużo wywołań! Max {max_calls} w {time_window}s"
            
            calls.append(teraz)
            return funkcja(*args, **kwargs)
        
        return wrapper
    return decorator

@rate_limiter(max_calls=3, time_window=10)
def wyslij_email(adres):
    return f"Email wysłany do {adres}"

# Pierwsze 3 wywołania - OK
print(wyslij_email("jan@test.com"))
print(wyslij_email("anna@test.com"))
print(wyslij_email("piotr@test.com"))

# 4-te - za dużo
print(wyslij_email("ewa@test.com"))
# Za dużo wywołań! Max 3 w 10s

Inspekcja closure

def zewnetrzna(x):
    def wewnetrzna(y):
        return x + y
    return wewnetrzna

closure_func = zewnetrzna(10)

# Sprawdź co closure "zapamiętała"
print(closure_func.__closure__)
# (<cell at 0x...: int object at 0x...>,)

# Wartość
print(closure_func.__closure__[0].cell_contents)  # 10

Podsumowanie Closures

Definicja:

• Funkcja zagnieżdżona
• Używa zmiennych z funkcji zewnętrznej
• Jest zwracana przez funkcję zewnętrzną

Kluczowe słowa:

• nonlocal – modyfikuj zmienną zewnętrzną

Zastosowania:

• Dekoratory
• Funkcje fabrykujące
• Enkapsulacja danych
• Callbacks z kontekstem
• Memoizacja

Zalety:

• Prywatne dane
• Prostsza składnia niż klasy
• Funkcyjne programowanie

Ćwiczenia

1. Napisz closure zwracające funkcję mnożącą przez dowolną liczbę.
2. Napisz closure tworzące licznik (increment, decrement, reset).
3. Napisz closure zapisujące historię wywołań funkcji.
4. Stwórz funkcję fabrykującą validatory (min długość, max długość).
5. Napisz closure implementujące prostą cache (memoizację).
6. Stwórz closure z prywatnym stanem (np. konto bankowe).
7. Napisz closure logujące wywołania funkcji.
8. Stwórz closure obliczające średnią ruchomą.
9. Napisz closure rate limitera (max wywołań w czasie).
10. Stwórz closure generujące unikalne ID.

Artykuł 22. Python – Closures (Domknięcia) pochodzi z serwisu Kama Kaczmarek.

Rodzaje błędów:

1. Składniowe (Syntax Errors) – błędy w kodzie, program się nie uruchomi
2. Runtime Errors – błędy podczas działania (wyjątki)
3. Logiczne – program działa, ale wyniki są błędne

Dlaczego debugging jest ważny?

• Każdy kod ma bugi
• Debugowanie to 50%+ czasu programisty
• Umiejętność szybkiego znajdowania błędów = produktywność

Metody debugowania

1. Print debugging (najprostsza)

def oblicz_srednia(liczby):
    suma = 0
    for liczba in liczby:
        print(f"Dodaję: {liczba}")  # Debug
        suma += liczba
    
    print(f"Suma: {suma}")  # Debug
    print(f"Liczba elementów: {len(liczby)}")  # Debug
    
    srednia = suma / len(liczby)
    print(f"Średnia: {srednia}")  # Debug
    
    return srednia

wynik = oblicz_srednia([10, 20, 30])

Zalety:

• Proste
• Szybkie
• Działa wszędzie

Wady:

• Trzeba pamiętać o usunięciu printów
• Nieefektywne dla złożonych problemów

2. Asercje (Assertions)

def podziel(a, b):
    assert b != 0, "Dzielnik nie może być zerem!"
    return a / b

# Asercja sprawdza warunek
# Jeśli False → AssertionError z komunikatem

wynik = podziel(10, 2)  # OK
# wynik = podziel(10, 0)  # AssertionError: Dzielnik nie może być zerem!

Użycie:

• Sprawdzanie założeń
• Walidacja stanów wewnętrznych
• Tylko w fazie rozwoju (wyłączane w produkcji)

Python

def oblicz_srednia(liczby):
    assert len(liczby) > 0, "Lista nie może być pusta!"
    assert all(isinstance(x, (int, float)) for x in liczby), "Wszystkie elementy muszą być liczbami!"
    
    return sum(liczby) / len(liczby)

3. Logging – profesjonalne logowanie

import logging

# Konfiguracja
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def oblicz_srednia(liczby):
    logging.debug(f"Wywołano oblicz_srednia z {liczby}")
    
    if not liczby:
        logging.error("Lista jest pusta!")
        return None
    
    suma = sum(liczby)
    logging.info(f"Suma: {suma}")
    
    srednia = suma / len(liczby)
    logging.info(f"Średnia: {srednia}")
    
    return srednia

wynik = oblicz_srednia([10, 20, 30])

Poziomy logowania:

• DEBUG – szczegółowe informacje diagnostyczne
• INFO – potwierdzenie że wszystko działa
• WARNING – coś nieprzewidzianego, ale program działa
• ERROR – poważny problem
• CRITICAL – program może się zatrzymać

4. Debugger PDB (Python Debugger)

PDB to wbudowany debugger w Pythonie.

import pdb

def oblicz_srednia(liczby):
    suma = 0
    
    for liczba w liczby:
        pdb.set_trace()  # ← Breakpoint - program się zatrzyma tutaj
        suma += liczba
    
    return suma / len(liczby)

oblicz_srednia([10, 20, 30])

Podstawowe komendy PDB:

• l (list) – pokaż kod
• n (next) – następna linia
• s (step) – wejdź do funkcji
• c (continue) – kontynuuj do następnego breakpointa
• p zmienna – wypisz wartość zmiennej
• pp zmienna – ładnie wypisz
• h (help) – pomoc
• q (quit) – wyjdź

5. Breakpoint() – Python 3.7+

def oblicz_srednia(liczby):
    suma = 0
    
    for liczba in liczby:
        breakpoint()  # ← Nowocześniejszy sposób
        suma += liczba
    
    return suma / len(liczby)

oblicz_srednia([10, 20, 30])

breakpoint() to to samo co pdb.set_trace(), ale lepsze (można łatwo wyłączyć wszystkie).

Debugowanie w IDE

Visual Studio Code

Dokumentacja debuggowania

Interfejs użytkownika debuggera

• Widok Uruchom i debuguj : wyświetla wszystkie informacje dotyczące uruchamiania, debugowania i zarządzania ustawieniami konfiguracji debugowania.
• Pasek narzędzi debugowania : zawiera przyciski umożliwiające wykonywanie najczęściej spotykanych czynności debugowania.
• Konsola debugowania : umożliwia przeglądanie i interakcję z wynikami kodu uruchomionego w debugerze.
• Pasek boczny debugowania : w trakcie sesji debugowania umożliwia interakcję ze stosem wywołań, punktami przerwania, zmiennymi i zmiennymi obserwowanymi.
• Menu Uruchom : zawiera najczęstsze polecenia uruchamiania i debugowania.

Rozpocznij sesję debugowania

• Otwórz plik zawierający kod, który chcesz debugować.
• Rozpocznij sesję debugowania klawiszem F5 lub wybierz opcję Uruchom i debuguj w widoku Uruchom i debuguj ( workbench.view.debug).

W przypadku bardziej złożonych scenariuszy debugowania, takich jak dołączanie do działającego procesu, należy utworzyć 
launch.jsonplik określający konfigurację debugera. Więcej informacji na temat 
konfiguracji debugowania znajdziesz tutaj .

• Z listy dostępnych debugerów wybierz debuger, którego chcesz użyć.VS Code próbuje uruchomić i debugować aktualnie aktywny plik. W przypadku Node.js, VS Code sprawdza, czy startw package.jsonpliku znajduje się skrypt, aby określić punkt wejścia aplikacji.
• Po rozpoczęciu sesji debugowania wyświetlany jest panel DEBUG CONSOLE z wynikami debugowania, a pasek stanu zmienia kolor (domyślny motyw kolorystyczny jest pomarańczowy).

Podstawowe funkcje:

Po rozpoczęciu sesji debugowania u góry okna pojawia się pasek narzędzi Debugowanie. Pasek zawiera akcje sterujące przebiegiem sesji debugowania, takie jak przechodzenie przez kod krok po kroku, wstrzymywanie wykonywania i zatrzymywanie sesji debugowania.

• F9 – ustaw/usuń breakpoint
• F5 – rozpocznij debugowanie
• F10 – następna linia (step over)
• F11 – wejdź do funkcji (step into)
• Shift+F11 – wyjdź z funkcji (step out)
• F5 – kontynuuj

Punkty przerwania

Punkt przerwania to specjalny znacznik, który wstrzymuje wykonywanie kodu w określonym momencie, umożliwiając sprawdzenie stanu aplikacji w tym momencie. VS Code obsługuje kilka typów punktów przerwania

Ustawianie punktów przerwania

Aby ustawić lub usunąć punkt przerwania, kliknij margines edytora lub użyj klawisza F9 w bieżącym wierszu.

• Punkty przerwania na marginesie edytora są zazwyczaj wyświetlane jako wypełnione na czerwono kółka.
• Wyłączone punkty przerwania są oznaczone wypełnionym szarym okręgiem.
• Po uruchomieniu sesji debugowania punkty przerwania, których nie można zarejestrować w debugerze, zmieniają się w szare, puste kółko. To samo może się zdarzyć, jeśli kod źródłowy jest edytowany podczas sesji debugowania bez obsługi edycji na żywo.

Aby mieć większą kontrolę nad punktami przerwania, skorzystaj z sekcji 
„PUNKTY PRZERWANIA” w widoku 
„Uruchom i debuguj” . Ta sekcja zawiera listę wszystkich punktów przerwania w kodzie i udostępnia dodatkowe akcje do zarządzania nimi.

PyCharm

Podobne funkcje:

• Kliknij na marginesie obok linii → breakpoint
• Shift+F9 – debuguj
• F8 – następna linia
• F7 – wejdź do funkcji

Techniki debugowania

1. Rubber Duck Debugging

Metoda: Wyjaśnij swój kod „gumowej kaczce” (lub koledze) linijka po linijce.

Dlaczego działa: Wymuszając werbalizację często sam znajdziesz błąd.

2. Dziel i zwyciężaj

# Błąd gdzieś w tym kodzie
def skomplikowana_funkcja(dane):
    # 100 linii kodu
    ...
    return wynik

# Podziel na mniejsze części
def czesc1(dane):
    print("Po części 1:", dane)  # Debug
    return wynik1

def czesc2(dane):
    print("Po części 2:", dane)  # Debug
    return wynik2

def czesc3(dane):
    print("Po części 3:", dane)  # Debug
    return wynik3

3. Binary Search Debugging

Jeśli wiesz że błąd jest w 100-liniowej funkcji:

1. Dodaj print/breakpoint w linii 50
2. Sprawdź czy błąd jest przed czy po
3. Powtarzaj aż znajdziesz

4. Zrozum komunikat błędu

Traceback (most recent call last):
  File "program.py", line 10, in <module>
    wynik = oblicz(5, 0)
  File "program.py", line 6, in oblicz
    return a / b
ZeroDivisionError: division by zero

Jak czytać:

• Od dołu do góry!
• Ostatnia linia = typ błędu i komunikat
• Powyżej = stos wywołań (gdzie nastąpił błąd)

Częste błędy i jak je debugować

1. NameError – niezdefiniowana zmienna

print(zmiennna)  # NameError: name 'zmiennna' is not defined

# Debug:
# - Sprawdź literówki
# - Czy zmienna została zdefiniowana?
# - Czy jesteś w odpowiednim zakresie (scope)?

2. IndexError – indeks poza zakresem

lista = [1, 2, 3]
print(lista[5])  # IndexError: list index out of range

# Debug:
print(f"Długość listy: {len(lista)}")
print(f"Próbuję dostać się do indeksu: 5")
# Aha! 5 >= 3

3. KeyError – brak klucza w słowniku

slownik = {"klucz1": "wartość1"}
print(slownik["klucz2"])  # KeyError: 'klucz2'

# Debug:
print(f"Dostępne klucze: {slownik.keys()}")
# Użyj get() zamiast []
print(slownik.get("klucz2", "Domyślna"))

4. TypeError – niewłaściwy typ

wynik = "5" + 5  # TypeError: can only concatenate str (not "int") to str

# Debug:
print(f"Typ pierwszej wartości: {type('5')}")  # str
print(f"Typ drugiej wartości: {type(5)}")      # int
# Konwertuj:
wynik = "5" + str(5)  # lub int("5") + 5

5. AttributeError – brak atrybutu

lista = [1, 2, 3]
lista.add(4)  # AttributeError: 'list' object has no attribute 'add'

# Debug:
print(f"Typ obiektu: {type(lista)}")
print(f"Dostępne metody: {dir(lista)}")
# Poprawka:
lista.append(4)

Narzędzia pomocnicze

1. traceback – szczegółowe informacje o błędzie

import traceback

try:
    wynik = 10 / 0
except Exception as e:
    print("Wystąpił błąd:")
    traceback.print_exc()
    
    # Lub zapisz do pliku
    with open('error.log', 'w') as f:
        traceback.print_exc(file=f)

2. sys.exc_info() – informacje o wyjątku

import sys

try:
    wynik = 10 / 0
except:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print(f"Typ: {exc_type}")
    print(f"Wartość: {exc_value}")
    print(f"Traceback: {exc_traceback}")

3. inspect – inspekcja obiektów

import inspect

def moja_funkcja(a, b):
    return a + b

# Informacje o funkcji
print(inspect.getsource(moja_funkcja))  # Kod źródłowy
print(inspect.signature(moja_funkcja))  # Sygnatura: (a, b)

4. dis – disassembler

import dis

def dodaj(a, b):
    return a + b

# Zobacz bytecode Pythona
dis.dis(dodaj)

Praktyczne przykłady debugowania

Przykład 1: Błąd logiczny

# Kod ma błąd - znajdź go!
def oblicz_srednia_ocen(oceny):
    suma = 0
    licznik = 0
    
    for ocena in oceny:
        suma += ocena
        licznik += 1
    
    return suma / licznik  # Dzielenie przez zero?

# Test
print(oblicz_srednia_ocen([4, 5, 3]))  # Działa
print(oblicz_srednia_ocen([]))  # ZeroDivisionError!

# Debug z printami
def oblicz_srednia_ocen_debug(oceny):
    print(f"Wejście: {oceny}")
    print(f"Długość: {len(oceny)}")
    
    suma = 0
    licznik = 0
    
    for ocena in oceny:
        suma += ocena
        licznik += 1
        print(f"Suma: {suma}, Licznik: {licznik}")
    
    if licznik == 0:
        print("UWAGA: Dzielenie przez zero!")
        return None
    
    return suma / licznik

# Poprawiona wersja
def oblicz_srednia_ocen_fix(oceny):
    if not oceny:
        return 0  # lub raise ValueError("Lista ocen jest pusta")
    
    return sum(oceny) / len(oceny)

Przykład 2: Debugowanie z PDB

import pdb

def faktoryzacja(n):
    """Zwraca dzielniki liczby n."""
    dzielniki = []
    
    for i in range(1, n + 1):
        pdb.set_trace()  # Zatrzymaj się tutaj
        if n % i == 0:
            dzielniki.append(i)
    
    return dzielniki

print(faktoryzacja(12))

# W PDB:
# p i           # Wypisz i
# p n           # Wypisz n
# p n % i       # Wypisz resztę z dzielenia
# n             # Następna iteracja

Przykład 3: Logging w aplikacji

import logging

# Konfiguracja
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('app.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        logger.info(f"Utworzono konto dla {owner} z saldem {balance}")
    
    def deposit(self, amount):
        if amount <= 0:
            logger.warning(f"Próba wpłaty nieprawidłowej kwoty: {amount}")
            return False
        
        self.balance += amount
        logger.info(f"{self.owner}: Wpłata {amount}, nowe saldo: {self.balance}")
        return True
    
    def withdraw(self, amount):
        if amount > self.balance:
            logger.error(f"{self.owner}: Próba wypłaty {amount}, ale saldo to tylko {self.balance}")
            return False
        
        self.balance -= amount
        logger.info(f"{self.owner}: Wypłata {amount}, nowe saldo: {self.balance}")
        return True

# Użycie
konto = BankAccount("Jan Kowalski", 1000)
konto.deposit(500)
konto.withdraw(2000)  # Błąd - za mało środków
konto.withdraw(200)

Najlepsze praktyki debugowania

1. Czytaj dokumentację

Przed debugowaniem sprawdź dokumentację funkcji/biblioteki.

2. Pisz testy jednostkowe

import unittest

def dodaj(a, b):
    return a + b

class TestDodaj(unittest.TestCase):
    def test_dodatnie(self):
        self.assertEqual(dodaj(2, 3), 5)
    
    def test_ujemne(self):
        self.assertEqual(dodaj(-2, -3), -5)
    
    def test_mieszane(self):
        self.assertEqual(dodaj(-2, 3), 1)

if __name__ == '__main__':
    unittest.main()

Testy pomagają wykrywać bugi wcześnie.

3. Używaj type hints

def dodaj(a: int, b: int) -> int:
    return a + b

# IDE od razu wykryje błąd
# dodaj("a", "b")  # Typ niezgodny!

4. Code review

Poproś kogoś o przejrzenie kodu – świeże oko często widzi błędy.

5. Git bisect – znajdź kiedy pojawił się bug

git bisect start
git bisect bad  # Obecna wersja ma bug
git bisect good abc123  # Commit abc123 nie miał buga
# Git automatycznie znajdzie commit który wprowadził błąd

Podsumowanie

Metody debugowania:

1. Print debugging – proste, szybkie
2. Assertions – sprawdzanie założeń
3. Logging – profesjonalne logowanie
4. PDB/breakpoint() – interaktywny debugger
5. IDE debugger – najpotężniejsze

Techniki:

• Rubber duck debugging
• Dziel i zwyciężaj
• Binary search
• Czytaj traceback od dołu

Narzędzia:

• traceback, inspect, dis
• Testy jednostkowe
• Type hints

Dobre praktyki:

• Debuguj systematycznie
• Dokumentuj znalezione błędy
• Ucz się na błędach
• Pisz testy

Pamiętaj: Debugging to umiejętność – im więcej ćwiczysz, tym lepszy się stajesz!

Artykuł 22. Python – Debugging (Debugowanie) pochodzi z serwisu Kama Kaczmarek.

Dlaczego Generics?

• Wielokrotne użycie kodu
• Bezpieczeństwo typów
• Czytelność kodu
• Lepsze wsparcie IDE (autouzupełnianie)

W Pythonie: Moduł typing (Python 3.5+)

Moduł typing

from typing import List, Dict, Tuple, Optional, Union, Any

# Proste typy
imie: str = "Jan"
wiek: int = 25
cena: float = 19.99
aktywny: bool = True

# Kolekcje
liczby: List[int] = [1, 2, 3, 4]
slownik: Dict[str, int] = {"Jan": 25, "Anna": 30}
para: Tuple[str, int] = ("Jan", 25)

# Optional - może być None
imie_opcjonalne: Optional[str] = None  # To samo co: Union[str, None]

# Union - jeden z typów
identyfikator: Union[int, str] = 123  # Może być int lub str

# Any - dowolny typ
cokolwiek: Any = "może być wszystko"

Funkcje z typami

from typing import List

def suma_liczb(liczby: List[int]) -> int:
    """
    Sumuje listę liczb.
    
    Args:
        liczby: Lista liczb całkowitych
    
    Returns:
        Suma wszystkich liczb
    """
    return sum(liczby)

# Użycie
wynik: int = suma_liczb([1, 2, 3, 4, 5])
print(wynik)  # 15

# IDE podpowie błąd
# suma_liczb(["a", "b"])  # Błąd typu!

TypeVar – zmienne typowe

TypeVar pozwala stworzyć „placeholder” dla typu.

from typing import TypeVar, List

# Stwórz zmienną typową
T = TypeVar('T')

def pierwszy_element(lista: List[T]) -> T:
    """
    Zwraca pierwszy element listy.
    Typ zwracany jest taki sam jak typ elementów.
    """
    return lista[0]

# Użycie
liczby = [1, 2, 3]
wynik1 = pierwszy_element(liczby)  # wynik1: int

teksty = ["a", "b", "c"]
wynik2 = pierwszy_element(teksty)  # wynik2: str

Generic – klasa ogólna

from typing import TypeVar, Generic

T = TypeVar('T')

class Pudelko(Generic[T]):
    """
    Generyczna klasa pudełka - może przechowywać dowolny typ.
    """
    def __init__(self, zawartosc: T):
        self.zawartosc = zawartosc
    
    def pobierz(self) -> T:
        return self.zawartosc
    
    def ustaw(self, nowa_zawartosc: T) -> None:
        self.zawartosc = nowa_zawartosc

# Użycie z int
pudelko_int: Pudelko[int] = Pudelko(42)
liczba = pudelko_int.pobierz()  # liczba: int

# Użycie z str
pudelko_str: Pudelko[str] = Pudelko("Hello")
tekst = pudelko_str.pobierz()  # tekst: str

# IDE ostrzeże o błędzie
# pudelko_int.ustaw("tekst")  # Błąd - oczekiwano int!

Para – generic z dwoma typami

from typing import TypeVar, Generic

T = TypeVar('T')
U = TypeVar('U')

class Para(Generic[T, U]):
    """Generyczna para dwóch wartości."""
    
    def __init__(self, pierwszy: T, drugi: U):
        self.pierwszy = pierwszy
        self.drugi = drugi
    
    def pobierz_pierwszy(self) -> T:
        return self.pierwszy
    
    def pobierz_drugi(self) -> U:
        return self.drugi
    
    def __str__(self) -> str:
        return f"Para({self.pierwszy}, {self.drugi})"

# Użycie
para1: Para[str, int] = Para("Jan", 25)
print(para1)  # Para(Jan, 25)

para2: Para[int, str] = Para(1, "jeden")
print(para2)  # Para(1, jeden)

Stos (Stack) – praktyczny przykład

from typing import TypeVar, Generic, List, Optional

T = TypeVar('T')

class Stos(Generic[T]):
    """
    Generyczny stos (LIFO - Last In First Out).
    """
    def __init__(self):
        self._elementy: List[T] = []
    
    def push(self, element: T) -> None:
        """Dodaj element na szczyt stosu."""
        self._elementy.append(element)
    
    def pop(self) -> Optional[T]:
        """Usuń i zwróć element ze szczytu."""
        if self.jest_pusty():
            return None
        return self._elementy.pop()
    
    def peek(self) -> Optional[T]:
        """Sprawdź szczyt bez usuwania."""
        if self.jest_pusty():
            return None
        return self._elementy[-1]
    
    def jest_pusty(self) -> bool:
        """Czy stos jest pusty?"""
        return len(self._elementy) == 0
    
    def rozmiar(self) -> int:
        """Liczba elementów."""
        return len(self._elementy)
    
    def __str__(self) -> str:
        return f"Stos({self._elementy})"

# Użycie
stos_int: Stos[int] = Stos()
stos_int.push(1)
stos_int.push(2)
stos_int.push(3)
print(stos_int)  # Stos([1, 2, 3])
print(stos_int.pop())  # 3

stos_str: Stos[str] = Stos()
stos_str.push("Python")
stos_str.push("Java")
print(stos_str)  # Stos(['Python', 'Java'])

Kolejka (Queue) – przykład

from typing import TypeVar, Generic, List, Optional

T = TypeVar('T')

class Kolejka(Generic[T]):
    """
    Generyczna kolejka (FIFO - First In First Out).
    """
    def __init__(self):
        self._elementy: List[T] = []
    
    def enqueue(self, element: T) -> None:
        """Dodaj element na koniec kolejki."""
        self._elementy.append(element)
    
    def dequeue(self) -> Optional[T]:
        """Usuń i zwróć element z początku."""
        if self.jest_pusta():
            return None
        return self._elementy.pop(0)
    
    def jest_pusta(self) -> bool:
        return len(self._elementy) == 0
    
    def rozmiar(self) -> int:
        return len(self._elementy)
    
    def __str__(self) -> str:
        return f"Kolejka({self._elementy})"

# Użycie
kolejka: Kolejka[str] = Kolejka()
kolejka.enqueue("Pierwszy")
kolejka.enqueue("Drugi")
kolejka.enqueue("Trzeci")
print(kolejka)  # Kolejka(['Pierwszy', 'Drugi', 'Trzeci'])
print(kolejka.dequeue())  # Pierwszy

Linked List – lista powiązana

from typing import TypeVar, Generic, Optional

T = TypeVar('T')

class Wezel(Generic[T]):
    """Węzeł listy powiązanej."""
    def __init__(self, dane: T):
        self.dane = dane
        self.nastepny: Optional[Wezel[T]] = None

class ListaPowiazana(Generic[T]):
    """Generyczna lista powiązana."""
    
    def __init__(self):
        self.glowa: Optional[Wezel[T]] = None
    
    def dodaj_na_poczatek(self, dane: T) -> None:
        """Dodaj element na początek."""
        nowy = Wezel(dane)
        nowy.nastepny = self.glowa
        self.glowa = nowy
    
    def dodaj_na_koniec(self, dane: T) -> None:
        """Dodaj element na koniec."""
        nowy = Wezel(dane)
        
        if self.glowa is None:
            self.glowa = nowy
            return
        
        aktualny = self.glowa
        while aktualny.nastepny is not None:
            aktualny = aktualny.nastepny
        aktualny.nastepny = nowy
    
    def wyswietl(self) -> None:
        """Wyświetl wszystkie elementy."""
        aktualny = self.glowa
        elementy = []
        while aktualny is not None:
            elementy.append(str(aktualny.dane))
            aktualny = aktualny.nastepny
        print(" -> ".join(elementy))

# Użycie
lista: ListaPowiazana[int] = ListaPowiazana()
lista.dodaj_na_koniec(1)
lista.dodaj_na_koniec(2)
lista.dodaj_na_koniec(3)
lista.wyswietl()  # 1 -> 2 -> 3

Ograniczenia typów (Bounded TypeVar)

from typing import TypeVar

# Ograniczenie do typów numerycznych
Liczba = TypeVar('Liczba', int, float)

def suma(a: Liczba, b: Liczba) -> Liczba:
    """Sumuje dwie liczby (int lub float)."""
    return a + b

print(suma(5, 3))      # 8 (int)
print(suma(5.5, 3.2))  # 8.7 (float)
# suma("a", "b")  # Błąd - string nie jest dozwolony!

Protocol – duck typing z typami

from typing import Protocol

class Drawable(Protocol):
    """Protokół dla obiektów które można narysować."""
    def draw(self) -> str:
        ...

class Circle:
    def draw(self) -> str:
        return "Rysujęokrąg"

class Square:
    def draw(self) -> str:
        return "Rysuję kwadrat"

def render(shape: Drawable) -> None:
    """Rysuje kształt."""
    print(shape.draw())

# Użycie - Circle i Square automatycznie spełniają Protocol
circle = Circle()
square = Square()

render(circle)  # Rysuję okrąg
render(square)  # Rysuję kwadrat

Callable – typ funkcji

from typing import Callable

def wykonaj_operacje(a: int, b: int, operacja: Callable[[int, int], int]) -> int:
    """
    Wykonuje operację na dwóch liczbach.
    
    operacja: funkcja przyjmująca dwa int i zwracająca int
    """
    return operacja(a, b)

def dodaj(x: int, y: int) -> int:
    return x + y

def pomnoz(x: int, y: int) -> int:
    return x * y

print(wykonaj_operacje(5, 3, dodaj))    # 8
print(wykonaj_operacje(5, 3, pomnoz))   # 15

Praktyczny przykład – Repository

from typing import TypeVar, Generic, List, Optional, Dict

T = TypeVar('T')

class Repository(Generic[T]):
    """
    Generyczne repozytorium do przechowywania obiektów.
    """
    def __init__(self):
        self._dane: Dict[int, T] = {}
        self._next_id: int = 1
    
    def dodaj(self, obiekt: T) -> int:
        """Dodaje obiekt i zwraca jego ID."""
        id_obiektu = self._next_id
        self._dane[id_obiektu] = obiekt
        self._next_id += 1
        return id_obiektu
    
    def pobierz(self, id_obiektu: int) -> Optional[T]:
        """Pobiera obiekt po ID."""
        return self._dane.get(id_obiektu)
    
    def wszystkie(self) -> List[T]:
        """Zwraca wszystkie obiekty."""
        return list(self._dane.values())
    
    def usun(self, id_obiektu: int) -> bool:
        """Usuwa obiekt po ID."""
        if id_obiektu in self._dane:
            del self._dane[id_obiektu]
            return True
        return False

# Użycie z różnymi typami
class Uzytkownik:
    def __init__(self, imie: str):
        self.imie = imie
    
    def __str__(self):
        return f"Uzytkownik({self.imie})"

repo_uzytkownikow: Repository[Uzytkownik] = Repository()
id1 = repo_uzytkownikow.dodaj(Uzytkownik("Jan"))
id2 = repo_uzytkownikow.dodaj(Uzytkownik("Anna"))

print(repo_uzytkownikow.pobierz(id1))  # Uzytkownik(Jan)
print(repo_uzytkownikow.wszystkie())   # [Uzytkownik(Jan), Uzytkownik(Anna)]

Podsumowanie

Typing:

• List[T], Dict[K, V], Tuple[T, ...]
• Optional[T] = Union[T, None]
• Union[T, U] – jeden z typów
• Any – dowolny typ

Generics:

• TypeVar('T') – zmienna typowa
• Generic[T] – klasa ogólna
• Wielokrotne użycie kodu
• Bezpieczeństwo typów

Przykłady:

• Pudełko, Para
• Stos, Kolejka
• Lista powiązana
• Repository

Korzyści:

• IDE podpowiada typy
• Wykrywanie błędów przed uruchomieniem
• Lepszaczytelność kodu
• Dokumentacja w kodzie

Artykuł 21. Python – Szablony (wzorce) klas – Generics pochodzi z serwisu Kama Kaczmarek.

Dlaczego algorytmy?

• Efektywność – szybsze przetwarzanie danych
• Optymalizacja – mniej zasobów (pamięć, czas)
• Zrozumienie podstaw informatyki
• Rozmowy kwalifikacyjne

W tej lekcji:

• Algorytmy sortowania
• Algorytmy przeszukiwania
• Złożoność obliczeniowa (Big O)

Złożoność obliczeniowa (Big O Notation)

Złożoność obliczeniowa mierzy jak szybko rośnie czas wykonania algorytmu wraz ze wzrostem rozmiaru danych.

Notacja Big O

O(n) – „Big O of n” – opisuje najgorszy przypadek.

Najczęstsze złożoności (od najlepszej do najgorszej):

Wizualizacja wzrostu

n = 10:
O(1)      = 1
O(log n)  = 3
O(n)      = 10
O(n log n)= 30
O(n²)     = 100
O(2^n)    = 1024

n = 1000:
O(1)      = 1
O(log n)  = 10
O(n)      = 1000
O(n log n)= 10000
O(n²)     = 1000000
O(2^n)    = ???  (za dużo!)

Przykłady złożoności

# O(1) - Stała
def get_first(lista):
    return lista[0]  # Zawsze 1 operacja

# O(n) - Liniowa
def contains(lista, element):
    for item in lista:  # n operacji
        if item == element:
            return True
    return False

# O(n²) - Kwadratowa
def print_pairs(lista):
    for i in lista:       # n razy
        for j in lista:   # n razy
            print(i, j)   # n * n = n²

Algorytmy sortowania

Sortowanie to uporządkowanie elementów według określonego kryterium.

1. Bubble Sort (Sortowanie bąbelkowe)

Idea: Porównuj sąsiednie elementy i zamieniaj je miejscami jeśli są w złej kolejności. Powtarzaj aż lista będzie posortowana.

Złożoność:

• Czasowa: O(n²) – najgorszy i średni przypadek
• Czasowa: O(n) – najlepszy przypadek (lista już posortowana)
• Pamięciowa: O(1) – sortowanie in-place

Kiedy używać:

• Małe zbiory danych
• Dane prawie posortowane
• Cel edukacyjny

def bubble_sort(lista):
    """
    Sortowanie bąbelkowe.
    Porównuje sąsiednie elementy i zamienia je miejscami.
    """
    n = len(lista)
    
    # Zewnętrzna pętla - liczba przejść
    for i in range(n):
        # Flaga - czy było zamiana
        zamiana = False
        
        # Wewnętrzna pętla - porównania
        for j in range(0, n - i - 1):
            # Jeśli element jest większy od następnego
            if lista[j] > lista[j + 1]:
                # Zamień miejscami
                lista[j], lista[j + 1] = lista[j + 1], lista[j]
                zamiana = True
        
        # Jeśli nie było zamiany, lista jest posortowana
        if not zamiana:
            break
    
    return lista

# Test
dane = [64, 34, 25, 12, 22, 11, 90]
print("Przed:", dane)
bubble_sort(dane)
print("Po:", dane)
# Po: [11, 12, 22, 25, 34, 64, 90]

Wizualizacja (pierwsze przejście):

[64, 34, 25, 12, 22, 11, 90]
 64>34 → zamień
[34, 64, 25, 12, 22, 11, 90]
    64>25 → zamień
[34, 25, 64, 12, 22, 11, 90]
       64>12 → zamień
[34, 25, 12, 64, 22, 11, 90]
          64>22 → zamień
[34, 25, 12, 22, 64, 11, 90]
             64>11 → zamień
[34, 25, 12, 22, 11, 64, 90]
                64<90 → OK

2. Selection Sort (Sortowanie przez wybieranie)

Idea: Znajdź najmniejszy element i umieść go na początku. Powtarzaj dla pozostałej części.

Złożoność:

• Czasowa: O(n²) – zawsze
• Pamięciowa: O(1)

def selection_sort(lista):
    """
    Sortowanie przez wybieranie.
    Znajduje minimum i umieszcza na początku.
    """
    n = len(lista)
    
    # Przejdź przez wszystkie elementy
    for i in range(n):
        # Znajdź indeks najmniejszego elementu
        min_idx = i
        for j in range(i + 1, n):
            if lista[j] < lista[min_idx]:
                min_idx = j
        
        # Zamień znaleziony minimum z pierwszym elementem
        lista[i], lista[min_idx] = lista[min_idx], lista[i]
    
    return lista

# Test
dane = [64, 25, 12, 22, 11]
print("Przed:", dane)
selection_sort(dane)
print("Po:", dane)
# Po: [11, 12, 22, 25, 64]

Wizualizacja:

[64, 25, 12, 22, 11]
 ^               ^  min=11, zamień
[11, 25, 12, 22, 64]
     ^   ^          min=12, zamień
[11, 12, 25, 22, 64]
         ^   ^      min=22, zamień
[11, 12, 22, 25, 64]
             ^  ^   min=25, już OK
[11, 12, 22, 25, 64] ✓

3. Insertion Sort (Sortowanie przez wstawianie)

Idea: Bierz kolejne elementy i wstawiaj je we właściwe miejsce w już posortowanej części.

Złożoność:

• Czasowa: O(n²) – najgorszy przypadek
• Czasowa: O(n) – najlepszy przypadek (lista posortowana)
• Pamięciowa: O(1)

Kiedy używać:

• Małe zbiory danych
• Dane prawie posortowane
• Sortowanie online (elementy przychodzą po kolei)

def insertion_sort(lista):
    """
    Sortowanie przez wstawianie.
    Jak sortowanie kart w ręce.
    """
    n = len(lista)
    
    # Zacznij od drugiego elementu
    for i in range(1, n):
        # Element do wstawienia
        key = lista[i]
        j = i - 1
        
        # Przesuń elementy większe od key o jedno miejsce w prawo
        while j >= 0 and lista[j] > key:
            lista[j + 1] = lista[j]
            j -= 1
        
        # Wstaw key na właściwe miejsce
        lista[j + 1] = key
    
    return lista

# Test
dane = [12, 11, 13, 5, 6]
print("Przed:", dane)
insertion_sort(dane)
print("Po:", dane)
# Po: [5, 6, 11, 12, 13]

Analogia: Jak sortowanie kart w ręce – bierzesz kolejną kartę i wstawiasz ją we właściwe miejsce.

4. Merge Sort (Sortowanie przez scalanie)

Idea: Dziel listę na połowy, sortuj rekurencyjnie, następnie scalaj posortowane połowy.

Złożoność:

• Czasowa: O(n log n) – zawsze!
• Pamięciowa: O(n) – wymaga dodatkowej pamięci

Kiedy używać:

• Duże zbiory danych
• Stabilne sortowanie (zachowuje kolejność równych elementów)
• Gwarantowana wydajność O(n log n)

def merge_sort(lista):
    """
    Sortowanie przez scalanie (rekurencyjne).
    Dziel i zwyciężaj.
    """
    # Warunek bazowy - lista o długości 1 jest posortowana
    if len(lista) <= 1:
        return lista
    
    # Podziel na dwie połowy
    srodek = len(lista) // 2
    lewa = lista[:srodek]
    prawa = lista[srodek:]
    
    # Rekurencyjnie posortuj połowy
    lewa = merge_sort(lewa)
    prawa = merge_sort(prawa)
    
    # Scal posortowane połowy
    return merge(lewa, prawa)

def merge(lewa, prawa):
    """Scala dwie posortowane listy."""
    wynik = []
    i = j = 0
    
    # Porównuj elementy z obu list
    while i < len(lewa) and j < len(prawa):
        if lewa[i] <= prawa[j]:
            wynik.append(lewa[i])
            i += 1
        else:
            wynik.append(prawa[j])
            j += 1
    
    # Dodaj pozostałe elementy
    wynik.extend(lewa[i:])
    wynik.extend(prawa[j:])
    
    return wynik

# Test
dane = [38, 27, 43, 3, 9, 82, 10]
print("Przed:", dane)
posortowane = merge_sort(dane)
print("Po:", posortowane)
# Po: [3, 9, 10, 27, 38, 43, 82]

Wizualizacja:

[38, 27, 43, 3, 9, 82, 10]
       ↓ dziel ↓
[38, 27, 43]  [3, 9, 82, 10]
  ↓ dziel ↓    ↓ dziel ↓
[38] [27, 43]  [3, 9] [82, 10]
       ↓          ↓       ↓
    [27, 43]    [3, 9]  [10, 82]
        ↓ scal ↓          ↓
    [27, 38, 43]    [3, 9, 10, 82]
           ↓ scal ↓
    [3, 9, 10, 27, 38, 43, 82]

5. Quick Sort (Sortowanie szybkie)

Idea: Wybierz element (pivot), podziel na mniejsze i większe, sortuj rekurencyjnie.

Złożoność:

• Czasowa: O(n log n) – średni przypadek
• Czasowa: O(n²) – najgorszy (rzadko)
• Pamięciowa: O(log n) – rekursja

Kiedy używać:

• Duże zbiory danych
• Najszybszy w praktyce
• Sortowanie in-place

def quick_sort(lista):
    """
    Sortowanie szybkie.
    Wybiera pivot i dzieli na mniejsze/większe.
    """
    # Warunek bazowy
    if len(lista) <= 1:
        return lista
    
    # Wybierz pivot (środkowy element)
    pivot = lista[len(lista) // 2]
    
    # Podziel na trzy grupy
    mniejsze = [x for x in lista if x < pivot]
    rowne = [x for x in lista if x == pivot]
    wieksze = [x for x in lista if x > pivot]
    
    # Rekurencyjnie posortuj i połącz
    return quick_sort(mniejsze) + rowne + quick_sort(wieksze)

# Test
dane = [10, 7, 8, 9, 1, 5]
print("Przed:", dane)
posortowane = quick_sort(dane)
print("Po:", posortowane)
# Po: [1, 5, 7, 8, 9, 10]

Wizualizacja:

[10, 7, 8, 9, 1, 5]  pivot=8
      ↓
mniejsze: [7, 1, 5]
rowne: [8]
wieksze: [10, 9]
      ↓ sortuj rekurencyjnie
[1, 5, 7] + [8] + [9, 10]
      ↓
[1, 5, 7, 8, 9, 10]

Porównanie algorytmów sortowania

Stabilny = zachowuje względną kolejność równych elementów.

Algorytmy przeszukiwania

1. Przeszukiwanie liniowe (Linear Search)

Idea: Sprawdź każdy element po kolei.

Złożoność:

• Czasowa: O(n)
• Pamięciowa: O(1)

Kiedy używać:

• Mała lista
• Lista nieposortowana
• Jednorazowe wyszukiwanie

def linear_search(lista, szukany):
    """
    Przeszukiwanie liniowe.
    Sprawdza każdy element po kolei.
    """
    for i in range(len(lista)):
        if lista[i] == szukany:
            return i  # Zwróć indeks
    return -1  # Nie znaleziono

# Test
dane = [10, 23, 45, 70, 11, 15]
wynik = linear_search(dane, 70)
print(f"Element 70 znajduje się na indeksie: {wynik}")  # 3

wynik = linear_search(dane, 100)
print(f"Element 100 znajduje się na indeksie: {wynik}")  # -1

2. Przeszukiwanie binarne (Binary Search)

Idea: W posortowanej liście sprawdź środek. Jeśli szukany jest mniejszy, szukaj w lewej połowie, jeśli większy – w prawej.

Złożoność:

• Czasowa: O(log n)
• Pamięciowa: O(1) – iteracyjna, O(log n) – rekurencyjna

Wymaganie: Lista MUSI być posortowana!

Kiedy używać:

• Duża, posortowana lista
• Wielokrotne wyszukiwania

def binary_search(lista, szukany):
    """
    Przeszukiwanie binarne (iteracyjne).
    Wymaga posortowanej listy!
    """
    lewy = 0
    prawy = len(lista) - 1
    
    while lewy <= prawy:
        # Znajdź środek
        srodek = (lewy + prawy) // 2
        
        # Sprawdź środkowy element
        if lista[srodek] == szukany:
            return srodek
        elif lista[srodek] < szukany:
            # Szukaj w prawej połowie
            lewy = srodek + 1
        else:
            # Szukaj w lewej połowie
            prawy = srodek - 1
    
    return -1  # Nie znaleziono

# Test
dane = [11, 15, 23, 45, 70]  # MUSI BYĆ POSORTOWANA!
wynik = binary_search(dane, 45)
print(f"Element 45 znajduje się na indeksie: {wynik}")  # 3

Wizualizacja:

Szukamy: 45
[11, 15, 23, 45, 70]
 L       M       P    środek=23, 45>23 → szukaj w prawo

         [45, 70]
          L   P       środek=45, znaleziono! ✓

Przeszukiwanie binarne – rekurencyjne

def binary_search_recursive(lista, szukany, lewy=0, prawy=None):
    """Przeszukiwanie binarne (rekurencyjne)."""
    if prawy is None:
        prawy = len(lista) - 1
    
    # Warunek bazowy
    if lewy > prawy:
        return -1
    
    # Znajdź środek
    srodek = (lewy + prawy) // 2
    
    if lista[srodek] == szukany:
        return srodek
    elif lista[srodek] < szukany:
        return binary_search_recursive(lista, szukany, srodek + 1, prawy)
    else:
        return binary_search_recursive(lista, szukany, lewy, srodek - 1)

# Test
dane = [11, 15, 23, 45, 70]
wynik = binary_search_recursive(dane, 70)
print(f"Element 70 znajduje się na indeksie: {wynik}")  # 4

Porównanie przeszukiwania

Przykład: Dla n=1,000,000

• Linear: max 1,000,000 porównań
• Binary: max ~20 porównań!

Praktyczne przykłady

Przykład 1: Benchmark sortowania

import time
import random

def benchmark_sort(funkcja_sort, dane, nazwa):
    """Mierzy czas sortowania."""
    kopia = dane.copy()
    start = time.time()
    funkcja_sort(kopia)
    koniec = time.time()
    print(f"{nazwa}: {koniec - start:.4f}s")

# Wygeneruj dane
dane = [random.randint(1, 1000) for _ in range(5000)]

print("Benchmark sortowania (5000 elementów):")
benchmark_sort(bubble_sort, dane, "Bubble Sort")
benchmark_sort(selection_sort, dane, "Selection Sort")
benchmark_sort(insertion_sort, dane, "Insertion Sort")
benchmark_sort(merge_sort, dane, "Merge Sort")
benchmark_sort(quick_sort, dane, "Quick Sort")
benchmark_sort(sorted, dane, "Python sorted()")

Przykład 2: Wyszukiwanie w bazie danych

class BazaDanych:
    def __init__(self):
        self.dane = []
    
    def dodaj(self, rekord):
        self.dane.append(rekord)
        # Sortuj po dodaniu (dla binary search)
        self.dane.sort(key=lambda x: x['id'])
    
    def znajdz_linear(self, id):
        """Wyszukiwanie liniowe."""
        for rekord in self.dane:
            if rekord['id'] == id:
                return rekord
        return None
    
    def znajdz_binary(self, id):
        """Wyszukiwanie binarne."""
        lewy, prawy = 0, len(self.dane) - 1
        
        while lewy <= prawy:
            srodek = (lewy + prawy) // 2
            if self.dane[srodek]['id'] == id:
                return self.dane[srodek]
            elif self.dane[srodek]['id'] < id:
                lewy = srodek + 1
            else:
                prawy = srodek - 1
        
        return None

# Test
db = BazaDanych()
db.dodaj({'id': 1, 'imie': 'Jan'})
db.dodaj({'id': 5, 'imie': 'Anna'})
db.dodaj({'id': 3, 'imie': 'Piotr'})

print(db.znajdz_binary(5))  # {'id': 5, 'imie': 'Anna'}

Wbudowane funkcje Pythona

Python ma wbudowane, bardzo zoptymalizowane funkcje sortowania.

# sorted() - zwraca nową posortowaną listę
dane = [3, 1, 4, 1, 5, 9, 2, 6]
posortowane = sorted(dane)
print(posortowane)  # [1, 1, 2, 3, 4, 5, 6, 9]

# sort() - sortuje in-place
dane = [3, 1, 4, 1, 5, 9, 2, 6]
dane.sort()
print(dane)  # [1, 1, 2, 3, 4, 5, 6, 9]

# Malejąco
dane.sort(reverse=True)
print(dane)  # [9, 6, 5, 4, 3, 2, 1, 1]

# Sortowanie z kluczem
osoby = [{'imie': 'Jan', 'wiek': 25}, 
         {'imie': 'Anna', 'wiek': 30}]
osoby.sort(key=lambda x: x['wiek'])
print(osoby)

Algorytm: Python używa Timsort (hybrydowy Merge Sort + Insertion Sort) – O(n log n).

Podsumowanie

Sortowanie:

• Bubble Sort – O(n²), prosty, edukacyjny
• Selection Sort – O(n²), prosty
• Insertion Sort – O(n²), dobry dla małych/prawie posortowanych
• Merge Sort – O(n log n), stabilny, wymaga pamięci
• Quick Sort – O(n log n) średnio, najszybszy praktycznie
• Python sort() – Timsort, O(n log n), używaj tego!

Przeszukiwanie:

• Linear Search – O(n), dla nieposortowanych
• Binary Search – O(log n), dla posortowanych

Złożoność:

• O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2^n)

Zasada: Dla małych danych (< 1000) różnice są niewielkie. Dla dużych – algorytm ma ogromne znaczenie!

Artykuł 20. Python – Algorytmy: Sortowanie i Przeszukiwanie pochodzi z serwisu Kama Kaczmarek.

Wizualizacja danych to kluczowy element analizy – pozwala szybko zrozumieć dane i wyciągnąć wnioski.

Biblioteki:

• Matplotlib – podstawowa, najpopularniejsza
• Seaborn – ładniejsze wykresy, bazuje na Matplotlib
• Plotly – interaktywne wykresy

Matplotlib – podstawy

Instalacja

pip install matplotlib

Pierwszy wykres – linia

import matplotlib.pyplot as plt

# Dane
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Stwórz wykres
plt.plot(x, y)

# Opisy
plt.title('Mój pierwszy wykres')
plt.xlabel('Oś X')
plt.ylabel('Oś Y')

# Pokaż
plt.show()

Personalizacja linii

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Styl linii
plt.plot(x, y, 
         color='red',          # Kolor
         linewidth=2,          # Grubość
         linestyle='--',       # Styl: '-', '--', '-.', ':'
         marker='o',           # Markery: 'o', 's', '^', '*'
         markersize=8,         # Rozmiar markerów
         label='Dane 1')       # Etykieta

plt.title('Wykres z personalizacją')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()  # Pokaż legendę
plt.grid(True)  # Siatka
plt.show()

Wiele linii na jednym wykresie

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y1 = [2, 4, 6, 8, 10]
y2 = [1, 3, 5, 7, 9]
y3 = [3, 5, 4, 6, 8]

plt.plot(x, y1, label='Linia 1', marker='o')
plt.plot(x, y2, label='Linia 2', marker='s')
plt.plot(x, y3, label='Linia 3', marker='^')

plt.title('Wiele linii')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.grid(True)
plt.show()

Typy wykresów

Wykres punktowy (scatter)

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5, 6]
y = [2, 4, 5, 7, 8, 10]

plt.scatter(x, y, 
            s=100,           # Rozmiar punktów
            c='red',         # Kolor
            alpha=0.6,       # Przezroczystość
            edgecolors='black')  # Obramowanie

plt.title('Wykres punktowy')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

Wykres słupkowy (bar)

import matplotlib.pyplot as plt

kategorie = ['A', 'B', 'C', 'D', 'E']
wartosci = [23, 45, 56, 78, 32]

plt.bar(kategorie, wartosci, 
        color='skyblue',
        edgecolor='black',
        width=0.6)

plt.title('Wykres słupkowy')
plt.xlabel('Kategoria')
plt.ylabel('Wartość')
plt.show()

Wykres słupkowy poziomy

import matplotlib.pyplot as plt

kategorie = ['Produkt A', 'Produkt B', 'Produkt C']
wartosci = [150, 230, 180]

plt.barh(kategorie, wartosci, color='lightgreen')
plt.title('Sprzedaż produktów')
plt.xlabel('Liczba sprzedanych')
plt.show()

Histogram

import matplotlib.pyplot as plt
import numpy as np

# Dane - rozkład normalny
dane = np.random.randn(1000)

plt.hist(dane, 
         bins=30,           # Liczba słupków
         color='purple',
         alpha=0.7,
         edgecolor='black')

plt.title('Histogram')
plt.xlabel('Wartość')
plt.ylabel('Częstość')
plt.show()

Wykres kołowy (pie)

import matplotlib.pyplot as plt

kategorie = ['Python', 'Java', 'JavaScript', 'C++']
udzialy = [40, 25, 20, 15]

plt.pie(udzialy, 
        labels=kategorie,
        autopct='%1.1f%%',  # Pokaż procenty
        startangle=90,       # Kąt początkowy
        colors=['#ff9999', '#66b3ff', '#99ff99', '#ffcc99'])

plt.title('Popularne języki programowania')
plt.show()

Wyciągnięty kawałek (explode)

import matplotlib.pyplot as plt

kategorie = ['Python', 'Java', 'JavaScript', 'C++']
udzialy = [40, 25, 20, 15]
explode = [0.1, 0, 0, 0]  # Wyciągnij pierwszy

plt.pie(udzialy, 
        labels=kategorie,
        autopct='%1.1f%%',
        explode=explode,
        shadow=True)

plt.title('Języki programowania')
plt.show()

Wykres pudełkowy (box plot)

import matplotlib.pyplot as plt
import numpy as np

# Dane dla różnych grup
dane1 = np.random.normal(100, 10, 200)
dane2 = np.random.normal(90, 20, 200)
dane3 = np.random.normal(80, 5, 200)

dane = [dane1, dane2, dane3]

plt.boxplot(dane, labels=['Grupa A', 'Grupa B', 'Grupa C'])
plt.title('Box Plot')
plt.ylabel('Wartości')
plt.show()

Wiele wykresów (subplots)

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)

# Stwórz siatkę 2x2
fig, axes = plt.subplots(2, 2, figsize=(10, 8))

# Wykres 1
axes[0, 0].plot(x, np.sin(x))
axes[0, 0].set_title('sin(x)')

# Wykres 2
axes[0, 1].plot(x, np.cos(x), 'r')
axes[0, 1].set_title('cos(x)')

# Wykres 3
axes[1, 0].plot(x, x**2, 'g')
axes[1, 0].set_title('x²')

# Wykres 4
axes[1, 1].plot(x, np.exp(x/10), 'purple')
axes[1, 1].set_title('e^(x/10)')

plt.tight_layout()  # Automatyczne dopasowanie
plt.show()

Zapisywanie wykresów

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

plt.plot(x, y)
plt.title('Mój wykres')

# Zapisz do pliku
plt.savefig('wykres.png', dpi=300, bbox_inches='tight')
# plt.savefig('wykres.pdf')  # PDF
# plt.savefig('wykres.svg')  # SVG

print("Wykres zapisany!")

Pandas + Matplotlib

Pandas ma wbudowaną integrację z Matplotlib.

import pandas as pd
import matplotlib.pyplot as plt

# DataFrame
df = pd.DataFrame({
    'Miesiąc': ['Sty', 'Lut', 'Mar', 'Kwi', 'Maj'],
    'Sprzedaż': [120, 150, 180, 160, 200]
})

# Wykres bezpośrednio z DataFrame
df.plot(x='Miesiąc', y='Sprzedaż', kind='bar', color='skyblue')
plt.title('Sprzedaż miesięczna')
plt.ylabel('Sprzedaż')
plt.show()

# Inne typy: 'line', 'bar', 'barh', 'hist', 'box', 'scatter', 'pie'

Seaborn – piękniejsze wykresy

Instalacja

pip install seaborn

Podstawy Seaborn

import seaborn as sns
import matplotlib.pyplot as plt

# Ustaw styl
sns.set_style('darkgrid')  # 'darkgrid', 'whitegrid', 'dark', 'white', 'ticks'

# Dane
tips = sns.load_dataset('tips')  # Przykładowy zbiór danych

# Wykres punktowy z linią trendu
sns.scatterplot(data=tips, x='total_bill', y='tip')
plt.title('Rachunek vs Napiwek')
plt.show()

Wykres z regresją liniową

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset('tips')

# Scatter plot + linia trendu
sns.regplot(data=tips, x='total_bill', y='tip')
plt.title('Rachunek vs Napiwek (z trendem)')
plt.show()

Wykres skrzypcowy (violin)

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset('tips')

sns.violinplot(data=tips, x='day', y='total_bill')
plt.title('Rachunki według dni tygodnia')
plt.show()

Heatmapa (korelacja)

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# Dane
df = pd.DataFrame({
    'A': [1, 2, 3, 4, 5],
    'B': [2, 4, 6, 8, 10],
    'C': [5, 4, 3, 2, 1]
})

# Macierz korelacji
korelacja = df.corr()

# Heatmapa
sns.heatmap(korelacja, 
            annot=True,      # Pokaż wartości
            cmap='coolwarm', # Paleta kolorów
            center=0)        # Wyśrodkuj na 0

plt.title('Macierz korelacji')
plt.show()

Pair plot

import seaborn as sns
import matplotlib.pyplot as plt

# Załaduj dane
iris = sns.load_dataset('iris')

# Wykres wszystkich par zmiennych
sns.pairplot(iris, hue='species')
plt.show()

Praktyczne przykłady

Przykład 1: Analiza sprzedaży

import pandas as pd
import matplotlib.pyplot as plt

# Dane sprzedażowe
sprzedaz = pd.DataFrame({
    'Miesiąc': ['Sty', 'Lut', 'Mar', 'Kwi', 'Maj', 'Cze'],
    'Sprzedaż': [12000, 15000, 13000, 18000, 22000, 25000],
    'Cel': [15000, 15000, 15000, 20000, 20000, 20000]
})

# Wykres
plt.figure(figsize=(10, 6))
plt.plot(sprzedaz['Miesiąc'], sprzedaz['Sprzedaż'], 
         marker='o', linewidth=2, label='Rzeczywista')
plt.plot(sprzedaz['Miesiąc'], sprzedaz['Cel'], 
         marker='s', linewidth=2, linestyle='--', label='Cel')

plt.title('Sprzedaż vs Cel - 2024', fontsize=16)
plt.xlabel('Miesiąc')
plt.ylabel('Sprzedaż (PLN)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Przykład 2: Porównanie produktów

import matplotlib.pyplot as plt

produkty = ['Laptop', 'Telefon', 'Tablet', 'Monitor', 'Klawiatura']
sprzedaz_q1 = [45, 78, 32, 56, 89]
sprzedaz_q2 = [52, 85, 38, 61, 95]

x = range(len(produkty))
width = 0.35

plt.figure(figsize=(10, 6))
plt.bar([i - width/2 for i in x], sprzedaz_q1, width, label='Q1', color='skyblue')
plt.bar([i + width/2 for i in x], sprzedaz_q2, width, label='Q2', color='lightgreen')

plt.title('Sprzedaż produktów - Q1 vs Q2')
plt.xlabel('Produkt')
plt.ylabel('Liczba sprzedanych')
plt.xticks(x, produkty)
plt.legend()
plt.grid(axis='y', alpha=0.3)
plt.tight_layout()
plt.show()

Przykład 3: Rozkład wieku

import matplotlib.pyplot as plt
import numpy as np

# Symulacja danych
wiek = np.random.normal(35, 10, 1000)  # Średnia 35, odchylenie 10

plt.figure(figsize=(10, 6))
plt.hist(wiek, bins=30, color='coral', edgecolor='black', alpha=0.7)
plt.axvline(wiek.mean(), color='red', linestyle='--', linewidth=2, label=f'Średnia: {wiek.mean():.1f}')

plt.title('Rozkład wieku pracowników')
plt.xlabel('Wiek')
plt.ylabel('Liczba osób')
plt.legend()
plt.grid(axis='y', alpha=0.3)
plt.show()

Przykład 4: Dashboard z wieloma wykresami

import matplotlib.pyplot as plt
import pandas as pd

# Dane
df = pd.DataFrame({
    'Miesiąc': ['Sty', 'Lut', 'Mar', 'Kwi'],
    'Przychód': [12000, 15000, 13000, 18000],
    'Koszty': [8000, 9000, 8500, 11000],
    'Klienci': [120, 145, 130, 170]
})

df['Zysk'] = df['Przychód'] - df['Koszty']

# Stwórz dashboard
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
fig.suptitle('Dashboard Sprzedażowy - Q1 2024', fontsize=16)

# Wykres 1: Przychód i koszty
axes[0, 0].plot(df['Miesiąc'], df['Przychód'], marker='o', label='Przychód')
axes[0, 0].plot(df['Miesiąc'], df['Koszty'], marker='s', label='Koszty')
axes[0, 0].set_title('Przychód i Koszty')
axes[0, 0].set_ylabel('PLN')
axes[0, 0].legend()
axes[0, 0].grid(True, alpha=0.3)

# Wykres 2: Zysk
axes[0, 1].bar(df['Miesiąc'], df['Zysk'], color='green', alpha=0.7)
axes[0, 1].set_title('Zysk')
axes[0, 1].set_ylabel('PLN')
axes[0, 1].grid(axis='y', alpha=0.3)

# Wykres 3: Liczba klientów
axes[1, 0].plot(df['Miesiąc'], df['Klienci'], marker='D', color='purple', linewidth=2)
axes[1, 0].set_title('Liczba klientów')
axes[1, 0].set_ylabel('Klienci')
axes[1, 0].grid(True, alpha=0.3)

# Wykres 4: Udział przychodów
axes[1, 1].pie(df['Przychód'], labels=df['Miesiąc'], autopct='%1.1f%%', startangle=90)
axes[1, 1].set_title('Udział przychodów')

plt.tight_layout()
plt.show()

Podsumowanie

Matplotlib:

• plt.plot() – wykres liniowy
• plt.scatter() – wykres punktowy
• plt.bar() / plt.barh() – słupkowy
• plt.hist() – histogram
• plt.pie() – kołowy
• plt.boxplot() – pudełkowy
• plt.subplots() – wiele wykresów

Personalizacja:

• color, linewidth, linestyle, marker
• title(), xlabel(), ylabel()
• legend(), grid()
• savefig() – zapis do pliku

Seaborn:

• Ładniejsze style
• scatterplot(), regplot(), violinplot()
• heatmap() – korelacja
• pairplot() – wszystkie pary

Integracja z Pandas:

• df.plot() – bezpośrednie wykresy z DataFrame

Artykuł 19. Python – Wykresy (Matplotlib i Seaborn) pochodzi z serwisu Kama Kaczmarek.

Format CSV

CSV (Comma-Separated Values) to prosty format przechowywania danych tabelarycznych w pliku tekstowym.

Imie,Nazwisko,Wiek,Miasto
Jan,Kowalski,25,Warszawa
Anna,Nowak,30,Kraków
Piotr,Wiśniewski,28,Gdańsk

Struktura:

• Pierwszy wiersz = nagłówki kolumn
• Kolejne wiersze = dane
• Separator (najczęściej przecinek)

Python ma wbudowany moduł csv do czytania i zapisywania plików CSV.

Odczyt pliku CSV

import csv

# Odczyt CSV jako lista list
with open('dane.csv', 'r', encoding='utf-8') as plik:
    czytnik = csv.reader(plik)
    
    # Pierwszy wiersz - nagłówki
    naglowki = next(czytnik)
    print(naglowki)  # ['Imie', 'Nazwisko', 'Wiek', 'Miasto']
    
    # Pozostałe wiersze - dane
    for wiersz in czytnik:
        print(wiersz)
        # ['Jan', 'Kowalski', '25', 'Warszawa']
        # ['Anna', 'Nowak', '30', 'Kraków']

Odczyt jako słownik

import csv

# DictReader - każdy wiersz jako słownik
with open('dane.csv', 'r', encoding='utf-8') as plik:
    czytnik = csv.DictReader(plik)
    
    for wiersz in czytnik:
        print(wiersz)
        # {'Imie': 'Jan', 'Nazwisko': 'Kowalski', 'Wiek': '25', 'Miasto': 'Warszawa'}
        
        # Dostęp po kluczu
        print(f"{wiersz['Imie']} {wiersz['Nazwisko']}, {wiersz['Wiek']} lat")

Zapis do CSV

import csv

dane = [
    ['Imie', 'Nazwisko', 'Wiek', 'Miasto'],
    ['Jan', 'Kowalski', 25, 'Warszawa'],
    ['Anna', 'Nowak', 30, 'Kraków'],
    ['Piotr', 'Wiśniewski', 28, 'Gdańsk']
]

# Zapis do CSV
with open('nowe_dane.csv', 'w', newline='', encoding='utf-8') as plik:
    writer = csv.writer(plik)
    writer.writerows(dane)

print("Plik zapisany!")

Ważne: newline='' zapobiega pustym liniom w Windows

Zapis słowników

import csv

dane = [
    {'Imie': 'Jan', 'Nazwisko': 'Kowalski', 'Wiek': 25},
    {'Imie': 'Anna', 'Nazwisko': 'Nowak', 'Wiek': 30},
    {'Imie': 'Piotr', 'Nazwisko': 'Wiśniewski', 'Wiek': 28}
]

with open('slowniki.csv', 'w', newline='', encoding='utf-8') as plik:
    naglowki = ['Imie', 'Nazwisko', 'Wiek']
    writer = csv.DictWriter(plik, fieldnames=naglowki)
    
    writer.writeheader()  # Zapisz nagłówki
    writer.writerows(dane)  # Zapisz dane

print("Plik zapisany!")

Różne separatory

import csv

# CSV z średnikiem jako separator
with open('dane_sredniki.csv', 'r', encoding='utf-8') as plik:
    czytnik = csv.reader(plik, delimiter=';')
    for wiersz in czytnik:
        print(wiersz)

# Zapis z tabulatorem
with open('dane_tab.csv', 'w', newline='', encoding='utf-8') as plik:
    writer = csv.writer(plik, delimiter='\t')
    writer.writerow(['Kolumna1', 'Kolumna2', 'Kolumna3'])

Pandas – profesjonalna analiza danych

Pandas to najpopularniejsza biblioteka do analizy danych w Pythonie.

Instalacja

pip install pandas

Podstawowe struktury danych

Pandas ma dwie główne struktury:

• Series – jednowymiarowa (jak lista z indeksami)
• DataFrame – dwuwymiarowa (tabela)

Series – jednowymiarowa seria

import pandas as pd

# Tworzenie Series
s = pd.Series([10, 20, 30, 40, 50])
print(s)
# 0    10
# 1    20
# 2    30
# 3    40
# 4    50
# dtype: int64

# Series z własnymi indeksami
s2 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(s2)
# a    10
# b    20
# c    30

# Dostęp do elementów
print(s2['a'])  # 10
print(s2[0])    # 10

DataFrame – tabela danych

DataFrame to główna struktura w Pandas – dwuwymiarowa tabela z kolumnami.

Tworzenie DataFrame

import pandas as pd

# Ze słownika
dane = {
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk']
}

df = pd.DataFrame(dane)
print(df)
#     Imie  Wiek    Miasto
# 0    Jan    25  Warszawa
# 1   Anna    30    Kraków
# 2  Piotr    28    Gdańsk

Z listy list – zagnieżdżone listy

import pandas as pd

dane = [
    ['Jan', 25, 'Warszawa'],
    ['Anna', 30, 'Kraków'],
    ['Piotr', 28, 'Gdańsk']
]

df = pd.DataFrame(dane, columns=['Imie', 'Wiek', 'Miasto'])
print(df)

Z listy słowników

import pandas as pd

dane = [
    {'Imie': 'Jan', 'Wiek': 25, 'Miasto': 'Warszawa'},
    {'Imie': 'Anna', 'Wiek': 30, 'Miasto': 'Kraków'},
    {'Imie': 'Piotr', 'Wiek': 28, 'Miasto': 'Gdańsk'}
]

df = pd.DataFrame(dane)
print(df)

Wczytywanie danych z plików

CSV

import pandas as pd

# Wczytaj CSV
df = pd.read_csv('dane.csv')
print(df)

# Z różnymi opcjami
df = pd.read_csv('dane.csv', 
                 encoding='utf-8',      # Kodowanie
                 sep=';',               # Separator
                 decimal=',',           # Separator dziesiętny
                 thousands=' ')         # Separator tysięcy

# Bez nagłówków
df = pd.read_csv('dane.csv', header=None)

# Własne nazwy kolumn
df = pd.read_csv('dane.csv', names=['Col1', 'Col2', 'Col3'])

Excel

import pandas as pd

# Wymaga: pip install openpyxl

# Wczytaj Excel
df = pd.read_excel('dane.xlsx')

# Konkretny arkusz
df = pd.read_excel('dane.xlsx', sheet_name='Arkusz1')

JSON

import pandas as pd

# Wczytaj JSON
df = pd.read_json('dane.json')

# Z różnymi orientacjami
df = pd.read_json('dane.json', orient='records')

Podstawowe operacje na DataFrame

Podgląd danych

import pandas as pd

df = pd.read_csv('dane.csv')

# Pierwsze 5 wierszy
print(df.head())

# Pierwsze n wierszy
print(df.head(10))

# Ostatnie 5 wierszy
print(df.tail())

# Informacje o DataFrame
print(df.info())
# Wyświetli: typy kolumn, liczbę niepustych wartości

# Statystyki opisowe (dla kolumn numerycznych)
print(df.describe())
# Wyświetli: count, mean, std, min, max, quartiles

# Wymiary (wiersze, kolumny)
print(df.shape)  # (100, 5)

# Nazwy kolumn
print(df.columns)  # Index(['Imie', 'Wiek', 'Miasto'])

# Typy danych
print(df.dtypes)

Dostęp do kolumn

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk']
})

# Jedna kolumna (Series)
print(df['Imie'])
# 0      Jan
# 1     Anna
# 2    Piotr

# Lub jako atrybut
print(df.Imie)

# Wiele kolumn (DataFrame)
print(df[['Imie', 'Wiek']])
#     Imie  Wiek
# 0    Jan    25
# 1   Anna    30
# 2  Piotr    28

Dostęp do wierszy

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk']
})

# Po indeksie liczbowym - iloc
print(df.iloc[0])  # Pierwszy wiersz
# Imie          Jan
# Wiek           25
# Miasto    Warszawa

print(df.iloc[0:2])  # Pierwsze dwa wiersze

# Po etykiecie indeksu - loc
df_indexed = df.set_index('Imie')
print(df_indexed.loc['Anna'])
# Wiek          30
# Miasto    Kraków

# Konkretna komórka
print(df.iloc[0, 1])  # Wiersz 0, kolumna 1 → 25
print(df.loc[0, 'Wiek'])  # Wiersz 0, kolumna 'Wiek' → 25

Filtrowanie danych

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr', 'Ewa'],
    'Wiek': [25, 30, 28, 22],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk', 'Warszawa']
})

# Filtruj wiek > 25
starsi = df[df['Wiek'] > 25]
print(starsi)
#     Imie  Wiek   Miasto
# 1   Anna    30   Kraków
# 2  Piotr    28   Gdańsk

# Filtruj miasto
warszawiacy = df[df['Miasto'] == 'Warszawa']
print(warszawiacy)

# Wiele warunków (& = and, | = or)
mlodzi_z_warszawy = df[(df['Wiek'] < 30) & (df['Miasto'] == 'Warszawa')]
print(mlodzi_z_warszawy)

# isin() - czy wartość w liście
krakowskie = df[df['Miasto'].isin(['Kraków', 'Gdańsk'])]
print(krakowskie)

Dodawanie i usuwanie kolumn

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28]
})

# Dodaj nową kolumnę
df['Pensja'] = [5000, 6000, 5500]
print(df)
#     Imie  Wiek  Pensja
# 0    Jan    25    5000
# 1   Anna    30    6000
# 2  Piotr    28    5500

# Oblicz nową kolumnę z istniejącej
df['Wiek_za_10_lat'] = df['Wiek'] + 10
print(df)

# Usuń kolumnę
df = df.drop('Wiek_za_10_lat', axis=1)
# Lub in-place
df.drop('Pensja', axis=1, inplace=True)
print(df)

Sortowanie

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28],
    'Pensja': [5000, 6000, 5500]
})

# Sortuj po wieku (rosnąco)
df_sorted = df.sort_values('Wiek')
print(df_sorted)

# Sortuj malejąco
df_sorted = df.sort_values('Wiek', ascending=False)
print(df_sorted)

# Sortuj po wielu kolumnach
df_sorted = df.sort_values(['Wiek', 'Pensja'], ascending=[True, False])
print(df_sorted)

# In-place
df.sort_values('Wiek', inplace=True)

Grupowanie i agregacja

import pandas as pd

df = pd.DataFrame({
    'Miasto': ['Warszawa', 'Kraków', 'Warszawa', 'Gdańsk', 'Kraków'],
    'Wiek': [25, 30, 28, 22, 35],
    'Pensja': [5000, 6000, 5500, 4500, 6500]
})

# Grupuj po mieście i oblicz średnią
srednie = df.groupby('Miasto')['Pensja'].mean()
print(srednie)
# Miasto
# Gdańsk       4500.0
# Kraków       6250.0
# Warszawa     5250.0

# Wiele agregacji
agregacja = df.groupby('Miasto').agg({
    'Wiek': 'mean',
    'Pensja': ['min', 'max', 'mean']
})
print(agregacja)

# Policz wystąpienia
liczebnosc = df.groupby('Miasto').size()
print(liczebnosc)

Brakujące dane

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, 7, 8],
    'C': [9, 10, 11, 12]
})

# Sprawdź brakujące wartości
print(df.isnull())
#        A      B      C
# 0  False  False  False
# 1  False   True  False
# 2   True  False  False
# 3  False  False  False

# Zlicz brakujące
print(df.isnull().sum())
# A    1
# B    1
# C    0

# Usuń wiersze z brakującymi
df_clean = df.dropna()
print(df_clean)

# Wypełnij brakujące wartością
df_filled = df.fillna(0)
print(df_filled)

# Wypełnij średnią
df['A'] = df['A'].fillna(df['A'].mean())
print(df)

Zapisywanie danych

import pandas as pd

df = pd.DataFrame({
    'Imie': ['Jan', 'Anna', 'Piotr'],
    'Wiek': [25, 30, 28]
})

# Do CSV
df.to_csv('wynik.csv', index=False)  # index=False = bez numeru wiersza

# Do Excel
df.to_excel('wynik.xlsx', index=False, sheet_name='Dane')

# Do JSON
df.to_json('wynik.json', orient='records', indent=2)

print("Pliki zapisane!")

Praktyczne przykłady

Przykład 1: Analiza sprzedaży

import pandas as pd

# Dane sprzedażowe
sprzedaz = pd.DataFrame({
    'Produkt': ['Laptop', 'Mysz', 'Klawiatura', 'Laptop', 'Mysz'],
    'Cena': [3000, 50, 200, 3000, 50],
    'Ilosc': [2, 10, 5, 1, 15],
    'Miasto': ['Warszawa', 'Kraków', 'Warszawa', 'Gdańsk', 'Kraków']
})

# Wartość sprzedaży
sprzedaz['Wartosc'] = sprzedaz['Cena'] * sprzedaz['Ilosc']

# Całkowita sprzedaż
print(f"Całkowita sprzedaż: {sprzedaz['Wartosc'].sum()} zł")

# Sprzedaż po produktach
po_produktach = sprzedaz.groupby('Produkt')['Wartosc'].sum()
print("\nSprzedaż po produktach:")
print(po_produktach)

# Najlepiej sprzedający się produkt
najlepszy = po_produktach.idxmax()
print(f"\nNajlepszy produkt: {najlepszy}")

Przykład 2: Czyszczenie danych

import pandas as pd
import numpy as np

# Dane z błędami
df = pd.DataFrame({
    'Imie': ['Jan', 'ANNA', 'piotr', '  Ewa  '],
    'Wiek': [25, 200, -5, 30],  # Błędne wartości
    'Email': ['jan@test.com', 'invalid', 'piotr@test.com', 'ewa@test.com']
})

print("PRZED czyszczeniem:")
print(df)

# Normalizuj imiona
df['Imie'] = df['Imie'].str.strip().str.title()

# Popraw wiek (ustal realistyczne granice)
df.loc[(df['Wiek'] < 0) | (df['Wiek'] > 120), 'Wiek'] = np.nan
df['Wiek'] = df['Wiek'].fillna(df['Wiek'].median())

# Waliduj email (prosty sposób)
df['Email_OK'] = df['Email'].str.contains('@')

print("\nPO czyszczeniu:")
print(df)

Przykład 3: Analiza ocen uczniów

import pandas as pd

oceny = pd.DataFrame({
    'Uczen': ['Jan', 'Anna', 'Piotr', 'Jan', 'Anna', 'Piotr'],
    'Przedmiot': ['Matematyka', 'Matematyka', 'Matematyka', 
                  'Polski', 'Polski', 'Polski'],
    'Ocena': [4, 5, 3, 5, 4, 4]
})

# Średnia po uczniach
srednie_uczniow = oceny.groupby('Uczen')['Ocena'].mean()
print("Średnie uczniów:")
print(srednie_uczniow)

# Średnia po przedmiotach
srednie_przedmiotow = oceny.groupby('Przedmiot')['Ocena'].mean()
print("\nŚrednie przedmiotów:")
print(srednie_przedmiotow)

# Najlepszy uczeń
najlepszy = srednie_uczniow.idxmax()
print(f"\nNajlepszy uczeń: {najlepszy} (średnia: {srednie_uczniow.max():.2f})")

# Tabela przestawna
pivot = oceny.pivot_table(
    values='Ocena',
    index='Uczen',
    columns='Przedmiot',
    aggfunc='mean'
)
print("\nTabela przestawna:")
print(pivot)

Przykład 4: Łączenie danych

import pandas as pd

# Dane uczniów
uczniowie = pd.DataFrame({
    'ID': [1, 2, 3],
    'Imie': ['Jan', 'Anna', 'Piotr']
})

# Dane ocen
oceny = pd.DataFrame({
    'ID_ucznia': [1, 1, 2, 3],
    'Przedmiot': ['Matematyka', 'Polski', 'Matematyka', 'Polski'],
    'Ocena': [4, 5, 5, 3]
})

# Połącz (merge) - jak JOIN w SQL
polaczone = pd.merge(uczniowie, oceny, 
                      left_on='ID', 
                      right_on='ID_ucznia')

print(polaczone)
#    ID  Imie  ID_ucznia   Przedmiot  Ocena
# 0   1   Jan          1  Matematyka      4
# 1   1   Jan          1      Polski      5
# 2   2  Anna          2  Matematyka      5
# 3   3 Piotr          3      Polski      3

Pandas – przydatne metody

Unikalne wartości

import pandas as pd

df = pd.DataFrame({
    'Miasto': ['Warszawa', 'Kraków', 'Warszawa', 'Gdańsk', 'Kraków']
})

# Unikalne wartości
print(df['Miasto'].unique())
# ['Warszawa' 'Kraków' 'Gdańsk']

# Liczba unikalnych
print(df['Miasto'].nunique())  # 3

# Zlicz wystąpienia
print(df['Miasto'].value_counts())
# Warszawa    2
# Kraków      2
# Gdańsk      1

Zastosuj funkcję

import pandas as pd

df = pd.DataFrame({
    'Liczba': [1, 2, 3, 4, 5]
})

# apply() - zastosuj funkcję do każdego elementu
df['Kwadrat'] = df['Liczba'].apply(lambda x: x ** 2)
print(df)

# apply() z własną funkcją
def klasyfikuj(x):
    if x < 3:
        return 'Mała'
    else:
        return 'Duża'

df['Kategoria'] = df['Liczba'].apply(klasyfikuj)
print(df)

Zastąp wartości

import pandas as pd

df = pd.DataFrame({
    'Ocena': ['A', 'B', 'C', 'A', 'B']
})

# Zamień wartości
mapping = {'A': 5, 'B': 4, 'C': 3}
df['Ocena_numeryczna'] = df['Ocena'].replace(mapping)
print(df)

Podsumowanie

Format CSV:

• Prosty format tabelaryczny
• Moduł csv do odczytu/zapisu
• csv.reader(), csv.DictReader()
• csv.writer(), csv.DictWriter()

Pandas – podstawy:

• Series – jednowymiarowa
• DataFrame – dwuwymiarowa tabela
• pd.read_csv(), pd.read_excel(), pd.read_json()

Operacje DataFrame:

• Podgląd: head(), tail(), info(), describe()
• Dostęp: df['kolumna'], df.iloc[], df.loc[]
• Filtrowanie: df[df['kolumna'] > wartość]
• Sortowanie: sort_values()
• Grupowanie: groupby()

Brakujące dane:

• isnull(), dropna(), fillna()

Zapis:

• to_csv(), to_excel(), to_json()

Zastosowania:

• Analiza sprzedaży
• Czyszczenie danych
• Raporty i statystyki
• Przygotowanie danych do wizualizacji

Ćwiczenia – CSV i Pandas

Moduł csv

1. Stwórz plik CSV z danymi 5 osób (imię, nazwisko, wiek, miasto).
2. Wczytaj plik CSV i wyświetl wszystkie dane.
3. Wczytaj CSV jako słowniki (DictReader) i wyświetl.
4. Dodaj nową osobę do istniejącego pliku CSV.
5. Policz ile osób jest z konkretnego miasta.
6. Znajdź najstarszą osobę w pliku CSV.
7. Wyfiltruj osoby starsze niż 25 lat i zapisz do nowego CSV.
8. Stwórz CSV z danymi produktów (nazwa, cena, ilość).
9. Oblicz wartość magazynu (cena × ilość) i zapisz do nowego CSV.
10. Wczytaj CSV z różnym separatorem (średnik).

Pandas – podstawy

11. Stwórz DataFrame z danymi 3 osób (słownik).
12. Stwórz DataFrame z listy list.
13. Wyświetl pierwsze 3 wiersze DataFrame.
14. Wyświetl ostatnie 2 wiersze DataFrame.
15. Wyświetl informacje o DataFrame (info()).
16. Wyświetl statystyki opisowe (describe()).
17. Wyświetl nazwy kolumn DataFrame.
18. Wyświetl wymiary DataFrame (shape).
19. Wyświetl typy danych kolumn (dtypes).
20. Stwórz Series z listy liczb.

Wczytywanie danych

21. Wczytaj plik CSV do DataFrame.
22. Wczytaj CSV bez nagłówków i dodaj własne.
23. Wczytaj tylko pierwsze 10 wierszy z CSV.
24. Wczytaj CSV z separatorem średnikowym.
25. Wczytaj plik Excel do DataFrame.

Dostęp do danych

26. Wyświetl pojedynczą kolumnę DataFrame.
27. Wyświetl dwie wybrane kolumny DataFrame.
28. Wyświetl pierwszy wiersz DataFrame (iloc).
29. Wyświetl wiersze od 2 do 5 (iloc).
30. Wyświetl konkretną komórkę DataFrame.

Filtrowanie

31. Wyfiltruj osoby starsze niż 25 lat.
32. Wyfiltruj osoby z konkretnego miasta.
33. Wyfiltruj osoby młodsze niż 30 AND z Warszawy.
34. Wyfiltruj osoby starsze niż 25 OR z Krakowa.
35. Wyfiltruj osoby z listy miast (isin).
36. Wyfiltruj wiersze gdzie pensja > 5000.
37. Znajdź osoby których imię zaczyna się na 'A’.
38. Wyfiltruj produkty droższe niż 100 zł.
39. Znajdź zamówienia z ostatniego miesiąca.
40. Wyfiltruj niepuste wartości w kolumnie.

Dodawanie i usuwanie

41. Dodaj nową kolumnę do DataFrame.
42. Oblicz nową kolumnę na podstawie istniejącej (np. wiek + 10).
43. Usuń kolumnę z DataFrame.
44. Usuń wiersz po indeksie.
45. Zmień nazwę kolumny (rename).

Sortowanie

46. Posortuj DataFrame po wieku (rosnąco).
47. Posortuj DataFrame po imieniu (alfabetycznie).
48. Posortuj DataFrame po wieku (malejąco).
49. Posortuj po dwóch kolumnach (wiek, pensja).
50. Posortuj indeks DataFrame.

Grupowanie i agregacja

51. Zgrupuj po mieście i oblicz średni wiek.
52. Zgrupuj po kategorii produktu i oblicz sumę sprzedaży.
53. Policz ile osób jest w każdym mieście (size).
54. Zgrupuj i oblicz min, max, mean dla pensji.
55. Stwórz tabelę przestawną (pivot_table).

Brakujące dane

56. Stwórz DataFrame z brakującymi wartościami (np.nan).
57. Sprawdź które wiersze mają brakujące dane (isnull).
58. Policz brakujące wartości w każdej kolumnie.
59. Usuń wiersze z brakującymi wartościami (dropna).
60. Wypełnij brakujące wartości zerem (fillna).
61. Wypełnij brakujące wartości średnią kolumny.
62. Usuń kolumny z więcej niż 50% braków.
63. Wykryj duplikaty wierszy (duplicated).
64. Usuń duplikaty (drop_duplicates).
65. Zastąp wartości None średnią.

Zapisywanie

66. Zapisz DataFrame do CSV bez indeksu.
67. Zapisz DataFrame do Excel.
68. Zapisz DataFrame do JSON.
69. Zapisz tylko wybrane kolumny do CSV.
70. Zapisz DataFrame z innym separatorem.

Operacje na tekście

71. Zamień wszystkie imiona na wielkie litery (str.upper).
72. Usuń spacje z początku i końca (str.strip).
73. Sprawdź czy email zawiera '@’ (str.contains).
74. Podziel kolumnę na dwie (str.split).
75. Wyciągnij pierwsze 3 znaki z tekstu (str[:3]).

Unikalne wartości

76. Wyświetl unikalne wartości kolumny 'Miasto’.
77. Policz liczbę unikalnych miast (nunique).
78. Zlicz wystąpienia każdej wartości (value_counts).
79. Znajdź najczęściej występującą wartość.
80. Usuń duplikaty z kolumny.

Apply i transform

81. Zastosuj funkcję lambda do kolumny (apply).
82. Stwórz kategorię na podstawie wieku (apply).
83. Zastosuj własną funkcję do DataFrame.
84. Oblicz nową kolumnę używając apply.
85. Zamień wartości używając replace.

Łączenie danych

86. Połącz dwa DataFrame wertykalnie (concat).
87. Połącz dwa DataFrame horyzontalnie (concat axis=1).
88. Wykonaj merge (inner join) dwóch DataFrame.
89. Wykonaj left join.
90. Wykonaj outer join.

Zadania analityczne

91. Wczytaj dane sprzedażowe i oblicz całkowitą wartość sprzedaży.
92. Znajdź 5 najlepiej sprzedających się produktów.
93. Oblicz średnią cenę produktów w każdej kategorii.
94. Stwórz raport miesięczny sprzedaży.
95. Znajdź klientów którzy wydali najwięcej.
96. Oblicz procent sprzedaży dla każdego produktu.
97. Wyfiltruj zamówienia z ostatnich 30 dni.
98. Znajdź produkty których nie ma na stanie.
99. Oblicz średnią ocen dla każdego produktu.
100. Stwórz ranking najlepszych sprzedawców.

Zadania kompleksowe

101. Wczytaj dane uczniów i ocen, oblicz średnie, znajdź najlepszego.
102. Analiza danych o pracownikach: średnia pensja, najstarszy, podział po działach.
103. Dane sprzedażowe: najlepszy miesiąc, najbardziej dochodowy produkt, trend.
104. Czyszczenie danych: usuń duplikaty, wypełnij braki, normalizuj tekst.
105. Analiza ankiety: zlicz odpowiedzi, procenty, wykres rozkładu.
106. Połącz dane z dwóch źródeł (merge) i stwórz raport.
107. Analiza logów: zlicz błędy, najczęstsze typy, wykres czasowy.
108. Dane finansowe: oblicz przychody, koszty, zysk netto.
109. Segmentacja klientów: podziel na grupy wiekowe, oblicz statystyki.
110. Time series: analiza sprzedaży w czasie, trendy, sezonowość.

Artykuł 18. Python – Analiza danych: CSV i Pandas pochodzi z serwisu Kama Kaczmarek.

• SQLite3 to lekka, wbudowana relacyjna baza danych SQL
• Nie wymaga osobnego serwera – cała baza to jeden plik
• Python ma wbudowany moduł sqlite3 – nie trzeba nic instalować
• Idealna do nauki, prototypów i małych/średnich aplikacji

SQLite3 to lekka, wbudowana relacyjna baza danych SQL

Nie wymaga osobnego serwera – cała baza to jeden plik

Python ma wbudowany moduł sqlite3 – nie trzeba nic instalować

Idealna do nauki, prototypów i małych/średnich aplikacji

Podstawowe pojęcia:

Połączenie (Connection) – łącze z plikiem bazy danych

Kursor (Cursor) – obiekt do wykonywania poleceń SQL

Commit – zatwierdzenie zmian w bazie

Rollback – cofnięcie niezatwierdzonych zmian

Analogia ze świata rzeczywistego:

Wyobraź sobie, że:

• Baza danych = Biblioteka pełna książek
• Connection (połączenie) = Karta biblioteczna (pozwala Ci wejść do biblioteki)
• Cursor (kursor) = Bibliotekarz, który wykonuje dla Ciebie konkretne zadania
• Dlaczego potrzebujemy kursora?

Nie możesz bezpośrednio rozmawiać z bazą danych! Potrzebujesz „pośrednika”, który:

• Zaniesie Twoje polecenie do bazy danych
• Wykona operację (znajdzie dane, doda coś, usunie)
• Przyniesie Ci wyniki

Tym pośrednikiem jest właśnie KURSOR.

import sqlite3
# KROK 1: Otwierasz drzwi do biblioteki (połączenie)
conn = sqlite3.connect('mojabaza.db')
# Teraz jesteś w bibliotece, ale jeszcze nic nie możesz zrobić
# KROK 2: Wzywasz bibliotekarza (tworzysz kursor)
cursor = conn.cursor()
# Teraz masz "pomocnika", któremu możesz wydawać polecenia
# KROK 3: Wydajesz polecenie bibliotekarzowi
cursor.execute('SELECT * FROM ksiazki WHERE autor LIKE ?', ('%Tolkien%',))
# Bibliotekarz idzie, szuka książek Tolkiena
# KROK 4: Bibliotekarz przynosi Ci wyniki
wyniki = cursor.fetchall()
print(wyniki)
# KROK 5: Wychodzisz z biblioteki
conn.close()

PRZYKŁADY PRAKTYCZNE

Przykład 1: Podstawowe operacje CRUD

tworzymy plik o nazwie crud_basics.py

import sqlite3
# Połączenie z bazą (tworzy plik jeśli nie istnieje)
conn = sqlite3.connect('mojabaza.db')
cursor = conn.cursor()
# CREATE - Tworzenie tabeli
cursor.execute('''
CREATE TABLE IF NOT EXISTS pracownicy (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    imie TEXT NOT NULL,
    nazwisko TEXT NOT NULL,
    wiek INTEGER,
    wynagrodzenie REAL
)
''')
# INSERT - Wstawianie pojedynczego rekordu
cursor.execute('''
    INSERT INTO pracownicy (imie, nazwisko, wiek, wynagrodzenie)
    VALUES (?, ?, ?, ?)
''', ('Jan', 'Kowalski', 35, 5500.50))
# INSERT - Wstawianie wielu rekordów
dane = [
    ('Anna', 'Nowak', 28, 6200.00),
    ('Kacper', 'Malinowski', 22, 4100.75),
    ('Maria', 'Wiśniewska', 45, 7800.00)
]
cursor.executemany('''
    INSERT INTO pracownicy (imie, nazwisko, wiek, wynagrodzenie)
    VALUES (?, ?, ?, ?)
''', dane)
# Zatwierdzenie zmian
conn.commit()
# SELECT - Pobieranie wszystkich danych
cursor.execute('SELECT * FROM pracownicy')
wyniki = cursor.fetchall()
print("Wszyscy pracownicy:")
for wiersz in wyniki:
    print(wiersz)
# SELECT - Pobieranie z warunkiem
cursor.execute('SELECT imie, nazwisko FROM pracownicy WHERE wiek > ?', (30,))
starsi = cursor.fetchall()
print("\nPracownicy powyżej 30 lat:")
for osoba in starsi:
    print(f"{osoba[0]} {osoba[1]}")
# UPDATE - Aktualizacja danych
cursor.execute('''
    UPDATE pracownicy
    SET wynagrodzenie = wynagrodzenie * 1.1
    WHERE wiek < 30
''')
conn.commit()
# DELETE - Usuwanie danych
cursor.execute('DELETE FROM pracownicy WHERE id = ?', (1,))
conn.commit()
# Zamknięcie połączenia
conn.close()

Przykład 2: Context Manager (zalecane podejście)

tworzymy plik o nazwie context_manager.py

import sqlite3
 # Automatyczne zarządzanie połączeniem
with sqlite3.connect('sklep.db') as conn:
    cursor = conn.cursor()
   
    # Tworzenie tabeli produktów
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS produkty (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nazwa TEXT NOT NULL,
        cena REAL NOT NULL,
        ilosc INTEGER DEFAULT 0
    )
    ''')
   
    # Dane są automatycznie commitowane przy wyjściu z bloku 'with'
    cursor.execute('INSERT INTO produkty (nazwa, cena, ilosc) VALUES (?, ?, ?)',
                   ('Laptop', 3500.00, 5))
   
    # Pobieranie z użyciem row_factory dla dostępu jak do słownika
    conn.row_factory = sqlite3.Row
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM produkty')
   
    for row in cursor:
        print(f"Produkt: {row['nazwa']}, Cena: {row['cena']} zł")

Przykład 3: Zaawansowane zapytania

tworzymy plik o nazwie advanced_queries.py

import sqlite3
 with sqlite3.connect('firma.db') as conn:
    cursor = conn.cursor()
   
    # Tworzenie dwóch powiązanych tabel
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS dzialy (
        id INTEGER PRIMARY KEY,
        nazwa TEXT NOT NULL
    )
    ''')
   
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS pracownicy (
        id INTEGER PRIMARY KEY,
        imie TEXT NOT NULL,
        nazwisko TEXT NOT NULL,
        dzial_id INTEGER,
        FOREIGN KEY (dzial_id) REFERENCES dzialy(id)
    )
    ''')
   
    # Wstawienie działów
    dzialy = [(1, 'IT'), (2, 'HR'), (3, 'Sprzedaż')]
    cursor.executemany('INSERT OR IGNORE INTO dzialy VALUES (?, ?)', dzialy)
   
    # Wstawienie pracowników
    pracownicy = [
        ('Jan', 'Kowalski', 1),
        ('Anna', 'Nowak', 2),
        ('Piotr', 'Wiśniewski', 1)
    ]
    cursor.executemany('INSERT INTO pracownicy (imie, nazwisko, dzial_id) VALUES (?, ?, ?)', pracownicy)
   
    # JOIN - łączenie tabel
    cursor.execute('''
    SELECT p.imie, p.nazwisko, d.nazwa
    FROM pracownicy p
    JOIN dzialy d ON p.dzial_id = d.id
    WHERE d.nazwa = 'IT'
    ''')
   
    print("Pracownicy działu IT:")
    for row in cursor.fetchall():
        print(f"{row[0]} {row[1]} - {row[2]}")
   
    # GROUP BY - agregacja
    cursor.execute('''
    SELECT d.nazwa, COUNT(p.id) as liczba_pracownikow
    FROM dzialy d
    LEFT JOIN pracownicy p ON d.id = p.dzial_id
    GROUP BY d.nazwa
    ''')
   
    print("\nLiczba pracowników w działach:")
    for row in cursor.fetchall():
        print(f"{row[0]}: {row[1]}")

Przykład 4: Obsługa błędów

tworzymy plik o nazwie error_handling.py

import sqlite3
 try:
    with sqlite3.connect('test.db') as conn:
        cursor = conn.cursor()
       
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY,
            email TEXT UNIQUE NOT NULL
        )
        ''')
       
        # Próba wstawienia duplikatu
        cursor.execute('INSERT INTO users (email) VALUES (?)', ('jan@example.com',))
        cursor.execute('INSERT INTO users (email) VALUES (?)', ('jan@example.com',))
       
except sqlite3.IntegrityError as e:
    print(f"Błąd integralności danych: {e}")
except sqlite3.OperationalError as e:
    print(f"Błąd operacyjny: {e}")
except sqlite3.Error as e:
    print(f"Błąd bazy danych: {e}")

Typy wyjątków:

Przykład 5:

#https://pypi.org/project/sqlite-database/
#shift + ctrl + p -> wpisujemy sqlite i wybieramy naszą bazę (test.db) - po lewej na dole pokazuje się dostęp do bazy
#tworzymy połączenie z bazą
import sqlite3

conn = sqlite3.connect('test1.db') #tworzymy połączenie z bazą danych przechowywaną w pliku na dysku (test.db, nazwa pliku jest dowolona) lub w pamięci, jeśli podamy ':memory:'
conn.row_factory = sqlite3.Row #dostęp do kolumn (pól tabel) nie tylko przez indeksy, ale również przez nazwy
db = conn.cursor() #obiekt kursora do wykonywania operacji na bazie danych
print(db)
#tworzymy tabele
#pojedyncze polecenia SQL-a wykonujemy za pomocą metody .execute()
db.execute("DROP TABLE IF EXISTS klasa;")

db.execute("""
    CREATE TABLE IF NOT EXISTS klasa (
        id INTEGER PRIMARY KEY ASC,
        nazwa varchar(250) NOT NULL,
        profil varchar(250) DEFAULT ''
    )""")

#wiele instrukcji wykonujemy za pomocą metody .executescript()
db.executescript("""
    DROP TABLE IF EXISTS uczen;
    CREATE TABLE IF NOT EXISTS uczen (
        id INTEGER PRIMARY KEY ASC,
        imie varchar(250) NOT NULL,
        nazwisko varchar(250) NOT NULL,
        klasa_id INTEGER NOT NULL,
        FOREIGN KEY(klasa_id) REFERENCES klasa(id)
    )""")
#po uruchomieniu kodu baza pojawi się w katalogu

# wstawiamy jeden rekord danych
db.execute('INSERT INTO klasa VALUES(NULL, ?, ?);', ('1A', 'matematyczny'))
db.execute('INSERT INTO klasa VALUES(NULL, ?, ?);', ('1B', 'humanistyczny'))

#Polecenia CREATE TABLE (a także DROP TABLE, ALTER TABLE) są traktowane przez SQLite jako DDL (Data Definition Language) i są automatycznie zatwierdzane — SQLite implicitnie wykonuje COMMIT po każdej takiej operacji.Ale już INSERT, UPDATE, DELETE tego nie robią automatycznie: Te operacje to DML (Data Manipulation Language) i wymagają jawnego conn.commit(), jeśli chcesz, żeby zmiany zostały zapisane na stałe.
conn.commit()

# Wyświetlamy zawartość tabeli klasa
print("Zawartość tabeli 'klasa':")
for row in db.execute('SELECT * FROM klasa'):
    print(dict(row))  # wypisujemy jako słownik, żeby było czytelniej


# wykonujemy zapytanie SQL, które pobierze id klasy "1A" z tabeli "klasa".
db.execute('SELECT id FROM klasa WHERE nazwa = ?', ('1A',))
klasa_id = db.fetchone()[0]

# tupla "uczniowie" zawiera tuple z danymi poszczególnych uczniów
uczniowie = (
    (None, 'Tomasz', 'Nowak', klasa_id),
    (None, 'Jan', 'Kos', klasa_id),
    (None, 'Piotr', 'Kowalski', klasa_id)
)

# wstawiamy wiele rekordów
db.executemany('INSERT INTO uczen VALUES(?,?,?,?)', uczniowie)



# pobieranie danych z bazy
def czytajdane():
    """Funkcja pobiera i wyświetla dane z bazy."""
    #poniżej potrójny cudzysłów został wykorzystany do zapisania długielo zapytania SQL
    db.execute(
        """
        SELECT uczen.id,imie,nazwisko,nazwa FROM uczen,klasa
        WHERE uczen.klasa_id=klasa.id
        """)
    
    uczniowie = db.fetchall()
    for uczen in uczniowie:
        print(uczen['id'], uczen['imie'], uczen['nazwisko'], uczen['nazwa'])
    print()    

czytajdane()

# zmiana klasy ucznia o identyfikatorze 2res
db.execute('SELECT id FROM klasa WHERE nazwa = ?', ('1B',))
klasa_id = db.fetchone()[0]
db.execute('UPDATE uczen SET klasa_id=? WHERE id=?', (klasa_id, 2))

# usunięcie ucznia o identyfikatorze 3
# db.execute('DELETE FROM uczen WHERE id=?', (3,))

czytajdane()

# zatwierdzamy zmiany w bazie
conn.commit()
# Zamykamy połączenie
conn.close()

ĆWICZENIA

Ćwiczenie 1: Biblioteka książek (Podstawowe)

Utwórz bazę danych biblioteki z tabelą ksiażki zawierającą:

id (PRIMARY KEY)

tytul (TEXT)

autor (TEXT)

rok_wydania (INTEGER)

dostepna (INTEGER – 0 lub 1)

Zadania:

Dodaj 5 książek do tabeli

Wyświetl wszystkie książki wydane po 2000 roku

Oznacz książkę jako wypożyczoną (dostepna = 0)

Policz ile jest dostępnych książek

Ćwiczenie 2: Sklep internetowy (Średniozaawansowane)

Stwórz system zarządzania produktami z bazą o nazwie sklep.db. Utwórz dwie tabele: kategorie i produkty.

Tabela kategorie: id, nazwa

Tabela produkty: id, nazwa, cena, kategoria_id, stan_magazynowy

Utwórz obie tabele z odpowiednimi kluczami obcymi

Zadania:

Dodaj 3 kategorie (Elektronika, Odzież, Książki)

Dodaj po 3 produkty do każdej kategorii

Napisz zapytanie wyświetlające produkty wraz z nazwą kategorii

Oblicz średnią cenę produktów w każdej kategorii

Znajdź najdroższy produkt w bazie

Ćwiczenie 3: System zarządzania studentami z relacjami wiele-do-wielu: (Zaawansowane)

Utwórz bazę o nazwie uczelnia.db z trzema tabelami: studenci, kursy, zapisy (tabela łącząca)

Utwórz wszystkie trzy tabele z odpowiednimi kluczami obcymi i ograniczeniem UNIQUE(student_id, kurs_id)

Zaimplementuj funkcje:

dodaj_studenta(imie, nazwisko, rok_studiow)

dodaj_kurs(nazwa, punkty_ects)

zapisz_na_kurs(student_id, kurs_id, ocena)

wyswietl_kursy_studenta(student_id)

oblicz_srednia_studenta(student_id)

Użyj transakcji do zapisania studenta na wiele kursów jednocześnie

NAJWAŻNIEJSZE ZASADY

1. Bezpieczeństwo – SQL Injection

#ŹLE - podatne na SQL Injection
nazwa = input("Podaj nazwę: ")
cursor.execute(f"SELECT * FROM users WHERE name = '{nazwa}'")
 
#DOBRZE - używaj parametrów
nazwa = input("Podaj nazwę: ")
cursor.execute("SELECT * FROM users WHERE name = ?", (nazwa,))

2. Zawsze używaj commit()

cursor.execute('INSERT INTO ...')
conn.commit()  # BEZ TEGO dane nie zostaną zapisane!

3. Zamykaj połączenia

#Sposób 1: Manualnie
conn = sqlite3.connect('db.db')
... operacje ...
conn.close()
 
#Sposób 2: Context manager (zalecane)
with sqlite3.connect('db.db') as conn:
    ... operacje ...
    Automatyczne zamknięcie

PRZYDATNE METODY

Dlaczego dwa kroki? (Connection + Cursor)

Dlaczego nie może być tak:

conn = sqlite3.connect('baza.db')
conn.execute('SELECT...')  # Czy to nie wystarczy?

Może być! Ale to jest skrót:

#Sposób 1: SKRÓT (Python robi to za Ciebie)
conn.execute('SELECT * FROM users')
 
# Sposób 2: PEŁNY (tak naprawdę działa)
cursor = conn.cursor()
cursor.execute('SELECT * FROM users')
 
# Python w skrócie automatycznie tworzy kursor, ale go nie widzisz!

Możesz mieć WIELU BIBLIOTEKARZY naraz (wiele kursorów) i każdy może wykonywać różne zadania, ale wszyscy korzystają z tej samej karty bibliotecznej (połączenia). To pozwala na równoczesną pracę z bazą danych.

conn = sqlite3.connect('baza.db')
 
# Pierwszy bibliotekarz zajmuje się użytkownikami
cursor1 = conn.cursor()
cursor1.execute('SELECT * FROM users')
 
# Drugi bibliotekarz zajmuje się zamówieniami
cursor2 = conn.cursor()
cursor2.execute('SELECT * FROM orders')
 
# Każdy robi swoją robotę niezależnie!
users = cursor1.fetchall()
orders = cursor2.fetchall()
 
# Kursor "pamięta" wyniki swoich zapytań, więc możesz mieć wielu kursorów, a każdy z nich będzie miał swoje własne wyniki.
cursor = conn.cursor()
cursor.execute('SELECT * FROM users')
 
# Pobierasz wyniki STOPNIOWO
pierwszy = cursor.fetchone()   # Pobiera 1 wiersz
drugi = cursor.fetchone()      # Pobiera kolejny wiersz
reszta = cursor.fetchall()     # Pobiera wszystkie pozostałe
 
# Gdybyś użył conn.execute(), nie miałbyś takiej kontroli nad kursorami i wynikami.

Pamiętaj

• pojedyncze polecenia SQL-a wykonujemy za pomocą metody .execute() np. DROP TABLE IF EXISTS uczen;
• wiele instrukcji wykonujemy za pomocą metody .executescript() np. DROP TABLE IF EXISTS uczen; CREATE TABLE IF NOT EXISTS uczen (...);
• dodanie wielu rekordów do tabeli wykonujemy za pomocą metody .executemany()
• Polecenia CREATE TABLE (a także DROP TABLE, ALTER TABLE) oraz SELECT są traktowane przez SQLite jako DDL (Data Definition Language) i są automatycznie zatwierdzane — SQLite implicitnie wykonuje COMMIT po każdej takiej operacji.Ale już INSERT, UPDATE, DELETE tego nie robią automatycznie: Te operacje to DML (Data Manipulation Language) i wymagają jawnego conn.commit(), jeśli chcesz, żeby zmiany zostały zapisane na stałe.

ROZWIĄZANIA

Rozwiązanie ćwiczenia 1: Biblioteka książek

import sqlite3
 
with sqlite3.connect('biblioteka.db') as conn:
    c = conn.cursor()
   
    # 1. Tworzenie tabeli
    c.execute('''
    CREATE TABLE IF NOT EXISTS ksiazki (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        tytul TEXT NOT NULL,
        autor TEXT NOT NULL,
        rok_wydania INTEGER,
        dostepna INTEGER DEFAULT 1
    )
    ''')
   
    # 2. Dodawanie książek
    ksiazki = [
        ('Władca Pierścieni', 'J.R.R. Tolkien', 1954, 1),
        ('Harry Potter', 'J.K. Rowling', 1997, 1),
        ('Wiedźmin', 'Andrzej Sapkowski', 1990, 1),
        ('Metro 2033', 'Dmitry Glukhovsky', 2005, 1),
        ('Kod Da Vinci', 'Dan Brown', 2003, 1)
    ]
    c.executemany('INSERT INTO ksiazki (tytul, autor, rok_wydania, dostepna) VALUES (?, ?, ?, ?)', ksiazki)
   
    # 3. Książki po 2000 roku
    print("Książki wydane po 2000 roku:")
    c.execute('SELECT tytul, autor, rok_wydania FROM ksiazki WHERE rok_wydania > 2000')
    for row in c.fetchall():
        print(f"- {row[0]} ({row[1]}, {row[2]})")
   
    # 4. Wypożyczenie książki
    c.execute('UPDATE ksiazki SET dostepna = 0 WHERE tytul = ?', ('Metro 2033',))
   
    # 5. Liczba dostępnych książek
    c.execute('SELECT COUNT(*) FROM ksiazki WHERE dostepna = 1')
    liczba = c.fetchone()[0]
    print(f"\nDostępnych książek: {liczba}")

Rozwiązanie ćwiczenia 2: Sklep internetowy

import sqlite3
 
with sqlite3.connect('sklep.db') as conn:
    c = conn.cursor()
   
    # 1. Tworzenie tabel
    c.execute('''
    CREATE TABLE IF NOT EXISTS kategorie (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nazwa TEXT NOT NULL UNIQUE
    )
    ''')
   
    c.execute('''
    CREATE TABLE IF NOT EXISTS produkty (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nazwa TEXT NOT NULL,
        cena REAL NOT NULL,
        kategoria_id INTEGER,
        stan_magazynowy INTEGER DEFAULT 0,
        FOREIGN KEY (kategoria_id) REFERENCES kategorie(id)
    )
    ''')
   
    # 2. Dodawanie kategorii
    kategorie = [('Elektronika',), ('Odzież',), ('Książki',)]
    c.executemany('INSERT OR IGNORE INTO kategorie (nazwa) VALUES (?)', kategorie)
   
    # 3. Dodawanie produktów
    produkty = [
        ('Laptop', 3500.00, 1, 10),
        ('Smartphone', 2200.00, 1, 15),
        ('Słuchawki', 450.00, 1, 25),
        ('Koszulka', 89.99, 2, 50),
        ('Spodnie', 199.99, 2, 30),
        ('Kurtka', 499.00, 2, 20),
        ('Python dla każdego', 59.99, 3, 100),
        ('Clean Code', 89.00, 3, 75),
        ('Algorytmy', 120.00, 3, 40)
    ]
    c.executemany('INSERT INTO produkty (nazwa, cena, kategoria_id, stan_magazynowy) VALUES (?, ?, ?, ?)', produkty)
   
    # 4. Produkty z kategoriami
    print("Produkty z kategoriami:")
    c.execute('''
    SELECT p.nazwa, p.cena, k.nazwa
    FROM produkty p
    JOIN kategorie k ON p.kategoria_id = k.id
    ORDER BY k.nazwa
    ''')
    for row in c.fetchall():
        print(f"{row[0]} ({row[2]}) - {row[1]} zł")
   
    # 5. Średnia cena w kategoriach
    print("\nŚrednia cena w kategoriach:")
    c.execute('''
    SELECT k.nazwa, ROUND(AVG(p.cena), 2) as srednia
    FROM kategorie k
    JOIN produkty p ON k.id = p.kategoria_id
    GROUP BY k.nazwa
    ''')
    for row in c.fetchall():
        print(f"{row[0]}: {row[1]} zł")
   
    # 6. Najdroższy produkt
    c.execute('SELECT nazwa, cena FROM produkty ORDER BY cena DESC LIMIT 1')
    najdrozszy = c.fetchone()
    print(f"\nNajdroższy produkt: {najdrozszy[0]} ({najdrozszy[1]} zł)")

Rozwiązanie ćwiczenia 3: System zarządzania studentami

import sqlite3

class SystemStudentow:
    def __init__(self, db_name='uczelnia.db'):
        # Polaczenie z baza danych
        self.conn = sqlite3.connect(db_name)
        # Ustawienie row_factory dla dostepu do kolumn jak do slownika
        self.conn.row_factory = sqlite3.Row
        self._utworz_tabele()
    
    def _utworz_tabele(self):
        # Utworzenie kursora
        cursor = self.conn.cursor()
        
        # Tworzenie tabeli studenci
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS studenci (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            imie TEXT NOT NULL,
            nazwisko TEXT NOT NULL,
            rok_studiow INTEGER
        )
        ''')
        
        # Tworzenie tabeli kursy
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS kursy (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            nazwa TEXT NOT NULL,
            punkty_ects INTEGER
        )
        ''')
        
        # Tworzenie tabeli zapisy (relacja wiele-do-wielu)
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS zapisy (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            student_id INTEGER,
            kurs_id INTEGER,
            ocena REAL,
            FOREIGN KEY (student_id) REFERENCES studenci(id),
            FOREIGN KEY (kurs_id) REFERENCES kursy(id),
            UNIQUE(student_id, kurs_id)
        )
        ''')
        
        # Zatwierdzenie zmian
        self.conn.commit()
    
    def dodaj_studenta(self, imie, nazwisko, rok_studiow):
        cursor = self.conn.cursor()
        # Wstawienie studenta
        cursor.execute(
            'INSERT INTO studenci (imie, nazwisko, rok_studiow) VALUES (?, ?, ?)',
            (imie, nazwisko, rok_studiow)
        )
        self.conn.commit()
        # Zwrocenie ID dodanego rekordu
        return cursor.lastrowid
    
    def dodaj_kurs(self, nazwa, punkty_ects):
        cursor = self.conn.cursor()
        # Wstawienie kursu
        cursor.execute(
            'INSERT INTO kursy (nazwa, punkty_ects) VALUES (?, ?)',
            (nazwa, punkty_ects)
        )
        self.conn.commit()
        return cursor.lastrowid
    
    def zapisz_na_kurs(self, student_id, kurs_id, ocena=None):
        cursor = self.conn.cursor()
        try:
            # Wstawienie zapisu studenta na kurs
            cursor.execute(
                'INSERT INTO zapisy (student_id, kurs_id, ocena) VALUES (?, ?, ?)',
                (student_id, kurs_id, ocena)
            )
            self.conn.commit()
            return True
        except sqlite3.IntegrityError:
            print("Student jest juz zapisany na ten kurs")
            return False
    
    def ustaw_ocene(self, student_id, kurs_id, ocena):
        cursor = self.conn.cursor()
        # Aktualizacja oceny
        cursor.execute('''
            UPDATE zapisy 
            SET ocena = ? 
            WHERE student_id = ? AND kurs_id = ?
        ''', (ocena, student_id, kurs_id))
        
        # Sprawdzenie czy rekord zostal zaktualizowany
        if cursor.rowcount == 0:
            print("Student nie jest zapisany na ten kurs")
            return False
        
        self.conn.commit()
        return True
    
    def wyswietl_kursy_studenta(self, student_id):
        cursor = self.conn.cursor()
        # Zapytanie JOIN laczace tabele zapisy i kursy
        cursor.execute('''
        SELECT k.nazwa, k.punkty_ects, z.ocena
        FROM zapisy z
        JOIN kursy k ON z.kurs_id = k.id
        WHERE z.student_id = ?
        ''', (student_id,))
        
        print(f"\nKursy studenta (ID: {student_id}):")
        # Odczyt wszystkich wierszy
        for row in cursor.fetchall():
            ocena_str = f"{row['ocena']}" if row['ocena'] else "brak"
            print(f"- {row['nazwa']} ({row['punkty_ects']} ECTS) - Ocena: {ocena_str}")
    
    def oblicz_srednia_studenta(self, student_id):
        cursor = self.conn.cursor()
        # Zapytanie z funkcja agregujaca AVG
        cursor.execute('''
        SELECT AVG(ocena) as srednia
        FROM zapisy
        WHERE student_id = ? AND ocena IS NOT NULL
        ''', (student_id,))
        
        # Odczyt jednego wiersza
        wynik = cursor.fetchone()
        return round(wynik['srednia'], 2) if wynik['srednia'] else 0
    
    def zapisz_na_wiele_kursow(self, student_id, kursy_ids):
        try:
            cursor = self.conn.cursor()
            # Transakcja - wstawienie wielu rekordow
            for kurs_id in kursy_ids:
                cursor.execute(
                    'INSERT INTO zapisy (student_id, kurs_id) VALUES (?, ?)',
                    (student_id, kurs_id)
                )
            self.conn.commit()
            print(f"Student zapisany na {len(kursy_ids)} kursow")
        except sqlite3.Error as e:
            # Wycofanie zmian w przypadku bledu
            self.conn.rollback()
            print(f"Blad: {e}")
    
    def __del__(self):
        # Zamkniecie polaczenia
        self.conn.close()


if __name__ == '__main__':
    import os
    
    # Usuniecie starej bazy danych
    if os.path.exists('uczelnia.db'):
        os.remove('uczelnia.db')
    
    system = SystemStudentow()
    
    # Dodawanie studentow
    student1 = system.dodaj_studenta('Jan', 'Kowalski', 2)
    student2 = system.dodaj_studenta('Anna', 'Nowak', 1)
    student3 = system.dodaj_studenta('Piotr', 'Wisniewski', 3)
    
    # Dodawanie kursow
    kurs1 = system.dodaj_kurs('Bazy Danych', 6)
    kurs2 = system.dodaj_kurs('Algorytmy', 5)
    kurs3 = system.dodaj_kurs('Sieci Komputerowe', 4)
    
    # Zapisanie studenta 1 na wszystkie kursy
    system.zapisz_na_wiele_kursow(student1, [kurs1, kurs2, kurs3])
    
    # Ustawienie ocen dla studenta 1
    system.ustaw_ocene(student1, kurs1, 4.5)
    system.ustaw_ocene(student1, kurs2, 5.0)
    system.ustaw_ocene(student1, kurs3, 3.5)
    
    # Zapisanie studenta 2 na 2 kursy z ocenami
    system.zapisz_na_kurs(student2, kurs1, 4.0)
    system.zapisz_na_kurs(student2, kurs2, 5.0)
    
    # Zapisanie studenta 3 na 1 kurs bez oceny
    system.zapisz_na_kurs(student3, kurs1)
    
    # Wyswietlanie kursow studentow
    system.wyswietl_kursy_studenta(student1)
    srednia1 = system.oblicz_srednia_studenta(student1)
    print(f"\nSrednia ocen: {srednia1}")
    
    system.wyswietl_kursy_studenta(student2)
    srednia2 = system.oblicz_srednia_studenta(student2)
    print(f"\nSrednia ocen: {srednia2}")
    
    system.wyswietl_kursy_studenta(student3)
    srednia3 = system.oblicz_srednia_studenta(student3)
    print(f"\nSrednia ocen: {srednia3}")

Artykuł 17. Python – bazy danych – sqlite pochodzi z serwisu Kama Kaczmarek.

O tym po co nam programie obiektowe możesz przeczytać niżej w materiale.

Kluczowe koncepcje:

• Klasa – szablon/przepis na obiekt
• Obiekt – konkretna instancja klasy
• Atrybuty – dane/właściwości obiektu
• Metody – funkcje należące do obiektu

Analogia:

• Klasa = Przepis na ciasto
• Obiekt = Konkretne ciasto upieczone według przepisu
• Atrybuty = Składniki ciasta (mąka, jajka, cukier)
• Metody = Akcje (pieczenie, dekorowanie)

Klasa i obiekt

Czym jest klasa?

Klasa to szablon/wzorzec definiujący:

• Jakie dane będzie przechowywać obiekt (atrybuty)
• Jakie operacje może wykonać (metody)

Analogia: Klasa to formularz, obiekt to wypełniony formularz.

Tworzenie pierwszej klasy

class Kot:
    pass  # Pusta klasa

# Tworzenie obiektu (instancji)
mruczek = Kot()
print(type(mruczek))  # <class '__main__.Kot'>

Klasa z atrybutami

class Test:
    # Atrybuty klasy (wspólne dla wszystkich instancji)
    wlasnosc = "Jestem własnością klasy Test"
    lista = ["kot", "pies", "królik"]
    slownik = {"k1": "v1", "k2": "v2"}

# Tworzenie obiektu
obiekt = Test()

# Dostęp do atrybutów
print(obiekt.wlasnosc)  # Jestem własnością klasy Test
print(obiekt.lista[0])  # kot
print(obiekt.slownik["k1"])  # v1

Prywatne atrybuty

W Pythonie nie ma prawdziwych modyfikatorów dostępu. Używamy konwencji:

• nazwa – publiczne
• _nazwa – chronione (konwencja, nie używaj poza klasą)
• __nazwa – prywatne (name mangling)

class Test:
    publiczne = "Dostępne wszędzie"
    _chronione = "Konwencja - nie używaj"
    __prywatne = "Trudno dostępne"

obiekt = Test()
print(obiekt.publiczne)  # OK
# print(obiekt.__prywatne)  # AttributeError

# Można dostać się, ale to złamanie konwencji
print(obiekt._Test__prywatne)  # Zadziała, ale nie rób tego!

Metody

Metoda to funkcja zdefiniowana wewnątrz klasy.

Podstawowa metoda

class Pies:
    def szczekaj(self):
        # self - odwołanie do instancji obiektu
        print("Hau hau!")

azor = Pies()
azor.szczekaj()  # Hau hau!

Ważne: Pierwszy parametr metody to zawsze self (konwencja).

Metody z parametrami

class Kalkulator:
    def dodaj(self, a, b):
        return a + b
    
    def odejmij(self, a, b):
        return a - b

kalk = Kalkulator()
print(kalk.dodaj(5, 3))     # 8
print(kalk.odejmij(10, 4))  # 6

Metody korzystające z atrybutów

class Osoba:
    imie = "Jan"
    
    def przywitaj(self):
        # self.imie - dostęp do atrybutu
        print(f"Cześć, jestem {self.imie}!")

osoba = Osoba()
osoba.przywitaj()  # Cześć, jestem Jan!

Konstruktor – init

Konstruktor to specjalna metoda wywoływana automatycznie przy tworzeniu obiektu.

Podstawowy konstruktor

class Kot:
    def __init__(self, imie, wiek):
        """Konstruktor - inicjalizuje obiekt"""
        self.imie = imie  # Atrybut instancji
        self.wiek = wiek
    
    def info(self):
        print(f"{self.imie} ma {self.wiek} lat")

# Podczas tworzenia obiekt wywołuje __init__
mruczek = Kot("Mruczek", 3)
mruczek.info()  # Mruczek ma 3 lata

puszek = Kot("Puszek", 5)
puszek.info()  # Puszek ma 5 lat

Konstruktor z wartościami domyślnymi

class Gracz:
    def __init__(self, nick, hp=100, lvl=1):
        self.nick = nick
        self.hp = hp
        self.lvl = lvl
    
    def __str__(self):
        return f"{self.nick} (HP: {self.hp}, Lvl: {self.lvl})"

# Z domyślnymi wartościami
gracz1 = Gracz("Warrior")
print(gracz1)  # Warrior (HP: 100, Lvl: 1)

# Nadpisanie domyślnych
gracz2 = Gracz("Mage", hp=80, lvl=5)
print(gracz2)  # Mage (HP: 80, Lvl: 5)

Metody magiczne (dunder methods)

Metody magiczne to specjalne metody otoczone podwójnymi podkreślnikami: __nazwa__.

str – reprezentacja tekstowa

class Ksiazka:
    def __init__(self, tytul, autor):
        self.tytul = tytul
        self.autor = autor
    
    def __str__(self):
        """Wywoływane przez print() i str()"""
        return f'"{self.tytul}" - {self.autor}'

ksiazka = Ksiazka("Wiedźmin", "Andrzej Sapkowski")
print(ksiazka)  # "Wiedźmin" - Andrzej Sapkowski

repr – reprezentacja techniczna

class Ksiazka:
    def __init__(self, tytul, autor, rok):
        self.tytul = tytul
        self.autor = autor
        self.rok = rok
    
    def __str__(self):
        # Dla użytkownika
        return f'"{self.tytul}" - {self.autor} ({self.rok})'
    
    def __repr__(self):
        # Dla programisty/debugowania
        return f'Ksiazka(tytul="{self.tytul}", autor="{self.autor}", rok={self.rok})'

ksiazka = Ksiazka("Wiedźmin", "Sapkowski", 1990)
print(str(ksiazka))   # "Wiedźmin" - Sapkowski (1990)
print(repr(ksiazka))  # Ksiazka(tytul="Wiedźmin", autor="Sapkowski", rok=1990)

len – długość obiektu

class Playlista:
    def __init__(self, nazwa):
        self.nazwa = nazwa
        self.utwory = []
    
    def dodaj(self, utwor):
        self.utwory.append(utwor)
    
    def __len__(self):
        """Wywoływane przez len()"""
        return len(self.utwory)

pl = Playlista("Rock")
pl.dodaj("Song 1")
pl.dodaj("Song 2")
print(len(pl))  # 2

Operatory porównania

class Osoba:
    def __init__(self, imie, wiek):
        self.imie = imie
        self.wiek = wiek
    
    def __eq__(self, other):
        """Operator =="""
        return self.wiek == other.wiek
    
    def __lt__(self, other):
        """Operator <"""
        return self.wiek < other.wiek
    
    def __gt__(self, other):
        """Operator >"""
        return self.wiek > other.wiek

anna = Osoba("Anna", 25)
jan = Osoba("Jan", 30)

print(anna < jan)   # True
print(jan > anna)   # True
print(anna == jan)  # False

getitem i setitem – indeksowanie

class Lista:
    def __init__(self):
        self.dane = []
    
    def __getitem__(self, index):
        """Wywoływane przez lista[index]"""
        return self.dane[index]
    
    def __setitem__(self, index, value):
        """Wywoływane przez lista[index] = value"""
        self.dane[index] = value
    
    def dodaj(self, element):
        self.dane.append(element)

lista = Lista()
lista.dodaj("Python")
lista.dodaj("Java")
lista.dodaj("C++")

print(lista[0])  # Python - wywołuje __getitem__
lista[1] = "JavaScript"  # Wywołuje __setitem__
print(lista[1])  # JavaScript

Operatory matematyczne

class Wektor:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        """Operator +"""
        return Wektor(self.x + other.x, self.y + other.y)
    
    def __mul__(self, skalar):
        """Operator *"""
        return Wektor(self.x * skalar, self.y * skalar)
    
    def __str__(self):
        return f"({self.x}, {self.y})"

v1 = Wektor(1, 2)
v2 = Wektor(3, 4)

v3 = v1 + v2  # Wywołuje __add__
print(v3)     # (4, 6)

v4 = v1 * 3   # Wywołuje __mul__
print(v4)     # (3, 6)

call – obiekt jako funkcja

class Mnoznik:
    def __init__(self, mnoznik):
        self.mnoznik = mnoznik
    
    def __call__(self, x):
        """Pozwala wywołać obiekt jak funkcję"""
        return x * self.mnoznik

razy_2 = Mnoznik(2)
razy_10 = Mnoznik(10)

print(razy_2(5))   # 10
print(razy_10(5))  # 50

Tabela metod magicznych

Modyfikatory dostępu

Python nie ma prawdziwych modyfikatorów dostępu jak Java czy C++. Używa konwencji:

Publiczne (brak podkreślników)

class Osoba:
    def __init__(self, imie):
        self.imie = imie  # Publiczne

osoba = Osoba("Jan")
print(osoba.imie)  # OK
osoba.imie = "Anna"  # OK

Chronione (jeden podkreślnik)

class Osoba:
    def __init__(self, imie):
        self._imie = imie  # Chronione (konwencja)
    
    def _metoda_wewnetrzna(self):
        print("Używana tylko wewnątrz")

osoba = Osoba("Jan")
print(osoba._imie)  # Technicznie działa, ale nie powinieneś

Konwencja: _nazwa sugeruje „nie używaj tego poza klasą”.

Prywatne (dwa podkreślniki)

class Osoba:
    def __init__(self, imie):
        self.__imie = imie  # Prywatne
    
    def __metoda_prywatna(self):
        print("Prywatna metoda")
    
    def pokaz_imie(self):
        print(self.__imie)  # OK wewnątrz klasy

osoba = Osoba("Jan")
# print(osoba.__imie)  # AttributeError

# Python zmienia nazwę (name mangling)
print(osoba._Osoba__imie)  # Działa, ale nie rób tego!

Name mangling: Python zmienia __nazwa na _NazwaKlasy__nazwa.

Dziedziczenie

Dziedziczenie pozwala tworzyć nowe klasy bazując na istniejących.

Podstawowe dziedziczenie

class Zwierze:
    def __init__(self, imie):
        self.imie = imie
    
    def dzwiek(self):
        return "Jakiś dźwięk"

class Pies(Zwierze):  # Pies dziedziczy po Zwierze
    def dzwiek(self):
        return "Hau hau!"

class Kot(Zwierze):
    def dzwiek(self):
        return "Miau!"

pies = Pies("Azor")
kot = Kot("Mruczek")

print(f"{pies.imie}: {pies.dzwiek()}")  # Azor: Hau hau!
print(f"{kot.imie}: {kot.dzwiek()}")    # Mruczek: Miau!

super() – wywołanie metod rodzica

class Pojazd:
    def __init__(self, marka):
        self.marka = marka
        print(f"Utworzono pojazd: {marka}")
    
    def info(self):
        return f"Pojazd marki {self.marka}"

class Samochod(Pojazd):
    def __init__(self, marka, model):
        super().__init__(marka)  # Wywołanie konstruktora rodzica
        self.model = model
    
    def info(self):
        # Wywołanie metody rodzica
        podstawowa_info = super().info()
        return f"{podstawowa_info}, model {self.model}"

auto = Samochod("Toyota", "Corolla")
# Utworzono pojazd: Toyota
print(auto.info())
# Pojazd marki Toyota, model Corolla

isinstance() – sprawdzanie typu

class Zwierze:
    pass

class Pies(Zwierze):
    pass

class Kot(Zwierze):
    pass

pies = Pies()
kot = Kot()

print(isinstance(pies, Pies))      # True
print(isinstance(pies, Zwierze))   # True (dziedziczy!)
print(isinstance(pies, Kot))       # False
print(isinstance(pies, object))    # True (wszystko dziedziczy po object)

Wielodziedziczenie

Python obsługuje dziedziczenie z wielu klas (ostrożnie!).

class Latanie:
    def lataj(self):
        print("Lecę!")

class Plywanie:
    def plywaj(self):
        print("Pływam!")

class Kaczka(Latanie, Plywanie):
    def kwacz(self):
        print("Kwa kwa!")

kaczka = Kaczka()
kaczka.lataj()   # Lecę!
kaczka.plywaj()  # Pływam!
kaczka.kwacz()   # Kwa kwa!

Kompozycja vs Dziedziczenie

W OOP (programowaniu obiektowym) dziedziczenie i kompozycja to dwa sposoby budowania relacji między klasami.

Zadaj sobie pytanie:

Czy mogę powiedzieć: X jest Y

Przykłady:

• Pies jest zwierzęciem – tak
• Student jest człowiekiem – tak
• Samochód jest pojazdem – tak

→ dziedziczenie

Czy mogę powiedzieć: X ma Y

Przykłady:

• Samochód ma silnik – tak
• Dom ma okna – tak
• Komputer ma procesor – tak

→ kompozycja

Kiedy używać dziedziczenia?

Relacja „JEST” (is-a):

• Pies JEST Zwierzęciem
• Samochód JEST Pojazdem

class Zwierze:
    pass

class Pies(Zwierze):  # Pies JEST Zwierzęciem
    pass

Kiedy używać kompozycji?

Relacja „MA” (has-a):

• Samochód MA Silnik
• Osoba MA Adres

class Silnik:
    def __init__(self, moc):
        self.moc = moc
    
    def uruchom(self):
        print(f"Silnik {self.moc}KM uruchomiony")

class Samochod:
    def __init__(self, marka, moc_silnika):
        self.marka = marka
        self.silnik = Silnik(moc_silnika)  # MA silnik
    
    def uruchom(self):
        print(f"Uruchamiam {self.marka}")
        self.silnik.uruchom()

auto = Samochod("Toyota", 150)
auto.uruchom()
# Uruchamiam Toyota
# Silnik 150KM uruchomiony

Problem z dziedziczeniem

# ŹLE - nadmierne dziedziczenie
class Ptak:
    def lataj(self):
        print("Lecę")

class Pingwin(Ptak):
    # Problem! Pingwin nie lata, ale dziedziczy lataj()
    pass

pingwin = Pingwin()
pingwin.lataj()  # Pingwin lata? To błąd logiczny!

Rozwiązanie – kompozycja

# DOBRZE - kompozycja
class Latanie:
    def lataj(self):
        print("Lecę w powietrzu")

class Plywanie:
    def plywaj(self):
        print("Pływam w wodzie")

class Orzel:
    def __init__(self):
        self.latanie = Latanie()  # MA zdolność latania
    
    def wykonaj_lot(self):
        self.latanie.lataj()

class Pingwin:
    def __init__(self):
        self.plywanie = Plywanie()  # MA zdolność pływania
    
    def wykonaj_plywanie(self):
        self.plywanie.plywaj()

orzel = Orzel()
orzel.wykonaj_lot()  # Lecę w powietrzu

pingwin = Pingwin()
pingwin.wykonaj_plywanie()  # Pływam w wodzie

Złota zasada: „Prefer composition over inheritance” (Preferuj kompozycję nad dziedziczeniem)

Klasy abstrakcyjne

Klasa abstrakcyjna to klasa, która:

• Nie może być instancjonowana (nie można z niej tworzyć obiektów)
• Służy jako szablon dla klas potomnych
• Może zawierać metody abstrakcyjne (bez implementacji)

from abc import ABC, abstractmethod

class Zwierze(ABC):
    def __init__(self, imie):
        self.imie = imie
    
    @abstractmethod
    def dzwiek(self):
        """Metoda abstrakcyjna - musi być zaimplementowana"""
        pass
    
    def przedstaw_sie(self):
        print(f"Jestem {self.imie} i mówię {self.dzwiek()}")

# zwierze = Zwierze("Test")  # TypeError! Nie można utworzyć

class Pies(Zwierze):
    def dzwiek(self):
        return "Hau hau!"

class Kot(Zwierze):
    def dzwiek(self):
        return "Miau!"

pies = Pies("Azor")
pies.przedstaw_sie()  # Jestem Azor i mówię Hau hau!

Dekorator @property

@property pozwala traktować metodę jak atrybut.

class Prostokat:
    def __init__(self, szerokosc, wysokosc):
        self.szerokosc = szerokosc
        self.wysokosc = wysokosc
    
    @property
    def pole(self):
        """Metoda jako właściwość"""
        return self.szerokosc * self.wysokosc
    
    @property
    def obwod(self):
        return 2 * (self.szerokosc + self.wysokosc)

prostokat = Prostokat(5, 10)
# Wywołanie bez nawiasów!
print(prostokat.pole)    # 50
print(prostokat.obwod)   # 30

Getter i setter

class Osoba:
    def __init__(self, imie, wiek):
        self._imie = imie
        self._wiek = wiek
    
    @property
    def wiek(self):
        """Getter"""
        return self._wiek
    
    @wiek.setter
    def wiek(self, wartosc):
        """Setter z walidacją"""
        if wartosc < 0:
            raise ValueError("Wiek nie może być ujemny!")
        self._wiek = wartosc

osoba = Osoba("Jan", 25)
print(osoba.wiek)  # 25 - wywołuje getter

osoba.wiek = 30    # Wywołuje setter
print(osoba.wiek)  # 30

# osoba.wiek = -5  # ValueError!

Paradygmaty OOP

1. Abstrakcja

Ukrywanie skomplikowanych szczegółów, pokazywanie tylko tego co potrzebne.

class Telefon:
    def __init__(self, model):
        self.model = model
        self.__system = "Android"  # Ukryte
    
    def dzwon(self, numer):
        """Prosty interfejs - nie musisz wiedzieć jak działa"""
        self.__polacz_z_sieciami()
        self.__wyslij_sygnal(numer)
        print(f"Dzwonię na {numer}")
    
    def __polacz_z_sieciami(self):
        """Ukryte szczegóły"""
        pass
    
    def __wyslij_sygnal(self, numer):
        """Ukryte szczegóły"""
        pass

telefon = Telefon("iPhone")
telefon.dzwon("123456789")  # Prosta, ukrywa złożoność

2. Enkapsulacja

Ukrywanie danych i kontrolowanie dostępu do nich.

class KontoBankowe:
    def __init__(self, saldo):
        self.__saldo = saldo  # Prywatne - enkapsulacja
    
    def wplata(self, kwota):
        if kwota > 0:
            self.__saldo += kwota
            return True
        return False
    
    def wyplata(self, kwota):
        if 0 < kwota <= self.__saldo:
            self.__saldo -= kwota
            return True
        return False
    
    @property
    def saldo(self):
        """Kontrolowany dostęp tylko do odczytu"""
        return self.__saldo

konto = KontoBankowe(1000)
konto.wplata(500)
print(konto.saldo)  # 1500
# konto.__saldo = 999999  # Nie działa - chronione!

3. Dziedziczenie

Tworzenie hierarchii klas, współdzielenie kodu.

class Pojazd:
    def __init__(self, marka):
        self.marka = marka
    
    def info(self):
        return f"Pojazd {self.marka}"

class Samochod(Pojazd):
    def __init__(self, marka, model):
        super().__init__(marka)
        self.model = model
    
    def info(self):
        return f"Samochód {self.marka} {self.model}"

class Motocykl(Pojazd):
    def info(self):
        return f"Motocykl {self.marka}"

4. Polimorfizm

Różne obiekty reagują na tę samą metodę w różny sposób.

class Pies:
    def dzwiek(self):
        return "Hau hau!"

class Kot:
    def dzwiek(self):
        return "Miau!"

class Krowa:
    def dzwiek(self):
        return "Muuu!"

# Polimorfizm - ta sama metoda, różne zachowania
zwierzeta = [Pies(), Kot(), Krowa()]

for zwierze in zwierzeta:
    print(zwierze.dzwiek())
# Hau hau!
# Miau!
# Muuu!

Przykłady praktyczne

Zadanie 1: Klasa Trójkąt

import random

class Trojkat:
    def __init__(self):
        self.wysokosc = random.randint(1, 20)
        self.podstawa = random.randint(1, 20)
    
    def oblicz_pole(self):
        return (self.podstawa * self.wysokosc) / 2
    
    def __str__(self):
        return f"Trójkąt(podstawa={self.podstawa}, wysokość={self.wysokosc})"

trojkat1 = Trojkat()
trojkat2 = Trojkat()

pole1 = trojkat1.oblicz_pole()
pole2 = trojkat2.oblicz_pole()

print(f"{trojkat1} - Pole: {pole1} cm²")
print(f"{trojkat2} - Pole: {pole2} cm²")

if pole1 > pole2:
    print(f"Trójkąt 1 jest większy")
else:
    print(f"Trójkąt 2 jest większy")

Zadanie 2: Okrąg i Koło

from math import pi

class Okrag:
    def __init__(self, promien):
        self.promien = promien
    
    def obwod(self):
        return 2 * pi * self.promien

class Kolo(Okrag):
    def pole(self):
        return pi * self.promien ** 2

kolo = Kolo(10)
print(f"Obwód: {kolo.obwod():.2f}")
print(f"Pole: {kolo.pole():.2f}")

Zadanie 3: Gracz RPG

import random

class Gracz:
    def __init__(self, nick):
        self.nick = nick
        self.poziom = 1
        self.hp = 100
        self.exp = 0
    
    def atak(self, cel):
        obrazenia = random.randint(10, 25)
        print(f"{self.nick} atakuje {cel.nick}!")
        cel.otrzymaj_obrazenia(obrazenia)
    
    def otrzymaj_obrazenia(self, ilosc):
        self.hp -= ilosc
        if self.hp < 0:
            self.hp = 0
        print(f"{self.nick} ma {self.hp} HP")
    
    def zdobadz_exp(self, ilosc):
        self.exp += ilosc
        if self.exp >= 100:
            self.poziom += 1
            self.exp = 0
            print(f"{self.nick} awansował na poziom {self.poziom}!")
    
    def __str__(self):
        return f"{self.nick} | Poziom: {self.poziom} | HP: {self.hp} | EXP: {self.exp}"

gracz1 = Gracz("Warrior")
gracz2 = Gracz("Mage")
gracz1.atak(gracz2)

Po co programowanie obiektowe?

1. Organizacja i modularność

Kod podzielony na logiczne części (klasy) jest bardziej przejrzysty.

# Bez OOP - wszystko w jednym miejscu
gracz_imie = "Jan"
gracz_hp = 100
gracz_lvl = 1

przeciwnik_imie = "Goblin"
przeciwnik_hp = 50
przeciwnik_lvl = 1

# Z OOP - każdy obiekt osobno
class Postac:
    def __init__(self, imie, hp, lvl):
        self.imie = imie
        self.hp = hp
        self.lvl = lvl

gracz = Postac("Jan", 100, 1)
przeciwnik = Postac("Goblin", 50, 1)

2. Reużywalność kodu

Możesz wykorzystywać klasy wielokrotnie.

class Pojazd:
    def __init__(self, marka):
        self.marka = marka
    
    def jedz(self):
        print(f"{self.marka} jedzie")

# Możesz utworzyć wiele obiektów tej samej klasy
samochod1 = Pojazd("Toyota")
samochod2 = Pojazd("BMW")
samochod3 = Pojazd("Audi")

3. Łatwiejsze rozwijanie aplikacji

Zmiany w jednej klasie nie wpływają na inne.

# Dodanie nowej funkcjonalności tylko w jednym miejscu
class Samochod:
    def __init__(self, marka):
        self.marka = marka
        self.predkosc = 0
    
    def przyspiesz(self, ile):
        self.predkosc += ile
        print(f"Prędkość: {self.predkosc} km/h")

4. Enkapsulacja – ukrywanie szczegółów

Dane są chronione, dostęp tylko przez metody.

class KontoBankowe:
    def __init__(self, saldo):
        self.__saldo = saldo  # Prywatne
    
    def wplac(self, kwota):
        if kwota > 0:
            self.__saldo += kwota
    
    def pobierz_saldo(self):
        return self.__saldo

# Nie można bezpośrednio zmieniać salda
konto = KontoBankowe(1000)
konto.wplac(500)  # OK
# konto.__saldo = 999999  # Nie zadziała!

5. Naturalne odwzorowanie rzeczywistości

OOP naśladuje sposób myślenia o świecie.

class Kot:
    def __init__(self, imie, kolor):
        self.imie = imie
        self.kolor = kolor
    
    def miaucz(self):
        print(f"{self.imie}: Miauuu!")

mruczek = Kot("Mruczek", "rudy")
mruczek.miaucz()  # Mruczek: Miauuu!

Podsumowanie

Podstawy OOP:

• Klasa – szablon obiektu
• Obiekt – instancja klasy
• Atrybuty – dane obiektu
• Metody – funkcje obiektu
• self – odniesienie do instancji

Metody specjalne:

• __init__ – konstruktor
• __str__ – reprezentacja tekstowa
• __len__ – długość
• __eq__, __lt__, __gt__ – porównania
• __add__, __mul__ – operatory matematyczne
• __getitem__, __setitem__ – indeksowanie

Zaawansowane:

• Dziedziczenie – tworzenie hierarchii klas
• super() – wywołanie metod rodzica
• Kompozycja – obiekty zawierają inne obiekty
• Klasy abstrakcyjne – szablony dla klas potomnych
• @property – metody jako atrybuty

Paradygmaty OOP:

• Abstrakcja – ukrywanie szczegółów
• Enkapsulacja – ochrona danych
• Dziedziczenie – współdzielenie kodu
• Polimorfizm – jedna metoda, różne zachowania

Dobre praktyki:

• Jedna klasa = jedna odpowiedzialność
• Preferuj kompozycję nad dziedziczeniem
• Używaj @property dla computed properties
• Dokumentuj klasy docstringami
• Nazwy klas PascalCase

Ćwiczenia – Programowanie obiektowe

Podstawy klas i obiektów

1. Stwórz klasę Punkt z atrybutami x i y. Dodaj metodę wyświetlającą współrzędne.
2. Stwórz klasę Prostokat z atrybutami szerokość i wysokość. Dodaj metody obliczające pole i obwód.
3. Stwórz klasę Kolo z atrybutem promień. Dodaj metody obliczające pole i obwód.
4. Stwórz klasę Student z atrybutami: imię, nazwisko, numer_indeksu. Dodaj metodę wyświetlającą pełne dane.
5. Stwórz klasę Ksiazka z atrybutami: tytuł, autor, rok_wydania, liczba_stron.

Konstruktor init

1. Stwórz klasę Samochod z konstruktorem przyjmującym markę, model i rok_produkcji.
2. Stwórz klasę Pracownik z konstruktorem ustawiającym imię, nazwisko, pensję.
3. Stwórz klasę Uzytkownik z konstruktorem i domyślnymi wartościami (aktywny=True, rola=”user”).
4. Stwórz klasę Produkt z konstruktorem walidującym cenę (musi być > 0).
5. Stwórz klasę Data z konstruktorem przyjmującym dzień, miesiąc, rok i walidującym je.

Metody

1. Stwórz klasę Licznik z metodami zwiększ(), zmniejsz(), reset(), pokaz_wartosc().
2. Stwórz klasę Temperatura z metodą konwertującą Celsjusz na Fahrenheit.
3. Stwórz klasę Haslo z metodą sprawdzającą siłę hasła (długość, znaki specjalne).
4. Stwórz klasę Email z metodą walidującą adres email (@, kropka).
5. Stwórz klasę Kalkulator z metodami: dodaj, odejmij, pomnoz, podziel.

Metody str i repr

1. Dodaj __str__ do klasy Osoba wyświetlający „Imię Nazwisko, wiek: X lat”.
2. Dodaj __str__ i __repr__ do klasy Produkt.
3. Stwórz klasę Czas (godzina, minuta) z __str__ formatującym na „HH:MM”.
4. Stwórz klasę Data z __str__ formatującym na „DD/MM/YYYY”.
5. Stwórz klasę Ulamek (licznik, mianownik) z czytelnym __str__.

Atrybuty prywatne

1. Stwórz klasę KontoBankowe z prywatnym atrybutem __saldo.
2. Dodaj do KontoBankowe metody wplata() i wyplata() z walidacją.
3. Stwórz klasę Haslo z prywatnym atrybutem __haslo i metodą sprawdz().
4. Stwórz klasę Uzytkownik z prywatnym __email i publiczną metodą get_email().
5. Stwórz klasę Sejf z prywatnym kodem i metodą otwierania.

Metody magiczne – porównania

1. Dodaj __eq__ do klasy Osoba (porównanie po wieku).
2. Dodaj __lt__ i __gt__ do klasy Produkt (porównanie po cenie).
3. Stwórz klasę Ocena z metodami porównania (__eq__, __lt__, __gt__).
4. Stwórz klasę Data z możliwością porównywania dat.
5. Stwórz klasę Prostokat z porównywaniem pól powierzchni.

Metody magiczne – operatory

1. Dodaj __add__ do klasy Wektor2D (dodawanie wektorów).
2. Dodaj __mul__ do klasy Wektor2D (mnożenie przez skalar).
3. Stwórz klasę Czas z możliwością dodawania (__add__).
4. Stwórz klasę Pieniadze z możliwością dodawania i odejmowania.
5. Stwórz klasę Macierz2x2 z operacjami dodawania i mnożenia.

Metody magiczne – kolekcje

1. Stwórz klasę Lista z __len__ zwracającym liczbę elementów.
2. Dodaj __getitem__ do klasy Lista (dostęp przez indeks).
3. Dodaj __setitem__ do klasy Lista (ustawianie przez indeks).
4. Stwórz klasę Slownik z __getitem__ i __setitem__.
5. Stwórz klasę Playlista z __len__ i iteracją po utworach.

@property

1. Stwórz klasę Prostokat z @property dla pola powierzchni.
2. Stwórz klasę Kolo z @property dla pola i obwodu.
3. Stwórz klasę Osoba z @property dla pełnego imienia (imię + nazwisko).
4. Stwórz klasę Temperatura z @property dla Fahrenheita (obliczane z Celsjusza).
5. Stwórz klasę Produkt z @property i setterem dla ceny (walidacja > 0).

Dziedziczenie – podstawy

1. Stwórz klasę bazową Zwierze i klasy potomne Pies, Kot.
2. Stwórz klasę Pojazd i klasy potomne Samochod, Motocykl.
3. Stwórz klasę Figura i klasy potomne Kwadrat, Kolo.
4. Stwórz klasę Osoba i klasy potomne Student, Pracownik.
5. Stwórz klasę Konto i klasy potomne KontoOszczednosciowe, KontoBiezace.

Dziedziczenie z super()

1. W klasie Samochod (dziedziczy Pojazd) użyj super() w konstruktorze.
2. Nadpisz metodę w klasie potomnej i wywołaj metodę rodzica przez super().
3. Stwórz łańcuch dziedziczenia: Zwierze → Ssak → Pies, użyj super().
4. Rozszerz konstruktor klasy potomnej o dodatkowe atrybuty używając super().
5. Stwórz klasę PracownikZPremią dziedziczącą Pracownik i rozszerzającą metodę oblicz_wynagrodzenie().

Kompozycja

1. Stwórz klasę Silnik i klasę Samochod zawierającą obiekt Silnik.
2. Stwórz klasę Adres i klasę Osoba zawierającą obiekt Adres.
3. Stwórz klasę Telefon i klasę Kontakt zawierającą listę telefonów.
4. Stwórz klasę Skladnik i klasę Przepis zawierającą listę składników.
5. Stwórz klasę Gracz i klasę Druzyna zawierającą listę graczy.

Klasy abstrakcyjne

1. Stwórz abstrakcyjną klasę Figura z metodą abstrakcyjną pole().
2. Stwórz abstrakcyjną klasę Platnosc z metodą abstrakcyjną przetworz().
3. Stwórz abstrakcyjną klasę Zwierze z metodą abstrakcyjną dzwiek().
4. Stwórz abstrakcyjną klasę Pojazd z metodami abstrakcyjnymi jedz() i zatrzymaj().
5. Stwórz abstrakcyjną klasę Baza z metodami abstrakcyjnymi polacz() i rozlacz().

isinstance() i type()

1. Sprawdź isinstance() dla obiektów różnych klas z dziedziczeniem.
2. Napisz funkcję przyjmującą tylko obiekty typu Prostokat (walidacja isinstance).
3. Napisz funkcję działającą różnie dla różnych typów (isinstance).
4. Sprawdź czy obiekt jest instancją klasy bazowej lub potomnej.
5. Użyj isinstance() do walidacji argumentów metody.

Zadania praktyczne – Biblioteka

1. Stwórz klasę Ksiazka z atrybutami i metodą __str__.
2. Stwórz klasę Biblioteka przechowującą listę książek.
3. Dodaj metody dodaj_ksiazke(), usun_ksiazke() do Biblioteki.
4. Dodaj metodę wyszukaj_po_tytule() do Biblioteki.
5. Dodaj metodę wyszukaj_po_autorze() do Biblioteki.
6. Dodaj atrybut wypozyczona do Ksiazki i metody wypozycz()/zwroc().
7. Dodaj do Biblioteki metodę dostepne_ksiazki().
8. Dodaj licznik wypożyczeń do Ksiazki.
9. Dodaj metodę najpopularniejsza_ksiazka() do Biblioteki.
10. Zapisz bibliotekę do pliku JSON.

Zadania praktyczne – Sklep

1. Stwórz klasę Produkt (nazwa, cena, ilosc_w_magazynie).
2. Stwórz klasę Koszyk przechowującą produkty do zakupu.
3. Dodaj metody dodaj_do_koszyka(), usun_z_koszyka().
4. Dodaj metodę oblicz_wartosc_koszyka().
5. Dodaj metodę zrealizuj_zamowienie() (zmniejsza stan magazynowy).
6. Dodaj kategorie produktów (kompozycja lub dziedziczenie).
7. Dodaj kody rabatowe (klasa Rabat).
8. Dodaj historię zamówień (klasa Zamowienie).
9. Stwórz system logowania (klasa Uzytkownik).
10. Dodaj oceny produktów.

Zadania praktyczne – Gra RPG

1. Stwórz klasę Postac (imię, hp, atak, obrona).
2. Dodaj metody atakuj() i otrzymaj_obrazenia().
3. Stwórz klasy Wojownik, Mag, Lucznik dziedziczące po Postac.
4. Dodaj system poziomów i doświadczenia.
5. Dodaj ekwipunek (kompozycja – klasa Przedmiot).
6. Dodaj broń zwiększającą atak (klasa Bron).
7. Dodaj zbroje zwiększające obronę (klasa Zbroja).
8. Dodaj umiejętności specjalne dla każdej klasy postaci.
9. Stwórz system walki turowej.
10. Dodaj zapisywanie stanu gry do pliku.

Zadania zaawansowane

1. Stwórz system zarządzania studentami i kursami (wiele klas współpracujących).
2. Stwórz symulator banku z różnymi typami kont.
3. Stwórz system rezerwacji hotelu (pokoje, rezerwacje, goście).
4. Stwórz prosty system CMS (artykuły, autorzy, kategorie).
5. Stwórz system zarządzania projektami (projekty, zadania, użytkownicy).
6. Stwórz symulator farmy (rośliny, zwierzęta, zasoby).
7. Stwórz system biblioteki muzycznej (utwory, albumy, artyści, playlisty).
8. Stwórz prosty system e-learningowy (kursy, lekcje, quizy).
9. Stwórz system zarządzania restauracją (menu, zamówienia, stoły).
10. Stwórz grę tekstową z systemem lokacji, przedmiotów i postaci.

Artykuł 16. Python – obiektowo pochodzi z serwisu Kama Kaczmarek.

Dlaczego ważna jest obsługa błędów?

• Program nie kończy działania przy błędzie
• Możesz reagować na błędy (np. prosić użytkownika o poprawne dane)
• Lepsze doświadczenie użytkownika
• Łatwiejsze debugowanie
• Profesjonalny kod produkcyjny

Przykład bez obsługi błędu:

# Program się wysypie jeśli plik nie istnieje
with open("nieistniejacy.txt") as file:
    content = file.read()
# FileNotFoundError - program kończy działanie

Z obsługą błędu:

# Program kontynuuje działanie
try:
    with open("nieistniejacy.txt") as file:
        content = file.read()
except FileNotFoundError:
    print("Plik nie istnieje, tworzę nowy")
    with open("nieistniejacy.txt", "w") as file:
        file.write("Nowa zawartość")

Struktura try-except

Podstawowa składnia

try:
    # Kod, który może wywołać błąd
    ryzykowna_operacja()
except:
    # Kod wykonywany gdy wystąpi błąd
    obsluga_bledu()

Pełna struktura

try:
    # Spróbuj wykonać ten kod
    kod_ktory_moze_wywolac_blad()
except TypBledu:
    # Wykonaj gdy wystąpi konkretny błąd
    obsluga_bledu()
else:
    # Wykonaj TYLKO jeśli NIE było błędu
    kod_gdy_sukces()
finally:
    # Wykonaj ZAWSZE (bez względu na błędy)
    sprzatanie()

Kolejność:

1. try – zawsze jako pierwsze
2. except – jeden lub więcej
3. else – opcjonalnie, tylko jeśli nie było błędu
4. finally – opcjonalnie, wykonuje się zawsze

Podstawowe typy błędów

FileNotFoundError – brak pliku

# Błąd: próba otwarcia nieistniejącego pliku
with open("nieistniejacy.txt") as file:
    content = file.read()
# FileNotFoundError: [Errno 2] No such file or directory: 'nieistniejacy.txt'

Obsługa:

try:
    with open("nieistniejacy.txt") as file:
        content = file.read()
except FileNotFoundError:
    print("Plik nie istnieje!")

KeyError – brak klucza w słowniku

# Błąd: próba dostępu do nieistniejącego klucza
slownik = {"imie": "Jan", "wiek": 25}
miasto = slownik["miasto"]
# KeyError: 'miasto'

Obsługa:

slownik = {"imie": "Jan", "wiek": 25}

try:
    miasto = slownik["miasto"]
except KeyError:
    print("Klucz 'miasto' nie istnieje")
    miasto = "Nieznane"

IndexError – indeks poza zakresem

# Błąd: próba dostępu do nieistniejącego indeksu
lista = ["Python", "Java", "C++"]
jezyk = lista[5]
# IndexError: list index out of range

Obsługa:

lista = ["Python", "Java", "C++"]

try:
    jezyk = lista[5]
except IndexError:
    print("Indeks poza zakresem listy")

ValueError – nieprawidłowa wartość

# Błąd: konwersja niepoprawnej wartości
wiek = int("dwadzieścia")
# ValueError: invalid literal for int() with base 10: 'dwadzieścia'

Obsługa:

try:
    wiek = int(input("Podaj wiek: "))
except ValueError:
    print("To nie jest liczba!")
    wiek = 0

TypeError – nieprawidłowy typ

# Błąd: dodawanie string + int
tekst = "Python"
wynik = tekst + 5
# TypeError: can only concatenate str (not "int") to str

Obsługa:

tekst = "Python"

try:
    wynik = tekst + 5
except TypeError:
    print("Nie można dodać liczby do tekstu")
    wynik = tekst + str(5)

ZeroDivisionError – dzielenie przez zero

# Błąd: dzielenie przez 0
wynik = 10 / 0
# ZeroDivisionError: division by zero

Obsługa:

try:
    wynik = 10 / 0
except ZeroDivisionError:
    print("Nie można dzielić przez zero!")
    wynik = None

Przechwytywanie konkretnych błędów

ŹLE – ogólny except

# ŹLE - łapie WSZYSTKIE błędy
try:
    with open("plik.txt") as file:
        content = file.read()
    slownik = {"klucz": "wartość"}
    print(slownik["nieistniejacy"])
except:
    print("Jakiś błąd")  # Który? Nie wiadomo!

Problemy:

• Nie wiesz jaki błąd wystąpił
• Trudno debugować
• Możesz ukryć poważne błędy
• Nie możesz różnie reagować na różne błędy

DOBRZE – konkretne except

# DOBRZE - konkretne błędy
try:
    with open("plik.txt") as file:
        content = file.read()
    slownik = {"klucz": "wartość"}
    print(slownik["nieistniejacy"])
except FileNotFoundError:
    print("Plik nie istnieje")
except KeyError as e:
    print(f"Klucz {e} nie istnieje w słowniku")

Wiele except

Możesz mieć wiele bloków except dla różnych błędów.

try:
    liczba = int(input("Podaj liczbę: "))
    wynik = 100 / liczba
    print(f"Wynik: {wynik}")
except ValueError:
    print("To nie jest liczba!")
except ZeroDivisionError:
    print("Nie można dzielić przez zero!")
except KeyboardInterrupt:
    print("\nPrzerwano przez użytkownika")

Przypisanie błędu do zmiennej

try:
    slownik = {"imie": "Jan"}
    print(slownik["nazwisko"])
except KeyError as error:
    print(f"Błąd: brak klucza '{error}'")
    # Błąd: brak klucza 'nazwisko'

Inne przykłady:

try:
    plik = open("nieistniejacy.txt")
except FileNotFoundError as e:
    print(f"Szczegóły błędu: {e}")

try:
    wynik = int("abc")
except ValueError as e:
    print(f"Błąd konwersji: {e}")

Jeden except dla wielu błędów

# Obsługa wielu błędów tym samym kodem
try:
    # Kod ryzykowny
    operacja()
except (ValueError, TypeError, KeyError) as e:
    print(f"Wystąpił błąd: {e}")

Blok else

Blok else wykonuje się TYLKO gdy w try NIE było błędu.

try:
    with open("plik.txt") as file:
        content = file.read()
except FileNotFoundError:
    print("Plik nie istnieje")
else:
    # Wykonuje się TYLKO gdy plik został poprawnie otwarty
    print("Zawartość pliku:")
    print(content)

Przykład – walidacja danych

try:
    wiek = int(input("Podaj wiek: "))
except ValueError:
    print("To nie jest liczba!")
else:
    # Wykonuje się tylko gdy konwersja się powiodła
    if wiek >= 18:
        print("Jesteś pełnoletni")
    else:
        print("Jesteś niepełnoletni")

Blok finally

Blok finally wykonuje się ZAWSZE, niezależnie czy był błąd czy nie.

try:
    plik = open("dane.txt", "w")
    plik.write("Dane")
except IOError:
    print("Błąd zapisu")
else:
    print("Zapis udany")
finally:
    # ZAWSZE zamknij plik (czy był błąd czy nie)
    plik.close()
    print("Plik zamknięty")

Typowe zastosowania finally:

• Zamykanie plików
• Zamykanie połączeń z bazą danych
• Zwalnianie zasobów
• Sprzątanie po operacji

Przykład – finally zawsze się wykona

try:
    print("Try")
    raise ValueError("Błąd!")
except ValueError:
    print("Except - złapano błąd")
else:
    print("Else - nie wykona się (był błąd)")
finally:
    print("Finally - zawsze się wykona")

Wynik:

Try
Except - złapano błąd
Finally - zawsze się wykona

Wywoływanie własnych błędów – raise

Możesz ręcznie wywołać błąd używając słowa kluczowego raise.

Podstawowa składnia

raise TypBledu("Komunikat błędu")

Przykład – walidacja wzrostu

def oblicz_bmi(waga, wzrost):
    """Oblicza BMI z walidacją danych."""
    
    if wzrost > 3:
        raise ValueError("Wzrost człowieka nie przekracza 3 metrów!")
    
    if wzrost <= 0:
        raise ValueError("Wzrost musi być większy od 0!")
    
    if waga <= 0:
        raise ValueError("Waga musi być większa od 0!")
    
    bmi = waga / (wzrost ** 2)
    return bmi

# Użycie
try:
    wynik = oblicz_bmi(70, 3.5)
except ValueError as e:
    print(f"Błąd: {e}")
    # Błąd: Wzrost człowieka nie przekracza 3 metrów!

Przykład – funkcja z walidacją

def podziel(a, b):
    """Dzieli dwie liczby z walidacją."""
    
    if not isinstance(a, (int, float)):
        raise TypeError("Pierwszy argument musi być liczbą")
    
    if not isinstance(b, (int, float)):
        raise TypeError("Drugi argument musi być liczbą")
    
    if b == 0:
        raise ZeroDivisionError("Nie można dzielić przez zero")
    
    return a / b

# Użycie
try:
    wynik = podziel(10, 0)
except ZeroDivisionError as e:
    print(f"Błąd: {e}")

Re-raise – ponowne wywołanie błędu

try:
    wynik = 10 / 0
except ZeroDivisionError:
    print("Logowanie błędu...")
    raise  # Ponownie wywołaj ten sam błąd

Przykłady praktyczne

Przykład 1: Bezpieczny input liczby

def pobierz_liczbe(komunikat):
    """Pobiera liczbę od użytkownika z walidacją."""
    while True:
        try:
            liczba = float(input(komunikat))
            return liczba
        except ValueError:
            print("To nie jest liczba! Spróbuj ponownie.")

# Użycie
wiek = pobierz_liczbe("Podaj wiek: ")
print(f"Twój wiek: {wiek}")

Przykład 2: Kalkulator z obsługą błędów

def kalkulator():
    """Prosty kalkulator z obsługą błędów."""
    try:
        a = float(input("Pierwsza liczba: "))
        b = float(input("Druga liczba: "))
        operator = input("Operator (+, -, *, /): ")
        
        if operator == "+":
            wynik = a + b
        elif operator == "-":
            wynik = a - b
        elif operator == "*":
            wynik = a * b
        elif operator == "/":
            if b == 0:
                raise ZeroDivisionError("Nie można dzielić przez zero!")
            wynik = a / b
        else:
            raise ValueError(f"Nieznany operator: {operator}")
        
        print(f"Wynik: {wynik}")
        
    except ValueError as e:
        print(f"Błąd wartości: {e}")
    except ZeroDivisionError as e:
        print(f"Błąd dzielenia: {e}")
    except Exception as e:
        print(f"Nieoczekiwany błąd: {e}")

kalkulator()

Przykład 3: Bezpieczne otwieranie pliku

def wczytaj_plik(nazwa):
    """Bezpiecznie wczytuje plik."""
    try:
        with open(nazwa, 'r', encoding='utf-8') as plik:
            return plik.read()
    except FileNotFoundError:
        print(f"Plik {nazwa} nie istnieje")
        return None
    except PermissionError:
        print(f"Brak uprawnień do pliku {nazwa}")
        return None
    except Exception as e:
        print(f"Nieoczekiwany błąd: {e}")
        return None

# Użycie
zawartosc = wczytaj_plik("dane.txt")
if zawartosc:
    print(zawartosc)

Przykład 4: Słownik z domyślnymi wartościami

def pobierz_wartosc(slownik, klucz, domyslna=None):
    """Pobiera wartość ze słownika z obsługą błędów."""
    try:
        return slownik[klucz]
    except KeyError:
        print(f"Klucz '{klucz}' nie istnieje, zwracam wartość domyślną")
        return domyslna

# Użycie
dane = {"imie": "Jan", "wiek": 25}
miasto = pobierz_wartosc(dane, "miasto", "Warszawa")
print(f"Miasto: {miasto}")  # Miasto: Warszawa

Przykład 5: Lista z bezpiecznym dostępem

def bezpieczny_dostep(lista, indeks):
    """Bezpieczny dostęp do elementu listy."""
    try:
        return lista[indeks]
    except IndexError:
        print(f"Indeks {indeks} poza zakresem (0-{len(lista)-1})")
        return None
    except TypeError:
        print("Lista jest None lub indeks nie jest liczbą")
        return None

# Użycie
owoce = ["jabłko", "banan", "gruszka"]
owoc = bezpieczny_dostep(owoce, 5)
print(owoc)  # None

Przykład 6: Przechwyć błędy w funkcji make_pie

Problem:

fruits = ["Apple", "Pear", "Orange"]

def make_pie(index):
    fruit = fruits[index]
    print(fruit + " pie")

make_pie(4)  # IndexError!

Rozwiązanie:

fruits = ["Apple", "Pear", "Orange"]

def make_pie(index):
    try:
        fruit = fruits[index]
    except IndexError:
        print(f"Nie mamy takiego składnika. Wybierz 0-{len(fruits)-1}")
    else:
        print(fruit + " pie")

make_pie(4)  # Nie mamy takiego składnika. Wybierz 0-2
make_pie(1)  # Pear pie

Przykład 7: Zapobiegnij błędom w postach

Problem:

facebook_posts = [
    {'Likes': 21, 'Comments': 2},
    {'Likes': 13, 'Comments': 2, 'Shares': 1},
    {'Likes': 33, 'Comments': 8, 'Shares': 3},
    {'Comments': 4, 'Shares': 2},  # Brak 'Likes'
    {'Comments': 1, 'Shares': 1},  # Brak 'Likes'
    {'Likes': 19, 'Comments': 3}
]

total_likes = 0
for post in facebook_posts:
    total_likes = total_likes + post['Likes']  # KeyError!

Rozwiązanie:

facebook_posts = [
    {'Likes': 21, 'Comments': 2},
    {'Likes': 13, 'Comments': 2, 'Shares': 1},
    {'Likes': 33, 'Comments': 8, 'Shares': 3},
    {'Comments': 4, 'Shares': 2},
    {'Comments': 1, 'Shares': 1},
    {'Likes': 19, 'Comments': 3}
]

total_likes = 0

for post in facebook_posts:
    try:
        total_likes += post['Likes']
    except KeyError:
        # Post nie ma 'Likes', pomijamy
        pass

print(f"Łączna liczba polubień: {total_likes}")
# Łączna liczba polubień: 86

Alternatywne rozwiązanie (bez try-except):

total_likes = 0
for post in facebook_posts:
    total_likes += post.get('Likes', 0)
print(f"Łączna liczba polubień: {total_likes}")

Przykład 8: Program dzielący liczby

Wymagania:

• Pobierz dwie liczby
• Podziel pierwszą przez drugą
• Obsłuż: zły format, dzielenie przez 0, inne błędy

Rozwiązanie:

def dziel_liczby():
    """Program dzielący dwie liczby z pełną obsługą błędów."""
    try:
        # Pobranie liczb
        a = float(input("Podaj pierwszą liczbę: "))
        b = float(input("Podaj drugą liczbę: "))
        
        # Dzielenie
        wynik = a / b
        
    except ValueError:
        print("Błąd: Podano nieprawidłowy format liczby!")
    except ZeroDivisionError:
        print("Błąd: Nie można dzielić przez zero!")
    except KeyboardInterrupt:
        print("\nProgram przerwany przez użytkownika")
    except Exception as e:
        print(f"Nieoczekiwany błąd: {e}")
    else:
        print(f"Wynik dzielenia: {wynik:.2f}")
    finally:
        print("Koniec operacji")

# Uruchomienie
dziel_liczby()

Ulepszona wersja z pętlą:

def dziel_liczby_petla():
    """Wersja z ponawianiem przy błędach."""
    while True:
        try:
            a = float(input("\nPodaj pierwszą liczbę (lub 'q' aby wyjść): "))
            b = float(input("Podaj drugą liczbę: "))
            
            if b == 0:
                raise ZeroDivisionError("Dzielenie przez zero!")
            
            wynik = a / b
            print(f"Wynik: {a} / {b} = {wynik:.2f}")
            break
            
        except ValueError:
            odpowiedz = input("Nieprawidłowy format! Spróbować ponownie? (t/n): ")
            if odpowiedz.lower() != 't':
                break
        except ZeroDivisionError as e:
            print(f"Błąd: {e}")
            odpowiedz = input("Spróbować ponownie? (t/n): ")
            if odpowiedz.lower() != 't':
                break

dziel_liczby_petla()

Tworzenie własnych klas wyjątków

Możesz tworzyć własne typy wyjątków dziedzicząc po Exception.

class BledWalidacji(Exception):
    """Własny wyjątek dla błędów walidacji."""
    pass

class UjemnaWartoscError(BledWalidacji):
    """Wyjątek dla ujemnych wartości."""
    pass

def oblicz_pierwiastek(liczba):
    """Oblicza pierwiastek z walidacją."""
    if liczba < 0:
        raise UjemnaWartoscError("Nie można obliczyć pierwiastka z liczby ujemnej!")
    
    return liczba ** 0.5

# Użycie
try:
    wynik = oblicz_pierwiastek(-5)
except UjemnaWartoscError as e:
    print(f"Błąd: {e}")

Assertion – assert

assert służy do sprawdzania założeń w kodzie podczas developmentu.

def podziel(a, b):
    """Dzieli a przez b."""
    assert b != 0, "Dzielnik nie może być zerem!"
    return a / b

# Użycie
wynik = podziel(10, 2)  # OK
wynik = podziel(10, 0)  # AssertionError: Dzielnik nie może być zerem!

Uwaga: assert jest wyłączany w trybie produkcyjnym (python -O). Do walidacji w produkcji używaj if + raise.

Dobre praktyki

• Łap konkretne błędy
• Nie ukrywaj błędów
• Obsługuj tylko to co potrafisz
• Używaj finally do sprzątania
• Informacyjne komunikaty błędów

Ćwiczenia – Obsługa błędów i wyjątków

Podstawy try-except

1. Napisz program który próbuje otworzyć plik „dane.txt”. Obsłuż błąd gdy plik nie istnieje.
2. Pobierz od użytkownika liczbę. Obsłuż błąd gdy wpisze tekst zamiast liczby.
3. Stwórz listę 3 elementów. Spróbuj pobrać element o indeksie 5 i obsłuż błąd.
4. Stwórz słownik z 3 kluczami. Spróbuj pobrać nieistniejący klucz i obsłuż błąd.
5. Napisz program dzielący dwie liczby. Obsłuż dzielenie przez zero.
6. Spróbuj dodać string do liczby i obsłuż błąd TypeError.
7. Napisz program który próbuje skonwertować „abc” na int. Obsłuż błąd.
8. Pobierz od użytkownika indeks listy. Obsłuż błąd gdy podadzielny typ lub poza zakresem.
9. Otwórz plik do zapisu w katalogu bez uprawnień. Obsłuż PermissionError.
10. Napisz program który łapie KeyboardInterrupt (Ctrl+C) i wyświetla komunikat.

Wiele except

1. Napisz kalkulator obsługujący ValueError i ZeroDivisionError.
2. Napisz funkcję otwierającą plik obsługującą FileNotFoundError i PermissionError.
3. Pobierz od użytkownika wiek. Obsłuż ValueError i sprawdź czy nie jest ujemny (ValueError).
4. Napisz program dostępu do słownika obsługujący KeyError i TypeError.
5. Napisz funkcję konwertującą string na liczbę obsługującą ValueError i TypeError.

Przypisanie błędu do zmiennej

1. Złap KeyError i wyświetl komunikat zawierający nazwę brakującego klucza.
2. Złap ValueError i wyświetl dokładny komunikat błędu.
3. Złap FileNotFoundError i wyświetl nazwę brakującego pliku.
4. Złap wszystkie wyjątki jako zmienną i wyświetl ich typ.
5. Złap IndexError i wyświetl komunikat z podanym indeksem.

Blok else

1. Napisz program który próbuje otworzyć plik. W bloku else wyświetl jego zawartość.
2. Pobierz liczbę od użytkownika. W else oblicz jej kwadrat.
3. Otwórz plik do zapisu. W else zapisz dane. Obsłuż błędy.
4. Pobierz dwie liczby i podziel. W else wyświetl wynik.
5. Wczytaj dane ze słownika. W else przetwórz dane.

Blok finally

1. Otwórz plik i zagwarantuj jego zamknięcie w finally.
2. Napisz funkcję która zawsze wyświetla „Koniec” w finally.
3. Zaimplementuj licznik prób w finally.
4. Zapisz log operacji w finally (czy była udana czy nie).
5. Zmierz czas operacji w finally.

raise – wywoływanie błędów

1. Napisz funkcję sprawdzającą wiek. Wywołaj ValueError gdy wiek > 150.
2. Napisz funkcję obliczającą pierwiastek. Wywołaj ValueError dla liczb ujemnych.
3. Napisz funkcję dzielącą. Wywołaj ZeroDivisionError dla dzielnika = 0.
4. Napisz funkcję walidującą email. Wywołaj ValueError gdy brak @ .
5. Napisz funkcję sprawdzającą hasło (min 8 znaków). Wywołaj ValueError gdy za krótkie.
6. Napisz funkcję która wywołuje TypeError gdy argument nie jest typu int.
7. Napisz funkcję walidującą PESEL (11 cyfr). Wywołaj ValueError gdy niepoprawny.
8. Napisz funkcję sprawdzającą czy liczba jest w zakresie 1-100. Wywołaj ValueError gdy nie.
9. Napisz funkcję która wywołuje FileNotFoundError gdy podano pustą nazwę pliku.
10. Napisz funkcję walidującą numer telefonu (9 cyfr). Wywołaj ValueError gdy błędny.

Walidacja danych użytkownika

1. Napisz funkcję pobierającą dodatnią liczbę całkowitą. Powtarzaj dopóki nie będzie poprawna.
2. Napisz funkcję pobierającą liczbę z zakresu 1-10. Waliduj i powtarzaj.
3. Napisz funkcję pobierającą tak/nie. Akceptuj tylko te wartości.
4. Napisz funkcję pobierającą datę w formacie DD-MM-YYYY. Waliduj format.
5. Napisz funkcję pobierającą ocenę 1-6. Waliduj zakres.

Funkcje z obsługą błędów

1. Napisz funkcję bezpiecznego dzielenia zwracającą None przy błędzie.
2. Napisz funkcję bezpiecznego dostępu do listy zwracającą wartość domyślną.
3. Napisz funkcję bezpiecznego dostępu do słownika z wartością domyślną.
4. Napisz funkcję bezpiecznie konwertującą na int (zwraca 0 przy błędzie).
5. Napisz funkcję bezpiecznie otwierającą plik (zwraca None przy błędzie).

Praca z plikami

1. Napisz program który tworzy plik jeśli nie istnieje, otwiera jeśli istnieje.
2. Napisz funkcję kopiującą plik z obsługą wszystkich błędów.
3. Napisz program który próbuje wczytać JSON. Obsłuż błąd parsowania.
4. Napisz funkcję dopisującą do logu z obsługą błędów.
5. Napisz funkcję usuwającą plik z obsługą błędów.

Praca ze słownikami i listami

1. Napisz funkcję bezpiecznie pobierającą wartość zagnieżdżoną ze słownika.
2. Napisz funkcję aktualizującą słownik z obsługą błędów.
3. Napisz funkcję usuwającą element z listy po wartości (obsłuż ValueError).
4. Napisz funkcję sortującą listę mieszanych typów (obsłuż TypeError).
5. Napisz funkcję łączącą dwa słowniki z obsługą błędów.

Konwersje i parsowanie

1. Napisz funkcję konwertującą string na float z obsługą błędów.
2. Napisz funkcję parsującą datę z różnych formatów.
3. Napisz funkcję konwertującą string na bool (tak/nie, true/false, 1/0).
4. Napisz funkcję parsującą listę liczb z stringa „1,2,3,4,5”.
5. Napisz funkcję konwertującą temperaturę z obsługą błędnych jednostek.

Matematyka

1. Napisz funkcję obliczającą silnię. Wywołaj ValueError dla n < 0.
2. Napisz funkcję obliczającą pierwiastek z walidacją.
3. Napisz funkcję obliczającą potęgę. Obsłuż OverflowError.
4. Napisz funkcję obliczającą logarytm. Waliduj argument > 0.
5. Napisz funkcję obliczającą procent. Waliduj zakres 0-100.

Kalkulator rozszerzony

1. Napisz kalkulator z menu i pełną obsługą błędów.
2. Dodaj historię operacji zapisywaną do pliku (obsłuż błędy).
3. Dodaj tryb zaawansowany z funkcjami matematycznymi (obsłuż błędy dziedziny).
4. Dodaj obsługę nawiasów w wyrażeniach.
5. Dodaj możliwość zapisywania i wczytywania sesji.

Gry i aplikacje

1. Napisz grę w zgadywanie liczby z pełną walidacją inputu.
2. Napisz quiz z obsługą błędnych odpowiedzi.
3. Napisz kółko i krzyżyk z walidacją ruchów.
4. Napisz prostą grę tekstową z zapisem stanu (obsłuż błędy plików).
5. Napisz symulator bankomatu z walidacją PIN i kwot.

Własne wyjątki

1. Stwórz własny wyjątek NiepoprawnyWiekError.
2. Stwórz własny wyjątek BledWalidacjiEmail.
3. Stwórz hierarchię wyjątków dla aplikacji bankowej.
4. Stwórz własny wyjątek BledKonfiguracji z dodatkowymi atrybutami.
5. Stwórz własny wyjątek PrzekroczonoLimit z informacją o limicie.

Assert

1. Użyj assert do sprawdzenia czy lista nie jest pusta przed operacją.
2. Użyj assert do sprawdzenia typu argumentu funkcji.
3. Użyj assert do sprawdzenia czy liczba jest w zakresie.
4. Użyj assert do walidacji długości stringa.
5. Użyj assert do sprawdzenia niezmiennika klasy.

Zadania kompleksowe

1. Napisz system logowania użytkownika z pełną walidacją (login, hasło, próby).
2. Napisz program zarządzający kontami bankowymi z walidacją operacji.
3. Napisz parser plików konfiguracyjnych z obsługą wszystkich błędów.
4. Napisz system rezerwacji z walidacją dat, dostępności, konfliktów.
5. Napisz aplikację TODO z zapisem do pliku i pełną obsługą błędów.
6. Napisz kalkulator kredytu z walidacją wszystkich parametrów.
7. Napisz system ocen uczniów z walidacją ocen, obliczaniem średnich, zapisem.
8. Napisz konwerter walut z obsługą błędów API, walidacją kwot.
9. Napisz aplikację inwentaryzacji z walidacją stanów, cen, operacji.
10. Napisz prosty interpreter poleceń z obsługą błędów składni i wykonania.

Debugging

1. Napisz funkcję która loguje wszystkie wyjątki do pliku z datą, typem, traceback.
2. Napisz dekorator który łapie i loguje wszystkie wyjątki funkcji.
3. Napisz kontekst menedżer do obsługi zasobów z automatycznym sprzątaniem.
4. Napisz funkcję która wyświetla czytelny komunikat błędu dla użytkownika końcowego.
5. Napisz system retry (ponawiania operacji) z wykładniczym cofaniem.

Zaawansowane

1. Napisz funkcję która łapie wiele typów wyjątków i reaguje inaczej na każdy.
2. Napisz funkcję używającą re-raise do propagacji błędu z dodatkowym kontekstem.
3. Napisz chain wyjątków (raise … from …).
4. Napisz własny context manager używając try-finally.
5. Napisz wrapper funkcji który zamienia wyjątki na kody błędów.

Artykuł 15. Python – obsługa błędów i wyjątków pochodzi z serwisu Kama Kaczmarek.