Top 100 Python Interview Questions and Answers (2025)
Table of Contents
- Jaro Education
- 24, August 2025
- 11:00 am
Python still controls the technological market, being one of the most multifaceted and required programming languages. Whether you are getting ready to work on a technical interview or want to develop your coding skills, you must learn to master Python. Interviews are commonly challenged with solving projects and describing complicated features of using Python.
This guide offers an exhaustive list of the most typical and the most challenging Python interview questions. The regular practice of such questions will make sure that data professionals, developers, and software engineers have the necessary expertise to master the technical interviews and grow their career success.
Basic Python Interview Questions for Freshers
- What is Python’s __init__ method?
A special constructor method in a class that runs automatically when an object is created, used to initialize instance attributes. - What are Python decorators?
Functions (or callables) that take another function/method as input, extend or modify its behavior, and return it (or another function). - What is a lambda function?
An anonymous, single-line function defined using the lambda keyword. - Explain Python’s map() function.
Applies a given function to each item of an iterable and returns an iterator (map object). - What is filter() used for?
Selects elements from an iterable based on a condition and returns an iterator. - What is reduce()?
From functools, it applies a function cumulatively to items of an iterable to reduce it to a single value. - What is a Python module?
A .py file containing Python code (functions, classes, variables) that can be imported. - What is a package in Python?
A collection of modules organized in a directory with an optional __init__.py file. - What are *args and **kwargs?
*args passes a variable number of positional arguments; **kwargs passes a variable number of keyword arguments. - What are Python generators?
Functions that yield values one at a time using yield, producing data lazily instead of storing it in memory. - What is an iterator in Python?
An object with __iter__() and __next__() methods that returns items one at a time. - Difference between deepcopy and copy.
copy() creates a shallow copy (references nested objects); deepcopy() creates fully independent copies. - What is Python’s with statement?
Used with context managers to handle resource setup and cleanup automatically (e.g., file handling). - What are Python’s built-in data structures?
List, Tuple, Set, Dictionary, along with immutable types like frozenset, str, and binary types (bytes, bytearray). - What is Python’s frozenset?
An immutable, unordered collection of unique elements. - What is method overloading in Python?
Not supported natively; similar behavior is achieved using default arguments or variable arguments. - What is method overriding in Python?
Defining a method in a subclass with the same name as in the parent class, replacing its behavior. - Difference between classmethod, staticmethod, and instance method.
- Instance method: Default; takes self.
- Class method: Takes cls; defined with @classmethod.
- Static method: No automatic first argument; defined with @staticmethod.
- What is duck typing?
Type checking based on whether an object supports the required behavior, not its actual type or class. - What is Python’s zip() function?
Combines items from multiple iterables into tuples, stopping at the shortest iterable. - Difference between append() and extend().
append() adds a single element to the list; extend() adds elements from another iterable. - Difference between Python arrays and lists.
Arrays (from the array module) store elements of the same type; lists can store elements of mixed types and are more flexible. - What is Python’s globals() function?
Returns a dictionary of the current global symbol table. - What is Python’s locals() function?
Returns a dictionary of the current local symbol table. - What is dir() used for?
Lists valid attributes and methods for an object (including inherited ones).
Read Also : Top 25 Coding Interview Questions for You
Python Programming Interview Questions: Core Concepts
- What is a decorator?
A decorator is a function that accepts another function as an argument, wraps that function to add functionality, and returns the new, wrapped function. Essentially, it allows a function to be wrapped without actually changing the source code of the function.
- What is a generator?
A generator function will return an iterator. It uses yield instead of return, so it can produce a series of values over time. After it has produced a value, the generator function is paused until the next value is generated, so they are memory efficient.
- What is the Global Interpreter Lock (GIL)?
The Global Interpreter Lock (GIL) is a mutex that protects access to Python bytecodes in a single process. It is essentially a mutex that allows only one thread to hold at a time; the GIL is the reason Python is not considered excellent for CPU-bound parallel processing.
- How is memory managed in Python?
Memory management in Python occurs in a private heap. Python includes a built-in garbage collector that recycles all the unused memory to make it available for the heap storage area. In general, the garbage collector searches for unused memory to reclaim, mainly by reference counting, but it also has a cyclic garbage collector to deal with circular references.
- What are *args and **kwargs?
*args is used when a function accepts an unspecified number of non-keyworded arguments, and the value is assigned to `args`, which can be treated as a tuple.
**kwargs is used when a function accepts an unspecified number of keyworded arguments, and the values are assigned to `kwargs`, which can be treated as a dictionary.
- What is a lambda function?
A lambda function is a small, anonymous function defined with the lambda statement. It can have any number of arguments but can only have one expression. They are useful when you need a short, throwaway function without the overhead of naming it.
- Explain the difference between range() and xrange().
In Python 2, xrange() was a function that returned a generator. The most important feature of a generator is that they are memory efficient when calling large swathes of numbers; they will only store the last number in memory. In Python 3, range() was redesigned to be more like xrange() and therefore the full list of memory is never created; instead, a kind of iterator-like object is created, which is of better value.
- What is a docstring?
A docstring is a string literal that occurs as the first statement in a module, function, class, or method definition. It’s intended to be code documentation, accessed via the __doc__ attribute.
- What is the ‘self’ keyword?
The ‘self’ keyword is a convention referring to the instance of a class. Since the self is the first argument of any method in a class, it is how any method accesses the attributes and methods of the class instance.
- What is a class method and a static method?
Class methods are defined using the @classmethod decorator and take the class (cls) as the first argument. Static methods are defined using the @staticmethod decorator and do not have a first argument (self or cls). Static methods are regular functions that exist in the class’s namespace.
- What is monkey patching?
Monkey patching is a way to modify a class or a module at runtime. It is most frequently used to replace an existing object with a function, method, or attribute, and may make code difficult to debug.
- What is the ‘with’ statement?
The with statement is for context management. It handles most setup and teardown operations (for example, opening a file and closing a file), but will still handle those appropriately, even when an error occurs inside the block.
- What is a closure?
A closure is a function object that remembers values in enclosing lexical scopes, even if they are not present in memory. Closures are commonly used to create functions with specific, customized behaviors.
- What is the difference between a shallow copy and a deep copy?
A shallow copy creates a new object and then inserts references to the objects found in the original. A deep copy creates a new object and then recursively adds copies of nested objects found in the original.
- What are magic methods (dunder methods)?
Magic methods, often called dunder methods, are special methods in Python that are surrounded by double underscores on the left and right sides of the method name (i.e., __init__, __str__). Magic methods are used to define how your objects interact with built-in methods/operators.
- What is the difference between a module and a package?
A module is a single Python file (.py). A package is a directory containing multiple modules and an optional __init__.py file. Packages help to group related modules.
Read Also : Data Handling in Python: Optimise Your Python Skills in 2025
- How do you sort a dict by keys or values?
You cannot explicitly sort a dictionary, as it is unordered. Instead, you can convert the dictionary’s items to tuples and sort those tuples with the sorted function and an optional lambda function.
- Why do we write code like if __name__ == “__main__”?
This code is a common idiom that allows you to run a block of code only if the code is run directly. It will not run if the script is imported as a module in another file.
- What is a generator expression?
A generator expression is a simple way to create a generator object. It’s very similar to a list comprehension, but with a generator expression, you use () instead of [], so they are a more memory-efficient way of creating iterators that yield values.
- How does the zip() function work?
The zip() function takes multiple iterables and returns an iterator that aggregates elements from each of the iterables into tuples, with each tuple containing a new element from each of the input iterables at the same index.
- What is the difference between del and pop() on a list?
Del is a statement that deletes an item from a list at an index. Pop() is a built-in list method that removes and returns the item at an index.
- What is a frozenset?
A frozenset is an immutable version of a set. All of its values cannot change, which allows it to be used as a key in a dictionary or a value in another set.
- Explain Python’s map(), filter(), and reduce().
The map() function applies a specified function to each item in the given iterable. Filter () forms an iterator from elements for which the function returns True. Reduce () applies a function of two arguments cumulatively to the items of an iterable, from left to right, to reduce the iterable to a single value.
- What are type hints?
Type hints are a method for indicating what type a variable, function argument, or function return value is expected to be. Type hints are not enforced by the Python language at run-time but can be used by static analysis tools and IDEs to identify potential bugs.
- What is a deque?
A deque (double-ended queue) is a data structure in the collections module. It is a list-like container that allows for fast appends and pops from either end of the list. This also makes it a better overall choice than a typical list when implementing a queue or a stack.
Python Coding Interview Questions for Experienced Professionals
- Create a class that creates a Singleton object.
A Singleton is a design pattern that restricts the number of instances to just one of a class. You can achieve this by overriding the __new__ method.
cClassSingleton:
_instance = None
def __new__(cls, *args, **kwargs):
If not cls._instance:
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance
s1 = Singleton()
s2 = Singleton()
print(s1 is s2)
# True
- Write a function that flattens a list of lists.
Nesting is here to test your ability to understand recursive functions, as well as cumbersome data structures.
def flatten_list(nested_list):
flat_list = []
For item in nested_list:
if isinstance(item, list):
flat_list.extend(flatten_list(item))
Else:
flat_list.append(item)
return flat_list
nested = [1, [2, [3, 4]], 5]
print(flatten_list(nested))
# [1, 2, 3, 4, 5]
- Create your context manager using a class.
A custom context manager is usually used with the with statement to manage resources. A custom context manager simply requires that you implement the two methods __enter__ and __exit__ in that order.
Class FileHandler:
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
self.file = None
def __enter__(self):
self.file = open(self.filename, self.mode)
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
if self.file:
Self.file.close()
# Handle exceptions if needed
, return False
- Write a function that checks if two strings are anagrams.
An anagram of a word or phrase is formed by rearranging the letters of a word or phrase. The easiest, most efficient way to check if two strings are anagrams is to sort the characters in the string of each string and compare them.
def are_anagrams(s1, s2):
return sorted(s1) == sorted(s2)
print(are_anagrams(“listen”, “silent”))
# True
- Implement a caching decorator.
A caching decorator can store the results of expensive function calls so you don’t have to recompute for the same inputs.
def cache(func):
memo = {}
def wrapper(*args, **kwargs):
key = (args, tuple(sorted(kwargs.items())))
If key not in memo:
memo[key] = func(*args, **kwargs)
return memo[key]
return wrapper
@cache
def expensive_function(x, y):
print(“Computing…”)
return x + y
expensive_function(1, 2)
expensive_function(1, 2) # This call will be fast
- Write a function to get the first non-repeating character in a string.
This problem is about your use of data structures like dictionaries to hold counts.
def first_non_repeating_char(s):
char_counts = {}
For char in s:
char_counts[char] = char_counts.get(char, 0) + 1
For char in s:
if char_counts[char] == 1:
return char
return None
print(first_non_repeating_char(“aabbcdeff”))
# c
- How would you sort a list of dictionaries by a specific key?
You can use the sorted() function with a lambda key.
data = [
{‘name’: ‘Alice’, ‘age’: 30},
{‘name’: ‘Bob’, ‘age’: 25},
{‘name’: ‘Charlie’, ‘age’: 35}
]
sorted_by_age = sorted(data, key=lambda x: x[‘age’])
print(sorted_by_age)
# [{‘name’: ‘Bob’, ‘age’: 25}, {‘name’: ‘Alice’, ‘age’: 30}, {‘name’: ‘Charlie’, ‘age’: 35}]
- Write a function that counts the number of times each word in a text appears.
The collections. Counter class is very convenient for this purpose.From collections import Counter
def word_frequency(text):
words = text.lower().split()
return Counter(words)
text = “Hello world, hello Python, hello world.”
print(word_frequency(text))
# Counter({‘hello’: 3, ‘world,’: 2, ‘python,’: 1})
- Implement a debounce decorator.
A debounce decorator delays the execution of a function until after a certain amount of time has passed since the last invocation of that function.
import time
def debounce(wait_time):
def decorator(func):
last_called = {‘time’: 0}
def wrapper(*args, **kwargs):
If time.time() – last_called[‘time’] > wait_time:
last_called[‘time’] = time.time()
return func(*args, **kwargs)
return wrapper
return decorator
- Write a function that takes two sorted lists and returns a single sorted list.
This is a common interview question about your ability to maintain pointers or indices.
def merge_sorted_lists(l1, l2):
merged = []
i, j = 0, 0
while i < len(l1) and j < len(l2):
if l1[i] < l2[j]:
merged.append(l1[i])
i += 1
Else:
merged.append(l2[j])
j += 1
merged.extend(l1[i:])
merged.extend(l2[j:])
return merged
list1 = [1, 3, 5]
list2 = [2, 4, 6]
print(merge_sorted_lists(list1, list2))
# [1, 2, 3, 4, 5, 6]
- How would you implement a simple LRU (Least Recently Used) cache?
An LRU cache evicts the least recently used item when it reaches its full capacity. You can use an OrderedDict to implement this.
from collections import OrderedDict
class LRUCache(OrderedDict):
def __init__(self, capacity):
super().__init__()
self.capacity = capacity
def get(self, key):
if key not in self:
return -1
self.move_to_end(key)
return self[key]
def put(self, key, value):
if key in self:
self.move_to_end(key)
self[key] = value
if len(self) > self.capacity:
self.popitem(last=False)
- How would you implement a simple LRU (Least Recently Used) cache?
An LRU cache evicts the least recently used item when the cache reaches its capacity. You can use an OrderedDict for this.
from collections import OrderedDict
class LRUCache(OrderedDict):
def __init__(self, capacity):
super().__init__()
self.capacity = capacity
def get(self, key):
if key not in self:
return -1
self.move_to_end(key)
return self[key]
def put(self, key, value):
if key in self:
self.move_to_end(key)
self[key] = value
if len(self) > self.capacity:
self.popitem(last=False)
- Write a function to find all pairs in a list that sum up to a given target.
This problem can be solved efficiently using a hash set.
def find_pairs(nums, target):
seen = set()
pairs = []
For num in nums:
Complement = target – num
If a complement is seen:
pairs.append((num, complement))
seen.add(num)
return pairs
nums = [1, 2, 3, 4, 5]
target = 7
print(find_pairs(nums, target))
# [(4, 3), (5, 2)]
- How do you implement an iterator for a custom class?
To make a class iterable, you need to define the __iter__ and __next__ methods.
Class MyRange:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.current >= self.end:
raise StopIteration
current_value = self.current
self.current += 1
return current_value
for num in MyRange(1, 5):
print(num)
# 1, 2, 3, 4
- Write a function that finds the longest common prefix among a list of strings.
This problem tests your string manipulation skills and logical thinking.
def longest_common_prefix(strs):
if not strs:
return “”
prefix = strs[0]
for s in strs[1:]:
while not s.startswith(prefix):
prefix = prefix[:-1]
If not prefix:
return “”
return prefix
print(longest_common_prefix([“flower”, “flow”, “flight”]))
# “fl”
- How would you check for a cycle in a linked list?
This is a classic algorithm question. The “tortoise and hare” or Floyd’s cycle-finding algorithm is a common solution.
Class Node:
def __init__(self, value, next=None):
self.value = value
self.next = next
def has_cycle(head):
slow = head
fast = head
While fast and fast. next:
Sloww = slow.next
fast = fast.next.next
if slow == fast:
return True
return False
- Write a function to check if a binary tree is symmetric.
This requires a recursive helper function to compare the left and right subtrees.
Python
def is_symmetric(root):
def is_mirror(t1, t2):
if not t1 and not t2:
return True
if not t1 or not t2:
return False
return (t1.val == t2.val and
is_mirror(t1.right, t2.left) and
is_mirror(t1.left, t2.right))
return is_mirror(root, root)
- Implement a function to find the nth Fibonacci number.
A common approach is memoization (caching) to avoid re-computing values.
Python
memo = {}
def fibonacci(n):
if n in memo:
return memo[n]
if n <= 1:
return n
memo[n] = fibonacci(n – 1) + fibonacci(n – 2)
return memo[n]
- Write a function that converts an integer to a Roman numeral.
This tests your ability to handle data mapping and greedy algorithms.
Python
def int_to_roman(num):
val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
syb = [“M”, “CM”, “D”, “CD”, “C”, “XC”, “L”, “XL”, “X”, “IX”, “V”, “IV”, “I”]
roman_num = ”
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
- How would you implement a simple rate-limiter?
A rate-limiter restricts the number of times a function can be called in a given period.
Python
import time
class RateLimiter:
def __init__(self, max_calls, period):
self.max_calls = max_calls
self.period = period
self.calls = []
def allow_call(self):
now = time.time()
self.calls = [c for c in self. calls if now – c < self.period]
if len(self.calls) < self.max_calls:
self .calls.append(now)
return True
return False
- Implement a function to find the maximum subarray sum.
This is a classic dynamic programming problem known as Kadane’s algorithm.
Python
def max_subarray_sum(nums):
current_max = global_max = nums[0]
for num in nums[1:]:
current_max = max(num, current_max + num)
if current_max > global_max:
global_max = current_max
return global_max
- Write a function to check if a binary search tree is valid.
This requires a recursive traversal, ensuring that a node’s value is greater than all values in its left subtree and less than all values in its right subtree.
Python
def is_valid_bst(root):
def validate(node, low=-float(‘inf’), high=float(‘inf’)):
if not node:
return True
if not (low < node.val < high):
return False
return (validate(node.left, low, node.val) and
validate(node.right, node.val, high))
return validate(root)
- Implement a function to check for balanced parentheses.
A stack is the ideal data structure for this problem.
Python
def is_balanced_parentheses(s):
stack = []
mapping = {“)”: “(“, “}”: “{“, “]”: “[“}
For char in s:
if char in mapping.values():
stack.append(char)
Elif char in mapping.keys():
if not stack or mapping[char] != stack.pop():
return False
Else:
# Ignore other characters
pass
return not stack
- Write a function that finds the longest substring without repeating characters.
This problem can be solved using a sliding window approach with a dictionary to keep track of seen characters.
Python
def length_of_longest_substring(s):
seen = {}
max_len = 0
start = 0
For end, char in enumerate(s):
if char in seen and seen[char] >= start:
start = seen[char] + 1
Else:
max_len = max(max_len, end – start + 1)
seen[char] = end
return max_len
- Implement a function to search for a target value in a rotated sorted array.
This is a variation of binary search where you must first find the pivot point (the rotation point) or adapt the binary search to handle the rotation.
Python
def search_rotated_array(nums, target):
low, high = 0, len(nums) – 1
while low <= high:
mid = (low + high) // 2
if nums[mid] == target:
return mid
if nums[low] <= nums[mid]:
if nums[low] <= target < nums[mid]:
high = mid – 1
Else:
low = mid + 1
Else:
if nums[mid] < target <= nums[high]:
low = mid + 1
Else:
high = mid – 1
return -1
- Write a function to check if a Sudoku board is valid.
This tests your ability to handle grid-based problems and use sets to track unique numbers in rows, columns, and 3×3 sub-grids.
Python
def is_valid_sudoku(board):
rows = [set() for _ in range(9)]
cols = [set() for _ in range(9)]
boxes = [set() for _ in range(9)]
for r in range(9):
for c in range(9):
val = board[r][c]
if val == ‘.’:
continue
box_index = (r // 3) * 3 + (c // 3)
if val in rows[r] or val in cols[c] or val in boxes[box_index]:
return False
rows[r].add(val)
cols[c].add(val)
boxes[box_index].add(val)
Advanced Python Interview Questions for Experienced Developers
- What are shallow copy and deep copy?
Shallow copy refers to creating a new object and inserting references to the original object’s elements. If the immutable original object has mutable objects in it and you change the mutable objects, the original and shallow copy will be affected. Deep copy refers to creating a new object entirely independent from the original object and recursively copying its elements, so if you change the original object, you are not affecting the deep copy. To create either a shallow copy or a deep copy is easy, and you can use the copy module.
- What does __slots__ do?
__slots__ is a special class attribute that allows you to define a predetermined set of attributes. The definition of __slots__ prevents the construction of a __dict__ for each instance. When there is no __dict__, the amount of memory used is generally much lower than when there is a __dict__, and therefore is an attractive option for an application that will require millions of instances, where the memory savings may be considerable. __slots__ also prevent the addition of additional attributes from the class following construction.
- When would you use __new__ instead of __init__?
__new__ is the creator of the instance and is called before __init__. __init__ initializes the instance. You would generally override __new__ when you want to implement a singleton pattern or create a subclass of an immutable type, such as str or tuple.
- What is a metaclass?
A metaclass is a “class of a class.” It is a class for classes. By default, in Python, all classes are created using type as the metaclass. Metaclasses are typically used for advanced features like adding methods automatically or validating the contents of a class when the class is created.
Read Also : Essential Python Developer Skills for 2025
- How does Python’s asyncio work?
The asyncio module provides a framework for writing asynchronous code with a single-threaded event loop, so a program can perform multiple I/O operations concurrently and without blocking. It does so with coroutines – functions that can be “suspended” to wait for I/O to be available and “resumed” to allow other things to run while they are waiting.
- What is the difference between multithreading and multiprocessing?
Multithreading is the use of multiple threads in a single process, but due to the Global Interpreter Lock (GIL), threads in Python are not parallel for CPU-bound tasks. Multiprocessing executes multiple processes, where each process has its own separate memory and interpreter, which means they can execute code truly in parallel on a multi-core processor.
- How do you create a custom context manager?
Context managers are created by defining a class with methods named __enter__ and __exit__. __enter__ creates the resource and returns it, while __exit__ cleans up the resource. The __exit__ method is guaranteed to run even if an exception is thrown in the with block.
- What is the difference between __str__ and __repr__?
__str__ gives a string representation of a human-readable object, usually for the end user’s behalf (e.g., used with print()). __repr__ gives a string representation of a developer-readable object, which ideally would create an object if passed to eval().
- What is a deque, and when do you use it?
A deque (double-ended queue) is a data structure from the collections module. A deque has all of the functionality of a list (there is no insertion point), but is implemented in a way that allows for fast appends and pops from both ends. You would use a deque over a list for a queue or stack when performance is of the utmost importance.
- How do you serialize and deserialize a Python object?
You can serialize an object (convert it to a byte stream) with the pickle module’s pickle.dump() function. To deserialize it (convert it back to an object), you use pickle.load(). The JSON module is used for the same process, but for data types that can be represented in JSON.
- What is the super() function?
The super() function is used to call a method from a parent class. It is especially important for multiple inheritances since it follows the Method Resolution Order (MRO), so you can call it the proper parent method. Super() will also allow all parent classes to be correctly initiated.
- What is a classmethod vs a staticmethod?
A class method is a function that takes in the class (cls) as the first argument so that you can modify the state of the class. A static method is a method that belongs to a class but provides no access to the class or instance. It is not different from a function stored inside a class’s namespace.
- How does Python handle memory management?
Python’s memory management is handled by a private heap. It uses reference counting to track object usage and automatically deallocates objects when their reference count drops to zero. A cyclic garbage collector is also in place to clean up objects with circular references that reference counting cannot handle.
- Explain the difference between yield and return.
Return sends a value back to the caller and terminates the function’s execution. Yield, used in a generator, sends a value back but pauses the function’s execution, saving its state. When the generator is called again, it resumes from where it left off.
- What are __slots__ used for?
__slots__ is a special class attribute used to save memory. By explicitly declaring all of the object’s attributes, Python does not create a __dict__ for each instance, which can be a significant memory saver for programs that create a large number of objects.
- What is the zip() function?
The zip() function takes one or more iterables and returns an iterator of tuples, where each tuple contains elements from the input iterables at the same index. It is often used to iterate through multiple lists in parallel.
Read Also : Top 20 Python Project Ideas with Source Code in 2025
- How can you merge two dictionaries?
The most modern way is to use the **unpacking operator** (in Python 3.5+). This is clean and concise.
Python
dict1 = {‘a: 1, ‘b’: 2}
dict2 = {‘c’: 3, ‘d: 4}
merged_dict = {**dict1, **dict2}
- What is a generator expression?
A generator expression is a lazy version of a list comprehension, defined using parentheses (). It returns a generator object that yields values one by one, making it very memory-efficient for large datasets.
Python
gen_exp = (x**2 for x in range(1000))
- How do you implement a simple rate limiter in Python?
A rate limiter can be implemented using a decorator that tracks the time of the last function call and uses a delay or an exception to enforce a rate limit. This is often done using the time module.
- What is a classmethod?
A class method is a method that is bound to the class rather than the instance of the class. It is declared using the @classmethod decorator, which takes the class itself as its first argument, typically called cls. This is useful for factory methods, which create instances in a specific way.
- Explain duck typing.
Duck typing means that instead of the object type, its suitability is determined by the methods and properties an object has. The phrase “If it walks like a duck and it quacks like a duck, then it must be a duck” captures the idea nicely. This feature is one of the key characteristics of Python being a dynamic language.
- What is the difference between list.sort() and sorted()?
List.sort() is a method that sorts the list in-place and returns None. Sorted() is a built-in function that takes any iterable, creates a new sorted list, and leaves the original iterable unchanged.
- What is a metaclass?
A metaclass is a class whose instances are classes. It allows you to have control over how classes are defined. You can intercept the class definition and modify it before it is defined. This can be a very advanced topic that is typically used in frameworks.
- How can you implement a custom iterator?
To make a class an iterator, the class must implement __iter__() and __next__(). The __iter__() method should return the iterator object itself, and __next__() should return the next item in the sequence. When there are no more items to return, __next__() must raise StopIteration.
- What is the purpose of the __new__ method?
The __new__ method is responsible for creating an instance of a class. __new__ runs before __init__ and is a static method. It is an important part of the object creation process, especially for immutable types and design patterns like the Singleton.
Conclusion
To be successful in 2025, it is extremely important to prepare for Python interview questions. A beginner needs to concentrate on Python interview questions for beginners and Python interview questions for first-timers, whereas a professional needs to practise Python programming interview questions, Python interview questions for the experienced, and Python coding interview questions. Practice sessions will increase confidence and eventually make you pass any Python interview.
Frequently Asked Questions
Trending Blogs
