🐍 Python - Kompletny Przewodnik

🕰️ Historia i filozofia Pythona

Python został stworzony przez Guido van Rossuma w 1991 roku w Holandii. Nazwa języka pochodzi od popularnego serialu komediowego "Monty Python's Flying Circus", nie od węża pytona, jak wielu może myśleć.

Filozofia Pythona - Zen of Python

Python kieruje się filozofią wyrażoną w "Zen of Python" (PEP 20):

import this

# Wyświetli zasady Zen of Python:
# Beautiful is better than ugly.
# Explicit is better than implicit.
# Simple is better than complex.
# Readability counts.
# ...

Kluczowe cechy Pythona

• Czytelność kodu - składnia jest intuicyjna i przypomina język naturalny
• Interpretowany - kod wykonywany jest linia po linii
• Dynamiczne typowanie - nie trzeba deklarować typów zmiennych
• Wysokopoziomowy - abstrakcja od detali sprzętowych
• Multiparadygmatowy - wspiera różne style programowania
• Przenośny - działa na różnych systemach operacyjnych

💻 Instalacja i środowisko pracy

Instalacja Pythona

Python można pobrać ze strony python.org. Aktualnie rozwijaną wersją jest Python 3.x (Python 2.x jest już przestarzały).

Sprawdzenie wersji

# W terminalu/wierszu poleceń
python --version
python3 --version

# W kodzie Python
import sys
print(sys.version)

Interaktywny interpreter

Python oferuje interaktywny interpreter (REPL - Read-Eval-Print Loop):

# Uruchomienie interpretera
$ python3
>>> print("Hello, Python!")
Hello, Python!
>>> 2 + 3
5
>>> exit()

📝 Podstawy składni Pythona

Wcięcia zamiast nawiasów klamrowych

Python używa wcięć (indentacji) do określania bloków kodu:

if 5 > 3:
    print("5 jest większe od 3")  # wcięcie 4 spacje
    print("To jest w tym samym bloku")
    
print("To jest poza blokiem")  # brak wcięcia

Komentarze

# To jest komentarz jednoliniowy

"""
To jest komentarz
wieloliniowy (docstring)
"""

'''
Można też używać potrójnych
apostrofów
'''

Instrukcje i wyrażenia

# Instrukcje nie zwracają wartości
print("Hello")
x = 5

# Wyrażenia zwracają wartość
wynik = 2 + 3  # 2 + 3 to wyrażenie
dlugosc = len("Python")  # len("Python") to wyrażenie

🗂️ Typy danych w Pythonie

Typy podstawowe (primitive types)

Typ	Opis	Przykład	Funkcja sprawdzająca
int	Liczba całkowita	42, -17, 0	isinstance(x, int)
float	Liczba zmiennoprzecinkowa	3.14, -2.5	isinstance(x, float)
str	Ciąg znaków	"Hello", 'Python'	isinstance(x, str)
bool	Wartość logiczna	True, False	isinstance(x, bool)
NoneType	Brak wartości	None	x is None

Przykłady użycia typów podstawowych

# Liczby całkowite
wiek = 25
temperatura = -10

# Liczby zmiennoprzecinkowe
pi = 3.14159
cena = 19.99

# Ciągi znaków
imie = "Anna"
nazwisko = 'Kowalska'
opis = """To jest długi tekst
rozłożony na wiele linii"""

# Wartości logiczne
czy_aktywny = True
czy_admin = False

# None - brak wartości
wynik = None

Kolekcje danych

Lista (list) - kolekcja uporządkowana i modyfikowalna

# Tworzenie list
liczby = [1, 2, 3, 4, 5]
imiona = ["Anna", "Jan", "Piotr"]
mieszane = [1, "hello", 3.14, True]

# Operacje na listach
liczby.append(6)  # dodanie elementu na koniec
pierwszy = liczby[0]  # dostęp do elementu
liczby[1] = 10  # zmiana wartości
dlugosc = len(liczby)  # długość listy

Krotka (tuple) - kolekcja uporządkowana i niemodyfikowalna

# Tworzenie krotek
punkt = (3, 4)
kolory = ("czerwony", "zielony", "niebieski")

