Encapsulation : protéger les données

Qu'est-ce que l'encapsulation ? Principe et objectifs

L'encapsulation est l'un des quatre principes fondamentaux de la programmation orientée objet (avec l'héritage, le polymorphisme et l'abstraction).

L'encapsulation consiste à regrouper les données (attributs) et les méthodes qui manipulent ces données au sein d'une même entité (la classe), et à contrôler l'accès à ces données depuis l'extérieur de la classe.

Les objectifs de l'encapsulation sont :

• Protection des données : Empêcher l'accès direct et la modification accidentelle des données internes d'un objet depuis l'extérieur de la classe.
• Abstraction : Masquer les détails d'implémentation internes de la classe et ne révéler qu'une interface publique bien définie.
• Modularité : Faciliter la maintenance et l'évolution du code en limitant les dépendances entre les différentes parties du programme.
• Sécurité Limiter le risque d'altérer ou corrompre des données.

Encapsulation en Python : pas de modificateurs d'accès stricts

Contrairement à d'autres langages orientés objet comme Java ou C++, Python n'a pas de modificateurs d'accès stricts (comme `public`, `private`, `protected`). En Python, l'encapsulation repose sur des conventions de nommage et sur la discipline des développeurs.

Il existe cependant des conventions pour indiquer le niveau d'accès souhaité pour les attributs et les méthodes :

• Attributs et méthodes publics : Ils sont accessibles depuis n'importe où (à l'intérieur ou à l'extérieur de la classe). C'est le cas par défaut (pas de préfixe particulier).
• Attributs et méthodes "protégés" (convention) : Ils sont destinés à être utilisés uniquement à l'intérieur de la classe elle-même et de ses sous-classes (voir héritage). On les préfixe par un simple trait de soulignement (`_`). Ce n'est qu'une convention, Python ne bloque pas l'accès depuis l'extérieur.
• Attributs et méthodes "privés" (name mangling) : Ils sont destinés à être utilisés uniquement à l'intérieur de la classe elle-même. On les préfixe par un double trait de soulignement (`__`). Python effectue un "name mangling" (modification du nom) pour rendre l'accès depuis l'extérieur plus difficile (mais pas impossible).

Il est important de comprendre que ces conventions ne sont pas des mécanismes de protection stricts comme dans d'autres langages. Elles servent principalement à indiquer l'intention du développeur et à prévenir les utilisations accidentelles.

Attributs et méthodes publics : l'accès par défaut

Par défaut, tous les attributs et méthodes d'une classe sont publics en Python. Cela signifie qu'ils peuvent être accédés et modifiés depuis n'importe où (à l'intérieur de la classe, depuis une sous-classe, ou depuis l'extérieur de la classe).

Exemple :

class MaClasse:
    def __init__(self, valeur):
        self.valeur = valeur  # Attribut public

    def methode_publique(self):
        print("Méthode publique appelée")

objet = MaClasse(10)
print(objet.valeur)          # Accès à l'attribut public
objet.valeur = 20            # Modification de l'attribut public
objet.methode_publique()   # Appel de la méthode publique

Dans cet exemple, `valeur` et `methode_publique` sont publics. Ils peuvent être accédés et modifiés directement depuis l'extérieur de la classe.

Attributs et méthodes "protégés" : la convention du simple soulignement

Pour indiquer qu'un attribut ou une méthode est destiné à un usage interne à la classe ou à ses sous-classes, on utilise la convention de nommage du simple trait de soulignement (`_`) comme préfixe.

Exemple :

class MaClasse:
    def __init__(self):
        self._attribut_protege = 10  # Attribut "protégé"

    def _methode_protegee(self):
        print("Méthode protégée appelée")

objet = MaClasse()
# Accès à l'attribut "protégé" (techniquement possible, mais déconseillé)
print(objet._attribut_protege)

# Appel de la méthode "protégée" (techniquement possible, mais déconseillé)
objet._methode_protegee()

Il est important de souligner que le simple soulignement n'est qu'une *convention*. Python n'empêche pas techniquement d'accéder à un attribut ou à une méthode préfixé par un simple soulignement depuis l'extérieur de la classe.

Cependant, cette convention est largement respectée par la communauté Python. Si vous voyez un attribut ou une méthode avec un simple soulignement, considérez que c'est un détail d'implémentation interne et évitez de l'utiliser directement depuis l'extérieur de la classe (sauf si vous êtes sûr de ce que vous faites).

