Python Object-Oriented Programming (OOP) Basics Exercises

The __init__ method in Python is a special method used for initializing new objects of a class. Here's what you need to know:

• Purpose: Automatically called when a new instance of a class is created.
• Functionality: Sets up initial values for instance attributes, allowing each object to have its own data.
• Python syntax: It always takes self as the first parameter, which refers to the newly created instance.

Example:

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

my_car = Car("Toyota", "Red")
print(my_car.brand)  # Output: Toyota

• Here, __init__ initializes brand and color for the new my_car object.
• Each object can have different values for its attributes, even though they come from the same class.

Key Takeaways:

• __init__ is not a constructor itself but an initializer; Python automatically creates the object first.
• Always include self as the first argument in __init__ and instance methods.
• Do not confuse __init__ with class-level variables or methods.

In Python, understanding instance and class variables is crucial for designing classes correctly:

• Instance Variables: Defined within __init__ using self. Each object has its own copy.
• Class Variables: Defined directly inside the class but outside any method. Shared across all instances of the class.

Example:

class Car:
    wheels = 4  # Class variable

    def __init__(self, color):
        self.color = color  # Instance variable

car1 = Car("Red")
car2 = Car("Blue")

print(car1.color)  # Output: Red
print(car2.color)  # Output: Blue
print(car1.wheels)  # Output: 4
print(car2.wheels)  # Output: 4

car1.color = "Green"
print(car1.color)  # Output: Green
print(car2.color)  # Output: Blue

Car.wheels = 6
print(car1.wheels)  # Output: 6
print(car2.wheels)  # Output: 6

• Changing an instance variable only affects that object:
• Changing a class variable affects all objects:

Key Takeaways:

• Use instance variables for data unique to each object.
• Use class variables for data shared across all instances.
• Be careful when modifying mutable class variables as changes affect all instances.

In Python, self is a reference to the current instance of the class. It is used to access instance variables and methods for that particular object.

• Purpose: Allows each object to maintain its own state while using the same methods.
• Usage: Always the first parameter in instance methods, including __init__.

Example:

class Car:
    def __init__(self, brand):
        self.brand = brand  # Instance variable

    def show_brand(self):
        print("Brand:", self.brand)

my_car = Car("Toyota")
my_car.show_brand()  # Output: Brand: Toyota

• Here, self.brand refers to the brand attribute of my_car.
• Without self, the method would not know which object’s attribute to access.

Key Takeaways:

• self differentiates between instance and local variables.
• It must be included in all instance methods; otherwise, Python raises an error.
• While self is just a naming convention, it is strongly recommended to always use it for clarity.

In Python, instance methods require an object to work with because they use the self parameter to refer to that specific instance.

• obj.method(): The instance automatically becomes self inside the method.
• Class.method(obj): You must manually pass the instance as an argument to serve as self.

Key Points:

• Python uses self to differentiate between data in different objects of the same class.
• Calling a method via the object is the standard approach and cleaner.
• Directly calling a method via the class is rarely used except in special situations.

Takeaway: Understanding how Python passes the instance to methods is critical to avoid errors when working with instance methods.

In Python, understanding how variables behave in classes is essential:

• Instance Variables: Each object gets its own separate copy. Modifying it in one object does not affect other objects.
• Class Variables: Shared across all instances. Changing it through the class affects all objects that haven’t overridden it.

Key Points:

• Instance variables are typically defined in __init__ using self.
• Class variables are defined at the class level, outside any method.
• Be cautious with mutable class variables (like lists or dictionaries), as changes affect all instances.

Takeaway: Use instance variables for object-specific data and class variables for data shared across objects.

Python differentiates between instance methods and class methods based on what they operate on:

• Instance Methods: Operate on a specific object. The object is automatically passed as self.
• Class Methods: Operate on the class itself rather than any specific object. The class is automatically passed as cls. They are defined with the @classmethod decorator.

Key Points:

• Instance methods are used for data unique to each object.
• Class methods are useful for operations that pertain to the class as a whole (like alternative constructors).
• Instance methods cannot be called without an object unless the object is manually provided as self.

Takeaway: Knowing when to use instance methods versus class methods is fundamental for designing Python classes efficiently.

In Python, when an object has an attribute with the same name as a class variable, the object’s own attribute takes precedence.

• Attribute Lookup Order: Python first checks the object’s namespace (instance variables). If the attribute is not found, it looks in the class namespace (class variables).
• Why this matters: This allows individual objects to override shared class-level data without affecting other instances.

Example Conceptually: If a class has a variable wheels = 4, and one object sets wheels = 6, accessing object.wheels will return 6 for that object, while other objects still see 4.

Key Points:

• Instance attributes shadow class attributes with the same name.
• This behavior allows flexibility: shared defaults via class variables, customizable per object via instance variables.

Takeaway: Always be aware of naming conflicts between instance and class attributes to avoid unexpected results.

This is an example of inheritance and polymorphism in Python:

• Inheritance: A child class can reuse methods and attributes of its parent class.
• Method Overriding (Polymorphism): If the child class defines a method with the same name as a parent method, the child’s version is used when called on a child object.

Conceptual Example: Suppose the parent class has a method display(). If the child class defines its own display(), calling child.display() executes the child’s method.

Key Points:

• Method overriding allows child classes to modify or extend parent behavior.
• Polymorphism ensures that the correct method is called based on the object type, not the reference type.

Takeaway: In Python OOP, child class methods override parent methods, which is a foundation of polymorphism.

Python supports encapsulation conceptually rather than strictly enforcing it:

• Public Attributes: Accessible from anywhere.
• Protected Attributes: Prefix with a single underscore _attribute. This is a convention to indicate it should not be accessed outside the class or its subclasses.
• Private Attributes: Prefix with double underscore __attribute. This triggers name mangling to make it harder to access from outside, but it is not fully private.

Key Points:

• Encapsulation in Python is more about convention and discipline rather than strict access modifiers.
• It helps prevent accidental modification of internal class attributes and methods.
• Python developers rely on naming conventions (_protected and __private) to indicate intended visibility.

Takeaway: Encapsulation in Python is implemented via naming conventions; understanding these is critical for designing safe and maintainable classes.

This is a subtle Python OOP behavior involving class variables and mutability:

• Shared State: Mutable class variables (like lists or dictionaries) are stored in the class namespace and shared among all instances.
• Pitfall: Modifying the mutable object in one instance (e.g., appending to a list) will affect all other instances that reference the same class variable.

Key Concepts:

• Instance variables are independent, but mutable class variables are shared.
• This can lead to unexpected behavior if you think each object has its own copy.
• Safe practice: initialize mutable variables inside __init__ to ensure each object has a separate copy.

Takeaway: Always be careful with mutable class variables; this is a common source of tricky bugs in Python OOP.

In Python, abstraction allows defining a common interface for a group of subclasses without implementing all functionality in the base class.

• Abstract Base Classes: Provided by the abc module.
• @abstractmethod: Decorator used to declare methods that must be implemented by subclasses.

Key Points:

• Abstraction in Python is conceptual and enforced via abstract base classes.
• Attempting to instantiate an abstract class directly raises an error.
• Subclasses must implement all abstract methods to be instantiable.

Takeaway: Understanding abstraction helps structure code cleanly, ensuring subclasses adhere to a required interface.

This question involves the subtle Python OOP concept of attribute shadowing:

• Class Attributes: Shared among all instances unless overridden.
• Instance Attributes: Unique to each object. If an instance defines an attribute with the same name as a class attribute, it shadows the class attribute.

Key Points:

• Modifying the attribute via the instance creates or updates the instance attribute only.
• The original class attribute remains unchanged, affecting other objects that do not override it.
• This allows individual objects to override default class behavior safely.

Takeaway: Attribute shadowing is a powerful Python OOP feature, but understanding how class and instance attributes interact is crucial to avoid subtle bugs.