Python ja täiustatud meetodid, dunder funktsioonid paremaks programmeerimiseks

Python on fantastiline programmeerimiskeel ja seda tõendab GitHub, on ka 2022. aastal populaarsuselt teine ​​keel.

Pythoni kõige huvitavamad eelised on suur programmeerijate kogukond.

Tundub, et Pythonil on pakett igaks kasutusjuhtumiks.

Pythoni programmeerimise tohutus maailmas on hulk funktsioone, mis algajatele sageli märkamatuks jäävad, kuid millel on keele ökosüsteemis oluline tähtsus.

Maagilised meetodid on eelmeetodite kogumdefinites Pythonis, mis pakuvad erilisi süntaktilisi funktsioone. Neid tunneb kergesti ära topeltkriipsude järgi alguses ja lõpus, näiteks __init__, __call__, __len__ … jne.

Maagilised meetodid

Maagilised meetodid võimaldavad kohandatud objektidel käituda sarnaselt sisseehitatud Pythoni tüüpidega.

Selles artiklis keskendume võimsatele dunder-funktsioonidele. Uurime nende eesmärki ja arutame nende kasutamist.

Olenemata sellest, kas olete Pythoni algaja või kogenud programmeerija, selle artikli eesmärk on anda teile põhjalik arusaam Dunderi funktsioonidest, muutes teie Pythoni kodeerimiskogemuse tõhusamaks ja nauditavamaks.

Pidage meeles, et Pythoni võlu ei seisne mitte ainult selle lihtsuses ja mitmekülgsuses, vaid ka võimsates funktsioonides, nagu Dunderi funktsioonid.

__init__

Võib-olla kõige elementaarsem dunder-funktsioon. See on maagiline meetod, mida Python kutsub automaatselt välja iga kord, kui loome (või nagu nimigi ütleb, initsialiseerime) uue objekti.__init__

klassi pizza:
    def __init__(ise, suurus, lisandid):
        ise.suurus = suurus
        ise.katted = lisandid

# Nüüd loome pitsa
my_pizza = Pitsa ('suur', ['piparonid', 'seened'])

print(my_pizza.size) # See prindib: suur
print(my_pizza.toppings) # See prindib: ['pepperoni', 'seened']

Selles näites luuakse klass nimega Pizza. Seadistame funktsiooni __init__, et see hõlmaks lähtestamise ajal määratavaid parameetreid, ja määrasime need meie kohandatud objekti atribuutidena.

Siin kasutatakse seda klassi eksemplari esindamiseks. Nii et kui kirjutame self.size = suurus, ütleme: "Hei, sellel pitsaobjektil on atribuudi suurus sizeja ma tahan, et see oleks mis tahes suuruses, mille ma objekti loomisel andsin.

__str__ ja __repr__

__Str__

See on Pythoni maagiline meetod, mis võimaldab meil seda teha defikoostage meie kohandatud kauba kirjeldus.

Kui prindite objekti või teisendate selle stringiks kasutades str(), Python kontrollige, kas teil on defiOlen välja mõelnud meetodi __str__ selle objekti klassi jaoks.

Kui jah, kasutage seda meetodit objekti stringiks teisendamiseks.

Saame laiendada oma Pizza näidet funktsiooniga __str__ järgmiselt:

klass Pitsa: def __init__(ise, suurus, lisandid): self.size = suurus self.toppings = lisandid def __str__(ise): return f"{self.size} pitsa koos {', '.join(self.toppings) )}" my_pizza = Pizza('suur', ['pepperoni', "seened"]) print(minu_pitsa) # See prindib: suur pitsa pepperoni ja seentega

__repr__

Funktsioon __str__ on pigem mitteametlik viis objekti omaduste kirjeldamiseks. Teisest küljest kasutatakse __repr__ kohandatud objekti formaalsema, üksikasjalikuma ja ühemõttelisema kirjelduse pakkumiseks.

Kui helistate repr() objektil või lihtsalt tippides konsooli objekti nime, otsib Python meetodi __repr__.

Se __str__ see ei ole definite, kasutab Python __repr__ varukoopiana, kui proovite objekti printida või stringiks teisendada. Nii et see on sageli hea mõte defivähemalt lõpetada __repr__, isegi kui te seda ei tee defiilus __str__.

Siin on, kuidas me saaksime defilõpetama __repr__ meie pitsa näite jaoks:

klassi pizza:
    def __init__(ise, suurus, lisandid):
        ise.suurus = suurus
        ise.katted = lisandid

    def __repr__(ise):
        return f"Pizza('{self.size}', {self.toppings})"

