Zusammenfassung – Bankkonto-Manager

Teil des Abschnitts Object Oriented Programming der Python-Journey von Coddy — Lektion 16 von 64.

Aufgabe

Mittel

Erstellen Sie eine vollständige BankAccount-Klasse, die objektorientierte Programmierkonzepte wie Klassenvariablen, private Attribute, Properties, Getter, Setter und Methoden demonstriert.

1. Erstellen Sie eine `BankAccount`-Klasse mit:

Einer Klassenvariable interest_rate, die auf 0.02 (2%) gesetzt ist
Privaten Instanzattributen für __owner_name und __balance
Einem Konstruktor, der diese Attribute initialisiert

2. Implementieren Sie Property-Getter und -Setter:

Einer schreibgeschützten Property owner_name, die den Namen des Kontoinhabers zurückgibt
Einer Property balance mit:
- Einem Getter, der den aktuellen Kontostand zurückgibt
- Einem Setter, der Einzahlungen validiert (negative Beträge ablehnt)
- Wenn die Validierung fehlschlägt, geben Sie Folgendes aus: "Balance cannot be negative"

3. Implementieren Sie Methoden:

deposit(amount), die:
- Zum Kontostand addiert, wenn der Betrag positiv ist
- "Deposit amount must be positive" ausgibt und False zurückgibt, wenn der Betrag nicht positiv ist
- Bei Erfolg True zurückgibt
withdraw(amount), die:
- Vom Kontostand abzieht, wenn der Betrag positiv ist und ausreichend Guthaben vorhanden ist
- "Withdrawal amount must be positive" ausgibt und False zurückgibt, wenn der Betrag nicht positiv ist
- "Insufficient funds" ausgibt und False zurückgibt, wenn der Betrag den Kontostand übersteigt
- Bei Erfolg True zurückgibt
apply_interest(), die:
- Zinsen basierend auf dem Zinssatz der Klasse zum Kontostand addiert
- Den Zinsbetrag zurückgibt

display_info(), die Kontodetails in diesem Format ausgibt:

Account Owner: [owner_name]
Balance: $[balance]
Interest Rate: [interest_rate]%

Anforderungen an das Ausgabeformat

Alle Validierungsfehlermeldungen müssen exakt wie angegeben ausgegeben werden
Die Methode display_info() muss die Ausgabe exakt wie oben gezeigt formatieren
Der Zinssatz sollte als Prozentsatz angezeigt werden (mit 100 multiplizieren)

Spickzettel

Eine vollständige Klasse, die Konzepte der objektorientierten Programmierung demonstriert:

class BankAccount:
    interest_rate = 0.02  # Klassenvariable
    
    def __init__(self, owner_name, initial_balance):
        self.__owner_name = owner_name  # Privates Attribut
        self.__balance = initial_balance  # Privates Attribut
    
    @property
    def owner_name(self):  # Schreibgeschützte Eigenschaft
        return self.__owner_name
    
    @property
    def balance(self):  # Getter
        return self.__balance
    
    @balance.setter
    def balance(self, value):  # Setter mit Validierung
        if value < 0:
            print("Balance cannot be negative")
        else:
            self.__balance = value
    
    def deposit(self, amount):
        if amount <= 0:
            print("Deposit amount must be positive")
            return False
        self.__balance += amount
        return True
    
    def withdraw(self, amount):
        if amount <= 0:
            print("Withdrawal amount must be positive")
            return False
        if amount > self.__balance:
            print("Insufficient funds")
            return False
        self.__balance -= amount
        return True
    
    def apply_interest(self):
        interest = self.__balance * self.interest_rate
        self.__balance += interest
        return interest
    
    def display_info(self):
        print(f"Account Owner: {self.__owner_name}")
        print(f"Balance: ${self.__balance}")
        print(f"Interest Rate: {self.interest_rate * 100}%")

Schlüsselkonzepte:

