En Python, une classe constitue un modèle permettatn d'instancier des objets partageant des caractéristiques communes. Elle encapsule des données (attributs) et des comportements (méthodes). La déclaration s'effectue via le mot-clé class suivi du nom de la classe et d'un double point.

Définition d'une classe basique

Voici la structure fondamentale d'une classe :

class NomClasse:
    """Documentation de la classe"""
    corps_classe

Prenons l'exemple d'une classe Personnel représentant des employés :

class Personnel:
    """Représentation d'un membre du personnel"""
    effectif = 0  # Attribut de classe partagé
    
    def __init__(self, identite, remuneration):
        self.identite = identite          # Attribut d'instance
        self.remuneration = remuneration  # Attribut d'instance
        Personnel.effectif += 1
    
    def montrer_effectif(self):
        print(f"Effectif total : {Personnel.effectif}")
    
    def fiche_employe(self):
        print(f"Identité : {self.identite}, Rémunération : {self.remuneration}")

Instanciation et accès aux données

La création d'objets se fait en appelant la classe comme une fonction :

collaborateur_a = Personnel("Sophie Martin", 3200)
collaborateur_b = Personnel("Lucas Bernard", 4500)

L'accès aux attributs s'opère via la notation pointée. Les attributs d'instance sont propres à chaque objet, tandis que les attributs de classe sont communs :

collaborateur_a.fiche_employe()
collaborateur_b.fiche_employe()

Python autorise la modificaiton dynamique des objets :

collaborateur_a.anciennete = 5   # Ajout d'un attribut
collaborateur_a.anciennete = 6   # Modification
del collaborateur_a.anciennete   # Suppression

Mécanisme d'héritage

L'héritage permet de créer des classes dérivées qui récupèrent les caractéristiques d'une classe existante. La syntaxe place la classe mère entre parenthèses :

class ClasseFille(ClasseMere):
    """Documentation optionnelle"""
    corps_classe

Illustration avec une hiérarchie simple :

class Superieur:
    valeur_partagee = 100
    
    def __init__(self):
        print("Initialisation du niveau supérieur")
    
    def action_superieure(self):
        print("Exécution depuis le niveau supérieur")
    
    def configurer(self, valeur):
        Superieur.valeur_partagee = valeur
    
    def consulter(self):
        print(f"Valeur héritée : {Superieur.valeur_partagee}")

class Subalterne(Superieur):
    def __init__(self):
        super().__init__()
        print("Initialisation du niveau subalterne")
    
    def action_specifique(self):
        print("Comportement propre au subalterne")

# Utilisation
element = Subalterne()
element.action_specifique()
element.action_superieure()
element.configurer(250)
element.consulter()

Redéfinition des comportements

Une classe fille peut substituer une méthode héritée pour adapter son fonctionnement :

class Ancetre:
    def executer(self):
        print("Traitement défini dans l'ancêtre")

class Descendant(Ancetre):
    def executer(self):
        print("Traitement redéfini dans le descendant")

instance = Descendant()
instance.executer()  # Affiche le message du descendant