Conceptele OOP în Python

Ca ș i celelalte limbaje de programare de uz general, Python este de asemenea un limbaj orientat pe obiect încă de la începuturile sale.
Ne permite să dezvoltăm aplicaț ii folosind o abordare orientată pe [Link], putem crea ș i utiliza cu uș urinț ă
clase ș i obiecte.

Un paradigme orientate pe obiect este de a proiecta programul folosind clase ș i obiecte. Obiectul este legat de lumea reală.
entităț i precum carte, casă, stilou, etc. Conceptul OOP se concentrează pe scrierea codului reutilizabil. Este un concept răspândit
tehnică de a rezolva problema prin crearea de obiecte.

Principiile majore ale sistemului de programare orientată pe obiect sunt prezentate mai jos.

o Clasă
o Obiect
o Metodă
o Moș tenire
o Polimorfism
o Abstracț ia datelor
o Încapsulare

Clasă
Clasa poate fi definită ca o colecț ie de obiecte. Este o entitate logică care are anumite atribute ș i metode specifice.
De exemplu: dacă ai o clasă de angajat, atunci ar trebui să conț ină o atribut ș i o metodă, adică un e-mail, nume,
vârstă

Sintaxă

classClassName
statement-1
.
.
<declaraț ie-N

Obiect
Obiectul este o entitate care are stare ș i comportament. Poate fi orice obiect din lumea reală, cum ar fi mouse-ul, tastatura, scaunul,
masă, stilou, etc.

Totul în Python este un obiect, iar aproape totul are atribute ș i metode. Toate funcț iile au o funcț ie încorporată
atributul __doc__, care returnează docstring-ul definit în codul sursă al funcț iei.

Când definim o clasă, aceasta trebuie să creeze un obiect pentru a aloca memoria. Ia în considerare următorul exemplu.

Exemplu:
clasă auto
def __init__(self, modelname, year):
[Link] = modelname
[Link] = anul
defdisplay(self):
print([Link],[Link])

maș ină("Toyota", 2016)

[Link]()

În exemplul de mai sus, am creat clasa numită maș ină, care are două atribute: numele modelului ș i anul.
a creat un obiect c1 pentru a accesa atributul clasei. Obiectul c1 va aloca memorie pentru aceste valori. Vom învăț a
mai multe despre clasă ș i obiect în următorul tutorial.

Metodă
Metoda este o funcț ie care este asociată cu un obiect. În Python, o metodă nu este unică pentru instanț ele de clasă. Orice
Tipul de obiect poate avea metode.

Moștenire
Moș tenirea este cel mai important aspect al programării orientate pe obiect, care simulează conceptul din lumea reală de
moș tenire. Aceasta specifică faptul că obiectul copil dobândeș te toate proprietăț ile ș i comportamentele obiectului părinte.

Prin utilizarea moș tenirii, putem crea o clasă care foloseș te toate proprietăț ile ș i comportamentul unei alte clase. Noua clasă
este cunoscut ca o clasă derivată sau clasă copil, iar cea ale cărei proprietăț i sunt dobândite este cunoscută ca o clasă de bază sau
clasa părinte.

Oferă reutilizarea codului.

Polimorfism
Polimorfismul con ț ine două cuvinte "poly" ș i "morphs". Poly înseamnă multe, iar morph înseamnă formă. Prin
prin polimorfism, înț elegem că o sarcină poate fi efectuată în moduri diferite. De exemplu - ai o clasă
animal, iar toate animalele vorbesc. Dar ele vorbesc diferit. Aici, comportamentul de 'a vorbi' este polymorfic într-un sens ș i
depinde de animal. Aș adar, conceptul abstract de "animal" nu "vorbeș te" de fapt, dar animalele specifice (cum ar fi câinii
ș i pisicile) au o implementare concretă a acț iunii "vorbeș te".

Încapsulare
Încapsularea este de asemenea un aspect esenț ial al programării orientate pe obiecte. Este folosită pentru a restricț iona accesul la metode ș i
variabile. În încapsulare, codul ș i datele sunt împachetate împreună într-o unitate unică pentru a fi protejate de modificări accidentale.
Abstracția datelor
Abstrac ț ia datelor ș i încapsularea sunt adesea folosite ca sinonime. Ambele sunt aproape sinonime deoarece datele
abstracț ia este realizată prin încapsulare.

