Python interview questions for data roles, with answers.

What Python rounds test

Analyst and data science interviews in India usually test Python through the work itself: a file to clean, a question to answer with pandas, a short function to write. Algorithm puzzles come up less often than in software interviews, and how much depends on the role.

Under each role: the Python it’s usually tested on.

Rounds take the same three shapes as SQL rounds: an online test (often “what does this code print?” plus a short problem), a live round in a notebook or shared editor, and a take-home dataset. In a live round, narrate: say what you expect each line to return before you run it. Most analyst rounds also include SQL, covered in our SQL interview questions.

The example data

The pandas answers all use this small DataFrame of an online shop’s orders, plus a table of customer segments. It has the traps interviewers like: a missing amount, repeat customers, two orders on one date and a customer with no segment. Paste it into a notebook first.

import numpy as np
import pandas as pd

orders = pd.DataFrame({
    "order_id":   [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008],
    "customer":   ["Aarav", "Diya", "Aarav", "Kabir", "Meera", "Diya", "Rohan", "Kabir"],
    "city":       ["Pune", "Ahmedabad", "Pune", "Delhi", "Chennai", "Ahmedabad", "Kolkata", "Delhi"],
    "order_date": pd.to_datetime(["2026-09-02", "2026-09-05", "2026-09-20", "2026-10-01",
                                  "2026-10-02", "2026-10-04", "2026-10-04", "2026-10-11"]),
    "category":   ["Fashion", "Fashion", "Electronics", "Home", "Fashion", "Home", "Fashion", "Home"],
    "amount":     [1798.0, 2499.0, 1999.0, 3398.0, 1299.0, 998.0, 2499.0, np.nan],
    "status":     ["delivered", "delivered", "cancelled", "delivered", "returned",
                   "delivered", "delivered", "delivered"],
})

segments = pd.DataFrame({
    "customer": ["Aarav", "Diya", "Kabir", "Sana"],
    "segment":  ["Gold", "Silver", "Gold", "New"],
})

Core Python: 13 questions

Types, functions and the habits that make code readable. Online tests often show a snippet and ask what it prints, so run each of these and check you predicted the output.

city = "pune"
city.upper()            # 'PUNE' is a new string; city is still 'pune'

cities = ["Pune", "Delhi"]
same = cities           # a second name for the same list
same.append("Jaipur")
cities                  # ['Pune', 'Delhi', 'Jaipur']

point = (18.52, 73.86)
point[0] = 0            # TypeError: tuples can't be changed

order_ids = [1001, 1002, 1002]          # list: ordered, duplicates allowed
location  = ("Pune", 411001)            # tuple: a fixed record, can be a dict key
cities    = {"Pune", "Delhi", "Pune"}   # set: {'Pune', 'Delhi'}
price     = {"kurta": 1299, "shoes": 2499}

"Pune" in cities        # True, fast even for millions of items
price["kurta"]          # 1299

a = [1, 2]
b = [1, 2]
a == b          # True: same value
a is b          # False: two separate lists

x = None
x is None       # the right way to test for None

import copy

stores  = [["Pune", 120], ["Delhi", 60]]
shallow = stores.copy()          # new outer list, same inner lists
deep    = copy.deepcopy(stores)  # copies the inner lists too

shallow[0][1] = 999
stores[0][1]     # 999: the inner list is shared
deep[0][1]       # 120

def add_item(item, basket=[]):       # created once
    basket.append(item)
    return basket

add_item("kurta")     # ['kurta']
add_item("shoes")     # ['kurta', 'shoes']: the same list again

def add_item(item, basket=None):     # the fix
    if basket is None:
        basket = []
    basket.append(item)
    return basket

prices = {"kurta": 1299, "shoes": 2499, "bottle": 499}

[p for p in prices.values() if p > 1000]        # list: [1299, 2499]
{name: round(p * 0.9) for name, p in prices.items()}   # dict: 10% off
{len(name) for name in prices}                  # set: {5, 6}
sum(p for p in prices.values())                 # generator expression: 4297

def total(*amounts, discount=0, **details):
    print(details)                  # {'city': 'Pune'}
    return sum(amounts) - discount

total(1299, 2499, discount=100, city="Pune")   # 3698

products = [("kurta", 1299), ("shoes", 2499), ("bottle", 499)]
sorted(products, key=lambda p: p[1], reverse=True)
# [('shoes', 2499), ('kurta', 1299), ('bottle', 499)]

def read_rows(path):
    with open(path) as f:
        for line in f:                       # one line at a time
            yield line.rstrip("\n").split(",")

rows = read_rows("orders.csv")   # nothing is read yet
next(rows)                       # reads the first line only

def parse_amount(text):
    try:
        return float(text.replace("₹", "").replace(",", ""))
    except (ValueError, AttributeError):    # bad text, or None
        return None

parse_amount("₹1,299")    # 1299.0
parse_amount("N/A")       # None

try:
    f = open("orders.csv")
except FileNotFoundError:
    print("No file")
else:
    print(f.readline())   # only if open() worked
    f.close()
finally:
    print("Done")         # always

