Python и напредни методи, Dunder функции за подобро програмирање

Python е фантастичен програмски јазик, и како што е потврдено од GitHub, исто така е втор најпопуларен јазик во 2022 година.

Најинтересните предности на Python се големата заедница на програмери.

Се чини дека Python има пакет за секој случај на употреба.

Во огромниот свет на програмирањето на Python, постои сет на функции кои често остануваат незабележани од почетниците, но сепак имаат значајно значење во екосистемот на јазикот.

Магичните методи се збир на пред методиdefinites во Python кои обезбедуваат посебни синтаксички карактеристики. Лесно се препознаваат по нивните двојни цртички на почетокот и на крајот, како __init__, __call__, __len__ … итн.

Магичните методи

Магичните методи дозволуваат приспособените објекти да се однесуваат слично на вградените типови на Python.

Во оваа статија, ќе се фокусираме на моќните функции на Dunder. Ќе ја истражиме нивната цел и ќе разговараме за нивната употреба.

Без разлика дали сте почетник во Python или искусен програмер, оваа статија има за цел да ви овозможи сеопфатно разбирање на функциите на Dunder, правејќи го вашето искуство со кодирање во Python поефикасно и попријатно.

Запомнете, магијата на Python не лежи само во неговата едноставност и разноврсност, туку и во неговите моќни карактеристики како Dunder функциите.

__init__

Можеби најосновната Dunder функција од сите. Ова е магичниот метод што Python автоматски го повикува секогаш кога создаваме (или како што сугерира името, иницијализираме) нов објект.__init__

класа пица:
    def __init__(само, големина, додатоци):
        себе.големина = големина
        себе.прелив = прелив

# Сега ајде да создадеме пица
my_pizza = Пица('голема', ['феферони', 'печурки'])

print(my_pizza.size) # Ова ќе печати: големи
print(my_pizza.toppings) # Ова ќе отпечати: ['феферони', 'печурки']

Во овој пример, се создава класа наречена Пица. Ја поставивме нашата функција __init__ за да ги вклучи параметрите што треба да се специфицираат во времето на иницијализација и ги поставивме како својства за нашиот прилагоден објект.

Овде, се користи за претставување на примерот на класата. Значи, кога пишуваме self.size = големина, велиме: „Еј, овој објект за пица има големина на атрибут size, и сакам да биде каква било големина што сум ја дал кога го создадов објектот“.

__str__ и __repr__

__Стр__

Ова е магичниот метод на Пајтон кој ни овозможува defiниш опис за нашата прилагодена ставка.

Кога печатите објект или го претворате во стринг користејќи str(), Пајтон проверете дали имате defiСмислив метод __str__ за класата на тој објект.

Ако е така, користете го тој метод за да го конвертирате објектот во стринг.

Можеме да го прошириме нашиот пример за пица за да вклучиме функција __str__ како што следува:

класа Пица: def __init__(self, size, toppings): self.size = size self.toppings = toppings def __str__(self): врати f"A {self.size} пица со {', '.join(self.toppings )}" my_pizza = Пица('голема', ['пеперони', 'печурки']) print(my_pizza) # Ова ќе испечати: Голема пица со феферони, печурки

__repr__

Функцијата __str__ е повеќе неформален начин за опишување на својствата на објектот. Од друга страна, __repr__ се користи за да се обезбеди поформален, детален и недвосмислен опис на приспособениот објект.

Ако се јавите repr() на некој објект или само внесете го името на објектот во конзолата, Пајтон ќе бара метод __repr__.

Se __str__ не е definite, Python ќе користи __repr__ како резервна копија кога се обидувате да го испечатите објектот или да го претворите во стринг. Затоа често е добра идеја defiзаврши барем __repr__, дури и ако не го правите тоа defiизлегува __str__.

Еве како би можеле defiзаврши __repr__ за нашиот пример за пица:

класа пица:
    def __init__(само, големина, додатоци):
        себе.големина = големина
        себе.прелив = прелив

    def __repr__(себе):
        врати f"Pizza('{self.size}', {self.toppings})"

my_pizza = Пица('голема', ['феферони', 'печурки'])
print(repr(my_pizza)) # Ова ќе печати: Пица ('голема', ['пеперони', 'печурки'])

