Most Asked Python Interview Questions

What are mutable and immutable types in Python? What is the difference between shallow copy and deep copy in Python?

21 questions
PythonInterviewProgrammingOOPData StructuresCodingSoftware Development

Questions & Answers

1What are mutable and immutable types in Python?

Mutable types are objects whose content can be changed after creation without creating a new object. Examples include lists, dictionaries, and sets.

Immutable types cannot be modified after creation. Any modification creates a new object. Examples include integers, floats, strings, tuples, and frozensets.

Example:

# Mutable - list
my_list = [1, 2, 3]
my_list[0] = 10 # Original list is modified
print(my_list) # [10, 2, 3]

# Immutable - tuple
my_tuple = (1, 2, 3)
# my_tuple[0] = 10 # This would raise TypeError

Understanding mutability is crucial for avoiding bugs, especially when passing objects to functions or using them as dictionary keys.

2How is a list different from a tuple?

Lists and tuples differ in several key ways:

Mutability:

  1. Lists are mutable - you can add, remove, or modify elements
  2. Tuples are immutable - once created, they cannot be changed

Syntax:

  1. Lists use square brackets: [1, 2, 3]
  2. Tuples use parentheses: (1, 2, 3)

Performance:

  1. Tuples are slightly faster and use less memory
  2. Lists have more overhead due to mutability

Use Cases:

  1. Use lists for collections that need to change (shopping cart items, user inputs)
  2. Use tuples for fixed data (coordinates, RGB colors, database records)

Example:

my_list = [1, 2, 3]
my_list.append(4) # Works fine

my_tuple = (1, 2, 3)
# my_tuple.append(4) # AttributeError

3What is the difference between shallow copy and deep copy in Python?

When copying objects in Python, understanding shallow vs deep copy is essential:

Shallow Copy:

  1. Creates a new object but references the same nested objects
  2. Changes to nested objects affect both copies
  3. Created using copy.copy() or list.copy()

Deep Copy:

  1. Creates a completely independent copy, including all nested objects
  2. Changes to nested objects don't affect the original
  3. Created using copy.deepcopy()

Example:

import copy

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

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

# Deep copy
original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)
deep[0][0] = 99
print(original) # [[1, 2], [3, 4]] - Original unchanged

Use shallow copy for simple objects and deep copy when dealing with nested structures.

4What is the use of *args and **kwargs in a Python function?

These special parameters allow functions to accept variable numbers of arguments:

*args (Non-Keyword Arguments):

  1. Allows a function to accept any number of positional arguments
  2. Arguments are received as a tuple

**kwargs (Keyword Arguments):

  1. Allows a function to accept any number of keyword arguments
  2. Arguments are received as a dictionary

Examples:

# Using *args
def sum_all(*args):
return sum(args)

print(sum_all(1, 2, 3, 4)) # 10

# Using **kwargs
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")

print_info(name="Alice", age=25, city="NYC")

# Using both
def full_function(*args, **kwargs):
print("Positional:", args)
print("Keyword:", kwargs)

full_function(1, 2, name="Bob", age=30)
# Positional: (1, 2)
# Keyword: {'name': 'Bob', 'age': 30}

These are extremely useful for creating flexible APIs and wrapper functions.

5How is a lambda function different from a normal function defined with def?

Lambda functions are anonymous, single-expression functions with key differences from regular functions:

Lambda Functions:

  1. Anonymous (no name required)
  2. Single expression only
  3. Automatically returns the result
  4. Typically used for short, simple operations
  5. Cannot contain statements (no assignments, loops, etc.)

Regular Functions (def):

  1. Named and reusable
  2. Can contain multiple statements and expressions
  3. Requires explicit return statement
  4. Can include documentation strings
  5. Better for complex logic

Examples:

# Lambda function
square = lambda x: x ** 2
print(square(5)) # 25

# Equivalent regular function
def square_func(x):
return x ** 2

# Common use case - with sorted()
students = [('Alice', 85), ('Bob', 92), ('Charlie', 78)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students) # Sorted by score

Use lambda for simple operations in places like map(), filter(), and sorted(). Use regular functions for anything more complex.

