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
Python Libraries & Real-World Usage interview questions for placements and exams.
Questions
16
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.
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)For complete preparation, combine this set with full subject-wise practice for Python. You can also explore other subjects and sets from the links below.
NumPy stores data in contiguous memory blocks and performs vectorized math in optimized C loops. This avoids Python’s per-element overhead and speeds up arithmetic and broadcasting. The speedup is highest for large numeric arrays. For tiny arrays, Python overhead can dominate, and gains may be small.
import numpy as np x=np.arange(1_000_000) y=x*2 # vectorized C loop
.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]
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
.agg accepts a list of functions per column or a dict mapping columns to functions. It creates a tidy summary in one pass. This is faster and clearer than manual apply loops for standard aggregations.
df.groupby('city').agg({'sales':['sum','mean'],'id':'count'})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'})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))
A Session reuses TCP connections and carries shared headers, auth, and cookies across calls. This reduces latency and keeps stateful interactions simple. For retries, attach a Retry adapter from urllib3; it is not automatic.
s=requests.Session(); s.headers.update({'Authorization':'Bearer X'})
s.get(url)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}')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)
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')A naive datetime has no time zone info, so arithmetic and comparisons can be wrong across regions. An aware datetime carries a tzinfo and knows its offset from UTC, which makes math and conversions correct. Use zoneinfo (built in) to attach real time zones, convert to UTC for storage, and convert to local zones for display. Always specify a timezone when parsing external timestamps.
from zoneinfo import ZoneInfo
from datetime import datetime
now=datetime.now(tz=ZoneInfo('Asia/Kolkata'))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 Session with timeouts and a retry adapter. Fetch pages in a loop until no next link remains. Validate status codes and parse JSON safely. Accumulate records into a list of dicts or write pages to disk to cap memory. Finally, build a DataFrame from the collected rows and normalize nested fields with json_normalize. Persist as Parquet with a stable schema for fast reads later.
rows=[]; url=BASE
while url:
r=s.get(url, timeout=10)
data=r.json(); rows+=data['items']
url=data.get('next')
df=pd.DataFrame(rows)JSON is language-neutral and safe when parsed with standard libraries. pickle can execute code on load and must not be used with untrusted inputs. Use JSON for API payloads, with custom encoders for datetimes when needed.
import json
payload=json.dumps({'ok':True})A Session keeps TCP connections open between calls. This cuts handshake overhead and improves throughput. It also centralizes shared headers, cookies, and auth, making code cleaner and reducing duplication. To add retries, mount an HTTPAdapter with a Retry policy from urllib3. Configure backoff, allowed methods, and status codes like 429 or 503. This gives robust behavior under transient failures without rewriting call sites.
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
s=requests.Session()
retry=Retry(total=3, backoff_factor=0.5, status_forcelist=[429,502,503,504])
s.mount('https://', HTTPAdapter(max_retries=retry))