Python interview questions with answers for advanced interview questions

1.How do you create a custom context manager?

Create a custom context manager by either defining the __enter__ and __exit__ methods in a class or using the contextlib.contextmanager decorator

from contextlib import contextmanager @contextmanager def custom_context(): print(“Entering context”) yield print(“Exiting context”) with custom_context(): print(“In the block”)

2.Given a string s, find the length of the longest substring without repeating characters.

def length_of_longest_substring(s: str) -> int: char_index = {} longest = 0 left = 0 for right, char in enumerate(s): if char in char_index and char_index[char] >= left: left = char_index[char] + 1 char_index[char] = right longest = max(longest, right – left + 1) return longest # Example usage s = “abcabcbb” print(length_of_longest_substring(s))

3.Given an array of integers, return the indices of two numbers such that they add up to a specific target.

def two_sum(nums, target): hash_map = {} for i, num in enumerate(nums): complement = target – num if complement in hash_map: return [hash_map[complement], i] hash_map[num] = i return [] # Example usage nums = [2, 7, 11, 15] target = 9 print(two_sum(nums, target))

4.How do you handle circular imports in Python?

Answer: Circular imports occur when two or more modules depend on each other. To handle circular imports: Rearrange imports: Move the import inside a function or method to avoid circular dependencies at the module level.

Use import statements within functions, delaying the import until it’s actually needed.
Break large modules into smaller, more modular components that reduce interdependencies.
Use absolute imports to ensure proper module referencing.

5.Given a collection of intervals, merge all overlapping intervals.

def merge(intervals): intervals.sort(key=lambda x: x[0]) merged = [] for interval in intervals: if not merged or merged[-1][1] < interval[0]: merged.append(interval) else: merged[-1][1] = max(merged[-1][1], interval[1]) return merged # Example usage intervals = [[1, 3], [2, 6], [8, 10], [15, 18]] print(merge(intervals))

6.What is monkey patching in Python?

Monkey patching refers to the practice of modifying or extending a class or module at runtime. This can be useful for altering the behavior of third-party libraries or fixing bugs dynamically without modifying the original source code.

class MyClass: def say_hello(self): print(“Hello”) def new_hello(self): print(“Hello from monkey patch”) MyClass.say_hello = new_hello obj = MyClass() obj.say_hello()

7. Find the kth largest element in an unsorted array.

import heapq def find_kth_largest(nums, k): return heapq.nlargest(k, nums)[-1] # Example usage nums = [3, 2, 1, 5, 6, 4] k = 2 print(find_kth_largest(nums, k))

8.Given two sorted arrays, find the median of the two sorted arrays.

