Parent and child classes in Python - Deep Dive

Overview - Parent and child classes

What is it?

Parent and child classes are a way to organize code where one class (the child) inherits properties and behaviors from another class (the parent). This means the child class can use or change what the parent class has without rewriting everything. It helps to create a clear relationship between general and specific things in your code. This idea is called inheritance.

Why it matters

Without parent and child classes, programmers would have to repeat the same code many times for similar things, making programs longer and harder to fix. Inheritance lets us reuse code easily and build complex programs step-by-step. It also helps keep code organized and easier to understand, which saves time and reduces mistakes.

Where it fits

Before learning parent and child classes, you should understand what classes and objects are in Python. After this, you can learn about more advanced topics like method overriding, multiple inheritance, and design patterns that use inheritance.

Mental Model

Core Idea

A child class is like a specialized version of a parent class that inherits its features but can add or change them.

Think of it like...

Think of a parent class as a blueprint for a general vehicle, and a child class as a blueprint for a specific car model that uses the vehicle blueprint but adds its own features like color or engine type.

Parent Class (Vehicle)
├── Attributes: wheels, color
├── Methods: start(), stop()
└── Child Class (Car)
    ├── Inherits: wheels, color, start(), stop()
    ├── Adds: sunroof, play_music()
    └── Overrides: start() with special behavior

Build-Up - 7 Steps

1

Foundation

Understanding basic classes

Concept: Learn what a class is and how to create one in Python.

A class is like a blueprint for creating objects. It defines attributes (data) and methods (actions). For example: class Animal: def __init__(self, name): self.name = name def speak(self): print(f"{self.name} makes a sound")

Result

You can create an Animal object and call its speak method: >>> a = Animal('Dog') >>> a.speak() Dog makes a sound

Understanding classes is the foundation for inheritance because child classes build on this blueprint concept.

2

Foundation

Creating objects from classes

Concept: Learn how to make objects (instances) from a class and use their attributes and methods.

Objects are created by calling the class like a function. Each object has its own data: cat = Animal('Cat') dog = Animal('Dog') cat.speak() # Cat makes a sound dog.speak() # Dog makes a sound

Result

Each object remembers its own name and can perform actions defined by the class.

Knowing how objects work helps you see how child classes create specialized objects with inherited features.

3

Intermediate

Introducing inheritance with child classes

🤔Before reading on: do you think a child class can use methods from its parent class without rewriting them? Commit to your answer.

Concept: Child classes inherit attributes and methods from parent classes, so they can reuse code easily.

To create a child class, put the parent class name in parentheses: class Dog(Animal): pass Now Dog has all Animal's features: d = Dog('Buddy') d.speak() # Buddy makes a sound

Result

The child class Dog can use the speak method from Animal without any new code.

Understanding inheritance shows how child classes save time by reusing parent code instead of copying it.

4

Intermediate

Adding new features in child classes

🤔Before reading on: do you think child classes can have their own new methods or attributes besides what they inherit? Commit to your answer.

Concept: Child classes can add new methods or attributes that the parent class does not have.

You can add new features in the child class: class Dog(Animal): def bark(self): print(f"{self.name} barks") my_dog = Dog('Rex') my_dog.speak() # Rex makes a sound my_dog.bark() # Rex barks

Result

The Dog object can both speak (inherited) and bark (new).

Knowing that child classes can extend parents helps you create more specific and useful objects.

5

Intermediate

Overriding parent methods in child classes

🤔Before reading on: do you think a child class can change how a parent method works by writing its own version? Commit to your answer.

Concept: Child classes can replace parent methods with their own versions, called overriding.

Override a method by defining it again in the child class: class Dog(Animal): def speak(self): print(f"{self.name} says Woof!") my_dog = Dog('Max') my_dog.speak() # Max says Woof!

Result

The Dog's speak method replaces the Animal's speak method for Dog objects.

Overriding lets child classes customize behavior while still keeping the parent-child relationship.

6

Advanced

Using super() to call parent methods

🤔Before reading on: do you think a child method can still use the parent method it overrides? Commit to your answer.

Concept: The super() function lets child classes call the parent class's method inside an overridden method.

Use super() to extend parent behavior: class Dog(Animal): def speak(self): super().speak() # call parent method print(f"{self.name} barks loudly") my_dog = Dog('Rocky') my_dog.speak() # Output: # Rocky makes a sound # Rocky barks loudly

Result

The Dog's speak method runs the Animal's speak first, then adds more behavior.

Knowing super() helps combine parent and child behaviors cleanly without repeating code.

7

Expert

Understanding method resolution order (MRO)

🤔Before reading on: if a class inherits from multiple parents, which parent's method runs first? Commit to your answer.

Concept: Python uses a specific order called MRO to decide which method to run when multiple parents have the same method.

When a class inherits from multiple parents, Python checks methods in this order: 1. The child class itself 2. The first parent class 3. The next parent class, and so on Example: class A: def greet(self): print('Hello from A') class B: def greet(self): print('Hello from B') class C(A, B): pass c = C() c.greet() # Hello from A Python uses C's MRO: C -> A -> B

Result

The greet method from class A runs because it appears first in the MRO.

Understanding MRO prevents confusion and bugs in complex inheritance setups with multiple parents.

Under the Hood

When Python creates a child class, it builds a method resolution order (MRO) list that tells it where to look for attributes and methods. When you call a method on an object, Python searches the child class first, then its parents in order, until it finds the method. This lookup happens at runtime, allowing dynamic behavior. The super() function uses this MRO to find the next method to call in the chain.