# Dostęp do elementów
x = punkt[0]  # x = 3
y = punkt[1]  # y = 4

# Rozpakowanie krotki
x, y = punkt

Słownik (dict) - kolekcja par klucz-wartość

# Tworzenie słowników
osoba = {
    "imie": "Jan",
    "nazwisko": "Kowalski",
    "wiek": 30
}

# Operacje na słownikach
imie = osoba["imie"]  # dostęp do wartości
osoba["email"] = "jan@email.com"  # dodanie nowego klucza
osoba["wiek"] = 31  # zmiana wartości

# Bezpieczny dostęp
telefon = osoba.get("telefon", "Brak")  # zwraca "Brak" jeśli klucz nie istnieje

Zbiór (set) - kolekcja unikalnych elementów

# Tworzenie zbiorów
liczby_unikalne = {1, 2, 3, 3, 4}  # {1, 2, 3, 4}
kolory = {"czerwony", "zielony", "niebieski"}

# Operacje na zbiorach
kolory.add("żółty")  # dodanie elementu
czy_ma_czerwony = "czerwony" in kolory  # sprawdzenie przynależności

# Operacje matematyczne na zbiorach
a = {1, 2, 3}
b = {3, 4, 5}
suma = a | b  # suma zbiorów: {1, 2, 3, 4, 5}
przeciecie = a & b  # przecięcie: {3}
roznica = a - b  # różnica: {1, 2}

⚡ Operatory w Pythonie

Operatory arytmetyczne

Operator	Opis	Przykład	Wynik
+	Dodawanie	5 + 3	8
-	Odejmowanie	5 - 3	2
*	Mnożenie	5 * 3	15
/	Dzielenie	7 / 2	3.5
//	Dzielenie całkowitoliczbowe	7 // 2	3
%	Modulo (reszta z dzielenia)	7 % 3	1
**	Potęgowanie	2 ** 3	8

Operatory porównania

# Operatory porównania zawsze zwracają True lub False
a = 5
b = 3

print(a == b)  # False (równość)
print(a != b)  # True (nierówność)
print(a > b)   # True (większy od)
print(a < b)   # False (mniejszy od)
print(a >= b)  # True (większy lub równy)
print(a <= b)  # False (mniejszy lub równy)

Operatory logiczne

# and - prawdziwy gdy oba operandy są prawdziwe
print(True and True)   # True
print(True and False)  # False

# or - prawdziwy gdy przynajmniej jeden operand jest prawdziwy
print(True or False)   # True
print(False or False) # False

# not - negacja
print(not True)   # False
print(not False)  # True

Operatory przypisania

x = 10        # podstawowe przypisanie
x += 5       # x = x + 5, wynik: 15
x -= 3       # x = x - 3, wynik: 12
x *= 2       # x = x * 2, wynik: 24
x /= 4       # x = x / 4, wynik: 6.0
x //= 2      # x = x // 2, wynik: 3.0
x %= 2       # x = x % 2, wynik: 1.0
x **= 3      # x = x ** 3, wynik: 1.0

🔄 Struktury kontrolne

Instrukcja warunkowa if

# Podstawowa forma if
wiek = 20

if wiek >= 18:
    print("Jesteś pełnoletni")

# if-else
if wiek >= 18:
    print("Jesteś pełnoletni")
else:
    print("Jesteś niepełnoletni")

# if-elif-else
ocena = 85

if ocena >= 90:
    stopien = "Bardzo dobry"
elif ocena >= 80:
    stopien = "Dobry"
elif ocena >= 70:
    stopien = "Dostateczny"
else:
    stopien = "Niedostateczny"

print(f"Twój stopień: {stopien}")

# Przykład operatora warunkowego
wiek = 20
status = "pełnoletni" if wiek >= 18 else "niepełnoletni"
print(status)  # "pełnoletni"

Pętla for

# Iteracja przez listę
imiona = ["Anna", "Jan", "Piotr"]
for imie in imiona:
    print(f"Cześć, {imie}!")

# Iteracja z range()
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)

for i in range(1, 6):  # 1, 2, 3, 4, 5
    print(i)

for i in range(0, 10, 2):  # 0, 2, 4, 6, 8
    print(i)

