Python agus dòighean adhartach, gnìomhan dunder airson prògramadh nas fheàrr

Tha Python na chànan prògramaidh air leth, agus mar a chithear le GitHub, cuideachd mar an dàrna cànan as mòr-chòrdte ann an 2022.

Is e na buannachdan as inntinniche a tha aig Python a’ choimhearsnachd mhòr de luchd-prògramaidh.

Tha e coltach gu bheil pasgan aig Python airson cùis cleachdaidh sam bith.

Ann an saoghal farsaing de phrògraman Python, tha seata de fheartan ann nach toir luchd-tòiseachaidh an aire gu tric, ach aig a bheil cudrom mòr ann an eag-shiostam cànain.

Tha dòighean draoidheachd nan seata de dhòighean ro-mhìnichte ann an Python a tha a’ toirt seachad feartan syntactic sònraichte. Tha iad furasta an aithneachadh leis na loidhnichean dùbailte aca aig toiseach is deireadh, mar __init__, __call__, __len__ … etc.

Na dòighean draoidheil

Tha dòighean draoidheachd a’ leigeil le nithean àbhaisteach a bhith gan giùlan fhèin san aon dòigh ri seòrsaichean Python air a ghabhail a-steach.

San artaigil seo, cuiridh sinn fòcas air na gnìomhan dunder cumhachdach. Rannsaichidh sinn an adhbhar agus bruidhnidh sinn air an cleachdadh.

Co-dhiù a tha thu nad neach-tòiseachaidh gu Python no prògramadair eòlach, tha an artaigil seo ag amas air tuigse fharsaing a thoirt seachad air gnìomhan Dunder, a’ dèanamh an eòlas còdaidh agad Python nas èifeachdaiche agus nas tlachdmhoire.

Cuimhnich, draoidheachd na Python tha e na laighe chan ann a-mhàin ann an sìmplidheachd agus sùbailteachd, ach cuideachd anns na feartan cumhachdach aige leithid gnìomhan Dunder.

__nit__

Is dòcha gur e an gnìomh dunder as bunaitiche de na h-uile. Is e seo an dòigh draoidheachd a tha Python gairmean gu fèin-ghluasadach nuair a chruthaicheas sinn (no mar a tha an t-ainm a’ moladh, a thòisicheas sinn) nì ùr.__init__

Pizza clas:
    def __init__ (fèin, meud, mullaich):
        self.size = meud
        self.toppings = toppings

# A-nis cruthaichidh sinn piotsa
my_pizza = Pizza ('mòr', ['pepperoni', 'balgan-buachair'])

print(my_pizza.size) # Clò-bhuailidh seo: mòr
clò-bhualadh (my_pizza.toppings) # Clò-bhuailidh seo: ['pepperoni', 'balgan-buachair']

Anns an eisimpleir seo, tha clas ris an canar Pizza air a chruthachadh. Stèidhich sinn ar gnìomh __init__ gus paramadairean a ghabhail a-steach airson a shònrachadh aig àm tòiseachaidh, agus shuidhich sinn iad mar thogalaichean airson an nì àbhaisteach againn.

An seo, thathar ga chleachdadh airson eisimpleir a’ chlas a riochdachadh. Mar sin nuair a sgrìobhas sinn self.size = meud, tha sinn ag ràdh, “Hey, tha meud buadhach aig an nì piotsa seo size, agus tha mi airson gum bi e ge bith dè am meud a thug mi seachad nuair a chruthaich mi an nì”.

__str__ agus __repr__

__Str__

Is e seo an dòigh draoidheachd Python a leigeas leinn cunntas a mhìneachadh airson an nì àbhaisteach againn.

Nuair a bhios tu a’ clò-bhualadh nì no ga thionndadh gu sreang a’ cleachdadh str(), Python Dèan cinnteach a bheil thu air modh a mhìneachadh __str__ airson clas an nì sin.

Ma tha, cleachd an dòigh sin gus an nì a thionndadh gu sreang.

