Python Interview Questions for Data Analysts — 30 Practice Problems

20 fully solved problems with complete pandas code plus 10 more — covering groupby, merge, transform, datetime/IST, pivot_table, rolling windows, cohort retention, RFM feature engineering, and merge_asof. Every solution explains what the interviewer is testing.

import pandas as pd

df = pd.read_csv('orders.csv', parse_dates=['order_date'])

print(df.head())
print(f"Shape: {df.shape}")
print(df.dtypes)
print(df.isnull().sum())

filtered = df[
    (df['city'] == 'Delhi') &
    (df['amount_inr'] > 2000) &
    (df['order_date'] > '2026-09-01')
].copy()

print(filtered.sort_values('amount_inr', ascending=False))

summary = (
    df.groupby('city')['amount_inr']
    .agg(
        total_revenue='sum',
        order_count='count',
        avg_order_value='mean'
    )
    .round(0)
    .sort_values('total_revenue', ascending=False)
)
print(summary.head(10))

df['discount_inr'] = df['discount_inr'].fillna(0)
df = df.dropna(subset=['city'])

# Verify
print(df[['discount_inr', 'city']].isnull().sum())

df['city'] = (
    df['city']
    .str.strip()
    .str.title()
    .replace({'Delhi Ncr': 'Delhi', 'New Delhi': 'Delhi'})
)
print(df['city'].value_counts().head())

df['year']     = df['order_date'].dt.year
df['month']    = df['order_date'].dt.month
df['dow']      = df['order_date'].dt.day_name()    # Monday, Tuesday …

# Indian FY starts April (month 4)
df['fy_quarter'] = df['order_date'].apply(
    lambda d: f"Q{((d.month - 4) % 12 // 3) + 1}" if d.month >= 4
              else f"Q{((d.month + 8) // 3)}"
)

# Simpler alternative using pd.PeriodIndex offset 'Q-MAR'
df['fy_quarter_v2'] = pd.PeriodIndex(df['order_date'], freq='Q-MAR').astype(str)

df['city_total'] = df.groupby('city')['amount_inr'].transform('sum')
df['city_share_pct'] = (df['amount_inr'] / df['city_total'] * 100).round(1)

print(df[['order_id', 'city', 'amount_inr', 'city_share_pct']].head())

result = pd.merge(
    df,
    customers[['customer_id', 'name', 'email', 'registration_date']],
    on='customer_id',
    how='left'   # keep all orders, even if customer record is missing
)

# Check for unmatched orders
unmatched = result[result['name'].isnull()].shape[0]
print(f"Orders with no customer record: {unmatched}")

pivot = pd.pivot_table(
    df,
    index='city',
    columns='payment_method',
    values='amount_inr',
    aggfunc='sum',
    fill_value=0
).round(0)

# Add row total
pivot['Total'] = pivot.sum(axis=1)
pivot = pivot.sort_values('Total', ascending=False)
print(pivot.head(10))

def discount_tier(amount):
    if amount >= 5000:
        return 0.10
    elif amount >= 2000:
        return 0.05
    return 0.0

df['discount_rate'] = df['amount_inr'].apply(discount_tier)
df['net_amount']    = df['amount_inr'] * (1 - df['discount_rate'])

# Faster vectorised alternative with np.select:
import numpy as np
conditions = [df['amount_inr'] >= 5000, df['amount_inr'] >= 2000]
df['discount_rate_v2'] = np.select(conditions, [0.10, 0.05], default=0.0)

df_clean = (
    df
    .sort_values('updated_at', ascending=False)
    .drop_duplicates(subset='order_id', keep='first')
    .reset_index(drop=True)
)
print(f"Before: {len(df)}, After: {len(df_clean)}")

ct = pd.crosstab(
    df['city'],
    df['status'],
    normalize='index'   # row percentages
).round(3) * 100

ct.columns.name = None
print(ct.sort_values('returned', ascending=False).head(10))

daily = (
    df.groupby('order_date')
    .agg(orders=('order_id','count'), revenue=('amount_inr','sum'))
    .sort_index()
)

daily['orders_7d_avg'] = daily['orders'].rolling(7, min_periods=1).mean().round(1)
daily['revenue_7d_sum'] = daily['revenue'].rolling(7, min_periods=1).sum()
print(daily.tail(14))

