Syntaxe de définition d'une classe (class)

Le mot-clé class : déclarer une classe

En Python, vous définissez une classe en utilisant le mot-clé `class`, suivi du nom de la classe, et de deux-points `:`. Le corps de la classe (les définitions des attributs et des méthodes) est indenté après les deux-points.

Syntaxe de base :

class NomDeLaClasse:
    # Corps de la classe (attributs et méthodes)
    # ...

Exemple (une classe vide) :

class MaClasse:
    pass  # Le mot-clé 'pass' indique que la classe est vide (pour l'instant)

Le nom de la classe doit respecter les conventions de nommage Python. La convention la plus courante pour les noms de classes est le CamelCase (également appelé PascalCase), où chaque mot commence par une majuscule, sans espaces ni tirets (par exemple, `MaClasse`, `MonObjet`, `CompteBancaire`).

Une définition de classe crée un nouvel objet classe (à ne pas confondre avec une *instance* de la classe, qui est un objet créé à partir de la classe).

Structure d'une définition de classe : attributs et méthodes

Une définition de classe contient généralement :

• Des attributs de classe (optionnels).
• Un constructeur (`__init__`) (optionnel, mais très courant).
• Des méthodes (qui définissent le comportement des objets de la classe).

Exemple (une classe `Chien` simple) :

class Chien:
    """Représente un chien."""

    espece = "Canis familiaris"  # Attribut de classe

    def __init__(self, nom, age):
        """Initialise un chien avec un nom et un âge."""
        self.nom = nom  # Attribut d'instance
        self.age = age  # Attribut d'instance

    def aboyer(self):
        """Fait aboyer le chien."""
        print("Wouf wouf !")

    def decrire(self):
        """Décrit le chien."""
        print(f"Je m'appelle {self.nom} et j'ai {self.age} ans.")

Dans cet exemple :

• `Chien` est le nom de la classe.
• `espece` est un attribut de classe.
• `__init__` est le constructeur. Il initialise les attributs d'instance `nom` et `age`.
• `aboyer` et `decrire` sont des méthodes.

L'indentation est essentielle en Python. Elle définit le corps de la classe et le corps de chaque méthode.

Le constructeur __init__ : initialiser les objets

Le constructeur est une méthode spéciale nommée `__init__` (avec deux tirets de soulignement avant et après). Il est appelé automatiquement lorsque vous créez une nouvelle instance de la classe (un nouvel objet).

Le rôle principal du constructeur est d'initialiser les attributs de l'objet.

Le constructeur prend généralement `self` comme premier argument, suivi des arguments nécessaires pour initialiser l'objet.

Exemple (avec la classe `Chien`) :

# ... (définition de la classe Chien comme précédemment) ...

# Création d'objets (instances) de la classe Chien
chien1 = Chien("Médor", 3)
chien2 = Chien("Fido", 5)

# Lorsque vous faites Chien("Médor", 3), Python :
# 1. Crée un nouvel objet Chien.
# 2. Appelle la méthode __init__ de la classe Chien, en passant le nouvel objet comme 'self',
#    "Médor" comme 'nom', et 3 comme 'age'.
# 3. La méthode __init__ initialise les attributs de l'objet (self.nom et self.age).
# 4. L'objet est maintenant prêt à être utilisé.

Vous n'appelez *jamais* `__init__` directement. Vous appelez le nom de la classe comme si c'était une fonction, et Python appelle `__init__` en coulisses.

Conventions de nommage et bonnes pratiques

Voici quelques conventions de nommage et bonnes pratiques pour définir des classes en Python :

• Nom de la classe : Utilisez le CamelCase (ou PascalCase) : chaque mot commence par une majuscule, sans espaces ni tirets (par exemple, `MaClasse`, `MonObjet`, `CompteBancaire`).
• Attributs et méthodes : Utilisez des noms en minuscules, avec des mots séparés par des traits de soulignement (snake_case) (par exemple, `nom`, `age`, `calculer_aire`, `methode_speciale`).
• Attributs et méthodes "protégés" : Préfixez-les par un simple trait de soulignement (`_`).
• Attributs et méthodes "privés" : Préfixez-les par un double trait de soulignement (`__`).
• Docstrings : Documentez vos classes et méthodes en utilisant des docstrings.
• Structure : Organisez votre classe de manière logique, en regroupant les attributs et les méthodes par fonctionnalité.
• Cohérence : Soyez cohérent dans votre style de codage et respectez les conventions de la communauté Python (PEP 8).

La classe object : classe de base implicite (Python 3)

En Python 3, toutes les classes héritent implicitement de la classe de base `object`. Cela signifie que même si vous ne spécifiez pas de classe parente, votre classe aura certaines méthodes et attributs de base hérités de `object`.

Exemple :

class MaClasse:  # Equivalent à : class MaClasse(object):
    pass

Vous n'avez généralement pas besoin d'écrire `(object)` explicitement, car c'est implicite en Python 3. (En Python 2, c'était différent : il fallait écrire `class MaClasse(object):` pour créer une classe "new-style").

La classe `object` fournit des méthodes de base comme `__str__`, `__repr__`, `__new__`, etc., que vous pouvez redéfinir dans vos classes si nécessaire.