class Order:
    currency = "INR"                      # class attribute: shared

    def __init__(self, order_id, amount):
        self.order_id = order_id          # instance attributes
        self.amount = amount

    def with_discount(self, pct):
        return self.amount * (1 - pct / 100)

    def __repr__(self):
        return f"Order({self.order_id}, {self.amount})"

class UPIOrder(Order):                    # inherits from Order
    def __init__(self, order_id, amount, upi_ref):
        super().__init__(order_id, amount)
        self.upi_ref = upi_ref

o = UPIOrder(1001, 1798, "UPI123")
o.with_discount(50), o.currency           # (899.0, 'INR')

import time
from functools import wraps

def timed(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.3f}s")
        return result
    return wrapper

@timed
def load_orders(path):
    return pd.read_csv(path)

from collections import Counter, defaultdict

stock = {"kurta": 5}
stock.get("shoes", 0)                   # 0, no KeyError

by_city = defaultdict(list)
for city, order_id in [("Pune", 1001), ("Delhi", 1004), ("Pune", 1003)]:
    by_city[city].append(order_id)      # no need to check the key first
by_city["Pune"]                         # [1001, 1003]

Counter(["Pune", "Delhi", "Pune"])      # Counter({'Pune': 2, 'Delhi': 1})

pandas: 14 questions

The heart of a data interview. Each answer runs on the orders DataFrame above.

s  = orders["amount"]       # Series
df = orders[["amount"]]     # DataFrame with one column
type(s).__name__, type(df).__name__     # ('Series', 'DataFrame')
orders.shape                            # (8, 7): rows, columns

o = orders.set_index("order_id")

o.loc[1001:1003, ["customer", "amount"]]   # labels 1001 to 1003: 3 rows, end included
o.iloc[0:3, [0, 4]]                        # positions 0, 1, 2: end excluded
o.loc[o["amount"] > 2000, "customer"]      # mask and column together

mask = (orders["status"] == "delivered") & (orders["amount"] > 2000)
orders[mask]                                         # 1002, 1004, 1007

orders[orders["city"].isin(["Pune", "Delhi"])]
orders[orders["amount"].between(1000, 2000)]
orders.query("status == 'delivered' and amount > 2000")

orders["city"].value_counts()
orders["customer"].nunique()                         # 5
orders.duplicated(subset=["customer"]).sum()         # 3 repeat orders
orders.drop_duplicates(subset=["customer"], keep="first")   # each customer's first order

summary = (orders[orders["status"] == "delivered"]
           .groupby("city", as_index=False)
           .agg(orders=("order_id", "count"),
                revenue=("amount", "sum"),
                avg_order=("amount", "mean")))
# Delhi: orders 2, revenue 3398.0, avg_order 3398.0, because order 1008 has no amount

orders["city_avg"] = orders.groupby("city")["amount"].transform("mean")
orders["share_of_city"] = (orders["amount"]
                           / orders.groupby("city")["amount"].transform("sum"))

merged = orders.merge(segments, on="customer", how="left",
                      validate="many_to_one", indicator=True)
merged["_merge"].value_counts()
# both 6, left_only 2: Meera and Rohan have no segment

orders.pivot_table(index="city", columns="category", values="amount",
                   aggfunc="sum", fill_value=0)

orders.pivot(index="city", columns="category", values="amount")
# ValueError: Delhi has two Home orders

# Slow: a Python function per row
orders["band"] = orders["amount"].apply(lambda x: "Large" if x >= 2500 else "Small")

# Fast: one operation on the whole column
orders["band"] = np.where(orders["amount"] >= 2500, "Large", "Small")

# Several bands, NaN stays NaN
orders["band"] = pd.cut(orders["amount"], bins=[0, 1000, 2500, np.inf],
                        labels=["Small", "Medium", "Large"], right=False)

# Lookups
orders["is_sale"] = orders["status"].map({"delivered": 1, "cancelled": 0, "returned": 0})

orders["amount"].isna().sum()        # 1
orders["amount"].mean()              # 2070.0, from the 7 known amounts

orders.dropna(subset=["amount"])                                  # drop
orders["amount"].fillna(orders["amount"].median())                # fill
orders["amount"].fillna(orders.groupby("city")["amount"].transform("median"))  # fill by city
orders["amount_missing"] = orders["amount"].isna()               # flag

np.nan == np.nan                     # False: use isna()

raw = pd.Series(["05/09/2026", "20/09/2026", "not a date"])
pd.to_datetime(raw, format="%d/%m/%Y", errors="coerce")   # 2026-09-05, 2026-09-20, NaT

orders["month"]   = orders["order_date"].dt.to_period("M")
orders["weekday"] = orders["order_date"].dt.day_name()

monthly = orders.set_index("order_date").resample("MS")["amount"].sum()

daily = orders.groupby("order_date")["amount"].sum()

daily.cumsum()                           # running total
daily.rolling(7, min_periods=1).mean()   # last 7 rows
daily.rolling("7D").mean()               # last 7 calendar days
daily.shift(1)                           # previous row's value
daily.pct_change()                       # change on the previous row

# Never works in pandas 3.0: orders is unchanged
orders["amount"][orders["status"] == "cancelled"] = 0

