You use inheritance to create new classes from existing ones. In fact, every Python class inherits from an existing class. When you do not explicitly specify the base class for a new class, Python assumes that the class inherits directly from class object. The Python class hierarchy begins with class object, the direct or indirect base class of every class. So, class CommissionEmployee’s header could have been written as

class CommissionEmployee(object):

The parentheses after CommissionEmployee indicate inheritance and may contain a single class for single inheritance or a comma-separated list of base classes for multiple inheritance. Once again, multiple inheritance is beyond the scope of this book.

Class CommissionEmployee inherits all the methods of class object. Class object does not have any data attributes. Two of the many methods inherited from object are __repr__ and __str__. So every class has these methods that return string representations of the objects on which they’re called. When a base-class method implementation is inappropriate for a derived class, that method can be overridden (i.e., redefined) in the derived class with an appropriate implementation. Method __repr__ (lines 58–64) overrides the default implementation inherited into class CommissionEmployee from class object.⁷

Let’s quickly test some of CommissionEmployee’s features. First, create and display a CommissionEmployee:

In [1]: from commissionemployee import CommissionEmployee

In [2]: from decimal import Decimal

In [3]: c = CommissionEmployee('Sue', 'Jones', '333-33-3333',
   ...:     Decimal('10000.00'), Decimal('0.06'))
   ...:

In [4]: c
Out[4]:
CommissionEmployee: Sue Jones
social security number: 333-33-3333
gross sales: 10000.00
commission rate: 0.06

Next, let’s calculate and display the CommissionEmployee’s earnings:

In [5]: print(f'{c.earnings():,.2f}')
600.00

Finally, let’s change the CommissionEmployee’s gross sales and commission rate, then recalculate the earnings:

In [6]: c.gross_sales = Decimal('20000.00')

In [7]: c.commission_rate = Decimal('0.1')

In [8]: print(f'{c.earnings():,.2f}')
2,000.00

We now declare the subclass SalariedCommissionEmployee, which inherits most of its capabilities from class CommissionEmployee (line 6). A SalariedCommissionEmployee is a CommissionEmployee (because inheritance passes on the capabilities of class CommissionEmployee), but class SalariedCommissionEmployee also has the following features:

• Method __init__ (lines 10–15), which initializes all the data inherited from class CommissionEmployee (we’ll say more about this momentarily), then uses the base_salary property’s setter to create a _base_salary data attribute.

• Read-write property base_salary (lines 17–27), in which the setter performs data validation.

• A customized version of method earnings (lines 29–31).

• A customized version of method __repr__ (lines 33–36).

 1 # salariedcommissionemployee.py
 2 """SalariedCommissionEmployee derived from CommissionEmployee."""
 3 from commissionemployee import CommissionEmployee
 4 from decimal import Decimal
 5
 6 class SalariedCommissionEmployee(CommissionEmployee):
 7     """An employee who gets paid a salary plus
 8     commission based on gross sales."""
 9
