Lesson 6
Combining OOP Principles for Advanced Python Solutions
Introduction and Lesson Goal

Today's mission involves using multiple Object-Oriented Programming (OOP) principles to tackle complex tasks. When principles like Encapsulation, Abstraction, Polymorphism, and Composition are blended, the resulting code becomes streamlined and easier to manage.

Our goal is to dissect two real-world examples, gaining insights into how these principles can seamlessly orchestrate solutions.

Real-life Example 1: Building an Online Library System

Let's design an online library system, as we aim to reinforce our understanding of Encapsulation and Polymorphism. Encapsulation will help us protect the attributes of books, members, and transactions, making sure they are accessible in a controlled manner. Polymorphism will demonstrate its power by enabling a single interface to represent different underlying forms, such as digital and print versions of books.

Python
1# Base class for different types of library users
2class Member:
3    def __init__(self, name):
4        self.name = name
5
6    def check_out_book(self, book):
7        print(f"{self.name} checked out {book.get_book_type()} book {book.title}.")
8
9# Base class for different types of books
10class Book:
11    def __init__(self, title):
12        self.title = title
13
14    def get_book_type(self):
15        pass
16
17# Inherits from Book, represents a digital book
18class DigitalBook(Book):
19    def get_book_type(self):
20        return "Digital"
21
22# Inherits from Book, represents a physical book
23class PhysicalBook(Book):
24    def get_book_type(self):
25        return "Physical"
26
27# Library class that manages members and books
28class Library:
29    def __init__(self):
30        self.members = []
31        self.books = []
32
33    def add_member(self, member):
34        self.members.append(member)
35
36    def add_book(self, book):
37        self.books.append(book)
38
39my_library = Library()
40
41alice = Member("Alice")
42bob = Member("Bob")
43
44my_library.add_member(alice)
45my_library.add_member(bob)
46
47digital_book = DigitalBook("The Python Handbook")
48physical_book = PhysicalBook("Learning Python Design Patterns")
49
50my_library.add_book(digital_book)
51my_library.add_book(physical_book)
52
53alice.check_out_book(digital_book)  # Prints: Alice checked out Digital book The Python Handbook.
54bob.check_out_book(physical_book)   # Prints: Bob checked out Physical book Learning Python Design Patterns.

In this code snippet, Encapsulation is observed clearly through the class structures and the controlled access to their attributes. Polymorphism is vividly illustrated by how both DigitalBook and PhysicalBook classes inherit from the Book class but provide their own implementations of the get_book_type method. This setup allows objects of DigitalBook and PhysicalBook to be used interchangeably when a book's type needs to be identified, demonstrating polymorphism's capability to work with objects of different classes through a common interface.

  • Encapsulation ensures that details about members and books are well-contained within their respective classes.
  • Polymorphism showcases flexibility by treating different book types uniformly, making the system more adaptive and scalable.
Real-life Example 2: Building a Shape Drawing Application

Next, we'll develop a shape drawing application capable of drawing various shapes. For this, we'll employ the principles of Abstraction and Composition.

  • Abstraction simplifies the complexity associated with drawing different shapes.
  • Composition takes care of composite shapes.

Here's how we translate these principles into our shape drawing application:

Python
1# Define the basic Shape class
2class Shape:
3  # Abstract method that will be implemented in each subclass
4  def draw(self):
5    pass
6
7# Define the Circle class
8class Circle(Shape):
9  # Implement the draw method for circle
10  def draw(self):
11    print("Drawing a circle.")
12
13# Define the Square class
14class Square(Shape):
15  # Implement the draw method for square
16  def draw(self):
17    print("Drawing a square.")
18
19# Define the ShapeComposite class
20class ShapeComposite(Shape):
21  # Initialize with an empty list of shapes
22  def __init__(self):
23    self.shapes = []
24
25  # Add a new shape to the composite
26  def add_shape(self, shape):
27    self.shapes.append(shape)
28
29  # Implement the draw method to draw each shape in composite
30  def draw(self):
31    for shape in self.shapes:
32      shape.draw()
33
34circle = Circle()
35square = Square()
36
37# Drawing individual shapes
38circle.draw()  # Output: Drawing a circle.
39square.draw()  # Output: Drawing a square.
40
41# Create a ShapeComposite instance for composite shapes
42composite_shape = ShapeComposite()
43
44# Add individual shapes to the composite
45composite_shape.add_shape(circle)
46composite_shape.add_shape(square)
47
48# Drawing the composite shape
49composite_shape.draw()
50"""
51Output:
52Drawing a circle.
53Drawing a square.
54"""

This example unveils how Abstraction streamlines the process of drawing different shapes and Composition handles complex shapes.

Lesson Summary and Practice

Well done! You combined multiple OOP principles to respond to complex tasks. By dissecting real-world examples, we understood how these principles found their applications. Now, it's time to put this knowledge to work. Practice fortifies concepts, transforming knowledge into expertise. So, let's get coding!

Enjoy this lesson? Now it's time to practice with Cosmo!
Practice is how you turn knowledge into actual skills.