Stosowanie SOLID zasad w Python: Przykłady i najlepsze praktyki

Single Responsibility Principle(SRP)

Zasada ta mówi, że każda klasa powinna mieć jedną odpowiedzialność. Podkreśla, że ​​klasa powinna pełnić jedną określoną funkcję i nie mieć zbyt wielu powodów do zmian.

Przykład: Zarządzanie informacjami o użytkownikach i wysyłanie powiadomień e-mail.

class UserManager:  
    def create_user(self, user_data):  
        # Logic for creating a user  
        pass  
  
class EmailService:  
    def send_email(self, email_data):  
        # Logic for sending an email  
        pass  

Open/Closed Principle(OCP)

Ta zasada zachęca do rozszerzania funkcjonalności przez dodawanie nowego kodu zamiast modyfikowania istniejącego kodu.

Przykład: obsługa różnych metod płatności w aplikacji e-commerce.

from abc import ABC, abstractmethod  
  
class PaymentProcessor(ABC):  
    @abstractmethod  
    def process_payment(self):  
        pass  
  
class CreditCardPaymentProcessor(PaymentProcessor):  
    def process_payment(self):  
        # Logic for processing credit card payment  
        pass  
  
class PayPalPaymentProcessor(PaymentProcessor):  
    def process_payment(self):  
        # Logic for processing PayPal payment  
        pass  

Liskov Substitution Principle(LSP)

Zasada ta zakłada, że ​​obiekty klasy pochodnej powinny być zastępowalne obiektami klasy bazowej bez wpływu na poprawność programu.

Przykład: Zarządzanie kształtami geometrycznymi.

class Shape:  
    def area(self):  
        pass  
  
class Rectangle(Shape):  
    def area(self):  
        return self.width * self.height  
  
class Square(Shape):  
    def area(self):  
        return self.side * self.side  

Interface Segregation Principle(ISP)

Ta zasada zaleca dzielenie interfejsów na mniejsze, aby uniknąć zmuszania klas do implementowania metod, których nie potrzebują.

Przykład: Interfejsy do aktualizacji i wyświetlania danych.

class UpdateableFeature:  
    @abstractmethod  
    def update_feature(self):  
        pass  
  
class DisplayableFeature:  
    @abstractmethod  
    def display_feature(self):  
        pass  

Dependency Inversion Principle(DIP)

Ta zasada sugeruje użycie iniekcji zależności do zarządzania zależnościami.

Przykład: Używanie wstrzykiwania zależności do zarządzania zależnościami.

class OrderProcessor:  
    def __init__(self, db_connection, email_service):  
        self.db_connection = db_connection  
        self.email_service = email_service  

Pamiętaj, że stosowanie SOLID zasad w Python powinno odbywać się elastycznie, w oparciu o konkretny cel twojego projektu oraz twoje zrozumienie SOLID i Python.