Top 50 Python Interview Questions with Answers (2026): Fresher to Python Expert

Python does not have explicit, C-style pointers. Instead, variables act as References (or labels) pointing to objects stored in the memory heap. You can check the memory address of an object using the built-in id() function, but you cannot perform arithmetic on these addresses.

Python uses Pass-by-Object-Reference (sometimes called Pass-by-Assignment). If you pass a mutable object (like a list or dict) to a function, modifying it in place alters the original object. If you reassign the variable name inside the function, the outer scope is unaffected — you've only rebound the local name.

• Mutable: The object's internal state can be changed after creation — e.g., list, dict, set.
• Immutable: The object's state cannot be changed. Any “modification” creates a completely new object in memory — e.g., int, float, str, tuple.

Despite the name, a Python list is not a Linked List. It is implemented in CPython as a Dynamic Array of pointers. The array holds references to the actual objects stored elsewhere in memory.

• ==: Checks for Value Equality — do these two objects contain the same data?
• is: Checks for Identity / Memory Equality — do these two variables point to the exact same physical object in memory?

• Shallow Copy (list.copy()): Creates a new list object, but inserts references to the same child objects. Modifying a nested list affects both copies.
• Deep Copy (copy.deepcopy()): Creates a new object and recursively creates actual copies of all nested objects. Fully independent.

• Iterator: An object that implements __iter__() and __next__(), storing its full state in memory.
• Generator: A special type of iterator created using a function with the yield keyword. It lazily generates values one at a time, using virtually zero memory.

• append(): O(1) amortized — adds to the end of the dynamic array.
• insert(0, val): O(n) — every single element in the dynamic array must be shifted one space to the right in memory.

List Comprehension is a concise, highly optimized syntactic construct for creating a new list based on the values of an existing iterable.

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

