Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Tech Mahindra · Python
Practice Python questions specifically asked in Tech Mahindra interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
38
Tagged for this company + subject
Company
Tech Mahindra
View company-wise questions
Subject
Python
Explore topic-wise practice
Go through each question and its explanation. Use this page for targeted revision just before your Tech Mahindra Python round.
The pass statement is a placeholder that performs no action. It is used where syntactically a statement is required but no operation is needed yet. Developers often use it while writing skeleton code for functions, loops, or classes, to avoid syntax errors before logic is implemented.
def temp(): pass
For complete preparation, combine this company + subject page with full company-wise practice and subject-wise practice. You can also explore other companies and topics from the links below.
A traceback is the recorded path of function calls that led to an exception. It shows the file, line numbers, and frames, ending at the point of failure. Reading it reveals both the symptom and the path that produced it. In logs, include exception info and context. Capture variables that explain inputs, but avoid leaking secrets. Use logging.exception inside an except block so the traceback is included automatically.
import logging
try:
risky()
except Exception:
logging.exception('risky failed with inputs=%s', args)The plus operator creates a new list by combining two existing lists. It does not modify the originals but returns a fresh list containing all elements from both. If you use the extend method instead, it adds items of the second list into the first list in place. append adds the entire list as a single element, which is different from concatenation.
a=[1,2,3]; b=[4,5]; res=a+b
The floor function from Python’s math module returns the greatest integer less than or equal to a number. It simply drops the fractional part and rounds down. For example, the floor of three point seven is three, while the ceil function would give four. It is commonly used when converting float values to integer boundaries in numeric programs.
import math math.floor(3.7)
Indentation is mandatory in Python because it defines the structure of code blocks. Instead of braces or keywords, Python uses indentation level to determine which statements belong together. This rule improves readability but also enforces strict consistency. Incorrect indentation leads to an Indentation Error during execution.
if True:
print('Yes')The *args parameter allows a function to receive any number of positional arguments as a tuple. It provides flexibility when you don’t know how many inputs will be passed. The **kwargs parameter collects keyword arguments into a dictionary, letting you handle named parameters dynamically. Together they make Python functions highly extensible and are often used in wrappers and decorators.
def demo(*a, **b): print(a,b)
Derive custom errors from Exception, not from BaseException. BaseException is reserved for core control flow like SystemExit. Having a single AppError base lets you catch all app-specific failures in one place when needed.
class AppError(Exception):
pass
class ConfigError(AppError):
passDictionaries preserve insertion order as a language guarantee from Python 3.7 onward. Keys come out in the same order you inserted them. This makes dicts suitable for tasks where relative order matters without needing OrderedDict for most cases.
d = {}
d['a']=1; d['c']=3; d['b']=2
print(list(d.keys())) # ['a','c','b']A stack uses list append and pop for LIFO; both are O(1) average at the right end. It is ideal for undo, parsing, and depth-first search where last-in comes out first. A queue should use collections.deque for FIFO; append at the right and popleft at the left are O(1). Lists are inefficient for popleft because shifting is O(n). Use queues for breadth-first search, task scheduling, and producer consumer pipelines.
# stack stack=[]; stack.append(1); stack.append(2); stack.pop() # queue rom collections import deque q=deque([1,2]); q.append(3); q.popleft()
The with statement uses a context manager. It ensures setup and teardown happen reliably. The file handle is closed even when exceptions are raised. This reduces resource leaks and keeps code short compared to try and finally patterns.
with open('data.txt', 'r', encoding='utf-8') as f:
for line in f:
process(line)__repr__ should ideally return a string that could recreate the object or be precise for debugging. __str__ returns a user-friendly display. If only __repr__ is defined, print will fall back to it. Good object printing improves debuggability.
class P:
def __init__(self,x): self.x=x
def __repr__(self): return f'P(x={self.x})'
def __str__(self): return f'Point {self.x}'An Abstract Base Class defines a formal interface by declaring abstract methods that subclasses must implement. It prevents instantiation until required methods are provided and communicates intent clearly to readers and tools. Use ABCs when many implementations must share a contract, such as storage backends or payment gateways. They improve consistency, enable static checks, and reduce runtime surprises.
from abc import ABC, abstractmethod
class Store(ABC):
@abstractmethod
def save(self, item): ...
class DB(Store):
def save(self, item): passThe csv module expects newline empty string to manage newlines correctly on Windows. Without it, you can get extra blank rows. This setting lets the csv writer handle line endings consistently across platforms.
import csv
with open('out.csv','w',newline='',encoding='utf-8') as f:
w=csv.writer(f)
w.writerow(['id','name'])__init__.py runs on package import. You can import and re-export symbols there to present a clean interface. In modern Python, implicit namespace packages can work without it, but __init__.py still helps for explicit control and side effects.
# mypkg/__init__.py from .core import run __all__=['run']
Provide a tuple of exception classes in one except clause. Python checks the raised error against any of the types in the tuple. This keeps handlers concise when the recovery action is identical for several related exceptions.
try:
risky()
except (KeyError, IndexError):
recover()suppress catches the listed exception types inside a with block and ignores them. Code continues after the block without raising. Use it for harmless, expected failures like best-effort cleanups. Avoid hiding real bugs by suppressing too broadly.
from contextlib import suppress
with suppress(FileNotFoundError):
os.remove('tmp.txt')An iterator needs dunder iter that returns self and dunder next that yields the next value or raises StopIteration. You do not need inheritance or a generator; any object with these methods is an iterator.
class Count:
def __init__(self,n): self.i=0; self.n=n
def __iter__(self): return self
def __next__(self):
if self.i>=self.n: raise StopIteration
self.i+=1; return self.ipartial binds fixed positional or keyword arguments and returns a new callable with a smaller signature. This simplifies callbacks and adapters. It is handy with map, event handlers, or when passing configuration into a function without lambdas.
from functools import partial pow2 = partial(pow, 2) print(pow2(10)) # 1024
Use async for high-concurrency I O like sockets, HTTP calls, or databases with async drivers. The event loop schedules tasks that yield at await points, so many operations overlap without threads. Pitfalls include calling blocking functions inside async code, which stalls the loop. Use run in executor or an async variant. Also ensure you await tasks or gather them; otherwise work may never run or errors may be lost.
import asyncio, aiohttp
async def fetch(url):
async with aiohttp.ClientSession() as s:
async with s.get(url) as r:
return await r.text()
asyncio.run(fetch('https://example.com'))Lists are mutable and can be changed in place. Tuples are immutable and cannot be changed after creation. Understanding mutability is key to safe copying, hashing, and function argument behavior.
lst=[1,2]; lst.append(3) tup=(1,2) # cannot append
bytes is immutable. bytearray is mutable and lets you edit binary data without creating new objects. For zero-copy slicing of existing buffers, wrap with memoryview to avoid extra allocations.
buf = bytearray(b'ABC') buf[0]=97 # a
Start with measurement, not guesses. Use cProfile to collect function level timings and inspect results with pstats or snakeviz. Focus on the few functions that dominate total time, often called the vital few. Apply targeted fixes: reduce algorithmic complexity, move heavy loops out of Python into vectorized libraries, or cache pure results. Re-measure after each change to confirm real wins and to avoid regressions.
import cProfile, pstats
cProfile.run('main()', 'prof')
p=pstats.Stats('prof'); p.sort_stats('tottime').print_stats(20)del only deletes a name binding. If other references still exist, the object stays alive. When the last reference goes away, CPython frees it, or the cycle collector reclaims it later if part of a cycle. To diagnose leaks, track object counts over time with tracemalloc or objgraph like tools. Look for growing containers, cache keys that never expire, or reference cycles involving long lived objects.
import tracemalloc tracemalloc.start() # run workload print(tracemalloc.get_traced_memory())
Chained indexing can operate on a view and silently skip updates. Use .loc with a boolean mask to target rows and columns unambiguously. This produces predictable writes and keeps your code clear and safe.
m = df['a']>0 df.loc[m, 'b'] = 1
By default, requests may block indefinitely. Always pass a timeout as a tuple or number to bound connect and read waits. This prevents hung workers and improves reliability in production services.
import requests r = requests.get(url, timeout=(3.05, 10))
Raw strings treat backslashes as literal characters so regex escapes remain intact. This avoids accidental Python escape sequences. It improves readability and prevents common mistakes like using "\n" when you meant backslash and n.
pattern = re.compile(r'\d{4}-\d{2}-\d{2}')Named groups label captured parts, so your code reads by meaning rather than index numbers. This reduces off-by-one errors and makes future edits safer. You can access groups by name in match dictionaries, which is clearer for complex patterns such as dates, ids, or log lines.
m=re.search(r'(?P<yyyy>\d{4})-(?P<mm>\d{2})-(?P<dd>\d{2})', s)
year=m.group('yyyy')bisect_left returns the first index where the value can be inserted to keep order. It is the usual tool for lower bound queries. bisect_right returns the insertion point after any existing equal items.
from bisect import bisect_left idx = bisect_left([1,2,2,3], 2) # 1
With two pointers, place one at the left and one at the right. If the sum is too small, move left forward; if too big, move right backward. This finds a pair in linear time and constant extra space on sorted data. The hash map method also runs in linear time without sorting, but it uses extra space and does not give sorted order guarantees. If sorting is allowed or already given, two pointers is simpler and more space efficient.
def pair_sum_sorted(a, target):
i, j = 0, len(a)-1
while i < j:
s = a[i] + a[j]
if s == target: return i, j
if s < target: i += 1
else: j -= 1
return NoneAbsolute imports are explicit and unambiguous. They make refactors safer and work cleanly with tools and type checkers. Use relative imports for private, intra-package internals when you want to signal non-public APIs.
from myapp.core.service import run # Prefer absolute over: from .core import service
pyproject.toml centralizes project metadata, dependencies, and the build backend. It is the standard way to define how a package is built and installed. requirements.txt still helps pin runtime deps for apps, but pyproject describes the package itself.
[project] name = 'myapp' version = '0.1.0' [build-system] requires = ['setuptools','wheel'] build-backend = 'setuptools.build_meta'
PUT replaces the resource state, so repeating the same PUT has the same final effect. POST is not idempotent because each call may create or change additional state. PATCH is partial update and may or may not be idempotent based on semantics.
# Request
PUT /users/42 {"name":"A"}
# Repeat same request → same final statePass interfaces or callables into constructors or function parameters. Build the object graph at startup in a small composition root. Use factories for resources like clients or repositories. This keeps modules decoupled and testable. In tests, swap real dependencies for fakes by passing different constructors or using monkeypatch.
class Service:
def __init__(self, repo): self.repo=repo
def build():
repo = SqlRepo(url)
return Service(repo)Decorators are higher-order callables that take a function and return a wrapped function. They enable cross-cutting concerns like logging, timing, caching, and access control. This keeps core logic clean while applying consistent policies in a reusable way.
def log(fn):
def wrap(*a, **k):
print('call', fn.__name__)
return fn(*a, **k)
return wrap
@log
def add(x,y): return x+yStream data instead of loading it all. Iterate line by line, or read fixed-size chunks in binary for parsing. Keep memory usage stable and perform work incrementally. Use generators to pipe data through steps. Tune buffering, avoid per-line string concatenation, and batch writes. If I O is the bottleneck, consider gzip streams, multiprocessing for CPU-bound parsing, or external tools for pre-filtering.
def chunks(f, size=1024*1024):
while True:
b=f.read(size)
if not b: break
yield b
with open('big.bin','rb') as f:
for c in chunks(f):
process(c)yield from passes through values, exceptions, and the close or send calls to the subgenerator. It also captures the subgenerator's return value as the expression result. This makes generator composition simple and keeps control flow readable.
def outer():
result = yield from inner()
yield resultDictionaries preserve insertion order. dict.fromkeys keeps the first time each item appears. You can wrap keys with list to get a list back. Using set loses order. Sorting changes order entirely.
unique = list(dict.fromkeys([3,1,3,2,1])) # [3,1,2]
A shallow copy duplicates the outer list but keeps references to the same inner lists. deep copy recursively copies nested structures so edits do not leak back. Use deepcopy when structures are nested and you truly want independence between old and new.
import copy old=[[1],[2]] new=copy.deepcopy(old) new[0][0]=9 # old unchanged