Обектно-ориентирано програмиране в Python: класове, описание и функции

В Python класовете са фундаментална концепция. Това е основата на стандартната библиотека, работата на най-популярните програми и самия език. Ако искате да станете повече от начинаещ програмист, трябва да разберете същността и принципа на работа с класове и предмети.

Какви са класовете

Това е основният софтуерен компонент на OOP. В Python класовете се използват за внедряване на нови типове обекти и се създават с помощта на специална инструкция за клас. Навън те приличат на стандартни вградени типове данни, като например номера или последователности. Но обектите на класа имат значителна разлика - подкрепа за наследяване.

Обектно-ориентирано програмиране в Python напълно се основава на йерархичното наследство на класовете. Това е универсален начин за адаптиране и повторно използване на кода. Но обектно-ориентираният подход не е задължителен. Python позволява само процедурно и функционално програмиране без проблеми.

Основната задача на класовете в Python е опаковането на данни и изпълнимия код. Те са синтактично същите като инструкциите за дефиниране. Подобно на функциите, те създават свои собствени пространства за имена, които могат да се наричат ​​многократно от всяка част от програмата. Тогава защо са необходими? Класовете са по-мощен и универсален инструмент. Преди всичко техният потенциал се разкрива, когато се създават нови обекти.

Значението на класовете и принципа на наследството

Всеки нов обект има свое собствено пространство на имена, което можете да програмирате, да въвеждате променливи и да създавате каквито и да било функции. Също така има атрибути, наследени от класа: object.attribute. Това е значението на ООП.

Благодарение на наследството се създава йерархично дърво. На практика изглежда така. Когато преводачът се сблъска с израза object.attribute, той започва да търси първия случай на атрибута в определения клас. Без да открива атрибута, преводачът продължава да търси във всички свързани класове в дървото горе, отляво надясно.

Дървото за търсене включва:

• Суперкласи, които са в горната част на йерархията и прилагат общо поведение;
• подкласове - са по-долу;
• примерите са програмни елементи с наследствено поведение.

Фигурата показва класовото дърво на Python. От примера виждаме, че класове 2 и 3 са суперкласи. В дъното има два случая на инстанция 1 и 2, в средата - подклас от клас 1. Ако напишете израза Instance2.w, това ще доведе до претърсване на преводача за стойността на атрибута .w в следния ред:

1. instance2;
2. Клас1;
3. Class2;
4. Class3.

Името .w ще бъде намерено в Superclass Class3. В терминологията на OOP това означава, че инстанция 2 "наследява" атрибута .w от Class3.

Обърнете внимание, че примерите в картината наследяват само четири атрибута: .w, .x, .y и .z:

• За случаите на Instance1.x и Instance2.x, атрибутът .x ще бъде намерен в клас 1, където търсенето ще спре, защото Клас 1 е в дървото по-ниско от Клас 2.
• За Instance1.y и Instance2.y, атрибутът .y ще бъде намерен в клас 1, където търсенето ще спре, защото това е единственото място, където се появява.
• За случаите Instance1.z и Instance2.z, преводачът ще открие .z в клас 2, защото се намира в дървото отляво на Class3.
• За Instance2.name, атрибутът .name ще бъде намерен в Instance2, без да се търси в дървото.

Предпоследният елемент е най-важният. Той демонстрира как клас 1 заменя атрибута .x, заменяйки .x версията на Superclass от клас 2.

Обекти, примери и методи

ООП работи с две основни понятия: класове и обекти. Класовете създават нови типове, а класовите обекти в Python са техните случаи. Например, всички целочислени променливи се отнасят за вградения тип данни int. В езика OOP те са копия на клас int.

Класовете се създават с инструкции и обектите се създават чрез обаждания. Те могат да съхраняват данни и да имат свои собствени функционални или класови методи. В Питон терминологията играе важна роля. С неговата помощ програмистите разграничават независими функции от тези, които принадлежат към класове. Променливите, свързани с обекти, се наричат ​​полета.

В ООП има два типа полета. Първата е променливите, принадлежащи на целия клас, а втората - променливите на отделните случаи. Полетата и методите заедно са атрибути на даден клас. В Python те се записват в кодовия блок след класа на ключовите думи.

