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
Python · Question Set
Advanced Python Features interview questions for placements and exams.
Questions
14
Included in this set
Subject
Python
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Python.
itertools.chain yields from each iterable in sequence without building a new list. It is ideal for streaming pipelines. accumulate computes running totals. product makes cartesian products. zip_longest pairs uneven inputs with fill values.
from itertools import chain
for x in chain([1,2],[3,4]):
print(x)An 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)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.iA generator expression yields one item at a time. This keeps memory low for large streams or pipelines. A list comprehension builds the whole list in memory first, which is fine for small data but expensive for huge inputs.
total = sum(x*x for x in range(10_000_000))
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)partial 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
A descriptor is an object attribute with binding behavior defined by dunder get, dunder set, and dunder delete. Properties and functions use descriptors under the hood. Use descriptors to implement reusable managed attributes such as validation or type enforcement.
class NonEmpty:
def __set__(self, obj, val):
if not val: raise ValueError('empty')
obj.__dict__['name']=val
def __get__(self, obj, owner):
return obj.__dict__['name']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()Create a chain of small generator functions, each transforming or filtering items and yielding to the next stage. Because each stage yields on demand, only a few items live in memory at once. Compose them with for loops or yield from so that back pressure controls flow. This pattern is ideal for log processing, streaming CSVs, and network streams where you cannot load everything at once.
def read_lines(f):
for line in f: yield line.strip()
def only_errors(lines):
for s in lines:
if 'ERROR' in s: yield s
with open('app.log') as f:
for msg in only_errors(read_lines(f)): print(msg)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'))send pushes a value into a paused generator and resumes it until the next yield. throw injects an exception at the yield point. Together they allow two-way communication and controlled stop conditions. This is useful for coroutines in older code or for advanced pipelines that adjust behavior on feedback, such as changing a step size in a stream processor.
def coro():
total=0
while True:
x = yield total
if x is None: break
total += x
c = coro(); next(c)
print(c.send(3)); print(c.send(4)); c.throw(GeneratorExit)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)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 resultUse 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 set with full subject-wise practice for Python. You can also explore other subjects and sets from the links below.