Python na njia za hali ya juu, kazi za dunder kwa programu bora

Python ni lugha ya kupendeza ya programu, na kama inavyothibitishwa na GitHub, pia ni lugha ya pili kwa umaarufu mwaka wa 2022.

Faida za kuvutia zaidi za Python ni jamii kubwa ya watengeneza programu.

Inaonekana Python ina kifurushi cha kesi yoyote ya utumiaji.

Katika ulimwengu mkubwa wa programu ya Python, kuna seti ya vipengele ambavyo mara nyingi huwa havitambuliwi na wanaoanza, lakini vina umuhimu mkubwa katika mfumo wa ikolojia wa lugha.

Mbinu za uchawi ni seti ya mbinu za awalidefinites katika Python ambayo hutoa vipengele maalum vya kisintaksia. Wanatambulika kwa urahisi na mistari yao miwili mwanzoni na mwisho, kama __init__, __call__, __len__ … na kadhalika.

Mbinu za Kichawi

Njia za kichawi huruhusu vitu maalum kufanya kazi sawa na aina za Python zilizojengwa.

Katika makala hii, tutazingatia kazi za dunder zenye nguvu. Tutachunguza madhumuni yao na kujadili matumizi yao.

Iwe wewe ni mwanafunzi wa Python au mtaalamu wa programu, makala hii inalenga kukupa ufahamu wa kina wa kazi za Dunder, na kufanya uzoefu wako wa usimbaji wa Python kuwa mzuri na wa kufurahisha zaidi.

Kumbuka, uchawi wa Python hauko tu katika unyenyekevu na utofauti wake, lakini pia katika huduma zake zenye nguvu kama kazi za Dunder.

__init__

Labda kazi ya msingi zaidi ya dunder ya yote. Hii ndio njia ya kichawi ambayo Python huita kiotomatiki wakati wowote tunapounda (au kama jina linapendekeza, anzisha) kitu kipya.__init__

Pizza ya darasa:
    def __init__(ubinafsi, saizi, nyongeza):
        self.size = ukubwa
        self.toppings = toppings

# Sasa wacha tutengeneze pizza
my_pizza = Pizza('kubwa', ['pepperoni', 'uyoga'])

chapa(my_pizza.size) # Hii itachapisha: kubwa
chapa(my_pizza.toppings) # Hii itachapisha: ['pepperoni', 'uyoga']

Katika mfano huu, darasa linaloitwa Pizza linaundwa. Tunaweka kitendakazi chetu cha __init__ ili kujumuisha vigezo vitakavyobainishwa wakati wa uanzishaji, na kuviweka kama sifa za kitu chetu maalum.

Hapa, inatumika kuwakilisha mfano wa darasa. Kwa hivyo tunapoandika self.size = size, tunasema, "Halo, kitu hiki cha pizza kina ukubwa wa sifa. size, na ninataka iwe saizi yoyote niliyotoa nilipounda kitu hicho”.

__str__ na __repr__

__Str__

Hii ni njia ya kichawi ya Python ambayo inaruhusu sisi definish maelezo ya bidhaa zetu maalum.

Unapochapisha kitu au kukibadilisha kuwa mfuatano ukitumia str(), Python angalia ikiwa unayo defiNimekuja na mbinu __str__ kwa darasa la kitu hicho.

Ikiwa ni hivyo, tumia njia hiyo kubadilisha kitu kuwa kamba.

Tunaweza kupanua mfano wetu wa Pizza ili kujumuisha chaguo la kukokotoa __str__ kama ifuatavyo:

class Pizza: def __init__(self, size, toppings): self.size = size self.toppings = toppings def __str__(self): return f"Pizza {self.size} yenye {', '.jiunge(self.toppings) )}" my_pizza = Pizza('kubwa', ['pepperoni', 'mushrooms']) chapa(my_pizza) # Hii itachapishwa: Pizza kubwa yenye pepperoni, uyoga

__repr__

Chaguo __str__ ni zaidi ya njia isiyo rasmi ya kuelezea sifa za kitu. Kwa upande mwingine, __repr__ inatumika kutoa maelezo rasmi zaidi, ya kina na yasiyo na utata ya kitu maalum.

Ukipiga simu repr() kwenye kitu au unaandika tu jina la kitu kwenye koni, Python itatafuta njia __repr__.

Se __str__ sio definite, Python itatumia __repr__ kama chelezo wakati wa kujaribu kuchapisha kitu au kukibadilisha kuwa kamba. Kwa hivyo mara nyingi ni wazo nzuri defikumaliza angalau __repr__, hata kama huna definzuri __str__.

Hivi ndivyo tulivyoweza defikumaliza __repr__ kwa mfano wetu wa pizza:

Pizza ya darasa:
    def __init__(ubinafsi, saizi, nyongeza):
        self.size = ukubwa
        self.toppings = toppings

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

my_pizza = Pizza('kubwa', ['pepperoni', 'uyoga'])
chapisha(repr(my_pizza)) # Hii itachapisha: Pizza('kubwa', ['pepperoni', 'uyoga'])

