Python Interview Questions and Answers – Top 50+

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True  — same value
print(a is b)   # False — different objects in memory
print(a is c)   # True  — c points to the same object as a

# Small integer caching — CPython caches -5 to 256
x = 256
y = 256
print(x is y)   # True (cached)

x = 257
y = 257
print(x is y)   # False (not cached — implementation detail)

import copy

original = [[1, 2], [3, 4]]

# Shallow copy — copies the outer object, inner objects are shared
shallow = copy.copy(original)
shallow[0].append(99)
print(original)   # [[1, 2, 99], [3, 4]] — AFFECTED!

original = [[1, 2], [3, 4]]

# Deep copy — recursively copies all nested objects
deep = copy.deepcopy(original)
deep[0].append(99)
print(original)   # [[1, 2], [3, 4]] — NOT affected

def demo(*args, **kwargs):
    print(args)    # tuple of positional args
    print(kwargs)  # dict of keyword args

demo(1, 2, 3, name="Alice", age=30)
# (1, 2, 3)
# {'name': 'Alice', 'age': 30}

# Unpacking when calling functions
nums = [1, 2, 3]
info = {"name": "Bob"}
demo(*nums, **info)   # unpacks list and dict

nums = [1, 2, 3, 4, 5]

# List comprehension (preferred — more Pythonic)
squares = [x**2 for x in nums if x % 2 == 0]
print(squares)  # [4, 16]

# Equivalent with map + filter
squares = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, nums)))
print(squares)  # [4, 16]

# Comprehensions are generally faster and more readable
# Also available: dict/set comprehensions and generator expressions
d = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}

data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]

# Fast (Python 3.7+ dicts maintain insertion order)
unique = list(dict.fromkeys(data))
print(unique)   # [3, 1, 4, 5, 9, 2, 6]

# Alternative using a seen set
def remove_dupes(lst):
    seen = set()
    return [x for x in lst if not (x in seen or seen.add(x))]

from collections import defaultdict, Counter

# defaultdict — supplies a default value for missing keys
word_count = defaultdict(int)
for word in ["apple", "banana", "apple", "cherry", "banana", "apple"]:
    word_count[word] += 1
print(dict(word_count))  # {'apple': 3, 'banana': 2, 'cherry': 1}

# Counter — specialised dict for counting
counts = Counter(["apple", "banana", "apple", "cherry", "banana", "apple"])
print(counts.most_common(2))   # [('apple', 3), ('banana', 2)]
print(counts["apple"])          # 3
print(counts["missing"])        # 0 (no KeyError!)

from operator import itemgetter

people = [
    {"name": "Alice", "age": 30},
    {"name": "Bob",   "age": 25},
    {"name": "Carol", "age": 35},
]

# Sort by age ascending
by_age = sorted(people, key=lambda p: p["age"])
print([p["name"] for p in by_age])   # ['Bob', 'Alice', 'Carol']

# Sort by age descending
by_age_desc = sorted(people, key=itemgetter("age"), reverse=True)

# Sort by multiple keys: primary age, secondary name
by_multi = sorted(people, key=lambda p: (p["age"], p["name"]))

s = "Hello, World!"

print(s[0:5])     # Hello
print(s[7:])      # World!
print(s[:5])      # Hello
print(s[-6:])     # orld!  — last 6 characters
print(s[::2])     # Hlo ol!  — every other char
print(s[::-1])    # !dlroW ,olleH — reverse

lst = list(range(10))
print(lst[2:8:2])  # [2, 4, 6]

lst = [1, 2, 3]

lst.append([4, 5])   # Adds ONE element (the list itself)
print(lst)           # [1, 2, 3, [4, 5]]

lst = [1, 2, 3]
lst.extend([4, 5])   # Adds EACH element of the iterable
print(lst)           # [1, 2, 3, 4, 5]

lst.insert(1, 99)    # Inserts 99 at index 1
print(lst)           # [1, 99, 2, 3, 4, 5]

class MyClass:
    count = 0

    def instance_method(self):
        # Has access to self (instance) and MyClass (via self.__class__)
        return f"instance, count={MyClass.count}"

    @classmethod
    def class_method(cls):
        # Has access to cls (the class itself, not the instance)
        # Used as alternative constructors
        cls.count += 1
        return cls()

    @staticmethod
    def static_method(x, y):
        # No access to self or cls — just a regular function namespaced to the class
        return x + y

