Python Interview Preparation: 60 Essential Questions and Answers

# Question 1: What makes Python different from other programming languages?
# Answer: Python is interpreted, dynamically typed, emphasizes readability with 
# significant whitespace, supports multiple paradigms (procedural, OOP, functional),
# features automatic memory management, and extensive standard library.

# Question 2: Explain the difference between lists and tuples
# Lists - Mutable
my_list = [1, 2, 3]
my_list[0] = 10  # Can modify
my_list.append(4)
print(my_list)  # [10, 2, 3, 4]

# Tuples - Immutable
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # TypeError
dict_with_tuple = {(1, 2): 'value'}  # Tuples hashable

# Question 3: Python's built-in data types
# Numeric: int, float, complex
# Sequences: list, tuple, range
# Text: str
# Mapping: dict
# Sets: set, frozenset
# Boolean: bool
# Binary: bytes, bytearray
# None type

# Question 4: List comprehension
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

matrix = [[i*j for j in range(3)] for i in range(3)]
print(matrix)

# Question 5: Difference between == and is
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 reference

# Question 6: Mutable vs Immutable
# Mutable: list, dict, set - can be modified
# Immutable: int, float, str, tuple - cannot be modified

mutable_list = [1, 2, 3]
mutable_list[0] = 99  # Works

immutable_string = "hello"
# immutable_string[0] = 'H'  # TypeError

# Question 7: Python decorators
import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end-start:.4f}s")
        return result
    return wrapper

@timer_decorator
def slow_function():
    time.sleep(0.5)
    return "Done"

result = slow_function()

# Question 8: *args and **kwargs
def demo_function(*args, **kwargs):
    print("Positional:", args)
    print("Keyword:", kwargs)

demo_function(1, 2, 3, name="John", age=30)
# Output: Positional: (1, 2, 3)
# Output: Keyword: {'name': 'John', 'age': 30}

def sum_all(*numbers):
    return sum(numbers)

print(sum_all(1, 2, 3, 4, 5))  # 15

# Question 9: Deep copy vs Shallow copy
import copy

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

# Shallow copy
shallow = copy.copy(original)
shallow[0][0] = 99
print(original)  # [[99, 2, 3], [4, 5, 6]] - affected!

# Deep copy
original = [[1, 2, 3], [4, 5, 6]]
deep = copy.deepcopy(original)
deep[0][0] = 99
print(original)  # [[1, 2, 3], [4, 5, 6]] - not affected

# Question 10: Python's GIL (Global Interpreter Lock)
# GIL is mutex preventing multiple threads executing Python bytecode
# simultaneously. Limits multi-threading for CPU-bound tasks.
# Use multiprocessing for CPU-bound, threading for I/O-bound.

# Question 11: Lambda functions
square = lambda x: x**2
print(square(5))  # 25

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # [2, 4]

students = [('Alice', 85), ('Bob', 75), ('Charlie', 95)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students)

# Question 12: break, continue, and pass
for i in range(10):
    if i == 3:
        continue  # Skip 3
    if i == 7:
        break  # Exit at 7
    print(i)

class EmptyClass:
    pass  # Placeholder

# Question 13: List slicing
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:5])      # [2, 3, 4]
print(numbers[:5])       # [0, 1, 2, 3, 4]
print(numbers[5:])       # [5, 6, 7, 8, 9]
print(numbers[::2])      # [0, 2, 4, 6, 8]
print(numbers[::-1])     # Reversed
print(numbers[-3:])      # [7, 8, 9]

# Question 14: Memory management
# Python uses reference counting and garbage collection
# Objects freed when reference count reaches zero
# Cyclic GC handles circular references

# Question 15: Generators
def countdown(n):
    while n > 0:
        yield n
        n -= 1

for num in countdown(5):
    print(num)  # 5, 4, 3, 2, 1

squares_gen = (x**2 for x in range(10))
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
print([next(fib) for _ in range(10)])

