Programarea orientată pe obiecte în Python: clase, descriere și caracteristici

În Python, clasele sunt un concept fundamental. Aceasta este baza bibliotecii standard, a celor mai populare programe și a limbii în sine. Dacă doriți să deveniți mai mult decât un programator începător, trebuie să înțelegeți esența și principiul de lucru cu clasele și obiectele.

Ce sunt clasele

Aceasta este componenta software de bază a OOP. În Python, clasele sunt folosite pentru a implementa noi tipuri de obiecte și sunt create folosind o instrucțiune de clasă specială. În exterior, ele seamănă cu tipuri standard de date încorporate, cum ar fi numere sau secvențe. Dar obiectele de clasă au o diferență semnificativă - sprijin pentru moștenire.

Programarea orientată pe obiecte în Python se bazează pe moștenirea ierarhică a clasei. Acesta este un mod universal de adaptare și reutilizare a codului. Dar abordarea orientată spre obiect nu este obligatorie. Python permite programarea procedurala si functionala fara probleme.

Sarcina principală a claselor în Python este ambalarea datelor și a codului executabil. Ele sunt sintactic la fel ca instrucțiunile def. Ca și funcții, își creează propriile namespaces, care pot fi numite în mod repetat din orice parte a programului. Atunci de ce sunt necesare? Clasele sunt un instrument mai puternic și mai versatil. Mai presus de toate, potențialul lor este dezvăluit când se creează noi obiecte.

Importanța clasei și a principiului moștenirii

Fiecare obiect nou are propriul spațiu de nume, pe care îl puteți programa, introduce variabile și crea funcții. Și, de asemenea, există atribute moștenite din clasă: object.attribute. Acesta este sensul OOP.

Datorită moștenirii, este creat un arbore ierarhic. În practică, arată așa. În cazul în care interpretul întâlnește object.attribute de expresie, el începe să caute pentru prima apariție a atributului specificat în clasă. Nu se poate găsi atributul, interpretul continuă să caute informații în toate clasele conexe sunt în arborele de mai sus, de la stânga la dreapta.

Arborele de căutare include:

• Superclase care se află chiar în partea de sus a ierarhiei și pun în aplicare un comportament comun;
• subclasele - sunt sub;
• instanțele sunt elemente de program cu comportament moștenit.

Figura arată arborele de clase Python. Din exemplul respectiv vedem că clasele 2 și 3 sunt superclase. În partea de jos există două copii ale instanță 1 și 2, în mijloc - o subclasă de clasa 1. Dacă scrieți o expresie Instance2.w, aceasta va determina interpretul sa arate valoare de atribut .w în următoarea ordine:

1. instance2;
2. Class1;
3. class2;
4. Class3.

Numele .w se va găsi în clasa 3 superclase. În terminologia OOP, aceasta înseamnă că instanța 2 "moștenește" atributul .w din Class3.

Rețineți că instanțele din imagine moștenesc doar patru atribute: .w, .x, .y și .z:

• De exemplu, atributul Instance1.x și Instance2.x .x se găsește în clasa 1, în cazul în care căutarea se va opri, deoarece clasa 1 este în copac mai mic decât clasa 2.
• Pentru atributul Instance1.y și Instance2.y .y se găsește în clasa 1, în cazul în care căutarea se va opri, pentru că este singurul loc unde apare.
• De exemplu, Instance1.z și Instance2.z interpret va .Z din clasa 2, pentru că se află în partea stângă a arborelui decât Class3.
• Pentru instanța2.name, atributul .name va fi găsit în instanța2 fără a căuta copacul.

Punctul penultim este cel mai important. Aceasta demonstrează modul în care clasa 1 suprascrie atributul .x, înlocuind versiunea .x a superclasei de clasa 2.

Obiecte, instanțe și metode

OOP funcționează cu două concepte principale: clase și obiecte. Clasele creează noi tipuri, iar obiectele de clasă din Python sunt instanțele lor. De exemplu, toate variabilele întregi se referă la tipul de date încorporat int. În limbajul OOP, ele sunt instanțe ale clasei int.

Clasele sunt create prin instrucțiuni, iar obiectele sunt create folosind apeluri. Ei pot stoca date și au propriile lor funcționalități sau metode de clasă. În Python, terminologia joacă un rol important. Cu ajutorul său, programatorii disting funcțiile independente de cele care aparțin claselor. Variabilele legate de obiecte sunt numite câmpuri.

