Python interview questions with answers for experienced – 8yrs

1.What are context managers?

A context manager in Python is used to properly manage resources, ensuring they are acquired and released as needed. It is commonly used with the with statement.

2.What are slots in Python?

__slots__ is a mechanism that allows you to explicitly declare the attributes of a class, preventing the dynamic creation of instance dictionaries (__dict__).
This can save memory in instances where many instances of a class are created. Using __slots__ is helpful when you’re working with a large number of objects and want to reduce overhead.

class MyClass: __slots__ = [‘x’, ‘y’] def __init__(self, x, y): self.x = x self.y = y

3.What is the purpose of the nonlocal keyword in Python?

The nonlocal keyword allows you to modify a variable in the nearest enclosing scope (excluding global scope). It is often used in nested functions where a variable from the outer function needs to be modified in the inner function.

def outer(): x = “outer” def inner(): nonlocal x x = “inner” inner() return x

4. What are the main concurrency models in Python?

Python primarily supports three concurrency models:

Threading:
This allows concurrent execution of code by using threads. It is useful for I/O-bound tasks but is limited by the Global Interpreter Lock (GIL), which allows only one thread to execute Python bytecode at a time.
Multiprocessing:
This model creates separate processes with their own Python interpreter and memory space. It bypasses the GIL and is suitable for CPU-bound tasks as it can fully utilize multiple CPU cores.
Asyncio:
This is an asynchronous I/O framework introduced in Python 3.4 that uses the async and await keywords to handle I/O-bound tasks efficiently. It allows writing single-threaded concurrent code using coroutines.

5. Explain the Global Interpreter Lock (GIL) in Python.

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecodes at once. This means that in a multi-threaded Python program, only one thread can execute Python code at any given time. While this simplifies memory management and makes single-threaded programs easier, it limits the performance of CPU-bound multi-threaded programs. To overcome GIL limitations, developers often use the multiprocessing module to create separate processes.

6. What is the difference between threading and multiprocessing in Python?

Threading is used to achieve concurrency in a single process. Threads share the same memory space, which makes communication between them easier but also increases the risk of data corruption due to concurrent access. Multiprocessing involves creating separate processes, each with its own memory space. This model avoids the GIL issue, making it better suited for CPU-bound tasks. However, inter-process communication (IPC) is more complex and generally slower than communication between threads.

7. How can you implement a simple producer-consumer problem using threading in Python?

implement a producer-consumer problem using the queue module and the threading library.

import threading import queue import time def producer(q): for i in range(5): item = f’item {i}’ q.put(item) print(f’Produced {item}’) time.sleep(1) def consumer(q): while True: item = q.get() if item is None: break print(f’Consumed {item}’) q.task_done() q = queue.Queue() producer_thread = threading.Thread(target=producer, args=(q,)) consumer_thread = threading.Thread(target=consumer, args=(q,)) producer_thread.start() consumer_thread.start() producer_thread.join() q.put(None) consumer_thread.join()

8. What are async and await in Python, and how do they facilitate concurrency?

async and await are keywords introduced in Python 3.5 that allow for writing asynchronous code. async is used to define a coroutine, which is a special function that can be paused and resumed, enabling non-blocking I/O operations. await is used to call another coroutine and pause the execution of the current coroutine until the awaited coroutine finishes.

This mechanism allows Python to handle I/O-bound tasks efficiently without the overhead of threading or multiprocessing, making it easier to write scalable applications, such as web servers or applications with many simultaneous connections.

9.Explain the use of metaclass in Python.

In Python, a metaclass is a class of a class that defines how a class behaves. A __metaclass__ allows you to customize class creation by overriding the default behavior of the class creation process. You can modify attributes, methods, or enforce certain constraints during class creation.

10.How can you use __init_subclass__ to customize subclass behavior in Python?

The __init_subclass__ method is a special method that is automatically called when a class is subclassed. This allows you to customize the behavior of subclasses by enforcing rules or modifying their attributes.

11.What is the purpose of the type function in Python metaprogramming?

The type function in Python can be used not only to get the type of an object but also to create new classes dynamically. When called with three arguments, it defines a new class. The first argument is the name of the class, the second is a tuple of the base classes, and the third is a dictionary of attributes and methods.

12.How do you read a file line by line in Python?

You can read a file line by line using a for loop or the readline() method. Here’s an example using a for loop:

with open(‘example.txt’, ‘r’) as file: for line in file: print(line.strip())

13.How can you write to a file in Python, and what happens if the file already exists?

write to a file using the write() or writelines() methods. If you open a file in write mode (‘w’), it will create a new file or truncate an existing file (i.e., delete its contents) before writing.

14.How do you handle exceptions when working with file I/O in Python?

Handle exceptions during file I/O using a try…except block. This allows you to catch and respond to specific exceptions, such as FileNotFoundError, IOError, or PermissionError. Explain what a stack is and how it can be implemented in Python.

Stacks can be easily implemented using a list in Python: python Copy code stack = [] # Push operation stack.append(1) stack.append(2) stack.append(3) # Pop operation top_element = stack.pop()

15.How can you implement a queue in Python?

Queues can be implemented using a list, but it is more efficient to use collections.deque, which provides O(1) time complexity for both enqueue and dequeue operations:

from collections import deque queue = deque() # Enqueue operation queue.append(1) # Adds 1 queue.append(2) # Adds 2 # Dequeue operation front_element = queue.popleft()

16.How linked list differ from an array?

Differences from an Array:

Memory Allocation:
Arrays require contiguous memory allocation, whereas linked lists can be spread throughout memory. This allows linked lists to grow and shrink dynamically. Size: The size of an array is fixed at the time of its creation, while a linked list can grow or shrink as needed.
Access Time:
Arrays provide O(1) time complexity for accessing elements by index, while linked lists require O(n) time complexity to access an element, as you must traverse the list from the head to the desired node.

17.How does a lambda function differ from a regular function?

Differences from a Regular Function:

Anonymous:
Lambda functions do not have a name, whereas regular functions are defined using the def keyword and can be named.
Single Expression:
Lambda functions can only contain a single expression and cannot contain statements or annotations, while regular functions can have multiple expressions, statements, and can include documentation.
Return Value:
In a lambda function, the expression’s value is returned automatically. In contrast, regular functions use the return statement to return values.

18.Can you provide an example of using a lambda function as an argument to higher-order functions like map(), filter()?

map(): Applies a lambda function to each item in an iterable. numbers = [1, 2, 3, 4] squared = list(map(lambda x: x ** 2, numbers)) print(squared) filter(): Filters items from an iterable using a lambda function. numbers = [1, 2, 3, 4, 5, 6] even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) print(even_numbers)

19.How can you use a lambda function to create a simple sorting mechanism?

Use a lambda function as the key argument in the sorted() function to customize the sorting behavior. For example, sorting a list of tuples based on the second element:

data = [(1, ‘one’), (3, ‘three’), (2, ‘two’)] sorted_data = sorted(data, key=lambda x: x[1]) print(sorted_data)

20.Explain how to use a lambda function to implement a simple closure.

A closure is a function that remembers its enclosing lexical scope even when the function is executed outside that scope. You can create a closure using a lambda function as follows:

def make_multiplier(factor): return lambda x: x * factor double = make_multiplier(2) triple = make_multiplier(3) print(double(5)) # Output: 10 print(triple(5))

21.What is the difference between map() and a for loop?

Both map() and a for loop can apply a function to each element in an iterable, but map() is often more concise. While a for loop explicitly iterates and stores the result manually, map() does so implicitly and returns an iterator.
For example, using map() can improve code readability and performance when working with functional-style code. However, map() doesn’t modify the original iterable, whereas a for loop can be customized to do so.

22.What is the return type of map() in Python 3.x?

In Python 3.x, map() returns an iterator, which is a lazily evaluated object. It doesn’t apply the function to the elements immediately but computes the values on-demand when the iterator is consumed (e.g., by converting it to a list or using it in a loop). In Python 2.x, however, map() returned a list by default.

23.How can you convert the result of map() into a list or other types?

Since map() returns an iterator, convert it to a list using the list() constructor or any other type, like a tuple, by passing the map() result to their respective constructors:

result = map(lambda x: x ** 2, [1, 2, 3]) result_list = list(result) result_tuple = tuple(result)

24.Can map() work with multiple iterables?

Yes, the map() function can accept multiple iterables if the function provided takes multiple arguments. In this case, map() applies the function to corresponding elements from all iterables in parallel. The iteration stops when the shortest iterable is exhausted. For example:

result = map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6]) print(list(result))

25.Why is the collections module in Python useful?

