Cum funcționează clasele și obiectele în Python?

Question

Accepted Answer

O **clasă** este o sablonă pentru crearea **obiectelor** (instanțelor) care grupează date (atribute) și comportament (metode). POO din Python este flexibilă și are unele convenții distinctive, în special `self` explicit.

## De ce conteaza

Classele sunt modul în care modelezi entități și organizezi codul în Python orientat pe obiecte — grupând date și comportament conexe, utilizate pe scară largă în framework-uri, modelarea domeniului și aplicații mari.

Înțelegerea convențiilor distinctive ale Python — `self` explicit, constructor `__init__`, atribute de clasă vs instanță, cei trei tipuri de metodă (`instance`/`@classmethod`/`@staticmethod`) și convențiile de confidențialitate cu underscore — este esențială pentru scrierea și citirea Python orientat pe obiecte.

Ele diferă suficient de alte limbaje (self explicit, confidențialitate bazată pe convenție) pentru ca o înțelegere bună să prevină confuzia comună.

## Definirea unei clase

```python
class Dog:
    species = "Canis familiaris"     # CLASS attribute (shared by all instances)

def __init__(self, name, age):   # the constructor — runs on creation
        self.name = name              # INSTANCE attributes (per object)
        self.age = age

def bark(self):                   # a method — `self` is the instance
        return f"{self.name} says woof"

d = Dog("Rex", 3)        # create an instance (calls __init__)
d.name                   # "Rex"
d.bark()                 # "Rex says woof"
```

## Self explicit

```python
def bark(self):          # `self` is ALWAYS the first parameter of a method
    return self.name      # access instance data through self
```

Spre deosebire de multe limbaje cu un `this` implicit, Python necesită **`self`** ca prim parametru explicit al fiecărei metode de instanță — se referă la instanța pe care se apelează metoda. Nu îl transmiți manual; `d.bark()` transmite `d` ca `self` automat.

## Atribute de clasă vs atribute de instanță

```python
Dog.species          # "Canis familiaris" — shared by all dogs
d.species            # also accessible from an instance
d.name               # "Rex" — unique to this instance
```

Atributele de clasă sunt împărtășite între toate instanțele; atributele de instanță (setate via `self.x =`) sunt per-obiect.

## Tipuri de metode

```python
class Circle:
    def area(self): ...                    # instance method — needs self

@classmethod
    def from_diameter(cls, d):             # class method — receives the CLASS (cls)
        return cls(d / 2)                   # often used as alternative constructors

@staticmethod
    def pi(): return 3.14159               # static — no self/cls, just namespaced
```

## Convenții de încapsulare

```python
self.public                # public
self._protected            # "internal use" by convention (not enforced)
self.__private             # name-mangled to _ClassName__private (stronger hiding)
```

Python nu are membri cu adevărat privați — underscores-urile inițiale sunt convenții care semnalizează intenție ("nu atinge asta"), nu aplicare dură.