Abstracț ia este folosită pentru a ascunde detaliile interne ș i a arăta doar funcț ionalităț ile. A abstraha ceva înseamnă a da nume.
pentru lucruri astfel încât numele să surprindă esenț a a ceea ce face o funcț ie sau un întreg program.

Limbaje de programare orientate pe obiecte vs. limbaje de programare orientate pe proceduri

Diferenț a dintre programarea orientată pe obiecte ș i programarea orientată pe proceduri este dată mai jos:

Index Programare orientată pe obiect Programare Procedurală

1. Programarea orientată pe obiect este problema - Programarea procedurală foloseș te o listă de

abordare de rezolvare ș i utilizate unde instrucț iunile de calcul pentru a efectua calculul pas cu pas.
se face folosind obiecte.

2. Face dezvoltarea ș i între ț inerea în programarea procedurală, nu este u ș or să

mai uș or. men ț ine codurile atunci când proiectul
devine lung.

3. Simulează entitatea din lumea reală. Aș a că lumea reală nu simulează lumea reală. Funcț ionează pe
problems can be easily solved through oops. instrucț iuni pas cu pas împărț ite în mici
părț i numite funcț ii.

4. Oferă ascunderea datelor. Deci, este mai sigur. Limbajul procedural nu oferă asta.
decât limbajele procedurale. Nu poț i accesa o modalitate corespunzătoare pentru legarea datelor, aș a că este mai puț in

date private din orice loc. securizat.

5. Exemplu de programare orientată pe obiecte Exemple de limbaje procedurale sunt: C,

limbajele sunt C++, Java, .Net, Python, C#, etc. Fortran, Pascal, VB etc.

Clasa și Obiecte în Python

Am discutat deja în tutorialul precedent, o clasă este o entitate virtuală ș i poate fi văzută ca un plan al unui obiect.
Clasa a intrat în existenț ă atunci când a fost instanț iată. Să înț elegem acest lucru printr-un exemplu.

Presupune ț i că o clasă este un prototip al unei clădiri. O clădire con ț ine toate detaliile despre etaj, camere, u ș i,
feronier, etc. putem construi câte clădiri dorim, bazându-ne pe aceste detalii. Prin urmare, clădirea poate fi văzută ca
o clasă, ș i putem crea atâtea obiecte ale acestei clase.

Pe de altă parte, obiectul este instanț a unei clase. Procesul de creare a unui obiect poate fi numit instanț iere.

În această secț iune a tutorialului, vom discuta despre crearea de clase ș i obiecte în Python. De asemenea, vom discuta despre modul în care o clasă
atributul este accesat prin utilizarea obiectului.
 Crearea claselor în Python
În Python, o clasă poate fi creată folosind cuvântul cheie class, urmat de numele clasei. Sintaxa pentru a crea o clasă
este dat mai jos.

Sintaxă

1. classClassName
2. #declaraț ie_suită

În Python, trebuie să observăm că fiecare clasă este asociată cu un ș ir de documentaț ie care poate fi accesat prin
utilizând <numele-clasei>.__doc__.O clasă conț ine un set de declaraț ii care include câmpuri, constructor, funcț ie, etc. definiț ie.

Consideraț i următorul exemplu pentru a crea o clasă Angajat care conț ine două câmpuri: ID-ul angajatului ș i numele.

Clasa conț ine de asemenea o funcț ie display(), care este utilizată pentru a afisa informaț iile angajatului.

1. clasăAngajat
2. id = 10
3. Devansh
4. def afisare (self):
5. print([Link],[Link])

Aici, self este folosit ca o variabilă de referinț ă, care se referă la obiectul actual al clasei. Este întotdeauna primul argument în
definirea funcț iei. Cu toate acestea, utilizarea self este opț ională în apelul funcț iei.

Autoparametrul

Auto-parametrul se referă la instanț a curentă a clasei ș i accesează variabilele clasei. Putem folosi orice.
în loc de self, dar trebuie să fie primul parametru al oricărei funcț ii care aparț ine clasei.

Crearea unei instanțe a clasei

O clasă trebuie să fie instanț iată dacă dorim să folosim atributele clasei într-o altă clasă sau metodă. O clasă poate fi
instanț iat prin apelarea clasei folosind numele clasei.

Sintaxa pentru a crea o instanț ă a clasei este dată mai jos.

1. <nume-obiect> = <nume-clasă>(<argumente>)

Următorul exemplu creează o instanț ă a clasei Employee definită în exemplul de mai sus.

