Programare Orientată pe Obiecte în Python- Curs Phyton

Programare Orientată pe Obiecte (OOP)

Clase și Obiecte în Python

Programarea orientată pe obiecte (OOP) este un stil de programare care organizează codul în jurul „obiectelor” — instanțe ale unor clase. O clasă definește structura și comportamentul, iar obiectele sunt instanțe concrete ale acestei structuri.

Definirea unei clase

class Elev:
    pass

Crearea unui obiect

ioan = Elev()
print(type(ioan))   # Afișează: <class '__main__.Elev'>

Constructorul __init__ în Python

Metoda __init__ este constructorul unei clase în Python. Ea este apelată automat atunci când se creează un obiect și permite inițializarea atributelor.

Definirea unui constructor

class Elev:
    def __init__(self, nume, varsta):
        self.nume = nume
        self.varsta = varsta

Crearea unui obiect cu constructor

ioan = Elev("Ioan", 17)
print(ioan.nume)     # Afișează: Ioan
print(ioan.varsta)   # Afișează: 17

Atribute și Metode în Python

Atributele sunt variabile asociate unui obiect, iar metodele sunt funcții definite în cadrul unei clase. Ele definesc starea și comportamentul obiectelor.

Atribute de instanță

class Elev:
    def __init__(self, nume, varsta):
        self.nume = nume
        self.varsta = varsta

ioan = Elev("Ioan", 17)
print(ioan.nume)     # Afișează: Ioan

Metode de instanță

class Elev:
    def __init__(self, nume):
        self.nume = nume

    def salut(self):
        print(f"Salut, eu sunt {self.nume}!")

ioan = Elev("Ioan")
ioan.salut()   # Afișează: Salut, eu sunt Ioan!

Moștenire și Polimorfism în Python

Moștenirea permite unei clase să preia comportamentul și atributele altei clase. Polimorfismul permite folosirea acelorași metode în moduri diferite, în funcție de contextul obiectului.

Moștenirea unei clase

class Persoana:
    def __init__(self, nume):
        self.nume = nume

    def salut(self):
        print(f"Salut, eu sunt {self.nume}")

class Elev(Persoana):
    def salut(self):
        print(f"Elevul {self.nume} spune bună ziua!")

Polimorfism

pers = Persoana("Ana")
elev = Elev("Ioan")

pers.salut()   # Salut, eu sunt Ana
elev.salut()   # Elevul Ioan spune bună ziua!

Encapsulare și Proprietăți în Python

Encapsularea este principiul OOP care protejează datele interne ale unui obiect. În Python, putem controla accesul la atribute folosind convenții și proprietăți.

Atribute private (convenție)

class Elev:
    def __init__(self, nume):
        self._nume = nume   # convenție: atribut „protejat”
        self.__cod = 1234   # atribut „privat” (name mangling)

Acces controlat cu proprietăți

class Elev:
    def __init__(self, nume):
        self._nume = nume

    @property
    def nume(self):
        return self._nume

    @nume.setter
    def nume(self, valoare):
        if valoare:
            self._nume = valoare

ioan = Elev("Ioan")
print(ioan.nume)     # Afișează: Ioan
ioan.nume = "Andrei"
print(ioan.nume)     # Afișează: Andrei

Metode speciale (dunder methods) în Python

Metodele speciale, cunoscute și ca „dunder methods” (double underscore), permit definirea comportamentului personalizat al obiectelor în contexte uzuale: afișare, lungime, adunare etc. Ele încep și se termină cu două caractere underscore.

__str__ - afișare textuală

class Elev:
    def __init__(self, nume):
        self.nume = nume

    def __str__(self):
        return f"Elev: {self.nume}"

ioan = Elev("Ioan")
print(ioan)   # Afișează: Elev: Ioan

__len__ - lungimea obiectului

class Grup:
    def __init__(self, membri):
        self.membri = membri

    def __len__(self):
        return len(self.membri)

g = Grup(["Ioan", "Ana", "Mihai"])
print(len(g))   # Afișează: 3

__add__ - comportamentul operatorului +

class Elev:
    def __init__(self, nume):
        self.nume = nume

    def __add__(self, altul):
        return f"{self.nume} și {altul.nume} sunt colegi"

e1 = Elev("Ioan")
e2 = Elev("Ana")
print(e1 + e2)   # Afișează: Ioan și Ana sunt colegi

🧠 Quiz - Programare Orientată pe Obiecte (OOP)