# Iteracja przez słownik
osoba = {"imie": "Anna", "wiek": 25, "miasto": "Warszawa"}

for klucz in osoba:
    print(f"{klucz}: {osoba[klucz]}")

for klucz, wartosc in osoba.items():
    print(f"{klucz}: {wartosc}")

Pętla while

# Podstawowa pętla while
licznik = 0
while licznik < 5:
    print(f"Licznik: {licznik}")
    licznik += 1

# Pętla while z warunkiem logicznym
kontynuj = True
while kontynuj:
    odpowiedz = input("Czy chcesz kontynuować? (tak/nie): ")
    if odpowiedz.lower() == "nie":
        kontynuj = False

Instrukcje break i continue

# break - przerywa pętlę
for i in range(10):
    if i == 5:
        break  # zakończy pętlę gdy i=5
    print(i)  # wypisze: 0, 1, 2, 3, 4

# continue - przechodzi do następnej iteracji
for i in range(10):
    if i % 2 == 0:
        continue  # pomija parzyste liczby
    print(i)  # wypisze: 1, 3, 5, 7, 9

🔧 Funkcje w Pythonie

Definiowanie i wywoływanie funkcji

# Podstawowa definicja funkcji
def powitanie():
    print("Witaj w Pythonie!")

# Wywołanie funkcji
powitanie()  # Witaj w Pythonie!

# Funkcja z parametrami
def powitanie_personalizowane(imie):
    print(f"Witaj, {imie}!")

powitanie_personalizowane("Anna")  # Witaj, Anna!

# Funkcja zwracająca wartość
def dodaj(a, b):
    wynik = a + b
    return wynik

suma = dodaj(5, 3)
print(suma)  # 8

Parametry funkcji

# Parametry domyślne
def powitanie(imie, tytul="Pan/Pani"):
    print(f"Witaj, {tytul} {imie}!")

powitanie("Anna")                    # Witaj, Pan/Pani Anna!
powitanie("Anna", "Dr")           # Witaj, Dr Anna!

# Argumenty nazwane
def opis_osoby(imie, nazwisko, wiek, miasto):
    print(f"{imie} {nazwisko}, {wiek} lat, mieszka w {miasto}")

opis_osoby(wiek=25, imie="Anna", miasto="Warszawa", nazwisko="Kowalska")

# *args - zmienna liczba argumentów pozycyjnych
def suma_wszystkich(*liczby):
    return sum(liczby)

print(suma_wszystkich(1, 2, 3))         # 6
print(suma_wszystkich(1, 2, 3, 4, 5))  # 15

# **kwargs - zmienna liczba argumentów nazwanych
def info_osoby(**dane):
    for klucz, wartosc in dane.items():
        print(f"{klucz}: {wartosc}")

info_osoby(imie="Jan", wiek=30, miasto="Kraków")

Funkcje lambda (anonimowe)

# Podstawowa funkcja lambda
kwadrat = lambda x: x ** 2
print(kwadrat(5))  # 25

# Lambda z wieloma parametrami
dodaj = lambda x, y: x + y
print(dodaj(3, 4))  # 7

# Użycie lambda z funkcjami wbudowanymi
liczby = [1, 2, 3, 4, 5]
kwadraty = list(map(lambda x: x ** 2, liczby))
print(kwadraty)  # [1, 4, 9, 16, 25]

parzyste = list(filter(lambda x: x % 2 == 0, liczby))
print(parzyste)  # [2, 4]

Zasięg zmiennych (scope)

# Zmienna globalna
x = 10

def funkcja1():
    # Zmienna lokalna
    x = 20
    print(f"Wewnątrz funkcji: x = {x}")  # 20

funkcja1()
print(f"Na zewnątrz funkcji: x = {x}")  # 10

# Modyfikacja zmiennej globalnej
def funkcja2():
    global x
    x = 30
    print(f"Po modyfikacji globalnej: x = {x}")  # 30

funkcja2()
print(f"Na zewnątrz po modyfikacji: x = {x}")  # 30

🏗️ Programowanie obiektowe

Definicja klasy