Exemplu
clasăAngajat
id = 10
John
defdisplay (self):
print("ID: %d \nNume: %s"%([Link],[Link]))
# Crearea unei instanț e emp a clasei Employee
emp = Angajat()
[Link]()

În codul de mai sus, am creat clasa Employee care are două atribute numite id ș i name ș i le-am atribuit
valoare pentru ei. Putem observa că am trecut self ca parametru în funcț ia de afiș are. Este folosit pentru a se referi la
atribut de clasă similar.

Am creat un nou obiect de instanț ă numit emp. Folosindu-l, putem accesa atributele clasei.

Șterge obiectul
Putem ș terge proprietăț ile obiectului sau obiectul în sine folosind cuvântul cheie del. Luaț i în considerare următorul exemplu.

clasaAngajat
id = 10
John

defdisplay(self):
ID: %d Nume: %s
# Crearea unei instanț e emp a clasei Employee

emp = Angajat()

Ș tergerea proprietăț ii obiectului

[Link]
Ș tergerea obiectului în sine
delemp
[Link]()

Va genera eroarea de atribut deoarece am ș ters obiectul emp.

Constructor Python
Un constructor este un tip special de metodă (funcț ie) care este folosit pentru a iniț ializa membrii de instanț ă ai clasei.

În C++ sau Java, constructorul are acelaș i nume ca ș i clasa sa, dar tratează constructorul diferit în Python. Este folosit
pentru a crea un obiect.
 Constructorii pot fi de două tipuri.

Constructor parametrizat
2. Constructor non-parameterizat

Definiț ia constructorului este executată atunci când creăm obiectul acestei clase. Constructorii verifică de asemenea că există
suficiente resurse pentru ca obiectul să îndeplinească orice sarcină de start-up.

Crearea constructorului în python

În Python, metoda __init__() simulează constructorul clasei. Această metodă este apelată atunci când clasa este
instanț iat. Acceptă cuvântul-cheie self ca primul argument, ceea ce permite accesarea atributelor sau metodelor.
clasă.

Putem pasa orice număr de argumente în momentul creării obiectului clasei, în func ț ie de
definiț ia __init__(). Este folosită în principal pentru a iniț ializa atributele clasei. Fiecare clasă trebuie să aibă un constructor, chiar dacă
se bazează pur ș i simplu pe constructorul implicit.

Luaț i în considerare următorul exemplu pentru a iniț ializa atributele clasei Employee.

Exemplu

clasaAngajat
def__init__(self, name, id):
[Link] = id
[Link] = nume

defdisplay(self):
print("ID: %d Nume: %s" % ([Link], [Link]))

Angajat("John", 101)
Angajat("David", 102)

accesând metoda display() pentru a imprima informaț iile angajatului 1

[Link]()

accesând metoda display() pentru a imprima informaț iile angajatului 2

[Link]()

Numărarea numărului de obiecte ale unei clase

Constructorul este apelat automat atunci când creăm obiectul clasei. Întrebaț i următorul exemplu.
 Exemplu
classStudent
count = 0
def__init__(self):
[Link] = [Link] + 1
Student()
s2=Student()
Student()
print("Numărul de studenț i:", [Link])

Constructor non-parametrizat Python

Constructorul non-parametrizat se foloseș te atunci când nu dorim să manipulăm valoarea sau constructorul care are
doar self ca argument. Consideraț i următorul exemplu.

Exemplu

elevDeClasă
Constructor - non parametrizat
def__init__(self):
Acesta este un constructor non-parametrizat
defshow(self,nume):
print("Bună", nume)
student = Student()
[Link]ăta("John")

Constructor parametrizat Python

Constructorul parametrizat are mai mulț i parametri împreună cu self. Consideraț i următorul exemplu.

Exemplu

clasaStudent
Constructor - parametrizat
def__init__(self, nume):
print("Acesta este un constructor parametrizat")
[Link]
defshow(self):
print("Bună", [Link])
Studentul("John")
[Link]ă()

Constructorul implicit Python

Când nu includem constructorul în clasă sau uităm să-l declarăm, atunci acesta devine constructorul implicit.
Nu îndeplineș te nicio sarcină, ci initializează obiectele. Consideraț i următorul exemplu.

Exemplu
elevDeClasă
roll_num = 101
Iosif

defdisplay(self):
print(self.roll_num,[Link])

st = Student()
[Link]()

Mai mult de un constructor într-o singură clasă

