8. diel - Funkcie a výnimky v Pythone

V predchádzajúcom cvičení, Riešené úlohy k 6. a 7. lekciu Pythone, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.

V minulej lekcii, Riešené úlohy k 6. a 7. lekciu Pythone , sme si ukázali metódy na textových reťazcoch. V tomto tutoriálu sa naučíme používať funkcie a funkcionálne štýl programovania. Ďalej sa naučíme jednoduché ošetrovanie chýb programu. Vylepšíme si našu kalkulačku a urobíme z nej prvej chybám odolný program.

Funkcie

Doteraz sme programy písali imperatívne - urob tento príkaz, potom tamten atď. Týmto spôsobom možno písať jednoduché a krátke programy. Väčšia programy by však boli veľmi neprehľadné. Preto prejdeme na ďalší programovací paradigma (spôsob ako niečo naprogramovať) - funkcionálne štýl programovania. Náš program si rozdelíme na menšie časti (podproblémy), ktoré riešime samostatne. Jednotlivé podproblémy rieši funkcie. Pre funkcionálne štýl programovania môžeme použiť všetko, čo sme sa naučili doteraz.

Funkcia zvyčajne prijíma argumenty (dáta, ktoré spracuje) a niečo vracia - nejakú výslednú hodnotu pod. (Ale aj nemusí vracať nič ako napr. Funkcia print()).

Základné syntaxe funkcie

Funkcia majú syntax podobnú větvícím príkazom (if, elif, else). Funkcia sa definuje pomocou kľúčového slova def a výslednú hodnotu vracia kľúčovým slovom return. Za def sa píše medzera a potom názov funkcie. Za názov funkcie sa dávajú jednoduché zátvorky, do ktorých sa píšu názvy jednotlivých argumentov. Funkcia môže byť aj bez argumentov. Pri volaní funkcie sa do nich dosadzujú hodnoty argumentov. Na konci prvého riadka sa píše dvojbodka. Telo funkcie sa štandardne odsadzuje.

Príklad:

def mocnina(cislo):
    cislo = cislo ** 2
    return cislo

Takto vytvorená funkcia mocnina vracia číslo umocnené na druhú. Napríklad pri zavolaní mocnina(1) vráti 1, pri zavolaní mocnina(2) vráti 4 atď.

V praxi:

{PYTHON}
def mocnina(cislo):
    cislo = cislo ** 2
    return cislo
prvni_cislo = mocnina(2)
print(prvni_cislo)
{/PYTHON}

Argumentov samozrejme môže byť aj viac napr:

{PYTHON}
def soucin(prvni_cislo, druhe_cislo, treti_cislo):
    cislo = prvni_cislo * druhe_cislo * treti_cislo
    return cislo
priklad = soucin(2, 3, 4)
print(priklad)
{/PYTHON}

Argumenty

Argumentov sú dva druhy - pozičné a kľúčové.

Pozičné argumenty sme videli vyššie. Na ich pozíciu sa dosadí argument na rovnakej pozícii pri volaní funkcie. Tieto argumenty nemajú Dánov základnú hodnotu.

Syntax: název_argumentu

Kľúčové argumenty majú už vopred nastavenú hodnotu, ktorú je možné zmeniť. Na rozdiel od argumentov pozičných sú označené kľúčovým slovom (majú svoj názov). Tieto argumenty majú Dánov východiskovú hodnotu a nemusí byť pri volaní funkcie zadané v tom poradí, v akom sú deklarované. Naviac je nemusíme pri volaní funkcie inicializovať (určiť ich hodnotu), v tom prípade sa použije je základná hodnota.

Syntax: název_argumentu = hodnota

Všetky pozičné argumenty musia byť deklarované pred kľúčovými!

Teraz príklad - vylepšená verzia funkcie mocnina:

def mocnina(cislo, exponent=2):
    cislo = cislo ** exponent
    return cislo

