Semiclon

Co jsou funkce a proč je používat

Funkce jsou jedním z nejdůležitějších konceptů v programování. Jedná se o bloky kódu, které můžete opakovaně volat. Funkce vám umožňují:

• Rozdělit program do menších, lépe spravovatelných částí
• Znovu použít stejný kód na různých místech programu
• Organizovat kód logicky a přehledně
• Snadněji testovat a ladit program
• Sdílet kód s ostatními prostřednictvím knihoven a modulů

Představte si, že píšete recept na koláč. Místo toho, abyste pokaždé, když je třeba smíchat těsto, popisovali celý postup znovu, můžete vytvořit oddíl "Jak smíchat těsto" a odkázat na něj, kdykoli je to potřeba. Funkce fungují podobně - definujete postup jednou a potom ho můžete opakovaně používat.

Definice funkcí v Pythonu

V Pythonu se funkce definují pomocí klíčového slova def, za kterým následuje název funkce, závorky (které mohou obsahovat parametry) a dvojtečka. Pod definicí následuje odsazený blok kódu, který tvoří tělo funkce.

# Definice jednoduché funkce
def pozdrav():
    print("Ahoj, světe!")

# Volání funkce
pozdrav()

V tomto příkladu jsme definovali funkci pozdrav, která při zavolání vytiskne text "Ahoj, světe!". Funkci voláme pomocí jejího názvu následovaného závorkami.

Parametry funkcí

Funkce mohou přijímat vstupy, které se nazývají parametry. Ty umožňují, aby byla funkce flexibilnější a mohla pracovat s různými daty.

# Funkce s parametrem
def pozdrav_uzivatele(jmeno):
    print(f"Ahoj, {jmeno}!")

# Volání funkce s argumentem
pozdrav_uzivatele("Karel")  # Výstup: Ahoj, Karel!
pozdrav_uzivatele("Jana")   # Výstup: Ahoj, Jana!

V tomto příkladu má funkce pozdrav_uzivatele jeden parametr jmeno. Při volání funkce předáváme hodnotu, kterou má tento parametr mít - tato hodnota se nazývá argument.

Více parametrů

Funkce může mít libovolný počet parametrů, které jsou odděleny čárkami.

# Funkce s více parametry
def vypis_informace(jmeno, vek, mesto):
    print(f"{jmeno} je {vek} let starý a bydlí v městě {mesto}.")

# Volání funkce s více argumenty
vypis_informace("Karel", 30, "Praha")
# Výstup: Karel je 30 let starý a bydlí v městě Praha.

Výchozí hodnoty parametrů

Parametry mohou mít výchozí hodnoty, které se použijí, pokud není při volání funkce zadána jiná hodnota.

# Funkce s výchozí hodnotou parametru
def pozdrav_s_jazykem(jmeno, jazyk="čeština"):
    if jazyk == "čeština":
        print(f"Ahoj, {jmeno}!")
    elif jazyk == "angličtina":
        print(f"Hello, {jmeno}!")
    else:
        print(f"Jazyk '{jazyk}' není podporován.")

# Volání funkce s a bez zadání druhého parametru
pozdrav_s_jazykem("Karel")              # Výstup: Ahoj, Karel!
pozdrav_s_jazykem("Karel", "angličtina")  # Výstup: Hello, Karel!
pozdrav_s_jazykem("Karel", "němčina")     # Výstup: Jazyk 'němčina' není podporován.

Pojmenované argumenty

Při volání funkce můžete explicitně uvést název parametru, což vám umožní zadávat argumenty v libovolném pořadí.

# Volání funkce s pojmenovanými argumenty
vypis_informace(mesto="Brno", jmeno="Jana", vek=25)
# Výstup: Jana je 25 let starý a bydlí v městě Brno.

Proměnný počet argumentů

Někdy potřebujete, aby funkce mohla přijmout proměnný počet argumentů. K tomu slouží speciální syntaxe s hvězdičkou (*) pro seznamy a dvojitou hvězdičkou (**) pro slovníky.