Exemplu de doi constructori identici în clasă.

Exemplu

clasăStudenț i
def__init__(self):
Primul Constructor
def__init__(self):
print("Al doilea constructor")

st = Student()

În codul de mai sus, obiectele au apelat al doilea constructor, în timp ce ambele au aceeaș i configuraț ie. Primul
metoda nu este accesibilă de către obiectul thest. Intern, obiectul clasei va apela întotdeauna ultimul constructor dacă
clasa are mai mulț i constructori.

Notă: Supraincarcarea constructorului nu este permisă în python

 Funcții de clasă încorporate în Python

Funcț iile încorporate definite în clasă sunt descrise în următorul tabel.

SN Functon Descriere

1 getattr(obj,nume,default) Este folosit pentru a accesa atributul obiectului.

2 setattr(obj, nume, valoare) Este folosit pentru a seta o valoare particulară unui atribut specific al unui obiect.

3 delattr(obj, nume) Este folosit pentru a ș terge o atribut specific.

4 areattr(obj, nume) Returnează adevărat dacă obiectul conț ine o anumită caracteristică.

clasaStudent
def__init__(self, nume, id, varsta):
[Link]
[Link] = id
[Link]

# creează obiectul clasei Student

s = Student("John", 101, 22)

afiș ează numele atributului obiectului s

print(getattr(s, 'name'))

resetează valoarea atributului vârstă la 23

setattr(s,"vârstă", 23)

# afiș ează valoarea modificată a vârstei

print(getattr(s,'vârstă'))

# afiș ează adevărat dacă studentul conț ine atributul cu numele id

print(hasattr(s,'id'))
# deletes the attribute age
delattr(s,'age')

# acest lucru va provoca o eroare deoarece atributul vârstă a fost ș ters

print([Link])
 Atributele de clasă încorporate

Împreună cu celelalte atribute, o clasă Python conț ine, de asemenea, unele atribute de clasă încorporate care oferă informaț ii
despre clasă.

Atributele de clasă încorporate sunt prezentate în tabela de mai jos.

SN Atribute Descriere

1 __dict__ Oferă dicț ionarul care conț ine informaț ii despre spaț iul de nume al clasei.

2 __doc__ Conț ine un ș ir care are documentaț ia clasei

3 __name__ Este folosit pentru a accesa numele clasei.

4 Este folosit pentru a accesa modulul în care este definită această clasă.

5 __baze__ Conț ine un tuplu care include toate clasele de bază.

student de clasă
def__init__(self,nume,id,varsta):
[Link] = nume;
[Link] = id;
[Link]
defafisare_detalii(self):
print("Nume:%s, ID:%d, vârstă:%d"%([Link],[Link]))
Student("John", 101, 22)
print(s.__doc__)
print(s.__dict__)
print(s.__module__)

Moștenirea în Python
Mo ș tenirea este un aspect important al paradigmei orientate pe obiect. Mo ș tenirea oferă reutilizarea codului pentru
program deoarece putem folosi o clasă existentă pentru a crea o clasă nouă în loc să o creăm de la zero.

În moș tenire, clasa copilă dobândeș te proprietăț ile ș i poate accesa toț i membrii de date ș i funcț iile definite în
clasa părinte. O clasă copil poate, de asemenea, să ofere propria sa implementare specifică funcț iilor clasei părinte. În acest
în această secț iune a tutorialului, vom discuta despre moș tenire în detaliu.
 În python, o clasă derivată poate moș teni o clasă de bază doar menț ionând baza în paranteză după clasa derivată
nume. Consideraț i următoarea sintaxă pentru a moș teni o clasă de bază în clasa derivată.

Sintaxă

clasa derivată-clasă(baza)

1. <clasă-suită>

O clasă poate moș teni mai multe clase menț ionându-le pe toate în interiorul parantezelor. Consideraț i următoarea sintaxă.

Sintaxă

1. classderiva-clasă(<clasădebază1>, <clasădebază2>, ..... <clasădebazăn>):

2. <clasa-suită>

Exemplul 1

clasaAnimal

defvorbi(self):
tipăreș te("Animal Vorbitor")
#clasa copil Câine moș teneș te clasa de bază Animal
clasaCâine(Animal):
defbark(self):
câinele latră
d = Câine()
 [Link]()
[Link]()

Moștenire în mai multe niveluri Python

