Direkt zum Inhalt

Private Methoden in Python erklärt

Erfahre mehr über private Methoden in Python, ihre Syntax, wie und wann du sie in deinen Projekten einsetzen kannst, und lerne anhand von Beispielen die besten Methoden kennen.
Aktualisierte 16. Jan. 2025  · 9 Min. Lesezeit

In der objektorientierten Programmierung (OOP), einem Softwareentwicklungsansatz, verwenden wir "Objekte", um reale Entitäten zu modellieren. Ein Objekt ist eine Datenstruktur mit Attributen (Daten) und Methoden (Funktionen), die auf diese Daten wirken. Komplexe Systeme lassen sich leichter mit Objekten entwerfen.

Erfahre mehr über die Grundlagen und Software-Engineering-Konzepte, die hinter OOP stehen, indem du unseren Kurs zur objektorientierten Programmierung mit Python beginnst.

Kapselung ist ein grundlegendes Konzept in der OOP. Es bedeutet, die Daten und Methoden eines Objekts zu gruppieren und die Details vor der Außenwelt zu verbergen. Betrachte die Verkapselung als einen Prozess, der eine "Kapsel" (ein Objekt) mit eigenen Daten und Möglichkeiten zu deren Bearbeitung schafft.

Der Hauptzweck der Verkapselung ist:

  • Verhindere den direkten Zugriff auf die Daten (Datenintegrität).
  • Vereinfache das System, indem du nur das Nötigste zeigst (Abstraktion).

Private Methoden sind der Schlüssel, um diese Kapselung zu erreichen, indem sie die internen Implementierungsdetails einer Klasse verbergen.

Indem du eine Methode privat machst, sagst du anderen Programmierern, dass auf diese Methode nicht direkt zugegriffen werden soll. So können Bugs und Fehler vermieden werden, indem sichergestellt wird, dass der interne Zustand eines Objekts nur auf kontrollierte Weise geändert werden kann.

Hier werden wir private Methoden, die Syntax für ihre Definition, die Implementierung privater Methoden in realen Beispielen und die besten Praktiken für ihre Verwendung vorstellen.

Was sind private Methoden?

Private Methoden in der objektorientierten Programmierung (OOP) sind Funktionen innerhalb einer Klasse, die nur für den internen Gebrauch bestimmt sind. Sie kapseln die Funktionalität einer Klasse und stellen sicher, dass ihre internen Abläufe von externen Interaktionen abgeschirmt bleiben.

Diese Kapselung bietet eine Abstraktionsebene, die es der Klasse ermöglicht, die Kontrolle über ihren internen Zustand und ihr Verhalten zu behalten und ihre Implementierung zu ändern, ohne dass sich dies auf den externen Code auswirkt, der auf sie angewiesen ist.

In Python werden private Methoden üblicherweise mit einem einfachen Unterstrich (_) oder einem doppelten Unterstrich (__) vor dem Methodennamen gekennzeichnet. Dies dient den Entwicklern als Hinweis auf den beabsichtigten Anwendungsbereich der Methode und ist lediglich eine Konvention.

Obwohl diese Konvention keine strenge Geheimhaltung wie in anderen Sprachen erzwingt, ist sie in der Python-Gemeinschaft eine anerkannte Praxis, um die beabsichtigte Verwendung der Methode zu signalisieren. Später werden wir uns mit diesen Aspekten ausführlicher befassen.

Die Syntax der privaten Methoden

Es gibt zwei verschiedene Möglichkeiten, private Methoden zu definieren, die wir anhand von Beispielen sehen werden.

Wir können eine private Methode mit einem einzelnen Unterstrich vor dem Funktionsnamen definieren:

class MyClass:
   def _private_method(self):
       print("This is a private method")

Diese Definition ist lediglich eine Konvention für die Programmierer, da die Funktion auch außerhalb der Klasse zugänglich ist, obwohl sie nicht empfohlen wird.

Wenn du zum ersten Mal von Klassen in Python hörst, empfehlen wir dir, zuerst unser anfängerfreundliches Tutorial über Klassen zu lesen.

Lass uns ein Objekt erstellen und versuchen, auf die erstellte private Methode zuzugreifen:

# Creating an object
obj = MyClass()

# Accessing from outside
obj._private_method()  # Not recommended to call directly, but possible

Es gibt eine andere Syntax für die Definition privater Methoden in Python, die doppelte Unterstriche verwendet. Es sieht so aus: :

