Méthodes privées en Python

1. Le modificateur d’accès privé en Python
2. Déclarer une méthode privée en Python

Ce didacticiel montre comment déclarer, manipuler et utiliser des méthodes privées en Python.

private est un mot-clé pour un type de modificateur d’accès utilisé dans les langages de programmation orientés objet. Les modificateurs d’accès limitent la visibilité d’une fonction ou d’une variable dans une certaine mesure. Déclarer votre fonction/variable comme privée limite l’accès uniquement à la classe qui l’encapsule.

Une comparaison réelle avec une méthode privée serait un système d’éclairage domestique. L’interrupteur et l’ampoule sont comme des méthodes publiques car la personne y a un accès direct et une visibilité. Dans le même temps, les fils électriques à l’intérieur du caoutchouc de protection sont des méthodes privées car ils ne sont généralement pas visibles à moins d’être altérés, mais ils font toujours leur travail sans être surveillés pour la plupart.

Le modificateur d’accès privé en Python

En Python, les méthodes privées sont des méthodes qui ne sont pas accessibles en dehors de la classe dans laquelle elles sont déclarées ni à aucune autre classe de base.

Pour déclarer une méthode privée en Python, insérez des doubles traits de soulignement au début du nom de la méthode.

La méthode __init__()

Une méthode privée notable en Python est la méthode __init__(), qui est utilisée comme constructeur de classe pour un objet de classe. Cette méthode est appelée lorsqu’un objet d’une classe est instancié, en fonction des arguments de la méthode.

Par exemple, déclarez une classe Person avec deux champs et une méthode __init__() :

class Person:
    name = ""
    age = 0

    def __init__(self, n, a):
        self.name = n
        self.age = a

Maintenant, pour accéder à la méthode privée __init__() en dehors de la classe, nous aurions besoin qu’elle y accède depuis l’objet de la classe elle-même après l’avoir instanciée.

Par exemple, dans un autre fichier du même répertoire, créez une instance de la classe Person et appelez le constructeur en utilisant le nom de la classe.

from personClass import Person

sys.path.append(".")


person = Person("John Doe", 25)

print(person.name, person.age)

Production:

John Doe   25

La méthode __init__() peut être appelée explicitement après avoir instancié la classe Person dans une variable pour ré-instancier l’objet.

Par example:

person = Person("John Doe", 25)
person.__init__("Jane Doe", 29)

print(person.name, person.age)

Production:

Jane Doe   29

De plus, la méthode __init()__ peut être appelée explicitement en l’appelant depuis la classe elle-même. Bien que pour cette approche, vous auriez besoin de mettre explicitement le premier paramètre self dans les arguments.

person = Person("John Doe", 25)
Person.__init__(person, "Jack Sparrow", 46)  # person is the 'self' argument

print(person.name, person.age)

Production:

Jack Sparrow   46

Toutes ces approches conservent la propriété privée de la méthode __init__().

Maintenant que cette méthode intégrée a été disséquée. Passons à l’implémentation de nos propres méthodes privées dans une classe et à la différenciation de son accès par rapport à une méthode publique.

Déclarer une méthode privée en Python

Pour déclarer une méthode privée, préfixez la méthode en question avec des doubles traits de soulignement __. Sinon, elle sera traitée comme une méthode publique par défaut.

Étendons la classe Person de l’exemple précédent et créons une sous-classe Employee qui base son constructeur sur la classe Person.

Créez également deux nouvelles méthodes dans la classe person, une méthode publique et une méthode privée.

class Person:
    name = ""
    age = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def walk(self):
        print("Walking")

    def __call(self):
        print("Taking a call")

Maintenant, créez la classe dérivée ou la sous-classe Employee qui étend Person :

class Employee(Person):
    occupation = "Unemployed"
    salary = 0

    def __init__(self, name, age, occupation, salary):
        Person.__init__(self, name, age)
        self.occupation = occupation
        self.salary = salary

    def work(self):
        print("Employee is working")
        self.walk()

    def takeCall(self):
        self.__call()
        print("Employee is taking a call")

Dans cette classe, les méthodes work() et takeCall() appellent en externe les classes walk() et __call() de la classe parent Person, respectivement.

L’autre méthode appelle en externe une méthode publique et l’autre appelle une méthode privée à partir de leur classe parente. Voyons comment ce comportement fonctionne lorsque nous l’exécutons.

Par exemple, étant donné les déclarations de classe ci-dessus :

employee_1 = Employee("John Doe", 25, "Software Engineer", 40000)

employee_1.work()
employee_1.takeCall()

Production:

Employee is working
Walking
Traceback (most recent call last):
  File "python/demo.py", line 35, in <module>
    employee_1.takeCall()
  File "python/demo.py", line 29, in takeCall
    self.__call()
AttributeError: 'Employee' object has no attribute '_Employee__call'

L’appel à la méthode work() est exécuté avec succès, affichant les instructions des méthodes work() et walk(). Cependant, l’appel à takeCall() déclenche une AttributeError car il ne reconnaît pas la méthode __call() de la classe Person comme une méthode de la classe Employee. L’extension d’une classe à une autre classe n’inclut pas ses propres méthodes privées dans l’extension.

En résumé, les méthodes privées en Python sont déclarées en préfixant une méthode avec deux traits de soulignement, __. La déclaration de méthodes privées permet à une méthode d’être exclusivement réservée à la classe d’encapsulation. Une classe étendant une autre classe avec une méthode privée n’héritera pas de ces méthodes et déclenchera une erreur si elle essaie d’y accéder.