Prvý argument je pozičné, druhý je kľúčový. Teraz môžeme volať mocnina(1) alebo mocnina(1, exponent=2), a dostaneme rovnaký výsledok. Navyše treba môžeme umocniť 3 na 4 - mocnina(3, exponent=4).

Operátor *

Môžeme použiť aj operátor *. Ten nám umožní robiť zaujímavejšie veci.

napr .:

nejaka_funkce(*pozicni_argumenty)

Všeobecne sa pozičné argumenty zapisujú ako args a kľúčové argumenty ako kwargs.

Vďaka tomuto zápisu sa všetky zadané pozičné argumenty vloží do n-tica (niečo ako zoznam) s názvom pozicni_argumenty. Tú potom môžeme napríklad prechádzať cyklom for..in.

Ak chceme to isté pre kľúčové argumenty napíšeme dve hviezdičky.

Príklad:

{PYTHON}
def soucin(*cisla):
    vysledek = 1
    for cislo in cisla:
        vysledek = vysledek * cislo
    return vysledek
priklad = soucin(2, 3, 4, 5)
print(priklad)
{/PYTHON}

Pre záujemcov - môžeme použiť chuťovku typu:

funkcie(*, prvni_klicovy_arg=1, druhy_klicovy_arg=1)

Pričom nám funkcia nedovolí použiť pozičné argumenty.

Rekurzia

Rekurzia označuje keď funkcia volá sama seba. Možno ju použiť napríklad na výpočet faktoriálu.

Príklad:

def faktorial(cislo):
    if cislo > 0:
        return faktorial(cislo - 1) * cislo
    else:
        return 1

Pri rekurziu si musíte dať pozor, aby sa niekedy ukončila. Inak program upadne na pretečenie zásobníka. Rekurzia je pre záujemcov podrobne vysvetlená u algoritmu faktoriálu.

print()

Ako som kedysi sľúbil, tak sa naučíme upraviť si funkciu print(). Teraz sa pozrieme na jej dva kľúčové argumenty:

• sep - medzery medzi jednotlivými prvkami (pozičnými argumenty) - normálne nastavené na medzeru (" ")
• end - čím sa zápis ukončí - normálne znak nového riadku ("\n")

Príklady:

{PYTHON}
print(1, 2, 3, "a", sep="-")

print("Žiadna nová riadok!", end=" ")
{/PYTHON}

Ošetrenie chýb

Vo väčšine programov, čo sme doteraz vytvorili, bola chyba pri vstupe čísla. Ak sme zadali namiesto čísla napr. Písmeno, tak program spadol.

Teraz si ukážeme, ako takéto chyby ošetriť. Ošetrenie sa vykonáva pomocou bloku try - except.

Syntax:

try:
    #blok príkazov
except jmeno_prvni_vyjimky:
    #blok príkazov
except jmeno_dalsi_vyjimky:
    #blok príkazov
#tu je buď koniec, alebo zachytenie ďalších výnimiek

Ak chceme zachytiť aj chybovú správu - musíme napísať:

except jmeno_vyjimky as chyba:
    #text výnimky sa uloží do premennej chyba

Chybám sa v Pythone (a v objektových jazykoch všeobecne) hovorí výnimky. Tie základné sú nasledujúce:

• SyntaxError - chyba v zdrojovom kóde
• ZeroDivisionError - delenie nulou
• TypeError - nesprávne použitie dátových typov - napr. Sčítanie reťazca a čísla a pod.
• ValueError - nesprávna hodnota

Viac výnimiek tu (AJ): https://docs.python.org/...eptions.html

A teraz si ešte raz vylepšíme našu kalkulačku:

