What are the SOLID Principles?

SOLID is an acronym representing five foundational principles:

1. Single Responsibility Principle (SRP)
2. Open/Closed Principle (OCP)
3. Liskov Substitution Principle (LSP)
4. Interface Segregation Principle (ISP)
5. Dependency Inversion Principle (DIP)

These principles were introduced by Robert C. Martin (commonly known as Uncle Bob) and are essential for object-oriented design.

1. Single Responsibility Principle (SRP)

Definition: A class should have a single reason to change, meaning it should have one primary function or responsibility.

Example: Let’s take a look at a basic example of a class that manages book details:

class Book:

def __init__(self, title, author):

self.title = title

self.author = author

def get_book_info(self):

return f"{self.title} by {self.author}"

def save_book_to_file(self):

with open(f"{self.title}.txt", "w") as file:

file.write(self.get_book_info())

In this instance, the Book class is responsible for both managing book data and saving that data to a file. To comply with SRP, we should separate these functions into distinct classes.

Refactored: class Book:

def __init__(self, title, author):

self.title = title

self.author = author

def get_book_info(self):

return f"{self.title} by {self.author}"

class BookRepository:

def save_book_to_file(self, book):

with open(f"{book.title}.txt", "w") as file:

file.write(book.get_book_info())

Now, each class has a singular responsibility.

2. Open/Closed Principle (OCP)

Definition: Software entities (like classes, modules, functions, etc.) should be open for extension but closed for modification.

Example: Consider a class that computes the price of items using various discount strategies:

class PriceCalculator:

def calculate_price(self, item, discount_type):

if discount_type == "percentage":

return item.price * (1 - item.discount_rate)

elif discount_type == "fixed":

return item.price - item.discount_amount

Adding a new discount type necessitates modifying the PriceCalculator class, violating OCP.

Refactored: from abc import ABC, abstractmethod

class DiscountStrategy(ABC):

@abstractmethod

def calculate(self, price):

pass

class PercentageDiscount(DiscountStrategy):

def __init__(self, discount_rate):

self.discount_rate = discount_rate

def calculate(self, price):

return price * (1 - self.discount_rate)

class FixedDiscount(DiscountStrategy):

def __init__(self, discount_amount):

self.discount_amount = discount_amount

def calculate(self, price):

return price - self.discount_amount

class PriceCalculator:

def calculate_price(self, item, discount_strategy):

return discount_strategy.calculate(item.price)

Now, to introduce a new discount type, simply create another class inheriting from DiscountStrategy.

3. Liskov Substitution Principle (LSP)

Definition: Objects of a superclass should be interchangeable with objects of a subclass without compromising the program's correctness.

Example: Consider a class hierarchy for payment methods:

class Payment:

def pay(self, amount):

pass

class CreditCardPayment(Payment):

def pay(self, amount):

print(f"Paid {amount} using Credit Card")

class PayPalPayment(Payment):

def pay(self, amount):

print(f"Paid {amount} using PayPal")

class CashPayment(Payment):

def pay(self, amount):

raise Exception("Cash payments are not supported online")

Substituting CashPayment for Payment would cause the program to fail due to an exception being raised.

Refactored: class Payment(ABC):

@abstractmethod

def pay(self, amount):

pass

class CreditCardPayment(Payment):

def pay(self, amount):

print(f"Paid {amount} using Credit Card")

class PayPalPayment(Payment):

def pay(self, amount):

print(f"Paid {amount} using PayPal")

class OnlinePayment(Payment):

def pay(self, amount):

raise NotImplementedError("Online payments are not supported")

Now, all online payment methods inherit from Payment, while those that cannot will inherit from OnlinePayment, preventing incorrect usage.

4. Interface Segregation Principle (ISP)

Definition: Clients should not be compelled to depend on interfaces they do not utilize.

Example: Imagine an interface for a multifunction device:

class MultifunctionDevice:

def print(self, document):

pass

def scan(self, document):

pass

def fax(self, document):

pass

A basic printer that only prints would be required to implement methods it does not use.

Refactored: class Printer(ABC):

@abstractmethod

def print(self, document):

pass

class Scanner(ABC):

@abstractmethod

def scan(self, document):

pass

class Fax(ABC):

@abstractmethod

def fax(self, document):

pass

class SimplePrinter(Printer):

def print(self, document):

print("Printing document")

class MultiFunctionPrinter(Printer, Scanner, Fax):

def print(self, document):

print("Printing document")

def scan(self, document):

print("Scanning document")

def fax(self, document):

print("Faxing document")

Now, classes implement only the interfaces necessary for their functionality.

5. Dependency Inversion Principle (DIP)

Definition: High-level modules should not depend on low-level modules; both should depend on abstractions.

Example: Consider a class responsible for sending notifications:

class EmailService:

def send_email(self, message):

print("Sending email:", message)

class Notification:

def __init__(self):

self.email_service = EmailService()

def notify(self, message):

self.email_service.send_email(message)

Here, Notification is dependent on the concrete EmailService class.

Refactored: class MessageService(ABC):

@abstractmethod

def send_message(self, message):

pass

class EmailService(MessageService):

def send_message(self, message):

print("Sending email:", message)

class SMSService(MessageService):

def send_message(self, message):

print("Sending SMS:", message)

class Notification:

def __init__(self, message_service: MessageService):

self.message_service = message_service

def notify(self, message):

self.message_service.send_message(message)

Now, Notification relies on the MessageService abstraction, allowing for easy switching between services such as SMSService.

Conclusion

Grasping and implementing the SOLID principles can significantly enhance your code quality. By adhering to these principles, you can create software that is easier to maintain, extend, and understand. Begin incorporating these principles into your projects, and you'll observe a notable improvement in your code quality.

Happy coding!

Feel free to share any comments or questions below. If you found this article useful, please share it with other developers!