🐍 Day 6 - Python Interview Prep

Welcome to Day 6 of our 10-day Data Analyst Interview Prep Series! Today, we're diving deep
into Python - the Swiss Army knife of data analysis that has revolutionized the field.
Python has become the most in-demand technical skill for data analysts, with over 70% of
data job postings now requiring Python proficiency. Even traditionally Excel-focused roles are
increasingly expecting candidates to automate workflows and handle larger datasets with
Python.

Why Python Matters for Your Interview

Python's popularity stems from its versatility and powerful ecosystem of data libraries:

Pandas for data manipulation and analysis

NumPy for numerical operations

Matplotlib and Seaborn for visualization

scikit-learn for basic machine learning

Interviewers don't just want to know if you can code - they want to see how you think about
data problems and whether you follow best practices when writing Python code.
Let's get started with the Python skills that will set you apart in your data analyst interviews!

🐼 Pandas Mastery (Questions 1-4)

1. When to use .map() , .apply() , and .applymap()
These three methods often confuse even experienced developers:

.map() : Series-only transformations (value-to-value mapping)

# Converting categories to numeric values

df['size_code'] = df['size'].map({'Small': 1, 'Medium': 2, 'Large': 3})

.apply() : For operations that need the context of the entire row/column

# Custom calculation using multiple columns

df['risk_score'] = df.apply(lambda row: calculate_risk(row['income'], row['debt']), axis
=1)

.applymap() : Element-wise operations on every single cell

# Formatting all numeric values in a DataFrame

df_display = df.applymap(lambda x: f"${x:.2f}" if isinstance(x, (int, float)) else x)

Understanding these differences shows deep pandas knowledge.

🐍 Day 6 - Python Interview Prep 1

 2. Add grouped statistics without merging
The .transform() method is underutilized but incredibly powerful:

# Add each product's average rating to all rows

df['vs_category_avg'] = df['rating'] / df.groupby('category')['rating'].transform('mean')

# Flag outlier products

outliers = df[df['vs_category_avg'] < 0.7]

This is much cleaner than creating a separate DataFrame and merging back.

3. Why you should avoid .iterrows()

This is a common performance trap in pandas:

# Beginner approach (SLOW)

for idx, row in df.iterrows():
# Each iteration creates a new Series object - memory intensive!
result.append(some_function(row['a'], row['b']))

# Better approach
df['result'] = df.apply(lambda row: some_function(row['a'], row['b']), axis=1)

# Best approach (when possible)

df['result'] = vectorized_function(df['a'], df['b'])

The difference can be 100x+ on large datasets.

4. Multi-column filtering with nulls

# Find records missing critical fields (both name AND email)

critical_missing = df[df[['name', 'email']].isna().all(axis=1)]

# Find records missing any contact information

partial_missing = df[df[['email', 'phone', 'address']].isna().any(axis=1)]

These patterns appear frequently in data cleaning challenges.

🔢 NumPy Efficiency (Questions 5-7)

5. Why NumPy outperforms native Python lists
Compare these approaches for squaring numbers:

numbers = list(range(1000000))

🐍 Day 6 - Python Interview Prep 2

 # List comprehension
result1 = [x**2 for x in numbers] # ~300ms

# Using map()
result2 = list(map(lambda x: x**2, numbers)) # ~250ms

# NumPy vectorization
import numpy as np
arr = np.array(numbers)
result3 = arr**2 # ~5ms

NumPy's vectorization is dramatically faster because:

Operations execute in pre-compiled C code

Memory is contiguous

No Python interpretation overhead

6. Broadcasting: NumPy's secret weapon

Broadcasting lets you operate on arrays of different shapes without loops:

# Normalize data by subtracting mean and dividing by std dev

data = np.random.randn(1000, 5) # 1000 samples, 5 features
means = data.mean(axis=0) # Shape: (5,)
stds = data.std(axis=0) # Shape: (5,)

# Broadcasting handles the shape differences automatically

normalized = (data - means) / stds # Shape: (1000, 5)

This is both more readable and efficient than explicit loops.

7. Conditional operations on arrays

# Replace outliers with median values

arr = np.array([1, 2, 100, 3, 4, 200, 5])
median = np.median(arr)
threshold = 10

# Create a boolean mask and apply conditional replacement

mask = arr > threshold
arr[mask] = median

# Result: [1, 2, 3, 3, 4, 3, 5]

Boolean indexing makes complex operations concise and efficient.

📊
🐍 Day 6 - Python Interview Prep 3
 📊 Performance Optimization (Questions 8-9)
8. Fast unique value counting
When performance matters, consider alternatives to pandas' value_counts() :

from collections import Counter

# On large datasets, this can be faster

counts = Counter(df['category'])

# Need it as a DataFrame? Convert afterward

count_df = pd.DataFrame(counts.items(), columns=['category', 'count'])

Counter avoids pandas overhead for simple counting tasks.

9. Generators vs Lists

# Memory-hungry approach
def process_large_file(filename):
results = []
with open(filename) as f:
for line in f:
results.append(process_line(line))
return results # Returns everything at once

# Memory-efficient approach
def process_large_file(filename):
with open(filename) as f:
for line in f:
yield process_line(line) # Returns one at a time

Generators are crucial for handling data that doesn't fit in memory.

🧹 Clean Code Practices (Questions 10-12)

10. Profiling slow Python code
Know these tools to identify bottlenecks:

# Quick timing benchmark

%timeit expensive_function(data) # In Jupyter/IPython

# Line-by-line profiling
from line_profiler import LineProfiler
profile = LineProfiler(expensive_function)