# Question 16: Four pillars of OOP
# 1. Encapsulation: Bundle data and methods, hide internal details
# 2. Inheritance: Classes inherit from parents, promote reuse
# 3. Polymorphism: Methods take many forms through overriding
# 4. Abstraction: Hide implementation, show only necessary features

# Question 17: What is 'self' in Python?
class Dog:
    def __init__(self, name, age):
        self.name = name  # self refers to instance
        self.age = age
    
    def bark(self):
        return f"{self.name} says Woof!"

dog1 = Dog("Buddy", 3)
print(dog1.bark())  # Buddy says Woof!

# Question 18: Class methods vs Static methods
class MyClass:
    class_variable = 0
    
    def __init__(self, value):
        self.value = value
    
    @classmethod
    def class_method(cls):
        return f"Class variable: {cls.class_variable}"
    
    @staticmethod
    def static_method(x, y):
        return x + y  # No access to class/instance

print(MyClass.class_method())
print(MyClass.static_method(5, 3))  # 8

# Question 19: Method overriding
class Animal:
    def sound(self):
        return "Some sound"

class Dog(Animal):
    def sound(self):  # Override parent method
        return "Woof!"

class Cat(Animal):
    def sound(self):
        return "Meow!"

dog = Dog()
cat = Cat()
print(dog.sound())  # Woof!
print(cat.sound())  # Meow!

# Question 20: Multiple inheritance
class A:
    def method(self):
        return "A"

class B:
    def method(self):
        return "B"

class C(A, B):  # Multiple inheritance
    pass

c = C()
print(c.method())  # "A" - MRO determines order
print(C.__mro__)  # Method Resolution Order

# Question 21: Magic methods (dunder methods)
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"Point({self.x}, {self.y})"
    
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)
    
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1)  # Point(1, 2)
p3 = p1 + p2  # Uses __add__
print(p3)  # Point(4, 6)

# Question 22: Property decorators
class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

temp = Temperature(25)
print(temp.celsius)  # 25
print(temp.fahrenheit)  # 77.0
temp.celsius = 30

# Question 23: Method overloading
# Python doesn't support traditional overloading
# Use default arguments or *args/**kwargs
def add(a, b=0, c=0):
    return a + b + c

print(add(1))       # 1
print(add(1, 2))    # 3
print(add(1, 2, 3)) # 6

# Question 24: Abstract classes
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

rect = Rectangle(5, 3)
print(rect.area())  # 15

# Question 25: Composition vs Inheritance
# Composition: has-a relationship
class Engine:
    def start(self):
        return "Engine started"

class Car:
    def __init__(self):
        self.engine = Engine()  # Composition
    
    def start(self):
        return self.engine.start()

car = Car()
print(car.start())

# Question 26: Encapsulation
class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private (name mangling)
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
    
    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 1500
# print(account.__balance)  # AttributeError

# Question 27: Class vs Instance variables
class Student:
    school = "ABC School"  # Class variable
    
    def __init__(self, name):
        self.name = name  # Instance variable

s1 = Student("Alice")
s2 = Student("Bob")
print(s1.school)  # ABC School
Student.school = "XYZ School"
print(s2.school)  # XYZ School

# Question 28: super() function
class Parent:
    def __init__(self, name):
        self.name = name
    
    def greet(self):
        return f"Hello, {self.name}"

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # Call parent __init__
        self.age = age
    
    def greet(self):
        parent_greeting = super().greet()
        return f"{parent_greeting}, age {self.age}"

child = Child("Alice", 10)
print(child.greet())

# Question 29: Mixins
class LoggingMixin:
    def log(self, message):
        print(f"[LOG] {message}")

class DataProcessor(LoggingMixin):
    def process(self, data):
        self.log("Processing started")
        # Process data
        self.log("Processing completed")

processor = DataProcessor()
processor.process([1, 2, 3])

# Question 30: Polymorphism example
class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side
    
    def area(self):
        return self.side ** 2

