Python Interview Questions

import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)
shallow[0][0] = 99  # affects original
deep[0][0] = 88     # doesn't affect original

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        return f'Hello, I am {self.name}'
p = Person('John', 30)

def my_decorator(func):
  def wrapper(*args, **kwargs):
      print('Before')
      result = func(*args, **kwargs)
      print('After')
      return result
  return wrapper 

  def outer(x):
    def inner(y):
      return x + y
    return inner
add_5 = outer(5)
print(add_5(10))  # 15 

def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1
for num in count_up_to(5):
    print(num)

def greet(name: str, age: int) -> str: 
  return f"{name} is {age} years old" 

class Duck:
    def quack(self): return "Quack!"

class Person:
    def quack(self): return "I'm quacking!"

def make_sound(obj):
    return obj.quack()  # Works with any object with quack()

with open('file.txt', 'r') as f:
    content = f.read()
with open('file.txt', 'w') as f:
    f.write('Hello World')

import csv with open('data.csv', 'r') as f: 
reader = csv.reader(f)
  for row in reader: 
    print(row) 

import json
data = {'name': 'John', 'age': 30}
json_str = json.dumps(data)
parsed = json.loads(json_str)

class InvalidAgeError(Exception):
  def __init__(self, age, message='Age must be >= 0'):
      self.age = age
      self.message = message
      super().__init__(self.message)

Create with: "python -m venv env_name". 
Activate: "source env_name/bin/activate" (Linux/Mac) **or** "env_name\Scripts\activate" (Windows). 
Deactivate with "deactivate". 
Install packages with pip or peotry or uv in activated environment.

List comprehension: `[x**2 for x in range(10)]` returns list. 
Dict comprehension: `{k: v**2 for k, v in dict.items()}` returns dictionary. 
Set comprehension `{x**2 for x in range(10)}` returns set. 
Generator comprehension: `(x**2 for x in range(10))` returns generator (lazy evaluation, memory efficient). 

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data()
    print(result)

from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return 'Hello, World!'

@app.route('/user/<name>')
def user(name):
    return f'Hello, {name}'

if __name__ == '__main__':
    app.run(debug=True)

  `append()` adds single element to end of list (element can be any type, including list). 
  `extend()` adds all elements from iterable to end of list. 
  `append()` increases length by 1, 
  `extend()` increases by number of elements in iterable.

`remove(value)` removes first occurrence of value, raises ValueError if not found. 
`pop(index)` removes and returns item at index, default is last item.
`del` statement removes item at index or deletes entire list. All modify list in place.

def modify_list(lst):
  lst.append(4) # modifies original 

def modify_int(x): 
  x += 1 # creates new object, doesn't affect original 

my_list = [1, 2, 3] 
modify_list(my_list) # my_list becomes [1, 2, 3, 4] 
my_int = 5 
modify_int(my_int) # my_int still 5

import weakref

class Data:
    pass

obj = Data()
ref = weakref.ref(obj)
print(ref())  # <__main__.Data object>
del obj
print(ref())  # None (object was garbage collected)

import dis

def add(a, b):
    return a + b

dis.dis(add)
# Output shows bytecode instructions

class Property:
    def __init__(self, getter):
        self.getter = getter
    
    def __get__(self, obj, objtype=None):
        return self.getter(obj)

class Example: 
  def __getattr__(self, name): 
    return f"Attribute {name} not found" 
  
  def __getattribute__(self, name): # Called for ALL attribute access 
    return object.__getattribute__(self, name) 

# Equivalent to: class Person: pass
Person = type('Person', (), {})

# With methods
def greet(self):
    return f"Hello, I'm {self.name}"

Person = type('Person', (), {'greet': greet, 'name': 'John'})

class MyClass:
    def original_method(self):
    return "Original"

def new_method(self):
    return "Patched"

# Monkey patch
MyClass.original_method = new_method

obj = MyClass()
print(obj.original_method())  # "Patched"

def generator1():
    yield 1
    yield 2

def generator2():
    yield from generator1()  # Delegates to generator1
    yield 3

# Without yield from:
def generator2_old():
    for value in generator1():
        yield value
    yield 3

  def counter():
    i = 0
    while True:
      i += 1
      yield i  # Pauses here, frame preserved
  gen = counter()
  print(next(gen))  # 1 (frame created, executes to yield, pauses)
  print(next(gen))  # 2 (resumes from yield, frame still exists)

import dis

def example():
    x = 1
    y = 2
    return x + y

dis.dis(example)
# Shows bytecode: LOAD_CONST, STORE_FAST, BINARY_ADD, etc.

# Threading
import threading
import requests

def fetch(url):
    # blocking I/O
    return requests.get(url)

# async/await
import aiohttp

async def fetch(url):
    # non-blocking I/O
    return await aiohttp.get(url)

import cProfile
cProfile.run('your_function()') 

# Inheritance (bad)
class Car(Engine, Wheels, Body):
  pass

# Composition (better)
class Car:
  def __init__(self):
    self.engine = Engine()
    self.wheels = Wheels()
    self.body = Body()

class Dog:
    def speak(self): return "Woof"

class Cat:
    def speak(self): return "Meow"

def animal_factory(animal_type):
    animals = {'dog': Dog, 'cat': Cat}
    return animals.get(animal_type, Dog)()

# Usage
pet = animal_factory('dog')