Методи и значение на себе си

Методите са функции с допълнителното име самостоятелно. Той се добавя в горната част на списъка с параметри. Ако желаете, променливата може да се нарече различно име, но такава инициатива сред програмистите не е добре дошла. Самото е стандартно, лесно разпознаваемо име в кода. Освен това, някои среди за разработка са предназначени за работа с него.

За да разберете по-добре стойността на себе си в OOP, представете си, че имаме клас, наречен ClassA и методA:

• > Клас ClassA;
• def методA (самостоятелно, argument1, argument2).

ObjectA е инстанция на ClassA и извикването на метода изглежда така:

• > objectA.methodA (аргумент1, аргумент2).

Когато преводачът види този ред, той автоматично го преобразува, както следва: ClassA.methodA (objectA, argument1, argument2). Тоест, инстанцията на класа използва променливата аз като позоваване на себе си.

Как да създадете променливи, методи и случаи на класове

Предлагаме да разглобим практически пример от интерактивната черупка на Python. Създаването на класа "Experiment First" започва с класа на изявленията:

• > клас Първи експеримент:
• def setinf (self, value): # създайте първия метод с аргументи
• self.data = стойност
• def display (самостоятелно): # second method
• print (самостоятелно) # отпечатайте данните за потребителския модел.

След задължително отстъпване се следва блок със скрити инструкции за дефиниране, при които на два функционални обекта се задават имената, които се задават и се показват. С тяхна помощ са създадени атрибутите Experiment First.setinf и Experiment First.display. Всъщност всяко име, на което е присвоена стойност в най-горното ниво във вложения блок, става атрибут.

За да видите как работят методите, трябва да създадете два случая:

• > x = Първо експеримент () # Създават се два случая;
• > y = Първо експеримент () # Всеки е отделно пространство от имена.

Първоначално инстанциите не съхраняват никаква информация и са напълно празни. Но те са свързани с класа си:

• > x.setinf ("Изучаване на Python") # Извикване на метод, в който самое е x.
• > y.setinf (3.14) # Еквивалент: Първи експеримент (y, 3.14)

Ако чрез името на потребителския модел x, y се отнасят до атрибута .setinf на обекта "Експеримент първи", тогава интерпретаторът връща стойността на атрибута клас в резултат на търсене на дърво наследство.

• > x.display () # x и y имат свои собствени стойности на самостоятелни данни
• Научете Python
• > y.display ()
• 3.14.

Претоварване от оператора

В Python класовете могат да претоварят изразите. Тази възможност прави примерите подобни на вградените типове данни. Процесът се състои в прилагането на методи със специални имена, които започват и завършват с двойни долни черти.

Помислете в действие __init__ и __sub__. Първият метод се нарича конструктор на класа. В Python __init__ изпълнява претоварване на операцията за създаване на потребителски модел. Вторият метод __sub__ изпълнява операцията за изваждане.

• > Претоварване в клас: # създава нов клас
• def __init __ (самостоятелно, начало):
• самостоятелно = начало
• def __sub __ (самостоятелно, друго): # instance minus other
• връщане Претоварване (self.data - other) # Резултатът е нов
• > A = Претоварване (10) #__ init __ (A, 10)
• > B = A - 2 # _____ (B, 2)
• > B.data # B е ново копие на класа за претоварване
• 8.

Още за метода __init__

Методът __init__ се използва най-често при работа с класове. Необходимо е за инициализиране на различни обекти. __init__ не е необходимо да се нарича отделно. Когато се създаде нов потребителски модел, методът автоматично получава аргументите, посочени в скоби.

Използвайки методи за претоварване, можете да внедрите операции с вградени типове данни. Повечето се използват само при решаване на специални задачи, при които е необходимо обектите да имитират поведението на стандартни обекти.

Методите се наслеждават от суперкласи и не са задължителни. В началните етапи лесно можете да правите без тях. Но за пълно потапяне в програмирането и същността на OOP, трябва да работите с операторите.

__getitem__ метод