Klassenvariablen: Werden von allen Instanzen gemeinsam genutzt
Private Attribute: Verwenden Sie das Präfix mit doppeltem Unterstrich (__)
Eigenschaften (Properties): Verwenden Sie den @property-Dekorator für Getter
Setter: Verwenden Sie den @property_name.setter-Dekorator
Validierung: Bedingungen prüfen und Fehlermeldungen bereitstellen

Probier es selbst

from bank_account import BankAccount

# Testfall-Handler
test_case = input()

if test_case == "account_creation":
    # Teste Kontoerstellung
    account = BankAccount("Alice", 1000)
    print(f"Owner: {account.owner_name}")
    print(f"Initial balance: ${account.balance}")
    print(f"Interest rate: {BankAccount.interest_rate * 100}%")

elif test_case == "deposit_method":
    # Teste Einzahlungsfunktion
    account = BankAccount("Bob", 500)
    print(f"Initial balance: ${account.balance}")
    
    # Gültige Einzahlung
    result = account.deposit(300)
    print(f"Deposit result: {result}")
    print(f"New balance: ${account.balance}")
    
    # Ungültige Einzahlung
    result = account.deposit(-50)
    print(f"Negative deposit result: {result}")
    print(f"Balance after invalid deposit: ${account.balance}")

elif test_case == "withdraw_method":
    # Teste Auszahlungsfunktion
    account = BankAccount("Charlie", 1000)
    
    # Gültige Auszahlung
    result = account.withdraw(400)
    print(f"Withdrawal result: {result}")
    print(f"Balance after withdrawal: ${account.balance}")
    
    # Ungültige Auszahlung (negativ)
    result = account.withdraw(-50)
    print(f"Negative withdrawal result: {result}")
    
    # Ungültige Auszahlung (übersteigt Kontostand)
    result = account.withdraw(1000)
    print(f"Excessive withdrawal result: {result}")
    print(f"Final balance: ${account.balance}")

elif test_case == "property_access":
    # Teste Eigenschaftszugriff und Schutz
    account = BankAccount("Dave", 800)
    
    print(f"Owner via property: {account.owner_name}")
    print(f"Balance via property: ${account.balance}")
    
    # Versuche Kontostand zu setzen (sollte den Setter verwenden)
    account.balance = 1200
    print(f"Balance after valid setter: ${account.balance}")
    
    # Versuche ungültigen Kontostand
    account.balance = -500
    print(f"Balance after invalid setter: ${account.balance}")
    
    # Versuche direkt auf private Attribute zuzugreifen (sollte fehlschlagen)
    try:
        print(account.__owner_name)
    except AttributeError:
        print("Cannot access private owner_name directly")

elif test_case == "apply_interest":
    # Teste Zinsanwendung
    account = BankAccount("Eve", 2000)
    
    # Überprüfe ursprünglichen Kontostand
    print(f"Initial balance: ${account.balance}")
    
    # Zinsen anwenden
    interest_earned = account.apply_interest()
    expected_interest = 2000 * 0.02
    
    print(f"Interest earned: ${interest_earned}")
    print(f"New balance after interest: ${account.balance}")
    print(f"Interest calculation correct: {interest_earned == expected_interest}")

elif test_case == "display_info":
    # Teste Format der display_info Methode
    account = BankAccount("Frank", 1500)
    
    # Ändere Zinssatz, um Klassenvariable zu testen
    original_rate = BankAccount.interest_rate
    BankAccount.interest_rate = 0.03
    
    print("Display info output:")
    account.display_info()
    
    # Ursprünglichen Zinssatz wiederherstellen
    BankAccount.interest_rate = original_rate

elif test_case == "original_test_case":
    # Führe den ursprünglichen Testcode aus der Aufgabe aus
    account = BankAccount("Coddy", 1000)

    # Operationen durchführen
    account.deposit(500)
    account.withdraw(200)
    account.apply_interest()

    # Kontoinformationen anzeigen
    account.display_info()

    # Teste Setter-Validierung
    account.balance = 5000
    print(f"Balance after setter: ${account.balance}")

    # Teste Auszahlungs-Validierung
    account.withdraw(10000)
    print(f"Final balance: ${account.balance}")