Comprendre les principes SOLID avec des exemples Python

Comprendre les principes SOLID avec des exemples Python

Les principes SOLID sont un ensemble de principes de conception qui aident les développeurs à créer des logiciels plus maintenables et évolutifs. Décomposons chaque principe avec de brefs exemples Python.

1. Principe de responsabilité unique (SRP)

Une classe ne devrait avoir qu'une seule raison de changer, ce qui signifie qu'elle ne devrait avoir qu'un seul travail ou responsabilité.

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. Principe ouvert/fermé (OCP)

Les entités logicielles doivent être ouvertes pour extension mais fermées pour modification.

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. Principe de substitution de Liskov (LSP)

Les objets d'une superclasse doivent être remplaçables par des objets d'une sous-classe sans affecter l'exactitude du programme.

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. Principe de ségrégation d'interface (ISP)

Les clients ne devraient pas être obligés de dépendre d'interfaces qu'ils n'utilisent pas.

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. Principe d'inversion de dépendance (DIP)

Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Les deux devraient dépendre d’abstractions.

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

Ces exemples illustrent les principes SOLID de manière concise en utilisant Python. Chaque principe aide à créer une base de code robuste, évolutive et maintenable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!