Introducere

În această lecție, vom discuta despre polimorfism, metoda __str__ și alte metode speciale în limbajul de programare Python. Polimorfismul este un principiu fundamental în programarea orientată pe obiect care se referă la capacitatea unei funcții sau metode de a opera cu mai multe tipuri de obiecte. Metodele speciale, precum __str__, sunt metode predefinite în Python care pot fi suprascrise pentru a personaliza comportamentul anumitor funcții și operatori pentru obiectele noastre.

Cuprins

1. Polimorfism
2. Metoda __str__
3. Alte metode speciale
4. Exemple și scenarii de utilizare
5. Încheiere și concluzii

1. Polimorfism

Polimorfismul este un concept în programarea orientată pe obiect care se referă la capacitatea unei funcții sau metode de a opera cu diferite tipuri de obiecte, fără a necesita informații specifice despre tipul acestora. Aceasta permite crearea unui cod mai flexibil și reutilizabil, deoarece funcțiile și metodele pot fi adaptate pentru a funcționa cu o varietate de tipuri de obiecte.

În Python, polimorfismul este realizat în principal prin intermediul suprascrierii metodelor și a moștenirii. De exemplu, să presupunem că avem o clasă Animal și mai multe clase derivate, precum Dog și Cat, care suprascriu metoda make_sound:

class Animal:
    def make_sound(self):
        print("Some generic animal sound")

class Dog(Animal):
    def make_sound(self):
        print("Woof!")

class Cat(Animal):
    def make_sound(self):
        print("Meow!")

def play_sound(animal):
    animal.make_sound()

dog = Dog()
cat = Cat()

play_sound(dog)  # Output: Woof!
play_sound(cat)  # Output: Meow!

Funcția play_sound acceptă un obiect de tip Animal ca argument și apelează metoda make_sound a acestuia. Datorită polimorfismului, această funcție poate opera atât cu obiecte de tip Dog, cât și cu obiecte de tip Cat, fără a necesita informații specifice despre aceste tipuri.

2. Metoda __str__

Metoda __str__ este o metodă specială în Python care poate fi suprascrisă în clasele noastre pentru a personaliza reprezentarea șirului de caractere a obiectelor. Această metodă este apelată automat de funcția încorporată str() și de alte funcții care necesită o reprezentare ca șir de caractere a obiectelor, cum ar fi print().

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

    def __str__(self):
        return f"Animal named {self.name}"

animal = Animal("Buddy")
print(animal)  # Output: Animal named Buddy

3. Alte metode speciale

În plus față de metoda __str__, Python oferă o serie de alte metode speciale pe care le putem suprascrie în clasele noastre pentru a personaliza comportamentul anumitor funcții și operatori. Iată câteva exemple notabile:

• __repr__: Personalizează reprezentarea obiectelor în mediul interactiv și în alte contexte în care este necesară o reprezentare mai formală decât __str__.

• __len__: Personalizează comportamentul funcției len() pentru obiectele noastre.

• __getitem__: Permite accesarea elementelor obiectelor noastre folosind sintaxa de indexare (de ex., obj[index]).

• __setitem__: Permite modificarea elementelor obiectelor noastre folosind sintaxa de indexare (de ex., obj[index] = value).

• __iter__: Permite iterarea obiectelor noastre într-un mod personalizat, de exemplu, într-o instrucțiune for.

• __eq__: Personalizează comportamentul operatorului de egalitate (==) pentru obiectele noastre.

• __lt__, __le__, __gt__, __ge__: Personalizează comportamentul operatorilor de comparare (<, <=, >, >=) pentru obiectele noastre.

• __add__, __sub__, __mul__, __truediv__, __floordiv__, __mod__: Personalizează comportamentul operatorilor aritmetici (+, -, *, /, //, %) pentru obiectele noastre.

4. Exemple și scenarii de utilizare

Să luăm în considerare următorul scenariu: avem o clasă Vector care reprezintă un vector matematic. Am dori să suportăm operații precum adăugarea a doi vectori și compararea lungimilor lor. Putem implementa aceste funcționalități folosind metode speciale:

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented

    def __eq__(self, other):
        if isinstance(other, Vector):
            return (self.x == other.x) and (self.y == other.y)
        return NotImplemented

a = Vector(3, 4)
b = Vector(1, 2)

c = a + b  # Vector(4, 6)
print(a == b)  # Output: False
print(c)  # Output: (4, 6)

În acest exemplu, am suprascris metodele __str__, __add__ și __eq__ pentru a personaliza comportamentul operatorilor și funcțiilor corespunzătoare.

5. Încheiere și concluzii

Polimorfismul, metoda __str__ și alte metode speciale sunt concepte importante în programarea orientată pe obiect în Python. Acestea permit crearea unui cod mai flexibil și reutilizabil, deoarece funcțiile și metodele pot fi adaptate pentru a funcționa cu diferite tipuri de obiecte.

De asemenea, metodele speciale ne permit să personalizăm comportamentul anumitor funcții și operatori pentru obiectele noastre, astfel încât să putem crea clase care se comportă în moduri intuitive și ușor de utilizat.

În concluzie, prin înțelegerea și aplicarea polimorfismului și a metodelor speciale în proiectele noastre Python, putem îmbunătăți semnificativ structura, reutilizabilitatea și ușurința de utilizare a codului nostru.