Inheritance: Reusing and Extending Code

Inheritance allows you to derive a new class (child class) from an existing class (parent class). The child class inherits all the attributes and methods of the parent class, facilitating code reuse and enhancing modularity. Consider this simple example:

class Animal:

def __init__(self, name, species):

self.name = name

self.species = species

def make_sound(self):

print("The animal makes a sound.")

class Dog(Animal):

def __init__(self, name, breed):

super().__init__(name, "Dog")

self.breed = breed

def make_sound(self):

print("Woof!")

dog = Dog("Buddy", "Labrador")

dog.make_sound() # Output: Woof!

In this illustration, the Dog class inherits from the Animal class. The Dog class has its own __init__ method, which calls the parent class's __init__ method using super().__init__(). The make_sound method is overridden in the Dog class to produce "Woof!" instead of the generic behavior.

Instance Attributes: Defining Object Properties

Instance attributes are variables tied to a specific instance (or object) of a class. These attributes determine the state or characteristics of an object and can be accessed or modified using dot notation.

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def greet(self):

print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

person1 = Person("Alice", 25)

person2 = Person("Bob", 30)

person1.greet() # Output: Hello, my name is Alice and I'm 25 years old.

person2.greet() # Output: Hello, my name is Bob and I'm 30 years old.

In this case, name and age are instance attributes of the Person class. Each instance (person1 and person2) possesses its own values for these attributes, enabling distinct representations of different objects.

Combining Inheritance and Instance Attributes

The combination of inheritance and instance attributes allows for the creation of more intricate and powerful class hierarchies. Here’s an example:

class Vehicle:

def __init__(self, make, model, year):

self.make = make

self.model = model

self.year = year

def display_info(self):

print(f"{self.year} {self.make} {self.model}")

class Car(Vehicle):

def __init__(self, make, model, year, num_doors):

super().__init__(make, model, year)

self.num_doors = num_doors

def display_info(self):

super().display_info()

print(f"Number of doors: {self.num_doors}")

car = Car("Toyota", "Camry", 2020, 4)

car.display_info()

# Output:

# 2020 Toyota Camry

# Number of doors: 4

In this scenario, the Car class extends the Vehicle class, adding an extra instance attribute num_doors. The display_info method in the Car class overrides the method from the parent class and calls the parent's display_info method using super().display_info().