Methods and the __init__ Constructor

One Shared Foundation

Suppose a program models people at a school. Teachers and students are different kinds of school members, but both have a name and an age. Instead of defining those common attributes separately in both classes, a base class named SchoolMember can define them once. Teacher and Student can then inherit those shared features and add their own specialized attributes, such as salary or marks.

The base class is the shared foundation. A derived class, also called a subclass, reuses the base class's functionality and can add specialized features. In this example, SchoolMember is the base class, while Teacher and Student are derived classes. A Teacher is therefore a SchoolMember with an additional salary attribute, and a Student is a SchoolMember with an additional marks attribute.

Construction State

When a Teacher object is created, Python runs Teacher.__init__. That method explicitly calls SchoolMember.__init__(self, name, age). The parent initialization establishes the inherited name and age attributes. After that call finishes, Teacher initializes its own salary attribute. Calling the parent constructor is important because it ensures that the inherited part of the object is initialized before the subclass adds its specialized state.

Methods That Specialize

A method defined in a base class is available to derived classes. A derived class can also redefine that method. Redefining an inherited method is called overriding: the subclass supplies its own implementation instead of using only the parent's implementation.

SchoolMember defines tell() to display common details. Teacher and Student each define their own tell() method. Inside the Teacher version, the subclass first calls SchoolMember.tell(self), which displays the shared name and age information, and then adds the salary. Student follows the same pattern: it calls the parent tell() method and then adds marks.

One Base, Many Behaviors

Teacher and Student both reuse SchoolMember's common attributes and can use its methods. Each subclass then supplies behavior appropriate to its own kind of object. This arrangement reduces code duplication: name, age, and the shared part of tell() are defined in one place rather than repeated in every class.

The same design also supports polymorphism. A loop can contain both Teacher and Student objects and call member.tell() for each one without checking the specific class. Python calls Teacher.tell() for a Teacher object and Student.tell() for a Student object. The method call is the same, but the behavior depends on the object receiving it.

Mistakes to Avoid

• Defining subclass-specific attributes without calling the parent __init__ method.

  The inherited name and age attributes are not initialized by the base class.

  Fix: Call SchoolMember.__init__(self, name, age) before adding the Teacher-specific salary attribute.

• Replacing the parent's method without preserving shared behavior.

  The subclass version omits the shared name and age details supplied by the base class.

  Fix: Call the parent tell() method from the overridden method, then add the specialized output.

• Checking every object's class before calling tell().

  The loop does not use the flexibility provided by polymorphism.

  Fix: Call member.tell(); Python selects the appropriate overridden method for the object.

Practice the Trace

Key Takeaways

1. A base class defines attributes and methods shared by related objects.
2. A derived class inherits those features and can add specialized attributes and methods.
3. A derived class should call the parent __init__ method to initialize inherited attributes.
4. Overriding lets a subclass customize a method; calling the parent method lets it extend shared behavior.
5. Polymorphism allows one method call, such as member.tell(), to produce the correct behavior for different derived classes.