10     def __init__(self, first_name, last_name, ssn,
11                  gross_sales, commission_rate, base_salary):
12         """Initialize SalariedCommissionEmployee's attributes."""
13         super().__init__(first_name, last_name, ssn,
14                          gross_sales, commission_rate)
15         self.base_salary = base_salary # validate via property
16
17     @property
18     def base_salary(self):
19         return self._base_salary
20
21     @base_salary.setter
22     def base_salary(self, salary):
23         """Set base salary or raise ValueError if invalid."""
24         if salary < Decimal('0.00'):
25            raise ValueError('Base salary must be >= to 0')
26
27         self._base_salary = salary
28
29     def earnings(self):
30         """Calculate earnings."""
31         return super().earnings() + self.base_salary
32
33     def __repr__(self):
34         """Return string representation for repr()."""
35         return ('Salaried' + super().__repr__() +
36             f'
base salary: {self.base_salary:.2f}')

To inherit from a class, you must first import its definition (line 3). Line 6

class SalariedCommissionEmployee(CommissionEmployee):

specifies that class SalariedCommissionEmployee inherits from CommissionEmployee. Though you do not see class CommissionEmployee’s data attributes, properties and methods in class SalariedCommissionEmployee, they’re nevertheless part of the new class, as you’ll soon see.

Each subclass __init__ must explicitly call its base class’s __init__ to initialize the data attributes inherited from the base class. This call should be the first statement in the subclass’s __init__ method. SalariedCommissionEmployee’s __init__ method explicitly calls class CommissionEmployee’s __init__ method (lines 13–14) to initialize the base-class portion of a SalariedCommissionEmployee object (that is, the five inherited data attributes from class CommissionEmployee). The notation super().__init__ uses the built-in function super to locate and call the base class’s __init__ method, passing the five arguments that initialize the inherited data attributes.

Class SalariedCommissionEmployee’s earnings method (lines 29–31) overrides class CommissionEmployee’s earnings method (Section 10.8.1, lines 54–56) to calculate the earnings of a SalariedCommissionEmployee. The new version obtains the portion of the earnings based on commission alone by calling CommissionEmployee’s earnings method with the expression super().earnings() (line 31). SalariedCommissionEmployee’s earnings method then adds the base_salary to this value to calculate the total earnings. By having SalariedCommissionEmployee’s earnings method invoke CommissionEmployee’s earnings method to calculate part of a SalariedCommissionEmployee’s earnings, we avoid duplicating the code and reduce code-maintenance problems.

SalariedCommissionEmployee’s __repr__ method (lines 33–36) overrides class CommissionEmployee’s __repr__ method (Section 10.8.1, lines 58–64) to return a String representation that’s appropriate for a SalariedCommissionEmployee. The subclass creates part of the string representation by concatenating 'Salaried' and the string returned by super().__repr__(), which calls CommissionEmployee’s __repr__ method. The overridden method then concatenates the base salary information and returns the resulting string.

Let’s test class SalariedCommissionEmployee to show that it indeed inherited capabilities from class CommissionEmployee. First, let’s create a SalariedCommissionEmployee and print all of its properties:

In [9]: from salariedcommissionemployee import SalariedCommissionEmployee

In [10]: s = SalariedCommissionEmployee('Bob', 'Lewis', '444-44-4444',
    ...:         Decimal('5000.00'), Decimal('0.04'), Decimal('300.00'))
    ...:

In [11]: print(s.first_name, s.last_name, s.ssn, s.gross_sales,
    ...:       s.commission_rate, s.base_salary)
Bob Lewis 444-44-4444 5000.00 0.04 300.00

Notice that the SalariedCommissionEmployee object has all of the properties of classes CommissionEmployee and SalariedCommissionEmployee.

Next, let’s calculate and display the SalariedCommissionEmployee’s earnings. Because we call method earnings on a SalariedCommissionEmployee object, the subclass version of the method executes:

In [12]: print(f'{s.earnings():,.2f}')
500.00

Now, let’s modify the gross_sales, commission_rate and base_salary properties, then display the updated data via the SalariedCommissionEmployee’s __repr__ method:

In [13]: s.gross_sales = Decimal('10000.00')

In [14]: s.commission_rate = Decimal('0.05')

In [15]: s.base_salary = Decimal('1000.00')

In [16]: print(s)
SalariedCommissionEmployee: Bob Lewis
social security number: 444-44-4444
gross sales: 10000.00
commission rate: 0.05
base salary: 1000.00

Again, because this method is called on a SalariedCommissionEmployee object, the subclass version of the method executes. Finally, let’s calculate and display the SalariedCommissionEmployee’s updated earnings:

In [17]: print(f'{s.earnings():,.2f}')
1,500.00

Python provides two built-in functions—issubclass and isinstance—for testing “is a” relationships. Function issubclass determines whether one class is derived from another:

In [18]: issubclass(SalariedCommissionEmployee, CommissionEmployee)
Out[18]: True

Function isinstance determines whether an object has an “is a” relationship with a specific type. Because SalariedCommissionEmployee inherits from CommissionEmployee, both of the following snippets return True, confirming the “is a” relationship

In [19]: isinstance(s, CommissionEmployee)
Out[19]: True

In [20]: isinstance(s, SalariedCommissionEmployee)
Out[20]: True