Related Topics
Python Programing
class SubClassName(SuperClassName):
# Subclass definition goes here
Once you have defined the subclass, you can access the methods and attributes of the superclass using the super() function.
Here is an example to illustrate the use of inheritance in Python:
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print("This animal speaks")
class Dog(Animal):
def __init__(self, name):
super().__init__(name)
def bark(self):
print("Woof!")
In this example, Dog is a subclass of Animal. It inherits the __init__ and speak methods from Animal and defines its own bark method. When a new instance of Dog is created, it is initialized with the __init__ method of Animal, which sets the name attribute of the animal.
To use inheritance effectively in your classes, it is important to follow some best practices:
Use inheritance sparingly: Inheritance can be a powerful tool, but it can also make your code more complex and harder to understand. Use inheritance only when it makes sense and when it simplifies your code.
Follow the Liskov substitution principle: The Liskov substitution principle states that a subclass should be able to be used in place of its superclass without any unexpected behavior. This means that you should not change the behavior of the superclass in the subclass.
Use abstract base classes to define interfaces: Abstract base classes are classes that cannot be instantiated, but provide a common interface for subclasses. They are useful for defining a set of methods that subclasses must implement.
Use composition over inheritance: Composition is an alternative to inheritance that involves creating new classes by combining existing ones. This can be a more flexible and powerful way to create new classes, especially when the behavior of the new class is not a straightforward extension of the existing class.
By following these best practices, you can use inheritance effectively and make your code more maintainable and understandable.
class Animal:
def speak(self):
print("This animal speaks")
class Dog(Animal):
def speak(self):
print("Woof!")
class Cat(Animal):
def speak(self):
print("Meow!")
def speak_twice(animal):
animal.speak()
animal.speak()
dog = Dog()
cat = Cat()
speak_twice(dog) # Output: Woof! Woof!
speak_twice(cat) # Output: Meow! Meow!
In this example, Dog and Cat are both subclasses of Animal that override the speak method. The speak_twice function takes an Animal object as an argument and calls its speak method twice.
When the speak_twice function is called with a Dog object, the speak method of Dog is called twice, producing the output “Woof! Woof!”. Similarly, when the function is called with a Cat object, the speak method of Cat is called twice, producing the output “Meow! Meow!”.
Polymorphism is a powerful tool that allows you to write more flexible and reusable code. By defining common methods in a superclass and allowing subclasses to override them, you can create a hierarchy of related classes that share common behaviors while also allowing for variation in specific behaviors.
class BankAccount:
def __init__(self, balance):
self.__balance = balance
def deposit(self, amount):
self.__balance += amount
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
else:
print("Insufficient funds")
def get_balance(self):
return self.__balance
account = BankAccount(1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance()) # Output: 1300
In this example, BankAccount is a class that represents a bank account. The __balance member variable is marked as private by prefixing its name with two underscores. The deposit, withdraw, and get_balance methods provide access to the __balance variable in a controlled way.
By using encapsulation in this way, the internal state of the BankAccount object is protected from outside interference. The only way to access the __balance variable is through the methods provided by the class, which ensures that the balance is always updated correctly and prevents accidental modification of the data.
Popular Category
Topics for You
Go through our study material. Your Job is awaiting.