class Osoba:
    # Konstruktor klasy
    def __init__(self, imie, nazwisko, wiek):
        self.imie = imie
        self.nazwisko = nazwisko
        self.wiek = wiek
    
    # Metoda klasy
    def przedstaw_sie(self):
        return f"Cześć, jestem {self.imie} {self.nazwisko}, mam {self.wiek} lat."
    
    # Metoda zmieniająca stan obiektu
    def obchody_urodzin(self):
        self.wiek += 1
        print(f"Wszystkiego najlepszego! Mam teraz {self.wiek} lat.")

# Tworzenie obiektów (instancji)
osoba1 = Osoba("Anna", "Kowalska", 25)
osoba2 = Osoba("Jan", "Nowak", 30)

# Wywołanie metod
print(osoba1.przedstaw_sie())
osoba1.obchody_urodzin()

Dziedziczenie

# Klasa bazowa
class Pojazd:
    def __init__(self, marka, model, rok):
        self.marka = marka
        self.model = model
        self.rok = rok
    
    def info(self):
        return f"{self.marka} {self.model} ({self.rok})"
    
    def uruchom(self):
        print("Pojazd został uruchomiony")

# Klasa pochodna
class Samochod(Pojazd):
    def __init__(self, marka, model, rok, liczba_drzwi):
        super().__init__(marka, model, rok)  # wywołanie konstruktora klasy bazowej
        self.liczba_drzwi = liczba_drzwi
    
    # Przeciążenie metody
    def uruchom(self):
        print(f"Samochód {self.marka} {self.model} został uruchomiony")
    
    # Nowa metoda specyficzna dla samochodu
    def otwórz_drzwi(self):
        print(f"Otwieranie {self.liczba_drzwi} drzwi")

# Użycie
auto = Samochod("Toyota", "Corolla", 2020, 4)
print(auto.info())        # Toyota Corolla (2020)
auto.uruchom()              # Samochód Toyota Corolla został uruchomiony
auto.otwórz_drzwi()        # Otwieranie 4 drzwi

Enkapsulacja - atrybuty prywatne i właściwości

class KontoBankowe:
    def __init__(self, wlasciciel, saldo_poczatkowe=0):
        self.wlasciciel = wlasciciel
        self.__saldo = saldo_poczatkowe  # atrybut prywatny
    
    # Właściwość (property) - getter
    @property
    def saldo(self):
        return self.__saldo
    
    # Metoda do wpłaty
    def wplac(self, kwota):
        if kwota > 0:
            self.__saldo += kwota
            print(f"Wpłacono {kwota} zł. Saldo: {self.__saldo} zł")
        else:
            print("Kwota musi być dodatnia")
    
    # Metoda do wypłaty
    def wyplac(self, kwota):
        if kwota > 0 and kwota <= self.__saldo:
            self.__saldo -= kwota
            print(f"Wypłacono {kwota} zł. Saldo: {self.__saldo} zł")
        else:
            print("Nieprawidłowa kwota lub brak środków")

# Użycie
konto = KontoBankowe("Anna Kowalska", 1000)
print(f"Saldo: {konto.saldo} zł")  # dostęp przez property
konto.wplac(500)
konto.wyplac(200)
# konto.__saldo  # To by wywołało błąd - atrybut prywatny

📦 Moduły i pakiety

Import modułów

# Różne sposoby importowania
import math
print(math.pi)        # 3.141592653589793
print(math.sqrt(16))  # 4.0

# Import z aliasem
import math as m
print(m.pi)

# Import konkretnych funkcji
from math import pi, sqrt, sin
print(pi)        # 3.141592653589793
print(sqrt(25))  # 5.0

# Import wszystkich funkcji (nie zalecane)
from math import *

Tworzenie własnego modułu

# Plik: moj_modul.py
def powitanie(imie):
    return f"Witaj, {imie}!"

def oblicz_pole_kola(promien):
    import math
    return math.pi * promien ** 2

# Zmienna modułu
WERSJA = "1.0"

# Kod wykonywany tylko przy bezpośrednim uruchomieniu
if __name__ == "__main__":
    print("Moduł uruchomiony bezpośrednio")

# Użycie własnego modułu (w innym pliku)
import moj_modul