Moș tenirea pe mai multe niveluri este posibilă în Python, la fel ca în alte limbaje de programare orientate pe obiect. Moș tenirea pe mai multe niveluri este realizată

când o clasă derivată moș teneș te o altă clasă derivată. Nu există nicio limită asupra numărului de niveluri până la care, multi-
moș tenirea de nivel este arhivată în python.

Sintaxa moș tenirii multi-nivel este dată mai jos.

Sintaxă

clasăclasa1:
<clasă-suită>
clasa clasa2 (clasa1):
<clasăSuită>
classclass3(class2):
<clasaSuită>
.

Exemplu

clasaAnimal

defvorbire(self):
print("Animal Vorbind")
Clasa copil Dog moș teneș te clasa de bază Animal
clasaCâine(Animal):
defbark(self):
câinele latră
Clasa copil Dogchild moș teneș te o altă clasă copil Dog
clasa CâineCopil(Câine):
înfrângere(self):
Mâncând pâine...
d = CâineCopil()
[Link]()
[Link]()
[Link]()

Moștenirea multiplă în Python

Python ne oferă flexibilitatea de a moș teni mai multe clase de bază în clasa copil.
 Sintaxa pentru a efectua moș tenire multiplă este prezentată mai jos.

Sintaxă

classBase1
<clasa-suită>

clasaBaza2:
<clasă-suită>
.
.
.
classBaseN
<clasa-suită>

clasaDerivata(Base1, Base2, ...... BaseN):

<clasa-suita>

Exemplu

classCalculation1
defSuma(self,a,b):
returna+b;
clasăCalculare2:
defÎnmulț ire(self,a,b):
returna*b;
clasaDerivata(Calcul1, Calcul2):
def Împarte(self, a, b):
returna/b;
d = Derivat()
print([Link](10,20))
print([Link](10,20))
print([Link](10,20))

Metoda issubclass(sub,sup)

Metoda issubclass(sub, sup) este folosită pentru a verifica relaț iile dintre clasele specificate. Returnează adevărat dacă
prima clasă este subclasă a celei de-a doua clase, ș i fals în alt caz.

Consideraț i următorul exemplu.

 Exemplu

clasaCalcul1:
defSummare(self,a,b):
returna+b;
calculClasă2:
defMultiplicare(self,a,b):
returna*b;
classDerived(Calculation1, Calculation2):
defÎmparte(self,a,b):
returnează/b;
d = Derivat()
print(este_subclasă(Derived, Calculation2))
print(issubclass(Calculation1,Calculation2))

Metoda isinstance (obj, class)

Metoda isinstance() este utilizată pentru a verifica relaț ia dintre obiecte ș i clase. Aceasta returnează adevărat dacă primul
parametrul, adică, obj este instanț a celui de-al doilea parametru, adică, clasă.

Luaț i în considerare următorul exemplu.

Exemplu
1.
clasaCalcul1:
defSumeaza(self,a,b):
returnează a+b;

classCalculare2:
defInmultire(self,a,b):
returna*b;
clasaDerivata(Calcul1, Calcul2):
def Împărț i(self, a, b):
returna/b;
d = Derivat()
print(isinstance(d,Derived))

Suprascrierea metodei

Putem oferi o implementare specifică a metodei din clasa părinte în clasa noastră copil. Când clasa părinte
metoda este definită în clasa copil cu o implementare specifică, atunci conceptul se numeș te suprascrierea metodei.
Este posibil să fie nevoie să efectuam suprascrierea metodei în scenariul în care există o definiț ie diferită a unei metode din clasa părinte.
necesar în clasa copil.
 Luaț i în considerare următorul exemplu pentru a efectua suprascrierea metodei în python.

Exemplu
1.
clasăAnimal
defspeak(self):
vorbind
clasăCâine(Animal):
defspeak(self):
Lătrând
d = Câine()
[Link]()

Exemplu din viața reală de suprascriere a metodei

clasaBancă

defgetroi(self):
return10;
clasa SBI(Banc):
defgetroi(self):
return7;

classICICI(Banc):
defgetroi(self):
return8;
Bancă()
SBI()
ICICI()
Rata dobânzii bancare:
print("Rata dobânzii SBI:",[Link]());
print("Rata dobânzii ICICI:", [Link]());

Abstracția datelor în Python

Abstracț ia este un aspect important al programării orientate pe obiect. În Python, putem efectua ș i ascunderea datelor prin
adăugând sublinierea dublă (___) ca prefix pentru atributul care urmează să fie ascuns. După aceasta, atributul nu va mai
fii vizibil în afara clasei prin obiect.

