Introduction to the Composite Pattern in Python

Introduction to the Composite Pattern in Python | CodeSignal Learn

Introduction to the Composite Pattern

Welcome back! You have learned about the Adapter Pattern and how it helps make incompatible interfaces work together seamlessly. Now, let's dive into another crucial structural pattern that focuses on composition: the Composite Pattern. The Composite Pattern allows you to build complex structures by combining objects into tree-like structures to represent part-whole hierarchies. This pattern is particularly useful when dealing with applications like file systems, GUI frameworks, or organizational structures where you need to treat individual objects and compositions of objects uniformly.

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

To start with the Composite Pattern, we need to create an abstract class Employee . This class will define a method named show_details, which will be implemented by specific types of employees. Here’s the initial setup: Python from abc import ABC, abstractmethod class Employee(ABC): @abstractmethod def show_details(self): pass from abc import ABC, abstractmethod class Employee(ABC): @abstractmethod def show_details(self): pass The Employee class is abstract and cannot be instantiated. The show_details method is a placeholder that child classes will override.

Next, let's create a class for individual employees such as a developer. The Developer class will inherit from Employee and implement the show_details method: Pythonclass Developer(Employee): def __init__(self, name, position): self.name = name self.position = position def show_details(self): print(f"{self.name} works as {self.position}.")class Developer(Employee): def __init__(self, name, position): self.name = name self.position = position def show_details(self): print(f"{self.name} works as {self.position}.") In this step, the Developer class takes in a name and a position to describe the developer's details, and these details are printed whenever show_details is called.

To manage groups of employees, we create a Manager class. This class will also inherit from Employee but will contain a list to manage multiple employees: Python class Manager(Employee): def __init__(self): self.employees = [] def add(self, employee): self.employees.append(employee) def remove(self, employee): self.employees.remove(employee) class Manager(Employee): def __init__(self): self.employees = [] def add(self, employee): self.employees.append(employee) def remove(self, employee): self.employees.remove(employee) Here, the Manager class has methods to add and remove employees from its list. This allows the manager to manage a group of employees.

The Manager class will also implement the show_details method to display details of all employees it manages: Python class Manager(Employee): def __init__(self): self.employees = [] def add(self, employee): self.employees.append(employee) def remove(self, employee): self.employees.remove(employee) def show_details(self): for employee in self.employees: employee.show_details() class Manager(Employee): def __init__(self): self.employees = [] def add(self, employee): self.employees.append(employee) def remove(self, employee): self.employees.remove(employee) def show_details(self): for employee in self.employees: employee.show_details() This method iterates over all employees managed by the manager and calls their show_details method, ensuring that the details of every employee in the hierarchy are displayed.

Here is the complete code illustrating the Composite Pattern in an organizational structure: Pythonfrom abc import ABC, abstractmethod class Employee(ABC): @abstractmethod def show_details(self): pass class Developer(Employee): def __init__(self, name, position): self.name = name self.position = position def show_details(self): print(f"{self.name} works as {self.position}.") class Manager(Employee): def __init__(self): self.employees = [] def add(self, employee): self.employees.append(employee) def remove(self, employee): self.employees.remove(employee) def show_details(self): for employee in self.employees: employee.show_details()from abc import ABC, abstractmethod class Employee(ABC): @abstractmethod def show_details(self): pass class Developer(Employee): def __init__(self, name, position): self.name = name self.position = position def show_details(self): print(f"{self.name} works as {self.position}.") class Manager(Employee): def __init__(self): self.employees = [] def add(self, employee): self.employees.append(employee) def remove(self, employee): self.employees.remove(employee) def show_details(self): for employee in self.employees: employee.show_details()