Ten moduł w całości poświęcony jest funkcjom w języku Python -- od podstaw definiowania za pomocą słowa kluczowego def, przez elastyczne przekazywanie parametrów (pozycyjne, nazwane, wartości domyślne), aż po zwracanie wyników za pomocą instrukcji return. Omówiona została różnica między parametrem a argumentem, a także niebezpieczna pułapka mutowalnych argumentów domyślnych i sposoby jej unikania. Szczegółowo przeanalizowano zasięgi zmiennych (lokalny, globalny, reguła LEGB) oraz zaawansowane mechanizmy, takie jak *args, **kwargs, funkcje lambda, rekurencja i domknięcia. Moduł wprowadza również funkcje wyższego rzędu map i filter oraz praktyczne wzorce projektowe, w tym zasadę pojedynczej odpowiedzialności i programowanie bez zmiennych globalnych. Całość uzupełniają praktyczne ćwiczenia i przykładowe programy (kalkulator naukowy, system weryfikacji haseł, standaryzator danych), które utrwalają omawiane koncepcje w realnych zastosowaniach.

• Definiowanie funkcji -- składnia def, parametry i argumenty (pozycyjne, nazwane, wartości domyślne), różnica między parametrem a argumentem
• Zwracanie wartości -- instrukcja return, różnica między return a print, zwracanie wielu wartości, wczesny return (early return)
• Zasięgi zmiennych -- zmienne lokalne i globalne, reguła LEGB, słowo kluczowe global i nonlocal, zasada unikania global
• Zaawansowane mechanizmy -- *args i **kwargs, funkcje lambda, rekurencja, domknięcia (closures), funkcje map i filter
• Dobre praktyki i ćwiczenia -- zasada pojedynczej odpowiedzialności (SRP), czyste funkcje, docstringi, podpowiedzi typów oraz praktyczne programy do samodzielnej analizy

• W programowaniu funkcja to wydzielony, nazwany blok kodu, który został zaprojektowany do wykonywania określonego, powtarzalnego zadania.
• Możemy myśleć o funkcji jak o kulinarnym przepisie lub instrukcji obsługi – definiuje ona ciąg czynności, które należy wykonać po jej wywołaniu.
• Funkcja przyjmuje dane wejściowe, przetwarza je według określonego algorytmu, a następnie może zwrócić wynik końcowy.
• Działa ona jak czarna skrzynka: nie musimy znać jej wewnętrznej budowy, aby z niej skutecznie korzystać w naszym programie.
• Dzięki temu programista może skupić się na logicznym składaniu aplikacji z gotowych, niezawodnych klocków.