class MyClass:
   def __private_method(self):
       print("This is a private method")

obj = MyClass()
# obj.__private_method()  # This will raise an AttributeError

Wenn wir versuchen, von außerhalb der Klasse auf die private Methode zuzugreifen, wird ein AttributeError ausgelöst, der besagt, dass der direkte Zugriff über den Funktionsnamen nicht möglich ist.

Um die Syntax der privaten Methoden in Python zusammenzufassen:

  • Einfacher Unterstrich: lediglich eine Konvention für die Programmierer, kann außerhalb der Funktion aufgerufen werden.
  • Doppelter Unterstrich: kann nicht außerhalb der Funktion nur mit dem Funktionsnamen aufgerufen werden. Es kann immer noch durch "Name Mangling" erreicht werden, was wir später in diesem Tutorial sehen werden.

Private Methoden in Python implementieren

Ein Beispiel aus der Praxis ist eine sichere und benutzerfreundliche Klasse BankAccount, die Finanztransaktionen für einen Nutzer verwaltet. Die Anforderungen an Bankkonten sind:

  • Die Klasse muss den Kontostand des Kontoinhabers kapseln, Einzahlungen und Abhebungen ermöglichen und gleichzeitig sicherstellen, dass der Kontostand nicht direkt außerhalb der Klasse manipuliert werden kann.
  • Die Klasse sollte sichere Überweisungen zwischen Konten ermöglichen und den Saldo des Empfängerkontos aktualisieren, ohne den internen Mechanismus zur Änderung des Saldos offenzulegen.
  • Die Lösung muss sich an die Grundsätze der objektorientierten Programmierung halten, insbesondere an die Kapselung und Abstraktion, um die Integrität der Kontodaten zu wahren und eine klare, einfache Schnittstelle für die Interaktion mit dem Konto bereitzustellen.

Natürlich braucht ein Bankkonto noch weitere Funktionen wie die Überprüfung des Kontostands, die Währungsumrechnung und die Handhabung von Zinsen - aber um die Dinge einfach zu halten, ignorieren wir diese in unserer Implementierung.

Lass uns diese Lösung umsetzen und den Code verstehen.

class BankAccount:
   def __init__(self, account_holder, initial_balance=0):
       self.account_holder = account_holder
       self.__balance = initial_balance  # Private attribute

   def deposit(self, amount):
       if amount > 0:
           self.__balance += amount
           print(f"Deposited ${amount}. New balance: ${self.__balance}")
       else:
           print("Deposit amount must be positive.")

   def withdraw(self, amount):
       if 0 < amount <= self.__balance:
           self.__balance -= amount
           print(f"Withdrew ${amount}. New balance: ${self.__balance}")
       else:
           print("Insufficient funds or invalid amount.")

   def __update_balance(self, amount):  # Private method
       self.__balance += amount

   def transfer(self, amount, other_account):
       if 0 < amount <= self.__balance:
           self.withdraw(amount)
           other_account.__update_balance(amount)
           print(f"Transferred ${amount} to {other_account.account_holder}.")
       else:
           print("Insufficient funds or invalid amount.")

Zuerst erstellen wir ein BankAccountclass, das alle vorgesehenen Verhaltensweisen und Funktionen eines BankAccount-Objekts enthält.

Die Klasse BankAccount hat ein privates Attribut __balance und eine private Methode __update_balance:

  • Private Variable (__balance): Dies ist ein Attribut der Klasse BankAccount, das den aktuellen Kontostand speichert. Er wird als privat gekennzeichnet, indem seinem Namen zwei Unterstriche vorangestellt werden (__). Das bedeutet, dass nur innerhalb der Klasse selbst auf sie zugegriffen werden soll. Sie wird zum Beispiel durch die Methoden deposit, withdraw und __update_balance verändert. Ein externer Zugriff auf dieses Attribut wird nicht empfohlen.
  • Private Methode (__update_balance): Der Zweck dieser Methode ist es, den Kontostand zu aktualisieren. Sie wird von der Methode transfer aufgerufen, um den Saldo des Empfängerkontos während eines Überweisungsvorgangs zu aktualisieren. Die Verwendung einer privaten Methode hilft dabei, die Logik für die Aktualisierung des Kontostands zu kapseln und sicherzustellen, dass sie nur auf kontrollierte, von der Klasse definierte Weise durchgeführt werden kann.

