10 Must Ask Python Interview Questions For Hiring Managers

# List - mutable
my_list = [1, 2, 3]
my_list.append(4)        # Works
my_list[0] = 10          # Works

# Tuple - immutable  
my_tuple = (1, 2, 3)
my_tuple.append(4)       # Error - AttributeError
my_tuple[0] = 10         # Error - TypeError

import threading
import time

def cpu_bound_task():
    # This won't benefit from multiple threads due to GIL
    total = sum(i * i for i in range(10000000))

# For CPU-bound tasks, use multiprocessing instead
from multiprocessing import Pool

with Pool() as pool:
    results = pool.map(cpu_bound_task, range(4))  # True parallelism

def timing_decorator(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start:.2f} seconds")
        return result
    return wrapper

@timing_decorator
def slow_function():
    time.sleep(1)
    return "Done"

# Equivalent to: slow_function = timing_decorator(slow_function)

# Class-based decorator
class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0
    
    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"Call {self.count}")
        return self.func(*args, **kwargs)
```"

### 4. Explain the difference between `*args` and `**kwargs`.

Variable arguments are essential for flexible function design.

**Example Answer**: "`*args` collects positional arguments into a tuple, `**kwargs` collects keyword arguments into a dictionary:
```python
def example_function(required, *args, **kwargs):
    print(f"Required: {required}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

example_function("hello", 1, 2, 3, name="John", age=30)
# Output:
# Required: hello
# Args: (1, 2, 3)  
# Kwargs: {'name': 'John', 'age': 30}

# Unpacking arguments
def add(a, b, c):
    return a + b + c

numbers = [1, 2, 3]
result = add(*numbers)  # Unpacks list into arguments

data = {'a': 1, 'b': 2, 'c': 3}
result = add(**data)    # Unpacks dict into keyword arguments
```"

### 5. What is the difference between `is` and `==` in Python?

Understanding object identity vs value equality prevents common bugs.

**Example Answer**: "`==` compares values for equality, `is` compares object identity (memory location):
```python
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True - same values
print(a is b)   # False - different objects
print(a is c)   # True - same object

# Special case with small integers and strings (interning)
x = 256
y = 256
print(x is y)   # True - Python interns small integers

x = 257
y = 257  
print(x is y)   # False - larger integers not interned

# Always use == for value comparison, is for None/singleton comparison
if value is None:  # Correct
if value == None:  # Works but not recommended
```"

### 6. Explain list comprehensions and when to use them.

List comprehensions demonstrate Pythonic coding style and functional programming concepts.

**Example Answer**: "List comprehensions provide concise syntax for creating lists based on existing iterables:
```python
# Basic list comprehension
squares = [x**2 for x in range(10)]
# Equivalent to:
squares = []
for x in range(10):
    squares.append(x**2)

# With condition
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# Nested comprehensions
matrix = [[j for j in range(3)] for i in range(3)]

# Dict comprehension
word_lengths = {word: len(word) for word in ['python', 'java', 'go']}

# Set comprehension
unique_lengths = {len(word) for word in ['python', 'java', 'go']}

# Generator expression (memory efficient)
sum_of_squares = sum(x**2 for x in range(1000000))

try:
    result = risky_operation()
    file = open("data.txt", "r")
except FileNotFoundError as e:
    print(f"File not found: {e}")
    result = None
except ValueError as e:
    print(f"Invalid value: {e}")
    result = None
except Exception as e:
    print(f"Unexpected error: {e}")
    result = None
else:
    # Runs if no exception occurred
    print("Operation successful")
finally:
    # Always runs, typically for cleanup
    if 'file' in locals():
        file.close()

# Custom exceptions
class ValidationError(Exception):
    def __init__(self, message, code=None):
        super().__init__(message)
        self.code = code

# Context managers for automatic cleanup
with open("data.txt", "r") as file:
    content = file.read()
# File automatically closed
```"

### 8. What are Python generators and why use them?

Generators demonstrate understanding of memory efficiency and lazy evaluation.

**Example Answer**: "Generators are functions that return an iterator, yielding values one at a time instead of creating entire sequences in memory:
```python
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# Memory efficient - generates values on demand
fib_gen = fibonacci(10)
for num in fib_gen:
    print(num)

# Generator expression
squares = (x**2 for x in range(1000000))  # Doesn't consume memory
total = sum(squares)  # Computed on-the-fly

# Reading large files efficiently
def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

# Memory efficient processing of huge files
for line in read_large_file("huge_file.txt"):
    process(line)  # Process one line at a time

class Person:
    def __new__(cls, name, age):
        print(f"Creating instance of {cls.__name__}")
        instance = super().__new__(cls)
        return instance
    
    def __init__(self, name, age):
        print(f"Initializing instance")
        self.name = name
        self.age = age

# Singleton pattern using __new__
class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # True - same instance

# __new__ is useful for:
# - Controlling instance creation
# - Implementing singletons
# - Subclassing immutable types
class PositiveInt(int):
    def __new__(cls, value):
        if value < 0:
            raise ValueError("Value must be positive")
        return super().__new__(cls, value)
```"

### 10. What is the difference between deep copy and shallow copy?

Object copying affects data integrity and performance.

**Example Answer**: "Shallow copy creates new object but references same nested objects. Deep copy recursively copies all objects:
```python
import copy

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

# Shallow copy
shallow = copy.copy(original)
shallow = original[:]        # Alternative
shallow = list(original)     # Alternative

shallow[0][0] = 'X'
print(original)  # [['X', 2, 3], [4, 5, 6]] - modified!

# Deep copy
original = [[1, 2, 3], [4, 5, 6]]
deep = copy.deepcopy(original)

deep[0][0] = 'X'
print(original)  # [[1, 2, 3], [4, 5, 6]] - unchanged!

# Assignment just creates reference
reference = original
reference[0][0] = 'Y'
print(original)  # [['Y', 2, 3], [4, 5, 6]] - modified!