OOP Interview Questions

class MyClass:
    count = 0

    def instance_method(self):   # access self & class
        return self

    @classmethod
    def class_method(cls):        # access class, not instance
        return cls.count

    @staticmethod
    def static_method(x):        # no self or cls
        return x * 2

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v = Vector(1, 2) + Vector(3, 4)  # Vector(4, 6)

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name.title()

    @name.setter
    def name(self, value):
        if not value: raise ValueError("Name required")
        self._name = value

p = Person("alice")
print(p.name)   # Alice  (via @property getter)
p.name = "bob" # calls @name.setter

class Point:
    __slots__ = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y

# p.z = 1  → AttributeError: 'Point' object has no attribute 'z'

      A
     / \
    B   C
     \ /
      D      ← Which A.__init__ does D call?

class A:
    def hello(self): print("A")

class B(A):
    def hello(self): print("B"); super().hello()

class C(A):
    def hello(self): print("C"); super().hello()

class D(B, C): pass

D().hello()        # B → C → A  (MRO order)
print(D.__mro__)   # (D, B, C, A, object)

# Inheritance: Car IS-A Vehicle
class Car(Vehicle): ...

# Composition: Car HAS-A Engine
class Engine:
    def start(self): print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()   # composed

    def start(self):
        self.engine.start()

# Method 1: __new__
class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

# Method 2: via Metaclass
class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

# Verify
a, b = Singleton(), Singleton()
print(a is b)  # True

import copy

class Address:
    def __init__(self, city): self.city = city

class Person:
    def __init__(self, addr): self.addr = addr

p1 = Person(Address("NYC"))
p2 = copy.copy(p1)      # shallow — p2.addr is p1.addr
p3 = copy.deepcopy(p1)  # deep   — p3.addr is a new object

p2.addr.city = "LA"
print(p1.addr.city)  # LA  ← shallow copy shares nested obj
print(p3.addr.city)  # NYC ← deep copy is independent

# Every class is an instance of its metaclass
print(type(int))    # <class 'type'>
print(type(type))   # <class 'type'>

# Custom metaclass: enforce method naming convention
class EnforceLower(type):
    def __new__(mcs, name, bases, namespace):
        for key in namespace:
            if key.startswith('_'): continue
            if key != key.lower():
                raise TypeError(f"Method '{key}' must be lowercase")
        return super().__new__(mcs, name, bases, namespace)

class MyModel(metaclass=EnforceLower):
    def save(self): pass       # OK
    # def Save(self): pass   # → TypeError