Introducere

În această lecție, vom explora conceptul de clase în limbajul de programare Python, învățând cum să creăm și să lucrăm cu clase în profunzime. Ne vom concentra pe concepte avansate precum moștenirea, metodele de clasă și de instanță și vom explora cum să personalizăm comportamentul claselor noastre în funcție de nevoile aplicației.

Cuprins

1. Recapitulare a conceptelor de bază ale claselor
2. Moștenirea în clase
3. Metode de clasă, metode de instanță și metode statice
4. Suprascrierea metodelor
5. Proprietăți și descriptori
6. Încheiere și concluzii

1. Recapitulare a conceptelor de bază ale claselor

În Python, o clasă este un model pentru crearea de obiecte (o instanță particulară a unei clase). O clasă definește atribute și metode care sunt comune tuturor obiectelor create din această clasă. Atributele sunt variabile asociate cu obiectele unei clase, iar metodele sunt funcții asociate cu obiectele unei clase.

Aici este un exemplu simplu de clasă:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f'{self.name} says Woof!')

dog1 = Dog('Buddy', 3)
dog2 = Dog('Max', 5)

dog1.bark()  # Output: Buddy says Woof!
dog2.bark()  # Output: Max says Woof!

2. Moștenirea în clase

Moștenirea este un mecanism prin care o clasă nouă (clasa derivată) poate moșteni atribute și metode de la o clasă existentă (clasa bază). Clasa derivată poate adăuga sau suprascrie atributele și metodele moștenite.

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

    def make_sound(self):
        print(f"{self.name} makes a generic sound")

class Dog(Animal):
    def __init__(self, name, age):
        super().__init__(name, "Dog")
        self.age = age

    def make_sound(self):
        print(f"{self.name} barks")

dog = Dog("Buddy", 3)
dog.make_sound()  # Output: Buddy barks

3. Metode de clasă, metode de instanță și metode statice

• Metodele de instanță sunt cele mai comune metode și sunt asociate cu o instanță a clasei. Ele au access la atributele de instanță și de clasă prin intermediul argumentului self.
• Metodele de clasă sunt asociate cu clasa în sine și nu cu o instanță a clasei. Acestea sunt marcate cu decoratorul @classmethod și au access la atributele de clasă prin intermediul argumentului cls.
• Metodele statice sunt funcții obișnuite care aparțin unei clase, dar nu au acces la atributele de instanță sau de clasă. Ele sunt marcate cu decoratorul @staticmethod.

class MyClass:
    class_attribute = "This is a class attribute"

    def __init__(self, instance_attribute):
        self.instance_attribute = instance_attribute

    def instance_method(self):
        print("This is an instance method")

    @classmethod
    def class_method(cls):
        print("This is a class method")

    @staticmethod
    def static_method():
        print("This is a static method")

my_instance = MyClass("This is an instance attribute")
my_instance.instance_method()
MyClass.class_method()
MyClass.static_method()

4. Suprascrierea metodelor

Suprascrierea metodelor permite unei clase derivate să ofere o implementare nouă sau modificată a unei metode care este deja oferită de clasa de bază. Acest lucru se face prin definirea unei metode cu același numeîn clasa derivată.

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        print(f"{self.name} makes a generic sound")

class Dog(Animal):
    def make_sound(self):
        print(f"{self.name} barks")

animal = Animal("Generic animal")
animal.make_sound()  # Output: Generic animal makes a generic sound

dog = Dog("Buddy")
dog.make_sound()  # Output: Buddy barks

5. Proprietăți și descriptori

Proprietățile sunt atribute ale unei clase care sunt accesate folosind sintaxa atribute (fără paranteze), dar comportamentul lor este definit printr-o metodă. Proprietățile sunt create folosind decoratorul @property pentru metodele getter și @<atribut>.setter pentru metodele setter.

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    @property
    def diameter(self):
        return self._radius * 2

    @property
    def area(self):
        return 3.14159 * (self._radius ** 2)

circle = Circle(5)
print(circle.radius)  # Output: 5
print(circle.diameter)  # Output: 10
print(circle.area)  # Output: 78.53975
circle.radius = 7
print(circle.radius)  # Output: 7

Descriptorii sunt obiecte care controlează accesul la un atribut într-o clasă. Ei definesc metodele speciale __get__() și __set__() pentru a personaliza comportamentul atributele atunci când sunt accesate sau modificate.

class PositiveNumber:
    def __init__(self, value):
        self.value = value

    def __get__(self, instance, owner):
        return self.value

    def __set__(self, instance, value):
        if value < 0:
            raise ValueError("Value cannot be negative")
        self.value = value

class MyClass:
    number = PositiveNumber(5)

my_instance = MyClass()
print(my_instance.number)  # Output: 5
my_instance.number = 7
print(my_instance.number)  # Output: 7

6. Încheiere și concluzii

În această lecție, am explorat conceptul de clase în Python în profunzime. Am învățat despre moștenirea în clase, metodele de clasă, metodele de instanță și metodele statice. Am analizat suprascrierea metodelor, proprietățile și descriptorii.

Având o înțelegere solidă a claselor în Python ne permite să scriem cod mai modular, reutilizabil și ușor de întreținut. Clasele sunt baza pentru proiectarea orientată pe obiecte, un stil de programare puternic și versatil care facilitează dezvoltarea unor aplicații complexe și scalabile.