# Works
orders.loc[orders["status"] == "cancelled", "amount"] = 0

orders.memory_usage(deep=True).sum()

orders["city"] = orders["city"].astype("category")
orders["order_id"] = pd.to_numeric(orders["order_id"], downcast="integer")

cols = ["order_id", "city", "amount"]
pd.read_csv("orders.csv", usecols=cols, dtype={"city": "category"})

totals = {}
for chunk in pd.read_csv("orders.csv", usecols=cols, chunksize=100_000):
    for city, amount in chunk.groupby("city")["amount"].sum().items():
        totals[city] = totals.get(city, 0) + amount

NumPy: 3 questions

pandas is built on NumPy, so interviewers check that you know why it’s fast and how its shapes work.

prices = np.array([1299, 2499, 1899, 499])
prices * 0.9                                   # one vectorised operation
[p * 0.9 for p in [1299, 2499, 1899, 499]]     # a Python loop, item by item
prices.dtype                                   # one type for every element

sales = np.array([[120,  80, 95],     # rows: 2 stores
                  [ 60, 110, 70]])    # columns: 3 months

sales.sum(axis=0)     # per month: [180 190 165]
sales.sum(axis=1)     # per store: [295 240]

sales / sales.sum(axis=1, keepdims=True)   # each store's monthly share

amounts = np.array([1798, 2499, 1999, 3398, 1299])
amounts[amounts > 2000]                      # array([2499, 3398])
np.where(amounts > 2000, "High", "Normal")
(amounts > 2000).mean()                      # 0.4: 2 of 5

Coding tasks: 5 questions

Short problems of the kind set in online tests and live rounds. Say the approach and its cost before you code.

def dedupe(items):
    return list(dict.fromkeys(items))

def dedupe_loop(items):
    seen, out = set(), []
    for x in items:
        if x not in seen:
            seen.add(x)
            out.append(x)
    return out

dedupe(["Pune", "Delhi", "Pune", "Jaipur", "Delhi"])   # ['Pune', 'Delhi', 'Jaipur']

import re
from collections import Counter

text = "UPI is fast. UPI is free. Cards are not free."
words = re.findall(r"[a-z']+", text.lower())
Counter(words).most_common(3)     # [('upi', 2), ('is', 2), ('free', 2)]

def pair_with_sum(prices, target):
    seen = {}                          # price -> position
    for i, p in enumerate(prices):
        if target - p in seen:
            return seen[target - p], i
        seen[p] = i
    return None

pair_with_sum([499, 1299, 1899, 2499], 3798)    # (1, 3): 1299 + 2499

top2 = (orders.sort_values("amount", ascending=False)
              .groupby("city")
              .head(2))

orders["rank_in_city"] = (orders.groupby("city")["amount"]
                                .rank(method="dense", ascending=False))
orders[orders["rank_in_city"] <= 2]

import io

raw = io.StringIO("""Order ID, Order Date ,City,Amount
1001,02/09/2026, pune ,"₹1,798"
1002,05/09/2026,Ahmedabad,"₹2,499"
1002,05/09/2026,Ahmedabad,"₹2,499"
1003,20/09/2026,PUNE,
""")

df = pd.read_csv(raw)
df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
df["order_date"] = pd.to_datetime(df["order_date"], format="%d/%m/%Y")
df["city"] = df["city"].str.strip().str.title()
df["amount"] = pd.to_numeric(df["amount"].str.replace(r"[₹,]", "", regex=True),
                             errors="coerce")
df = df.drop_duplicates()
df.info()     # 3 rows; order_date datetime64, amount float64 with one NaN

A 7-day practice plan

About 90 minutes a day. Type every answer yourself in a notebook before you read ours, and predict each output before you run it.

For day 7, pick a dataset from our 15 data analyst projects on Indian public data: real files are messier than any example, which is the point.

Questions

Sources

1. pandas 3.0 documentation, Copy-on-Write (CoW), read 17 Oct 2026.
2. pandas documentation, What’s new in 3.0.0, read 17 Oct 2026.
3. pandas 3.0 documentation, Indexing and selecting data, read 17 Oct 2026.
4. pandas 3.0 documentation, Group by: split-apply-combine, read 17 Oct 2026.
5. pandas 3.0 documentation, Merge, join, concatenate and compare, read 17 Oct 2026.
6. pandas 3.0 documentation, Working with missing data, read 17 Oct 2026.
7. pandas 3.0 documentation, Time series / date functionality, read 17 Oct 2026.
8. pandas 3.0 documentation, Scaling to large datasets, read 17 Oct 2026.
9. NumPy documentation, Broadcasting, read 17 Oct 2026.
10. The Python Tutorial, More Control Flow Tools (default argument values), read 17 Oct 2026.
11. Python documentation, collections: Container datatypes, read 17 Oct 2026.
12. Python documentation, copy: Shallow and deep copy operations, read 17 Oct 2026.
13. Python documentation, Built-in Types (dictionary order), read 17 Oct 2026.
14. Indeed Hiring Lab, September 2025 labour market update, 25 Oct 2025.