6What are list comprehensions, and why are they used?

List comprehensions provide a concise way to create lists based on existing iterables.

Benefits:

  1. More readable and Pythonic than traditional loops
  2. Often faster than equivalent for-loops
  3. Can include conditional logic
  4. Reduce code verbosity

Basic Syntax:

[expression for item in iterable if condition]

Examples:

# Traditional approach
squares = []
for x in range(10):
squares.append(x ** 2)

# List comprehension - cleaner!
squares = [x ** 2 for x in range(10)]

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

# Nested comprehension
matrix = [[1, 2], [3, 4], [5, 6]]
flattened = [num for row in matrix for num in row]
print(flattened) # [1, 2, 3, 4, 5, 6]

# String manipulation
words = ["hello", "world", "python"]
capitalized = [word.upper() for word in words]
print(capitalized) # ['HELLO', 'WORLD', 'PYTHON']

Note: Don't overuse them - if the logic becomes too complex, use a regular loop for better readability.

7What is the difference between the is operator and the == operator?

These operators serve different purposes in Python:

== Operator (Equality):

  1. Compares the values of two objects
  2. Returns True if values are equal
  3. Can be overridden using __eq__() method

is Operator (Identity):

  1. Compares the memory addresses (identity) of two objects
  2. Returns True if both variables point to the same object
  3. Cannot be overridden

Examples:

# Value comparison with ==
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # True - same values
print(a is b) # False - different objects in memory

# Identity comparison with is
c = a
print(a is c) # True - same object
print(a == c) # True - same values

# Special case with small integers (Python caches them)
x = 256
y = 256
print(x is y) # True - Python caches small integers

z = 257
w = 257
print(z is w) # False - larger integers aren't cached

# Best practice for None
value = None
if value is None: # Correct way
print("Value is None")

Rule of thumb: Use == for value comparison and is only when checking for None or comparing singleton objects.

8Explain the role of __init__() in a Python class.

The __init__() method is a special constructor method in Python classes that initializes object attributes.

Key Points:

  1. Automatically called when a new object is created
  2. Used to set initial values for object attributes
  3. The first parameter is always self (reference to the instance)
  4. Can accept additional parameters for initialization
  5. Not required if no initialization is needed

Example:

class Person:
def __init__(self, name, age):
self.name = name # Instance attribute
self.age = age
self.email = None # Default value
def introduce(self):
return f"Hi, I'm {self.name}, {self.age} years old"

# Creating objects
person1 = Person("Alice", 30) # __init__ is called automatically
person2 = Person("Bob", 25)

print(person1.introduce()) # Hi, I'm Alice, 30 years old
print(person2.name) # Bob

With Default Parameters:

class Student:
def __init__(self, name, grade="A"):
self.name = name
self.grade = grade

student1 = Student("Charlie") # Uses default grade
student2 = Student("Diana", "B+") # Custom grade

Note: __init__() is different from __new__(). The __new__() method creates the object, while __init__() initializes it.

9What are "dunder" (magic) methods? Give some examples.

Dunder methods (double underscore methods) are special methods in Python that enable operator overloading and customization of built-in behavior.

Common Dunder Methods:

Object Representation:

  1. __init__() - Constructor
  2. __str__() - String representation for users
  3. __repr__() - Official representation for developers

Comparison Operators:

  1. __eq__() - Equality (==)
  2. __lt__() - Less than (<)
  3. __gt__() - Greater than (>)

Arithmetic Operators:

  1. __add__() - Addition (+)
  2. __sub__() - Subtraction (-)
  3. __mul__() - Multiplication (*)

Container Methods:

  1. __len__() - Length
  2. __getitem__() - Indexing
  3. __setitem__() - Assignment

Example:

class Book:
def __init__(self, title, pages):
self.title = title
self.pages = pages
def __str__(self):
return f"{self.title} ({self.pages} pages)"
def __repr__(self):
return f"Book('{self.title}', {self.pages})"
def __len__(self):
return self.pages
def __add__(self, other):
return self.pages + other.pages
def __eq__(self, other):
return self.pages == other.pages

book1 = Book("Python Guide", 350)
book2 = Book("Data Science", 350)

