SOLID-Prinzipien anhand von Python-Beispielen verstehen

SOLID-Prinzipien anhand von Python-Beispielen verstehen

Die SOLID-Prinzipien sind eine Reihe von Designprinzipien, die Entwicklern helfen, besser wartbare und skalierbare Software zu erstellen. Lassen Sie uns jedes Prinzip anhand kurzer Python-Beispiele aufschlüsseln.

1. Single-Responsibility-Prinzip (SRP)

Eine Klasse sollte nur einen Grund haben, sich zu ändern, das heißt, sie sollte nur eine Aufgabe oder Verantwortung haben.

class Invoice:
    def __init__(self, items):
        self.items = items

    def calculate_total(self):
        return sum(item['price'] for item in self.items)

class InvoicePrinter:
    def print_invoice(self, invoice):
        for item in invoice.items:
            print(f"{item['name']}: ${item['price']}")
        print(f"Total: ${invoice.calculate_total()}")

# Usage
invoice = Invoice([{'name': 'Book', 'price': 10}, {'name': 'Pen', 'price': 2}])
printer = InvoicePrinter()
printer.print_invoice(invoice)

2. Offen/Geschlossen-Prinzip (OCP)

Software-Entitäten sollten zur Erweiterung geöffnet, aber zur Änderung geschlossen sein.

class Discount:
    def apply(self, amount):
        return amount

class TenPercentDiscount(Discount):
    def apply(self, amount):
        return amount * 0.9

# Usage
discount = TenPercentDiscount()
print(discount.apply(100))  # Output: 90.0

3. Liskov-Substitutionsprinzip (LSP)

Objekte einer Oberklasse sollten durch Objekte einer Unterklasse ersetzbar sein, ohne die Korrektheit des Programms zu beeinträchtigen.

class Bird:
    def fly(self):
        return "Flying"

class Sparrow(Bird):
    pass

class Ostrich(Bird):
    def fly(self):
        return "Can't fly"

# Usage
def make_bird_fly(bird: Bird):
    print(bird.fly())

sparrow = Sparrow()
ostrich = Ostrich()
make_bird_fly(sparrow)  # Output: Flying
make_bird_fly(ostrich)  # Output: Can't fly

4. Prinzip der Schnittstellentrennung (ISP)

Kunden sollten nicht gezwungen werden, sich auf Schnittstellen zu verlassen, die sie nicht nutzen.

class Printer:
    def print(self, document):
        pass

class Scanner:
    def scan(self, document):
        pass

class MultiFunctionPrinter(Printer, Scanner):
    def print(self, document):
        print(f"Printing: {document}")

    def scan(self, document):
        print(f"Scanning: {document}")

# Usage
mfp = MultiFunctionPrinter()
mfp.print("Document1")
mfp.scan("Document2")

5. Abhängigkeitsinversionsprinzip (DIP)

High-Level-Module sollten nicht von Low-Level-Modulen abhängen. Beide sollten von Abstraktionen abhängen.

class Database:
    def connect(self):
        pass

class MySQLDatabase(Database):
    def connect(self):
        print("Connecting to MySQL")

class Application:
    def __init__(self, db: Database):
        self.db = db

    def start(self):
        self.db.connect()

# Usage
db = MySQLDatabase()
app = Application(db)
app.start()  # Output: Connecting to MySQL

Diese Beispiele veranschaulichen die SOLID-Prinzipien auf prägnante Weise mithilfe von Python. Jedes Prinzip hilft beim Aufbau einer robusten, skalierbaren und wartbaren Codebasis.

Das obige ist der detaillierte Inhalt vonSOLID-Prinzipien anhand von Python-Beispielen verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!