Funkcje w Pythonie: def, return, argumenty domyślne i nazwane

Funkcja to nazwany blok kroków

Za każdym razem, gdy piszesz te same kilka linii więcej niż raz albo chcesz nadać nazwę małemu kawałkowi logiki, to znak, że czas napisać funkcję. Funkcje to pierwsze prawdziwe narzędzie do panowania nad złożonością programu w Pythonie.

Podstawowy kształt:

def greet(name):
    print(f"Hello, {name}")

greet("Ada")
greet("Boris")

Po kolei:

• def to słowo kluczowe, które rozpoczyna definicję funkcji.
• greet to nazwa funkcji.
• (name) to lista parametrów, czyli danych wejściowych, które przyjmuje funkcja.
• Dwukropek kończy nagłówek, a wcięty blok poniżej to ciało.
• greet("Ada") to wywołanie. Python wykonuje ciało z name powiązanym z "Ada".

Funkcje czekają uśpione, dopóki ich nie wywołasz. Zdefiniowanie funkcji jej nie uruchamia. Robi to dopiero wywołanie greet("Ada").

Parametry i argumenty

Parametr to nazwa w definicji funkcji. Argument to wartość przekazywana przy wywołaniu. W luźnej rozmowie to nic wielkiego, ale to rozróżnienie pomaga przy czytaniu komunikatów o błędach.

def power(base, exponent):
    return base ** exponent

print(power(2, 10))
print(power(5, 3))

Tutaj base i exponent to parametry. 2 i 10 to argumenty. Python wiąże je po kolei: pierwszy argument z pierwszym parametrem i tak dalej.

return: odesłanie wartości

print wypisuje na ekran. return przekazuje wartość wywołującemu, żeby mógł jej użyć:

def power(base, exponent):
    return base ** exponent

result = power(2, 10)
print(result + 1)

Bez return funkcja domyślnie zwraca None:

def greet(name):
    print(f"Hello, {name}")

value = greet("Ada")
print("got back:", value)   # got back: None

return natychmiast kończy też funkcję. Często zobaczysz wczesne powroty, które obsługują przypadki brzegowe przed główną logiką:

def discount(price, percent):
    if percent < 0 or percent > 100:
        return None
    return price * (1 - percent / 100)

print(discount(50, 20))
print(discount(50, 150))

Wczesne powroty chronią główne ciało przed głębokim zagnieżdżaniem w if/else.

Argumenty domyślne

Parametr może mieć wartość domyślną, używaną wtedy, gdy wywołujący jej nie poda:

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Ada")
greet("Boris", "Good morning")

Wszystkie parametry z wartościami domyślnymi muszą występować po parametrach bez nich. def f(a, b=1, c): to błąd składni.

Pułapka modyfikowalnej wartości domyślnej

To najsłynniejsza pułapka Pythona. Patrz:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

Można by się spodziewać, że każde wywołanie zaczyna z pustą listą. Zamiast tego domyślna lista jest wspólna dla wszystkich wywołań, a elementy się kumulują. Python oblicza wartość domyślną raz, w chwili definiowania funkcji, i używa tej jednej listy już na zawsze.

Bezpieczny wzorzec to użycie None jako wartości domyślnej i utworzenie listy wewnątrz funkcji:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

Teraz każde wywołanie, które nie przekazuje items, dostaje nową listę. Ta zasada dotyczy list, słowników, zbiorów, czyli wszystkiego, co modyfikowalne.

Argumenty nazwane

Argumenty możesz przekazywać po nazwie zamiast po pozycji. Pozwala to pominąć parametry ze środka i sprawia, że długie wywołania są czytelniejsze:

def post(title, body, draft=False, tags=None):
    status = "draft" if draft else "published"
    print(f"[{status}] {title}")
    print(body)
    print("tags:", tags or [])

post("Python functions", "How to write them", draft=True, tags=["python", "tutorial"])

Argumenty pozycyjne i nazwane można mieszać, ale pozycyjne muszą być pierwsze:

post("Title", body="Body text", draft=True)    # w porządku
# post(body="Body", "Title")                    # SyntaxError

Gdy funkcja ma więcej niż trzy czy cztery parametry, stawianie na argumenty nazwane bardzo ułatwia czytanie wywołań.

Parametry tylko pozycyjne i tylko nazwane

Python pozwala oznaczyć niektóre parametry jako przekazywane tylko przez pozycję (przez /) albo tylko przez nazwę (przez *):

def configure(env, /, *, debug=False, log_level="info"):
    print(env, debug, log_level)

configure("prod")                          # w porządku: env pozycyjnie
configure("prod", debug=True)              # w porządku
# configure(env="prod")                    # błąd: env jest tylko pozycyjny
# configure("prod", True, "info")          # błąd: debug i log_level są tylko nazwane

Nie potrzebujesz tego pierwszego dnia. Przydaje się to przy projektowaniu API, gdy chcesz ściśle określić, jak wywołujący mają używać twojej funkcji.

Docstringi i nazewnictwo

Pierwszą linią w funkcji może być docstring, czyli napis w potrójnych cudzysłowach, który Python traktuje jako dokumentację:

def discount(price, percent):
    """Return the final price after applying a percentage discount."""
    return price * (1 - percent / 100)

help(discount)

Narzędzia takie jak help(), podpowiedzi w IDE i generatory dokumentacji automatycznie czytają docstring. Jedna linia jest dużo lepsza niż nic.

I proszę, przemyśl nazwy:

• Nazwy funkcji powinny być czasownikami: fetch_profile, compute_total, is_valid.
• Używaj lower_snake_case.
• Funkcje zwracające wartość logiczną często zaczynają się od is_, has_ albo can_.

Dobra nazwa sprawia, że miejsce wywołania objaśnia się samo, bez komentarza.

Funkcje czyste łatwiej zrozumieć

Funkcja czysta zwraca ten sam wynik dla tych samych danych wejściowych i nie ma efektów ubocznych: nie zmienia stanu globalnego, nie wypisuje na stdout (poza debugowaniem) i nie zapisuje do plików.

# Czysta: łatwo ją testować i zrozumieć.
def total(price, tax_rate):
    return price * (1 + tax_rate)

# Nieczysta: modyfikuje zewnętrzną zmienną.
cart = []
def add_to_cart(item):
    cart.append(item)

print(total(100, 0.08))
add_to_cart("apple")
print(cart)

Obie mają swoje miejsce, ale w kodzie, który chcesz ponownie wykorzystywać i testować, dąż do funkcji czystych, na ile się da.

Mały działający przykład

Krótka funkcja, która łączy wartości domyślne, argumenty nazwane i return:

def format_address(street, city, country="US", zip_code=None):
    parts = [street, city]
    if zip_code:
        parts.append(zip_code)
    parts.append(country)
    return ", ".join(parts)

print(format_address("1 Main St", "Boston"))
print(format_address("1 Main St", "Boston", zip_code="02108"))
print(format_address("Place Vendôme 1", "Paris", country="France"))

Dalej: elastyczne listy argumentów

Czasem nie wiesz, z iloma argumentami funkcja zostanie wywołana, albo chcesz przekazać dowolne otrzymane argumenty do innej funkcji. Do tego służą *args i **kwargs. O nich jest następna strona.