Python Interview Preparation: Complete Guide for 2026

import gc
  import sys
  
  class Node:
      def __init__(self, name):
          self.name = name
          self.parent = None
  
      def __del__(self):
          print(f"Node {self.name} destructor called")
  
  def make_cycle():
      a = Node("A")
      b = Node("B")
      a.parent = b
      b.parent = a  # reference cycle: each node's refcount never drops to 0
      print("refcount(a):", sys.getrefcount(a))
  
  make_cycle()
  print("Local names 'a' and 'b' are gone, but the cycle keeps both alive")
  gc.collect()  # the generational cyclic collector finds and frees the cycle
  print("Cycle collected")

# BUG: the default list is created ONCE, when the function is defined
  def add_item(item, bucket=[]):
      bucket.append(item)
      return bucket
  
  print(add_item("a"))  # ['a']
  print(add_item("b"))  # ['a', 'b']  <- unexpected! same list reused every call
  
  # FIX: use a None sentinel and create a fresh object per call
  def add_item_fixed(item, bucket=None):
      if bucket is None:
          bucket = []
      bucket.append(item)
      return bucket
  
  print(add_item_fixed("a"))  # ['a']
  print(add_item_fixed("b"))  # ['b']

import time
  import functools
  from contextlib import contextmanager
  
  def retry(times=3, exceptions=(Exception,)):
      """Decorator factory: retries the wrapped function on failure."""
      def decorator(func):
          @functools.wraps(func)  # preserves __name__, __doc__, signature
          def wrapper(*args, **kwargs):
              last_exc = None
              for attempt in range(1, times + 1):
                  try:
                      return func(*args, **kwargs)
                  except exceptions as exc:
                      last_exc = exc
                      print(f"Attempt {attempt} failed: {exc}")
              raise last_exc
          return wrapper
      return decorator
  
  @retry(times=3, exceptions=(ConnectionError,))
  def fetch(url):
      ...
  
  @contextmanager
  def timed_block(label):
      start = time.perf_counter()
      try:
          yield  # control returns to the 'with' block body here
      finally:
          elapsed = time.perf_counter() - start
          print(f"{label} took {elapsed:.4f}s")
  
  with timed_block("fetch"):
      fetch("https://api.example.com")

import asyncio
  import time
  
  async def fetch_page(session_id: int, delay: float) -> str:
      print(f"[{session_id}] request sent")
      await asyncio.sleep(delay)  # simulates non-blocking network I/O
      print(f"[{session_id}] response received")
      return f"page-{session_id}"
  
  async def main():
      start = time.perf_counter()
      results = await asyncio.gather(
          fetch_page(1, 1.0),
          fetch_page(2, 1.0),
          fetch_page(3, 1.0),
      )
      print(results, f"elapsed={time.perf_counter() - start:.2f}s")  # ~1.0s, not 3.0s
  
  asyncio.run(main())