Python uses two mechanisms: Reference Counting (when an object's reference count drops to 0, it is immediately freed) combined with a Generational Garbage Collector to detect and clean up cyclic references (e.g., Node A points to Node B, and Node B points back to Node A).

A Python dictionary is implemented as a Hash Table. It hashes the key to compute an index into a sparse array of slots. As of Python 3.7+, dictionaries officially maintain their insertion order. Search, insertion, and deletion are all O(1) on average.

A Hash Collision occurs when two different keys generate the exact same hash value. Python resolves this using Open Addressing with random probing — searching for the next available empty slot in the memory array.

A defaultdict is a subclass of the standard dictionary. If you access or modify a key that does not exist, it automatically creates the key and assigns it a default value (e.g., 0 for int, or [] for list), preventing KeyError exceptions.

Counter is a specialized dictionary designed for counting hashable objects. It instantly creates a frequency map.

from collections import Counter
freq = Counter("abracadabra")  # {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

A deque (Double-Ended Queue) is implemented in Python as a doubly linked list of fixed-size blocks. It provides blazing-fast O(1) appends and pops from both ends: append, appendleft, pop, popleft.

A NamedTuple is a subclass of tuples that allows you to access elements by name (like an object property) instead of just an integer index, while maintaining the immutability and memory efficiency of a standard tuple.

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

Python allows multiple assignment, meaning you can update all three pointers in a single elegant line without needing a temporary variable.

curr.next, prev, curr = prev, curr, curr.next

Use a standard Python list. Because lists are dynamic arrays, adding to the end (append()) and removing from the end (pop()) are both O(1) operations, perfectly simulating LIFO behavior.

stack = []
stack.append(1)   # push  → O(1)
val = stack.pop() # pop   → O(1)

A Monotonic Stack is a stack whose elements are kept in strictly increasing or strictly decreasing order. When a new element breaks the order, elements are popped until the invariant is satisfied again. The algorithm processes each element at most twice — once pushed, once popped — giving O(n) overall.

Use Floyd's Tortoise and Hare Algorithm. Create a slow pointer (moves 1 step) and a fast pointer (moves 2 steps). If slow == fast at any point, a cycle exists. If fast reaches None, no cycle exists. Time complexity: O(n). Space: O(1).

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

A BST is a binary tree where the left child's value is always less than the parent's, and the right child's value is always greater. This structure guarantees O(log n) search, insert, and delete on a balanced tree.

Import deque from collections. Append the root to the deque. While the deque is not empty, popleft() the current node, process it, and append its left and right children.

from collections import deque

def level_order(root):
    if not root:
        return []
    queue, result = deque([root]), []
    while queue:
        node = queue.popleft()
        result.append(node.val)
        if node.left:  queue.append(node.left)
        if node.right: queue.append(node.right)
    return result

DFS is implemented recursively using the Python call stack:

• Inorder (Left → Root → Right): Returns BST nodes in sorted order.
• Preorder (Root → Left → Right): Used for copying a tree.
• Postorder (Left → Right → Root): Used for deleting a tree from the bottom up.

A Trie is a tree where each node represents a character. A Python Trie node typically contains a boolean is_end_of_word and a dictionary children = mapping characters to child nodes. Insert and search run in O(L) where L is the word length.

A Heap is a specialized complete binary tree implemented as a flat array. It supports O(1) access to the min (or max) element, with insertions and deletions in O(log n) time.

The heapq module provides functions to use a standard Python list as a heap. By default, heapq only implements a Min-Heap.

import heapq

h = [3, 1, 4, 1, 5]
heapq.heapify(h)          # O(n) → transforms list in-place
heapq.heappush(h, 2)      # O(log n) → insert
smallest = heapq.heappop(h)  # O(log n) → remove & return min

Because heapq only supports Min-Heaps, the standard Pythonic trick is to negate all values before pushing, and negate again when popping.

import heapq

max_heap = []
heapq.heappush(max_heap, -5)   # negate before push
heapq.heappush(max_heap, -1)
heapq.heappush(max_heap, -8)
largest = -heapq.heappop(max_heap)  # negate on pop → 8

Using an Adjacency List built with defaultdict(list) — O(V + E) space, far more memory-efficient than a 2D matrix for sparse graphs.

from collections import defaultdict

adj = defaultdict(list)
adj['A'].append('B')
adj['A'].append('C')

Create a visited = set() to track seen nodes and prevent infinite loops. Use a recursive helper to visit a node, add it to visited, and recursively call DFS on all unvisited neighbors.

def dfs(node, adj, visited):
    visited.add(node)
    for neighbor in adj[node]:
        if neighbor not in visited:
            dfs(neighbor, adj, visited)

visited = set()
dfs('A', adj, visited)

Create a visited = set() and a queue = deque([start_node]). Add start_node to visited. While the queue is not empty, popleft() the node, process it, and enqueue all unvisited neighbors.

from collections import deque

def bfs(start, adj):
    visited = {start}
    queue = deque([start])
    while queue:
        node = queue.popleft()
        for neighbor in adj[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

Dijkstra's uses a Min-Heap (heapq) storing (distance, node) tuples. Initialize all distances to infinity, set the source to 0, and push it. Repeatedly pop the minimum-distance node, and relax its edges.

import heapq

def dijkstra(graph, src):
    dist = {node: float('inf') for node in graph}
    dist[src] = 0
    heap = [(0, src)]  # (distance, node)
    while heap:
        d, u = heapq.heappop(heap)
        if d > dist[u]:
            continue  # stale entry
        for v, w in graph[u]:
            if dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
                heapq.heappush(heap, (dist[v], v))
    return dist

Time complexity: O((V + E) log V)

Union-Find is a data structure using a parent dictionary to track elements partitioned into disjoint subsets. It uses find() with path compression and union() by rank to merge sets in near O(1) amortized time.

A Topological Sort is a linear ordering of vertices in a Directed Acyclic Graph (DAG). If there is an edge U → V, node U must appear before node V in the output. It can be implemented via DFS (add to result on finish) or Kahn's Algorithm (BFS with in-degree tracking).

DP breaks a complex problem down into simpler, overlapping subproblems. It stores the results in a data structure (dict or array) to avoid calculating the exact same recursive state twice. This converts exponential O(2ⁿ) naive recursion into polynomial O(n) solutions.

Memoization is the “Top-Down” implementation of DP. You pass a dictionary memo = {} into a recursive function. Before computing, check if state in memo; if so, return the cached value instantly.

def fib(n, memo={}):
    if n <= 1:
        return n
    if n in memo:
        return memo[n]
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]

Python 3.9+ includes @functools.cache (and @functools.lru_cache). Placing this decorator above a recursive function causes Python to automatically memoize inputs and outputs, eliminating the need to write a manual memo dictionary.

from functools import cache

@cache
def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

Sliding Window creates a “window” using two pointers (left and right) over a list or string. Expand the right boundary to process new elements, and shrink the left boundary when a constraint is violated. Achieves O(n) instead of O(n²).

Two-Pointers uses two indices (usually left = 0 and right = len(arr) - 1) traversing an array simultaneously. Used on sorted arrays to find pairs that sum to a target in O(n) instead of O(n²).

Backtracking follows the pattern: Choose → Explore → Undo. Append a choice to the path, recurse, then path.pop() to undo and try the next option.

def backtrack(path, remaining):
    if not remaining:
        results.append(path[:])  # snapshot
        return
    for choice in remaining:
        path.append(choice)      # Choose
        backtrack(path, ...)     # Explore
        path.pop()               # Undo

# Sort by value, descending
sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1], reverse=True))

Leverage the bitwise XOR operator (^). Because X ^ X = 0, XORing all numbers in the array with all numbers 1–N will cancel out duplicates, leaving only the missing number. Runs in O(n) time, O(1) space.

# Find the missing number in [0..n]
def missing(nums):
    xor = len(nums)
    for i, v in enumerate(nums):
        xor ^= i ^ v
    return xor

Use Python's slicing syntax with a negative step:

reversed_string = my_string[::-1]
reversed_list   = my_list[::-1]

• any(iterable): Returns True if at least one element evaluates to True.
• all(iterable): Returns True only if every element evaluates to True.

any([False, False, True])  # True
all([True, True, False])   # False

enumerate() adds an automated counter to an iterable, allowing you to get both the index and the value simultaneously without managing a manual i += 1 counter.

for index, val in enumerate(my_list):
    print(index, val)

zip() takes two or more iterables and aggregates them into tuples, pairing elements at the same index together.

a = [1, 2, 3]
b = ['x', 'y', 'z']
list(zip(a, b))  # [(1, 'x'), (2, 'y'), (3, 'z')]

Exactly O(1). Python objects store their length as an internal C-struct property. It does not iterate through the array to count elements.

The GIL is a mutex in CPython that allows only one thread to execute Python bytecode at a time, even on multi-core processors. Standard Python multithreading is therefore ineffective for CPU-bound DSA tasks. To achieve true parallelism, use the multiprocessing module.

While Python's interpreter makes raw execution slower, its clean syntax, built-in dynamic arrays, and massive standard library (collections, itertools, heapq) allow developers to write complex algorithms in half the time and lines of code compared to C++ or Java. Developer time is often more expensive than CPU time.