Zugriffsmodifikatoren

Teil des Abschnitts Objektorientierte Programmierung der Python-Journey von Coddy. Lektion 29 von 64.

Zugriffsmodifikatoren steuern die Sichtbarkeit von Klassenattributen und -methoden. Python verwendet Namenskonventionen anstelle von Schlüsselwörtern für die Zugriffskontrolle.

Hier ist ein Beispiel für öffentlichen Zugriff (kein Präfix):

class Person:
    def __init__(self):
        self.name = "Coddy"      # Öffentliches Attribut
        
    def greet(self):             # Öffentliche Methode
        return f"Hello, I'm {self.name}"

Greifen Sie von überall auf öffentliche Member zu:

person = Person()
print(person.name)           # Coddy
print(person.greet())        # Hello, I'm Coddy

Hier ist ein Beispiel für geschützten Zugriff (einfacher Unterstrich):

class Employee:
    def __init__(self):
        self._salary = 50000     # Geschütztes Attribut
    
    def _calculate_bonus(self):  # Geschützte Methode
        return self._salary * 0.1

    def show_bonus(self):
        return self._calculate_bonus()  # Verwendung innerhalb der Klasse ist OK

Zugriff auf geschützte Member (funktioniert, wird aber nicht empfohlen):

employee = Employee()
print(employee._salary)      # 50000 - funktioniert, wird aber nicht empfohlen
print(employee.show_bonus()) # 5000.0 - korrekte Vorgehensweise

Hier ist ein Beispiel für privaten Zugriff (doppelter Unterstrich):

class User:
    def __init__(self):
        self.__password = "secure123"   # Privates Attribut
        
    def __encrypt(self, data):          # Private Methode
        return f"Encrypted: {data}"
        
    def verify(self, input_password):
        # Private Member sind innerhalb der Klasse zugänglich
        return input_password == self.__password

Verwende private Mitglieder korrekt:

user = User()
print(user.verify("secure123"))  # True - Verwendung der öffentlichen Methode
# print(user.__password)         # AttributeError - kein direkter Zugriff möglich

Ausgabe:

Coddy
Hello, I'm Coddy
50000
5000.0
True

Wichtiger Punkt: Python-Zugriffsmodifikatoren sind Namenskonventionen: kein Präfix = öffentlich (überall zugänglich), einzelner Unterstrich = geschützt (interne Verwendung), doppelter Unterstrich = privat (nur innerhalb der Klasse). Sie helfen dabei, klare Grenzen zu schaffen und eine versehentliche missbräuchliche Verwendung von Klasseninterna zu verhindern.

Aufgabe

Mittel

In dieser Herausforderung implementierst du eine FileManager-Klasse, die Pythons Zugriffsmodifikatoren (öffentlich, geschützt und privat) veranschaulicht und dir gleichzeitig die Vorteile umfassender Tests nahebringt.

Bearbeite filemanager.py, um die FileManager-Klasse gemäß den TODO-Kommentaren zu implementieren. Die Datei enthält detaillierte Anweisungen zur Implementierung von:

Öffentlichen Methoden für Dateioperationen
Geschützten Methoden (mit einfachem Unterstrichpräfix)
Privaten Methoden (mit doppeltem Unterstrichpräfix)
Methodeninteraktionen zur Veranschaulichung der Kapselung

Probier es selbst

from file_manager import FileManager

# Umfassender Testfall-Handler
test_case = input()

if test_case == "basic_test":
    # Erstelle eine FileManager-Instanz
    manager = FileManager()
    # Rufe die Methode read_file auf
    print(manager.read_file("example.txt"))
    # Rufe die Methode get_file_content auf
    print(manager.get_file_content("example.txt"))

elif test_case == "protected_access":
    # Erstelle eine FileManager-Instanz
    manager = FileManager()
    # Versuche, die geschützte Methode aufzurufen
    # Geschützte Methoden sind zugänglich, aber für den internen Gebrauch gedacht
    print(manager._check_permissions("example.txt"))
    print("Note: Protected methods are accessible but intended for internal use only")

elif test_case == "private_access":
    # Erstelle eine FileManager-Instanz
    manager = FileManager()
    try:
        # Versuche, die private Methode direkt aufzurufen
        print(manager.__decrypt_content("some content"))
    except AttributeError as e:
        print(f"Error: {e}")
        print("Private methods are name-mangled and cannot be accessed directly")
    
    # Zugriff über die Name-Mangling-Form
    print(manager._FileManager__decrypt_content("some content"))
    print("Note: Accessed private method using name-mangled form")

elif test_case == "method_chaining":
    # Erstelle eine FileManager-Instanz
    manager = FileManager()
    # Demonstriere, wie get_file_content intern sowohl geschützte als auch private Methoden aufruft
    print("Calling get_file_content which internally uses protected and private methods:")
    print(manager.get_file_content("example.txt"))

elif test_case == "multiple_files":
    # Erstelle eine FileManager-Instanz
    manager = FileManager()
    # Verarbeite mehrere Dateien
    files = ["document.txt", "image.jpg", "data.csv"]
    
    for file in files:
        print(f"\
Processing {file}:")
        print(manager.read_file(file))
        print(manager.get_file_content(file))

elif test_case == "name_mangling":
    # Erstelle eine FileManager-Instanz
    manager = FileManager()
    # Demonstriere Name-Mangling
    print("Python's name mangling for private methods:")
    print("Attempting direct access would fail with AttributeError")
    print("Using mangled name:")
    print(manager._FileManager__decrypt_content("private data"))
    print("\
Name mangling is Python's mechanism to prevent accidental access")
    print("It renames __method to _ClassName__method internally")