🐍 Day 6 - Python Interview Prep 4

 profile.run('expensive_function(data)')
profile.print_stats()

# Memory usage
from memory_profiler import profile
@profile
def memory_hungry_function():
# ...

Showing proficiency with these tools demonstrates engineering maturity.

11. Eliminating magic numbers

Magic numbers make code hard to understand and maintain:

# Confusing code
if user_score > 750:
approve_loan()

# Self-documenting code
CREDIT_SCORE_THRESHOLD = 750
if user_score > CREDIT_SCORE_THRESHOLD:
approve_loan()

Using named constants makes code more readable and maintainable.

12. Function readability best practices

# Hard to understand
def p(d, t, r=0.05):
return d * (1 + r) ** t

# Clear and maintainable

def calculate_compound_interest(principal, time_periods, rate=0.05):
"""Calculate compound interest over time.

Args:
principal: Initial deposit amount
time_periods: Number of time periods
rate: Interest rate per period (default: 0.05)

Returns:
float: Final amount after compound interest
"""
return principal * (1 + rate) ** time_periods

🐍 Day 6 - Python Interview Prep 5

 Well-designed functions are self-documenting and future-proof.

💻 Bonus: Advanced Case Study

User Activity Analysis Challenge (LeetCode - Hard)
Question:
You are given a DataFrame user_activity with columns:

user_id

activity_date

Write a query to count daily active users (DAU) for each of the last 30 days.
Clarifying Questions (and Why They Matter):

1. What defines the "last 30 days" period? Does it include today?

→ Why it matters: This affects your date window calculation. Off-by-one errors here can
lead to missing or extra days in your analysis, potentially misrepresenting user trends.

2. Should we include days with zero active users in the output?

→ Why it matters: Product teams often need to see continuous date ranges, even on days
with no activity. This affects how we structure our solution to ensure completeness.

Optimal Solution:

from datetime import timedelta

# Define the date range

end_date = user_activity['activity_date'].max()
start_date = end_date - timedelta(days=29) # 30 days including end_date

# Filter to relevant time period

recent_activity = user_activity[
(user_activity['activity_date'] >= start_date) &
(user_activity['activity_date'] <= end_date)
]

# Count unique users per day

daily_active_users = (
recent_activity.groupby(recent_activity['activity_date'].dt.date)['user_id']
.nunique()
.reset_index(name='active_users')
)

# Ensure all 30 days are represented (including zero-activity days)

all_dates = pd.DataFrame({
'activity_date': pd.date_range(start=start_date, end=end_date)

🐍 Day 6 - Python Interview Prep 6

 })

complete_dau = (
all_dates
.merge(daily_active_users, left_on='activity_date', right_on='activity_date', how='left')
.fillna(0)
)

# Convert to integer type for counts

complete_dau['active_users'] = complete_dau['active_users'].astype(int)

Thought Process:

1. First, determine exact date boundaries for "last 30 days"

2. Filter data to reduce processing on potentially large tables

3. Use .groupby() with .nunique() to count distinct users per day

4. Create a continuous date range to ensure all days are represented

5. Merge to include days with zero activity

6. Ensure proper data types for the final output

Business Impact:

1. Product Decision Making - DAU is a critical north star metric that drives product
decisions. Accurate daily user counts help identify engagement trends, measure feature
impact, and detect potential issues before they affect retention.

2. Anomaly Detection - A complete DAU series allows for quick identification of unexpected
drops or spikes, enabling teams to respond rapidly to technical issues or user behavior
changes that might require intervention.

Optional Tip:

For massive datasets (billions of rows), consider:

# Pre-filter data by date in chunks before loading

import dask.dataframe as dd

# Convert to categorical type to reduce memory usage

ddf = dd.read_csv('huge_activity_log.csv', parse_dates=['activity_date'])
ddf['user_id'] = ddf['user_id'].astype('category')

# Process in parallel across dates

result = ddf[(ddf['activity_date'] >= start_date) &
(ddf['activity_date'] <= end_date)].groupby('activity_date')['user_id'].nunique().co
mpute()

🐍 Day 6 - Python Interview Prep 7

 This approach scales to terabytes of data by leveraging parallel processing and memory
optimization.

🚫 Common Python Mistakes to Avoid in Interviews

Here are some pitfalls that trip up even experienced candidates during Python interview
rounds:

Using .iterrows() for everything:

Interviewers see this as a red flag. It signals you're not leveraging pandas efficiently.

Forgetting to handle null values in filters or calculations:

Always think about NaN behavior when writing conditions or aggregations.

Writing long, cryptic one-liners:

Brevity is not clarity. Readable code beats clever code—especially in interviews.

Not explaining trade-offs:

Even if your code is correct, failing to mention performance, scalability, or readability can
cost you points.

Skipping docstrings or comments in functions:

Clean code shows that you care about maintainability and understand software
engineering best practices.

Avoiding these can give you an edge over others with similar technical skills.

👉 What’s Next?
Get your hands dirty with more prep on Dataford Python interview questions here.

If today’s deep dive on Python helped you level up your prep…

You’re going to love Day 7.

🐍 Day 6 - Python Interview Prep 8

 We’re shifting gears to tackle one of the most important (and underrated) parts of the data
analyst interview:

🧠 Case Study-style Interview Questions

You'll learn:

How to break down ambiguous business questions

What interviewers look for beyond just SQL or Python

Tips to structure your thought process, show impact, and stand out

📬 Stay tuned — Day 6 lands in your inbox tomorrow!

All the best,

Sai & Amney.

🐍 Day 6 - Python Interview Prep 9