Podstawy Pythona - Funkcje

Czym jest funkcja?

Funkcja to fragment kodu, który wykonuje określone zadanie i może zwracać wynik. Najprostsza definicja wygląda tak:

Python
Kopiuj
1
2
3
4
def przywitaj():
    print("Cześć, świecie!")

przywitaj()

Funkcja jest jak mini-program w programie — wykonuje jedno, konkretne działanie. Możesz ją wywołać wielokrotnie, w różnych miejscach kodu, bez powielania logiki.

Argumenty – przekazywanie danych do funkcji

Funkcje stają się naprawdę użyteczne, gdy potrafią pracować na danych. Argumenty pozwalają przekazać wartości do wnętrza funkcji:

Python
Kopiuj
1
2
3
4
5
def przywitaj(imie):
    print("Cześć,", imie, "!")

przywitaj("Kacper")
przywitaj("Ola")

Tutaj imie to parametr funkcji – zmienna lokalna widoczna tylko wewnątrz funkcji. Przy wywołaniu przekazujesz konkretną wartość, zwaną argumentem.

Zwracanie wartości

Nie każda funkcja musi coś drukować. Często lepiej, by zwracała wynik, a nie od razu go wyświetlała. Służy do tego słowo kluczowe return:

Python
Kopiuj
1
2
3
4
5
def dodaj(a, b):
    return a + b

wynik = dodaj(5, 3)
print("Suma to:", wynik)

return kończy działanie funkcji i zwraca wartość do miejsca, z którego funkcja została wywołana.

Typy argumentów – domyślne, nazwane i zmienne

Python daje dużą elastyczność w sposobie przekazywania danych do funkcji.

Argumenty domyślne

Możesz przypisać wartość domyślną do parametru:

Python
Kopiuj
1
2
3
4
5
def przywitaj(imie="Nieznajomy"):
    print("Cześć,", imie)

przywitaj()
przywitaj("Ania")

Jeśli nie podasz argumentu – zostanie użyta wartość domyślna.

Argumenty nazwane

Podczas wywołania możesz wskazać, który parametr odpowiada której wartości:

Python
Kopiuj
1
2
3
4
def przedstaw(imie, wiek):
    print("Mam na imię", imie, "i mam", wiek, "lat.")

przedstaw(wiek=25, imie="Marek")

To poprawia czytelność i eliminuje błędy wynikające z kolejności argumentów.

Argumenty zmienne (*args, **kwargs)

Czasem nie wiesz, ile argumentów dostaniesz. Wtedy użyj:

• *args – przyjmuje dowolną liczbę pozycyjnych argumentów,
• **kwargs – przyjmuje dowolną liczbę nazwanych argumentów.

Python
Kopiuj
1
2
3
4
5
def pokaz_args(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

pokaz_args(1, 2, 3, imie="Kacper", wiek=30)

To potężny mechanizm pozwalający pisać bardzo elastyczne funkcje.

Zakres zmiennych – lokalne i globalne

Zmienna utworzona wewnątrz funkcji istnieje tylko tam:

Python
Kopiuj
1
2
3
4
5
6
def test():
    x = 10
    print("W środku funkcji:", x)

test()
print(x)# Błąd – zmienna x nie istnieje poza funkcją

Jeśli chcesz użyć zmiennej globalnej wewnątrz funkcji, musisz to jawnie zaznaczyć:

Python
Kopiuj
1
2
3
4
5
6
7
8
x = 5

def zmien_globalna():
    global x
    x = 10

zmien_globalna()
print(x)# teraz 10

Ale uwaga — nadużywanie zmiennych globalnych to zły nawyk. Lepsze jest przekazywanie danych przez argumenty i zwracanie wyników.

Funkcje anonimowe (lambda)

Nie każda funkcja musi mieć nazwę. Dla prostych operacji Python oferuje funkcje anonimowe, definiowane słowem lambda.

Python
Kopiuj
1
2
dodaj = lambda a, b: a + b
print(dodaj(3, 4))# 7

To krótsza forma zapisu funkcji jednozdaniowej. Świetna w połączeniu z funkcjami takimi jak map(), filter() czy sorted():

Python
Kopiuj
1
2
3
liczby = [1, 2, 3, 4, 5]
kwadraty = list(map(lambda x: x ** 2, liczby))
print(kwadraty)

lambda to dobra opcja, gdy potrzebujesz jednorazowej funkcji, którą przekazujesz jako argument.

Typowanie funkcji (type hints)

Python nie wymaga deklarowania typów, ale możesz doprecyzować intencję za pomocą adnotacji typów:

Python
Kopiuj
1
2
3
4
5
6
7
8
def dodaj(a: int, b: int) -> int:
    return a + b

def przedstaw(imie: str, wiek: int) -> str:
    return f"Mam na imię {imie} i mam {wiek} lat."

print(dodaj(5, 7))
print(przedstaw("Kacper", 30))

Typy w Pythonie nie są obowiązkowe, ale znacząco poprawiają czytelność i współpracę z narzędziami typu mypy czy IDE.

Dokumentacja i dobre praktyki

Dobra funkcja powinna być krótka, jednoznaczna i udokumentowana. Komentarze to za mało — używaj docstringów:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def oblicz_pole_trapezu(a: float, b: float, h: float) -> float:
    """
    Oblicza pole trapezu na podstawie długości podstaw i wysokości.

    Args:
    a (float): długość pierwszej podstawy
    b (float): długość drugiej podstawy
    h (float): wysokość

    Returns:
    float: pole trapezu
    """
    return (a + b) * h / 2

print(oblicz_pole_trapezu(3, 5, 4))

Docstringi pomagają automatycznie generować dokumentację i są rozpoznawane przez IDE.

Funkcje jako obywatele pierwszej klasy

W Pythonie funkcje są pełnoprawnymi obiektami. Możesz przypisywać je do zmiennych, przekazywać jako argumenty i zwracać z innych funkcji.

Python
Kopiuj
1
2
3
4
5
6
7
def witaj(imie):
    return f"Cześć, {imie}!"

def wykonaj_funkcje(fun, wartosc):
    return fun(wartosc)

print(wykonaj_funkcje(witaj, "Pythonista"))

To podstawa programowania funkcyjnego i elastycznych architektur.

Ćwiczenia

1. Prosty kalkulator

Napisz funkcję kalkulator(a, b, operacja), która w zależności od argumentu operacja wykona dodawanie, odejmowanie, mnożenie lub dzielenie.

2. Filtr liczb

Użyj funkcji filter() i lambda, aby z listy [1, 2, 3, 4, 5, 6, 7, 8] wybrać tylko liczby parzyste.

3. Dokumentacja w praktyce

Napisz funkcję pole_okregu(r), dodaj adnotacje typów i docstring. Upewnij się, że wynik można łatwo przetestować w konsoli.

Dzięki funkcjom Twój kod staje się czysty, modularny i skalowalny. To właśnie one odróżniają „skrypt” od „programu”. Umiejętność pisania dobrych funkcji to pierwszy krok w stronę prawdziwego programowania obiektowego i funkcyjnego w Pythonie.

Podsumowanie

• Wiesz, jak definiować i wywoływać funkcje oraz zwracać wartości.
• Rozumiesz argumenty: domyślne, nazwane, zmienne (*args, **kwargs).
• Znasz zakresy zmiennych i konsekwencje użycia global.
• Potrafisz użyć lambda, adnotacji typów i docstringów.

Następny krok: moduły i organizacja kodu, testy jednostkowe, a także praktyka z funkcjami wyższego rzędu.