Mastering Python OOP: 35+ MCQs to Test Your Skills

Object-oriented programming (OOP) is a fundamental paradigm in modern software development, and Python is an excellent language for learning and applying OOP principles. By organizing code into classes and objects, you can write more modular, reusable, and maintainable programs.

In this article, we‘ll review the core concepts of OOP in Python and provide over 35 multiple-choice questions to test and strengthen your knowledge. Whether you‘re a beginner looking to learn OOP from scratch or an experienced developer brushing up on your skills, these MCQs will help deepen your understanding. Let‘s get started!

Classes and Objects

At the heart of OOP are classes and objects. A class is a blueprint for creating objects, defining a set of attributes (data) and methods (functions) that the objects will have. An object is a specific instance of a class.

Here‘s an example of a simple Python class:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} says woof!")

my_dog = Dog("Buddy", 5)
print(my_dog.name)  # Output: Buddy
my_dog.bark()       # Output: Buddy says woof!

Now let‘s test your knowledge with a few questions:

Question 1

What is a class in Python?
A) A specific instance of an object
B) A blueprint for creating objects
C) A data type for storing collections
D) A conditional branching statement

Answer: B
Explanation: A class provides a blueprint or template for creating objects. It defines a set of attributes and methods that the objects of that class will have.

Question 2

What is the purpose of the __init__ method in a Python class?
A) To create a new object
B) To initialize an object‘s attributes when it‘s created
C) To delete an object when it‘s no longer needed
D) To print an object‘s string representation

Answer: B
Explanation: The init method is a special "constructor" method that gets called automatically when a new object is instantiated from a class. It initializes the object‘s attributes with the provided values.

Question 3

How do you create an object from a class in Python?
A) By calling the class name followed by parentheses, passing any required arguments
B) By using the "new" keyword before the class name
C) By defining the class within the object
D) By appending parentheses to the end of the class definition

Answer: A
Explanation: To instantiate an object from a class, simply call the class name followed by parentheses, passing in any arguments required by the init method. The "new" keyword is not used in Python.

Inheritance and Polymorphism

Inheritance is a key feature of OOP that allows you to define a new class based on an existing class. The new subclass inherits attributes and methods from the parent superclass, allowing you to reuse code and create hierarchical relationships between classes.

Polymorphism means "many forms" and allows you to define methods in a subclass that override the implementation in the superclass. This lets objects of different but related types be handled in a uniform way.

Here‘s an example demonstrating inheritance and polymorphism:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

class Cat(Animal):
    def speak(self):
        print(f"{self.name} says meow!")

class Dog(Animal):    
    def speak(self):
        print(f"{self.name} says woof!")

animals = [Cat("Whiskers"), Dog("Buddy"), Cat("Luna")]

for animal in animals:
    animal.speak()

Output:

Whiskers says meow! 
Buddy says woof!
Luna says meow!

Let‘s reinforce these concepts with some questions:

Question 4

What is inheritance in OOP?
A) Allowing a class to have multiple superclasses
B) Defining a new class based on an existing class
C) Overriding a method in a superclass
D) Creating an object from a class

Answer: B
Explanation: Inheritance allows you to define a new class (subclass) based on an existing class (superclass). The subclass inherits attributes and methods from its parent, allowing code reuse and hierarchical relationships.

Question 5

How do you define a subclass in Python?
A) By listing the superclass name in parentheses after the subclass name in the class definition
B) By using the "extends" keyword before the superclass name
C) By indenting the subclass definition under the superclass
D) By calling the superclass constructor inside the subclass constructor

Answer: A
Explanation: To create a subclass, simply include the superclass name in parentheses after the subclass name when defining the subclass. Python uses this syntax instead of an "extends" keyword.

Question 6

What is polymorphism in OOP?
A) Defining a method in a subclass with the same name as a method in its superclass
B) Creating objects of different but related types that can be handled uniformly
C) Accessing a superclass‘s attributes from a subclass
D) Preventing a subclass from overriding a superclass‘s methods

Answer: B
Explanation: Polymorphism allows objects of different classes that share a common superclass to be treated as instances of the superclass. This allows methods to be written generically to work with objects of multiple types.

Encapsulation and Abstraction

Encapsulation is the bundling of data (attributes) and functions (methods) into a single unit (class),
and restricting access to the internal details from the outside. This protects the data from unintended modification and misuse.

Abstraction is the process of hiding complex implementation details and exposing only the essential features to the user. It allows you to create simplified, high-level interfaces for interacting with objects.

