Python Object-Oriented Programming (OOP) Basics Exercises

This code illustrates a foundational OOP concept in Python: creating and using objects from classes.

• The class Dog includes a constructor method __init__, which initializes the object with a name attribute.
• buddy = Dog("Buddy") creates a new instance (object) of the Dog class and assigns "Buddy" to the name attribute using self.name = name.
• print(buddy.name) accesses the attribute of the object using dot notation.

This approach allows developers to model and manage real-world entities like dogs, users, cars, or products in a structured way, making the codebase easier to understand and maintain.

The __init__ method initializes the name attribute, and the greet() method uses it to return a greeting. Since we create the object with "Alice", the method returns "Hello, Alice".

Unlike some other languages, Python does not use a special keyword like new to create objects. You simply call the class name with any required arguments, for example: obj = MyClass(). Therefore, the correct answer is: No keyword, just use class name.

The self keyword in Python is used to refer to the current instance of the class. It allows instance attributes and methods to be accessed and modified. It must be the first parameter of instance methods, though it is passed automatically by Python during method calls.

In Python, to inherit from another class, you include the parent class in parentheses after the class name. For example: class Dog(Animal):. This allows Dog to inherit attributes and methods from Animal.

This code demonstrates method overriding, a key concept in OOP where a subclass can provide its own implementation of a method defined in its superclass. The class Dog inherits from Animal and overrides the speak method. When pet.speak() is called, Python looks for the speak method in the Dog class first, and finds the overridden version that returns "Bark". Therefore, it does not call the version from Animal.

This is an example of using super() to call the constructor of the parent class. When the object b of class B is created, its __init__ method is called. Inside it, super().__init__() invokes the constructor of its parent class A, printing "A init", followed by "B init" from class B. This demonstrates proper constructor chaining in inheritance using super().

Encapsulation is the concept of restricting direct access to some of an object's components, which is achieved in Python by defining private variables (usually by prefixing the variable name with an underscore). This helps in protecting the internal state of the object and allows modification only through well-defined interfaces such as getter and setter methods. It is a crucial OOP principle that ensures controlled data access and enhances security and code maintainability.

This is another example of method overriding. The class Child overrides the show() method defined in its superclass Parent. When c.show() is called, Python searches for the method in Child first and executes it, printing "Child". This demonstrates dynamic (runtime) method resolution in OOP.

The correct syntax for defining a class in Python is class MyClass(): or simply class MyClass:. Parentheses are optional unless you want to inherit from another class. The other options are syntactically incorrect: square brackets are not used in class headers, def class is invalid syntax, and MyClass class is more like Java-style, which is not valid in Python.

When the object b is created from class B, its __init__() method is executed. Inside this constructor, super().__init__() calls the constructor of class A, which sets self.var to 'A'. Immediately after, class B overrides this value by setting self.var to 'B'. So the final value of b.var is 'B'. This shows how subclass constructors can override the state initialized by the superclass.

Even though the Derived class does not define its own __init__() method, Python automatically calls the parent class's constructor if super().__init__() is not overridden. So when d = Derived() is executed, the __init__() method from Base is called and "Base init" is printed. This behavior ensures that base class initialization logic is inherited if not explicitly changed.

In Python, private attributes are not enforced like in some statically typed languages, but convention and name mangling are used. Prefixing an attribute with __ (double underscore) triggers name mangling, which changes the name internally (e.g., __age becomes _ClassName__age) to make it harder to access from outside the class. This provides a level of encapsulation, although not strict enforcement.

A class method in Python is defined using the @classmethod decorator and must take cls as its first parameter instead of self. This allows the method to access and modify class-level variables or call other class methods. Class methods can be called using both the class name and the instance, but they operate on the class rather than instance-level data.

Multiple inheritance in Python allows a class to inherit attributes and methods from more than one parent class. For example, class C(A, B): means class C inherits from both A and B. This can provide flexibility but also introduce complexity such as the diamond problem, where Python uses the Method Resolution Order (MRO) to determine the order in which base classes are initialized and methods are called.

In this example, class B inherits from A but does not call super().__init__() in its constructor. Therefore, the constructor of class A is never executed, and self.value is assigned directly in B to 200. As a result, print(b.value) outputs 200. This demonstrates how not calling the parent constructor can skip important initializations from the base class.

This is a trick involving how super() works with multiple inheritance levels. In super(B, self), Python starts searching for the method from the class right after B in the MRO of C, which is A. Hence, A.greet() is called, and "Hello from A" is printed. Even though it looks strange, the syntax is valid and works with Python's method resolution order rules.

Instance variables in Python must be assigned using the self reference, which binds them to the object. Statements like self.name = "John", setattr(self, "name", "John"), and self.__dict__["name"] = "John" all correctly assign an attribute to the instance. However, name = "John" simply creates a local variable inside the method, not associated with the instance. Thus, this does not become an instance attribute.

count is a class variable, which is shared among all instances of the class. In the constructor, Test.count += 1 increments the same class-level variable every time a new object is created. Since three instances are created (a, b, and c), Test.count becomes 3. Class variables are useful for keeping shared data like counts or configuration among instances.

Even though the class X does not define its own __init__ method, Python provides one by default through inheritance from the base object class. So x does indeed have the __init__ method via inheritance. The function hasattr(x, '__init__') returns True because Python automatically includes fundamental methods in all classes, even empty ones.