Is urrainn dhuinn an eisimpleir Pizza againn a leudachadh gus gnìomh a thoirt a-steach __str__ mar a leanas:

clas Pizza: def __init__ (fèin, meud, mullaich): self.size = meud self.toppings = toppings def __str__(fèin): till f"Piotsa {self.size} le {', '.join(self.toppings) )}" my_pizza = Pizza ('mòr', ['pepperoni', 'balgan-buachair']) clò-bhualadh (my_pizza) # Clò-bhuailidh seo: Piotsa mòr le pepperoni, balgan-buachair

__repr__

Tha an gnìomh __str__ nas motha de dhòigh neo-fhoirmeil air feartan nì a mhìneachadh. Air an làimh eile, tha __repr__ air a chleachdadh gus tuairisgeul nas foirmeile, nas mionaidiche agus nas soilleire a thoirt seachad air an nì àbhaisteach.

Ma chuireas tu fòn repr() air rud no dìreach cuir a-steach ainm an nì a-steach don consol, Python bidh e a’ coimhead airson dòigh-obrach __repr__.

Se __str__ chan eil e air a mhìneachadh, Python cleachdadh __repr__ mar chùl-taic nuair a thathar a’ feuchainn ris an nì a chlò-bhualadh no a thionndadh gu sreang. Mar sin is e deagh bheachd a th’ ann gu tric mìneachadh co-dhiù __repr__, eadhon ged nach eil e air a mhìneachadh __str__.

Seo mar a b’ urrainn dhuinn a mhìneachadh __repr__ airson an eisimpleir pizza againn:

Pizza clas:
    def __init__ (fèin, meud, mullaich):
        self.size = meud
        self.toppings = toppings

    def __repr__(fèin):
        till f "Pizza ('{self.size}', {self.toppings})"

my_pizza = Pizza ('mòr', ['pepperoni', 'balgan-buachair'])
clò-bhualadh (repr (my_pizza)) # Clò-bhuailidh seo: Pizza ('mòr', ['pepperoni', 'balgan-buachair'])

__repr__ bheir e dhut sreang as urrainn dhut a chuir an gnìomh mar àithne Python gus am piotsa ath-chruthachadh, fhad ‘s a tha __str__ a’ toirt dhut tuairisgeul nas daonna. Tha mi an dòchas gun cuidich e thu le bhith a’ cagnadh nan dòighean dunder sin beagan nas fheàrr!

__cuir__

In Python, tha fios againn uile gun urrainn dhut àireamhan a chur ris a 'cleachdadh a' ghnìomhaiche +, coltach 3 + 5.

Ach dè ma tha sinn airson eisimpleirean de rud àbhaisteach a chuir ris?

An gnìomh dunder __add__ tha e a’ leigeil leinn dìreach sin a dhèanamh. Bheir e comas dhuinn giùlan a’ ghnìomhaiche a mhìneachadh + air na stuthan pearsanta againn.

A thaobh cunbhalachd, leig dhuinn gabhail ris gu bheil sinn airson giùlan a mhìneachadh + air an eisimpleir pizza againn. Canaidh sinn, nuair a chuireas sinn dà phiotsa no barrachd ri chèile, bidh e gu fèin-ghluasadach a’ cothlamadh na mullaich aca gu lèir. Seo cò ris a dh’ fhaodadh e a bhith coltach:

Pizza clas:
    def __init__ (fèin, meud, mullaich):
        self.size = meud
        self.toppings = toppings

    def __add__(fèin, eile):
        mura h-eil an suidheachadh (eile, pizza):
            tog TypeError ("Chan urrainn dhut ach piotsa eile a chur ris!")
        new_toppings = self.toppings + other.toppings
        tilleadh Pizza (fèin.size, new_toppings)

# Cruthaichidh sinn dà phiotsa
pizza1 = Pizza ('mòr', ['pepperoni', 'balgan-buachair'])
pizza2 = Pizza ('mòr', ['olives', 'pineapple'])