__repr__ ви дава низа што можете да ја извршите како команда на Python за да го рекреирате објектот на пица, додека __str__ ви дава похуман опис. Се надевам дека ќе ви помогне малку подобро да ги џвакате овие методи на шуга!

__додај__

Во Python, сите знаеме дека е можно да се додаваат броеви со помош на операторот +, Како 3 + 5.

Но, што ако сакаме да додадеме примери на некој прилагоден објект?

Функцијата Dunder __add__ ни овозможува да го направиме токму тоа. Тоа ни дава способност да defiпонижете го однесувањето на операторот + на нашите персонализирани предмети.

Во интерес на конзистентноста, да претпоставиме дека сакаме defiзаврши однесувањето на + на нашиот пример за пица. Да речеме дека секогаш кога ќе додадеме две или повеќе пици заедно, автоматски ќе ги комбинира сите нивни додатоци. Еве како тоа би можело да изгледа:

класа пица:
    def __init__(само, големина, додатоци):
        себе.големина = големина
        себе.прелив = прелив

    def __add__(себе, друго):
        ако не е пример (друго, пица):
            подигнете TypeError ("Можете да додадете само друга пица!")
        new_toppings = self.topings + other.toppings
        повратна пица (self.size, new_toppings)

# Ајде да создадеме две пици
pizza1 = Пица ('голема', ['феферони', 'печурки'])
pizza2 = Пица ('голема', ['маслинки', 'ананас'])

# И сега да ги „додадеме“.
комбинирана_пица = пица1 + пица2

print(combined_pizza.toppings) # Ова ќе отпечати: ['феферони', 'печурки', 'маслинки', 'ананас']

Слично на Dunder __add__, можеме и ние defiзавршете ги другите аритметички функции како на пр __sub__ (со одземање со помош на операторот -) И __mul__ (за множење со помош на операторот *).

__лен__

Овој dunder метод ни овозможува да defiзаврши што функцијата len() мора да се врати за нашите приспособени ставки.

Пајтон користи len() за да се добие должината или големината на структурата на податоци како листа или низа.

Во контекст на нашиот пример, би можеле да кажеме дека „должината“ на пицата е бројот на преливи што ги има. Еве како би можеле да го имплементираме:

класа пица:
    def __init__(само, големина, додатоци):
        себе.големина = големина
        себе.прелив = прелив

    def __len__(себе):
        повратна леќа (само. преливи)

# Ајде да создадеме пица
my_pizza = Пица('голема', ['феферони', 'печурки', 'маслинки'])

print(len(my_pizza)) # Ова ќе отпечати: 3

Во методот __len__, ја враќаме само должината на листата toppings. Сега, len(my_pizza) ќе ни каже колку преливи има на неа my_pizza.

__ процес __

Овој метод Dunder овозможува објектите да бидат повторливи, т.е. може да се користат во за јамка.

За да го направите ова, ние исто така мораме defiзавршете ја функцијата __next__, Ова се користи за defiNish однесувањето што треба да ја врати следната вредност во итерацијата. Исто така, треба да го сигнализира итерабилот во случај дека нема повеќе елементи во низата. Ова обично го постигнуваме со исклучок StopIteration.

За нашиот пример за пица, да речеме дека сакаме да ги повториме додатоците. Можеме да го направиме нашиот час по пица повторлив defiнедо метод __iter__:

класа пица:
    def __init__(само, големина, додатоци):
        себе.големина = големина
        себе.прелив = прелив

    дефиниција __iter__(себе):
        себе.n = 0
        врати се себеси

    дефиниција __следно__(себе):
        if self.n < len(self.topings):
            резултат = self.topings[self.n]
            себе.n += 1
            повратен резултат
        друго:
            подигнете StopIteration

# Ајде да создадеме пица
my_pizza = Пица('голема', ['феферони', 'печурки', 'маслинки'])

# И сега да повториме околу тоа
за прелив во my_pizza:
    печатење (прелив)

Во овој случај, јамката за повикува __iter__, што иницијализира бројач (self.n) и го враќа самиот предмет на пица (self).

Потоа, јамката за повикува __next__ да се добие секој прелив по ред.

Кога __next__ ги врати сите зачини, StopIteration фрла исклучок и за јамката сега знае дека нема повеќе додатоци и така ќе го прекине процесот на повторување.

Ercole Palmeri