[2024] Common Python Interview Questions

Explore a comprehensive list of common Python interview questions to boost your preparation. This guide covers a range of topics including data handling, functions, object-oriented programming, and advanced Python features. Perfect for candidates looking to ace their Python coding interviews.

Python Interview Q & A Aug 27, 2024 60 Add to Reading List

[2024] Common Python Interview Questions

Preparing for a Python interview involves understanding both fundamental and advanced concepts. This article covers a range of common Python interview questions that can help you get ready for your next technical interview.

1. What are the key features of Python?

Python is known for its simplicity and readability, with key features including:

Easy Syntax: Python’s syntax is clean and easy to understand, making it an excellent choice for beginners.

Dynamic Typing: Python uses dynamic typing, which means that variable types are determined at runtime.

Interpreted Language: Python is interpreted, which allows for immediate execution of code.

Object-Oriented: Python supports object-oriented programming with classes and inheritance.

Extensive Libraries: Python has a rich standard library and numerous third-party packages.

2. How does Python handle memory management?

Python handles memory management automatically using a built-in garbage collector. It uses reference counting to track objects and their references. When an object’s reference count drops to zero, it is eligible for garbage collection. Python also includes a cyclic garbage collector to handle reference cycles.

3. What is the difference between `list` and `tuple` in Python?

List: A list is mutable, meaning its elements can be modified after creation. Lists are defined using square brackets, e.g., [1, 2, 3].

Tuple: A tuple is immutable, meaning its elements cannot be changed once created. Tuples are defined using parentheses, e.g., (1, 2, 3).

4. What are Python decorators and how do they work?

Decorators are a design pattern in Python that allows you to modify the behavior of a function or a class method. They are implemented as functions that return other functions. You use the @decorator_name syntax to apply a decorator to a function.

Example:

