Come funzionano le classi e gli oggetti in Python?

Question

Accepted Answer

Una **classe** è un modello per creare **oggetti** (istanze) che raggruppano dati (attributi) e comportamento (metodi). L'OOP di Python è flessibile e ha alcune convenzioni distintive, in particolare il `self` esplicito.

## Definire una classe

```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"
```

## The explicit self

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

A differenza di molti linguaggi con un `this` implicito, Python richiede **`self`** come primo parametro esplicito di ogni metodo dell'istanza — si riferisce all'istanza su cui viene chiamato il metodo. Non lo passi manualmente; `d.bark()` passa automaticamente `d` come `self`.

## Attributi della classe vs attributi dell'istanza

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

Gli attributi della classe sono condivisi tra tutte le istanze; gli attributi dell'istanza (impostati tramite `self.x =`) sono per-oggetto.

## Tipi di metodo

```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
```

## Convenzioni di Encapsulation

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

Python non ha veri membri privati — i trattini bassi iniziali sono convenzioni che segnalano l'intento ("non toccare questo"), non applicazione rigorosa.

## Perché è importante

Le classi sono il modo in cui modellate le entità e organizzate il codice in Python orientato agli oggetti — raggruppando dati e comportamento correlati, ampiamente utilizzate nei framework, nella modellazione di dominio e nelle applicazioni di grandi dimensioni.

Comprendere le convenzioni Python distintive — il `self` esplicito, il costruttore `__init__`, gli attributi della classe vs attributi dell'istanza, i tre tipi di metodo (`instance`/`@classmethod`/`@staticmethod`) e le convenzioni sulla privacy con il trattino basso — è essenziale per scrivere e leggere Python orientato agli oggetti.

Si differenziano abbastanza dagli altri linguaggi (self esplicito, privacy basata su convenzione) da rendere la loro conoscenza approfondita utile nel prevenire confusioni comuni.