shapes = [Circle(5), Square(4)]
for shape in shapes:
    print(shape.area())  # Polymorphism in action

# Question 31: How dictionaries work internally
# Dictionaries use hash tables with O(1) average lookup
# Keys hashed to determine storage location
# Hash collisions handled through open addressing/chaining

# Question 32: Time complexity of list operations
# append: O(1) amortized
# insert: O(n)
# delete: O(n)
# access by index: O(1)
# search: O(n)
# sort: O(n log n)

# Question 33: Sets vs Lists
my_list = [1, 2, 2, 3, 3, 3]
my_set = {1, 2, 3}  # Unique elements, unordered

print(2 in my_list)  # O(n) - slow
print(2 in my_set)   # O(1) - fast

# Question 34: Reverse a string
def reverse_string(s):
    return s[::-1]

print(reverse_string("hello"))  # olleh

# Alternative methods
def reverse_iterative(s):
    return ''.join(reversed(s))

def reverse_loop(s):
    result = ""
    for char in s:
        result = char + result
    return result

# Question 35: Check palindrome
def is_palindrome(s):
    return s == s[::-1]

print(is_palindrome("racecar"))  # True
print(is_palindrome("hello"))    # False

# Case-insensitive, ignore spaces
def is_palindrome_advanced(s):
    s = s.replace(" ", "").lower()
    return s == s[::-1]

print(is_palindrome_advanced("A man a plan a canal Panama"))

# Question 36: Remove duplicates from list
# Method 1: Using set (loses order)
my_list = [1, 2, 2, 3, 3, 4]
unique = list(set(my_list))

# Method 2: Preserving order
unique_ordered = list(dict.fromkeys(my_list))
print(unique_ordered)  # [1, 2, 3, 4]

