Python - Access Modifiers (Français)

Bonjour à tous, aspirants programmeurs Python !aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde des modificateurs d'accès en Python. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je vais vous guider à travers ce concept étape par étape, avec beaucoup d'exemples et d'explications en cours de route. Alors, plongeons dans !

Modificateurs d'accès en Python

En programmation orientée objet, les modificateurs d'accès sont utilisés pour contrôler la visibilité et l'accessibilité des membres de classe (attributs et méthodes). Alors que de nombreux langages de programmation ont des modificateurs d'accès stricts tels que public, privé et protégé, Python adopte une approche plus détendue. Il suit une philosophie souvent appelée "Nous sommes tous des adultes consentants ici."

En Python, nous avons trois types de modificateurs d'accès :

1. Public
2. Protégé
3. Privé

Explorons chacun de ces types avec des exemples.

Membres publics

En Python, tous les membres sont publics par défaut. Cela signifie qu'ils peuvent être accédés de l'extérieur de la classe. Voici un exemple :

class Étudiant:
def __init__(self, nom, âge):
self.nom = nom  # Attribut public
self.âge = âge  # Attribut public

def afficher_info(self):  # Méthode publique
print(f"Nom: {self.nom}, Âge: {self.âge}")

# Création d'une instance de Étudiant
étudiant1 = Étudiant("Alice", 20)

# Accès aux membres publics
print(étudiant1.nom)  # Sortie : Alice
étudiant1.afficher_info()  # Sortie : Nom: Alice, Âge: 20

Dans cet exemple, nom, âge et afficher_info() sont tous des membres publics. Nous pouvons y accéder directement de l'extérieur de la classe.

Membres protégés

Les membres protégés sont indiqués par un préfixe d'un seul underscore (_). Ils ne sont pas vraiment privés et peuvent encore être accédés de l'extérieur de la classe, mais c'est une convention de les traiter comme une utilisation interne uniquement.

class Employé:
def __init__(self, nom, salaire):
self._nom = nom      # Attribut protégé
self._salaire = salaire  # Attribut protégé

def _afficher_salaire(self):  # Méthode protégée
print(f"{self._nom}'s salaire est de ${self._salaire}")

# Création d'une instance de Employé
emp1 = Employé("Bob", 50000)

# Accès aux membres protégés (Note : c'est possible mais non recommandé)
print(emp1._nom)  # Sortie : Bob
emp1._afficher_salaire()  # Sortie : Bob's salaire est de $50000

Bien que nous puissions accéder à _nom, _salaire et _afficher_salaire(), il est généralement recommandé de ne pas le faire en dehors de la classe ou de ses sous-classes.

Membres privés

Les membres privés sont indiqués par un préfixe de doubles underscores (__). Python effectue le mangle de nom pour ces membres, les rendant plus difficiles (mais pas impossibles) à accéder de l'extérieur de la classe.

class CompteBancaire:
def __init__(self, numéro_compte, solde):
self.__numéro_compte = numéro_compte  # Attribut privé
self.__solde = solde                # Attribut privé

def __afficher_solde(self):  # Méthode privée
print(f"Solde: ${self.__solde}")

def affichage_public(self):
self.__afficher_solde()

# Création d'une instance de CompteBancaire
compte1 = CompteBancaire("123456", 1000)

# Tentative d'accès aux membres privés
# print(compte1.__numéro_compte)  # Cela levera une AttributeError
# compte1.__afficher_solde()      # Cela levera également une AttributeError

# Accès à la méthode privée par une méthode publique
compte1.affichage_public()  # Sortie : Solde: $1000

Dans cet exemple, __numéro_compte, __solde et __afficher_solde() sont des membres privés. Tenter d'y accéder directement de l'extérieur de la classe levera une AttributeError.

Mangle de nom

Souvenez-vous quand j'ai mentionné que les membres privés en Python ne sont pas vraiment privés ? Cela est dû à un mécanisme appelé mangle de nom. Lorsque vous créez un membre privé en utilisant des doubles underscores, Python change son nom en interne pour le rendre plus difficile à accéder accidentellement.

