4. diel - Hracia kocka v Pythone druhýkrát - Prekrývanie metód a random

V minulej lekcii, Hracia kocka v Pythone - Zapuzdrenie a konštruktor , sme začali vytvárať prvý poriadny objekt, bola ním hracia kocka.

V tomto tutoriále objektovo orientovaného programovania v Pythone budeme pokračovať v tvorbe našej objektovej hracej kocky. Začneme s metódou pre hod. Vysvetlíme si na nej bližšie vnútorný import a potom dôkladne preskúmame princípy prekrývania metód.

Náhodné čísla

Začneme tým, že v triede Kostka definujeme ďalšiu metódu. Nazveme ju hod(). Metóda nám vráti náhodné číslo od jednej do počtu stien a nebude mať žiadny parameter. Náhodné číslo získame za pomoci modulu random. Modul si naimportujeme vnútorne ako privátny (použijeme jedno podtržítko) a použijeme metódu randint():

def hod(self):
    """
    Vykoná hod kostkou a vrátí číslo od 1 do
    počtu stěn.
    """
    import random as _random
    return _random.randint(1, self._pocet_sten)

Použitie jedného podčiarkovníka pred názvom importovaného modulu (alebo akejkoľvek inej premennej) je - nám už známou - konvenciou v Pythone, ktorá signalizuje, že táto premenná by mala byť považovaná za privátnu a nemala by byť priamo pristupovaná mimo triedy alebo modulu.

Vnútorný import

Výraz "vnútorný import" sa vzťahuje na prax importovania modulu priamo vo vnútri funkcie alebo metódy, namiesto toho, aby bol importovaný na začiatku súboru. V niektorých prípadoch to príde vhod, najmä ak:

• modul potrebujeme len v určitých špecifických situáciách,
• import modulu je nákladný na pamäť a čas a nechceme, aby spomaľoval štart aplikácie.

Je dôležité si uvedomiť, že importovanie modulu v Pythone je relatívne nákladná operácia. Avšak iba prvýkrát, kedy je modul importovaný. Ďalšie pokusy o jeho importovanie sú už veľmi rýchle, pretože Python použije už načítanú verziu modulu z pamäte. Inými slovami, pri importovaní modulov sa Python pozrie, či bol už modul importovaný. Ak áno, Python ho znova neimportuje. Preto sa prvý riadok v metóde vykoná len raz. Importy na začiatku súboru, ako sme zvyknutí, sú takmer za všetkých okolností jednoduchším a lepším riešením. Tento koncept teda berte len ako ukážku možností jazyka.

Nadmerné používanie vnútorných importov kód komplikuje a znižuje jeho čitateľnosť. Dobrou praxou je teda používať ich uvážene a len v situáciách, keď prinášajú skutočné výhody.

Prekrývanie metódy __str__()

Kocka je takmer hotová. Ukážme si teraz ešte jednu užitočnú metódu, ktorú budeme hojne používať aj vo väčšine našich ďalších objektov. Reč je o metóde __str__(). Túto metódu obsahuje každý objekt, teda aj teraz naša kocka. Metóda je určená na to, aby vrátila tzv. textovú reprezentáciu inštancie. Hodí sa vo všetkých prípadoch, keď si inštanciu potrebujeme vypísať alebo s ňou pracovať ako s textom. Túto metódu majú napr. aj čísla. V Pythone funguje implicitná konverzia. Akonáhle teda budeme chcieť do konzoly vypísať číslo alebo ktorýkoľvek iný objekt, Python na ňom zavolá metódu __str__() a vypíše jej výstup. Ak si robíme vlastnú triedu, mali by sme zvážiť, či sa nám takáto metóda hodí. Nikdy by sme si nemali robiť vlastnú metódu, napr. niečo ako vypis(), keď už máme v Pythone pripravenú cestu, ako toto riešiť. Pri kocke nemá __str__() vyšší zmysel, ale u bojovníka bude určite vracať jeho meno. My si ju ku kocke aj tak pridáme. Bude vypisovať, že sa jedná o kocku a vráti aj počet stien. Najprv si vypíšme do konzoly našu inštanciu kocky:

print(sestistenna)

Do konzoly sa vypíše iba cesta k našej triede:

Výpis objektu:
<__main__.Kostka object at 0x00000228043EE090>

Hoci je metóda už definovaná a poskytuje nám určitý výstup, chceme o našej kocke získať podrobnejšie informácie. Najlepšie také, o ktorých sami rozhodneme, že je vhodné ich zobraziť. To docielime tým, že vstavanú metódu __str__() jednoducho definujeme sami znova a tým ju prekryjeme:

class Kostka:
    """
    Třída reprezentuje hrací kostku.
    """

    def __init__(self,pocet_sten=6):
        self._pocet_sten = pocet_sten

    def vrat_pocet_sten(self):
        """
        Vrátí počet stěn kostky.
        """
        return self._pocet_sten

    def hod(self):
        """
        Vykoná hod kostkou a vrátí číslo od 1 do
        počtu stěn.
        """
        import random as _random
        return _random.randint(1, self._pocet_sten)

    def __str__(self):
        """
        Vrací textovou reprezentaci kostky.
        """
        return str(f"Kostka s {self._pocet_sten} stěnami.")

sestistenna = Kostka()
desetistenna = Kostka(10) # nebo můžeme zapsat Kostka(pocet_sten=10)
print(sestistenna)
print(desetistenna)

V konzole uvidíme:

Překrytí metody __str__():
Kostka s 6 stěnami.
Kostka s 10 stěnami.

Ešte si naše kocky vyskúšame. Skúsime si v programe s našimi dvoma kockami v cykloch hádzať a pozrieme sa, či fungujú tak, ako sa očakáva. Upravíme koniec súboru:

class Kostka:
    """
    Třída reprezentuje hrací kostku.
    """

    def __init__(self,pocet_sten=6):
        self._pocet_sten = pocet_sten

    def vrat_pocet_sten(self):
        """
        Vrátí počet stěn kostky.
        """
        return self._pocet_sten

    def hod(self):
        """
        Vykoná hod kostkou a vrátí číslo od 1 do
        počtu stěn.
        """
        import random as _random
        return _random.randint(1, self._pocet_sten)

    def __str__(self):
        """
        Vrací textovou reprezentaci kostky.
        """
        return str(f"Kostka s {self._pocet_sten} stěnami.")


# vytvoření kostek
sestistenna = Kostka()
desetistenna = Kostka(10)

#hod šestistěnnou
print(sestistenna)
for _ in range(6):
    print(sestistenna.hod(), end=" ")

#hod desetistěnnou
print("\n", desetistenna, sep=" ")
for _ in range(10):
    print(desetistenna.hod(), end=" ")

Za for nasleduje podtržítko. Divné, že? V kontexte slučky for sa jednoduché podtržítko _ používa ako dočasná premenná, keď nás skutočná hodnota v každom priechode slučkou nezaujíma. Je to konvenčný spôsob, ako naznačiť, že hodnota tejto premennej nebude v danom kontexte využitá.

Výstup môže vyzerať nejako takto:

Konzolová aplikácia
Kostka s 6 stěnami
1 6 4 5 5 4
Kostka s 10 stěnami
5 7 3 2 5 10 7 8 3 9

Máme hotovú celkom peknú a nastaviteľnú triedu, ktorá reprezentuje hraciu kocku. Bude sa nám hodiť v našej aréne, ale k dispozícii ju máme na využitie aj kdekoľvek inde. Vidíme, ako OOP umožňuje znovu používať komponenty.

V nasledujúcej lekcii, Zapuzdrenie atribútov podrobne v Pythone , sa budeme podrobnejšie venovať práci s privátnymi atribútmi a ich zapuzdrením.

 

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š.