Erstelle einfach eine neue Python-Datei, kopiere den Code oben und unten und führe ihn aus, um ihn selbst zu sehen.

# Using the Bank Account Solution
account1 = BankAccount("John Doe", 1000)
account2 = BankAccount("Jane Doe", 500)

account1.deposit(200)
account1.withdraw(100)
account1.transfer(300, account2)

Du siehst die folgende Ausgabe:

Deposited $200. New balance: $1200
Withdrew $100. New balance: $1100
Withdrew $300. New balance: $800
Transferred $300 to Jane Doe.

Herzlichen Glückwunsch! Du hast deine BankAccount-Lösung mit einer privaten Methode erstellt!

Anhand der Ausgabe sehen wir, dass bei der Durchführung der üblichen Bankgeschäfte wie Einzahlungen, Abhebungen und Überweisungen das übliche logische Verhalten eines Bankkontos befolgt wird.

Die Methode __init__: Ist sie eine private Methode?

Dir ist wahrscheinlich die Methode __init__ aufgefallen, die im Beispiel des Bankkontos verwendet wurde. Da sie auch die Syntax der doppelten Unterstriche verwendet, fragst du dich vielleicht, ob sie auch eine private Methode ist.

Die Methode __init__ wird nicht als private Methode betrachtet, so wie Methoden, die mit einem doppelten Unterstrich für Privatsphäre gekennzeichnet sind.

Stattdessen ist er Teil spezieller Methoden in Python, die oft als "dunder"-Methode (kurz für "doppelter Unterstrich") bezeichnet werden und einen bestimmten Zweck in der Sprache haben. Andere Beispiele für solche speziellen Methoden sind __str__, __repr__ und __del__.

Lass uns verstehen, wie diese spezielle Methode in unserem Beispiel angewendet wurde:

class BankAccount:
   def __init__(self, account_holder, initial_balance=0):
       self.account_holder = account_holder
       self.__balance = initial_balance

Wie wir sehen, ist die Methode __init__ der Konstruktor für eine Klasse. Sie wird automatisch aufgerufen, wenn eine neue Instanz der Klasse erstellt wird, und sie wird verwendet, um die Attribute des Objekts zu initialisieren. Für die Klasse BankAccount wird die Methode __init__ verwendet, um die Anfangswerte für die Attribute account_holder und __balance festzulegen.

Fortgeschrittene Konzepte: Name Mangling in Python

Weiter oben in unserer Definition haben wir bereits erwähnt, dass private Methoden in Python lediglich eine Konvention sind und die Sprache Python im Gegensatz zu anderen Programmiersprachen keine strenge Privatsphäre vorschreibt.

Richtig, wir haben gesehen, dass auf die privaten Methoden direkt zugegriffen werden kann, wenn ein einfacher Unterstrich verwendet wird, aber der Zugriff ist eingeschränkt, wenn ein doppelter Unterstrich verwendet wird.

Aber warum? Aufgrund eines Konzepts, das in Python "Name Mangling" genannt wird.

Wenn du einem Attributnamen doppelte Unterstriche voranstellst, ändert Python den Namen automatisch, indem es einen einfachen Unterstrich und den Klassennamen vor dem ursprünglichen Attributnamen hinzufügt.

Dieser geänderte Name gibt an, wie das Attribut intern in der Klasse gespeichert wird. Der Prozess, bei dem der Name auf diese Weise verändert wird, wird als Namensmanipulation bezeichnet.

Das Mangeln von Namen ist aus zwei Gründen nützlich:

  • Verhinderung von Namenskonflikten: Wenn bei der Vererbung eine Unterklasse ein Attribut mit demselben Namen definiert wie ein Attribut in ihrer Oberklasse, würden die beiden in Konflikt geraten. Das Mangeln von Namen hilft, dieses Problem zu vermeiden, indem sichergestellt wird, dass die Namen für jede Klasse eindeutig sind.
  • Ein gewisses Maß an Privatsphäre: In Python gibt es zwar keine wirklich privaten Attribute, aber durch das Mangeln von Namen können Attribute von außerhalb der Klasse weniger zugänglich gemacht werden und bieten so ein gewisses Maß an Privatsphäre.

Lass uns ein Beispiel ansehen, um es besser zu verstehen.

class MyClass:
   def __init__(self):
       self.__private_attribute = "I am private"

   def __private_method(self):
       print("This is a private method")