df['order_ts_utc'] = pd.to_datetime(df['order_timestamp'], utc=True)
df['order_ts_ist'] = df['order_ts_utc'].dt.tz_convert('Asia/Kolkata')
df['hour_ist']     = df['order_ts_ist'].dt.hour

# Peak hour analysis
print(df.groupby('hour_ist')['order_id'].count().sort_values(ascending=False))

df['spend_rank'] = (
    df.groupby('customer_id')['amount_inr']
    .rank(method='dense', ascending=False)
    .astype(int)
)

# Each customer's top order
top_orders = df[df['spend_rank'] == 1]
print(top_orders[['customer_id','order_id','amount_inr']].head())

# 1. Label each customer's cohort (first order month)
df['cohort'] = df.groupby('customer_id')['order_date'].transform('min').dt.to_period('M')
df['order_period'] = df['order_date'].dt.to_period('M')
df['months_since'] = (df['order_period'] - df['cohort']).apply(lambda x: x.n)

# 2. Count unique customers per cohort × months_since cell
cohort_data = (
    df.groupby(['cohort','months_since'])['customer_id']
    .nunique()
    .reset_index(name='customers')
)

# 3. Pivot
cohort_pivot = cohort_data.pivot(index='cohort', columns='months_since', values='customers')

# 4. Divide by cohort size (month 0) to get retention rates
retention = cohort_pivot.divide(cohort_pivot[0], axis=0).round(3) * 100
print(retention.iloc[:, :6])   # show first 6 months

events = pd.DataFrame(...)  # columns: user_id, event, timestamp

funnel_steps = ['product_viewed','added_to_cart','checkout_started','purchase_completed']

# Count unique users at each step
funnel = {
    step: events[events['event'] == step]['user_id'].nunique()
    for step in funnel_steps
}
funnel_df = pd.DataFrame.from_dict(funnel, orient='index', columns=['users'])
funnel_df['pct_of_top'] = (funnel_df['users'] / funnel_df['users'].iloc[0] * 100).round(1)
funnel_df['step_conversion'] = (
    funnel_df['users'] / funnel_df['users'].shift(1) * 100
).round(1)
print(funnel_df)

import numpy as np
from datetime import date

today = pd.Timestamp(date.today())

rfm = df.groupby('customer_id').agg(
    recency   = ('order_date', lambda x: (today - x.max()).days),
    frequency = ('order_id',   'count'),
    monetary  = ('amount_inr', 'sum')
).reset_index()

# Score each dimension 1–5 using quintiles
for col, ascending in [('recency', False), ('frequency', True), ('monetary', True)]:
    rfm[f'{col}_score'] = pd.qcut(
        rfm[col], q=5,
        labels=[1,2,3,4,5] if ascending else [5,4,3,2,1],
        duplicates='drop'
    ).astype(int)

rfm['rfm_segment'] = rfm['recency_score'].astype(str) + rfm['frequency_score'].astype(str) + rfm['monetary_score'].astype(str)
print(rfm.sort_values('monetary', ascending=False).head())

# orders: order_id, order_date, amount_usd
# fx_rates: date, usd_to_inr   (one row per trading day)

orders_sorted = orders.sort_values('order_date')
fx_sorted     = fx_rates.sort_values('date')

matched = pd.merge_asof(
    orders_sorted,
    fx_sorted,
    left_on='order_date',
    right_on='date',
    direction='backward'   # use most recent rate on or before order date
)
matched['amount_inr'] = (matched['amount_usd'] * matched['usd_to_inr']).round(2)
print(matched[['order_id','order_date','amount_usd','usd_to_inr','amount_inr']].head())

matrix = (
    df.groupby(['category','city'])['amount_inr']
    .sum()
    .unstack(fill_value=0)
)

# Best city per category
best_city = matrix.idxmax(axis=1).rename('top_city')
best_rev  = matrix.max(axis=1).rename('top_city_revenue')
result = pd.concat([best_city, best_rev], axis=1)
print(result)

EVIKA ACADEMY · NOIDA SECTOR 51

Master Python for Data Analyst Interviews

Our Python for Data Analysts module covers 60+ hands-on pandas problems using Indian e-commerce datasets, with mock interview practice and live code reviews by working analysts.