Why designed this way?

Inheritance was designed to promote code reuse and logical organization. The MRO system was created to handle multiple inheritance cleanly and predictably, avoiding ambiguity about which parent method to use. This design balances flexibility with clarity, making Python powerful yet understandable.

┌─────────────┐
│ Child Class │
├─────────────┤
│  Methods    │
│  Attributes │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Parent Class│
├─────────────┤
│  Methods    │
│  Attributes │
└─────┬───────┘
      │
      ▼
    (Object)

Method call flow:
Child Class -> Parent Class -> Object

Myth Busters - 4 Common Misconceptions

Quick: Does a child class copy all parent code into itself when created? Commit to yes or no.

Common Belief: A child class copies all the code from the parent class into itself.

Reality: A child class does not copy code; it references the parent class's methods and attributes dynamically when needed.

Why it matters: Thinking of inheritance as copying can lead to confusion about how changes in parent classes affect children and cause bugs when modifying code.

Quick: Can a child class use a parent method even if it defines a method with the same name? Commit to yes or no.

Common Belief: If a child class defines a method with the same name as the parent, the parent method is lost and cannot be used.

Reality: The child method overrides the parent method, but the parent method can still be accessed using super().

Why it matters: Not knowing about super() can cause duplicated code or loss of important parent behavior.

Quick: Does Python allow a class to inherit from multiple parents? Commit to yes or no.

Common Belief: Python does not support multiple inheritance; a class can only have one parent.

Reality: Python supports multiple inheritance, allowing a class to inherit from multiple parents, with a clear method resolution order.

Why it matters: Ignoring multiple inheritance limits design options and understanding of complex class relationships.

Quick: If a parent class changes after child classes are created, do child classes keep the old behavior? Commit to yes or no.

Common Belief: Child classes keep their original behavior even if the parent class changes later.

Reality: Child classes reflect changes in the parent class immediately because they reference parent methods dynamically.

Why it matters: Misunderstanding this can cause unexpected bugs when modifying parent classes, thinking children are unaffected.

Expert Zone

1

The use of super() is not just a shortcut; it follows the MRO and allows cooperative multiple inheritance, enabling all parents to contribute to method calls.

2

Overriding __init__ in child classes requires careful calling of super().__init__ to ensure proper initialization of parent parts, which is often missed.

3

Python's MRO uses the C3 linearization algorithm, which guarantees a consistent and monotonic order even in complex multiple inheritance hierarchies.

When NOT to use

Inheritance is not ideal when classes do not share a clear 'is-a' relationship or when behavior sharing is better done by composition (has-a relationship). In such cases, prefer composition or delegation patterns to avoid fragile and hard-to-maintain code.

Production Patterns

In real-world systems, inheritance is used to create base classes with common functionality (like database models or UI components) and specialized child classes for specific cases. Frameworks often rely on inheritance for extensibility, but careful use of super() and understanding MRO is critical to avoid bugs.

Connections

Composition over Inheritance

Alternative design pattern

Knowing when to use composition instead of inheritance helps create more flexible and maintainable code by favoring 'has-a' relationships over 'is-a'.

Polymorphism

Builds on inheritance

Inheritance enables polymorphism, where different child classes can be treated as their parent type but behave differently, allowing flexible and reusable code.

Biological Taxonomy

Hierarchical classification analogy

Understanding biological classification (kingdom, genus, species) helps grasp how inheritance organizes classes from general to specific.

Common Pitfalls

#1 Forgetting to call the parent __init__ in a child class causes missing initialization.

Wrong approach:

class Dog(Animal):
def __init__(self, name, breed):
self.breed = breed # Missing call to Animal.__init__

my_dog = Dog('Buddy', 'Beagle')
print(my_dog.name) # Error: 'Dog' object has no attribute 'name'

Correct approach:

class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # Properly initialize parent
self.breed = breed

my_dog = Dog('Buddy', 'Beagle')
print(my_dog.name) # Buddy

Root cause:

Misunderstanding that child __init__ replaces parent __init__ unless explicitly called.

#2 Overriding a method without calling super() loses parent behavior unintentionally.

Wrong approach:

class Dog(Animal):
def speak(self):
print(f"{self.name} barks") # No call to parent speak

my_dog = Dog('Max')
my_dog.speak() # Only barks, no parent message

Correct approach:

class Dog(Animal):
def speak(self):
super().speak() # Call parent method
print(f"{self.name} barks")

my_dog = Dog('Max')
my_dog.speak() # Parent and child messages

Root cause:

Not realizing that overriding replaces the parent method entirely unless super() is used.

#3 Assuming multiple inheritance order is random causes unexpected method calls.

Wrong approach:

class A:
def greet(self):
print('A')

class B:
def greet(self):
print('B')

class C(B, A):
pass

c = C()
c.greet() # Prints 'B' but learner expected 'A'

Correct approach:

class C(A, B): # Order matters
pass

c = C()
c.greet() # Prints 'A' as expected

Root cause:

Ignoring the method resolution order and the order of parent classes in the class definition.

Key Takeaways

Parent and child classes let you organize code by sharing common features and customizing specifics through inheritance.

Child classes inherit methods and attributes from parents but can add new ones or override existing ones to change behavior.

The super() function is essential for combining parent and child behaviors, especially in complex inheritance chains.

Python uses a method resolution order (MRO) to decide which method to run when multiple parents define the same method.

Understanding when to use inheritance versus composition is key to writing clear, maintainable, and flexible code.