print(moj_modul.powitanie("Anna"))
print(moj_modul.oblicz_pole_kola(5))
print(f"Wersja modułu: {moj_modul.WERSJA}")

Popularne moduły wbudowane

# datetime - praca z datami i czasem
from datetime import datetime, date, time

dzisiaj = date.today()
teraz = datetime.now()
print(f"Dzisiaj: {dzisiaj}")
print(f"Teraz: {teraz}")

# random - generowanie liczb losowych
import random

print(random.randint(1, 10))        # losowa liczba z zakresu 1-10
print(random.choice(["a", "b", "c"]))  # losowy element z listy

# os - operacje systemowe


  import os

print(os.getcwd())          # aktualny katalog
print(os.listdir('.'))     # lista plików w katalogu
os.makedirs('nowy_katalog')  # tworzenie katalogu

# json - praca z formatem JSON
import json

dane = {"imie": "Anna", "wiek": 25}
json_string = json.dumps(dane)     # konwersja do JSON
z_powrotem = json.loads(json_string)  # konwersja z JSON

⚠️ Obsługa wyjątków

Podstawy obsługi wyjątków

# Podstawowa konstrukcja try-except
try:
    liczba = int(input("Podaj liczbę: "))
    wynik = 10 / liczba
    print(f"Wynik: {wynik}")
except ValueError:
    print("Błąd: To nie jest prawidłowa liczba!")
except ZeroDivisionError:
    print("Błąd: Nie można dzielić przez zero!")

Zaawansowana obsługa wyjątków

try:
    plik = open("nieistniejacy_plik.txt", "r")
    zawartosc = plik.read()
except FileNotFoundError as e:
    print(f"Nie można otworzyć pliku: {e}")
except Exception as e:
    print(f"Wystąpił nieoczekiwany błąd: {e}")
else:
    print("Plik został pomyślnie odczytany")
    plik.close()
finally:
    print("Ten kod wykona się zawsze")

Tworzenie własnych wyjątków

class WlasnyWyjatek(Exception):
    def __init__(self, komunikat):
        self.komunikat = komunikat
        super().__init__(self.komunikat)

def sprawdz_wiek(wiek):
    if wiek < 0:
        raise WlasnyWyjatek("Wiek nie może być ujemny!")
    elif wiek > 150:
        raise WlasnyWyjatek("Wiek nie może być większy niż 150 lat!")
    return f"Wiek {wiek} jest prawidłowy"

# Użycie
try:
    print(sprawdz_wiek(25))    # OK
    print(sprawdz_wiek(-5))    # Wywołuje wyjątek
except WlasnyWyjatek as e:
    print(f"Błąd: {e}")

📄 Praca z plikami

Otwieranie i czytanie plików

# Bezpieczne otwieranie plików z with
with open("plik.txt", "r", encoding="utf-8") as plik:
    zawartosc = plik.read()
    print(zawartosc)

# Czytanie linia po linii
with open("plik.txt", "r", encoding="utf-8") as plik:
    for linia in plik:
        print(linia.strip())  # strip() usuwa znaki końca linii

# Czytanie wszystkich linii do listy
with open("plik.txt", "r", encoding="utf-8") as plik:
    linie = plik.readlines()
    for linia in linie:
        print(linia.strip())

Zapisywanie do plików

# Zapisywanie do pliku (nadpisuje zawartość)
with open("nowy_plik.txt", "w", encoding="utf-8") as plik:
    plik.write("Witaj, świecie!\n")
    plik.write("To jest druga linia.\n")

# Dopisywanie do pliku
with open("nowy_plik.txt", "a", encoding="utf-8") as plik:
    plik.write("To jest dopisana linia.\n")

# Zapisywanie listy do pliku
dane = ["Linia 1", "Linia 2", "Linia 3"]
with open("lista.txt", "w", encoding="utf-8") as plik:
    for linia in dane:
        plik.write(linia + "\n")

Praca z plikami CSV i JSON

# Praca z plikami CSV
import csv

# Zapis do CSV
dane_csv = [
    ["Imię", "Wiek", "Miasto"],
    ["Anna", 25, "Warszawa"],
    ["Jan", 30, "Kraków"]
]