my_pizza = Pitsa ('suur', ['piparonid', 'seened'])
print(repr(minu_pitsa)) # See prindib: Pizza('suur', ['pepperoni', 'seened'])

__repr__ annab teile stringi, mida saate pitsaobjekti taasloomiseks Pythoni käsuna käivitada __str__ annab sulle inimlikuma kirjelduse. Loodan, et see aitab teil neid jaburaid meetodeid veidi paremini närida!

__lisama__

Pythonis teame kõik, et operaatori abil on võimalik numbreid lisada +, Nagu 3 + 5.

Aga mis siis, kui tahame lisada mõne kohandatud objekti eksemplare?

Dunderi funktsioon __add__ see võimaldab meil just seda teha. See annab meile võimaluse defioperaatori käitumist + meie isikupärastatud esemetel.

Järjepidevuse huvides oletame, et tahame defikäitumist lõpetama + meie pitsa näitel. Oletame, et kui lisame kaks või enam pitsat, ühendab see automaatselt kõik nende lisandid. See võib välja näha järgmiselt.

klassi pizza:
    def __init__(ise, suurus, lisandid):
        ise.suurus = suurus
        ise.katted = lisandid

    def __add__(ise, muu):
        kui mitte, siis (muu, pizza):
            raise TypeError("Saate lisada ainult teise pitsa!")
        uued_lisandid = ise.katted + muud.lisandid
        tagasta pitsa (self.size, new_toppings)

# Loome kaks pitsat
pizza1 = pitsa ('suur', ['pepperoni', "seened"])
pizza2 = pizza ('suur', ['oliivid', "ananass"])

# Ja nüüd "lisagem" need
kombineeritud_pitsa = pizza1 + pitsa2

print(combined_pizza.toppings) # Sellega trükitakse: ['pepperoni', 'seened', 'oliivid', 'ananass']

Sarnaselt dunderiga __add__, saame ka defilõpetage muid aritmeetilisi funktsioone, näiteks __sub__ (lahutades, kasutades operaatorit -) Ja __mul__ (korrutamiseks operaatori abil *).

__len__

See dunder meetod võimaldab meil defilõpetage mis funktsioon on len() peab meie kohandatud kaupade saamiseks tagasi pöörduma.

Python kasutab len() andmestruktuuri (nt loendi või stringi) pikkuse või suuruse saamiseks.

Meie näite kontekstis võiksime öelda, et pitsa "pikkus" on sellel olevate lisandite arv. Siin on, kuidas saaksime seda rakendada:

klassi pizza:
    def __init__(ise, suurus, lisandid):
        ise.suurus = suurus
        ise.katted = lisandid

    def __len__(ise):
        tagasi objektiiv (self.toppings)

# Loome pitsa
my_pizza = Pitsa('suur', ['piparonid', "seened", "oliivid"])

print(len(my_pizza)) # See prindib: 3

Meetodi __len__ korral tagastame ainult loendi pikkuse toppings. Nüüd, len(my_pizza) see ütleb meile, kui palju lisandeid sellel on my_pizza.

__ protsess __

See dunder-meetod võimaldab objekte itereerida, st seda saab kasutada for-tsüklis.

Selleks peame ka defilõpetage funktsioon __next__, Seda kasutatakse definish käitumist, mis peaks tagastama iteratsiooni järgmise väärtuse. Samuti peaks see itereeritavale sündmusele märku andma, kui jadas pole enam elemente. Tavaliselt saavutame selle erandi tegemisega StopIteration.

Oletame, et meie pitsa näite puhul tahame katteid korrata. Võiksime muuta oma pizza klassi itereeritavaks definendo meetodit __iter__:

klassi pizza:
    def __init__(ise, suurus, lisandid):
        ise.suurus = suurus
        ise.katted = lisandid

    def __iter__(ise):
        ise.n = 0
        tagasi ennast

    def __next__(ise):
        kui ise.n < len(ise.katted):
            tulemus = self.toppings[self.n]
            ise.n += 1
            tagastada tulemus
        muu:
            tõsta StopIteration

# Loome pitsa
my_pizza = Pitsa('suur', ['piparonid', "seened", "oliivid"])

# Ja nüüd korrakem seda
minu_pizza katteks:
    print (pealmine)

Sel juhul kutsub tsükkel for __iter__, mis initsialiseerib loenduri (self.n) ja tagastab pitsaeseme enda (self).

Seejärel kutsuvad for tsüklit __next__ et saada iga kattekiht kordamööda.

Quando __next__ tagastas kõik maitseained, StopIteration see teeb erandi ja for-silmus teab nüüd, et lisandeid pole enam ja seega katkestab iteratsiooniprotsessi.

Ercole Palmeri