print(str(book1)) # Python Guide (350 pages)
print(repr(book1)) # Book('Python Guide', 350)
print(len(book1)) # 350
print(book1 + book2) # 700
print(book1 == book2) # True

Dunder methods make your custom classes behave like built-in Python types.

10What is the difference between @staticmethod, @classmethod, and an instance method?

These three method types serve different purposes in Python classes:

Instance Methods:

  1. Default method type
  2. First parameter is self (instance reference)
  3. Can access and modify instance attributes
  4. Can access class attributes through self

@classmethod:

  1. First parameter is cls (class reference)
  2. Can access and modify class attributes
  3. Cannot access instance attributes
  4. Often used for alternative constructors

@staticmethod:

  1. No automatic first parameter
  2. Cannot access instance or class attributes directly
  3. Behaves like a regular function but belongs to the class namespace
  4. Used for utility functions related to the class

Example:

class Pizza:
base_price = 10 # Class attribute
def __init__(self, size, toppings):
self.size = size # Instance attribute
self.toppings = toppings
# Instance method
def calculate_price(self):
return self.base_price + len(self.toppings) * 2
# Class method - alternative constructor
@classmethod
def margherita(cls, size):
return cls(size, ['cheese', 'tomato'])
# Static method - utility function
@staticmethod
def is_valid_size(size):
return size in ['small', 'medium', 'large']

# Using instance method
pizza1 = Pizza('large', ['pepperoni', 'mushrooms'])
print(pizza1.calculate_price()) # 14

# Using class method
pizza2 = Pizza.margherita('medium')
print(pizza2.toppings) # ['cheese', 'tomato']

# Using static method
print(Pizza.is_valid_size('medium')) # True
print(Pizza.is_valid_size('tiny')) # False

11What are iterators and generators in Python? How do they differ?

Both iterators and generators provide ways to iterate over data, but they work differently:

Iterators:

  1. Objects that implement __iter__() and __next__() methods
  2. Must explicitly maintain state
  3. Raise StopIteration when exhausted
  4. Can be created from any iterable using iter()

Generators:

  1. Special functions that use yield instead of return
  2. Automatically maintain state between calls
  3. More memory-efficient (lazy evaluation)
  4. Simpler to write than iterators
  5. Can only be iterated once

Examples:

# Iterator example
class CountUp:
def __init__(self, max_num):
self.max_num = max_num
self.current = 0
def __iter__(self):
return self
def __next__(self):
if self.current >= self.max_num:
raise StopIteration
self.current += 1
return self.current

counter = CountUp(3)
for num in counter:
print(num) # 1, 2, 3

# Generator example - much simpler!
def count_up(max_num):
current = 1
while current <= max_num:
yield current
current += 1

for num in count_up(3):
print(num) # 1, 2, 3

# Generator expression (like list comprehension)
squares_gen = (x ** 2 for x in range(5))
print(list(squares_gen)) # [0, 1, 4, 9, 16]

# Memory efficiency demonstration
import sys
list_comp = [x for x in range(1000000)] # Creates entire list in memory
gen_exp = (x for x in range(1000000)) # Generates values on demand

print(sys.getsizeof(list_comp)) # ~8 MB
print(sys.getsizeof(gen_exp)) # ~128 bytes

Use generators when working with large datasets or infinite sequences to save memory.

12What is the use of decorators in Python? Provide a simple example.

Decorators are functions that modify the behavior of other functions or classes without changing their source code.

Key Concepts:

  1. Functions are first-class objects in Python
  2. Decorators wrap another function to extend its behavior
  3. Denoted by @decorator_name syntax
  4. Commonly used for logging, authentication, timing, caching

Simple Example:

# Basic decorator
def uppercase_decorator(func):
def wrapper():
result = func()
return result.upper()
return wrapper

@uppercase_decorator
def greet():
return "hello world"

print(greet()) # HELLO WORLD

# Decorator with arguments
def repeat(times):
def decorator(func):
def wrapper(*args, **kwargs):
for _ in range(times):
func(*args, **kwargs)
return wrapper
return decorator

@repeat(3)
def say_hello(name):
print(f"Hello, {name}!")