with open("dane.csv", "w", newline="", encoding="utf-8") as plik:
    writer = csv.writer(plik)
    writer.writerows(dane_csv)

# Odczyt z CSV
with open("dane.csv", "r", encoding="utf-8") as plik:
    reader = csv.reader(plik)
    for wiersz in reader:
        print(wiersz)

# Praca z plikami JSON
import json

dane_json = {
    "osoby": [
        {"imie": "Anna", "wiek": 25, "miasto": "Warszawa"},
        {"imie": "Jan", "wiek": 30, "miasto": "Kraków"}
    ]
}

# Zapis do JSON
with open("dane.json", "w", encoding="utf-8") as plik:
    json.dump(dane_json, plik, ensure_ascii=False, indent=2)

# Odczyt z JSON
with open("dane.json", "r", encoding="utf-8") as plik:
    dane_odczytane = json.load(plik)
    print(dane_odczytane)

📚 Popularne biblioteki

NumPy - obliczenia numeryczne

# Instalacja: pip install numpy
import numpy as np

# Tworzenie tablic
tablica1d = np.array([1, 2, 3, 4, 5])
tablica2d = np.array([[1, 2], [3, 4]])

# Operacje matematyczne
wynik = tablica1d * 2  # [2, 4, 6, 8, 10]
suma = np.sum(tablica1d)    # 15
srednia = np.mean(tablica1d)  # 3.0

print(f"Tablica: {tablica1d}")
print(f"Wynik * 2: {wynik}")
print(f"Suma: {suma}, Średnia: {srednia}")

Pandas - analiza danych

# Instalacja: pip install pandas
import pandas as pd

# Tworzenie DataFrame
dane = {
    'Imię': ['Anna', 'Jan', 'Piotr'],
    'Wiek': [25, 30, 35],
    'Miasto': ['Warszawa', 'Kraków', 'Gdańsk']
}

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

# Podstawowe operacje
print(f"Średni wiek: {df['Wiek'].mean()}")
print(f"Liczba osób: {len(df)}")

# Filtrowanie danych
starsi = df[df['Wiek'] > 28]
print("Osoby starsze niż 28 lat:")
print(starsi)

Matplotlib - tworzenie wykresów

# Instalacja: pip install matplotlib
import matplotlib.pyplot as plt

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

# Tworzenie wykresu
plt.figure(figsize=(8, 6))
plt.plot(x, y, marker='o')
plt.title('Przykładowy wykres')
plt.xlabel('Oś X')
plt.ylabel('Oś Y')
plt.grid(True)
plt.show()

Requests - HTTP requests

# Instalacja: pip install requests
import requests

# GET request
response = requests.get('https://api.github.com/users/octocat')

if response.status_code == 200:
    dane = response.json()
    print(f"Użytkownik: {dane['login']}")
    print(f"Repozytoria: {dane['public_repos']}")
else:
    print(f"Błąd: {response.status_code}")

🚀 Zaawansowane funkcje

List comprehensions

# Podstawowe list comprehension
kwadraty = [x**2 for x in range(10)]
print(kwadraty)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Z warunkiem
parzyste_kwadraty = [x**2 for x in range(10) if x % 2 == 0]
print(parzyste_kwadraty)  # [0, 4, 16, 36, 64]