# Funkce s proměnným počtem argumentů
def soucet(*cisla):
    """Funkce, která sečte libovolný počet čísel."""
    vysledek = 0
    for cislo in cisla:
        vysledek += cislo
    return vysledek

# Volání funkce s různým počtem argumentů
print(soucet(1, 2))            # Výstup: 3
print(soucet(1, 2, 3, 4, 5))   # Výstup: 15

# Funkce s pojmenovanými argumenty
def vytvor_profil(jmeno, vek, **dalsi_udaje):
    """Funkce, která vytvoří slovník s profilem uživatele."""
    profil = {
        "jmeno": jmeno,
        "vek": vek
    }
    profil.update(dalsi_udaje)
    return profil

# Volání funkce s proměnným počtem pojmenovaných argumentů
profil1 = vytvor_profil("Karel", 30)
profil2 = vytvor_profil("Jana", 25, mesto="Brno", povolani="designér", konicek="fotografování")

print(profil1)  # Výstup: {'jmeno': 'Karel', 'vek': 30}
print(profil2)  # Výstup: {'jmeno': 'Jana', 'vek': 25, 'mesto': 'Brno', 'povolani': 'designér', 'konicek': 'fotografování'}

Návratové hodnoty funkcí

Funkce mohou nejen provádět akce (jako je tisk textu na obrazovku), ale také vracet hodnoty, které pak můžete dále používat ve svém programu. K tomu slouží příkaz return.

# Funkce, která vrací hodnotu
def secti(a, b):
    soucet = a + b
    return soucet

# Použití návratové hodnoty
vysledek = secti(5, 3)
print(f"Součet je: {vysledek}")  # Výstup: Součet je: 8

# Funkce může vrátit více hodnot
def statistika(cisla):
    """Funkce, která vypočítá minimum, maximum a průměr z čísel."""
    minimum = min(cisla)
    maximum = max(cisla)
    prumer = sum(cisla) / len(cisla)
    return minimum, maximum, prumer

# Rozbalení návratových hodnot
min_cislo, max_cislo, prumer_cisel = statistika([1, 2, 3, 4, 5])
print(f"Minimum: {min_cislo}, Maximum: {max_cislo}, Průměr: {prumer_cisel}")
# Výstup: Minimum: 1, Maximum: 5, Průměr: 3.0

Příkaz return ukončí provádění funkce a vrátí zadanou hodnotu volajícímu kódu. Pokud funkce neobsahuje příkaz return nebo obsahuje return bez hodnoty, vrací hodnotu None.

Dokumentační řetězce (docstrings)

Je dobrým zvykem dokumentovat vaše funkce, abyste vy i ostatní věděli, co funkce dělá, jaké parametry přijímá a jaký výsledek vrací. K tomu slouží tzv. dokumentační řetězce (docstrings), které se píší jako první příkaz funkce uvnitř trojitých uvozovek.

# Funkce s dokumentačním řetězcem
def vypocitej_obvod_kruhu(polomer):
    """
    Vypočítá obvod kruhu.
    
    Parametry:
        polomer (float): Poloměr kruhu v metrech
        
    Návratová hodnota:
        float: Obvod kruhu v metrech
    """
    import math
    return 2 * math.pi * polomer

# Získání nápovědy o funkci
help(vypocitej_obvod_kruhu)

Dokumentační řetězce se zobrazují při volání funkce help() nebo při použití jiných nástrojů dokumentace, jako jsou IDEs (integrovaná vývojová prostředí) nebo nástroje pro generování dokumentace.

Lokální a globální proměnné

Proměnné definované uvnitř funkce jsou lokální proměnné, které existují pouze v rámci této funkce. Proměnné definované mimo všechny funkce jsou globální proměnné, které jsou přístupné v celém programu.

# Příklad lokálních a globálních proměnných
globalni_promenna = "Jsem globální"