say_hello("Alice")
# Output:
# Hello, Alice!
# Hello, Alice!
# Hello, Alice!

Practical Example - Timing Functions:

import time

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

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

slow_function()
# Output: slow_function took 2.0012 seconds

Built-in Decorators:

  1. @property - Converts method to attribute
  2. @staticmethod - Defines static method
  3. @classmethod - Defines class method

13How does Python handle memory management and garbage collection?

Python uses automatic memory management with several key mechanisms:

1. Private Heap Space:

  1. All Python objects are stored in a private heap
  2. Managed internally by Python Memory Manager
  3. Not directly accessible to programmers

2. Reference Counting:

  1. Each object has a reference count
  2. Count increases when new reference is created
  3. Count decreases when reference is deleted or goes out of scope
  4. Object is deallocated when count reaches zero

3. Garbage Collection:

  1. Handles circular references that reference counting can't
  2. Uses generational garbage collection
  3. Objects are divided into three generations (0, 1, 2)
  4. Younger generations are collected more frequently

Example:

import sys
import gc

# Reference counting
a = [1, 2, 3]
print(sys.getrefcount(a)) # Shows reference count

b = a # Reference count increases
print(sys.getrefcount(a))

del b # Reference count decreases
print(sys.getrefcount(a))

# Circular reference problem
class Node:
def __init__(self):
self.ref = None

node1 = Node()
node2 = Node()
node1.ref = node2
node2.ref = node1 # Circular reference

# Manually trigger garbage collection
gc.collect() # Cleans up circular references

# Check garbage collector settings
print(gc.get_threshold()) # (700, 10, 10) - collection thresholds
print(gc.isenabled()) # True

# Disable/enable garbage collection
gc.disable()
gc.enable()