def find_median_sorted_arrays(nums1, nums2): nums = sorted(nums1 + nums2) n = len(nums) if n % 2 == 1: return nums[n // 2] else: return (nums[n // 2 – 1] + nums[n // 2]) / 2 # Example usage nums1 = [1, 3] nums2 = [2] print(find_median_sorted_arrays(nums1, nums2))

9.How does Python’s with statement manage resources?

The with statement simplifies exception handling and ensures that resources like files or database connections are properly cleaned up after use, even if errors occur. It works by utilizing the context manager protocol, which consists of the __enter__() and __exit__() methods. When entering the with block, the __enter__() method is called to set up the resource. When leaving the block, the __exit__() method is called to release the resource, regardless of whether the block exits normally or with an exception.

10.Given a set of integers, return all possible subsets (the power set).

def subsets(nums): res = [[]] for num in nums: res += [curr + [num] for curr in res] return res # Example usage nums = [1, 2, 3] print(subsets(nums))

11.Given a string and a dictionary of words, determine if the string can be segmented into space-separated words in the dictionary.

def word_break(s, word_dict): dp = [False] * (len(s) + 1) dp[0] = True for i in range(1, len(s) + 1): for j in range(i): if dp[j] and s[j:i] in word_dict: dp[i] = True break return dp[-1] # Example usage s = “leetcode” word_dict = [“leet”, “code”] print(word_break(s, word_dict))

2.Explain the difference between deepcopy() and copy() in Python.

The copy() function creates a shallow copy of an object, meaning it copies the object itself but does not create copies of objects that the original references (nested objects). Modifications to the nested objects will be reflected in both the original and the copied object.
The deepcopy() function creates a deep copy of the object, meaning it recursively copies all objects and subobjects. Changes to the copied object or its nested objects do not affect the original.

13.Given an array of non-negative integers representing the elevation map, compute how much water it can trap after raining.

def trap(height): if not height: return 0 left, right = 0, len(height) – 1 left_max, right_max = height[left], height[right] water = 0 while left < right: if left_max < right_max: left += 1 left_max = max(left_max, height[left]) water += left_max - height[left] else: right -= 1 right_max = max(right_max, height[right]) water += right_max - height[right] return water # Example usage height = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1] print(trap(height))

14.Given a string s, find the longest palindromic substring in s.

def longest_palindrome(s): res = “” for i in range(len(s)): # odd-length palindromes temp = expand_around_center(s, i, i) if len(temp) > len(res): res = temp # even-length palindromes temp = expand_around_center(s, i, i+1) if len(temp) > len(res): res = temp return res def expand_around_center(s, left, right): while left >= 0 and right < len(s) and s[left] == s[right]: left -= 1 right += 1 return s[left + 1:right] s = "babad" print(longest_palindrome(s))

15.Given a string s and a non-empty string p, find all the start indices of p’s anagrams in s.

from collections import Counter def find_anagrams(s, p): p_count = Counter(p) s_count = Counter() result = [] p_len = len(p) for i in range(len(s)): s_count[s[i]] += 1 if i >= p_len: if s_count[s[i – p_len]] == 1: del s_count[s[i – p_len]] else: s_count[s[i – p_len]] -= 1 if s_count == p_count: result.append(i – p_len + 1) return result print(find_anagrams(s, p))

16.What are Python descriptors and how do they work?

Descriptors are objects that define how attribute access is handled in a class. They allow you to customize behavior for getting, setting, and deleting attributes. A class becomes a descriptor by implementing one or more of the following methods:

__get__(self, instance, owner): Handles attribute access.
__set__(self, instance, value): Handles attribute assignment.
__delete__(self, instance): Handles attribute deletion.

17.Given an n x n 2D matrix representing an image. Rotate the image by 90 degrees clockwise.

def rotate(matrix): matrix[:] = zip(*matrix[::-1]) # Example usage matrix = [[1,2,3], [4,5,6], [7,8,9]] rotate(matrix) print(matrix)

18.Given a list of coin denominations, find the minimum number of coins that make up a given amount.

def coin_change(coins, amount): dp = [float(‘inf’)] * (amount + 1) dp[0] = 0 for coin in coins: for x in range(coin, amount + 1): dp[x] = min(dp[x], dp[x – coin] + 1) return dp[amount] if dp[amount] != float(‘inf’) else -1 # Example usage coins = [1, 2, 5] amount = 11 print(coin_change(coins, amount))

19.Given an array of heights representing a histogram, find the largest rectangle that can be formed.

def largest_rectangle_area(heights): stack = [] max_area = 0 heights.append(0) for i, h in enumerate(heights): while stack and h < heights[stack[-1]]: height = heights[stack.pop()] width = i if not stack else i - stack[-1] - 1 max_area = max(max_area, height * width) stack.append(i) return max_area heights = [2, 1, 5, 6, 2, 3] print(largest_rectangle_area(heights))

15.Given a linked list, determine if it has a cycle. If there is a cycle, return True, otherwise, return False.

class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def has_cycle(head): slow, fast = head, head while fast and fast.next: slow = slow.next fast = fast.next.next if slow == fast: return True return False node1 = ListNode(3) node2 = ListNode(2) node3 = ListNode(0) node4 = ListNode(-4) node1.next = node2 node2.next = node3 node3.next = node4 node4.next = node2 print(has_cycle(node1))

16.Given an array of integers, find the maximum sum of a subarray of size k.

python Copy code def max_sum_subarray(arr, k): max_sum, window_sum = 0, 0 for i in range(len(arr)): window_sum += arr[i] if i >= k – 1: max_sum = max(max_sum, window_sum) window_sum -= arr[i – (k – 1)] return max_sum # Example usage arr = [2, 1, 5, 1, 3, 2] k = 3 print(max_sum_subarray(arr, k))

17.Given an array of integers, find the maximum sum of a subarray of size k.

18.Explain the difference between asyncio coroutines and threading.

asyncio coroutines use a single thread but allow for asynchronous execution by pausing tasks when they are waiting for something (like I/O) and switching to another task. This avoids the overhead of multiple threads and context switching but is only beneficial for I/O-bound tasks, not CPU-bound tasks.
Threading involves using multiple threads, which can run in parallel on multi-core processors, but due to Python’s Global Interpreter Lock (GIL), true parallelism is not achieved for CPU-bound tasks in CPython. However, it can handle I/O-bound tasks efficiently by switching between threads during blocking I/O operations.

19.What are Python descriptors and how do they work?

__get__(self, instance, owner): Handles attribute access.
__set__(self, instance, value): Handles attribute assignment.
__delete__(self, instance): Handles attribute deletion.

20.What are weak references in Python, and when would you use them?

Weak references allow you to reference an object without preventing it from being garbage collected. The weakref module provides the ability to create weak references. When the object is no longer needed and no strong references exist, the object can be garbage collected, even if a weak reference to it still exists. This is useful when you want to refer to objects but don’t want them to be kept alive unnecessarily (e.g., in caching mechanisms or circular references).

21.What are Python’s call() and callable objects?

In Python, an object is callable if it can be invoked like a function, i.e., using parentheses (). By defining the __call__() method in a class, you can make its instances callable, effectively allowing them to behave like functions.

class CallableClass:

def __call__(self, *args, **kwargs): print(“Instance called with”, args, kwargs) obj = CallableClass() obj(1, 2, 3, key=”value”)

22.What is the purpose of super() in Python, and how does it work with multiple inheritance?

The super() function allows you to call methods from a parent or sibling class. It is commonly used in class inheritance to ensure that the parent class’s methods are properly called and initialized. In the case of multiple inheritance, super() follows the method resolution order (MRO) to determine the next class in line to call.

23.Explain Python’s garbage collection mechanism.

Python uses a combination of reference counting and garbage collection to manage memory and free up unused objects.

Reference counting:
Each object maintains a reference count, which tracks how many references point to it. When the reference count drops to zero, the object is immediately deallocated.
Garbage collection:
In addition to reference counting, Python has a garbage collector that can detect and clean up circular references (where two or more objects reference each other, preventing their reference count from reaching zero). Python’s garbage collector is part of the gc module and can be manually controlled using functions like gc.collect().

24.How can you implement caching in Python using the functools.lru_cache decorator?

functools.lru_cache is a decorator that caches the results of function calls to optimize expensive operations. It uses a Least Recently Used (LRU) caching strategy, meaning the least recently accessed items are discarded when the cache limit is reached.

Example: from functools import lru_cache @lru_cache(maxsize=128) def expensive_function(n): print(f”Calculating {n}”) return n * 2 print(expensive_function(10)) # Output: Calculating 10, 20 print(expensive_function(10))

25.What is the difference between deepcopy() and pickle in Python?

deepcopy():
Creates a new object that is a deep copy of the original, meaning all nested objects are recursively copied. However, this is limited to in-memory duplication and does not persist across sessions.
pickle:
Serializes (pickles) an object into a byte stream, which can then be stored in a file or sent over a network. The object can later be deserialized (unpickled) to reconstruct the original object, including its nested structures. Pickling is used for persisting objects beyond the current session.

26.How does Python’s multiprocessing differ from threading?

multiprocessing spawns separate processes that have their own memory space, avoiding GIL issues. threading runs threads in the same memory space, but due to the GIL, only one thread can execute Python code at a time in CPython.

27.What are type hints in Python, and how are they used?

Type hints allow specifying expected data types for function arguments and return values, improving code clarity and enabling static type checking tools like mypy. They are defined using Python’s typing module.

28.How does functools.lru_cache work?

functools.lru_cache is a decorator that caches the results of expensive function calls, storing them in an in-memory cache with a size limit. It uses a Least Recently Used (LRU) eviction strategy when the cache exceeds the limit.

29.How does Python’s exception handling work internally?

When an exception occurs, Python looks up the stack for an exception handler (a try-except block). If no handler is found, the program terminates and prints a traceback.

30.Explain Python’s descriptor protocol

The descriptor protocol in Python is a mechanism that allows objects to customize the way their attributes are accessed. It involves the use of three special methods: __get__, __set__, and __delete__. These methods give you fine control over attribute access, modification, and deletion, providing flexibility for things like computed properties, lazy evaluation, validation, and more.

Key Methods of the Descriptor Protocol

__get__(self, instance, owner)
__set__(self, instance, value)
__delete__(self, instance)

31.Write a function to rotate an array by k elements.

Solution:

def rotate_array(arr, k): k = k % len(arr) # In case k is greater than the length of the array return arr[-k:] + arr[:-k] # Example usage: print(rotate_array([1, 2, 3, 4, 5], 2))

32.What are type hints in Python, and how are they used?

33.Given an array of integers from 1 to n with one number missing, find the missing number.

def find_missing_number(arr): n = len(arr) + 1 total_sum = n * (n + 1) // 2 return total_sum – sum(arr) # Example usage: print(find_missing_number([1, 2, 4, 5, 6]))

34.Write a function to find duplicates in an array.

Solution:

def find_duplicates(arr): seen = set() duplicates = set() for num in arr: if num in seen: duplicates.add(num) seen.add(num) return list(duplicates) # Example usage: print(find_duplicates([1, 2, 3, 4, 5, 1, 2, 3]))

35.Write a function to merge two sorted arrays into one sorted array.

Solution:

def merge_sorted(arr1, arr2): i = j = 0 merged = [] while i < len(arr1) and j < len(arr2): if arr1[i] < arr2[j]: merged.append(arr1[i]) i += 1 else: merged.append(arr2[j]) j += 1 merged.extend(arr1[i:]) merged.extend(arr2[j:]) return merged # Example usage: print(merge_sorted([1, 3, 5], [2, 4, 6])) 36.Write a function to find the first non-repeating character in a string. Solution: from collections import Counter def first_non_repeating_char(s): count = Counter(s) for char in s: if count[char] == 1: return char return None # Example usage: print(first_non_repeating_char("swiss")) 37.Write a function to check if two strings are anagrams of each other. Solution: def are_anagrams(s1, s2): return sorted(s1) == sorted(s2) # Example usage: print(are_anagrams("listen", "silent")) # Output: True print(are_anagrams("hello", "world"))

38.state the different types of python descriptors

Types of Descriptors:

Data Descriptor:
Implements both __get__ and __set__. It has priority over instance dictionaries.
Non-Data Descriptor:
Implements only __get__. If an instance variable is set directly, it will override the descriptor.

39.What are the key differences between deque, list, and queue.Queue in Python?

list:
A dynamic array that allows fast access to elements by index, but appending to the front (O(n)) is slower as it requires shifting elements.
deque (from collections):
A double-ended queue that allows appending and popping from both ends efficiently (O(1) for both append and pop operations). It is ideal when you need a queue-like structure with efficient operations at both ends.
queue.Queue:
Designed for thread-safe FIFO operations in multi-threading environments. It has built-in locking to ensure that operations from multiple threads don’t overlap. It has a slightly higher overhead due to this thread-safety feature.

41. How would you implement an LRU (Least Recently Used) cache in Python using collections?

Implement an LRU cache using collections.OrderedDict since it maintains the order of keys by insertion, and when a key is accessed, we can move it to the end.

from collections import OrderedDict class LRUCache: def __init__(self, capacity: int): self.capacity = capacity self.cache = OrderedDict() def get(self, key: int) -> int: if key not in self.cache: return -1 else: self.cache.move_to_end(key) return self.cache[key] def put(self, key: int, value: int) -> None: if key in self.cache: self.cache.move_to_end(key) self.cache[key] = value if len(self.cache) > self.capacity: self.cache.popitem(last=False)

In this code, move_to_end maintains the LRU order, and popitem(last=False) removes the oldest element when the cache exceeds its capacity.

42. What is a metaclass in Python, and how would you use it to enforce singleton behavior?

A metaclass in Python is a class of a class, which controls how classes are constructed. It allows modifying or influencing the creation and behavior of classes.

To enforce singleton behavior, a metaclass can be used to ensure only one instance of a class is created.

class SingletonMeta(type): _instances = {} def __call__(cls, *args, **kwargs): if cls not in cls._instances: instance = super().__call__(*args, **kwargs) cls._instances[cls] = instance return cls._instances[cls] class Singleton (metaclass=SingletonMeta): def __init__(self, value): self.value = value # Test a = Singleton(1) b = Singleton(2) print(a is b) print(a.value, b.value)

Here, __call__ in the metaclass ensures that only one instance of the class is created by checking if an instance already exists.

43. Explain the purpose and use cases of the missing method in Python’s collections.defaultdict. How can you override it?

The __missing__ method in Python is used by mapping types, like dict, to handle missing keys. It’s automatically called when trying to access a key that doesn’t exist in the dictionary. The collections.defaultdict class utilizes this method to insert a default value when accessing a missing key.

To override __missing__, you can subclass dict:

class MyDict(dict): def __missing__(self, key): print(f”{key} not found, returning default value.”) return -1 d = MyDict(a=1, b=2) print(d[‘a’]) print(d[‘c’])

In this example, when a missing key is accessed, __missing__ returns a default value of -1 and prints a message.

44. What is the purpose of the abc module in Python? How would you enforce an abstract method in a metaclass?

The abc (Abstract Base Classes) module provides a way to define abstract base classes. Abstract methods defined in an abstract base class must be implemented by any concrete subclass.

To enforce an abstract method in a metaclass, you can leverage abc.ABCMeta:

from abc import ABC, abstractmethod class AbstractClass(ABC): @abstractmethod def do_something(self): pass class ConcreteClass(AbstractClass): def do_something(self): print(“Doing something!”) c = ConcreteClass() a = AbstractClass()

In this example, ConcreteClass must implement do_something, or a TypeError will be raised if an attempt is made to instantiate it without doing so.

45. How would you implement a Singly Linked List in Python?

class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def append(self, data): new_node = Node(data) if not self.head: self.head = new_node return last_node = self.head while last_node.next: last_node = last_node.next last_node.next = new_node def display(self): current = self.head while current: print(current.data, end=” -> “) current = current.next print(“None”)

This code creates a basic singly linked list with append and display methods.

46. How would you reverse a linked list in Python?

def reverse_linked_list(head): prev = None current = head while current: next_node = current.next current.next = prev prev = current current = next_node return prev

This function takes the head of a linked list and reverses the pointers, returning the new head.

47. What is the time complexity of inserting an element at the head and at the tail in a singly linked list?

Inserting at the head: O(1) because you only need to update the head pointer. Inserting at the tail: O(n) if the list does not maintain a tail pointer (as you must traverse the list), but it can be O(1) if you maintain a reference to the tail.

48. How would you implement a thread-safe linked list in Python?

Use threading locks to ensure thread safety in linked lists.

import threading class ThreadSafeLinkedList: def __init__(self): self.head = None self.lock = threading.Lock() def append(self, data): with self.lock: new_node = Node(data) if not self.head: self.head = new_node return last_node = self.head while last_node.next: last_node = last_node.next last_node.next = new_node

49. Explain the Global Interpreter Lock (GIL) in Python and its impact on multithreading.

The Global Interpreter Lock (GIL) is a mutex in CPython that protects access to Python objects, ensuring that only one thread executes Python bytecode at a time. This means that even in a multithreaded environment, Python threads are not fully concurrent on multi-core systems due to GIL.
This limits the performance of CPU-bound multithreaded programs but doesn’t impact I/O-bound threads. To achieve true parallelism for CPU-bound tasks, it’s better to use multiprocessing instead of multithreading.

50. What are the differences between threading and multiprocessing in Python?

Threading:
Multiple threads share the same memory space, which makes it lightweight but vulnerable to issues like the GIL. Best suited for I/O-bound tasks.
Multiprocessing:
Each process runs in its own memory space, offering true parallelism by utilizing multiple CPU cores. Better for CPU-bound tasks but more memory-intensive than threading.

Request more information

Python interview questions with answers for advanced interview questions