obj = MyClass()
print(obj.__private_attribute)  # This will raise an AttributeError

In diesem Beispiel werden die Namen __private_attribute und __private_method vermischt. Intern werden sie als _MyClass__private_attribute bzw. _MyClass__private_method gespeichert. Der Versuch, von außerhalb der Klasse auf sie mit ihren ursprünglichen Namen zuzugreifen, führt zu einer AttributeError.

Du kannst sie aber immer noch mit ihrem geänderten Namen aufrufen:

print(obj._MyClass__private_attribute)  # This will print "I am private"
obj._MyClass__private_method()  # This will print "This is a private method"

Auch wenn die Namensvermischung die Zugänglichkeit von Attributen verringert, ist es wichtig zu wissen, dass dies kein sicherer Weg ist, um den Datenschutz in Python zu gewährleisten. Es ist eher eine Konvention, um anzuzeigen, dass ein Attribut für die interne Verwendung innerhalb der Klasse bestimmt ist.

Best Practices für die Verwendung privater Methoden und Variablen

Um private Methoden und Variablen effektiv zu nutzen, müssen bestimmte Best Practices eingehalten werden. Diese Praktiken tragen dazu bei, dass dein Code nicht nur funktional, sondern auch klar, wartbar und sicher ist.

Hier sind einige Best Practices, die du befolgen solltest:

  • Verwende einen einfachen Unterstrich für "Geschützte" Attribute. Wenn du angeben möchtest, dass ein Attribut oder eine Methode für die Verwendung innerhalb der Klasse und ihrer Unterklassen, aber nicht für die externe Verwendung bestimmt ist, stellst du einen einfachen Unterstrich (_) voran. Dies ist eine Konvention in Python, die anderen Entwicklern signalisiert, dass das Attribut oder die Methode "geschützt" ist und nicht direkt aufgerufen werden darf.
  • Verwende einen doppelten Unterstrich für "Private" Attribute. Wenn du ein Attribut oder eine Methode außerhalb der Klasse weniger zugänglich machen willst, um eine versehentliche Änderung oder Verwendung zu vermeiden, stellst du ihr einen doppelten Unterstrich (__) voran. Dies führt zu einer Vermischung der Namen und macht es schwieriger (aber nicht unmöglich), auf das Attribut oder die Methode von außerhalb der Klasse zuzugreifen.
  • Verwende private Methoden für die interne Logik. Private Methoden (die mit einem einfachen oder doppelten Unterstrich versehen sind) sind eine gute Möglichkeit, die interne Logik deiner Klasse zu kapseln. Verwende sie, um Aufgaben auszuführen, die spezifisch für die Implementierung der Klasse sind und nicht als Teil der öffentlichen Schnittstelle der Klasse offengelegt werden sollten.

Schließlich ist es wichtig, dass du dich an die bewährten Verfahren für die Codierung hältst. Halte dich an die Namenskonventionen und verwende sie konsequent in deiner gesamten Codebasis. Dadurch wird dein Code für andere Entwickler und für dich selbst leichter verständlich und wartbar.

Fazit

In diesem Tutorium hast du die Konzepte hinter privaten Methoden, ihre Syntax und ihre Einsatzmöglichkeiten kennengelernt. Wir haben auch mehrere Beispiele gesehen, die zeigen, wie du sie in deinem nächsten Programmierprojekt einsetzen kannst. Schließlich haben wir uns einige bewährte Praktiken angeschaut, die du bei ihrer Verwendung beachten solltest.

Wenn du dich weiterbilden möchtest, kannst du dir den Lernpfad Python-Programmierung und den Kurs Objektorientierte Programmierung in Python ansehen.


Arunn Thevapalan's photo
Author
Arunn Thevapalan
LinkedIn
Twitter

Als Senior Data Scientist konzipiere, entwickle und implementiere ich umfangreiche Machine-Learning-Lösungen, um Unternehmen dabei zu helfen, bessere datengestützte Entscheidungen zu treffen. Als Data-Science-Autorin teile ich Erfahrungen, Karrieretipps und ausführliche praktische Anleitungen.

Themen

Setze deine Python-Lernreise fort!

Zertifizierung verfügbar

Kurs

Datenschutz und Anonymisierung in Python

4 hr
3K
Lerne, sensible Informationen mit Techniken zu verarbeiten, die die Privatsphäre schützen.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow