Question 1

__repr__ vs __str__

Accepted Answer

When Python needs `__str__` and the class does not define it, the lookup falls back to `__repr__`. This means defining only `__repr__` covers both the developer view (REPL, `repr()`) and the user-facing view (`print()`, `str()`). The reverse is not true: defining only `__str__` still leaves `repr()` showing the default `<ClassName object at 0x...>` output.

Question 2

Role of __init__ and self

Accepted Answer

Every instance method receives the calling object as its first argument, and by convention that parameter is named `self`. Python passes it automatically - you never include it when calling the method, only when defining it. Without `self`, an instance method would have no way to read or modify the object's own attributes.

Question 3

Class vs instance attribute lookup

Accepted Answer

The class attribute `count` stays 0 because the assignment in `__init__` creates a brand-new instance attribute on `c`, shadowing the class attribute for that object only. Accessing `Counter.count` still finds the original class-level value. The instance and the class each have their own `count` at this point.

Question 4

What __init__ does

Accepted Answer

__init__ is the initializer, not the constructor - the actual allocation happens in __new__. By the time __init__ runs, the object already exists; your job is to set it up by assigning to self. The distinction rarely matters in daily Python, but it matters when you subclass immutable types like int or str, where you must override __new__ instead.

Question 5

super().__init__ in subclass

Accepted Answer

`super().__init__(name)` delegates to `Animal.__init__`, which sets `self.name` on the `Dog` instance. Then `self.breed = breed` adds the breed. Because both lines run, `d` ends up with both attributes set correctly. If `super().__init__` were omitted, accessing `d.name` would raise `AttributeError` since `Animal.__init__` never ran.

Question 6

Mutable class attribute shared state

Accepted Answer

The list `members` is a class attribute shared by every instance. Calling `self.members.append(...)` mutates the same list in place - it does not create an instance attribute, because append modifies the existing object rather than rebinding the name. Both `a` and `b` refer to the same list, so after both calls the list has two entries. To give each instance its own list, initialize it in `__init__` with `self.members = []`.

Question 7

What @dataclass generates

Accepted Answer

By default, `@dataclass` generates three methods: `__init__` (setting each annotated field as a parameter), `__repr__` (a readable string showing all fields), and `__eq__` (comparing instances field by field). It does not generate `__str__` or `__hash__` by default. Pass `order=True` to also get `__lt__`, `__le__`, `__gt__`, and `__ge__`.

Question 8

Operator overloading with __add__

Accepted Answer

The `+` operator calls `__add__`, which creates a new `Money` instance with the summed amounts. `print()` then calls `__str__`, which falls back to `__repr__` since `__str__` is not defined, producing `Money(35)`. Notice that `a + b` does not return a plain integer - it returns a `Money` object, which is the whole point of `__add__`: keeping the type consistent across operations.

Question 9

__repr__ vs __str__

Accepted Answer

When you call repr(obj) or inspect an object in a REPL, Python calls __repr__. When you call str(obj) or print(obj), Python calls __str__, falling back to __repr__ if __str__ is not defined. A good __repr__ lets you reconstruct the object: Point(x=1, y=2). A good __str__ just describes it clearly: '(1, 2)'. If you only implement one, implement __repr__ - it covers both cases.

Question 10

classmethod vs staticmethod

Accepted Answer

A classmethod is bound to the class, not an instance - it gets cls automatically and can access or modify class-level state. A staticmethod is just a regular function that lives in the class namespace for organizational reasons; Python passes nothing extra to it. Use classmethods for alternative constructors (Date.from_string(...)) and staticmethods for utility functions that logically belong to the class but don't need any class or instance data.

Question 11

What super() does

Accepted Answer

super() does not simply return 'the parent' - it follows the MRO, which matters in multiple inheritance where the next class in line may not be the direct parent. The most common use is super().__init__() in a child class to run the parent's initializer before adding child-specific setup. Always use super() instead of Parent.__init__(self) directly, because super() handles multiple inheritance correctly and the direct call does not.

Question 12

Shadowing a class attribute via assignment

Accepted Answer

When you do `c1.debug = True`, Python creates an instance attribute on `c1` that shadows the class attribute for that object only. Later setting `Config.debug = False` changes the class attribute, but `c1` already has its own instance-level `debug`, so looking it up on `c1` still finds `True`. `c2` has no instance attribute, so it reads from the class and gets `False`. This shadowing behavior is one of the most common OOP gotchas in Python.

Question 13

Method resolution with super() chain

Accepted Answer

Python resolves methods using the MRO (Method Resolution Order), which for `C` is `[C, B, A]`. When `C.greet` calls `super().greet()`, it gets `B.greet`. `B.greet` then calls its own `super().greet()`, which follows the MRO and finds `A.greet`. The results concatenate as the call stack unwinds: `A` returns `"A"`, `B` prepends `"B"` to get `"BA"`, and `C` prepends `"C"` to get `"CBA"`. This chaining behavior is why `super()` is preferred over hardcoding parent class names.

Question 14

__eq__ and its effect on __hash__

Accepted Answer

Python enforces the contract that objects which compare equal must have the same hash. If you define `__eq__` without `__hash__`, Python sets `__hash__ = None` on your class, making instances unhashable. Attempting to use them in a set or as dict keys then raises `TypeError: unhashable type`. To restore hashability, explicitly define `__hash__` - for example, by hashing a tuple of the fields that define equality.

Question 15

What __enter__ and __exit__ do

Accepted Answer

Implementing __enter__ and __exit__ makes your class a context manager, usable with the with statement. __enter__ receives the instance and can return a value bound to the as variable: with open('f') as fh. __exit__ receives the exception type, value, and traceback if one occurred. Returning True from __exit__ suppresses the exception; returning None or False lets it propagate. This protocol is what makes with guarantee cleanup - the same guarantee that finally gives you, but packaged reusably.