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
TCS · Python
Practice Python questions specifically asked in TCS interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
54
Tagged for this company + subject
Company
TCS
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 TCS Python round.
heapq.nlargest uses a small heap of size k and runs faster than sorting everything when k is much smaller than n. Full sorts are O(n log n). nlargest runs in O(n log k).
import heapq best = heapq.nlargest(3, [5,1,8,4,9])
Python decides the data type of a variable at runtime based on the value you assign. You do not need to declare a type explicitly. This flexibility makes coding faster but can cause runtime errors if unexpected types are passed. It contrasts with statically typed languages where type checks happen at compile time.
x=10 x='Hi'
Adding question mark to star, plus, or brace quantifiers switches them to the shortest match. For example, star question matches as little as possible. This is useful for extracting the smallest block between tags or quotes.
import re
re.findall('<p>.*?</p>', html, flags=re.S)Python performs both compilation and interpretation. When you run a Python file, the source code is first compiled into bytecode, a lower-level form that the Python Virtual Machine understands. This compiled bytecode is stored in dot py c files. After that, the Python Virtual Machine interprets the bytecode line by line at runtime. This is why Python is considered interpreted in practice. Some implementations such as PyPy use Just-In-Time compilation to further speed up execution by compiling bytecode to native machine code at runtime.
python myfile.py
A while loop in Python continues executing its block as long as the given condition evaluates to true. Once it becomes false, the loop stops automatically. This makes while loops useful when you do not know in advance how many times the block should repeat, such as reading data until an end condition is met.
i=0 while i<5: print(i); i+=1
The single slash performs true division and always returns a floating-point result, even when both operands are integers. The double slash performs floor division. It divides the numbers and rounds the result down to the nearest integer. This is often used when integer results are required, such as index calculations.
print(5/2, 5//2)
List comprehension is a compact way to create a new list by applying an expression to each element of an iterable. It replaces long loops with a single, readable line. For instance, to build a list of squares you can write square equals x star star 2 for each x in a list. It is both faster and cleaner than using append inside a loop and is widely used in data transformation tasks.
a=[1,2,3] squares=[x*x for x in a]
The break statement immediately exits the loop, skipping any remaining iterations. continue jumps to the next iteration, skipping only the current one. pass simply does nothing and is used as a placeholder. These three help control the flow of loops. break is often used when a condition is met, continue is used to skip unwanted cases, and pass keeps structure valid while leaving logic for later.
for i in range(5): if i==2: continue if i==4: break print(i)
A list lets you add, remove, or replace items; a tuple does not. That is why lists are great for dynamic collections while tuples are good for fixed records. Because tuples are immutable, they can be used as dictionary keys when they contain only hashable values. This property makes tuples a safe choice for representing coordinates or composite keys.
t = (1,2,3) # t[0] = 9 # TypeError lst = [1,2,3]; lst[0] = 9
A list comprehension in square brackets returns a list. A set comprehension uses curly braces and returns a set. map needs a function object, not an expression. Choose list comprehension when order and duplicates matter and you need a list API afterward.
nums=[1,2,2,3] sq=[x*x for x in nums] # [1,4,4,9]
Counter counts hashable items and most_common returns items sorted by frequency. It is concise for word counts and event tallies. You can also add, subtract, and combine counters when merging tallies from multiple sources.
from collections import Counter
c=Counter('banana')
print(c.most_common(3))A shallow copy duplicates the outer container but shares references to inner objects. Changing an inner list in the copy also changes it in the original, because both point to the same inner object. A deep copy recursively copies inner objects, so edits in the copy do not affect the original. Use shallow copy when inner items are immutable or you want sharing; use deep copy when you need isolation between complex nested graphs.
import copy orig=[[1],[2]] sh = copy.copy(orig) dp = copy.deepcopy(orig) sh[0][0]=9 # orig changes # dp edits do not affect orig
defaultdict creates missing keys automatically using a factory like list or int, so you can append or add without pre-checks. It reduces boilerplate when grouping items or counting events. A pitfall is accidental key creation when reading; any access can materialize a key. Convert to a plain dict before serialization if you do not want the default behavior to surprise downstream code.
from collections import defaultdict
groups=defaultdict(list)
for k,v in [('a',1),('a',2)]:
groups[k].append(v)
print(dict(groups))Python searches first in the Local scope, then in any Enclosing function scopes, then in the module Global scope, and finally in Builtins. Knowing LEGB helps explain behaviors with closures, nonlocal, and why a name resolves the way it does.
x='G'
def outer():
x='E'
def inner():
x='L'
return x
return inner()
print(outer())Python computes a single consistent linear order called the MRO using C3 linearization. It respects subclass precedence and the order of bases. You can inspect it via Class.__mro__ to understand how super will resolve methods.
class A: pass class B(A): pass class C(B, A): pass print(C.__mro__)
Dataclasses reduce boilerplate for simple data containers. They generate init, repr, eq, and more based on field definitions. They keep code readable while supporting defaults, type hints, and post-init hooks.
from dataclasses import dataclass
@dataclass
class Point:
x:int
y:intMode x is exclusive creation. It succeeds only if the file does not exist. This is useful when you want to avoid accidental overwrites. Mode w truncates existing files. Mode a appends if the file exists, or creates it if not. Mode r+ reads and writes without truncation.
with open('report.txt', 'x', encoding='utf-8') as f:
f.write('first run only')Defaults vary by system and locale. Declaring UTF eight makes behavior predictable across machines and containers. It also avoids subtle bugs with special characters, especially when moving code between Windows, Mac, and Linux.
with open('notes.txt','r',encoding='utf-8') as f:
txt=f.read()A single dot means the current package. This form keeps package internals flexible if you reorganize directories. Absolute imports are clearer for public APIs. Relative imports suit private, within-package usage.
# inside package module from .utils import helper helper.run()
sys.path is a list of directories that the import system searches in order. You can inspect or modify it at runtime for advanced cases. A better practice is to use packages and editable installs rather than mutating sys.path in production code.
import sys print(sys.path[0])
Organize code by feature: keep internals in submodules and re-export stable names in the package’s __init__.py. This gives users short imports while letting you refactor internals later. Use __all__ to declare what is public. Document the public surface and keep breaking changes behind the package boundary. Internals can change, but the top-level API should remain stable for consumers.
mypkg/ __init__.py # from .core import run; __all__=['run'] core.py utils.py
Code inside try runs first. If an exception occurs and matches a handler, the matching except runs. If no exception occurs, the else block runs. The finally block always runs at the end for cleanup, whether an exception happened or not. This ensures resources are released in all cases.
try:
do_work()
except ValueError:
fix()
else:
commit()
finally:
close()Using from preserves the cause in the traceback as __cause__. It tells readers why the higher-level error happened. This is useful when translating low-level errors into domain-specific ones while keeping a clear audit trail.
try:
low()
except OSError as e:
raise RuntimeError('storage failed') from eEasier to ask forgiveness than permission uses try and except. You attempt the operation and handle failure. It is concise and safe under races where the world can change between a check and an action. Look before you leap tests conditions first. It can be clearer when errors are expensive or truly exceptional. In Python, prefer EAFP when interacting with dictionaries, files, or concurrency. Use LBYL for validation paths where exceptions would be noisy.
# EAFP
d = {}
try:
v = d['x']
except KeyError:
v = 0
# LBYL
v = d['x'] if 'x' in d else 0An object is iterable if it implements the iteration protocol. That means it defines dunder iter which returns an iterator. The iterator itself must implement dunder next. In practice, containers return a fresh iterator from dunder iter, while custom iterator objects can return self when dunder iter is called.
class Box:
def __init__(self, items): self.items=items
def __iter__(self): return iter(self.items)lru_cache stores results for a function call based on arguments. It works best for pure functions where the same input always gives the same output. Avoid caching when results depend on external state, time, or I O, unless you manage invalidation carefully.
from functools import lru_cache
@lru_cache(maxsize=256)
def fib(n):
return n if n<2 else fib(n-1)+fib(n-2)contextmanager turns a simple generator into a context manager. The code before the yield is the setup. The code after the yield is the teardown that always runs, even if an exception occurs. Use it when the resource logic is small and linear. It keeps the pattern concise without defining enter and exit methods. For complex state or multiple exit paths, a class-based manager can be clearer and easier to extend.
from contextlib import contextmanager
@contextmanager
def opened(path):
f=open(path,'r',encoding='utf-8')
try:
yield f
finally:
f.close()copy.copy makes a shallow copy. copy.deepcopy walks the entire object graph and copies inner containers too. For custom classes, you can guide deep copy with __deepcopy__ if you need special handling.
import copy b = copy.deepcopy(a)
Implementations like CPython cache a range of small integers to reduce allocations. This makes repeated small numbers share the same identity. It is an implementation detail, not a language guarantee. Do not rely on it for program logic.
a=5; b=5 print(id(a)==id(b)) # often True
CPython primarily uses reference counting. Each object tracks how many references point to it. When the count drops to zero, the object is freed immediately. This makes most reclamation prompt and predictable. Reference cycles cannot be collected by counting alone, so a cyclic garbage collector runs occasionally to find groups of objects that reference each other but are otherwise unreachable. You can tune collection thresholds with the gc module, but most apps do not need manual tweaks. Be careful with objects that define finalizers; cycles containing them may not be collected automatically. Breaking cycles with weak references or context managers keeps memory healthy.
import gc print(gc.get_threshold()) # gc.collect() can force a cycle collection
.loc uses index labels and supports boolean masks. .iloc uses zero-based integer positions. Mixing them up causes off-by-one errors or KeyErrors. Prefer .loc when working with meaningful index labels such as dates or ids.
df.loc['2025-01-01'] df.iloc[0:10]
Specifying dtypes and selecting only needed columns cuts RAM usage. Parsing dates during read can also help if types are clear. For huge files, consider chunksize to stream data and process in batches.
pd.read_csv('data.csv', usecols=['id','price'], dtype={'id':'int32','price':'float32'})Prefer vectorized operations and built-ins like where, clip, str, and dt for series-wise transforms. They run in optimized C and avoid per-row Python overhead. apply is flexible but slower since it calls Python for each row or column. If you must use apply, limit it to column-wise functions and avoid row-wise lambdas. For very large data, consider cython, numba, or pushing work into database engines when possible.
df['z'] = (df['x']+df['y']).clip(lower=0) # slower # df['z']=df.apply(lambda r: max(r.x+r.y,0), axis=1)
Stream it in chunks. Use read_csv with chunksize to process piece by piece, aggregate partial results, and combine at the end. Restrict columns with usecols and set precise dtypes to save RAM. If parsing dates, specify parse_dates to avoid post-processing overhead. For compute heavy steps, push aggregation into a database or use Dask for out-of-core scaling.
it=pd.read_csv('big.csv', chunksize=200_000, usecols=['id','amt'], dtype={'id':'int32','amt':'float32'})
for chunk in it:
process(chunk)Use a hash map from number to index while scanning once. For each value, check if target minus value exists in the map. This gives linear time because each lookup is constant time on average. Sorting would make it O(n log n) and nested loops are quadratic. The hash map approach is the standard answer in interviews.
def two_sum(nums, target):
pos = {}
for i, x in enumerate(nums):
y = target - x
if y in pos:
return pos[y], i
pos[x] = i
return NoneSliding window keeps a moving range and updates state as the window grows or shrinks. It shines for subarray or substring problems with local constraints. Graph algorithms and matrix math do not fit this pattern well.
def longest_unique(s):
seen, left, best = {}, 0, 0
for right, ch in enumerate(s):
if ch in seen and seen[ch] >= left:
left = seen[ch] + 1
seen[ch] = right
best = max(best, right-left+1)
return bestEnv vars let you change configuration per environment without code edits. They are easy to inject in containers and CI/CD. Read them once at startup and validate. Do not hard-code secrets or hostnames in code.
import os
DB_URL = os.environ['DATABASE_URL']
DEBUG = os.getenv('DEBUG','0')=='1'Maintain a running prefix total. For each index j, you want some i where prefix j minus prefix i equals K. Rearranged, prefix i equals prefix j minus K. Keep a map from prefix value to the number of times you have seen it. Add the count of prefix j minus K to the answer and then record prefix j. This works with negative and positive numbers and runs in linear time. It replaces nested loops with a single scan and a dictionary.
from collections import defaultdict
def count_subarrays_k(nums, K):
pref, seen, ans = 0, defaultdict(int), 0
seen[0] = 1
for x in nums:
pref += x
ans += seen[pref-K]
seen[pref] += 1
return ansKadane keeps a running best ending at the current index. Either extend the previous sum by adding the current number, or start fresh from the current number, whichever is larger. Track the global best seen so far. It works because any negative running sum only hurts future totals, so dropping it and starting at the current index cannot reduce the best answer. The result comes in linear time with constant space.
def kadane(nums):
best = cur = nums[0]
for x in nums[1:]:
cur = max(x, cur + x)
best = max(best, cur)
return bestA virtual environment gives your project its own interpreter and site-packages. This avoids version conflicts with global packages and keeps builds reproducible. It also makes deployments predictable: you freeze exact versions and recreate the same environment everywhere.
python -m venv .venv source .venv/bin/activate # Windows: .venv\Scripts\activate pip install -r requirements.txt
201 indicates a new resource was created. Include a Location header pointing to the new resource. Use 200 for a successful read or update where nothing new was created.
# pseudo FastAPI
return JSONResponse(obj, status_code=201, headers={'Location': url})Use a src layout with a top-level package for code, and tests as a sibling. Group code by feature or layer: api, core, adapters, and shared utils. Keep entry points thin and route all logic through the core domain layer. This layout isolates concerns, avoids import path hacks, and lets you publish the package if needed. It also makes testing easy because each module has a clear dependency direction toward the core.
project/
pyproject.toml
src/myapp/{api,core,adapters,utils}
tests/{unit,integration}A context manager defines enter and exit steps around a code block. Python calls the enter method before the block starts and exit after it ends, even when exceptions happen. This pattern centralizes resource handling and prevents leaks. You can implement one by defining __enter__ and __exit__ methods or by using contextlib.contextmanager. Common uses include file handles, locks, temporary directories, and timing utilities.
class Locker:
def __enter__(self): print('acquire'); return self
def __exit__(self, exc_type, exc, tb): print('release')
with Locker() as l:
do_work()A closure is a function that captures variables from its enclosing scope, keeping them alive even after the outer function has returned. This enables function factories and configurable behaviors without global state. Use nonlocal when the inner function needs to rebind a variable from the nearest enclosing scope rather than create a new local variable. This makes stateful callbacks and accumulators straightforward while avoiding mutable defaults or classes for small tasks.
def counter():
count=0
def inc():
nonlocal count
count += 1
return count
return inc
c = counter(); c(); c()The logging module lets you route messages to files, streams, or remote systems with levels and formatting. It integrates with exception info to capture tracebacks and supports configuration without changing source code.
import logging
logging.exception('failed to save')finally runs no matter what, including when exceptions occur or returns happen. This makes it a reliable place to close files, release locks, or restore state. It protects cleanup from early exits and errors. A context manager packages this pattern in a reusable form. The enter step acquires a resource, and the exit step guarantees release. Prefer with for common patterns and use finally when you need custom control flow in one place.
f=None
try:
f=open('data.txt','r',encoding='utf-8')
use(f)
finally:
if f: f.close()A bare return stops the generator. A return with a value raises StopIteration carrying that value. It can be observed by a caller that drives the generator manually or via yield from. This is useful for communicating a final result from a subgenerator to its delegator.
def g():
yield 1
return 99
# next after yield raises StopIteration(99)__slots__ removes the per-instance dictionary and stores fields in a fixed structure. This cuts memory per instance and can make attribute lookups a bit faster. It also limits dynamic attribute creation unless you include __dict__ in slots.
class Row:
__slots__=('a','b')
def __init__(self,a,b): self.a=a; self.b=bThreads work best for I O bound tasks, like network calls or disk waits. While one thread blocks, others can run, and the program makes progress. The Global Interpreter Lock limits true parallel CPU execution, but I O overlap still helps a lot. For CPU bound work, use multiprocessing to run multiple processes that bypass the Global Interpreter Lock. Share data carefully, batch work to reduce pickling costs, and consider using native extensions when possible.
# I O bound: threading # CPU bound: multiprocessing # mix with concurrent.futures for a simple API
Provide a tuple key where the first element sorts by name ascending and the second uses negative score to get descending order. cmp is not supported directly in Python 3, and sorting twice works but is less direct here.
students = sorted(students, key=lambda s: (s.name, -s.score))
Choose asyncio for high-concurrency I O: many sockets, HTTP calls, or database drivers with async support. It scales with a single event loop and has low context-switch overhead. Do not call blocking code inside async paths; offload it to a worker pool. Always await tasks or gather them; leaked tasks hide errors. For CPU-bound work, use processes or native extensions instead of the event loop.
import asyncio
async def main():
await asyncio.gather(fetch(a), fetch(b))
asyncio.run(main())A class variable is shared by all instances; an instance variable belongs to one object. Reading a missing instance attribute falls back to the class attribute via normal lookup. A common pitfall is using a mutable class variable like a list and then mutating it through one instance, which affects all others. Prefer per-instance fields for mutable state by assigning in __init__.
class Bag:
items=[] # shared
def __init__(self):
self.things=[] # per instance
b1=Bag(); b2=Bag()
b1.things.append(1)
Bag.items.append('X')A deque is a double-ended queue optimized for fast appends and pops at both left and right. Lists are fast at the right end but slow for pops from the left. Choose deque for FIFO queues, sliding windows, and bounded buffers.
from collections import deque q=deque() q.append(1); q.append(2); q.popleft()
Use property for one attribute on one class. It is simple and local. Choose a custom descriptor when the same validation or behavior must be reused across many classes or many attributes. Descriptors centralize logic and remove repetition, such as non-empty strings, ranged numbers, or type-checked fields. They also work with class attributes and can coordinate with metaclasses if you need schema-like behavior.
class NonEmpty:
def __set__(self,obj,val):
if not val: raise ValueError('empty')
obj.__dict__['name']=val
class User:
name = NonEmpty()
def __init__(self, name): self.name=nameFor 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.