Best Practices:

  1. Don't create unnecessary circular references
  2. Use context managers (with statement) for resource management
  3. Let Python handle memory automatically in most cases
  4. Use __del__() method carefully (it's called on garbage collection)

14Explain exception handling in Python — how do try, except, else, and finally work?

Python's exception handling provides a robust way to handle errors gracefully:

Components:

  1. try - Code that might raise an exception
  2. except - Handles specific exceptions
  3. else - Executes if no exception occurs
  4. finally - Always executes (cleanup code)

Basic Syntax:

try:
# Code that might raise exception
result = 10 / 0
except ZeroDivisionError:
# Handle specific exception
print("Cannot divide by zero!")
except Exception as e:
# Catch all other exceptions
print(f"Error occurred: {e}")
else:
# Executes if no exception
print("Division successful")
finally:
# Always executes
print("Cleanup complete")

Practical Examples:

# Multiple exception types
def divide_numbers(a, b):
try:
result = a / b
return result
except ZeroDivisionError:
return "Cannot divide by zero"
except TypeError:
return "Invalid input types"
except Exception as e:
return f"Unexpected error: {e}"
finally:
print("Division attempt completed")

print(divide_numbers(10, 2)) # 5.0
print(divide_numbers(10, 0)) # Cannot divide by zero
print(divide_numbers(10, "2")) # Invalid input types

# File handling with exception handling
def read_file(filename):
try:
with open(filename, 'r') as file:
content = file.read()
return content
except FileNotFoundError:
return "File not found"
except PermissionError:
return "Permission denied"
finally:
print("File operation completed")

# Raising custom exceptions
class InvalidAgeError(Exception):
pass

def check_age(age):
if age < 0:
raise InvalidAgeError("Age cannot be negative")
elif age < 18:
raise ValueError("Must be 18 or older")
return "Valid age"

try:
check_age(-5)
except InvalidAgeError as e:
print(f"Custom error: {e}")
except ValueError as e:
print(f"Value error: {e}")

Best Practices:

  1. Catch specific exceptions, not bare except
  2. Use finally for cleanup (closing files, connections)
  3. Don't use exceptions for normal flow control
  4. Log exceptions for debugging

15What is the purpose of the statement if __name__ == "__main__": in a Python script?

This statement checks whether a Python file is being run directly or being imported as a module.

How it Works:

  1. When a file is run directly, Python sets __name__ to "__main__"
  2. When a file is imported, __name__ is set to the module name
  3. Allows you to have code that only runs when the script is executed directly

Use Cases:

  1. Testing code in the same file as module definitions
  2. Providing a CLI interface for modules
  3. Running demonstrations or examples
  4. Preventing code execution when importing

Example:

# mymodule.py

def add(a, b):
"""Function to add two numbers"""
return a + b

def multiply(a, b):
"""Function to multiply two numbers"""
return a * b

# This code only runs when script is executed directly
if __name__ == "__main__":
# Testing/demo code
print("Testing the module...")
print(f"2 + 3 = {add(2, 3)}")
print(f"2 * 3 = {multiply(2, 3)}")
print("Module works correctly!")

When Used:

# Scenario 1: Running directly
$ python mymodule.py
# Output:
# Testing the module...
# 2 + 3 = 5
# 2 * 3 = 6
# Module works correctly!

# Scenario 2: Importing in another file
# main.py
import mymodule

result = mymodule.add(10, 20)
print(result) # 30
# The test code in mymodule.py doesn't run

Practical Pattern:

def main():
"""Main function containing script logic"""
print("Running main program")
# Your code here

if __name__ == "__main__":
main()

This pattern makes your code reusable as both a standalone script and an importable module.

16What are map(), filter(), and reduce() functions in Python and when would you use them?

These are functional programming tools that operate on iterables without explicit loops.

map():

  1. Applies a function to every item in an iterable
  2. Returns a map object (iterator)
  3. Syntax: map(function, iterable)

filter():

  1. Filters items based on a condition (function returns True/False)
  2. Returns a filter object (iterator)
  3. Syntax: filter(function, iterable)

reduce():

  1. Applies a function cumulatively to reduce iterable to a single value
  2. Must import from functools module
  3. Syntax: reduce(function, iterable[, initializer])

Examples:

from functools import reduce

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

# With regular function
def double(x):
return x * 2

doubled = list(map(double, numbers))
print(doubled) # [2, 4, 6, 8, 10]

# Multiple iterables
list1 = [1, 2, 3]
list2 = [4, 5, 6]
sums = list(map(lambda x, y: x + y, list1, list2))
print(sums) # [5, 7, 9]

# filter() - Select elements based on condition
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # [2, 4, 6, 8, 10]

# Filter strings by length
words = ["hi", "hello", "hey", "wonderful", "world"]
long_words = list(filter(lambda w: len(w) > 3, words))
print(long_words) # ['hello', 'wonderful', 'world']

# reduce() - Cumulative operation
numbers = [1, 2, 3, 4, 5]
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all) # 15 (1+2+3+4+5)

product = reduce(lambda x, y: x * y, numbers)
print(product) # 120 (1*2*3*4*5)

# Find maximum
max_value = reduce(lambda x, y: x if x > y else y, numbers)
print(max_value) # 5

# With initial value
sum_with_initial = reduce(lambda x, y: x + y, numbers, 10)
print(sum_with_initial) # 25 (10+1+2+3+4+5)

Comparison with List Comprehensions:

# These are equivalent

# Using map
squared = list(map(lambda x: x ** 2, numbers))

# Using list comprehension (often more Pythonic)
squared = [x ** 2 for x in numbers]

# Using filter
even = list(filter(lambda x: x % 2 == 0, numbers))

# Using list comprehension
even = [x for x in numbers if x % 2 == 0]

When to use:

  1. Use map() and filter() with existing functions
  2. Use list comprehensions for lambda-based transformations (more Pythonic)
  3. Use reduce() for cumulative operations where built-in alternatives don't exist

17How are sets different from lists and dictionaries in Python?

Sets, lists, and dictionaries are all collection types but with distinct characteristics:

Lists:

  1. Ordered collection
  2. Allows duplicates
  3. Mutable (can be modified)
  4. Indexed by position
  5. Syntax: [1, 2, 3]

Sets:

  1. Unordered collection
  2. No duplicates allowed
  3. Mutable (elements must be immutable)
  4. No indexing
  5. Optimized for membership testing
  6. Syntax: {1, 2, 3}