# Method 3: Using loop
def remove_duplicates(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

# Question 37: Sorting algorithms complexity
# Bubble Sort: O(n²)
# Merge Sort: O(n log n)
# Quick Sort: O(n log n) average, O(n²) worst
# Python's sort(): Timsort O(n log n)

numbers = [64, 34, 25, 12, 22, 11, 90]
numbers.sort()  # In-place
print(numbers)

sorted_numbers = sorted(numbers)  # Returns new list

# Question 38: Find duplicate elements
from collections import Counter

numbers = [1, 2, 3, 2, 4, 5, 3]
duplicates = [k for k, v in Counter(numbers).items() if v > 1]
print(duplicates)  # [2, 3]

# Set approach
def find_duplicates(lst):
    seen = set()
    dups = set()
    for item in lst:
        if item in seen:
            dups.add(item)
        seen.add(item)
    return list(dups)

# Question 39: Binary search implementation
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    
    return -1

arr = [1, 3, 5, 7, 9, 11, 13]
print(binary_search(arr, 7))  # 3
print(binary_search(arr, 6))  # -1

# Question 40: Merge two sorted lists
def merge_sorted_lists(l1, l2):
    result = []
    i = j = 0
    
    while i < len(l1) and j < len(l2):
        if l1[i] < l2[j]:
            result.append(l1[i])
            i += 1
        else:
            result.append(l2[j])
            j += 1
    
    result.extend(l1[i:])
    result.extend(l2[j:])
    return result

list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
print(merge_sorted_lists(list1, list2))

# Question 41: Stack implementation
class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        self.items.append(item)
    
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
    
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
    
    def is_empty(self):
        return len(self.items) == 0

stack = Stack()
stack.push(1)
stack.push(2)
print(stack.pop())  # 2

# Question 42: Queue implementation
from collections import deque

class Queue:
    def __init__(self):
        self.items = deque()
    
    def enqueue(self, item):
        self.items.append(item)
    
    def dequeue(self):
        if not self.is_empty():
            return self.items.popleft()
    
    def is_empty(self):
        return len(self.items) == 0

queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(queue.dequeue())  # 1

# Question 43: Find missing number in sequence
def find_missing_number(arr, n):
    # Sum formula: n * (n + 1) / 2
    expected_sum = n * (n + 1) // 2
    actual_sum = sum(arr)
    return expected_sum - actual_sum

numbers = [1, 2, 4, 5, 6]  # Missing 3
print(find_missing_number(numbers, 6))  # 3

# Question 44: Linked list node implementation
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
    
    def insert_at_beginning(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node
    
    def print_list(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

ll = LinkedList()
ll.insert_at_beginning(3)
ll.insert_at_beginning(2)
ll.insert_at_beginning(1)
ll.print_list()  # 1 -> 2 -> 3 -> None

# Question 45: Detect cycle in linked list (Floyd's Algorithm)
def has_cycle(head):
    if not head:
        return False
    
    slow = fast = head
    
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        
        if slow == fast:
            return True
    
    return False

# Question 46: NumPy arrays vs Python lists
import numpy as np

# Lists - dynamic, heterogeneous, slower
python_list = [1, 2, 3, 4, 5]
list_result = [x * 2 for x in python_list]  # Requires loop

# NumPy - fixed-type, vectorized, faster
numpy_array = np.array([1, 2, 3, 4, 5])
array_result = numpy_array * 2  # Vectorized operation
print(array_result)  # [ 2  4  6  8 10]

# NumPy is 50x faster for numerical operations

# Question 47: Pandas DataFrame
import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 70000]
}

df = pd.DataFrame(data)
print(df)
print(df['age'].mean())  # 30.0
print(df[df['salary'] > 55000])  # Filter

# Question 48: Context managers
class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()

with FileManager('test.txt', 'w') as f:
    f.write('Hello, World!')
# File automatically closed

# Using contextlib
from contextlib import contextmanager

@contextmanager
def timer():
    import time
    start = time.time()
    yield
    end = time.time()
    print(f"Elapsed: {end - start:.4f}s")

with timer():
    sum([i**2 for i in range(1000000)])

# Question 49: Exception handling
def divide_numbers(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Cannot divide by zero!")
        return None
    except TypeError:
        print("Invalid types!")
        return None
    else:
        print("Division successful")
        return result
    finally:
        print("Cleanup operations")

print(divide_numbers(10, 2))  # 5.0
print(divide_numbers(10, 0))  # None

# Custom exceptions
class InvalidAgeError(Exception):
    pass

def set_age(age):
    if age < 0:
        raise InvalidAgeError("Age cannot be negative")
    return age

# Question 50: Multithreading vs Multiprocessing
import threading
import multiprocessing
import time

# Threading - I/O bound
def io_task():
    time.sleep(1)

threads = [threading.Thread(target=io_task) for _ in range(5)]
for t in threads:
    t.start()
for t in threads:
    t.join()

# Multiprocessing - CPU bound
def cpu_task(n):
    return sum(i**2 for i in range(n))

with multiprocessing.Pool(4) as pool:
    results = pool.map(cpu_task, [1000000] * 4)

# Question 51: Async/await
import asyncio

async def fetch_data(id):
    print(f"Fetching {id}...")
    await asyncio.sleep(1)  # Simulate I/O
    return f"Data {id}"

async def main():
    tasks = [fetch_data(i) for i in range(3)]
    results = await asyncio.gather(*tasks)
    print(results)

# asyncio.run(main())  # Run async code

# Question 52: Regular expressions
import re

text = "Contact: [email protected], phone: 123-456-7890"

# Find email
email = re.search(r'[\w\.-]+@[\w\.-]+', text)
print(email.group())  # [email protected]

# Find phone
phone = re.search(r'\d{3}-\d{3}-\d{4}', text)
print(phone.group())  # 123-456-7890

# Replace
masked = re.sub(r'\d', '*', text)
print(masked)

# Find all
numbers = re.findall(r'\d+', text)
print(numbers)  # ['123', '456', '7890']

# Question 53: Iterators
class Counter:
    def __init__(self, max):
        self.max = max
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current >= self.max:
            raise StopIteration
        self.current += 1
        return self.current

counter = Counter(5)
for num in counter:
    print(num)  # 1, 2, 3, 4, 5

# Question 54: map, filter, reduce
numbers = [1, 2, 3, 4, 5]

# map - apply function to all
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# filter - keep elements where function returns True
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # [2, 4]

# reduce - cumulative operation
from functools import reduce
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all)  # 15

product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120

# Question 55: Pickle module
import pickle

data = {'name': 'Alice', 'age': 30, 'scores': [85, 90, 95]}

# Serialize (pickling)
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)

