| What Are Inheritance and Composition? | ||||||||||||||||
|
inheritance and composition are two major concepts in object-oriented programming they model the relationship between two classes they drive the design of an application and determine how the application should evolve as new features are added or requirements change both of them enable code reuse, but they do it in different ways What is Inheritance?
inheritance models what's called an 'is a' relationshipwhen a Derived class that inherits from a Base class, a relationship is created specialized version of Base What is Composition?
composition is a concept that models a 'has a' relationshipenables creating complex types by combining objects of other types class acts as a container |
||||||||||||||||
| An Overview of Inheritance in Python | ||||||||||||||||
The Object Super Class
create an empty class
>>> class EmptyClass: ... pass ...the dir() function returns a list of all the members in the specified object >>> c = EmptyClass() >>> dir(c) ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']the instance of EmptyClass is derived from object inherits the object class' members Exceptions Are an Exception
BaseException is a base class provided for all error typesto create a new error type, must derive from BaseException or one of its derived classes Python convention is to derive custom error types from Exception which in turn derives from BaseException >>> class AnError(Exception): ... pass ... >>> raise AnError() Traceback (most recent call last): ... AnError Creating Class Hierarchies
inheritance is the mechanism used to create hierarchies of related classesthe related classes will share a common interface that the base classes will define derived classes can specialize the interface by providing a particular implementation where applicable Modeling an HR System the HR system needs to process payroll for the company's employees there are different types of employees depending on how their payroll is calculated base class implementation class PayrollSystem:
def calculate_payroll(self, employees):
print("Calculating Payroll")
print("===================")
for employee in employees:
print(f"Payroll for: {employee.id} - {employee.name}")
print(f"- Check amount: {employee.calculate_payroll()}")
print("")
implement an Employee base class which handles the common interface for every employee type
# ...
class Employee:
def __init__(self, id, name):
self.id = id
self.name = name
system requires that every Employee processed must provide a .calculate_payroll() interface which
returns the employee's weekly salaryimplementation of the interface differs depending on the type of Employee # ...
class SalaryEmployee(Employee):
def __init__(self, id, name, weekly_salary):
# call the base class' c'tor
super().__init__(id, name)
self.weekly_salary = weekly_salary
def calculate_payroll(self):
return self.weekly_salary
the SalaryEmployee type's weekly salary is passed in the c'torno calculation is needed manufacturing workers who are paid by the hour add HourlyEmployee to the HR system # ...
class HourlyEmployee(Employee):
def __init__(self, id, name, hours_worked, hourly_rate):
super().__init__(id, name)
self.hours_worked = hours_worked
self.hourly_rate = hourly_rate
def calculate_payroll(self):
return self.hours_worked * self.hourly_rate
sales associates are paid through a fixed salary plus a commission based on their sales
# ...
class CommissionEmployee(SalaryEmployee):
def __init__(self, id, name, weekly_salary, commission):
super().__init__(id, name, weekly_salary)
self.commission = commission
def calculate_payroll(self):
fixed = super().calculate_payroll()
return fixed + self.commission
create mule named program.py
import hr salary_employee = hr.SalaryEmployee(1, "John Smith", 1500) hourly_employee = hr.HourlyEmployee(2, "Jane Doe", 40, 15) commission_employee = hr.CommissionEmployee(3, "Kevin Bacon", 1000, 250) payroll_system = hr.PayrollSystem() payroll_system.calculate_payroll([salary_employee, hourly_employee, commission_employee] )output $ python program.py Calculating Payroll =================== Payroll for: 1 - John Smith - Check amount: 1500 Payroll for: 2 - Jane Doe - Check amount: 600 Payroll for: 3 - Kevin Bacon - Check amount: 1250an instance of Employee passed to hr.PayrollSystem().calculate_payroll() will fail >>> import hr
>>> employee = hr.Employee(1, "Invalid")
>>> payroll_system = hr.PayrollSystem()
>>> payroll_system.calculate_payroll([employee])
Calculating Payroll
===================
Payroll for: 1 - Invalid
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Users/martin/hr.py", line 7, in calculate_payroll
print(f"- Check amount: {employee.calculate_payroll()}")
^^^^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'Employee' object has no attribute 'calculate_payroll'
an issue is if SalaryEmployee.calculate_payroll() is changed the
CommissionEmployee.calculate_payroll() may have to changebetter to rely on the already-implemented method in the base class and extend the functionality as needed Abstract Base Classes in Python
modify the implementation of the Employee class to ensure that it can't be instantiated
from abc import ABC, abstractmethod
# ...
class Employee(ABC):
def __init__(self, id, name):
self.id = id
self.name = name
@abstractmethod
def calculate_payroll(self):
pass
Implementation Inheritance vs Interface Inheritance
when one class is derived from another, the derived class inherits
class DisgruntledEmployee:
def __init__(self, id, name):
self.id = id
self.name = name
def calculate_payroll(self):
return 1_000_000
class PayrollSystem:
def calculate_payroll(self, employees):
print("Calculating Payroll")
print("===================")
for employee in employees:
print(f"Payroll for: {employee.id} - {employee.name}")
print(f"- Check amount: {employee.calculate_payroll()}")
print("")
class Employee:
def __init__(self, id, name):
self.id = id
self.name = name
class SalaryEmployee(Employee):
def __init__(self, id, name, weekly_salary):
super().__init__(id, name)
self.weekly_salary = weekly_salary
def calculate_payroll(self):
return self.weekly_salary
class HourlyEmployee(Employee):
def __init__(self, id, name, hours_worked, hourly_rate):
super().__init__(id, name)
self.hours_worked = hours_worked
self.hourly_rate = hourly_rate
def calculate_payroll(self):
return self.hours_worked * self.hourly_rate
class CommissionEmployee(SalaryEmployee):
def __init__(self, id, name, weekly_salary, commission):
super().__init__(id, name, weekly_salary)
self.commission = commission
def calculate_payroll(self):
fixed = super().calculate_payroll()
return fixed + self.commission
The Class Explosion Problem
class explosion problem - inheritance can lead to a huge hierarchical class structurehard to understand and maintain ProductivitySystem tracks productivity based on employee roles different employee roles
employees.py class Employee:
def __init__(self, id, name):
self.id = id
self.name = name
class SalaryEmployee(Employee):
def __init__(self, id, name, weekly_salary):
super().__init__(id, name)
self.weekly_salary = weekly_salary
def calculate_payroll(self):
return self.weekly_salary
class HourlyEmployee(Employee):
def __init__(self, id, name, hours_worked, hourly_rate):
super().__init__(id, name)
self.hours_worked = hours_worked
self.hourly_rate = hourly_rate
def calculate_payroll(self):
return self.hours_worked * self.hourly_rate
class CommissionEmployee(SalaryEmployee):
def __init__(self, id, name, weekly_salary, commission):
super().__init__(id, name, weekly_salary)
self.commission = commission
def calculate_payroll(self):
fixed = super().calculate_payroll()
return fixed + self.commission
hr.py
class PayrollSystem:
def calculate_payroll(self, employees):
print("Calculating Payroll")
print("===================")
for employee in employees:
print(f"Payroll for: {employee.id} - {employee.name}")
print(f"- Check amount: {employee.calculate_payroll()}")
print("")
update program.py to support the change
import hr
import employees
salary_employee = employees.SalaryEmployee(1, "John Smith", 1500)
hourly_employee = employees.HourlyEmployee(2, "Jane Doe", 40, 15)
commission_employee = employees.CommissionEmployee(3, "Kevin Bacon", 1000, 250)
payroll_system = hr.PayrollSystem()
payroll_system.calculate_payroll(
[salary_employee, hourly_employee, commission_employee]
)
can now add new classes to employees.py
# ...
class Manager(SalaryEmployee):
def work(self, hours):
print(f"{self.name} screams and yells for {hours} hours.")
class Secretary(SalaryEmployee):
def work(self, hours):
print(f"{self.name} expends {hours} hours doing office paperwork.")
class SalesPerson(CommissionEmployee):
def work(self, hours):
print(f"{self.name} expends {hours} hours on the phone.")
class FactoryWorker(HourlyEmployee):
def work(self, hours):
print(f"{self.name} manufactures gadgets for {hours} hours.")
create a file named productivity.py and add the ProductivitySytem class
class ProductivitySystem:
def track(self, employees, hours):
print("Tracking Employee Productivity")
print("==============================")
for employee in employees:
employee.work(hours)
print("")
the program works as expected but four new classes had to be added to support the changes
$ python program.py Tracking Employee Productivity ============================== Mary Poppins screams and yells for 40 hours. John Smith expends 40 hours doing office paperwork. Kevin Bacon expends 40 hours on the phone. Jane Doe manufactures gadgets for 40 hours. Calculating Payroll =================== Payroll for: 1 - Mary Poppins - Check amount: 3000 Payroll for: 2 - John Smith - Check amount: 1500 Payroll for: 3 - Kevin Bacon - Check amount: 1250 Payroll for: 4 - Jane Doe - Check amount: 600the class hierarchy is more complicated Inheriting Multiple Classes
the HR project needs another Employee class for temporary secretariesthe new TemporarySecretary class has characteristics of
# ...
class TemporarySecretary(Secretary, HourlyEmployee):
pass
edit program.py to include the new class
import hr
import employees
import productivity
manager = employees.Manager(1, "Mary Poppins", 3000)
secretary = employees.Secretary(2, "John Smith", 1500)
sales_guy = employees.SalesPerson(3, "Kevin Bacon", 1000, 250)
factory_worker = employees.FactoryWorker(4, "Jane Doe", 40, 15)
temporary_secretary = employees.TemporarySecretary(5, "Robin Williams", 40, 9)
company_employees = [
manager,
secretary,
sales_guy,
factory_worker,
temporary_secretary,
]
productivity_system = productivity.ProductivitySystem()
productivity_system.track(company_employees, 40)
payroll_system = hr.PayrollSystem()
payroll_system.calculate_payroll(company_employees)
running program.py results with
$ python program.py
Traceback (most recent call last):
File "/Users/martin/program.py", line 9, in <module>
temporary_secretary = employees.TemporarySecretary(5, "Robin Williams", 40, 9)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: SalaryEmployee.__init__() takes 4 positional arguments but 5 were given
the interpreter is trying to use Secretary.__init__() to initialize the objectreversing the order of base classes # ...
class TemporarySecretary(HourlyEmployee, Secretary):
pass
running program.py again
$ python program.py
Traceback (most recent call last):
File "/Users/martin/program.py", line 9, in <module>
temporary_secretary = employees.TemporarySecretary(5, "Robin Williams", 40, 9)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/Users/martin/employees.py", line 18, in __init__
super().__init__(id, name)
TypeError: SalaryEmployee.__init__() missing 1 required positional argument: 'weekly_salary'
Method Resolution Order (MRO)when a method or attribute of a class is accessed, Python uses the class MRO to find it the MRO is also used by super() to determine which method or attribute to invoke evaluate the TemporarySecretary class MRO using the interactive interpreter >>> from employees import TemporarySecretary >>> TemporarySecretary.__mro__ (<class 'employees.TemporarySecretary'>, <class 'employees.HourlyEmployee'>, <class 'employees.Secretary'>, <class 'employees.SalaryEmployee'>, <class 'employees.Employee'>, <class 'object'>)the MRO shows the order in which Python is going to look for a matching attribute or method this is what happens when the TemporarySecretary object is to be created
in this case want to skip the initialization of Secretary and SalaryEmployee do this by reversing the inheritance order again back to how it was initially then directly call HourlyEmployee.__init__() # ...
class TemporarySecretary(Secretary, HourlyEmployee):
def __init__(self, id, name, hours_worked, hourly_rate):
HourlyEmployee.__init__(self, id, name, hours_worked, hourly_rate)
reversing the order so Secretary is first changes the MRO output
>>> from employees import TemporarySecretary >>> TemporarySecretary.__mro__ (<class 'employees.TemporarySecretary'>, <class 'employees.Secretary'>, <class 'employees.SalaryEmployee'>, <class 'employees.HourlyEmployee'>, <class 'employees.Employee'>, <class 'object'>)explicitly specifying .__init__() should use HourlyEmployee.__init__(), is effectively skipping Secretary and SalaryEmployee in the MRO when initializing an object doing this allows a TemporarySecretary object to be created $ python program.py
Tracking Employee Productivity
==============================
...
Robin Williams expends 40 hours doing office paperwork.
Calculating Payroll
===================
...
Payroll for: 5 - Robin Williams
Traceback (most recent call last):
File "/Users/martin/program.py", line 22, in <module>
payroll_system.calculate_payroll(company_employees)
File "/Users/martin/hr.py", line 7, in calculate_payroll
print(f"- Check amount: {employee.calculate_payroll()}")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/Users/martin/employees.py", line 13, in calculate_payroll
return self.weekly_salary
^^^^^^^^^^^^^^^^^^
AttributeError: 'TemporarySecretary' object has no attribute 'weekly_salary'
override .calculate_payroll() in TemporarySecretary and invoke the right implementation from it
# ...
class TemporarySecretary(Secretary, HourlyEmployee):
def __init__(self, id, name, hours_worked, hourly_rate):
HourlyEmployee.__init__(self, id, name, hours_worked, hourly_rate)
def calculate_payroll(self):
return HourlyEmployee.calculate_payroll(self)
multiple inheritance can lead to the diamond problema type created with multiple inheritance where both inherited types have the same base class two different systems use the Employee class
class ProductivitySystem:
def track(self, employees, hours):
print("Tracking Employee Productivity")
print("==============================")
for employee in employees:
result = employee.work(hours)
print(f"{employee.name}: {result}")
print("")
class ManagerRole:
def work(self, hours):
return f"screams and yells for {hours} hours."
class SecretaryRole:
def work(self, hours):
return f"expends {hours} hours doing office paperwork."
class SalesRole:
def work(self, hours):
return f"expends {hours} hours on the phone."
class FactoryRole:
def work(self, hours):
return f"manufactures gadgets for {hours} hours."
add role classes to hr.py
class PayrollSystem:
def calculate_payroll(self, employees):
print("Calculating Payroll")
print("===================")
for employee in employees:
print(f"Payroll for: {employee.id} - {employee.name}")
print(f"- Check amount: {employee.calculate_payroll()}")
print("")
class SalaryPolicy:
def __init__(self, weekly_salary):
self.weekly_salary = weekly_salary
def calculate_payroll(self):
return self.weekly_salary
class HourlyPolicy:
def __init__(self, hours_worked, hourly_rate):
self.hours_worked = hours_worked
self.hourly_rate = hourly_rate
def calculate_payroll(self):
return self.hours_worked * self.hourly_rate
class CommissionPolicy(SalaryPolicy):
def __init__(self, weekly_salary, commission):
super().__init__(weekly_salary)
self.commission = commission
def calculate_payroll(self):
fixed = super().calculate_payroll()
return fixed + self.commission
edit the classes in employees.py
from hr import SalaryPolicy, CommissionPolicy, HourlyPolicy
from productivity import ManagerRole, SecretaryRole, SalesRole, FactoryRole
class Employee:
def __init__(self, id, name):
self.id = id
self.name = name
class Manager(Employee, ManagerRole, SalaryPolicy):
def __init__(self, id, name, weekly_salary):
SalaryPolicy.__init__(self, weekly_salary)
super().__init__(id, name)
class Secretary(Employee, SecretaryRole, SalaryPolicy):
def __init__(self, id, name, weekly_salary):
SalaryPolicy.__init__(self, weekly_salary)
super().__init__(id, name)
class SalesPerson(Employee, SalesRole, CommissionPolicy):
def __init__(self, id, name, weekly_salary, commission):
CommissionPolicy.__init__(self, weekly_salary, commission)
super().__init__(id, name)
class FactoryWorker(Employee, FactoryRole, HourlyPolicy):
def __init__(self, id, name, hours_worked, hourly_rate):
HourlyPolicy.__init__(self, hours_worked, hourly_rate)
super().__init__(id, name)
class TemporarySecretary(Employee, SecretaryRole, HourlyPolicy):
def __init__(self, id, name, hours_worked, hourly_rate):
HourlyPolicy.__init__(self, hours_worked, hourly_rate)
super().__init__(id, name)
|
||||||||||||||||
| Composition in Python | ||||||||||||||||
|
composition relationship between two classes is considered loosely coupled changes to the component class rarely affect the composite class changes to the composite class never affect the component class Employee has two attributes
contacts.py class Address:
def __init__(self, street, city, state, zipcode, street2=""):
self.street = street
self.street2 = street2
self.city = city
self.state = state
self.zipcode = zipcode
def __str__(self):
# provides a pretty representation of an Address
lines = [self.street]
if self.street2:
lines.append(self.street2)
lines.append(f"{self.city}, {self.state} {self.zipcode}")
return "\n".join(lines)
Employee class leverages the implementation of the Address class without any knowledge of what
an Address object is or how it's representeddesign is so flexible the Address class can be changed without affecting the Employee class Flexible Designs With Composition
composition is more flexible than inheritance because it models a loosely coupled relationshipchanges to a component class have minimal or no effects on the composite class designs based on composition are more suitable to change policy-based design - classes are composed of policies types delegate to those policies to do the work productivity.py class ProductivitySystem:
def __init__(self):
self._roles = {
"manager": ManagerRole,
"secretary": SecretaryRole,
"sales": SalesRole,
"factory": FactoryRole,
}
def get_role(self, role_id):
role_type = self._roles.get(role_id)
if not role_type:
raise ValueError(role_id)
return role_type()
def track(self, employees, hours):
print("Tracking Employee Productivity")
print("==============================")
for employee in employees:
employee.work(hours)
print("")
class ManagerRole:
def perform_duties(self, hours):
return f"screams and yells for {hours} hours."
class SecretaryRole:
def perform_duties(self, hours):
return f"does paperwork for {hours} hours."
class SalesRole:
def perform_duties(self, hours):
return f"expends {hours} hours on the phone."
class FactoryRole:
def perform_duties(self, hours):
return f"manufactures gadgets for {hours} hours."
hr.py
class PayrollSystem:
def __init__(self):
self._employee_policies = {
1: SalaryPolicy(3000),
2: SalaryPolicy(1500),
3: CommissionPolicy(1000, 100),
4: HourlyPolicy(15),
5: HourlyPolicy(9),
}
def get_policy(self, employee_id):
policy = self._employee_policies.get(employee_id)
if not policy:
return ValueError(employee_id)
return policy
def calculate_payroll(self, employees):
print("Calculating Payroll")
print("===================")
for employee in employees:
print(f"Payroll for: {employee.id} - {employee.name}")
print(f"- Check amount: {employee.calculate_payroll()}")
if employee.address:
print("- Sent to:")
print(employee.address)
print("")
class PayrollPolicy:
def __init__(self):
self.hours_worked = 0
def track_work(self, hours):
self.hours_worked += hours
class SalaryPolicy(PayrollPolicy):
def __init__(self, weekly_salary):
super().__init__()
self.weekly_salary = weekly_salary
def calculate_payroll(self):
return self.weekly_salary
class HourlyPolicy(PayrollPolicy):
def __init__(self, hourly_rate):
super().__init__()
self.hourly_rate = hourly_rate
def calculate_payroll(self):
return self.hours_worked * self.hourly_rate
class CommissionPolicy(SalaryPolicy):
def __init__(self, weekly_salary, commission_per_sale):
super().__init__(weekly_salary)
self.commission_per_sale = commission_per_sale
@property
def commission(self):
sales = self.hours_worked / 5
return sales * self.commission_per_sale
def calculate_payroll(self):
fixed = super().calculate_payroll()
return fixed + self.commission
contacts.py
class AddressBook:
def __init__(self):
self._employee_addresses = {
1: Address("121 Admin Rd.", "Concord", "NH", "03301"),
2: Address("67 Paperwork Ave", "Manchester", "NH", "03101"),
3: Address("15 Rose St", "Concord", "NH", "03301", "Apt. B-1"),
4: Address("39 Sole St.", "Concord", "NH", "03301"),
5: Address("99 Mountain Rd.", "Concord", "NH", "03301"),
}
def get_employee_address(self, employee_id):
address = self._employee_addresses.get(employee_id)
if not address:
raise ValueError(employee_id)
return address
class Address:
def __init__(self, street, city, state, zipcode, street2=""):
self.street = street
self.street2 = street2
self.city = city
self.state = state
self.zipcode = zipcode
def __str__(self):
lines = [self.street]
if self.street2:
lines.append(self.street2)
lines.append(f"{self.city}, {self.state} {self.zipcode}")
return "\n".join(lines)
no major changes in the design to this point
a EmployeeDatabase type is added to employees.pythe EmployeeDatabase creates objects of the Employee class from productivity import ProductivitySystem
from hr import PayrollSystem
from contacts import AddressBook
class EmployeeDatabase:
def __init__(self):
self._employees = [
{"id": 1, "name": "Mary Poppins", "role": "manager"},
{"id": 2, "name": "John Smith", "role": "secretary"},
{"id": 3, "name": "Kevin Bacon", "role": "sales"},
{"id": 4, "name": "Jane Doe", "role": "factory"},
{"id": 5, "name": "Robin Williams", "role": "secretary"},
]
self.productivity = ProductivitySystem()
self.payroll = PayrollSystem()
self.employee_addresses = AddressBook()
@property
def employees(self):
return [self._create_employee(**data) for data in self._employees]
def _create_employee(self, id, name, role):
address = self.employee_addresses.get_employee_address(id)
employee_role = self.productivity.get_role(role)
payroll_policy = self.payroll.get_policy(id)
return Employee(id, name, address, employee_role, payroll_policy)
class Employee:
def __init__(self, id, name, address, role, payroll):
self.id = id
self.name = name
self.address = address
self.role = role
self.payroll = payroll
def work(self, hours):
duties = self.role.perform_duties(hours)
print(f"Employee {self.id} - {self.name}:")
print(f"- {duties}")
print("")
self.payroll.track_work(hours)
def calculate_payroll(self):
return self.payroll.calculate_payroll()
program.py uses the new design
from hr import PayrollSystem from productivity import ProductivitySystem from employees import EmployeeDatabase productivity_system = ProductivitySystem() payroll_system = PayrollSystem() employee_database = EmployeeDatabase() employees = employee_database.employees productivity_system.track(employees, 40) payroll_system.calculate_payroll(employees) Customizing Behavior With Composition
with composition an object's policy can be changed dynamically
a temporary manager is hired and paid an hourly rate
from hr import PayrollSystem, HourlyPolicy from productivity import ProductivitySystem from employees import EmployeeDatabase productivity_system = ProductivitySystem() payroll_system = PayrollSystem() employee_database = EmployeeDatabase() employees = employee_database.employees manager = employees[0] manager.payroll = HourlyPolicy(55) productivity_system.track(employees, 40) payroll_system.calculate_payroll(employees)output $ python program.py Tracking Employee Productivity ============================== Employee 1 - Mary Poppins: - screams and yells for 40 hours. Employee 2 - John Smith: - does paperwork for 40 hours. Employee 3 - Kevin Bacon: - expends 40 hours on the phone. Employee 4 - Jane Doe: - manufactures gadgets for 40 hours. Employee 5 - Robin Williams: - does paperwork for 40 hours. Calculating Payroll =================== Payroll for: 1 - Mary Poppins - Check amount: 2200 - Sent to: 121 Admin Rd. Concord, NH 03301 Payroll for: 2 - John Smith - Check amount: 1500 - Sent to: 67 Paperwork Ave Manchester, NH 03101 Payroll for: 3 - Kevin Bacon - Check amount: 1800.0 - Sent to: 15 Rose St Apt. B-1 Concord, NH 03301 Payroll for: 4 - Jane Doe - Check amount: 600 - Sent to: 39 Sole St. Concord, NH 03301 Payroll for: 5 - Robin Williams - Check amount: 360 - Sent to: 99 Mountain Rd. Concord, NH 03301the temporary manager earns $2,200 a week the previous manager received a salary of $3,000 business rule was changed without making any code changes within the design |
||||||||||||||||
| Choosing Between Inheritance and Composition in Python | ||||||||||||||||
Inheritance to Model "Is A" Relationship
Liskov's substitution principle is the most important guideline to determine if inheritance is
the appropriate design solutionconsider relationship between two types A is a square and B is a rectangle evaluate B is an A and A is a B in terms of calculating area (height * length) both statements are true neither type should derive from the other Mixing Features With Mixin Classes
Multiple Inheritance and Mixin Classes for another description
the Employee class' has no need to expose its role and payroll attributescan hide the attributes using a mixin class AsDictionaryMixin:
def to_dict(self):
return {
prop: self._represent(value)
# .__dict__ is basically a mapping of all the attributes in an object to their values
for prop, value in self.__dict__.items()
if not self._is_internal(prop)
}
def _represent(self, value):
if isinstance(value, object):
if hasattr(value, "to_dict"):
return value.to_dict()
else:
return str(value)
else:
return value
def _is_internal(self, prop):
return prop.startswith("_")
.to_dict() method returns the representation of itself as a dictionarymethod is implemented as a dict comprehension iterates through all the items in .__dict__ filters out the ones that have a name that starts with an underscore using ._is_internal() in employees.py set the role and payroll attributes as private using an underscore add the mixin to the Employee class from productivity import ProductivitySystem
from hr import PayrollSystem
from contacts import AddressBook
from representations import AsDictionaryMixin
class EmployeeDatabase:
def __init__(self):
self._employees = [
{"id": 1, "name": "Mary Poppins", "role": "manager"},
{"id": 2, "name": "John Smith", "role": "secretary"},
{"id": 3, "name": "Kevin Bacon", "role": "sales"},
{"id": 4, "name": "Jane Doe", "role": "factory"},
{"id": 5, "name": "Robin Williams", "role": "secretary"},
]
self.productivity = ProductivitySystem()
self.payroll = PayrollSystem()
self.employee_addresses = AddressBook()
@property
def employees(self):
return [self._create_employee(**data) for data in self._employees]
def _create_employee(self, id, name, role):
address = self.employee_addresses.get_employee_address(id)
employee_role = self.productivity.get_role(role)
payroll_policy = self.payroll.get_policy(id)
return Employee(id, name, address, employee_role, payroll_policy)
class Employee(AsDictionaryMixin):
def __init__(self, id, name, address, role, payroll):
self.id = id
self.name = name
self.address = address
self._role = role
self._payroll = payroll
def work(self, hours):
duties = self._role.perform_duties(hours)
print(f"Employee {self.id} - {self.name}:")
print(f"- {duties}")
print("")
self.payroll.track_work(hours)
def calculate_payroll(self):
return self._payroll.calculate_payroll()
the Address class can use the mixin as well
from representations import AsDictionaryMixin
class AddressBook:
def __init__(self):
self._employee_addresses = {
1: Address("121 Admin Rd.", "Concord", "NH", "03301"),
2: Address("67 Paperwork Ave", "Manchester", "NH", "03101"),
3: Address("15 Rose St", "Concord", "NH", "03301", "Apt. B-1"),
4: Address("39 Sole St.", "Concord", "NH", "03301"),
5: Address("99 Mountain Rd.", "Concord", "NH", "03301"),
}
def get_employee_address(self, employee_id):
address = self._employee_addresses.get(employee_id)
if not address:
raise ValueError(employee_id)
return address
class Address(AsDictionaryMixin):
def __init__(self, street, city, state, zipcode, street2=""):
self.street = street
self.street2 = street2
self.city = city
self.state = state
self.zipcode = zipcode
def __str__(self):
lines = [self.street]
if self.street2:
lines.append(self.street2)
lines.append(f"{self.city}, {self.state} {self.zipcode}")
return "\n".join(lines)
to test the mixin
# mixin_mule.py
import json
from employees import EmployeeDatabase
def print_dict(d):
print(json.dumps(d, indent=2))
for employee in EmployeeDatabase().employees:
print_dict(employee.to_dict())
output
$ python mixin_mule.py
{
"id": "1",
"name": "Mary Poppins",
"address": {
"street": "121 Admin Rd.",
"street2": "",
"city": "Concord",
"state": "NH",
"zipcode": "03301"
}
}
{
"id": "2",
"name": "John Smith",
"address": {
"street": "67 Paperwork Ave",
"street2": "",
"city": "Manchester",
"state": "NH",
"zipcode": "03101"
}
}
{
"id": "3",
"name": "Kevin Bacon",
"address": {
"street": "15 Rose St",
"street2": "Apt. B-1",
"city": "Concord",
"state": "NH",
"zipcode": "03301"
}
}
{
"id": "4",
"name": "Jane Doe",
"address": {
"street": "39 Sole St.",
"street2": "",
"city": "Concord",
"state": "NH",
"zipcode": "03301"
}
}
{
"id": "5",
"name": "Robin Williams",
"address": {
"street": "99 Mountain Rd.",
"street2": "",
"city": "Concord",
"state": "NH",
"zipcode": "03301"
}
}
mixin only provides a behaviorcan be used by multiple classes Composition to Model "Has A" Relationship
a problem with Has A composition is types can grow quickly when using multiple componentscan make c'tor unwieldly can avoid problem by using factory method above the call to create an employee uses the signature def _create_employee(self, id, name, role)a simpler signature would be def _create_employee(self, id)modify productivity.py to create a singleton _ProductivitySystem object when the script is run adding the underscore to the class name marks the class as internal class _ProductivitySystem:
# ...
# ...
_productivity_system = _ProductivitySystem()
def get_role(role_id):
return _productivity_system.get_role(role_id)
def track(employees, hours):
_productivity_system.track(employees, hours)
make similar changes to hr.py
class _PayrollSystem:
# ...
# ...
_payroll_system = _PayrollSystem()
def get_policy(employee_id):
return _payroll_system.get_policy(employee_id)
def calculate_payroll(employees):
_payroll_system.calculate_payroll(employees)
and to contacts.py
# ...
class _AddressBook:
# ...
_address_book = _AddressBook()
def get_employee_address(employee_id):
return _address_book.get_employee_address(employee_id)
with some refactoring the EmployeeDatabase will be a singleton as well
from productivity import get_role
from hr import get_policy
from contacts import get_employee_address
from representations import AsDictionaryMixin
class _EmployeeDatabase:
def __init__(self):
self._employees = {
1: {"name": "Mary Poppins", "role": "manager"},
2: {"name": "John Smith", "role": "secretary"},
3: {"name": "Kevin Bacon", "role": "sales"},
4: {"name": "Jane Doe", "role": "factory"},
5: {"name": "Robin Williams", "role": "secretary"},
}
@property
def employees(self):
return [Employee(id_) for id_ in sorted(self._employees)]
def get_employee_info(self, employee_id):
info = self._employees.get(employee_id)
if not info:
raise ValueError(employee_id)
return info
class Employee(AsDictionaryMixin):
def __init__(self, id):
self.id = id
info = employee_database.get_employee_info(self.id)
self.name = info.get("name")
self.address = get_employee_address(self.id)
self._role = get_role(info.get("role"))
self._payroll = get_policy(self.id)
def work(self, hours):
duties = self._role.perform_duties(hours)
print(f"Employee {self.id} - {self.name}:")
print(f"- {duties}")
print("")
self._payroll.track_work(hours)
def calculate_payroll(self):
return self._payroll.calculate_payroll()
employee_database = _EmployeeDatabase()
the Employee c'tor uses exposed application methods of internal singletons to get employee-specific dataimports the relevant public functions and classes from other modules _EmployeeDatabase is internal, and and a single instance is created the instance is public and part of the interface to use in the application program.py will also be refactored import json
from hr import calculate_payroll
from productivity import track
from employees import employee_database, Employee
def print_dict(d):
print(json.dumps(d, indent=2))
employees = employee_database.employees
track(employees, 40)
calculate_payroll(employees)
temp_secretary = Employee(5)
print("Temporary Secretary:")
print_dict(temp_secretary.to_dict())
the Employee class remains a composite objectthe difference is the only external dependency the c'tor needs is the employee ID the type's other dependencies are loaded by using the factory methods Choosing Between Inheritance and Composition
guidelines
|