Attributs et méthodes "privés" : le name mangling (double soulignement)

Pour rendre l'accès à un attribut ou à une méthode plus difficile (mais pas impossible) depuis l'extérieur de la classe, vous pouvez utiliser le double trait de soulignement (`__`) comme préfixe.

Lorsque vous utilisez un double soulignement, Python effectue un "name mangling" (modification du nom). Le nom de l'attribut ou de la méthode est transformé en interne en `_NomDeLaClasse__nom`. Cela rend l'accès direct depuis l'extérieur plus difficile, car il faut connaître le nom modifié.

Exemple :

class MaClasse:
    def __init__(self):
        self.__attribut_prive = 10  # Attribut "privé"

    def __methode_privee(self):
        print("Méthode privée appelée")

    def methode_publique(self):
        print("Méthode publique appelée")
        self.__methode_privee()  # Accès à la méthode privée depuis l'intérieur de la classe
        print(self.__attribut_prive) #Accès à la méthode privée depuis l'intérieur de la classe

objet = MaClasse()

# print(objet.__attribut_prive)  # Lèverait une AttributeError (l'attribut n'existe pas avec ce nom)
# objet.__methode_privee()      # Lèverait une AttributeError

# Accès via le nom modifié (fortement déconseillé, mais possible) :
print(objet._MaClasse__attribut_prive)  # Affiche 10
objet._MaClasse__methode_privee()

objet.methode_publique()

Dans cet exemple :

• `__attribut_prive` et `__methode_privee` sont "privés".
• Essayer d'y accéder directement depuis l'extérieur de la classe avec leur nom d'origine (`objet.__attribut_prive`) lève une `AttributeError`.
• Cependant, on peut y accéder en utilisant le nom modifié (`objet._MaClasse__attribut_prive`). C'est pourquoi on dit que le name mangling rend l'accès plus difficile, mais pas impossible.
• L'accès se fait sans problème depuis l'intérieur de la classe via la `methode_publique`.

Le name mangling est principalement destiné à éviter les conflits de noms accidentels dans les hiérarchies de classes (voir héritage), plutôt qu'à fournir une véritable protection des données.

Propriétés (@property) : contrôler l'accès aux attributs

Une autre approche, recommandée en Python pour contrôler l'accès à un attribut, est d'utiliser le décorateur `@property`.

Il permet de transformer des méthodes en attributs, en définissant des accesseurs (getters), des mutateurs (setters) et des suppresseurs (deleters).

Cela permet d'encapsuler l'accès aux attributs et d'effectuer des validations ou des calculs lors de l'accès, de la modification ou de la suppression.

Exemple :

class Cercle:
    def __init__(self, rayon):
        self._rayon = rayon  # Attribut "protégé"

    @property
    def rayon(self):
        """Le rayon du cercle."""
        print("Accès au rayon")
        return self._rayon

    @rayon.setter
    def rayon(self, valeur):
        print("Modification du rayon")
        if valeur < 0:
            raise ValueError("Le rayon ne peut pas être négatif.")
        self._rayon = valeur

    @rayon.deleter
    def rayon(self):
        print("Suppression du rayon")
        del self._rayon


c = Cercle(5)
print(c.rayon)  # Accès au rayon (affiche "Accès au rayon" puis 5)
c.rayon = 10   # Modification du rayon (affiche "Modification du rayon")
# c.rayon = -2  # Lèverait une ValueError
del c.rayon    # Suppression du rayon (affiche "Suppression du rayon")

Dans cet exemple :

• `_rayon` est un attribut "protégé" (convention du simple soulignement).
• `rayon` est une propriété. Elle a un accesseur (`@property`), un mutateur (`@rayon.setter`), et un suppresseur (`@rayon.deleter`).
• Lorsque vous accédez à `c.rayon`, c'est la méthode `rayon(self)` (l'accesseur) qui est appelée.
• Lorsque vous modifiez `c.rayon`, c'est la méthode `rayon(self, valeur)` (le mutateur) qui est appelée. Elle valide la valeur avant de modifier l'attribut `_rayon`.
• Lorsque vous supprimez `c.rayon`, c'est la méthode `rayon(self)` (le suppresseur) qui est appelée.

Les propriétés offrent un moyen élégant et puissant de contrôler l'accès aux attributs et de maintenir l'intégrité des données.