Private Methoden in Python

1. Der private Zugriffsmodifikator in Python
2. Deklarieren Sie eine private Methode in Python

Dieses Tutorial zeigt, wie Sie private Methoden in Python deklarieren, manipulieren und verwenden.

private ist ein Schlüsselwort für eine Art von Zugriffsmodifikator, der in objektorientierten Programmiersprachen verwendet wird. Zugriffsmodifikatoren schränken die Sichtbarkeit einer Funktion oder Variable bis zu einem gewissen Grad ein. Wenn Sie Ihre Funktion/Variable als privat deklarieren, wird der Zugriff nur auf die Klasse beschränkt, die sie kapselt.

Ein realer Vergleich mit einer privaten Methode wäre ein Heimbeleuchtungssystem. Der Lichtschalter und die Glühbirne sind wie öffentliche Methoden, da die Person direkten Zugang und Sichtbarkeit hat. Gleichzeitig sind die elektrischen Leitungen im Schutzgummi die privaten Methoden, da sie ohne Manipulation in der Regel nicht sichtbar sind, aber dennoch ihre Arbeit weitgehend unbeaufsichtigt verrichten.

Der private Zugriffsmodifikator in Python

In Python sind private Methoden Methoden, auf die weder außerhalb der Klasse, in der sie deklariert wurde, noch einer anderen Basisklasse zugegriffen werden kann.

Um eine private Methode in Python zu deklarieren, fügen Sie am Anfang des Methodennamens doppelte Unterstriche ein.

Die __init__()-Methode

Eine bemerkenswerte private Methode in Python ist die Methode __init__(), die als Klassenkonstruktor für ein Klassenobjekt verwendet wird. Diese Methode wird aufgerufen, wenn ein Objekt einer Klasse instanziiert wird, abhängig von den Argumenten der Methode.

Deklarieren Sie beispielsweise eine Klasse Person mit zwei Feldern und einer Methode __init__():

class Person:
    name = ""
    age = 0

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

Um nun auf die private Methode __init__() außerhalb der Klasse zuzugreifen, benötigen wir sie, um nach der Instanziierung vom Objekt der Klasse selbst darauf zuzugreifen.

Erstellen Sie beispielsweise in einer anderen Datei im selben Verzeichnis eine Instanz der Klasse Person und rufen Sie den Konstruktor mit dem Klassennamen auf.

from personClass import Person

sys.path.append(".")


person = Person("John Doe", 25)

print(person.name, person.age)

Ausgabe:

John Doe   25

Die Methode __init__() kann explizit aufgerufen werden, nachdem die Klasse Person in eine Variable instanziiert wurde, um das Objekt neu zu instanziieren.

Beispielsweise:

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

print(person.name, person.age)

Ausgabe:

Jane Doe   29

Außerdem kann die Methode __init()__ explizit aufgerufen werden, indem sie von der Klasse selbst aufgerufen wird. Für diesen Ansatz müssten Sie jedoch den ersten Parameter self explizit in die Argumente einfügen.

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

print(person.name, person.age)

Ausgabe:

Jack Sparrow   46

Alle diese Ansätze behalten das private Eigentum der Methode __init__().

Nun, da diese eingebaute Methode seziert wurde. Lassen Sie uns dazu übergehen, unsere eigenen privaten Methoden tatsächlich in eine Klasse zu implementieren und ihren Zugriff von einer öffentlichen Methode zu unterscheiden.

Deklarieren Sie eine private Methode in Python

Um eine private Methode zu deklarieren, stellen Sie der betreffenden Methode doppelte Unterstriche __ voran. Andernfalls wird sie als öffentliche Standardmethode behandelt.

Erweitern wir die Klasse Person aus dem vorherigen Beispiel und erstellen eine Unterklasse Employee, deren Konstruktor auf der Klasse Person basiert.

Erstellen Sie außerdem zwei neue Methoden innerhalb der Person-Klasse, eine öffentliche und eine private Methode.

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")

Erstellen Sie nun die abgeleitete Klasse oder Unterklasse Employee, die Person erweitert:

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")

In dieser Klasse rufen die Methoden work() und takeCall() extern die Klassen walk() bzw. __call() der Elternklasse Person auf.

Die andere Methode ruft extern eine öffentliche Methode auf, und die andere ruft eine private Methode ihrer Elternklasse auf. Sehen wir uns an, wie dieses Verhalten funktioniert, wenn wir es ausführen.

Angenommen, die Klassendeklarationen oben:

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

employee_1.work()
employee_1.takeCall()

Ausgabe:

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'

Der Aufruf der Methode work() wird erfolgreich ausgeführt und gibt die Anweisungen der Methode work() und walk() aus. Der Aufruf von takeCall() löst jedoch einen AttributeError aus, da er die Methode __call() der Klasse Person nicht als Methode der Klasse Employee erkennt. Das Erweitern einer Klasse auf eine andere Klasse schließt ihre eigenen privaten Methoden nicht in die Erweiterung ein.

Zusammenfassend lässt sich sagen, dass private Methoden in Python deklariert werden, indem einer Methode zwei Unterstriche vorangestellt werden, __. Durch die Deklaration privater Methoden kann eine Methode ausschließlich für die kapselnde Klasse reserviert werden. Eine Klasse, die eine andere Klasse mit einer privaten Methode erweitert, erbt diese Methoden nicht und löst einen Fehler aus, wenn sie versucht, darauf zuzugreifen.