1. Module-level: Python modules are singletons. Simplest. 
2. Decorator: function decorator that wraps class. Clean syntax. 
3. Metaclass: custom metaclass controls class creation. Powerful but complex.
4. `__new__` method: override `__new__` in base class. Straightforward.

  def singleton(cls): 
    instances = {}
  
  def get_instance(): 
    if cls not in instances: 
      instances[cls] = cls() 
        return instances[cls]
    return get_instance 

**Trade-offs:** 
  module-level simplest but less flexible; 
  decorator clean but adds indirection; 
  metaclass powerful but complex; 
  `__new__` straightforward but requires inheritance.

# Without Strategy pattern 
def process_data(data, strategy): 
  return strategy(data) 

def sort_ascending(data): 
  return sorted(data) 
  
def sort_descending(data): 
  return sorted(data, reverse=True) 

# Usage result = process_data([3, 1, 2], sort_ascending) 

**1) Class-based**: implement `__enter__` and `__exit__`. 
**2) Decorator**: use `@contextmanager`. 

# Class-based 
class DatabaseConnection: 
  def __enter__(self): 
    self.conn = connect() 
      return self.conn 
  
  def __exit__(self, exc_type, exc_val, exc_tb): 
    self.conn.close() 
    
# @contextmanager from contextlib 
import contextmanager

@contextmanager 
def database_connection(): 
  conn = connect() 
    try: yield 
  conn finally: 
    conn.close()

  1. Resource-based URLs: `/users/123` not `/getUser?id=123`. 
  2. HTTP methods: GET (read), POST (create), PUT (update), DELETE (delete). 
  3. Stateless: each request contains all information. 
  4. JSON responses: standard format.
  5. Versioning: `/api/v1/users`. 
  6. Error handling: proper HTTP status codes.
  7. Pydantic models: validate request/response. 
  8. Use FastAPI or Flask-RESTful.

  @app.get('/users/{user_id}') 
    returns user
  
  @app.post('/users')
    creates user.

1. Refactor: move common code to third module. 
2. Lazy imports: import inside functions.
3. Dependency injection: pass dependencies as parameters. 

# Bad: circular import
# a.py imports b, b.py imports a

# Solution 1: Refactor
# common.py: shared code
# a.py and b.py import common

# Solution 2: Lazy import
def func():
  import b  # Import when needed
  return b.something()

# Solution 3: Dependency injection
def func(dependency):
  return dependency.something()

import requests

def mock_get(url):
    return MockResponse()

# Monkey patch for testing
requests.get = mock_get

from unittest.mock import Mock, patch

@patch('module.external_api_call')
def test_function(mock_api):
    mock_api.return_value = {'data': 'test'}
    result = function_under_test()
    assert result == expected

# Stub: just returns value
mock_api = Mock(return_value={'data': 'test'})

# Mock: verify it was called
mock_api.assert_called_once()
mock_api.assert_called_with('expected_arg')

## Debugging Python Code

### Core Debugging Tools

Use Python debugger (`pdb`) or IDE debuggers. Set breakpoints, step through code, inspect variables. Use `print()` statements strategically (or logging). Use `traceback` module to analyze exceptions. Use `inspect` module to examine objects.

### Common Techniques

**Breakpoints**: 
```python
import pdb; pdb.set_trace()

import logging
logging.basicConfig(level=logging.DEBUG)
logging.debug("Variable value: %s", variable)

try:
    # code
except Exception as e:
    logging.error("Error occurred", exc_info=True)

  def calculate(x, y): 
    import pdb 
    pdb.set_trace() # Breakpoint 
    result = x + y 
    return result 

import logging

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

def process_data(data):
    logger.debug(f"Processing {len(data)} items")
    logger.info("Starting processing")
    # ... code ...
    logger.error("Error occurred", exc_info=True)

import traceback
import sys

try:
    # code that might fail
    result = 1 / 0
except Exception:
    traceback.print_exc()  # Print to stderr
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print(f"Exception type: {exc_type}")
    print(f"Exception value: {exc_value}")

  1. Print debugging: strategic `print()` statements (use logging instead).
  2. Debugger: `pdb` or IDE debuggers.
  3. Logging: structured logging with context.
  4. Exception handling: catch and inspect exceptions.
  5. Assertions: verify assumptions with `assert`.
  6. Profiling: use `cProfile` to find bottlenecks.
  7. Type checking: use `mypy` to catch type errors.
  8. Unit tests**: write tests to reproduce bugs.
  9. Code review: fresh eyes catch bugs.
 10. Rubber duck debugging: explain code to find issues. Combine techniques based on problem type.

  1. `cProfile` for function-level
  2. `line_profiler` for line-level 
  3. `memory_profiler` for memory usage. 
  4. `timeit` for micro-benchmarks.
  5. `memory_profiler` for memory leaks.

import cProfile 
profiler = cProfile.Profile() 
profiler.enable() # Your code here 
profiler.disable() 

import pstats 
stats = pstats.Stats(profiler) 
stats.sort_stats('cumulative') 
stats.print_stats(10) # Top 10 functions 

1. Identify bottlenecks, then optimize. 
2. Profile before optimizing: measure, don't guess. 
3. Focus on hot paths (code executed frequently).

import tracemalloc
import gc

tracemalloc.start()
# Your code
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:10]:
    print(stat)

# Check for uncollectable objects
print(gc.collect())
print(len(gc.garbage))