# Deserialize (unpickling)
with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)
    print(loaded_data)

# Warning: Don't unpickle untrusted data (security risk)
# Use JSON for simple data interchange

# Question 56: FizzBuzz
def fizzbuzz():
    for i in range(1, 101):
        if i % 15 == 0:
            print("FizzBuzz")
        elif i % 3 == 0:
            print("Fizz")
        elif i % 5 == 0:
            print("Buzz")
        else:
            print(i)

# One-liner version
for i in range(1, 101):
    print('FizzBuzz' if i % 15 == 0 else 'Fizz' if i % 3 == 0 
          else 'Buzz' if i % 5 == 0 else i)

# Question 57: Fibonacci sequence
# Iterative with generator
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

print(list(fibonacci(10)))  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Recursive
def fib_recursive(n):
    if n <= 1:
        return n
    return fib_recursive(n-1) + fib_recursive(n-2)

# Memoized version (efficient)
from functools import lru_cache

@lru_cache(maxsize=None)
def fib_memo(n):
    if n <= 1:
        return n
    return fib_memo(n-1) + fib_memo(n-2)

print(fib_memo(50))  # Fast even for large n

# Question 58: Two Sum problem
def two_sum(nums, target):
    """
    Find two numbers that add up to target.
    Return their indices.
    """
    seen = {}
    
    for i, num in enumerate(nums):
        complement = target - num
        
        if complement in seen:
            return [seen[complement], i]
        
        seen[num] = i
    
    return None

numbers = [2, 7, 11, 15]
target = 9
print(two_sum(numbers, target))  # [0, 1]

# Brute force O(n²)
def two_sum_brute(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return None

# Question 59: Reverse words in sentence
def reverse_words(s):
    return ' '.join(s.split()[::-1])

sentence = "Hello World Python"
print(reverse_words(sentence))  # Python World Hello

# Alternative
def reverse_words_alt(s):
    return ' '.join(reversed(s.split()))

# Reverse each word but keep order
def reverse_each_word(s):
    return ' '.join(word[::-1] for word in s.split())

print(reverse_each_word("Hello World"))  # olleH dlroW

# Question 60: Anagram checker
def is_anagram(s1, s2):
    # Remove spaces and convert to lowercase
    s1 = s1.replace(" ", "").lower()
    s2 = s2.replace(" ", "").lower()
    
    return sorted(s1) == sorted(s2)

print(is_anagram("listen", "silent"))  # True
print(is_anagram("hello", "world"))    # False

# Using Counter (more efficient for large strings)
from collections import Counter

def is_anagram_counter(s1, s2):
    s1 = s1.replace(" ", "").lower()
    s2 = s2.replace(" ", "").lower()
    
    return Counter(s1) == Counter(s2)

print(is_anagram_counter("anagram", "nagaram"))  # True

# Check if one string is anagram of another (case-insensitive)
def are_anagrams(str1, str2):
    if len(str1) != len(str2):
        return False
    
    char_count = {}
    
    for char in str1.lower():
        char_count[char] = char_count.get(char, 0) + 1
    
    for char in str2.lower():
        if char not in char_count:
            return False
        char_count[char] -= 1
        if char_count[char] < 0:
            return False
    
    return all(count == 0 for count in char_count.values())

print(are_anagrams("Dormitory", "Dirty room"))  # False (spaces)