Object-Oriented Programming practice questions

Use 'pass' as the method body

Why wrong: pass does nothing and allows accidental calls.

Delete the method from the base class using 'del'

Why wrong: Deleting the method would prevent any call, including from subclasses.

Add a comment '# override in subclass' inside the method body

Why wrong: Comments do not enforce overriding.

Use a property decorator on a class method

Why wrong: A property on a class method requires an instance and does not prevent external modification.

Define a public class attribute and document it as read-only

Why wrong: Documentation does not prevent modification.

Define an instance attribute inside __init__

Why wrong: Instance attributes are not shared.

Composition

Why wrong: Composition involves 'has-a' relationships, not overriding.

Aggregation

Why wrong: Aggregation is a form of composition.

Inheritance

Why wrong: Inheritance is the mechanism, but the question asks about the pattern.

Encapsulation

Why wrong: Encapsulation is about data hiding.

Inheritance

Why wrong: Inheritance establishes parent-child relationships but not the behavior variation.

Abstraction

Why wrong: Abstraction simplifies complex reality, but polymorphism is the direct solution.

The 'log' method is defined as a class method using @classmethod

Why wrong: Class methods share class-level state.

The file handle is stored as a private attribute __file

Why wrong: Private attributes are still class-level if defined at class level.

The subclass overrides the 'log' method

Why wrong: Overriding does not affect sharing of file handle if the base class uses a class attribute.

Because the attribute is defined as a class attribute, not instance attribute

Why wrong: Name mangling applies regardless of attribute type.

Because the subclass overrides the method that uses the attribute

Why wrong: Override does not cause AttributeError on the attribute itself.

Because the attribute is private and not inherited

Why wrong: Private attributes are inherited but name-mangled.

Interface Segregation Principle

Why wrong: ISP is about keeping interfaces small.

Single Responsibility Principle

Why wrong: SRP is about each class having one responsibility.

Dependency Inversion Principle

Why wrong: DIP is about high-level modules not depending on low-level modules.

3

Why wrong: Only car1's instance attribute changed.

AttributeError

Why wrong: No error; class attribute exists.

None

Why wrong: car2 has no instance attribute, so it uses the class attribute.

The assignment is silently ignored

Why wrong: It raises an error.

Python issues a warning and adds the attribute

Why wrong: No warning; raises AttributeError.

The attribute 'z' is added dynamically

Why wrong: Slots prevents dynamic attributes.

self.work()

Why wrong: This calls the overridden method recursively.

super(Manager, self).work()

Why wrong: This is correct but more verbose; however, it is not wrong. The question expects D as best.

Employee.work(self)

Why wrong: This bypasses MRO and may cause issues with multiple inheritance.

None

Why wrong: a is set to 10, not None.

AttributeError

Why wrong: a is defined in B's __init__.

0

Why wrong: a is set to 10.

Define borrow as a static method and override in subclasses

Why wrong: Static methods do not participate in polymorphic overriding in the same way.

Define borrow as a class method and override in subclasses

Why wrong: Class methods are not intended for instance-level polymorphic behavior.

Define borrow with pass and let subclasses override

Why wrong: A pass method can be called directly and does not enforce overriding.

Python always calls the method from the last base class

Why wrong: Python uses C3 linearization, not a simple last-base rule.

The 'foo' method in class B is defined after class A's 'foo' in the same file

Why wrong: Definition order in the file does not affect MRO.

Python uses depth-first, left-to-right resolution

Why wrong: Python uses C3 linearization, not depth-first.

class MyClass: attr: int = 0

Why wrong: This is a type annotation, not a class attribute assignment (though it may be interpreted as such in some contexts, it is not a standard way).

class MyClass: def set_attr(self): MyClass.attr = 0

Why wrong: This defines a method that sets a class attribute, but the attribute is not defined at class creation.

class MyClass: def __init__(self): self.attr = 0

Why wrong: This creates an instance attribute, not a class attribute.

AttributeError: 'Derived' object has no attribute 'get_x'

Why wrong: get_x is inherited from Base.

10

Why wrong: Base.__init__ is not called, so _x is not set to 10.

AttributeError: 'Derived' object has no attribute '_x'

Why wrong: Derived has _x set in its __init__.

Declare 'self.balance' as a class variable

Why wrong: Class variable is also public and directly accessible.

Declare 'self.balance' and provide a getter method

Why wrong: Public attribute can be accessed directly without the getter.

Declare 'self._balance' and provide a getter method

Why wrong: Single underscore is a naming convention only, does not prevent direct access.

'Car started Vehicle started'

Why wrong: No super call is made in the override.

'Vehicle started'

Why wrong: This would be the output without overriding, but Car overrides start.

AttributeError

Why wrong: The method exists in both classes, no error occurs.

__getitem__ and __contains__

Why wrong: __contains__ is for membership testing, not required for sequence behavior.

__setitem__ and __delitem__

Why wrong: These are for item assignment and deletion, not necessary for read-only indexing.

__iter__ and __next__

Why wrong: These are for iteration, not indexing.

Define a new __init__ in Dog that does not call super

Why wrong: The parent's __init__ won't run, so 'name' attribute is missing.

Dog will automatically inherit the __init__ method

Why wrong: If Dog doesn't define __init__, it inherits Animal.__init__, but that requires 'name' parameter. However, the question implies Dog must call it properly; if called without argument, TypeError.

Use a decorator to initialize

Why wrong: No standard decorator for this purpose.

To access class variables without creating an instance

Why wrong: That is the purpose of class methods.

To allow the method to be overridden in subclasses

Why wrong: Static methods can be overridden, but that's not the primary purpose.

To enforce that the method cannot be called from an instance

Why wrong: Static methods can be called from instances.