def decorator_func(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@decorator_func
def say_hello():
    print("Hello!")

say_hello()

5. What is the purpose of the `self` keyword in Python classes?

The self keyword represents the instance of the class and allows access to the instance’s attributes and methods. It is used to differentiate between instance variables and local variables.

Example:

class MyClass:
    def __init__(self, value):
        self.value = value

    def display(self):
        print(self.value)

6. How do you handle exceptions in Python?

Exceptions in Python are handled using try, except, else, and finally blocks:

try: Code that might throw an exception is placed here.

except: Code to handle the exception is placed here.

else: Code that runs if no exceptions are raised.

finally: Code that runs regardless of whether an exception was raised or not.

Example:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")
finally:
    print("This block always runs.")

7. What is a Python generator and how does it differ from a function?

A generator is a special type of iterator that allows you to iterate over a sequence of values. Unlike functions that return a single value, generators use the yield keyword to return multiple values one at a time, pausing execution between yields.

Example:

def my_generator():
    yield 1
    yield 2
    yield 3

for value in my_generator():
    print(value)

8. What are Python list comprehensions and how do you use them?

List comprehensions provide a concise way to create lists. They consist of an expression followed by a for clause and optional if clauses.

Example:

squares = [x**2 for x in range(10)]

This creates a list of squares from 0 to 81.

9. Explain the difference between `deep copy` and `shallow copy`.

Shallow Copy: Creates a new object, but does not create copies of nested objects. Instead, it copies references to the nested objects.

Deep Copy: Creates a new object and recursively copies all objects found in the original.

Example:

import copy

original = [1, [2, 3]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

10. How can you achieve multithreading in Python?

Python provides the threading module to work with threads. Threads allow you to run multiple operations concurrently, though Python’s Global Interpreter Lock (GIL) can limit the effectiveness of multi-threading for CPU-bound tasks.

Example:

import threading

def print_numbers():
    for i in range(5):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

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

is: Checks if two variables point to the same object in memory.
==: Checks if the values of two variables are equal.

Example:

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # True, because the contents are equal
print(a is b)  # False, because they are different objects in memory

12. How do you manage package dependencies in Python?

Python uses package management tools like pip and conda to manage dependencies. You can specify dependencies in a requirements.txt file for pip or an environment.yml file for conda.

Example of requirements.txt:

To install the packages listed in requirements.txt, you would run:

13. What is the `with` statement in Python, and how does it help with resource management?

The with statement simplifies resource management by ensuring that resources are properly acquired and released. It is commonly used for file handling, where it automatically closes the file when the block of code is exited.

Example:

with open('file.txt', 'r') as file:
    contents = file.read()
# File is automatically closed when the block is exited

14. How do you use Python's built-in `map` and `filter` functions?

map: Applies a function to all items in an input list (or other iterable) and returns an iterator of the results.

Example:

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

filter: Filters elements from an iterable based on a function that returns True or False.

Example:

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

15. What is the `global` keyword used for in Python?

The global keyword allows you to modify a variable outside the current scope. It is used to indicate that a variable refers to a global variable rather than a local one.

Example:

x = 10

def modify_global():
    global x
    x = 20

modify_global()
print(x)  # 20

16. Explain Python’s `init` method and its purpose.

The __init__ method is a special method in Python classes that is called when an instance of the class is created. It initializes the instance with default or provided values.

Example:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(person.name)  # Alice
print(person.age)   # 30

17. What are Python’s built-in data types?

Python includes several built-in data types, such as:

Numeric Types: int, float, complex
Sequence Types: str (string), list, tuple
Mapping Type: dict
Set Types: set, frozenset
Boolean Type: bool
Binary Types: bytes, bytearray, memoryview

18. How do you perform unit testing in Python?

Python uses the unittest framework for unit testing. You create test cases by subclassing unittest.TestCase and writing test methods.

Example:

import unittest

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

class TestAddFunction(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

if __name__ == '__main__':
    unittest.main()

19. What is the `str` method, and how is it used?

The __str__ method is a special method used to define the string representation of an object. It is called by the str() function and print() function to return a human-readable string representation.

Example:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"{self.name} is {self.age} years old."

person = Person("Bob", 25)
print(person)  # Bob is 25 years old.

20. What are Python’s list methods, and how do they differ from each other?

Python lists have several methods, including:

append(): Adds an item to the end of the list.
extend(): Extends the list by appending elements from an iterable.
insert(): Inserts an item at a specified position.
remove(): Removes the first occurrence of a specified item.
pop(): Removes and returns an item at a specified position (or the last item if no position is specified).
sort(): Sorts the items of the list in place.
reverse(): Reverses the elements of the list in place.

Example:

numbers = [1, 2, 3]
numbers.append(4)  # [1, 2, 3, 4]
numbers.extend([5, 6])  # [1, 2, 3, 4, 5, 6]
numbers.insert(0, 0)  # [0, 1, 2, 3, 4, 5, 6]
numbers.remove(3)  # [0, 1, 2, 4, 5, 6]
numbers.pop()  # [0, 1, 2, 4, 5]
numbers.sort()  # [0, 1, 2, 4, 5]
numbers.reverse()  # [5, 4, 2, 1, 0]

21. How do you handle missing or incomplete data in Python?

Handling missing or incomplete data is crucial in data processing. Python libraries like pandas provide several methods for dealing with such data:

dropna(): Removes missing values.
fillna(): Fills missing values with specified values or methods.
isna(): Checks for missing values.

Example:

import pandas as pd

data = pd.DataFrame({
    'A': [1, 2, None],
    'B': [4, None, 6]
})

# Drop rows with missing values
data_dropped = data.dropna()

# Fill missing values with zero
data_filled = data.fillna(0)

# Check for missing values
missing_values = data.isna()

22. What is a lambda function in Python, and how is it used?

A lambda function is an anonymous function defined with the lambda keyword. It can have any number of arguments but only one expression. It is often used for short, throwaway functions.

Example:

add = lambda x, y: x + y
print(add(2, 3))  # 5

23. Explain Python’s `repr` method and its purpose.

The __repr__ method is a special method used to define the official string representation of an object. It is called by the repr() function and is used for debugging and development.

Example:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age!r})"

person = Person("Alice", 30)
print(repr(person))  # Person(name='Alice', age=30)

24. How do you sort a list of dictionaries by a specific key?

You can use the sorted() function along with a lambda function to sort a list of dictionaries by a specific key.

Example:

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

sorted_data = sorted(data, key=lambda x: x['age'])
print(sorted_data)
# [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

25. What are Python’s iterators and generators, and how do they differ?

Iterators: Objects that implement the iterator protocol, including __iter__() and __next__() methods. They are used to iterate over collections of items.

Example:

class MyIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.limit:
            self.current += 1
            return self.current - 1
        else:
            raise StopIteration

iterator = MyIterator(3)
for item in iterator:
    print(item)

Generators: Special functions that use the yield keyword to produce a sequence of values. They are simpler to write and use less memory than iterators.

Example:

def my_generator(limit):
    for i in range(limit):
        yield i

for item in my_generator(3):
    print(item)

26. What is the purpose of Python’s `del` method?

The __del__ method is a special method that is called when an object is about to be destroyed. It is used to perform any cleanup or resource deallocation before the object is removed from memory.

Example:

class MyClass:
    def __init__(self):
        print("Object created")

    def __del__(self):
        print("Object destroyed")

obj = MyClass()
del obj  # Output: Object destroyed

27. How do you use list slicing in Python?

List slicing allows you to access a subset of a list by specifying a start, stop, and optional step. The syntax is list[start:stop:step].

Example:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Get elements from index 2 to 5
subset = numbers[2:6]  # [2, 3, 4, 5]

# Get every second element
every_second = numbers[::2]  # [0, 2, 4, 6, 8]

# Reverse the list
reversed_list = numbers[::-1]  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

28. What are Python’s data structures, and when should you use each?

Python provides several built-in data structures:

Lists: Ordered, mutable collections of items. Use for ordered collections where you need to modify elements.
Tuples: Ordered, immutable collections of items. Use for fixed-size collections where immutability is desired.
Sets: Unordered collections of unique items. Use for membership testing and removing duplicates.
Dictionaries: Unordered collections of key-value pairs. Use for fast lookups, insertions, and deletions.

29. How do you implement a class method and a static method in Python?

Class Method: A method that receives the class as its first argument. Defined with the @classmethod decorator.

Example:

class MyClass:
    count = 0

    @classmethod
    def increment_count(cls):
        cls.count += 1

MyClass.increment_count()
print(MyClass.count)  # 1

Static Method: A method that does not receive an implicit first argument. Defined with the @staticmethod decorator.

Example:

class MyClass:
    @staticmethod
    def greet(name):
        return f"Hello, {name}!"

print(MyClass.greet("Alice"))  # Hello, Alice!

30. What is the difference between `deepcopy` and `copy` in Python?

copy.copy(): Creates a shallow copy of an object. It copies the object but not the nested objects.
copy.deepcopy(): Creates a deep copy of an object. It recursively copies all nested objects, resulting in a completely independent object.

Example:

import copy

original = [[1, 2], [3, 4]]
shallow_copy = copy.copy(original)
deep_copy = copy.deepcopy(original)

# Modify the original object
original[0][0] = 0

print(original)      # [[0, 2], [3, 4]]
print(shallow_copy) # [[0, 2], [3, 4]]
print(deep_copy)    # [[1, 2], [3, 4]]

31. What are Python’s special methods, and can you give some examples?

Special methods (also known as magic methods or dunder methods) are methods with double underscores before and after their names. They allow you to define how objects behave with built-in functions and operators.

Examples:

__init__(): Initializes a new instance of a class.
__str__(): Defines the string representation of an object.
__repr__(): Defines the official string representation of an object.
__len__(): Returns the length of an object.
__getitem__(): Accesses an item by index.
__setitem__(): Sets an item by index.

Example:

class MyClass:
    def __init__(self, values):
        self.values = values

    def __len__(self):
        return len(self.values)

    def __getitem__(self, index):
        return self.values[index]

obj = MyClass([1, 2, 3])
print(len(obj))  # 3
print(obj[1])    # 2

32. How do you implement multi-threading in Python?

Python’s threading module allows you to create and manage threads. Threads are useful for I/O-bound tasks, but due to the Global Interpreter Lock (GIL), multi-threading is not as effective for CPU-bound tasks.

Example:

import threading

def print_numbers():
    for i in range(5):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

33. How do you handle large data files in Python?

For handling large data files, consider using libraries like pandas for data manipulation or csv for reading and writing CSV files. Additionally, you can use file chunking to process data in smaller parts.

Example using pandas:

import pandas as pd

chunksize = 10000
for chunk in pd.read_csv('large_file.csv', chunksize=chunksize):
    process(chunk)

34. What is the difference between `args` and `kwargs`?

*args: Allows a function to accept a variable number of positional arguments. It is used to pass a non-keyworded, variable-length argument list.
**kwargs: Allows a function to accept a variable number of keyword arguments. It is used to pass a keyworded, variable-length argument list.

Example:

def example_function(*args, **kwargs):
    print("Arguments:", args)
    print("Keyword arguments:", kwargs)

example_function(1, 2, 3, a=4, b=5)
# Arguments: (1, 2, 3)
# Keyword arguments: {'a': 4, 'b': 5}

35. How do you handle exceptions in Python?

Exceptions in Python are handled using try, except, else, and finally blocks. This allows you to catch and manage errors without crashing the program.

Example:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero.")
else:
    print("Division successful.")
finally:
    print("Execution completed.")

36. What is the purpose of the `pass` statement in Python?

The pass statement is a null operation. It is used as a placeholder in blocks where code is syntactically required but you have nothing to write yet.

Example:

def placeholder_function():
    pass  # Placeholder for future code

37. How do you use Python's `enumerate()` function?

The enumerate() function adds a counter to an iterable and returns it as an enumerate object, which can be used to loop over both the index and the value.

Example:

items = ['apple', 'banana', 'cherry']
for index, item in enumerate(items):
    print(index, item)

38. What is the difference between `import` and `from ... import ...`?

import: Imports the entire module. You need to use the module name to access its functions and variables.

Example:

import math
print(math.sqrt(16))  # 4.0

from ... import ...: Imports specific items from a module directly. You can use the items without needing the module name.

Example:

from math import sqrt
print(sqrt(16))  # 4.0

39. How do you use Python’s `collections` module?

The collections module provides alternatives to built-in data types, such as namedtuple, deque, Counter, and defaultdict.

Examples:

namedtuple: Creates tuple subclasses with named fields.
deque: Provides a double-ended queue for fast appends and pops.
Counter: Counts hashable objects.
defaultdict: Provides a default value for nonexistent keys.

Example:

from collections import namedtuple, deque, Counter, defaultdict

# namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)

# deque
dq = deque([1, 2, 3])
dq.appendleft(0)

# Counter
c = Counter(['a', 'b', 'a', 'c'])

# defaultdict
dd = defaultdict(int)
dd['key'] += 1

40. What are Python’s context managers, and how do you use them?

Context managers manage resources by setting up and tearing down actions, ensuring proper resource management. They are commonly used with the with statement.

Example:

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self
    
    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")
        
with MyContextManager() as manager:
    print("Inside the context")

Conclusion

Being well-prepared for common Python interview questions can significantly boost your chances of success in technical interviews. Understanding key concepts, from basic syntax and memory management to advanced topics like decorators and generators, will help you demonstrate your Python proficiency effectively. Regular practice and familiarity with these questions will enhance your interview performance and problem-solving skills.