obj = MyClass()
MyClass.class_method()        # Increments count
MyClass.static_method(3, 4)  # Returns 7

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

class B(A):
    def hello(self): return "B"

class C(A):
    def hello(self): return "C"

class D(B, C):  # Diamond inheritance
    pass

d = D()
print(d.hello())   # "B" — MRO: D → B → C → A
print(D.__mro__)   # (D, B, C, A, object)

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

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

    def __str__(self):             # human-readable string
        return f"({self.x}, {self.y})"

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

    def __len__(self):             # len(v)
        return 2

    def __eq__(self, other):       # v1 == v2
        return self.x == other.x and self.y == other.y

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)   # (4, 6)
print(len(v1))   # 2

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    @property
    def area(self):
        import math
        return math.pi * self._radius ** 2

c = Circle(5)
print(c.radius)   # 5   — looks like attribute access, not method call
c.radius = 10     # triggers the setter
print(c.area)     # 314.159...

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        pass

    @abstractmethod
    def perimeter(self) -> float:
        pass

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h

    def area(self):
        return self.w * self.h

    def perimeter(self):
        return 2 * (self.w + self.h)

# Shape()       # TypeError: Can't instantiate abstract class
r = Rectangle(3, 4)
print(r.area())        # 12

from dataclasses import dataclass, field

@dataclass(order=True)
class Employee:
    name: str
    department: str
    salary: float = 50_000.0
    skills: list = field(default_factory=list)

    def give_raise(self, pct):
        self.salary *= (1 + pct / 100)

e = Employee("Alice", "Engineering", 90_000)
e.skills.append("Python")
print(e)          # Employee(name='Alice', department='Engineering', salary=90000.0, skills=['Python'])
print(e == Employee("Alice", "Engineering", 90_000.0, ["Python"]))  # True

def make_multiplier(n):
    def multiplier(x):
        return x * n   # 'n' is closed over from the enclosing scope
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))   # 10
print(triple(5))   # 15

# Inspect closed variables
print(double.__closure__[0].cell_contents)  # 2

import functools, time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function(n):
    return sum(range(n))

slow_function(10_000_000)
# slow_function took 0.3142s

from functools import lru_cache

@lru_cache(maxsize=None)   # cache all results
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))   # Instant — without cache, this would take exponential time
print(fibonacci.cache_info())  # CacheInfo(hits=48, misses=51, maxsize=None, currsize=51)

from functools import reduce

nums = [1, 2, 3, 4, 5]

# map — apply function to every element
squares = list(map(lambda x: x**2, nums))    # [1, 4, 9, 16, 25]

# filter — keep elements where function returns True
evens = list(filter(lambda x: x % 2 == 0, nums))   # [2, 4]

# reduce — accumulate to a single value
product = reduce(lambda acc, x: acc * x, nums)  # 120  (1*2*3*4*5)

from typing import Optional, List, Dict, Tuple, Union

def process_data(
    items: List[int],
    config: Optional[Dict[str, str]] = None,
) -> Tuple[int, float]:
    total = sum(items)
    avg = total / len(items)
    return total, avg

# Python 3.10+ union syntax
def parse(value: int | str) -> str:
    return str(value)

# Type hints are NOT enforced at runtime — use mypy or pyright to check them

def func(pos_only, /, normal, *, kw_only):
    print(pos_only, normal, kw_only)

# pos_only must be positional (before /)
# normal can be positional or keyword
# kw_only must be keyword (after *)

func(1, 2, kw_only=3)          # OK
func(1, normal=2, kw_only=3)   # OK
# func(pos_only=1, ...)         # TypeError

def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError as e:
        print(f"Cannot divide by zero: {e}")
        return None
    except TypeError as e:
        print(f"Invalid types: {e}")
        return None
    else:
        # Runs only if NO exception occurred
        print("Division successful")
        return result
    finally:
        # ALWAYS runs — good for cleanup (closing files, releasing locks)
        print("Division attempted")

class AppError(Exception):
    """Base class for application exceptions."""
    pass

class ValidationError(AppError):
    def __init__(self, field, message):
        self.field = field
        super().__init__(f"Validation failed for '{field}': {message}")

try:
    raise ValidationError("email", "Invalid format")
except ValidationError as e:
    print(e)          # Validation failed for 'email': Invalid format
    print(e.field)    # email