Dictionaries:

  1. Ordered (Python 3.7+) key-value pairs
  2. Keys must be unique and immutable
  3. Values can be duplicates
  4. Indexed by keys
  5. Syntax: {'a': 1, 'b': 2}

Examples:

# Lists - ordered, allows duplicates
my_list = [1, 2, 2, 3, 4, 4]
print(my_list[0]) # 1 (indexed access)
print(len(my_list)) # 6

# Sets - unordered, no duplicates
my_set = {1, 2, 2, 3, 4, 4}
print(my_set) # {1, 2, 3, 4} - duplicates removed
# print(my_set[0]) # TypeError - sets don't support indexing

# Dictionaries - key-value pairs
my_dict = {'name': 'Alice', 'age': 25, 'age': 30}
print(my_dict) # {'name': 'Alice', 'age': 30} - duplicate key overwritten
print(my_dict['name']) # Alice

# Set operations - very useful!
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1 | set2) # Union: {1, 2, 3, 4, 5, 6}
print(set1 & set2) # Intersection: {3, 4}
print(set1 - set2) # Difference: {1, 2}
print(set1 ^ set2) # Symmetric difference: {1, 2, 5, 6}

# Membership testing - sets are fastest
import time

large_list = list(range(10000))
large_set = set(range(10000))

# List membership (slow)
start = time.time()
9999 in large_list
print(f"List: {time.time() - start:.6f}s")

# Set membership (fast)
start = time.time()
9999 in large_set
print(f"Set: {time.time() - start:.6f}s")

# Removing duplicates from a list
list_with_dupes = [1, 2, 2, 3, 3, 3, 4]
unique_list = list(set(list_with_dupes))
print(unique_list) # [1, 2, 3, 4]

When to use:

  1. List: Ordered collection, need indexing, allow duplicates
  2. Set: Remove duplicates, membership testing, set operations
  3. Dictionary: Key-value mapping, fast lookups by key

18What is the difference between inheritance and polymorphism in Python OOP?

Inheritance and polymorphism are fundamental OOP concepts that work together but serve different purposes:

Inheritance:

  1. Mechanism where a class derives properties and methods from another class
  2. Enables code reusability
  3. Creates a parent-child (is-a) relationship
  4. Child class inherits all attributes and methods from parent

Polymorphism:

  1. Ability of different objects to respond to the same method in different ways
  2. Greek for "many forms"
  3. Achieved through method overriding or duck typing
  4. Enables writing flexible, reusable code

Inheritance Example:

# Parent class (Base class)
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return "Some sound"
def info(self):
return f"I am {self.name}"

# Child classes (Derived classes)
class Dog(Animal): # Dog inherits from Animal
def speak(self): # Method overriding
return "Woof!"
def fetch(self): # Additional method
return f"{self.name} is fetching"

class Cat(Animal): # Cat inherits from Animal
def speak(self): # Method overriding
return "Meow!"
def scratch(self): # Additional method
return f"{self.name} is scratching"

# Using inheritance
dog = Dog("Buddy")
print(dog.info()) # Inherited method: "I am Buddy"
print(dog.speak()) # Overridden method: "Woof!"
print(dog.fetch()) # Own method: "Buddy is fetching"

cat = Cat("Whiskers")
print(cat.info()) # Inherited method: "I am Whiskers"
print(cat.speak()) # Overridden method: "Meow!"

Polymorphism Example:

# Polymorphism - same method, different behavior
def make_animal_speak(animal):
print(animal.speak()) # Works with any Animal subclass

dog = Dog("Max")
cat = Cat("Luna")
generic_animal = Animal("Unknown")

# Same function works with different object types
make_animal_speak(dog) # Woof!
make_animal_speak(cat) # Meow!
make_animal_speak(generic_animal) # Some sound

# Polymorphism with a list
animals = [Dog("Rex"), Cat("Mittens"), Dog("Spot")]

for animal in animals:
print(f"{animal.name} says: {animal.speak()}")
# Output:
# Rex says: Woof!
# Mittens says: Meow!
# Spot says: Woof!

Multiple Inheritance:

class Flyable:
def fly(self):
return "Flying high"

