Trying to instantiate the abstract base class raises an error

ByJordan Brown

Inheritance and polymorphism are two fundamental pillars of object-oriented programming (OOP) in Python. Inheritance allows you to create new classes that reuse, extend, and modify the behavior defined in other classes. Polymorphism, on the other hand, refers to the ability of different objects to respond to the same method call in different ways based on their specific type or class. Together, these techniques enable you to write modular, reusable, and maintainable code.

To test your understanding of Python inheritance and polymorphism, we‘ve put together a comprehensive set of multiple-choice questions. Each question is designed to challenge your knowledge and help you identify areas where you may need further study. Let‘s dive in!

Inheritance Basics

Q1. What is inheritance in Python?

A) A way to define methods in a class

B) A mechanism for creating new classes from existing ones

C) A technique for overloading operators

D) A means of encapsulating data within a class

Answer: B

Explanation: Inheritance is a mechanism in Python that allows you to create new classes based on existing ones, inheriting their attributes and methods.

Q2. Which keyword is used to define a subclass in Python?

A) subclass

B) inherits

C) extends

D) derives

Answer: C

Explanation: In Python, you define a subclass by specifying the parent class in parentheses after the subclass name, such as class Child(Parent).

Q3. How do you check if a class is a subclass of another class in Python?

A) isinstance(subclass, parentclass)

B) issubclass(subclass, parentclass)

C) subclass in parentclass

D) subclass == parentclass

Answer: B

Explanation: The built-in issubclass() function allows you to check if one class is a subclass of another. It returns True if the first argument is a subclass of the second argument.

Example:


class Animal:
    pass

class Dog(Animal):
pass


print(issubclass(Dog, Animal))  # Output: True
print(issubclass(Animal, Dog))  # Output: False

Method Overriding and Polymorphism

Q4. What is method overriding in Python?

A) Defining a method in a subclass with the same name as a method in the parent class

B) Defining multiple methods with the same name but different parameters

C) Calling a method from the parent class using super()

D) Accessing a parent class‘s attributes from a subclass

Answer: A

Explanation: Method overriding occurs when a subclass defines a method with the same name as a method in its parent class. The subclass‘s method overrides the implementation provided by the parent class.

Example:

  
class Animal:
    def sound(self):
        print("Animal sound")

class Cat(Animal):
def sound(self):
print("Meow")


animal = Animal()
cat = Cat()


animal.sound()  # Output: Animal sound
cat.sound()     # Output: Meow

Q5. What is polymorphism in Python?

A) The ability to define multiple classes in a single module

B) The ability to create objects from different classes

C) The ability to use a single interface with objects of different types

D) The ability to inherit attributes and methods from a parent class

Answer: C

Explanation: Polymorphism allows you to use a single interface (such as a method name) with objects of different types. In Python, this is achieved through method overriding and duck typing.

Q6. What is the output of the following code?


class Shape:
    def area(self):
        pass

class Square(Shape):
def init(self, side):
self.side = side


def area(self):
    return self.side ** 2


class Circle(Shape):

def init(self, radius):

self.radius = radius


def area(self):
    return 3.14 * self.radius ** 2


shapes = [Square(5), Circle(3), Square(2)]

total_area = sum(shape.area() for shape in shapes)

print(total_area)




A) 25



B) 28.26


C) 53.26



D) Error: cannot iterate over shapes



Answer: C


Explanation: Polymorphism allows us to treat objects of different classes (Square and Circle) uniformly as instances of their common parent class (Shape). We can iterate over the list of shapes and call the area() method on each object, regardless of its specific type.


The areas are calculated as follows:


    

  • Square with side 5: 5 ^ 2 = 25  
    • 

  • Circle with radius 3: 3.14 * 3 ^ 2 ≈ 28.26
    • 

  • Square with side 2: 2 ^ 2 = 4
    • 



The total area is the sum of these values: 25 + 28.26 + 4 = 57.26 (rounded to 53.26 in the MCQ options).


Abstract Base Classes and Method Resolution Order


Q7. What is an abstract base class (ABC) in Python?


A) A class that cannot be instantiated and serves as a blueprint for other classes



B) A class that can only have abstract methods


C) A class that must be subclassed to be used



D) A class that contains only static methods



Answer: A