Методът __getitem__ изпълнява претоварване на елементите на индекса. Ако е наследена или присъства в дефиницията на класа, преводачът ще я нарече автоматично за всяка операция по индексиране. Например, когато един екземпляр от F се появява в израза за извличане на елемент в индекс като F [i], интерпретаторът на Python извиква метода __getitem__, предава обекта F в първия аргумент и индексът, посочен в квадратни скоби, във втория.

Следващият клас "Индекс на индексиране" връща квадрата на стойността на индекса:

• > class SampleIndexation:
• def __getitem __ (самостоятелно, индекс):
• индекс на връщане ** 2
• > F = Пример за индексиране ()
• > F [2] # Изразът F [i] извиква F .__ getitem __ (i)
• 4
• > за i в обхвата (5):
• отпечатване (F [i], end = "") # Покани __getitem __ (F, i) във всяка итерация
• 0 1 4 9 16

Със същия метод можете да извършите операция за извличане на срезове, която често се прибягва към работа с последователности. Когато се обработват списъци, стандартният синтаксис за операцията е както следва:

• > Списък = [13, 6, «и», «с», 74,9]
• > Списък [2: 4]
• ["И", "c"]
• > Списък [1:]
• [6, "и", "с", 74.9]
• > Списък [: - 1]
• [13, 6, "и", "c"]
• > Списък [:: 2]
• [13, "и", 74.9]

Клас, който изпълнява метода __getitem__:

• > индекс на класа:
• my_list = [13, 6, «и», «с», 74,9]
• def __getitem __ (самостоятелно, индекс): # Избрано при индексиране или извличане на парче
• отпечатване ("getitem:", индекс)
• return self.my list [index] # Извършва индексиране или извлича парче
• > X = Indexer ()
• > X [0] # Когато индексираме, __getitem__ получава цяло число
• гетит: 0
• 13
• > X [2: 4] # Когато изваждате парче, __getitem__ получава обект от разрез
• гетит: парче (2, 4, няма)
• ["И", "c"]

Атрибутът има достъп

За да препратите към даден атрибут, използвайте специалния метод __getattr__. Тя се нарича с името на атрибута под формата на низ в случаите на откриване на опит за получаване на препратка към несъществуващ или неопределен атрибут. Когато преводачът може да намери желания обект в дървовидното наследство, __getattr __. Не се извиква.

Методът е удобен за обобщена обработка на заявки към атрибути:

• > клас изчезнал:
• def __getattr __ (самостоятелно, име):
• ако atname == "възраст":
• връщане 20
• друго:
• повишаване на AttributeError, atname
• > D = Изчезна ()
• > D.ageage
• 20
• > D.name
• AttributeError: име

Класът Gone и инстанцията му D нямат свои атрибути. Следователно при достъпа до D.age автоматично се извиква методът __getattr__. Самата инстанция се предава като самостоятелно, но името на неопределената "възраст" в низа на atname. Класът връща резултата от достъп до името на D.age въпреки факта, че няма този атрибут.

Ако класът не предвижда обработка на атрибута, методът __getattr__ извиква вградено изключение и по този начин предава на преводача информация, че името всъщност е неопределено. В този случай опитването за достъп до името D.name води до грешка.

Методът за претоварване на оператора __setattr__ работи по подобен начин, като прихваща всеки опит за задаване на стойност на атрибут. Ако този метод е регистриран в тялото на класа, изразът "self.attribute = стойност" ще бъде преобразуван в извикване на метода self .__ setattr _ ("attribute", value).

Описахме само няколко от съществуващите методи за претоварване. Целият списък е в стандартното езиково ръководство и включва много повече имена.

Допълнителни функции

ОПП понякога се използва за сложни и нестандартни задачи. Като наследява класове в Python, поведението на вградените типове данни и техните възможности се поддава на разширяване и адаптиране.

Ако не сте доволни от факта, че индексирането в последователност започва от нулата, можете да го коригирате с помощта на израза на класа. За целта създайте подклас от тип списък с нови имена от всички типове и изпълнете необходимите промени. Също така в OOP в Python има функционални декоратори, статични методи и много други сложни и специални техники.