The collections module in Python provides specialized container data types beyond the basic built-in types like list, tuple, dict, and set. It includes useful structures like:

namedtuple
deque
Counter
defaultdict
OrderedDict.

These data types allow for more efficient and flexible operations depending on the use case. For example, Counter is ideal for counting hashable objects, while deque provides an efficient way to add/remove items from both ends of a list.

26.How can counter be used in Python?

Counter is a dict subclass in the collections module used to count the occurrences of elements in an iterable. It stores elements as dictionary keys and their counts as dictionary values. This is particularly useful for tallying items, such as finding the frequency of words in a text.

from collections import Counter word_count = Counter([‘apple’, ‘banana’, ‘apple’, ‘orange’]) print(word_count)

27.What is the purpose of defaultdict?

defaultdict is a subclass of the built-in dict class. It overrides one aspect of the behavior: if you try to access or modify a key that doesn’t exist, it will automatically create a default value for that key using a factory function (such as int, list, etc.). This avoids key errors.

from collections import defaultdict dd = defaultdict(list) dd[‘key1’].append(1) print(dd)

28.Explain deque and when you would use it over a regular list.

A deque (double-ended queue) is a list-like container that allows appending and popping elements from both ends with O(1) time complexity, which makes it more efficient than a list for such operations. You would use deque when you need to efficiently append or remove elements from either end of the sequence, such as implementing queues, stacks, or performing breadth-first searches (BFS).

from collections import deque d = deque([1, 2, 3]) d.appendleft(0) # Adds 0 to the front d.append(4) # Adds 4 to the back print(d) # Output: deque([0, 1, 2, 3, 4])

27.why deque is preferred over a regular list.

inserting or removing from the front of a regular list has O(n) time complexity, making deque preferable in such cases.

28.What is a namedtuple?

A namedtuple is a subclass of Python’s tuple that allows fields to be accessed by name rather than index, improving readability and self-documentation. It’s useful when you need to handle simple structured data and want more meaningful names than positional indices.

from collections import namedtuple Point = namedtuple(‘Point’, [‘x’, ‘y’]) p = Point(10, 20) print(p.x, p.y)

29.Which module supports regular expression?

A regular expression (regex) is a sequence of characters that forms a search pattern, often used for string matching, searching, and replacing operations.
In Python, regular expressions are supported through the re module. The module provides functions like re.search(), re.match(), re.findall(), and re.sub() for performing regex operations on strings.

30.What is the difference between re.match() and re.search()?

The re.match() function checks for a match only at the beginning of the string, returning a match object if the string starts with the pattern, while re.search() scans through the entire string and returns a match object for the first occurrence of the pattern anywhere in the string.

31.What does the re.findall() function do?

The re.findall() function returns a list of all non-overlapping matches of a pattern in a string. It searches the entire string and collects all matches. If no match is found, it returns an empty list.

32.How would you use a regular expression to split a string based on multiple delimiters?

Use re.split() to split a string using multiple delimiters by providing a pattern that matches all the delimiters. For example, to split a string on commas, spaces, and semicolons:

import re text = ‘apple, banana; orange grape’ result = re.split(r'[,\s;]+’, text) print(result)

33.How can youHow can you use re.sub() for string replacement, and how does it handle patterns?

The re.sub() function is used to replace occurrences of a pattern in a string with a specified replacement. It allows you to substitute all matches of the pattern with another string or function result.

import re text = ‘I have 2 apples and 3 oranges’ result = re.sub(r’\d+’, ‘many’, text) print(result) a pattern in a string with a specified replacement.

It allows you to substitute all matches of the pattern with another string or function result.

For example:

34.What is the difference between +, *, and ? quantifiers in regular expressions?

These are quantifiers in regex that specify how many times a pattern can occur:

+ matches one or more occurrences of the preceding element. For example, \d+ matches 1, 123, etc.

* matches zero or more occurrences of the preceding element. For example, \d* matches 123, 0, or an empty string.

? matches zero or one occurrence of the preceding element, making it optional. For example, \d? matches 1, or an empty string (no digit).

35.How do you use named groups in Python regular expressions?
Named groups allow you to name a group, making it easier to access and improving code readability. Named groups are defined using (?Ppattern), where name is the group name. You can retrieve the named group using match.group(‘name’)

36.What is the purpose of grouping in regular expressions?

Grouping in regular expressions is used to capture subpatterns and treat them as a single unit. It’s implemented using parentheses (). This is useful for extracting parts of a string, applying quantifiers to the group, or reusing the matched content.

37.What is a lookahead, and how is it used in Python regular expressions?

A lookahead is a zero-width assertion in regex that allows you to check for a pattern ahead in the string without including it in the match. Positive lookahead is specified by (?=pattern) and negative lookahead by (?!pattern). Example of positive lookahead:

38.How do you create and start a thread in Python?

Create and start a thread in Python using the threading.Thread class. Define a target function for the thread to execute and then start the thread using the start() method.

39.What is the purpose of the join() method in threading?

The join() method ensures that the main program waits for a thread to complete before proceeding. If you have multiple threads running and want to wait until all of them are finished, you can call join() on each thread. Without join(), the main thread could exit before the other threads have finished their execution.

40.What are daemon threads, and how are they different from normal threads?
Daemon threads are background threads that automatically terminate when the main program exits. Normal threads, by contrast, keep running even after the main program completes, unless they are explicitly joined. You can set a thread as a daemon by setting thread.daemon = True before starting the thread. Daemon threads are typically used for background tasks like monitoring.

41.How does GIL affect threading in Python?

The Global Interpreter Lock (GIL) is a mutex in Python that ensures only one thread executes Python bytecode at a time. This limits the effectiveness of threading for CPU-bound tasks because even though multiple threads may be running, only one can execute Python code at a time due to the GIL. However, for I/O-bound tasks, threading can still be useful because the GIL is released during I/O operations, allowing other threads to proceed

42.What are thread synchronization mechanisms in Python?

Thread synchronization mechanisms are used to manage access to shared resources by multiple threads. It prevents race conditions where two or more threads modify a shared resource simultaneously, leading to unpredictable results.

43. Explain the synchronization tools in python

Synchronization tools

Locks (threading.Lock):
Ensures that only one thread accesses a shared resource at a time.

RLocks (threading.RLock):
A reentrant lock that allows a thread to acquire the same lock multiple times.

Semaphores (threading.Semaphore):
Controls access to a resource with a limited number of slots.

Events (threading.Event):
Allows threads to wait for an event to be triggered before continuing. Synchronization mechanisms are essential to avoid data corruption and ensure that threads access shared resources safely.

44.What is a Lock?

A Lock is a synchronization primitive used to prevent multiple threads from accessing a shared resource at the same time. It ensures that only one thread can execute a critical section of code by “locking” it, forcing other threads to wait until the lock is released.

45. How do you use lock in threading?

46. How does Semaphore differ from a Lock?

A Semaphore is a synchronization primitive that controls access to a resource by allowing a limited number of threads to acquire the semaphore at the same time. While a Lock allows only one thread at a time to access a resource, a Semaphore can allow a specified number of threads to access it concurrently.

47.What is an Event object in Python threading?

An Event is a synchronization primitive used to signal one or more threads to proceed with their execution. One thread can set the event, and other threads that are waiting for the event will be unblocked when the event is set. You can use methods like set(), clear(), and wait() to manage the event

48.What are the benefits of using threads in Python?

Benefits:

Concurrency for I/O-bound tasks:
Threads are excellent for tasks like reading files or handling network requests because they allow the program to remain responsive while waiting for I/O operations to complete.

Simpler than multiprocessing:
Threading is often simpler to implement than multiprocessing, especially for I/O-bound tasks.

Shared memory:
Threads can easily share data because they run in the same memory space.

49. What are the drawbacks of using threads in python?

Drawbacks:

Global Interpreter Lock (GIL):
The GIL limits the performance of CPU-bound tasks in Python since only one thread can execute Python bytecode at a time.

Complex synchronization:
When threads share data, careful synchronization is required to avoid race conditions, deadlocks, and other concurrency bugs.

Not ideal for CPU-bound tasks:
Due to the GIL, using threading for CPU-intensive operations in Python will not provide the performance improvements seen in other languages.

50.What is threading in Python, and why is it used?

Threading in Python allows concurrent execution of multiple threads (smaller units of a process). Threads are useful for performing tasks that can run simultaneously, such as I/O-bound operations (like reading/writing files, making network requests) because they allow other tasks to run while waiting for a slow operation to complete. Threading is managed using the threading module, which provides tools to create, manage, and synchronize threads.

Request more information

Python interview questions with answers for experienced – 8yrs