Există două tipuri de câmpuri în OOP. Prima este variabilele care aparțin întregii clase, a doua sunt variabilele instanțelor individuale. Câmpurile și metodele împreună sunt atribute ale unei clase. În Python, acestea sunt scrise în blocul de cod după clasa de cuvinte cheie.

Metodele și semnificația propriei persoane

Metodele sunt funcții cu numele de nume suplimentar. Acesta este adăugat la partea de sus a listei parametrilor. Dacă se dorește, variabila poate fi numită alt nume, însă o astfel de inițiativă între programatori nu este binevenită. Sinele este un nume standard, ușor de recunoscut în cod. Mai mult, anumite medii de dezvoltare sunt concepute pentru a lucra cu ele.

Pentru a înțelege mai bine valoarea de sine în OOP, imaginați-vă că avem o clasă numită ClassA și methodA:

• > clasa ClassA;
• metoda defA (sine, argument1, argument2).

Obiectul A este o instanță a ClassA și apelul metodei arată astfel:

• > objectA.methodA (argument1, argument2).

Atunci când interpretul vede această linie, ea îl convertește automat după cum urmează: ClassA.methodA (objectA, argument1, argument2). Adică, instanța clasei utilizează sinele variabil ca referință la sine.

Cum se creează variabile, metode și instanțe de clase

Oferim dezasamblarea unui exemplu practic din shell-ul interactiv Python. Crearea clasei "Experiment First" începe cu o clasă de clase compuse:

• > clasa Experimentul primul:
• def setinf (auto, valoare): # creați prima metodă cu argumente
• auto.data = valoare
• display def (auto): # a doua metodă
• print (auto.data) # tipăriți datele instanței.

După o indentare obligatorie, urmează un bloc cu instrucțiuni def imbricate, în care două obiecte de funcții sunt asociate cu numele și afișarea. Cu ajutorul lor, sunt create atributele Experiment First.setinf și Experiment First.display. De fapt, orice nume căruia îi este atribuită o valoare la nivelul superior din blocul imbricat devine un atribut.

Pentru a vedea cum funcționează metodele, trebuie să creați două instanțe:

• > x = Experiment First () # Sunt create două instanțe;
• > y = Primul experiment () # Fiecare este un spațiu de nume separat.

Inițial, instanțele nu stochează nicio informație și sunt complet goale. Dar ele sunt legate de clasa lor:

• > x.setinf ("Learning Python") # Apelarea unei metode în care auto este x.
• > y.setinf (3.14) # Echivalent: Experiment First.setinf (y, 3.14)

În cazul în care, după numele instanței x, y se referă la atributul .setinf obiect de clasă EksperimentPervy, rezultată interpretul moștenire de căutare copac returnează valoarea atributului de clasă.

• > x.display () # x și y au propriile valori ale auto-datei
• Aflați Python
• > y.display ()
• 3.14.

Supraîncărcarea operatorului

În Python, clasele pot supraîncărca declarațiile de expresie. Această capacitate face instanțele similare cu tipurile de date încorporate. Procesul constă în implementarea metodelor cu nume speciale care încep și se termină cu dublu subliniere.

Luați în considerare în acțiune __init__ și __sub__. Prima metodă se numește constructor de clasă. În Python, __init__ efectuează o supraîncărcare a operației de creare a instanței. A doua metodă __sub__ implementează operația de scădere.

• > suprasarcină de clasă: # creează o nouă clasă
• def __init __ (auto, începe):
• auto.data = start
• def __sub __ (auto, altul): # instanță minus altele
• return Overload (auto.data - other) # Rezultatul este un nou exemplu
• > A = suprasarcină (10) #__ init __ (A, 10)
• > B = A - 2 #__ sub __ (B, 2)
• > B.data # B este o nouă instanță a clasei de suprasarcină
• 8.

Mai multe despre metoda __init__

Metoda __init__ este cea mai des utilizată atunci când lucrați cu clase. Este indispensabil pentru inițializarea diferitelor obiecte. __init__ nu trebuie să fie chemat separat. Atunci când se creează o nouă instanță, metoda primește automat argumentele specificate în paranteze.

Folosind metode de suprasarcină, puteți implementa orice operațiuni cu tipuri de date încorporate. Cele mai multe sunt folosite numai atunci când se rezolvă sarcini speciale în care este necesar ca obiectele să imite comportamentul obiectelor standard.

Metodele sunt moștenite din superclase și nu sunt obligatorii. În stadiile inițiale, puteți face cu ușurință fără ele. Dar pentru o imersiune completă în programare și esența OOP, trebuie să lucrați cu operatorii.