def ukaz_promenne():
    lokalni_promenna = "Jsem lokální"
    print(globalni_promenna)  # Lze přistupovat ke globální proměnné
    print(lokalni_promenna)   # Lze přistupovat k lokální proměnné

ukaz_promenne()
print(globalni_promenna)  # Lze přistupovat ke globální proměnné
# print(lokalni_promenna)  # Chyba - lokální proměnná není definována v tomto rozsahu

# Změna globální proměnné uvnitř funkce
def zmen_globalni():
    global globalni_promenna  # Deklarace, že chceme používat globální proměnnou
    globalni_promenna = "Globální proměnná byla změněna"

zmen_globalni()
print(globalni_promenna)  # Výstup: Globální proměnná byla změněna

Pro změnu globální proměnné uvnitř funkce musíte použít klíčové slovo global, jinak Python vytvoří novou lokální proměnnou se stejným názvem.

Rekurze

Rekurze je technika, kdy funkce volá sama sebe. Je užitečná pro řešení problémů, které lze rozdělit na menší podproblémy stejného typu.

# Příklad rekurzivní funkce - výpočet faktoriálu
def faktorial(n):
    """
    Vypočítá faktoriál čísla n použitím rekurze.
    
    Parametry:
        n (int): Celé nezáporné číslo
        
    Návratová hodnota:
        int: Faktoriál čísla n (n!)
    """
    if n == 0 or n == 1:  # Základní případ
        return 1
    else:  # Rekurzivní případ
        return n * faktorial(n - 1)

# Testování funkce
print(faktorial(5))  # Výstup: 120 (5! = 5 * 4 * 3 * 2 * 1)

Rekurzivní funkce musí mít základní případ (podmínku ukončení), který zabraňuje nekonečnému volání funkce. V našem příkladu je to případ, kdy n je 0 nebo 1.

Lambda funkce

Lambda funkce jsou malé anonymní funkce (funkce bez jména), které mohou být definovány jedním výrazem. Jsou užitečné pro krátké, jednoúčelové funkce.

# Příklad lambda funkce
secti = lambda a, b: a + b
print(secti(5, 3))  # Výstup: 8

# Použití lambda funkce s vestavěnými funkcemi
cisla = [1, 5, 3, 9, 7]
serazeno = sorted(cisla, key=lambda x: x)  # Seřadí čísla vzestupně
print(serazeno)  # Výstup: [1, 3, 5, 7, 9]

# Seřazení slov podle délky
slova = ["jablko", "hruška", "pomeranč", "kiwi", "ananas"]
podle_delky = sorted(slova, key=lambda slovo: len(slovo))
print(podle_delky)  # Výstup: ['kiwi', 'jablko', 'hruška', 'ananas', 'pomeranč']

Lambda funkce jsou omezeny na jeden výraz, takže nejsou vhodné pro složitější logiku.

Praktické příklady použití funkcí

1. Převod teploty

# Funkce pro převod mezi teplotními stupnicemi
def celsius_na_fahrenheit(celsius):
    """Převede teplotu z Celsia na Fahrenheit."""
    return (celsius * 9/5) + 32

def fahrenheit_na_celsius(fahrenheit):
    """Převede teplotu z Fahrenheit na Celsius."""
    return (fahrenheit - 32) * 5/9

# Testování funkcí
teplota_c = 25
teplota_f = celsius_na_fahrenheit(teplota_c)
print(f"{teplota_c}°C je {teplota_f:.1f}°F")
# Výstup: 25°C je 77.0°F

teplota_f = 68
teplota_c = fahrenheit_na_celsius(teplota_f)
print(f"{teplota_f}°F je {teplota_c:.1f}°C")
# Výstup: 68°F je 20.0°C

2. Kalkulačka

# Funkce pro základní aritmetické operace
def scitani(a, b):
    return a + b

def odcitani(a, b):
    return a - b

