Funkce

Funkce jsou klíčové pro modularizaci a organizaci kódu.

Umožňují opakované použití kódu bez jeho opakovaného psaní.

Funkce mohou přijímat parametry, vrátit hodnoty a pomáhat v oddělení různých části programu do logických sekcí.

Zdroj obrázku: https://files.realpython.com/media/How-to-Create-Python-Functions-with-Optional-Arguments_Watermarked.f2c8b582aff0.jpg

Definice a volání funkce

Funkci v Pythonu definujeme pomocí klíčového slova def, následovaného názvem funkce, seznamem parametrů v závorkách a dvojtečkou.

Tělo funkce je odsazené a může obsahovat jakýkoliv počet příkazů.

def pozdrav(jmeno):
    print(f"Ahoj {jmeno}")

Funkci voláme použitím jejího názvu s potřebnými argumenty (vstupními parametry) v závorkách.

pozdrav("Lukáš") #Vypíše Ahoj Lukáš

Parametry a argumenty

Pomocí parametrů můžeme specifikovat, jaké hodnoty funkce očekává a pomocí argumentů tyto hodnoty předáváme funkci při jejím volání.

Funkce mohou mít několik typů parametrů:

• poziční parametry – tyto parametry získávají hodnoty založené na jejich pozici v definici funkce, hodnoty se předávají ve stejném pořadí, v jakém jsou definovány parametry
• klíčové parametry – hodnoty můžeme předat parametrům podle názvu parametru, což nám umožňuje přeskočit některé parametry nebo je zadat v libovolném pořadí
• výchozí parametry – umožňují definovat výchozí hodnotu pro parametr, která bude použita, pokud při volání funkce není hodnota specifikována

Výchozí parametry jsou užitečné pro situace, kdy určité hodnoty nemusí být vždy specifikovány, ale přesto mají být často používány.

Všechny poziční parametry musíme jmenovat před klíčovými!

def zobraz_info(jmeno, vek=24, mesto="Praha"):
    print(f"Jméno: {jmeno}, Věk: {vek}, Město: {mesto}")

zobraz_info("Lukáš", mesto="Rakvice")  # Specifikuje některé parametry podle názvu

Použití různých typů argumentů zvyšuje flexibilitu funkce a činí ji více adaptabilní na různé situace.

Klíčové argumenty zvyšují čitelnost kódu tím, že je jasné, co každý argument znamená.

Poziční argumenty jsou jednoduché a přímočaré pro jednoduché funkce.

Vrácení hodnot

Funkce může vrátit hodnotu (návratová funkce) pomocí klíčového slova return. Pokud return není specifikován, vrátí none.

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

soucet = secti(5,3)
print(soucet) #Vypíše 8

Return používáme pro:

• ukončení funkce
• vrácení výsledku – můžeme vrátit výsledek do proměnné, s kterou můžeme v programu dále pracovat
• podmíněné vrácení – můžeme mít více return příkazů v rámci jedné funkce, což umožňuje vrátit různé výsledky na základě různých podmínek

def je_sude(cislo):
    if cislo % 2 == 0:
        return True
    else:
        return False

print(je_sude(10))  # Vrátí True

Funkce mohou vrátit více hodnot najednou, což je ve skutečnosti návrat n-tice hodnot. Tento přístup je užitečný pro funkce, které potřebují vrátit více než jednu hodnotu.

def get_info():
    return "Lukáš", 24, "Rakvice"  # Vrátí n-tici (tuple) tří hodnot

jmeno, vek, mesto = get_info()
print(jmeno, vek, mesto)

Rekurze

Rekurze je technika v programování, kdy funkce volá sama sebe. Je to užitečný způsob pro řešení problémů, které lze přirozeně rozdělit na menší, jednodušší problémy stejného typu.

Rekurzivní funkce musí mít podmínku pro ukončení, aby se zabránilo nekonečnému volání funkce.

def faktorial(n):
    # Podmínka ukončení
    if n == 0:
        return 1
    # Rekurzivní volání
    else:
        return n * faktorial(n-1)

print(faktorial(5))  # Vypíše: 120

Typování

Anotace typů v Pythonu byly představeny v Pythonu 3.5 a poskytují způsob, jak explicitně určit typy dat, které funkce očekává (pro parametry) a vrací (pro návratové hodnoty).

Tyto anotace neovlivňují běh programu, protože Python zůstává dynamicky typovaným jazykem. Nicméně, anotace typů mohou zlepšit čitelnost kódu a usnadnit ladění.

Rekurzivní funkce musí mít podmínku pro ukončení, aby se zabránilo nekonečnému volání funkce.

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

def pozdrav(jmeno: str) -> None:
    print(f"Ahoj, {jmeno}!")