__getitem__

Metoda __getitem__ efectuează o suprasarcină a accesului elementului pe index. Dacă este moștenită sau prezentă în definiția clasei, interpretul o va numi automat pentru fiecare operație de indexare. De exemplu, atunci când o instanță de F apare într-o expresie a unui element de recuperare a unui index, cum ar fi F [i], interpretul Python apelează metoda __getitem__, trece obiectul F în primul argument și indexul specificat în paranteze pătrate, în al doilea.

Următoarea clasă "Indice de indexare" returnează pătratul valorii indexului:

• > clasa SampleIndexation:
• def __getitem __ (auto, index):
• indice de returnare ** 2
• > F = Exemplu de indexare ()
• > F [2] # Expresia F [i] solicită F .__ getitem __ (i)
• 4
• > pentru i în raza de acțiune (5):
• print (end F [i], = «») # Apeluri __getitem __ (F, i) în fiecare iterație
• 0 1 4 9 16

Cu aceeași metodă, puteți efectua o operațiune de extracție a feliei, care este adesea recursată la lucrul cu secvențe. Când se procesează liste, sintaxa standard pentru operație este următoarea:

• > List = [13, 6, «și», «cu», 74,9]
• > Lista [2: 4]
• ["Și", "c"]
• > Lista [1:]
• [6, "și", "c", 74,9]
• > Lista [: - 1]
• [13, 6, "și", "c"]
• > Lista [:: 2]
• [13, "și", 74,9]

O clasă care implementează metoda __getitem__:

• > indexer de clasă:
• my_list = [13, 6, «și», «cu», 74,9]
• def __getitem __ (auto, index): # Chemată la indexarea sau extragerea unei felii
• print ("getitem:", index)
• return self.my list [index] # Efectuează indexarea sau extrage o felie
• > X = Indexer ()
• > X [0] # Când se indexează, __getitem__ primește un număr întreg
• getitem: 0
• 13
• > X [2: 4] # Atunci când extrageți o felie, __getitem__ primește un obiect slice
• getitem: felie (2, 4, fără)
• ["Și", "c"]

Atributele accesează

Pentru a obține o referință la un atribut, utilizați metoda specială __getattr__. Se numește cu numele atributului sub forma unui șir în cazul detectării unei încercări de a obține o referință la un atribut inexistent sau nedefinit. Când interpretul poate găsi obiectul dorit în arborele moștenirii, __getattr __. Nu este apelat.

Metoda este convenabilă pentru procesarea generalizată a cererilor de atribute:

• > Clasa Gone:
• def __getattr __ (sine, atame):
• dacă atname == "vârstă":
• retur 20
• altceva:
• ridicați AttributeError, atname
• > D = Gone ()
• > D.age
• 20
• > D nume
• AttributeError: nume

Clasa Gone și instanța lui D nu au atribute proprii. Prin urmare, atunci când accesați D.age, metoda __getattr__ este apelată automat. Instanța însăși este transmisă ca sine, dar numele "erei" nedefinite în șirul atname. Clasa returnează rezultatul accesării numelui D.age, în ciuda faptului că nu are acest atribut.

Dacă clasa nu prevede manipularea atributului, metoda __getattr__ numește o excepție încorporată și, prin urmare, transmite informații interpretului că numele este de fapt nedefinit. În acest caz, încercarea de a accesa numele D. nume duce la o eroare.

Metoda de supraîncărcare a operatorului __setattr__ funcționează într-un mod similar, interceptând fiecare încercare de a atribui o valoare de atribut. Dacă această metodă este înregistrată în corpul clasei, expresia "self.attribute = value" va fi convertită la un apel la metoda self .__ setattr _ ("attribute", value).

Am descris doar câteva dintre metodele existente de supraîncărcare. Întreaga listă este în ghidul de limbă standard și include mai multe nume.

Caracteristici suplimentare

OOP este uneori folosit pentru sarcini complexe și non-standard. Prin moștenirea claselor în Python, comportamentul tipurilor de date încorporate și capabilitățile acestora este susceptibil de expansiune și adaptare.

Dacă nu sunteți mulțumit de faptul că indexarea în secvențe pornește de la zero, o puteți remedia folosind instrucțiunea de clasă. Pentru a face acest lucru, creați o subclasă de listă de tip cu nume noi de toate tipurile și implementați modificările necesare. De asemenea, în PLO în Python există decoratori de funcții, metode statice și multe alte tehnici complexe și speciale.