Consideraț i următorul exemplu.

Exemplu

clasaAngajat

__count = 0;
def__init__(self):
Employee.__count = Employee.__count + 1
defdisplay(self):
print("Numărul de angajaț i", Employee.__count)
emp = Angajat()
Angajat()
încercă:
print(emp.__count)
în sfârș it
[Link]()

Abstracție în Python
Abstracț ia este folosită pentru a ascunde funcț ionalitatea internă a funcț iei de utilizatori. Utilizatorii
interacț ionează doar cu implementarea de bază a funcț iei, dar funcț ionarea internă este ascunsă. Utilizatorul este
familiar cu asta "ce funcț ie are" dar nu ș tiu "cum o face."

În cuvinte simple, cu toț ii folosim smartphone-ul ș i suntem foarte familiarizaț i cu funcț iile sale, cum ar fi
cameră, înregistrator vocal, apelare, etc., dar nu ș tim cum se desfăș oară aceste operaț iuni
în fundal. Să luăm un alt exemplu - Când folosim telecomanda televizorului pentru a creș te
volum. Nu ș tim cum apăsarea unei taste creș te volumul televizorului. Ș tim doar să
apasa butonul '+' pentru a creste volumul.

Aceasta este exact abstracț ia care funcț ionează înconcept orientat pe obiecte.

De ce este importantă abstractizarea?

În Python, o abstractizare este folosită pentru a ascunde datele/clasele irelevante pentru a reduce complexitatea. De asemenea, îmbunătăț eș te
eficienț a aplicaț iei. Apoi, vom învăț a cum putem atinge abstractizarea folosindprogram Python.

Clase de abstractizare în Python

ÎnPythonAbstracț ia poate fi realizată prin utilizarea claselor abstracte ș i a interfeț elor.
 O clasă care constă dintr-o sau mai multe metode abstracte se numeș te clasă abstractă. Metodele abstracte nu conț in
implementarea lor. Clasa abstractă poate fi moș tenită de subclasă, iar metoda abstractă îș i primeș te definiț ia în
subclasă. Clasele de abstractizare sunt destinate să fie planul altor clase. O clasă abstractă poate fi utilă atunci când noi
proiecta ț i func ț ii mari. O clasă abstractă este, de asemenea, utilă pentru a oferi interfa ț a standard pentru diferite
implementările componentelor. Python oferă modulul abc pentru a utiliza abstractizarea în programul Python. Haideț i să
vedeț i următoarea sintaxă.

Importăm clasa ABC din theabcmodule.

Clase Abstracte de Bază

O clasă de bază abstractă este aplicaț ia comună a programului de interfaț ă pentru un set de subclase. Poate fi utilizată de
terț a parte, care va furniza implementările, cum ar fi cu pluginuri. De asemenea, este benefic atunci când lucrăm cu
codul mare este greu de reț inut toate clasele.

Funcționarea claselor abstracte

Spre deosebire de celelalte limbaje de programare de nivel înalt, Python nu oferă clasa abstractă în sine. Trebuie să importăm abc.
modul, care oferă baza pentru definirea claselor de bază abstracte (ABC). ABC funcț ionează prin decorarea metodelor de
clasa de bază ca abstractă. Aceasta înregistrează clase concrete ca implementare a bazei abstracte. Folosim
decoratorul@abstractmethod pentru a defini o metodă abstractă sau dacă nu oferim definiț ia pentru metodă, ea
devine automat metoda abstractă. Să înț elegem următorul exemplu.

# Program Python demonstrează

#clasa de bază abstractă
de la abc import ABC, abstractmethod
clasăMaș ină(ABC):
def kilometraj(self):
trece

clasa Tesla(Masina):
def kilometraj(self):
Consum de carburant este de 30km/h
clasaSuzuki(Masina):
def kilometraj(self):
Consum de carburant este 25km/h
clasaDuster(Masina):
def kilometraj(self):
Consumului este de 24 km/h

clasăRenault(Maș ină):
def kilometraj(self):
Consum de combustibil este 27 km/h

# Codul şoferului
t= Tesla ()
[Link]()
r = Renault()
[Link]()

s = Suzuki()
[Link]()
d = Duster()
[Link]()

Explicaț ie -