• Głównym powodem stosowania funkcji jest chęć uniknięcia powtarzania tego samego kodu w wielu miejscach programu, co opisuje znana zasada DRY (ang. Don't Repeat Yourself, czyli Nie powtarzaj się).
• Grupowanie instrukcji w funkcje drastycznie poprawia czytelność kodu, czyniąc go bardziej przejrzystym dla innych programistów.
• Modularna struktura programu ułatwia również debugowanie, ponieważ błąd w logice można poprawić w jednym, konkretnym miejscu.
• Funkcje są również znacznie łatwiejsze do testowania, co gwarantuje wyższą stabilność całej aplikacji.
• Wreszcie, ułatwiają one podział pracy w zespole, gdzie każdy programista może odpowiadać za stworzenie innych funkcji.

• Do zdefiniowania nowej funkcji w języku Python służy słowo kluczowe def, po którym następuje unikalna nazwa funkcji.
• Bezpośrednio po nazwie musimy umieścić nawiasy okrągłe (), w których w przyszłości zdefiniujemy parametry wejściowe.
• Definicję kończymy obowiązkowym dwukropkiem, który informuje interpreter o początku nowego bloku kodu.
• Całe ciało funkcji (instrukcje, które ma wykonać) musi zostać bezwzględnie wcięte o cztery spacje w prawo.
• Zgodnie z oficjalną konwencją PEP 8, nazwy funkcji powinny być pisane małymi literami z użyciem znaku podkreślenia, np. moja_funkcja.

def powitaj_swiat():
    print("Witaj w świecie Pythona!")  # ciało funkcji musi być wcięte
            

• Samo zdefiniowanie funkcji za pomocą słowa kluczowego def jedynie rejestruje ją w pamięci komputera, lecz nie wykonuje zawartego w niej kodu.
• Aby faktycznie uruchomić instrukcje zapisane w ciele funkcji, musimy ją wywołać w odpowiednim miejscu programu.
• Wywołanie funkcji polega na podaniu jej dokładnej nazwy, po której bezwzględnie musimy dopisać nawiasy okrągłe ().
• Nawet jeśli funkcja nie przyjmuje żadnych argumentów wejściowych, nawiasy są elementem obowiązkowym informującym interpreter o chęci wykonania kodu.
• Użycie samej nazwy funkcji bez nawiasów nie uruchomi jej, lecz jedynie zwróci referencję do obiektu tej funkcji w pamięci.

def wyswietl_alert():
    print("Uwaga! System działa poprawnie.")

wyswietl_alert()  # Wywołanie funkcji z nawiasami
            

• Funkcja bez parametrów to najprostsza możliwa konstrukcja, która wykonuje stały, niezmienny zestaw instrukcji przy każdym swoim wywołaniu.
• Nie wymaga ona dostarczania żadnych dodatkowych informacji z zewnątrz do poprawnego działania.
• Jest idealna do zadań takich jak drukowanie stałego nagłówka raportu, czyszczenie ekranu konsoli czy wyświetlanie menu powitalnego.
• Podczas definiowania takiej funkcji nawiasy okrągłe pozostają puste, a wywołanie również nie zawiera żadnych argumentów.
• Chociaż jest mało elastyczna, stanowi doskonały punkt wyjścia do zrozumienia modularnej organizacji kodu w Pythonie.

def rysuj_linie():
    print("-" * 40)  # Wyświetli stałą linię poziomą

rysuj_linie()  # Wywołanie narysuje linię
            

• W terminologii programistycznej pojęcia parametru i argumentu są bardzo często używane zamiennie, jednak istnieje między nimi istotna różnica formalna.
• Parametr to zmienna zdefiniowana w nagłówku funkcji, która służy jako lokalny symbol zastępczy (placeholder) na dane wejściowe.
• Parametry określają, jakich informacji funkcja potrzebuje w momencie definicji.
• Argument to rzeczywista, konkretna wartość (np. liczba, tekst), którą przekazujemy do funkcji podczas jej wywoływania w kodzie.
• Można powiedzieć, że parametr to puste pudełko wewnątrz funkcji, a argument to konkretny przedmiot, który do tego pudełka wkładamy w trakcie uruchomienia.

def przyklad(parametr):  # 'parametr' to placeholder
    print(parametr)

przyklad("To jest argument")  # "To jest argument" to konkretna wartość
            

• Dodanie jednego parametru do funkcji pozwala na spersonalizowanie lub zmodyfikowanie jej działania na podstawie przekazanej wartości.
• Zdefiniowana zmienna staje się dostępna wewnątrz ciała funkcji jako lokalna zmienna o nazwie podanej w nawiasie.
• W momencie wywołania funkcji jesteśmy zobowiązani przekazać dokładnie jeden argument, inaczej Python zgłosi błąd TypeError.
• Przekazany argument może być dowolnego typu: liczbą, ciągiem znaków czy listą, co daje dużą elastyczność.
• Dzięki temu funkcja staje się uniwersalnym narzędziem, które potrafi przetwarzać różne dane według jednego schematu logicznego.

def kwadrat(liczba):
    wynik = liczba * liczba
    print(f"Kwadrat liczby {liczba} to {wynik}")

kwadrat(5)  # Wyświetli: Kwadrat liczby 5 to 25
            

• Funkcje w Pythonie mogą bez problemu przyjmować wiele parametrów wejściowych, co pozwala na budowanie bardziej skomplikowanych algorytmów obliczeniowych.
• W nagłówku definicji funkcji poszczególne parametry oddzielamy od siebie przecinkami wewnątrz nawiasów okrągłych.
• W ciele funkcji możemy swobodnie korzystać ze wszystkich zadeklarowanych zmiennych parametrycznych.
• Podczas wywoływania takiej funkcji musimy dostarczyć odpowiednią liczbę argumentów, zachowując domyślnie właściwą kolejność.
• Pozwala to na realizację zadań takich jak obliczanie pól figur geometrycznych, łączenie danych osobowych czy kalkulacja odsetek na lokacie.

def pole_prostokata(a, b):
    pole = a * b
    print(f"Pole prostokąta o bokach {a} i {b} wynosi {pole}")

pole_prostokata(4, 6)  # Przekazanie dwóch argumentów
            

• Domyślnym sposobem dopasowywania argumentów do parametrów w języku Python jest dopasowanie pozycyjne (ang. positional arguments).
• Oznacza to, że kolejność, w jakiej podajemy argumenty podczas wywołania funkcji, ściśle decyduje o tym, do których parametrów zostaną one przypisane.
• Pierwszy przekazany argument trafi do pierwszego parametru w nagłówku, drugi do drugiego i tak dalej.
• Zmiana kolejności argumentów pozycyjnych może całkowicie zmienić wynik działania funkcji lub doprowadzić do błędów typowania.
• Metoda ta jest bardzo naturalna i szybka do zapisu, ale wymaga od programisty doskonałej znajomości sygnatury wywoływanej funkcji.

def przedstaw_osobe(imie, wiek):
    print(f"Imię: {imie}, Wiek: {wiek}")

przedstaw_osobe("Tomasz", 25)  # Tomasz trafi do imie, 25 do wiek
# przedstaw_osobe(25, "Tomasz")  # BŁĄD LOGICZNY! Zamieniona kolejność!
            

• Alternatywnym i wysoce czytelnym sposobem wywoływania funkcji w Pythonie są argumenty nazwane (ang. keyword arguments).
• Pozwalają one na jawne wskazanie, do którego parametru przypisujemy daną wartość za pomocą zapisu nazwa_parametru = wartość.
• Dzięki temu kolejność podawania argumentów w wywołaniu funkcji przestaje mieć jakiekolwiek znaczenie dla interpretera.
• Zastosowanie argumentów nazwanych znacząco podnosi czytelność kodu programu, zwłaszcza przy funkcjach przyjmujących wiele parametrów o tym samym typie.
• Chroni to również przed pomyłkami polegającymi na zamianie kolejności zmiennych w rozbudowanych wywołaniach.

def ustawienia_konta(login, rola, aktywny):
    print(f"User: {login}, Rola: {rola}, Status: {aktywny}")

# Wywołanie z jawnym wskazaniem nazw parametrów (kolejność dowolna):
ustawienia_konta(rola="Moderator", aktywny=True, login="user123")
            

• Python pozwala na elastyczne łączenie w jednym wywołaniu funkcji argumentów podawanych pozycyjnie oraz argumentów nazwanych.
• Wymaga to jednak przestrzegania jednej, absolutnie żelaznej zasady składniowej: wszystkie argumenty pozycyjne muszą znajdować się przed argumentami nazwanymi.
• Próba umieszczenia choćby jednego argumentu pozycyjnego po argumencie nazwanym zakończy się natychmiastowym błędem składniowym SyntaxError.
• Zasada ta chroni interpreter przed niejednoznacznością przy dopasowywaniu wartości do zmiennych lokalnych.
• Mieszanie podejść jest przydatne, gdy pierwsze parametry funkcji są kluczowe, a kolejne służą do konfiguracji opcji dodatkowych.

def wyslij_mail(odbiorca, temat, tresc, pilny=False):
    print(f"Do: {odbiorca}, Temat: {temat}, Pilny: {pilny}")

# POPRAWNIE:
wyslij_mail("biuro@example.com", "Faktura", "W załączniku...", pilny=True)
# BŁĄD! SyntaxError: positional argument follows keyword argument:
# wyslij_mail(odbiorca="biuro@example.com", "Faktura", "W załączniku...")
            

• Definiując funkcję w Pythonie, możemy przypisać wybranym parametrom wartości domyślne za pomocą operatora przypisania = w nagłówku definicji.
• Sprawia to, że powiązane parametry stają się całkowicie opcjonalne podczas wywoływania funkcji przez programistę.
• Jeśli podczas wywołania nie przekażemy wartości dla takiego parametru, funkcja automatycznie użyje zadeklarowanej wartości domyślnej.
• Jeśli jednak przekażemy własny argument, domyślna wartość zostanie zignorowana na rzecz wartości podanej przez użytkownika.
• Podobnie jak w wywołaniu, w definicji parametry z wartościami domyślnymi muszą bezwzględnie znajdować się na samym końcu listy parametrów.

def powitanie(imie, tekst="Dzień dobry"):
    print(f"{tekst}, {imie}!")

powitanie("Jan")                 # Dzień dobry, Jan! (użyje domyślnego)
powitanie("Anna", "Cześć")        # Cześć, Anna! (nadpisze domyślny)
            

• Jedna z najbardziej klasycznych i podstępnych pułapek w języku Python dotyczy stosowania obiektów mutowalnych (takich jak listy czy słowniki) jako domyślnych wartości parametrów.
• Wartości domyślne parametrów są określane (tworzone) tylko raz – w momencie, gdy interpreter po raz pierwszy wczytuje i kompiluje definicję funkcji, a nie przy każdym jej wywołaniu.
• Oznacza to, że jeśli użyjemy listy jako wartości domyślnej, wszystkie kolejne wywołania funkcji bez tego argumentu będą współdzielić dokładnie tę samą instancję listy w pamięci! Modyfikacja tej listy w ciele funkcji wpłynie na jej stan przy następnych wywołaniach, co prowadzi do niezwykle trudnych do wykrycia błędów logicznych.

# NIEPOPRAWNIE:
def dodaj_do_listy_zle(element, lista=[]):
    lista.append(element)
    return lista

print(dodaj_do_listy_zle(1))  # [1]
print(dodaj_do_listy_zle(2))  # [1, 2] -- Uwaga! Lista współdzieli stan!
            

• Głównym celem większości funkcji jest przetworzenie danych i przekazanie wyniku z powrotem do miejsca, z którego funkcja została wywołana.
• Do tego celu służy słowo kluczowe return, po którym umieszczamy wartość lub zmienną, którą chcemy przekazać na zewnątrz.
• Instrukcja return ma dwojakie działanie: natychmiastowo przerywa dalsze wykonywanie kodu w ciele funkcji i przekazuje określoną wartość do programu głównego.
• Wszelkie linie kodu znajdujące się po instrukcji return w tym samym bloku zostaną całkowicie zignorowane przez interpreter Pythona jako nieosiągalne.
• Zwrócony wynik możemy przypisać do zmiennej lub użyć w wyrażeniu arytmetycznym.

def dodaj(a, b):
    suma = a + b
    return suma  # Zwrócenie sumy na zewnątrz
    print("To się nigdy nie wyświetli!")  # Kod nieosiągalny

wynik = dodaj(5, 10)  # wynik otrzyma wartość 15
            

• Rozróżnienie działania instrukcji return od funkcji print() to jeden z najczęstszych problemów, z jakimi borykają się początkujący adepci programowania.
• Funkcja print() służy wyłącznie do tymczasowego wyświetlenia tekstu na ekranie konsoli dla oczu użytkownika i nie przekazuje żadnych danych do dalszej obróbki w programie.
• Słowo kluczowe return przekazuje rzeczywiste dane w pamięci komputera z powrotem do programu, umożliwiając ich dalsze przetwarzanie, np. w instrukcjach warunkowych czy kolejnych kalkulacjach.
• Funkcja, która jedynie wyświetla dane za pomocą print(), z perspektywy kodu zwraca domyślną wartość None.

def tylko_print(x):
    print(x)  # Tylko pokazuje tekst w konsoli

def daje_return(x):
    return x  # Przekazuje dane do pamięci kodu

a = tylko_print(5)  # a otrzyma None!
b = daje_return(5)  # b otrzyma 5, gotowe do dalszych obliczeń!
            

• Choć w wielu językach programowania funkcja może zwrócić tylko jedną wartość, Python oferuje w tym obszarze niezwykle wygodne i eleganckie rozwiązanie.
• Stosując instrukcję return, możemy wymienić po przecinku wiele wartości lub zmiennych, które chcemy przekazać na zewnątrz funkcji.
• Pod maską interpreter Pythona automatycznie spakuje wszystkie te wartości w jedną, niemutowalną krotkę (ang. tuple) i zwróci ją jako pojedynczy obiekt.
• W miejscu wywołania możemy tę krotkę przypisać do jednej zmiennej lub dokonać jej natychmiastowego rozpakowania do wielu zmiennych jednocześnie, co jest niesamowicie praktyczną techniką.

def pobierz_wymiary():
    szerokosc = 1920
    wysokosc = 1080
    return szerokosc, wysokosc  # Zwraca krotkę (1920, 1080)

w, h = pobierz_wymiary()  # Rozpakowanie na dwie zmienne w locie
            

• W języku Python nie ma obowiązku umieszczania instrukcji return na końcu każdej zdefiniowanej funkcji.
• Jeśli funkcja nie zawiera słowa kluczowego return lub instrukcja ta zostanie wywołana bez żadnej wartości towarzyszącej, funkcja automatycznie i po cichu zwróci specjalny obiekt None.
• Oznacza to, że z punktu widzenia interpretera każda funkcja zawsze coś zwraca.
• Funkcje bez return są nazywane procedurami i służą do wykonywania operacji powodujących efekty uboczne, takich jak zapisywanie danych do pliku, modyfikacja globalnych obiektów czy rysowanie grafik na ekranie.

def zapisz_log(tekst):
    print(f"Zapisano log: {tekst}")  # Brak instrukcji return

wynik = zapisz_log("Uruchomienie")
print(wynik)  # Wyświetli: None
            

• Technika wczesnego zwracania wartości (ang. early return) to popularny wzorzec projektowy, który polega na natychmiastowym wyjściu z funkcji za pomocą instrukcji return, gdy tylko zostaną spełnione określone warunki brzegowe (np. błędy walidacji danych).
• Pozwala to na uniknięcie pisania skomplikowanych, głęboko zagnieżdżonych struktur warunkowych if-else wewnątrz ciała funkcji.
• Kod staje się znacznie bardziej płaski, co diametralnie ułatwia jego późniejszą analizę i czytanie.
• Wczesny return działa jak bezpiecznik: jeśli dane wejściowe są niepoprawne, funkcja od razu kończy bieg, oszczędzając zasoby procesora i skracając ścieżkę wykonania.

def podziel(a, b):
    if b == 0:
        return "Błąd: dzielenie przez zero!"  # Wczesne wyjście
    return a / b  # Wykonane tylko jeśli b != 0
            

• Zmienne, które tworzymy i którym przypisujemy wartości wewnątrz ciała funkcji, to zmienne lokalne (ang. local variables).
• Posiadają one ograniczony zasięg (ang. scope), co oznacza, że są widoczne i można z nich korzystać wyłącznie wewnątrz tej konkretnej funkcji.
• Zmienne te powstają w pamięci w momencie wywołania funkcji i są z niej bezpowrotnie usuwane zaraz po jej zakończeniu.
• Próba odwołania się do zmiennej lokalnej z poziomu programu głównego zakończy się natychmiastowym błędem NameError.
• Dzięki temu funkcje są odizolowane, co zapobiega przypadkowym konfliktom nazw zmiennych w różnych modułach aplikacji.

def ustaw_wynik():
    zmienna_lokalna = 100  # Zmienna istnieje tylko w tej funkcji
    print(zmienna_lokalna)

ustaw_wynik()
# print(zmienna_lokalna)  # BŁĄD! NameError: name 'zmienna_lokalna' is not defined
            

• Zmienne zdefiniowane w głównym pliku programu, poza jakimikolwiek funkcjami, to zmienne globalne (ang. global variables).
• Posiadają one zasięg globalny, co oznacza, że ich wartość może być bez przeszkód odczytywana z dowolnego miejsca w kodzie, w tym również z wnętrza wszystkich zdefiniowanych funkcji.
• Stanowią one wygodny sposób na przechowywanie konfiguracji programu czy wspólnego stanu aplikacji.
• Należy jednak pamiętać, że chociaż odczyt zmiennej globalnej z poziomu funkcji jest bardzo prosty, to próba bezpośredniej modyfikacji jej wartości bez dodatkowych deklaracji spowoduje jedynie utworzenie nowej zmiennej lokalnej o tej samej nazwie, pozostawiając oryginał bez zmian.

nazwa_aplikacji = "SuperKalkulator"  # Zmienna globalna

def wyswietl_naglowek():
    print(f"=== {nazwa_aplikacji} ===")  # Bezproblemowy odczyt globalnej

wyswietl_naglowek()
            

• Gdy odwołujemy się do nazwy zmiennej w Pythonie, interpreter szuka jej wartości w ściśle określonej kolejności opisanej akronimem LEGB.
• Najpierw przeszukiwany jest zasięg lokalny (Local) – wewnątrz bieżącej funkcji.
• Jeśli tam jej nie ma, szuka w funkcjach nadrzędnych (Enclosing), co ma miejsce przy funkcjach zagnieżdżonych.
• Następnie sprawdza zasięg globalny (Global) w skali całego pliku.
• Na samym końcu interpreter zagląda do zasięgu wbudowanego (Built-in) – zawierającego predefiniowane funkcje języka, takie jak print() czy len().
• Jeśli nazwa nie zostanie odnaleziona w żadnym z tych czterech obszarów, program zgłasza błąd NameError.

x = "Globalny"

def zewnetrzna():
    x = "Nadrzędny (Enclosing)"
    def wewnetrzna():
        x = "Lokalny"
        print(x)  # Wypisze "Lokalny" zgodnie z regułą LEGB
    wewnetrzna()
zewnetrzna()
            

• Jeśli z poziomu wnętrza funkcji chcemy zmodyfikować wartość zmiennej zdefiniowanej w zasięgu globalnym, musimy poinformować o tym interpreter za pomocą słowa kluczowego global.
• Instrukcja global nazwa_zmiennej umieszczona na samym początku ciała funkcji nakazuje interpreterowi powiązanie tej nazwy bezpośrednio z oryginalną zmienną globalną, zamiast tworzenia nowej zmiennej lokalnej.
• Od tego momentu każde przypisanie wartości w ciele funkcji fizycznie zmieni stan zmiennej w programie głównym.
• Należy jednak używać tego mechanizmu z ogromną ostrożnością, gdyż nadużywanie modyfikacji globalnych dramatycznie utrudnia analizę i debugowanie przepływu danych.

licznik = 0  # Globalny licznik

def zwieksz_licznik():
    global licznik  # Odwołanie do zmiennej globalnej
    licznik += 1

zwieksz_licznik()
print(licznik)  # Wyświetli: 1 (zmienna została zmodyfikowana!)
            

• Chociaż modyfikacja zmiennych globalnych za pomocą instrukcji global jest technicznie bardzo prosta, w inżynierii oprogramowania jest ona powszechnie uznawana za złą praktykę projektową.
• Funkcje modyfikujące stan globalny tracą swoją niezależność i stają się trudne do wielokrotnego wykorzystania w innych częściach systemu.
• Powstają tzw. efekty uboczne (ang. side effects), które sprawiają, że działanie jednej funkcji zależy w nieprzewidywalny sposób od kolejności wywoływania innych funkcji.
• Znacznie trudniej jest również pisać testy jednostkowe dla takiego kodu.
• Zamiast tego zaleca się przekazywanie danych jako parametrów i zwracanie zmodyfikowanych wyników za pomocą instrukcji return.

• Czasami projektujemy funkcje, które muszą przyjąć nieznaną z góry, zmienną liczbę argumentów pozycyjnych (np. funkcja obliczająca sumę wszystkich podanych liczb).
• Python pozwala na elegancką obsługę takiej sytuacji poprzez umieszczenie gwiazdki * przed nazwą parametru w definicji funkcji, najczęściej jako *args.
• Gwiazdka nakazuje interpreterowi spakowanie wszystkich nadmiarowych argumentów pozycyjnych przekazanych podczas wywołania w jedną, wspólną krotkę (tuple).
• Wewnątrz funkcji zmienna args jest zwykłą krotką, po której możemy bez przeszkód iterować za pomocą pętli for czy przekazywać ją do innych funkcji.

def suma_wielu(*liczby):
    # 'liczby' to krotka zawierająca wszystkie przekazane wartości
    suma = sum(liczby)
    print(f"Suma: {suma}")

suma_wielu(1, 2, 3)        # Suma: 6
suma_wielu(10, 20, 30, 40)  # Suma: 100
            

• Podobnie jak w przypadku argumentów pozycyjnych, możemy chcieć, aby nasza funkcja potrafiła przyjąć nieokreśloną wcześniej liczbę opcjonalnych argumentów nazwanych.
• W tym celu stosujemy konstrukcję z dwiema gwiazdkami ** przed nazwą parametru, tradycyjnie zapisaną jako **kwargs (ang. keyword arguments).
• Ten zapis powoduje, że wszystkie nadmiarowe argumenty przekazane po nazwie zostaną spakowane w jeden, wspólny słownik (dict).
• Kluczami słownika stają się nazwy parametrów z wywołania, a wartościami przypisane do nich dane.
• Daje to niesamowite możliwości przy konfiguracji obiektów czy przekazywaniu opcjonalnych filtrów.

def pokaz_profil(**dane):
    # 'dane' to słownik par klucz-wartość
    for klucz, wartosc in dane.items():
        print(f"{klucz}: {wartosc}")

pokaz_profil(imie="Jan", miasto="Warszawa", wiek=30)
            

• Język Python umożliwia zdefiniowanie niezwykle uniwersalnej funkcji, która potrafi przyjąć absolutnie dowolną kombinację argumentów pozycyjnych oraz nazwanych w jednym wywołaniu.
• Aby to osiągnąć, łączymy w definicji parametry *args oraz **kwargs w jednym nagłówku.
• Niezwykle ważne jest jednak zachowanie rygorystycznej kolejności deklaracji: najpierw definiujemy zwykłe parametry, potem *args, a na samym końcu **kwargs.
• Taka kolejność gwarantuje, że interpreter Pythona bezbłędnie przypisze wszystkie przekazane wartości do odpowiednich zmiennych, nie powodując konfliktów ani niejednoznaczności.

def uniwersalna(*args, **kwargs):
    print(f"Pozycyjne (krotka): {args}")
    print(f"Nazwane (słownik): {kwargs}")

uniwersalna(1, 2, status="aktywny", kod=200)
            

• Operatorów gwiazdki * oraz podwójnej gwiazdki ** możemy używać nie tylko przy definiowaniu parametrów funkcji, ale również przy ich wywoływaniu.
• Proces ten nazywamy rozpakowywaniem argumentów (ang. argument unpacking).
• Jeśli posiadamy listę lub krotkę i chcemy przekazać jej elementy jako osobne argumenty pozycyjne do funkcji, poprzedzamy kolekcję pojedynczą gwiazdką, np. funkcja(*lista).
• Jeśli natomiast dysponujemy słownikiem i chcemy dopasować jego pary klucz-wartość do parametrów nazwanych funkcji, stosujemy podwójną gwiazdkę funkcja(**slownik).
• Zapobiega to ręcznemu przepisywaniu elementów.

def dodaj_trzy(a, b, c):
    return a + b + c

liczby = [10, 20, 30]
wynik = dodaj_trzy(*liczby)  # Rozpakuje listę do parametrów a, b, c
print(wynik)  # Wyświetli: 60
            

• Dobre praktyki programistyczne wymagają, aby każda zdefiniowana funkcja była czytelnie udokumentowana, co ułatwia jej późniejsze wykorzystanie i rozwój.
• W Pythonie do tego celu służy tzw. docstring – czyli specjalny łańcuch znaków ujęty w potrójne cudzysłowy """, umieszczony bezpośrednio w pierwszej linii ciała funkcji.
• W docstringu opisujemy zwięźle przeznaczenie funkcji, znaczenie parametrów wejściowych oraz typ i sens zwracanej wartości.
• Zaletą docstringa jest fakt, że jest on wbudowanym elementem struktury kodu – możemy go dynamicznie odczytać w trakcie działania programu za pomocą atrybutu funkcja.__doc__ lub wywołując funkcję help(funkcja).

def oblicz_vat(cena_netto):
    """Oblicza wartość podatku VAT (23%) dla podanej ceny netto.
    
    Argumenty:
        cena_netto (float): Cena podstawowa produktu.
    Zwraca:
        float: Wartość podatku VAT.
    """
    return cena_netto * 0.23
            

• Python jest językiem typowanym dynamicznie, co oznacza, że zmienne mogą swobodnie zmieniać swoje typy w trakcie działania programu.
• Od wersji 3.5 wprowadzono jednak opcjonalny mechanizm podpowiedzi typów (ang. type hints), który pozwala na jawne zadeklarowanie oczekiwanych typów parametrów oraz typu zwracanego wyniku.
• Robimy to za pomocą dwukropka po nazwie parametru (np. x: int) oraz strzałki przed dwukropkiem nagłówka (np. -> str).
• Podpowiedzi te nie są wymuszane przez interpreter podczas uruchomienia programu, lecz służą jako potężne wsparcie dla edytorów kodu (autouzupełnianie, ostrzeżenia) oraz zewnętrznych analizatorów statycznych (np. mypy).

def przygotuj_napis(tekst: str, powtorzenia: int) -> str:
    # Parametry i wynik mają jasno określone oczekiwane typy
    return tekst * powtorzenia
            

• W języku Python funkcje są traktowane jako obiekty pierwszej klasy (ang. first-class citizens).
• Oznacza to, że funkcja jest takim samym obiektem w pamięci jak liczba całkowita, ciąg znaków czy lista.
• Możemy ją bez problemu przypisać do nowej zmiennej, przechowywać wewnątrz struktur danych (np. w listach czy słownikach), a także przekazywać jako argument wejściowy do innych funkcji.
• Ta właściwość leży u podstaw zaawansowanego programowania funkcyjnego i pozwala na tworzenie wysoce elastycznych architektur kodu.
• Przypisanie funkcji do zmiennej odbywa się bez użycia nawiasów okrągłych, co pozwala na jej wywołanie za pomocą nowej nazwy.

def powitaj():
    print("Witaj!")

zmienna_funkcyjna = powitaj  # Przypisanie referencji (bez nawiasów)
zmienna_funkcyjna()         # Wywołanie funkcji poprzez zmienną
            

• W inżynierii oprogramowania jedną z najważniejszych zasad czystego kodu jest zasada pojedynczej odpowiedzialności (ang. Single Responsibility Principle, czyli Zasada Jednej Odpowiedzialności).
• W kontekście funkcji oznacza to, że każda funkcja powinna wykonywać dokładnie jedno, dobrze zdefiniowane zadanie i robić to bezbłędnie.
• Jeśli funkcja zaczyna pobierać dane od użytkownika, przetwarzać je matematycznie, zapisywać do pliku i jednocześnie drukować raport, staje się monolitycznym "kodem spaghetti".
• Taki kod jest niezwykle trudny w utrzymaniu i testowaniu.
• Rozbicie go na kilka mniejszych, wyspecjalizowanych funkcji, które komunikują się między sobą, drastycznie podnosi jakość i profesjonalizm oprogramowania.

• Aby bezpiecznie rozwiązać problem mutowalnych argumentów domyślnych (omawiany w slajdzie 13), stosuje się powszechnie uznany i sprawdzony wzorzec projektowy.
• Jako wartość domyślną parametru w nagłówku funkcji przypisujemy niemutowalną wartość None.
• Następnie, na samym początku ciała funkcji, umieszczamy prosty warunek sprawdzający: jeśli przekazana wartość parametru jest równa None, dynamicznie tworzymy i przypisujemy nową, pustą listę wewnątrz lokalnego zasięgu.
• Dzięki temu przy każdym uruchomieniu funkcji bez argumentu tworzona jest zupełnie świeża instancja listy w pamięci, co całkowicie eliminuje błędy współdzielenia stanu.

# POPRAWNA INICJALIZACJA:
def dodaj_do_listy_dobrze(element, lista=None):
    if lista is None:
        lista = []  # Nowa lista tworzona przy każdym wywołaniu
    lista.append(element)
    return lista
            

• Gdy definiujemy funkcję wewnątrz innej funkcji (tzw. funkcje zagnieżdżone), funkcja wewnętrzna ma pełny dostęp do odczytu zmiennych zdefiniowanych w funkcji nadrzędnej (zgodnie z regułą LEGB, zasięg Enclosing).
• Jeśli jednak chcemy zmodyfikować wartość takiej zmiennej nadrzędnej z poziomu funkcji wewnętrznej, samo przypisanie utworzyłoby nową zmienną lokalną.
• Aby temu zapobiec, Python udostępnia specjalne słowo kluczowe nonlocal.
• Deklaracja nonlocal nazwa_zmiennej informuje interpreter, że chcemy powiązać nazwę ze zmienną z bezpośrednio wyższego, nadrzędnego zasięgu (wykluczając zasięg globalny).
• Jest to kluczowe narzędzie przy tworzeniu domknięć.

def licznik_krokow():
    stan = 0  # Zmienna w zasięgu nadrzędnym (Enclosing)
    def klik():
        nonlocal stan  # Deklaracja nonlocal
        stan += 1
        return stan
    return klik
            

• Funkcje lambda (nazywane również funkcjami anonimowymi) to zwięzła, skrócona składnia służąca do tworzenia prostych, jednoliniowych funkcji bez konieczności nadawania im formalnej nazwy za pomocą def.
• Definiujemy je za pomocą słowa kluczowego lambda, po którym wymieniamy parametry, stawiamy dwukropek i zapisujemy pojedyncze wyrażenie matematyczne lub logiczne, którego wynik jest automatycznie zwracany.
• Funkcje te nie mogą zawierać skomplikowanych pętli ani wielu instrukcji – ich siła tkwi w prostocie.
• Są powszechnie stosowane jako szybkie argumenty w operacjach sortowania, filtrowania czy transformacji danych w kolekcjach.

# Tradycyjny zapis:
def pomnoz(x): return x * 2

# Zapis za pomocą funkcji lambda:
dwa_razy = lambda x: x * 2
print(dwa_razy(5))  # Wyświetli: 10
            

• Wbudowana w Pythonie funkcja map() to wysoce zoptymalizowane narzędzie służące do transformowania danych w kolekcjach bez konieczności pisania jawnych pętli for.
• Funkcja map(funkcja, sekwencja) przyjmuje jako argumenty inną funkcję oraz obiekt iterowalny (np. listę), a następnie stosuje (wykonuje) tę funkcję na każdym pojedynczym elemencie podanej kolekcji.
• Wynikiem działania jest specjalny iterator, który możemy łatwo przekształcić z powrotem w tradycyjną listę za pomocą konstruktora list().
• Jest to technika niezwykle wydajna i elegancka, stanowiąca fundament programowania funkcyjnego w Pythonie.

liczby = [1, 2, 3, 4]
# Podniesienie wszystkich liczb do kwadratu za pomocą map i lambda:
kwadraty = list(map(lambda x: x ** 2, liczby))
print(kwadraty)  # Wyświetli: [1, 4, 9, 16]
            

• Kolejnym potężnym narzędziem wbudowanym w język Python jest funkcja filter(), która służy do selektywnego wybierania elementów z kolekcji na podstawie określonego warunku logicznego.
• Składnia filter(funkcja_predykat, sekwencja) wymaga przekazania funkcji testującej (która zwraca wartość True lub False) oraz kolekcji wejściowej.
• Funkcja filter() przechodzi po każdym elemencie i zachowuje w wyniku wyłącznie te, dla których funkcja testująca zwróciła wartość True.
• Podobnie jak map, zwraca wydajny iterator, który najczęściej konwertujemy na listę.
• Użycie filter w połączeniu z lambdą daje niesamowicie zwięzły i czytelny kod.

wiek = [12, 18, 25, 15, 30]
# Wybranie wyłącznie osób pełnoletnich za pomocą filter:
dorosli = list(filter(lambda x: x >= 18, wiek))
print(dorosli)  # Wyświetli: [18, 25, 30]
            

• Rekurencja (nazywana również rekursją) to zaawansowana technika programistyczna, w której zdefiniowana funkcja wywołuje samą siebie z wnętrza własnego ciała.
• Pozwala to na eleganckie rozwiązywanie problemów, które mają strukturę samopodobną (np. drzewa katalogów, fraktale czy obliczenia matematyczne jak silnia).
• Każda poprawnie zaprojektowana funkcja rekurencyjna musi bezwzględnie posiadać dwa kluczowe elementy: warunek bazowy (stopu), który przerywa dalsze wywołania i zwraca konkretną wartość, oraz krok rekurencyjny, w którym funkcja wywołuje siebie z nowymi, mniejszymi argumentami.
• Brak warunku stopu doprowadzi do przepełnienia stosu pamięci i błędu RecursionError.

def silnia(n):
    if n <= 1:
        return 1  # Warunek bazowy (stopu)
    return n * silnia(n - 1)  # Krok rekurencyjny

print(silnia(5))  # Wyświetli: 120
            

• Domknięcie (ang. closure) to niezwykle ciekawa technika programistyczna, która powstaje wtedy, gdy zagnieżdżona funkcja wewnętrzna zapamiętuje i zachowuje dostęp do zmiennych lokalnych z funkcji nadrzędnej (zasięgu Enclosing) nawet po tym, jak funkcja nadrzędna zakończyła już w pełni swoje działanie i została zdjęta ze stosu wywołań.
• Aby domknięcie mogło zaistnieć w Pythonie, musimy spełnić trzy warunki: mieć funkcję zagnieżdżoną, funkcja wewnętrzna musi odwoływać się do zmiennej nadrzędnej, a funkcja nadrzędna musi zwrócić obiekt funkcji wewnętrznej.
• Domknięcia pozwalają na bezpieczne ukrywanie stanu (hermetyzację danych) bez konieczności tworzenia pełnych klas.

def stworz_powitanie(tekst_powitania):
    def przywitaj(imie):
        print(f"{tekst_powitania}, {imie}!")  # Zapamiętana zmienna
    return przywitaj

milo = stworz_powitanie("Miło Cię widzieć")
milo("Piotr")  # Wyświetli: Miło Cię widzieć, Piotr!
            

• Ponieważ funkcje w Pythonie są pełnoprawnymi obiektami, możemy bez przeszkód przekazywać je jako parametry wejściowe do innych funkcji.
• Technikę tę nazywamy często mechanizmem wywołań zwrotnych (ang. callbacks).
• Pozwala ona na napisanie bardzo ogólnej, elastycznej funkcji sterującej, której konkretne zachowanie w trakcie działania decydujemy dynamicznie, podsyłając odpowiednią funkcję pomocniczą jako argument.
• Jest to powszechnie stosowane w bibliotekach graficznych do obsługi zdarzeń (np. co ma się stać po kliknięciu przycisku), w systemach przetwarzania danych czy przy zaawansowanym sortowaniu elementów.

def wykonaj_operacje(a, b, operacja):
    return operacja(a, b)  # Wywołanie przekazanej funkcji

pomnoz = lambda x, y: x * y
wynik = wykonaj_operacje(4, 5, pomnoz)  # Przekazanie lambdy jako argumentu
print(wynik)  # Wyświetli: 20
            

• Python pozwala na bezproblemowe definiowanie funkcji wewnątrz ciał innych funkcji – struktury takie nazywamy funkcjami zagnieżdżonymi lub wewnętrznymi (ang. nested functions).
• Funkcja wewnętrzna jest całkowicie ukryta przed światem zewnętrznym – jest widoczna i może być wywołana wyłącznie z poziomu ciał funkcji nadrzędnej, w której została zadeklarowana.
• Używa się ich głównie jako funkcji pomocniczych do wykonywania powtarzalnych, lokalnych kalkulacji, co zapobiega zanieczyszczaniu globalnej przestrzeni nazw.
• Ponadto, funkcje zagnieżdżone stanowią absolutną podstawę techniczną do tworzenia dekoratorów oraz struktur domknięć w zaawansowanych aplikacjach.

def kalkulator_brutto(netto):
    def pobierz_podatek():
        return netto * 0.23  # Dostęp do zmiennej netto
    return netto + pobierz_podatek()

print(kalkulator_brutto(100))  # Wyświetli: 123.0
            

• Przeanalizujmy kompletny, w pełni poprawny i modularny program kalkulatora naukowego, który doskonale ilustruje w praktyce podział logiki na małe, wyspecjalizowane funkcje.
• Każde działanie matematyczne (dodawanie, odejmowanie, potęgowanie) zostało wydzielone do osobnej, dedykowanej funkcji o wysokiej czytelności.
• Główna funkcja sterująca pobiera wybór użytkownika, a następnie za pomocą mechanizmu dopasowania słownikowego (lub instrukcji match-case) dynamicznie wywołuje odpowiednią funkcję obliczeniową.
• Taka architektura sprawia, że dodanie nowego działania (np. logarytmu) polega jedynie na dopisaniu małej funkcji i dodaniu jednej pozycji w konfiguracji, nie naruszając działania reszty kodu.

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

def kalkulator(x, y, operacja):
    menu = {"+": dodaj, "**": potega}
    func = menu.get(operacja)
    if func:
        return func(x, y)
    return "Nieznana operacja"

print(kalkulator(2, 3, "**"))  # Wyświetli: 8
            

• Kolejnym klasycznym zastosowaniem podziału na funkcje jest system autoryzacji użytkowników w aplikacji.
• Zamiast pisać jeden olbrzymi ciąg instrukcji warunkowych, dzielimy cały proces weryfikacji na małe, niezależne funkcje logiczne.
• Pierwsza funkcja waliduje poprawność formatu loginu, druga sprawdza siłę hasła (np. wymagana długość i cyfry), a trzecia dokonuje ostatecznego porównania z bazą danych użytkowników.
• Taki podział sprawia, że każdą regułę bezpieczeństwa możemy niezależnie testować, a ewentualna zmiana wymagań dotyczących haseł nie wpłynie na proces samego sprawdzania loginu.

def sprawdz_dlugosc(haslo: str) -> bool:
    return len(haslo) >= 8

def waliduj_rejestracje(haslo):
    if not sprawdz_dlugosc(haslo):
        return "Hasło za krótkie!"
    return "Rejestracja pomyślna."

print(waliduj_rejestracje("tajne_haslo_123"))  # Rejestracja pomyślna.
            

• Praca z danymi wprowadzonymi przez użytkowników bardzo często wymaga ich dokładnego oczyszczenia i standaryzacji przed zapisem do bazy.
• W tym programie używamy zestawu funkcji do sformatowania imion, nazwisk oraz numerów telefonów do jednolitej postaci.
• Jedna funkcja zajmuje się czyszczeniem zbędnych białych znaków i zamianą na wielkie litery, inna weryfikuje czy numer telefonu zawiera odpowiednią liczbę cyfr i dodaje międzynarodowy prefiks.
• Dzięki takiemu podziałowi, kod jest łatwy do modyfikacji, a standaryzacja kolejnych pól (np. adresów e-mail) polega jedynie na dopisaniu nowej funkcji formatującej i wpięciu jej do głównego potoku przetwarzania.

def oczysc_tekst(tekst: str) -> str:
    return tekst.strip().title()

def formatuj_telefon(numer: str) -> str:
    cyfry = "".join([c for c in numer if c.isdigit()])
    return f"+48 {cyfry}"

imie_czyste = oczysc_tekst("  jAN  ")  # Jan
tel_format = formatuj_telefon("123-456-789")  # +48 123456789
            

• Unikanie stosowania słowa kluczowego global to jeden z wyznaczników profesjonalnego podejścia do pisania kodu w Pythonie.
• Zamiast modyfikować zmienne globalne wewnątrz funkcji, powinniśmy przekazywać aktualny stan jako parametry wejściowe, a zmodyfikowane wartości zwracać za pomocą instrukcji return.
• W miejscu wywołania przypisujemy zwrócony wynik z powrotem do zmiennej głównej.
• Takie podejście sprawia, że funkcje stają się tzw. funkcjami czystymi (ang. pure functions), co oznacza, że ich wynik zależy wyłącznie od argumentów wejściowych i nie powodują one żadnych nieoczekiwanych efektów ubocznych w pamięci komputera.

• Napiszmy prosty kalkulator, w którym każde podstawowe działanie arytmetyczne (dodawanie, odejmowanie, mnożenie, dzielenie) jest realizowane przez osobną funkcję.
• Zadaniem ćwiczenia jest zaimplementowanie funkcji w taki sposób, aby funkcja dzielenia bezpiecznie obsługiwała przypadek dzielenia przez zero i zwracała odpowiedni komunikat o błędzie zamiast powodowania awarii programu.
• Następnie napisz główną funkcję sterującą, która zapyta użytkownika o dwie liczby oraz rodzaj operacji, po czym wywoła odpowiednią funkcję i wyświetli wynik na ekranie.
• To klasyczne ćwiczenie doskonale utrwala podstawy definiowania parametrów i zwracania wartości.

def dodaj(a, b): return a + b
def podziel(a, b):
    if b == 0: return "Nie dziel przez zero!"
    return a / b

print(dodaj(10, 5))    # 15
print(podziel(10, 0))  # Nie dziel przez zero!
            

• Stwórzmy zestaw funkcji walidujących dane rejestracyjne wprowadzane przez użytkownika.
• Pierwsza funkcja powinna sprawdzać, czy podany wiek jest poprawną liczbą całkowitą większą od zera i czy użytkownik jest pełnoletni (wiek >= 18).
• Druga funkcja powinna walidować login, upewniając się, że nie zawiera on spacji i ma długość co najmniej 5 znaków.
• Trzecia funkcja integruje te weryfikacje i decyduje o dopuszczeniu użytkownika do rejestracji.
• To ćwiczenie uczy programowania obronnego oraz poprawnego łączenia wielu funkcji logicznych w jeden spójny system decyzyjny.

def czy_pelnoletni(wiek: int) -> bool:
    return wiek >= 18

def czy_poprawny_login(login: str) -> bool:
    return len(login) >= 5 and " " not in login

print(czy_pelnoletni(20))        # True
print(czy_poprawny_login("user"))  # False (za krótki)
            

• Napisz funkcję, która przyjmuje surowy ciąg znaków wprowadzony przez użytkownika i dokonuje jego kompleksowego formatowania.
• Zadaniem funkcji jest usunięcie wszelkich zbędnych spacji z początku i końca tekstu, zamiana wszystkich liter na małe, a następnie zamiana pierwszej litery całego zdania na wielką (formatowanie typu capitalize).
• Dodatkowo, funkcja powinna zastąpić wszystkie wystąpienia określonego słowa niecenzuralnego ciągiem gwiazdek.
• Ćwiczenie to utrwala wiedzę o przekazywaniu parametrów tekstowych, niemutowalności napisów w Pythonie oraz efektywnym korzystaniu z wbudowanych metod klasy str.

def cenzura(tekst: str, brzydkie_slowo: str) -> str:
    tekst_czysty = tekst.strip().lower().capitalize()
    return tekst_czysty.replace(brzydkie_slowo, "***")

surowy = "  to jest złe zachowanie!  "
print(cenzura(surowy, "złe"))  # "To jest *** zachowanie!"
            

• Pisanie profesjonalnego kodu wymaga stosowania się do sprawdzonych reguł inżynierii oprogramowania.
• Zawsze nadawaj funkcjom jasne, opisowe nazwy (najlepiej czasowniki w języku polskim lub angielskim), które dokładnie odzwierciedlają ich przeznaczenie.
• Pilnuj, aby pojedyncza funkcja nie była zbyt długa – jeśli ciało funkcji przekracza 20-30 linii kodu, to znak, że należy ją podzielić na mniejsze podfunkcje.
• Pamiętaj o dokładnym dokumentowaniu kodu za pomocą docstringów oraz opcjonalnym stosowaniu type hintów.
• Na koniec, unikaj stosowania efektów ubocznych i dąż do tego, aby Twoje funkcje były jak najbardziej niezależne.

• Gratulacje! W tej części kursu opanowałeś jeden z absolutnie najważniejszych i najbardziej fundamentalnych pojęć w świecie programowania – funkcje.
• Dowiedziałeś się, jak prawidłowo definiować bloki kodu za pomocą słowa kluczowego def oraz jak elastycznie przekazywać parametry pozycyjne, nazwane i domyślne.
• Opanowałeś instrukcję return służącą do bezpiecznego zwracania danych do programu.
• Poznałeś zasady rządzące regułą LEGB i zasięgami zmiennych lokalnych oraz globalnych.
• Ta niezwykle solidna wiedza stanowi kluczowy krok na drodze do projektowania modularnych, czytelnych i w pełni profesjonalnych aplikacji.

# Opanowałeś funkcje w Pythonie!
# Potrafisz: def, return, parametry, LEGB, *args, **kwargs i lambdy!
# Czas na kolejny krok: praca z trwałymi danymi na dysku!
            

• W kolejnej części naszego kursu zrobimy bardzo ważny krok w stronę praktycznego zachowywania efektów pracy naszych programów, badając szczegółowo mechanikę obsługi plików w języku Python.
• Do tej pory wszystkie dane wprowadzane do programu znikały bezpowrotnie po jego wyłączeniu.
• W części 11 dowiemy się, jak bezpiecznie otwierać, odczytywać i zapisywać pliki tekstowe oraz binarne.
• Opanujemy nowoczesny menedżer kontekstu with open() as f:, który gwarantuje automatyczne i bezpieczne zamykanie połączeń z plikami na dysku.
• Na koniec poznamy niezwykle popularne formaty wymiany danych: pliki CSV oraz struktury JSON.

# W części 11 poznamy m.in.:
# - Otwieranie plików (open) i bezpieczny menedżer kontekstu (with)
# - Odczyt (read, readline) oraz zapis (write, writelines) danych
# - Zaawansowaną obsługę popularnych formatów CSV oraz JSON