Liskov Substitution Principle (LSP)

Understanding the Liskov Substitution Principle (LSP) in Python

Introduction to LSP

The Liskov Substitution Principle (LSP) is one of the five SOLID principles of object-oriented design, introduced by Barbara Liskov in 1987. The principle states that:

“Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.”

In simpler terms, if a class B is a subclass of class A, then instances of B should be able to replace instances of A without causing any errors. The subclass must honor the behavior expected from the superclass so that the program continues to work correctly when subclasses are used in place of their parent class.

Why is LSP Important?

The LSP ensures that class hierarchies are designed in a way that upholds the integrity of the system. Violating this principle can lead to code that is difficult to maintain, brittle, or produces unexpected behavior when dealing with inheritance.

Key Points of LSP

Subclasses must not violate the expectations set by the base class.
Subclasses must enhance, not break, the functionality of the base class.
Preconditions cannot be strengthened in a subclass, and postconditions cannot be weakened.

LSP in Python – A Practical Example

Let’s look at an example that demonstrates how LSP can be applied and violated.

Example 1: A Correct Implementation of LSP

Consider a system that models geometric shapes. We have a base class Rectangle and a subclass Square.

class Rectangle:
    def __init__(self, width: float, height: float):
        self._width = width
        self._height = height

    def set_width(self, width: float):
        self._width = width

    def set_height(self, height: float):
        self._height = height

    def get_area(self) -> float:
        return self._width * self._height

# Subclass: Square
class Square(Rectangle):
    def __init__(self, side_length: float):
        super().__init__(side_length, side_length)

    # Overriding set_width and set_height methods to keep the sides equal
    def set_width(self, width: float):
        self._width = width
        self._height = width

    def set_height(self, height: float):
        self._width = height
        self._height = height

class Rectangle:

def __init__(self, width: float, height: float):

self._width = width

self._height = height

def set_width(self, width: float):

self._width = width

def set_height(self, height: float):

self._height = height

def get_area(self) -> float:

return self._width * self._height

# Subclass: Square

class Square(Rectangle):

def __init__(self, side_length: float):

super().__init__(side_length, side_length)

# Overriding set_width and set_height methods to keep the sides equal

def set_width(self, width: float):

self._width = width

self._height = width

def set_height(self, height: float):

self._width = height

self._height = height

Explanation

The Rectangle class has two dimensions: width and height, and a method get_area() to calculate the area.
The Square class inherits from Rectangle but ensures that width and height remain the same by overriding the set_width() and set_height() methods.

This design maintains the integrity of the Rectangle class, and we can substitute Square wherever Rectangle is expected without breaking any behavior. Let’s test this:

def print_area(rect: Rectangle):
    print(f”Area: {rect.get_area()}”)

rect = Rectangle(4, 5)
print_area(rect)  # Output: Area: 20

square = Square(5)
print_area(square)  # Output: Area: 25

def print_area(rect: Rectangle):

print(f“Area: {rect.get_area()}”)

rect = Rectangle(4, 5)

print_area(rect) # Output: Area: 20

square = Square(5)

print_area(square) # Output: Area: 25

Both Rectangle and Square behave correctly when passed into the print_area() function, thus adhering to the Liskov Substitution Principle.

Example 2: Violating LSP

Let’s look at how LSP could be violated in the same example.

class Square(Rectangle):
    def __init__(self, side_length: float):
        super().__init__(side_length, side_length)

    def set_width(self, width: float):
        # Incorrectly change only width
        self._width = width

    def set_height(self, height: float):
        # Incorrectly change only height
        self._height = height

class Square(Rectangle):

def __init__(self, side_length: float):

super().__init__(side_length, side_length)

def set_width(self, width: float):

# Incorrectly change only width

self._width = width

def set_height(self, height: float):

# Incorrectly change only height

self._height = height

Here, we’ve violated the rule that the width and height of a square should always remain equal. If we now test this:

square = Square(5)
square.set_width(10)
print(square.get_area())  # Output: 50, which is incorrect for a square

square = Square(5)

square.set_width(10)

print(square.get_area()) # Output: 50, which is incorrect for a square

This produces incorrect behavior because setting the width does not automatically adjust the height, which violates the expected behavior of a square and breaks the LSP.

Conclusion

The Liskov Substitution Principle is crucial for designing robust class hierarchies. It ensures that subclasses can be used interchangeably with their parent classes without introducing errors or unexpected behavior. By following LSP, you enhance code maintainability, readability, and reduce the likelihood of bugs in an object-oriented system.

In the Python example, we saw how adhering to LSP allowed for proper substitution of a Square for a Rectangle and how violating it led to incorrect results.