În codul de mai sus, am importat modulul abc pentru a crea clasa de bază abstractă. Am creat clasa maș ină care...
am moș tenit clasa ABC ș i am definit o metodă abstractă numită mileage(). Apoi am moș tenit clasa de bază din
cele trei subclase diferite ș i am implementat metoda abstractă diferit. Am creat obiectele pentru a apela ...
metodă abstractă.

Să înț elegem un alt exemplu.

# Program Python pentru a defini

#clasă abstractă

de la abcimportABC

clasaPolygon(ABC):

#metodăabstractă
def laturi(self):
pasează

clasăTriunghi(Poligon):

def laturi(self):
Triunghiul are 3 laturi

clasaPentagon(Poligon):

def laturi(self):
Pentagonul are 5 laturi

clasăHexagon(Poligon):

def laturi(self):
Hexagonul are 6 laturi
clasa pătrat(Poligon):

def laturi(self):
Am 4 laturi

# Codul ș oferului
t = Triunghi()
[Link]()

s = pătrat()
[Link]()

p = Pentagon()
[Link]()

k = Hexagon()
[Link]()

Explicaț ie -

În codul de mai sus, am definit clasa de bază abstractă numită Polygon ș i, de asemenea, am definit metoda abstractă.
Această clasă de bază este mo ș tenită de diverse subclase. Am implementat metoda abstractă în fiecare subclasă. Noi
a creat obiectul subclaselor ș i a invocat metoda sides(). Implementările ascunse pentru
metoda thesides() din fiecare subclasă intră în joc. Metoda abstractă sides(), definită în
clasa abstractă, nu este niciodată invocată.

Puncte de reținut
Mai jos sunt punctele pe care ar trebui să le reț inem despre clasa de bază abstractă în Python.

o O clasă abstractă poate conț ine atât metode normale, cât ș i metode abstracte.

o O clasă abstractă nu poate fi instanț iată; nu putem crea obiecte pentru clasa abstractă.

Abstracț ia este esenț ială pentru a ascunde funcț ionalitatea de bază de utilizatori. Am acoperit toate conceptele de bază de
Abstracț ie în Python.

Module Python
Un modul Python poate fi definit ca un fiș ier de program Python care conț ine un cod Python, inclusiv funcț ii Python.
clasa sau variabile. Cu alte cuvinte, putem spune că fiș ierul nostru de cod Python salvat cu extensia (.py) este tratat ca
modul. Este posibil să avem un cod executabil în interiorul modulului python.

Modulele în Python ne oferă flexibilitatea de a organiza codul într-un mod logic.

 Pentru a folosi funcț ionalitatea unui modul în altul, trebuie să importăm modulul specific.

Exemplu

În acest exemplu, vom crea un modul numit [Link] care conț ine o funcț ie func ce conț ine un cod pentru a printa
un mesaj pe consola.

Să creăm modulul numit [Link].

1. #displayMsg afiș ează un mesaj pentru numele care este transmis.

2. defdisplayMsg(nume)
3. print("Salut " + nume);

Aici, trebuie să includem acest modul în modulul nostru principal pentru a apela metoda displayMsg() definită în modul.
fiș ier numit.

Declarația from-import
În loc să importăm întreaga bibliotecă în spaț iul de nume, Python oferă flexibilitatea de a importa doar elementul specific.
atributele unui modul. Acest lucru poate fi realizat folosind instruc ț iunea from? import. Sintaxa pentru a folosi from-import
declaraț ia este dată mai jos.

1. din< numele-module>importa< numele 1>, < numele 2>..,< numele n>

Consideraț i următorul modul numit calcul, care conț ine trei funcț ii: adunare, înmulț ire ș i
împărț iț i.

[Link]

#plasează codul în [Link]

defsumare(a,b):
returna+b
defmultiplicare(a,b):
returna*b;
defdivide(a,b):
returna/b;

[Link]
decalculimportsumare
va importa doar summation() din [Link]
a = int(input("Introduceti primul numar"))
b = int(input("Introduceti al doilea numar"))
print("Suma = ", summarea(a, b))#nu trebuie să specificăm numele modulului în timp ce accesăm summarea

Declaraț ia from...import este întotdeauna mai bine de utilizat dacă ș tim atributelor care trebuie importate din modul în
avans. Nu ne permite ca codul nostru să fie mai greoi. De asemenea, putem importa toate atributele dintr-un modul folosind *.

Consideraț i următoarea sintaxă.

1. din<modul>import*