# Agus a-nis leig dhuinn "cuir" iad
combine_pizza = piotsa1 + piotsa2

clò-bhualadh (combined_pizza.toppings) # Clò-bhuailidh seo: ['pepperoni', 'balgan-buachair', 'olives', 'pineapple']

Coltach ri dunder __add__, is urrainn dhuinn cuideachd gnìomhan àireamhachd eile leithid __sub__ (le toirt air falbh a’ cleachdadh a’ ghnìomhaiche -) e __mul__ (airson iomadachadh a’ cleachdadh a’ ghnìomhaiche *).

__len__

Tha an dòigh dunder seo a’ leigeil leinn mìneachadh dè an gnìomh a th’ ann len() feumaidh sinn tilleadh airson na stuthan gnàthaichte againn.

Python Na Stàitean Aonaichte len() gus fad no meud structar dàta leithid liosta no sreang fhaighinn.

Ann an co-theacsa ar n-eisimpleir, dh'fhaodadh sinn a ràdh gur e "fad" piotsa an àireamh de thobraichean a th' aige. Seo mar a b’ urrainn dhuinn a chur an gnìomh:

Pizza clas:
    def __init__ (fèin, meud, mullaich):
        self.size = meud
        self.toppings = toppings

    def __len__(fèin):
        tilleadh lionsa (self.toppings)

# Cruthaichidh sinn piotsa
my_pizza = Pizza ('mòr', ['pepperoni', 'balgan-buachair', 'ollan'])

print(len(my_pizza)) # Clò-bhuailidh seo: 3

Anns an dòigh __len__, cha till sinn ach fad an liosta toppings. A-nis, len(my_pizza) innsidh e dhuinn cia mheud bàrr a tha air my_pizza.

__ pròiseas __

Tha an dòigh dunder seo a’ leigeil le nithean a bhith air an ath-aithris, i.e. faodar a chleachdadh ann an airson lùb.

Gus seo a dhèanamh, feumaidh sinn cuideachd an gnìomh a mhìneachadh __next__, Tha seo air a chleachdadh gus an giùlan a mhìneachadh a bu chòir an ath luach san ath-aithris a thilleadh. A bharrachd air an sin, bu chòir dha cuideachd innse don ath-aithris air an tachartas nach eil barrachd eileamaidean san t-sreath. Mar as trice bidh sinn a’ coileanadh seo le bhith a’ togail eisgeachd StopIteration.

Airson an eisimpleir piotsa againn, canaidh sinn gu bheil sinn airson na mullaich ath-aithris. Dh’ fhaodadh sinn ar clas Pizza ath-aithris le bhith a’ mìneachadh dòigh-obrach __iter__:

Pizza clas:
    def __init__ (fèin, meud, mullaich):
        self.size = meud
        self.toppings = toppings

    def __iter__(fèin):
        fèin.n = 0
        tilleadh fèin

    def __next__(fèin):
        mas e fèin.n <len(self.toppings):
            toradh = self.toppings[self.n]
            fèin.n +=1
            toradh air ais
        eile:
            Àrdaich StopIteration

# Cruthaichidh sinn piotsa
my_pizza = Pizza ('mòr', ['pepperoni', 'balgan-buachair', 'ollan'])

# Agus a nis rachamaid thairis air
airson bàrr ann am my_pizza:
    clò-bhualadh (mullach)

Anns a 'chùis seo, airson gairmean lùb __iter__, a thòisicheas cuntair (self.n) agus tillidh e am piotsa fhèin (self).

An uairsin, an airson gairmean lùb __next__ gus gach mullach fhaighinn mu seach.

nuair a __next__ thug air ais a h-uile blasad, StopIteration tha e a’ tilgeil eisgeachd agus tha fios aig an airson loop a-nis nach eil tuilleadh mullaich ann agus mar sin sguir e den phròiseas ath-aithris.

Ercole Palmeri