{PYTHON}
print("Kalkulačka\n")
pokracovat = True
while pokracovat:
    prvni_cislo = int(input("Zadajte prvé číslo: "))
    druhe_cislo = int(input("Zadajte druhé číslo: "))
    print("1 - sčítanie")
    print("2 - odčítanie")
    print("3 - násobenie")
    print("4 - delenie")
    print("5 - umocňovanie")
    cislo_operace = int(input("Zadajte číslo operácie: "))
    if cislo_operace == 1:
        print("Ich súčet je:", prvni_cislo + druhe_cislo)
    elif cislo_operace == 2:
        print("Ich rozdiel je:", prvni_cislo - druhe_cislo)
    elif cislo_operace == 3:
        print("Ich súčin je:", prvni_cislo * druhe_cislo)
    elif cislo_operace == 4:
        print("Ich podiel je:", prvni_cislo / druhe_cislo)
    elif cislo_operace == 5:
        print(prvni_cislo, "na", druhe_cislo, "je:", prvni_cislo ** druhe_cislo)
    else:
        print("Neplatná voľba!")
    nezadano = True
    while nezadano:
        odpoved = input("\nPrajete si zadať ďalší príklad? y / n: ")
        if (odpoved == "y" or odpoved == "Y"):
            nezadano = False
        elif (odpoved == "n" or odpoved == "n"):
            nezadano = False
            pokracovat = False
        else:
            pass
input("\nStlačte ľubovoľný kláves...")
{/PYTHON}

Najprv vyrobíme funkciu na získanie čísla zo vstupu od užívateľa:

def nacti_cislo(text_zadani, text_chyba):
    spatne = True
    while spatne:
        try:
            cislo = float(input(text_zadani))
            spatne = False
        except ValueError:
            print(text_chyba)
        else:
            return cislo

Program sa opakuje v cykle, kým nezadáme správny vstup. Riadok s float() prevedie reťazec na desatinné číslo.

Ďalej vyrobíme funkciu na vstup "y" alebo "n":

def dalsi_priklad():
    nezadano = True
    while nezadano:
        odpoved = input("\nPrajete si zadať ďalší príklad? y / n: ")
        if (odpoved == "y" or odpoved == "Y"):
            return True
        elif (odpoved == "n" or odpoved == "N"):
            return False
        else:
            pass

Skoro to isté ...

Ďalší na rade je voľba:

def volba(prvni_cislo, druhe_cislo):
    print("1 - sčítanie")
    print("2 - odčítanie")
    print("3 - násobenie")
    print("4 - delenie")
    print("5 - umocňovanie")
    cislo_operace = nacti_cislo("Zadaj voľbu: ", "Neplatné zadanie!\n")
    if cislo_operace == 1:
        print("Ich súčet je:", prvni_cislo + druhe_cislo)
    elif cislo_operace == 2:
        print("Ich rozdiel je:", prvni_cislo - druhe_cislo)
    elif cislo_operace == 3:
        print("Ich súčin je:", prvni_cislo * druhe_cislo)
    elif cislo_operace == 4:
        mezivysledek = 0
        try:
            mezivysledek = prvni_cislo / druhe_cislo
            print("Ich podiel je:", mezivysledek)
        except ZeroDivisionError:
            print("Delenie nulou!")
    elif cislo_operace == 5:
        print(prvni_cislo, "na", druhe_cislo, "je:", prvni_cislo ** druhe_cislo)
    else:
        print("Neplatná voľba!")

A ošetrenie delenie nulou. Išlo by aj len kontrolovať, či je druhé číslo 0.

A teraz hlavné cyklus:

def main():
    print("Kalkulačka\n")
    pokracovat = True
    while pokracovat:
        prvni_cislo = nacti_cislo("Zadaj číslo: ", "Neplatné číslo!\n")
        druhe_cislo = nacti_cislo("Zadaj číslo: ", "Neplatné číslo!\n")
        volba(prvni_cislo, druhe_cislo)
        if dalsi_priklad():
            pass
        else:
            pokracovat = False
    input("\nStlačte ľubovoľný kláves...")
main()

Kompletný kód kalkulačky je k dispozícii nižšie na stiahnutie.

V budúcej lekcii, Viacrozmerné polia v Pythone , sa pozrieme na import knižníc a niekoľko si ich predstavíme. A ukážeme si pythonovská veľkonočné vajíčka

 

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.