Renunțarea la un modul

Python ne oferă flexibilitatea de a importa un anumit modul cu un nume specific, astfel încât să putem folosi acest nume pentru a utiliza
acel modul din fiș ierul nostru sursă python.

Sintaxa pentru a redenumi un modul este prezentată mai jos.

1. importă <numele-modului> ca <numele-specific>

Exemplu

module de calcul al exemplului anterior este importat în acest exemplu ca cal.

importăcalculare ca cal;
a = int(input("Introduceț i a?"));
b = int(input("Introduceț i b?"));
print("Sumă = ",[Link](a,b))

Folosind funcția dir()

Funcț ia dir() returnează o listă sortată de nume definite în modulul trecut. Această listă conț ine toate submodulele,
variabilele ș i funcț iile definite în acest modul.
 Consideraț i următorul exemplu.

Exemplu

importjson

List = dir(json)

print(List)

Funcția reload()
Aș a cum am menț ionat deja, un modul este încărcat o singură dată, indiferent de câte ori este importat în
fiș ier sursă python. Cu toate acestea, dacă doriț i să reîncărcaț i modulul deja importat pentru a re-executa codul de nivel superior,
python ne oferă funcț ia reload(). Sintaxa pentru a folosi funcț ia reload() este dată mai jos.

1. reload(<numele-module>)

de exemplu, pentru a reîncărca modulul de calcul definit în exemplul anterior, trebuie să folosim următoarea linie de
cod.

1 reîncărcare(calcul)

Domeniul variabilelor
În Python, variabilele sunt asociate cu două tipuri de domenii. Toate variabilele definite într-un modul conț in domeniul global.
domeniu de aplicare, cu excepț ia cazului în care este definit în cadrul unei funcț ii.

Toate variabilele definite în interiorul unei funcț ii conț in un domeniu local care este limitat la această funcț ie în sine. Nu putem accesa
o variabilă locală la nivel global.

Dacă două variabile sunt definite cu acelaș i nume în două domenii diferite, adică, local ș i global, atunci prioritatea
va fi întotdeauna atribuit variabilei locale.

Consideraț i următorul exemplu.

Exemplu

john
defprint_nume(nume):
print("Salut", nume) #afişează numele care este local doar acestei funcţii.
introdu numele?
printa_nume(nume)

Pachete Python
Pachetele în python facilitează dezvoltatorului mediu de dezvoltare a aplica ț iilor prin furnizarea unei
structură de directoare ierarhică în care un pachet conț ine sub-pachete, module ș i sub-module. Pachetele
sunt folosite pentru a clasifica eficient codul la nivelul aplicaț iei.

Să creăm un pachet numit Angajaț i în directorul tău de acasă. Ia în considerare următorii paș i.

1. Creează un director cu numele Angajaț i pe calea /home.

2. Creaț i un fiș ier sursă Python cu numele [Link] pe calea /home/Employees.

[Link]

defgetITNames():
List = ["John","David","Nick","Martin"]
returnList;

3. În mod similar, creează un alt fiș ier python cu numele [Link] ș i creează o funcț ie getBPONames().

4. Acum, directorul Angajaț i pe care l-am creat în primul pas conț ine două module python. Pentru a face acest lucru
în directorul unui pachet, trebuie să includem încă un fiș ier aici, adică __init__.py care conț ine instrucț iunile de import ale
modulele definite în acest director.

__init__.py

1. dinAngajaț iiITimportăobț ineNumeleIT

2. deBPOAngajaț iimportăgetBPONume

Acum, directorul Angajaț i a devenit pachetul care conț ine două module python. Aici trebuie să observăm că
trebuie să creăm __init__.py în interiorul unui director pentru a transforma acest director într-un pachet.

6. Pentru a utiliza modulele definite în pachetul Angajaț i, trebuie să le importăm în fiș ierul nostru sursă Python.
Să creăm un fi ș ier sursă Python simplu în directorul nostru de acasă (/home) care folose ș te modulele definite în aceasta
pachet.
 [Link]

1 importaAngajaț i
2. print([Link]())

Putem avea sub-pachete în interiorul pachetelor. Putem îmbina pachetele până la orice nivel, în funcț ie de
cerinț e de aplicare.

Următoarea imagine arată structura directorului unui sistem de gestionare a bibliotecilor care conț ine trei
sub-pachete ca Admin, Bibliotecar ș i Student. Sub-pachetele conț in modulele python.