class Swimmable:
def swim(self):
return "Swimming"

class Duck(Animal, Flyable, Swimmable): # Multiple inheritance
def speak(self):
return "Quack!"

duck = Duck("Donald")
print(duck.speak()) # Quack!
print(duck.fly()) # Flying high
print(duck.swim()) # Swimming
print(duck.info()) # I am Donald

Key Differences:

  1. Inheritance: About code reuse and creating relationships
  2. Polymorphism: About interface flexibility and behavior variation
  3. Inheritance is the mechanism; polymorphism is the result

19What are some common uses of the re (regular expression) module in Python?

The re module provides powerful pattern matching and text manipulation capabilities.

Common Functions:

  1. re.search() - Find first match anywhere in string
  2. re.match() - Match at beginning of string
  3. re.findall() - Find all matches as a list
  4. re.sub() - Replace matches
  5. re.split() - Split string by pattern
  6. re.compile() - Compile pattern for reuse

Common Pattern Elements:

  1. \d - Digit (0-9)
  2. \w - Word character (letter, digit, underscore)
  3. \s - Whitespace
  4. . - Any character except newline
  5. * - 0 or more occurrences
  6. + - 1 or more occurrences
  7. ? - 0 or 1 occurrence
  8. {n} - Exactly n occurrences
  9. ^ - Start of string
  10. $ - End of string

Practical Examples:

import re

# 1. Email validation
email = "user@example.com"
pattern = r"^[\w\.-]+@[\w\.-]+\.\w+$"
if re.match(pattern, email):
print("Valid email")

# 2. Phone number extraction
text = "Call me at 123-456-7890 or 987-654-3210"
phones = re.findall(r"\d{3}-\d{3}-\d{4}", text)
print(phones) # ['123-456-7890', '987-654-3210']

# 3. Password validation (8+ chars, letter + number)
password = "secure123"
if re.match(r"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$", password):
print("Strong password")

# 4. Extract URLs from text
text = "Visit https://example.com or http://test.org"
urls = re.findall(r"https?://[\w\.-]+\.\w+", text)
print(urls) # ['https://example.com', 'http://test.org']

# 5. Replace/clean text
text = "Hello World! How are you?"
cleaned = re.sub(r"\s+", " ", text) # Replace multiple spaces with one
print(cleaned) # "Hello World! How are you?"

# 6. Remove HTML tags
html = "
Hello World
"
plain_text = re.sub(r"<.*?>", "", html)
print(plain_text) # "Hello World"

# 7. Split by multiple delimiters
text = "apple,banana;orange|grape"
fruits = re.split(r"[,;|]", text)
print(fruits) # ['apple', 'banana', 'orange', 'grape']

# 8. Extract hashtags
tweet = "Loving #Python and #Coding today!"
hashtags = re.findall(r"#\w+", tweet)
print(hashtags) # ['#Python', '#Coding']

# 9. Validate date format (YYYY-MM-DD)
date = "2025-11-09"
if re.match(r"^\d{4}-\d{2}-\d{2}$", date):
print("Valid date format")

# 10. Compile pattern for reuse (more efficient)
email_pattern = re.compile(r"^[\w\.-]+@[\w\.-]+\.\w+$")
print(email_pattern.match("test@example.com")) # Match object
print(email_pattern.match("invalid-email")) # None

# 11. Groups and capturing
phone = "123-456-7890"
match = re.search(r"(\d{3})-(\d{3})-(\d{4})", phone)
if match:
area_code = match.group(1) # 123
print(f"Area code: {area_code}")
print(match.groups()) # ('123', '456', '7890')

# 12. Case-insensitive matching
text = "Python is AWESOME"
if re.search(r"python", text, re.IGNORECASE):
print("Found 'python' (case-insensitive)")

Best Practices:

  1. Use raw strings (r"pattern") to avoid escape issues
  2. Compile patterns that are used multiple times
  3. Test regex patterns using tools like regex101.com
  4. Don't over-complicate - sometimes simple string methods are better

20What is the Global Interpreter Lock (GIL) in Python?

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecode simultaneously.