V těchto příkladech secti_cisla očekává dva celočíselné argumenty a vrátí celé číslo.

Funkce pozdrav očekává řetězec a nevrací žádnou hodnotu (technicky None).

Použití anotací pro kolekce

Pro kolekce jako seznamy, slovníky a množiny Python nabízí modul typing, který umožňuje specifikovat typy prvků uvnitř těchto kolekcí.

from typing import List, Dict, Set, Tuple

def zpracuj_polozky(polozky: List[str]) -> None:
    for polozka in polozky:
        print(polozka)

zpracuj_polozky očekává seznam řetězců.

Operátor *

Operátor * se používá ve dvou hlavních kontextech:

• pro rozbalení iterovatelných objektů při volání funkcí
• pro zachycení neomezeného množství argumentů ve funkci

Rozbalování iterovatelných objektů

Operátor * umožňuje předat prvky seznamu, n-tice, nebo jiného iterovatelného objektu jako pozicionální argumenty funkce.

cisla = [1, 2, 3]
print(*cisla)  # Ekvivalentní k print(1, 2, 3)

Zachycení argumentů ve funkci

Pomocí *args můžeme ve funkci zachytit libovolný počet pozičních argumentů. Tyto argumenty jsou dostupné ve funkci jako n-tice.

def zretezeni(*args):
    vysledek = ""
    for arg in args:
        vysledek += arg
    return vysledek

print(zretezeni("Chodím ", "na ", "MěSOŠ."))  # Vypíše: Chodím na MěSOŠ.

Pro klíčové argumenty se používá podobný operátor **, který zachytává argumenty do slovníku.

def zobraz_data_uzivatele(**kwargs):
    for klic, hodnota in kwargs.items():
        print(f"{klic}: {hodnota}")

zobraz_data_uzivatele(jmeno="Lukáš", vek=24, mesto="Rakvice")

Global a nonlocal

Někdy můžeme narazit na situace, kde potřebujeme manipulovat s proměnnými, které jsou definované mimo aktuální funkční obor. Pro tyto účely existují klíčová slova global a nonlocal.

• global – používá se k přístupu a modifikaci proměnných, které jsou definované na úrovni modulu (mimo jakoukoliv funkci)
• nonlocal – se používá k manipulaci s proměnnými ve vnějších, ale ne globálních, funkcích, tedy vnořených funkcích

x = 5

def modifikuj_global():
    global x
    x = 10  # Modifikuje globální proměnnou x

modifikuj_global()
print(x)  # Vypíše: 10

def vnejsi():
    x = "lokalni"
    def vnitrni():
        nonlocal x
        x = "nonlocal"  # Modifikuje x definované ve funkci vnejsi
    vnitrni()
    print(x)  # Vypíše: nonlocal

vnejsi()

Lambda funkce

Lambda funkce jsou malé anonymní funkce definované pomocí klíčového slova lambda.

Lambda funkce mohou mít libovolný počet argumentů, ale pouze jeden výraz.

nasobeni = lambda x, y: x * y
print(nasobeni(5, 6))  # Vypíše: 30

Dekorátory

Dekorátory jsou nástroje, které umožňují modifikovat chování funkcí nebo tříd.

Dekorátory jsou implementovány jako funkce, které přijímají jinou funkci jako argument a vracejí novou funkci.

def muj_dekorator(funkce):
    def obal():
        print("Něco se děje před voláním funkce.")
        funkce()
        print("Něco se děje po volání funkce.")
    return obal

@muj_dekorator
def rekni_ahoj():
    print("Ahoj!")

rekni_ahoj()

rekni_ahoj je dekorovaná funkcí muj_dekorator. Když zavoláme rekni_ahoj(), nejprve se zavolá obalová funkce obal, která zahrnuje předvolání a povolání funkcionality, a poté samotná funkce rekni_ahoj.

Dekorátory mohou být užitečné pro:

• přidání funkcionalit k funkcím bez modifikace samotných funkcí
• logging, kontrola přístupu a měření výkonu
• zpřehlednění API nebo změny jeho chování

Dekorátory mohou být řetězeny, což znamená, že jednu funkci můžete dekorovat více dekorátory.

def prvni_dekorator(funkce):
    def obal():
        print("První dekorátor před voláním funkce.")
        funkce()
        print("První dekorátor po volání funkce.")
    return obal

def druhy_dekorator(funkce):
    def obal():
        print("Druhý dekorátor před voláním funkce.")
        funkce()
        print("Druhý dekorátor po volání funkce.")
    return obal

@prvni_dekorator
@druhy_dekorator
def rekni_ahoj():
    print("Ahoj!")

rekni_ahoj()

Když zavoláme rekni_ahoj(), první se aplikuje druhy_dekorator a poté prvni_dekorator

Zdroje