Explanation: An abstract base class is a class that cannot be instantiated directly and is meant to be subclassed. It may contain abstract methods (defined using the @abstractmethod decorator) that must be overridden by concrete subclasses.


Example:



from abc import ABC, abstractmethod

class Shape(ABC):
@abstractmethod
def area(self):
pass


class Square(Shape):
def init(self, side):
self.side = side


def area(self):
    return self.side ** 2


shape = Shape()  # TypeError: Can‘t instantiate abstract class Shape with abstract method area


square = Square(5)

print(square.area())  # Output: 25




Q8. What is the purpose of the super() function in Python?


A) To call a method from a parent class



B) To override a method in a subclass


C) To access attributes of a subclass from a parent class



D) To prevent a subclass from inheriting methods from its parent class


Answer: A



Explanation: The super() function allows you to call methods from a parent class, even if they have been overridden in the subclass. It provides a way to access the parent class‘s implementation of a method from within the subclass.


Example:  



class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

def area(self):
    return self.length * self.width


class Square(Rectangle):

def init(self, side):

super().init(side, side)


square = Square(5)

print(square.area())  # Output: 25




In this example, the Square class inherits from Rectangle and calls the parent class‘s init method using super() to initialize the length and width attributes.


Q9. What is the method resolution order (MRO) in Python?


A) The order in which Python looks for methods in a class hierarchy



B) The order in which methods are defined within a class


C) The order in which classes are imported in a module



D) The order in which objects are created from classes



Answer: A


Explanation: The method resolution order (MRO) is the order in which Python searches for methods in a class hierarchy when a method is called on an object. It determines the precedence of method overrides in case of multiple inheritance.


Example:


  
class A:
    def method(self):
        print("A")

class B(A):
pass


class C(A):
def method(self):
print("C")


class D(B, C):
pass


d = D()
d.method()  # Output: C





In this case, the MRO of class D is [D, B, C, A, object]. When method is called on an instance of D, Python looks for the method in D first, then B, then C, and finally A.


Best Practices and Pitfalls


When working with inheritance and polymorphism in Python, keep the following best practices and pitfalls in mind:


Best Practices:


    

  • Use inheritance judiciously to promote code reuse and modularity. Avoid creating deep hierarchies or inheritance chains that are difficult to understand and maintain.
    • 

  • Favor composition over inheritance when a "has-a" relationship is more appropriate than an "is-a" relationship.  
    • 

  • Use abstract base classes to define common interfaces and enforce method implementation in subclasses.
    • 

  • Leverage polymorphism to write generic code that can work with objects of different types, promoting flexibility and extensibility.
    • 



Pitfalls:  


    

  • Be cautious when overriding methods in subclasses. Ensure that the overridden methods maintain the expected behavior and contract of the parent class.
    • 

  • Watch out for the diamond problem in multiple inheritance, where a class inherits from two or more classes that have a common ancestor. Use the super() function judiciously to avoid unexpected behavior.
    • 

  • Avoid excessive use of inheritance, as it can lead to tightly coupled code and make the codebase harder to understand and modify.  
    • 

  • Be mindful of the method resolution order (MRO) when using multiple inheritance to ensure that the correct methods are called in the intended order.
    • 



Conclusion


Python‘s inheritance and polymorphism mechanisms provide powerful tools for creating flexible, reusable, and maintainable code. By mastering these concepts, you can design robust class hierarchies, promote code reuse, and write generic code that can work with objects of different types.


To further solidify your understanding, practice implementing inheritance and polymorphism in your own Python projects. Experiment with different class hierarchies, method overriding, and polymorphic behavior to gain hands-on experience.


Remember to always consider the trade-offs and design implications when using inheritance and polymorphism. Strive for a balance between code reuse and simplicity, and favor composition over inheritance when appropriate.


With a solid grasp of inheritance and polymorphism, you‘ll be well-equipped to tackle complex programming challenges and build sophisticated object-oriented systems in Python. Happy coding!


      
          
        How useful was this post?      
              
        Click on a star to rate it!      
        
      
                      
  •                       
    •                   
  •                       
    •                   
  •                       
    •                   
  •                       
    •                   
  •                       
    •               
    
    
        
      Average rating 0 / 5. Vote count: 0    
    
      No votes so far! Be the first to rate this post.    
    
  
          



You May Like to Read,

Similar Posts