Voici comment cela fonctionne :

class MangleDeNomDémonstration:
def __init__(self):
self.__variable_privee = "Je suis privé !"

démonstration = MangleDeNomDémonstration()
print(dir(démonstration))
# Sortie : [..., '_MangleDeNomDémonstration__variable_privee', ...]

# Accès à la variable privée en utilisant le nom mangle
print(démonstration._MangleDeNomDémonstration__variable_privee)  # Sortie : Je suis privé !

Comme vous pouvez le voir, Python renomme __variable_privee en _MangleDeNomDémonstration__variable_privee. Voilà le mangle de nom en action !

Objet propriété Python

La fonction propriété() en Python est une fonction intégrée qui crée et renvoie un objet propriété. C'est un moyen d'ajouter des méthodes getter, setter et deleter aux attributs de classe.

Voici un exemple :

class Température:
def __init__(self, celsius):
self._celsius = celsius

def get_fahrenheit(self):
return (self._celsius * 9/5) + 32

def set_fahrenheit(self, fahrenheit):
self._celsius = (fahrenheit - 32) * 5/9

fahrenheit = propriété(get_fahrenheit, set_fahrenheit)

# Utilisation de la propriété
temp = Température(25)
print(temp.fahrenheit)  # Sortie : 77.0

temp.fahrenheit = 86
print(temp._celsius)  # Sortie : 30.0

Dans cet exemple, fahrenheit est une propriété qui nous permet d'obtenir et de définir la température en Fahrenheit tout en stockant internalement en Celsius.

Méthodes getter et setter

Les getters et setters sont des méthodes utilisées pour obtenir et définir les valeurs des attributs de classe. Ils fournissent un moyen d'accéder et de modifier des attributs privés tout en maintenant l'encapsulation.

Voici un exemple utilisant le décorateur @propriété, qui est une manière plus pythonesque d'implémenter les getters et les setters :

class Personne:
def __init__(self, nom, âge):
self._nom = nom
self._âge = âge

@propriété
def nom(self):
return self._nom

@nom.setter
def nom(self, valeur):
if not isinstance(valeur, str):
raise ValueError("Le nom doit être une chaîne")
self._nom = valeur

@propriété
def âge(self):
return self._âge

@âge.setter
def âge(self, valeur):
if not isinstance(valeur, int) or valeur < 0:
raise ValueError("L'âge doit être un entier positif")
self._âge = valeur

# Utilisation des getters et setters
personne = Personne("Charlie", 30)
print(personne.nom)  # Sortie : Charlie

personne.nom = "David"
print(personne.nom)  # Sortie : David

try:
personne.âge = -5
except ValueError as e:
print(e)  # Sortie : L'âge doit être un entier positif

Dans cet exemple, nous avons créé des méthodes getter et setter pour nom et âge. Les méthodes setter incluent une validation pour s'assurer que les valeurs définies rencontrent certains critères.

Pour résumer les méthodes que nous avons discutées, voici un tableau en format Markdown :

Méthode	Description	Exemple
Public	Accessible de n'importe où	self.nom
Protégé	Accessible dans la classe et les sous-classes (par convention)	self._nom
Privé	Nom mangle pour restreindre l'accès	self.__nom
Propriété	Crée un objet propriété	propriété(get_method, set_method)
Getter	Méthode pour obtenir la valeur d'un attribut	@propriété
Setter	Méthode pour définir la valeur d'un attribut	@attribut.setter

Et voilà ! Nous avons couvert les modificateurs d'accès en Python, le mangle de nom, les objets propriété et les méthodes getter et setter. Rappelez-vous, l'approche de Python pour le contrôle de l'accès est plus sobre la convention et la confiance que des règles strictes. Au fur et à mesure de votre parcours Python, vous découvrirez que cette flexibilité permet de代码l et lisible tout en fournissant des moyens d'implémenter l'encapsulation lorsque cela est nécessaire.

Continuez à pratiquer, restez curieux, et bon codage !

Credits: Image by storyset