Key Points:

  1. Only one thread can execute Python code at a time
  2. Exists in CPython (the standard Python implementation)
  3. Simplifies memory management but limits multi-threading performance
  4. Affects CPU-bound tasks more than I/O-bound tasks

Why GIL Exists:

  1. Makes memory management simpler and safer
  2. Prevents race conditions with reference counting
  3. Allows easy integration with C libraries
  4. Simplifies implementation of CPython

Impact on Performance:

import threading
import time

# CPU-bound task (affected by GIL)
def cpu_intensive():
total = 0
for i in range(10_000_000):
total += i
return total

# Single thread
start = time.time()
cpu_intensive()
print(f"Single thread: {time.time() - start:.2f}s")

# Multiple threads (not much faster due to GIL)
start = time.time()
threads = []
for _ in range(2):
t = threading.Thread(target=cpu_intensive)
threads.append(t)
t.start()

for t in threads:
t.join()
print(f"Two threads: {time.time() - start:.2f}s")
# Often similar or slower due to GIL overhead!

Workarounds:

# 1. Use multiprocessing for CPU-bound tasks
from multiprocessing import Pool

def cpu_task(n):
return sum(range(n))

with Pool(processes=4) as pool:
results = pool.map(cpu_task, [1000000, 2000000, 3000000])

# 2. Use threading for I/O-bound tasks (GIL released during I/O)
import threading
import requests

def fetch_url(url):
response = requests.get(url)
return len(response.content)

urls = ['http://example.com'] * 10
threads = []

for url in urls:
t = threading.Thread(target=fetch_url, args=(url,))
threads.append(t)
t.start()

for t in threads:
t.join()

# 3. Use async/await for I/O operations
import asyncio

async def async_task():
await asyncio.sleep(1)
return "Done"

async def main():
tasks = [async_task() for _ in range(10)]
results = await asyncio.gather(*tasks)

asyncio.run(main())

# 4. Use alternative Python implementations
# - Jython (Java-based, no GIL)
# - IronPython (.NET-based, no GIL)
# - PyPy (JIT compiler, still has GIL but faster)

When GIL Matters:

  1. CPU-bound tasks: Use multiprocessing
  2. I/O-bound tasks: Threading works fine (GIL released during I/O)
  3. Network requests: async/await or threading
  4. Data processing: NumPy/Pandas (release GIL internally)

The GIL is not a limitation for most applications, especially I/O-bound ones like web servers.

21How does file handling work in Python? Why is with open(...) as ...: preferred?

Python provides several ways to work with files, but the with statement is the recommended approach.

Basic File Operations:

  1. 'r' - Read mode (default)
  2. 'w' - Write mode (overwrites existing content)
  3. 'a' - Append mode
  4. 'r+' - Read and write mode

Why use with statement?

  1. Automatically closes the file (even if exceptions occur)
  2. Cleaner and more readable code
  3. Prevents resource leaks
  4. No need to explicitly call close()

Examples:

# OLD WAY - Not recommended
file = open('data.txt', 'r')
content = file.read()
file.close() # Must remember to close!

# RECOMMENDED WAY - Using with statement
with open('data.txt', 'r') as file:
content = file.read()
# File automatically closes after this block

# Reading files - different methods
with open('data.txt', 'r') as file:
# Read entire file
content = file.read()
# Read line by line
for line in file:
print(line.strip())
# Read all lines into a list
lines = file.readlines()

# Writing to files
with open('output.txt', 'w') as file:
file.write("Hello, World!\n")
file.write("Second line\n")

# Appending to files
with open('log.txt', 'a') as file:
file.write("New log entry\n")

# Reading and writing
with open('data.txt', 'r+') as file:
content = file.read()
file.write("\nNew content")

# Working with multiple files
with open('input.txt', 'r') as infile, open('output.txt', 'w') as outfile:
for line in infile:
outfile.write(line.upper())

# Exception handling with files
try:
with open('data.txt', 'r') as file:
content = file.read()
except FileNotFoundError:
print("File not found")
except PermissionError:
print("Permission denied")

The with statement uses context managers (__enter__ and __exit__ methods) to ensure proper resource management.

See Other FAQs