Python doesn‘t have strict access controls like "private" and "public" keywords, but follows a naming convention to indicate intended visibility:

• Attributes/methods named with a single leading underscore (e.g. "_attr") are considered "private" and should only be accessed within the class
• Double leading underscores ("__attr") trigger name mangling, strongly discouraging access from outside the class

Here‘s an example of encapsulation in a Python class:

class BankAccount:
    def __init__(self, account_number, balance=0):
        self._account_number = account_number  
        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

Now let‘s test your knowledge of these concepts:

Question 7

What is the purpose of encapsulation in OOP?
A) To bundle data and functions into a class
B) To hide the internal details of a class and restrict access from outside
C) To allow a class to inherit from multiple superclasses
D) To override methods in a superclass

Answer: B
Explanation: Encapsulation protects the internal state of an object from being accessed or modified inappropriately from outside the class. It allows the class to control how its attributes are accessed and maintains the integrity of the data.

Question 8

In Python, how can you indicate that an attribute should be treated as non-public?
A) Prefix the attribute name with a single underscore
B) Prefix the attribute name with two underscores
C) Suffix the attribute name with an underscore
D) Capitalize the first letter of the attribute name

Answer: A
Explanation: By convention, a single leading underscore before an attribute name (e.g. "_attr") signals that it should be considered "private" and not accessed directly from outside the class. Python doesn‘t have true access control, but this naming style is widely followed.

Question 9

What happens when you prefix an attribute with double underscores ("__") in Python?
A) The attribute becomes read-only
B) The attribute is only accessible within the class
C) The attribute name is "mangled" to discourage access from outside the class
D) The attribute is deleted when the object is destroyed

Answer: C
Explanation: Double underscore prefix triggers name mangling – Python rewrites the attribute name to include the class name, e.g. "_ClassName__attr". This strongly discourages accessing the attribute from outside the class, as the mangled name must be used.

Putting It All Together

As you can see, the pillars of OOP – encapsulation, inheritance, polymorphism – work together to help you write well-organized, flexbile, and maintainable code. Classes allow you to encapsulate related data and behaviors, inheritance lets you reuse and specialize code, while polymorphism enables you to write generic code that works with multiple related types.

To close out, here are a few more MCQs touching on different aspects of OOP in Python:

Question 10

What is the difference between a class attribute and an instance attribute?
A) Class attributes are shared by all instances, instance attributes are unique to each object
B) Class attributes can only be accessed inside the class, instance attributes can be accessed from outside
C) Class attributes cannot be modified, instance attributes can
D) Class attributes require more memory than instance attributes

Answer: A
Explanation: Class attributes are defined directly on the class, outside of any methods, and are shared by all instances of that class. Instance attributes are defined inside methods (usually init) and are specific to each object created from the class.

Question 11

What is the purpose of the self parameter in Python class methods?
A) To refer to the class itself
B) To refer to the object that the method is called on
C) To specify the data type of the return value
D) To define a static class attribute

Answer: B
Explanation: In Python, class methods always take self as the first parameter (by convention). self refers to the object that the method is called on, allowing you to access its attributes and call other methods on it.

Question 12

How can you check if an object is an instance of a specific class in Python?
A) Using the type() function
B) Using the isinstance() function
C) Using the is operator
D) Using the in operator

Answer: B
Explanation: The isinstance(obj, class) function checks if the given object obj is an instance of the specified class (or a subclass thereof). type(obj) returns the class that obj is an instance of, but cannot check inheritance. The is operator tests object identity, not type.

Conclusion

We‘ve covered a lot of ground in this deep dive into Python OOP concepts! Mastering OOP takes practice, but it‘s a critical skill for any serious Python developer. By understanding classes, objects, inheritance, polymorphism, encapsulation, and abstraction, you‘ll be able to architect cleaner, more efficient, and more sophisticated programs.

Here are a few tips for continuing to learn and apply OOP principles:

• Read the official Python docs on classes and OOP
• Study open-source Python projects on GitHub to see OOP in action
• Build your own classes to model real-world objects and relationships
• Experiment with inheritance to create specialized classes and behaviors
• Practice using polymorphism to write flexible and generic code

OOP is also a fundamental part of many popular Python libraries and frameworks, such as:

• Django and Flask for web development
• NumPy and pandas for data analysis
• Pygame and Panda3D for game development
• TensorFlow and PyTorch for machine learning

By deepening your knowledge of OOP, you‘ll be better equipped to leverage these powerful tools and contribute to complex software projects. Keep coding and happy learning!