Comment fonctionnent les classes et les objets en Python?

Question

Accepted Answer

Une **classe** est un modèle pour créer des **objets** (instances) qui regroupent les données (attributs) et le comportement (méthodes). L'OOP de Python est flexible et a certaines conventions distinctives, notamment le `self` explicite.

## Définir une 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"
```

## Le self explicite

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

Contrairement à de nombreux langages ayant un `this` implicite, Python requiert **`self`** comme premier paramètre explicite de toute méthode d'instance — il fait référence à l'instance sur laquelle la méthode est appelée. Vous ne le passez pas manuellement ; `d.bark()` passe `d` comme `self` automatiquement.

## Attributs de classe vs attributs d'instance

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

Les attributs de classe sont partagés entre toutes les instances ; les attributs d'instance (définis via `self.x =`) sont propres à chaque objet.

## Types de méthodes

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

## Conventions d'encapsulation

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

Python n'a pas de véritables membres privés — les underscores avant sont des conventions signalant l'intention ("ne touchez pas à ceci"), non une application stricte.

## Pourquoi c'est important

Les classes sont la façon de modéliser les entités et d'organiser le code en Python orienté objet — en regroupant les données et le comportement connexes, largement utilisées dans les frameworks, la modélisation de domaine et les grandes applications.

Comprendre les conventions distinctives de Python — le `self` explicite, le constructeur `__init__`, les attributs de classe par rapport aux attributs d'instance, les trois types de méthodes (`instance`/`@classmethod`/`@staticmethod`) et les conventions de confidentialité avec underscores — est essentiel pour écrire et lire du Python orienté objet.

Ellles diffèrent suffisamment des autres langages (self explicite, confidentialité basée sur les conventions) pour que les bien connaître prévienne les confusions courantes.