# Dict comprehension
kwadraty_dict = {x: x**2 for x in range(5)}
print(kwadraty_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Set comprehension
unikalne_reszty = {x % 3 for x in range(10)}
print(unikalne_reszty)  # {0, 1, 2}

Generatory

# Funkcja generująca
def liczby_fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# Użycie generatora
for liczba in liczby_fibonacci(10):
    print(liczba, end=' ')  # 0 1 1 2 3 5 8 13 21 34

# Generator expression
kwadraty_gen = (x**2 for x in range(5))
print(list(kwadraty_gen))  # [0, 1, 4, 9, 16]

Dekoratory

# Prosty dekorator
def moj_dekorator(func):
    def wrapper(*args, **kwargs):
        print(f"Wykonywanie funkcji: {func.__name__}")
        wynik = func(*args, **kwargs)
        print(f"Funkcja {func.__name__} zakończona")
        return wynik
    return wrapper

@moj_dekorator
def powitanie(imie):
    print(f"Witaj, {imie}!")

powitanie("Anna")

# Dekorator z parametrami
def powtorz(ile_razy):
    def dekorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(ile_razy):
                func(*args, **kwargs)
        return wrapper
    return dekorator

@powtorz(3)
def powiedz_cos():
    print("Hello!")

powiedz_cos()  # Wypisze "Hello!" 3 razy

Context managery

# Własny context manager
class MojContextManager:
    def __enter__(self):
        print("Rozpoczynam pracę")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Kończę pracę")
    
    def rób_cos(self):
        print("Robię coś ważnego...")

# Użycie
with MojContextManager() as cm:
    cm.rób_cos()

# Context manager z @contextmanager
from contextlib import contextmanager

@contextmanager
def prosty_context():
    print("Przygotowanie")
    yield "Wartość z contextu"
    print("Sprzątanie")

with prosty_context() as wartosc:
    print(f"Używam: {wartosc}")

✨ Dobre praktyki

PEP 8 - Standard kodowania

# Dobre praktyki nazewnictwa
# Zmienne i funkcje - snake_case
nazwa_uzytkownika = "Anna"
maksymalna_liczba_prob = 3

def oblicz_srednia(lista_liczb):
    return sum(lista_liczb) / len(lista_liczb)

# Klasy - PascalCase
class MenedzerUzytkownikow:
    pass

# Stałe - WIELKIE_LITERY
MAKSYMALNY_ROZMIAR_PLIKU = 1024 * 1024  # 1MB
DOMYSLNY_TIMEOUT = 30

Dokumentowanie kodu

def oblicz_pole_prostokata(dlugosc, szerokosc):
    """
    Oblicza pole prostokąta.
    
    Args:
        dlugosc (float): Długość prostokąta
        szerokosc (float): Szerokość prostokąta
    
    Returns:
        float: Pole prostokąta
        
    Raises:
        ValueError: Gdy długość lub szerokość są ujemne
    
    Example:
        >>> oblicz_pole_prostokata(5, 3)
        15.0
    """
    if dlugosc < 0 or szerokosc < 0:
        raise ValueError("Wymiary nie mogą być ujemne")
    
    return dlugosc * szerokosc

class Kalkulator:
    """
    Prosta klasa kalkulatora do podstawowych operacji matematycznych.
    
    Attributes:
        historia (list): Lista wykonanych operacji
    """
    
    def __init__(self):
        self.historia = []
    
    def dodaj(self, a, b):
        """Dodaje dwie liczby i zapisuje w historii."""
        wynik = a + b
        self.historia.append(f"{a} + {b} = {wynik}")
        return wynik

Obsługa błędów i logowanie

import logging

# Konfiguracja logowania
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    filename='aplikacja.log'
)

def bezpieczne_dzielenie(a, b):
    """Bezpieczne dzielenie z logowaniem."""
    try:
        logging.info(f"Dzielenie {a} przez {b}")
        wynik = a / b
        logging.info(f"Wynik: {wynik}")
        return wynik
    except ZeroDivisionError:
        logging.error("Próba dzielenia przez zero!")
        return None
    except Exception as e:
        logging.error(f"Nieoczekiwany błąd: {e}")
        return None

# Użycie
print(bezpieczne_dzielenie(10, 2))  # 5.0
print(bezpieczne_dzielenie(10, 0))  # None

Testowanie kodu

import unittest

class TestKalkulator(unittest.TestCase):
    """Testy jednostkowe dla klasy Kalkulator."""
    
    def setUp(self):
        """Przygotowanie przed każdym testem."""
        self.kalk = Kalkulator()
    
    def test_dodawanie(self):
        """Test operacji dodawania."""
        wynik = self.kalk.dodaj(2, 3)
        self.assertEqual(wynik, 5)
    
    def test_historia(self):
        """Test czy operacje są zapisywane w historii."""
        self.kalk.dodaj(2, 3)
        self.assertEqual(len(self.kalk.historia), 1)
        self.assertIn("2 + 3 = 5", self.kalk.historia[0])

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