__repr__ inakupa kamba ambayo unaweza kukimbia kama amri ya Python kuunda tena kitu cha pizza, wakati __str__ inakupa maelezo zaidi ya kibinadamu. Natumai itakusaidia kutafuna njia hizi bora zaidi!

__ongeza__

Katika Python, sote tunajua kwamba inawezekana kuongeza nambari kwa kutumia operator +, Kama 3 + 5.

Lakini vipi ikiwa tunataka kuongeza mifano ya kitu maalum?

Kazi ya dunder __add__ inaturuhusu kufanya hivyo. Inatupa uwezo wa defiondoa tabia ya mwendeshaji + kwenye vitu vyetu vilivyobinafsishwa.

Kwa maslahi ya uthabiti, wacha tufikirie tunataka defikumaliza tabia ya + kwenye mfano wetu wa pizza. Wacha tuseme kwamba wakati wowote tunapoongeza pizza mbili au zaidi pamoja, itachanganya kiotomatiki nyongeza zao zote. Hivi ndivyo inavyoweza kuonekana:

Pizza ya darasa:
    def __init__(ubinafsi, saizi, nyongeza):
        self.size = ukubwa
        self.toppings = toppings

    def __ongeza__(binafsi, nyingine):
        ikiwa sio mfano (nyingine, Pizza):
            kuongeza TypeError("Unaweza tu kuongeza Pizza nyingine!")
        new_toppings = self.toppings + other.toppings
        return Pizza(self.size, new_toppings)

# Wacha tutengeneze pizza mbili
pizza1 = Pizza('kubwa', ['pepperoni', 'uyoga'])
pizza2 = Pizza('kubwa', ['zaituni', 'nanasi'])

# Na sasa hebu "tuwaongeze".
pamoja_pizza = pizza1 + pizza2

chapa(combined_pizza.toppings) # Hii itachapishwa: ['pepperoni', 'uyoga', 'zaituni', 'nanasi']

Sawa na dunder __add__, tunaweza pia defikumaliza kazi zingine za hesabu kama vile __sub__ (kwa kutoa kwa kutumia opereta -) Na __mul__ (kwa kuzidisha kwa kutumia opereta *).

__len__

Njia hii ya dunder inaruhusu sisi defikumaliza kazi gani len() lazima irudi kwa bidhaa zetu zilizobinafsishwa.

Python hutumia len() kupata urefu au ukubwa wa muundo wa data kama vile orodha au mfuatano.

Katika muktadha wa mfano wetu, tunaweza kusema kwamba "urefu" wa pizza ni idadi ya nyongeza iliyo nayo. Hivi ndivyo tunavyoweza kuitekeleza:

Pizza ya darasa:
    def __init__(ubinafsi, saizi, nyongeza):
        self.size = ukubwa
        self.toppings = toppings

    def __len__(binafsi):
        rudisha lenzi(self.toppings)

# Wacha tutengeneze pizza
my_pizza = Pizza('kubwa', ['pepperoni', 'uyoga', 'zaituni'])

print(len(my_pizza)) # Hii itachapisha: 3

Katika __len__ mbinu, tunarudisha urefu wa orodha pekee toppings. Sasa, len(my_pizza) itatuambia ni toppings ngapi juu yake my_pizza.

_ mchakato __

Njia hii ya dunder huruhusu vitu kueleweka, i.e. inaweza kutumika kwa kitanzi.

Ili kufanya hivyo, ni lazima pia defikumaliza kazi __next__, Hii ​​inatumika kwa definish tabia ambayo inapaswa kurudisha thamani inayofuata katika iteration. Inapaswa pia kuashiria iterable juu ya tukio kwamba hakuna vipengele zaidi katika mlolongo. Kwa kawaida tunafanikisha hili kwa kuweka ubaguzi StopIteration.

Kwa mfano wetu wa pizza, wacha tuseme tunataka kuongeza nyongeza. Tunaweza kufanya darasa letu la Pizza lifahamike definendo mbinu __iter__:

Pizza ya darasa:
    def __init__(ubinafsi, saizi, nyongeza):
        self.size = ukubwa
        self.toppings = toppings

    def __iter__(binafsi):
        binafsi.n = 0
        kurudi mwenyewe

    def __ifuatayo__(binafsi):
        if self.n < len(self.toppings):
            matokeo = self.toppings[self.n]
            binafsi.n += 1
            matokeo ya kurudi
        mwingine:
            kuongeza StopIteration

# Wacha tutengeneze pizza
my_pizza = Pizza('kubwa', ['pepperoni', 'uyoga', 'zaituni'])

# Na sasa turudie tena juu yake
kwa kuweka kwenye my_pizza:
    chapa (kuweka juu)

Katika kesi hii, kwa simu za kitanzi __iter__, ambayo huanzisha kihesabu (self.n) na inarudisha kitu cha pizza yenyewe (self).

Kisha, kwa simu za kitanzi __next__ kupata kila topping kwa zamu.

Wakati __next__ alirudisha manukato yote, StopIteration inatoa ubaguzi na kitanzi sasa kinajua kuwa hakuna toppings zaidi na hivyo itaondoa mchakato wa kurudia.

Ercole Palmeri