def nasobeni(a, b):
    return a * b

def deleni(a, b):
    if b == 0:
        return "Nelze dělit nulou"
    return a / b

# Funkce kalkulačky
def kalkulacka():
    """Jednoduchá kalkulačka s uživatelským rozhraním."""
    while True:
        print("\nJednoduchá kalkulačka")
        print("1: Sčítání")
        print("2: Odčítání")
        print("3: Násobení")
        print("4: Dělení")
        print("5: Konec")
        
        volba = input("Zvolte operaci (1-5): ")
        
        if volba == '5':
            print("Ukončuji kalkulačku...")
            break
            
        if volba not in ['1', '2', '3', '4']:
            print("Neplatná volba. Zkuste to znovu.")
            continue
            
        try:
            a = float(input("Zadejte první číslo: "))
            b = float(input("Zadejte druhé číslo: "))
        except ValueError:
            print("Neplatné číslo. Zadejte prosím číslo.")
            continue
        
        if volba == '1':
            print(f"Výsledek: {scitani(a, b)}")
        elif volba == '2':
            print(f"Výsledek: {odcitani(a, b)}")
        elif volba == '3':
            print(f"Výsledek: {nasobeni(a, b)}")
        elif volba == '4':
            print(f"Výsledek: {deleni(a, b)}")

# Spuštění kalkulačky
# kalkulacka()

3. Analýza textu

# Funkce pro analýzu textu
def analyzuj_text(text):
    """
    Analyzuje zadaný text a vrátí statistiky.
    
    Parametry:
        text (str): Text k analýze
        
    Návratová hodnota:
        dict: Slovník se statistikami o textu
    """
    statistiky = {
        "počet_znaků": len(text),
        "počet_písmen": sum(c.isalpha() for c in text),
        "počet_číslic": sum(c.isdigit() for c in text),
        "počet_mezer": sum(c.isspace() for c in text),
        "počet_slov": len(text.split()),
        "počet_vět": text.count('.') + text.count('!') + text.count('?')
    }
    
    # Nejčastější slovo
    slova = [slovo.lower().strip('.,!?:;()[]{}""\'') for slovo in text.split()]
    if slova:
        from collections import Counter
        nejcastejsi = Counter(slova).most_common(1)[0]
        statistiky["nejčastější_slovo"] = nejcastejsi[0]
        statistiky["počet_výskytů"] = nejcastejsi[1]
    
    return statistiky

# Testování funkce
ukazka_textu = """
Python je vysokoúrovňový, interpretovaný, objektově orientovaný programovací jazyk s dynamickou sémantikou.
Jeho vysokoúrovňové datové struktury ve spojení s dynamickým typováním a dynamickým vázáním ho dělají velmi atraktivním pro rychlý vývoj aplikací.
Python je jednoduchý a snadno se učí. Python podporuje moduly a balíčky, což podporuje modularitu programu a znovupoužití kódu.
"""

vysledek = analyzuj_text(ukazka_textu)
for klic, hodnota in vysledek.items():
    print(f"{klic}: {hodnota}")

Shrnutí

V tomto článku jste se naučili:

• Co jsou funkce a proč jsou důležité pro organizaci kódu
• Jak definovat funkce v Pythonu pomocí def
• Jak pracovat s parametry funkcí, včetně výchozích hodnot a proměnného počtu argumentů
• Jak vracet hodnoty z funkcí pomocí return
• Jak dokumentovat funkce pomocí dokumentačních řetězců
• Rozdíl mezi lokálními a globálními proměnnými
• Základy rekurze
• Jak používat lambda funkce pro krátké anonymní funkce
• Praktické příklady použití funkcí v reálných aplikacích

Funkce jsou jedním z nejdůležitějších nástrojů pro udržování kódu organizovaného, čitelného a znovupoužitelného. V dalším článku se zaměříme na práci se soubory v Pythonu, což je další důležitá dovednost pro praktické programování.