Top Python Topics for Data Science Interviews

Python is the default language of modern data science—and interviewers know it. In most data science and ML interviews, your Python fluency is evaluated implicitly: how you explore data, implement models, debug, and reason about performance. This guide walks through the top Python topics for data science interviews, with concrete examples, common pitfalls, and what “good” looks like in code.

We’ll focus on the Python skills that actually show up in interviews, not an exhaustive language tour. If you’re preparing for data science or ML interviews and wondering where to focus your Python practice, this is the roadmap.

1. Core Python Fundamentals for Data Science Interviews

Even for experienced data scientists, many interview bugs come from basic Python misunderstandings: mutability, scoping, iteration, and data structures. Interviewers often start here before moving into libraries and modeling.

1.1 Data Types and Data Structures

You should be comfortable with:

list, tuple, set, dict
When to use each
Time complexity of common operations (at least at a high level)

PYTHON
# Lists: ordered, mutable
nums = [1, 2, 3]
nums.append(4)        # O(1) amortized
nums[1] = 20          # O(1) indexing

# Tuples: ordered, immutable
point = (10, 20)

# Sets: unordered, unique elements, fast membership tests
ids = {101, 102, 103}
if 101 in ids:        # O(1) average
    ...

# Dicts: key-value mapping
user = {"id": 1, "name": "Alice"}
user["email"] = "a@example.com"  # O(1) average

Interview-style question:
“You have a list of user IDs with duplicates. Return the list of unique IDs while preserving original order.”

PYTHON
def unique_preserve_order(ids):
    seen = set()
    result = []
    for uid in ids:
        if uid not in seen:
            seen.add(uid)
            result.append(uid)
    return result

Be ready to explain why a set alone is not enough (it loses order) and why this is O(n) time, O(n) extra space.

1.2 Mutability, Aliasing, and Copying

Bugs in data pipelines often come from unintended mutation.

PYTHON
a = [1, 2, 3]
b = a        # both point to the same list
b.append(4)
print(a)     # [1, 2, 3, 4]

You should know:

list.copy() or a[:] for shallow copies
copy.deepcopy() for nested structures
That list * n duplicates references, not nested lists

PYTHON
# Pitfall: list multiplication with mutables
grid = [[0] * 3] * 2
grid[0][0] = 1
print(grid)  # [[1, 0, 0], [1, 0, 0]]  <-- both rows changed

# Correct
grid = [[0] * 3 for _ in range(2)]

2. Control Flow, Functions, and Pythonic Style

Interviewers watch for code that is not just correct, but idiomatic and maintainable.

2.1 Functions, Arguments, and Scoping

You should understand:

Positional vs keyword arguments
Default arguments (and the mutable default trap)
Local vs global scope and closures

PYTHON
# BAD: mutable default argument
def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]  <-- shared state

# GOOD
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

Expect questions like: “Explain what’s wrong with this function and how you’d fix it.”

2.2 Comprehensions and Generators

Pythonic data science code leans heavily on comprehensions and generator expressions.

PYTHON
# List comprehension
squares = [x * x for x in range(10)]

# Dict comprehension
name_to_len = {name: len(name) for name in ["alice", "bob"]}

# Generator expression (lazy)
squares_gen = (x * x for x in range(10))

Use generators when processing large data streams or logs to avoid loading everything into memory.

PYTHON
def read_large_file(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

3. Strings, Dates, and File I/O

Data rarely arrives as clean DataFrames. You’ll often need to parse logs, CSVs, or JSON by hand in interviews.

3.1 String Manipulation

Common operations:

Splitting and joining
Stripping whitespace
Basic pattern checks

PYTHON
line = " user_id=123, event=click "
clean = line.strip()
parts = [p.strip() for p in clean.split(",")]
parsed = dict(p.split("=") for p in parts)
# {'user_id': '123', 'event': 'click'}

You should also know in, startswith, endswith, and basic re usage for simple patterns.

3.2 Working with Dates and Times

Interviews often include time-series or log questions.

PYTHON
from datetime import datetime, timedelta

ts = "2024-01-01 12:30:45"
dt = datetime.strptime(ts, "%Y-%m-%d %H:%M:%S")
next_hour = dt + timedelta(hours=1)
print(next_hour.isoformat())

Be ready to:

Parse timestamps from strings
Compute differences ((dt2 - dt1).total_seconds())
Round or truncate to day/hour

4. Object-Oriented Python in Data Science Context

You don’t need to design large systems, but you should understand classes well enough to:

Wrap preprocessing logic
Implement simple model-like APIs
Understand how scikit-learn estimators are structured

PYTHON
class StandardScaler:
    def __init__(self):
        self.mean_ = None
        self.std_ = None

    def fit(self, X):
        # X: list of numbers for simplicity
        n = len(X)
        self.mean_ = sum(X) / n
        variance = sum((x - self.mean_) ** 2 for x in X) / n
        self.std_ = variance ** 0.5

    def transform(self, X):
        if self.mean_ is None or self.std_ is None:
            raise ValueError("Call fit() before transform()")
        return [(x - self.mean_) / self.std_ for x in X]

    def fit_transform(self, X):
        self.fit(X)
        return self.transform(X)

This pattern mirrors scikit-learn’s fit / transform / fit_transform interface, which interviewers often expect you to recognize and use.

5. NumPy: The Foundation of Numerical Python

For ML interview prep, NumPy is non-negotiable. Many “Python interview questions” for data science are really NumPy questions.

5.1 Arrays, Shapes, and Broadcasting

You should be fluent with:

Creating arrays
Understanding shapes and ranks
Broadcasting rules

PYTHON
import numpy as np

a = np.array([1, 2, 3])        # shape (3,)
b = np.array([[1], [2], [3]])  # shape (3, 1)

# Broadcasting: (3, 1) + (3,) -> (3, 3)
c = b + a

Common operations:

PYTHON
X = np.random.randn(100, 3)  # 100 samples, 3 features

means = X.mean(axis=0)       # feature-wise mean, shape (3,)
stds = X.std(axis=0)         # feature-wise std, shape (3,)

X_norm = (X - means) / stds  # broadcasting

NumPy Broadcasting for Feature Normalization

You should be able to explain what happens when shapes don’t align and how to debug shape errors.

5.2 Vectorization vs Loops

A classic interview pattern: “Implement this in NumPy without explicit Python loops.”

Example: Euclidean distance between rows of two matrices.

PYTHON
# X: (n_samples, n_features)
# Y: (m_samples, n_features)
def pairwise_distances(X, Y):
    # (n, 1, d) - (1, m, d) -> (n, m, d)
    diff = X[:, None, :] - Y[None, :, :]
    # sum over features axis
    return np.sqrt(np.sum(diff ** 2, axis=2))

Discuss why this is faster than nested Python loops:

Computation in C
Better cache locality
Fewer Python-level operations

5.3 Linear Algebra Essentials

At minimum:

Matrix multiplication: A @ B
Transpose: A.T
Inverse and pseudo-inverse: np.linalg.inv, np.linalg.pinv
Solving linear systems: np.linalg.solve

For a simple linear regression solution:

PYTHON
def linear_regression_closed_form(X, y):
    # X: (n, d), y: (n,)
    # Add bias term
    X_bias = np.c_[np.ones(len(X)), X]  # shape (n, d+1)
    # w = (X^T X)^(-1) X^T y
    XtX = X_bias.T @ X_bias
    Xty = X_bias.T @ y
    w = np.linalg.solve(XtX, Xty)
    return w  # weights including bias

6. Pandas: Data Manipulation and Analysis

For data science Python topics, Pandas is where most interview time is spent. You should be comfortable doing 80–90% of typical data wrangling tasks.

6.1 Core Objects: Series and DataFrame

Basic creation and inspection:

PYTHON
import pandas as pd

df = pd.DataFrame({
    "user_id": [1, 2, 3, 4],
    "country": ["US", "US", "FR", "IN"],
    "revenue": [10.0, 20.0, 15.0, None],
})

df.head()
df.info()
df.describe()

Know the difference between:

df["col"] (Series) vs df[["col"]] (DataFrame)
df.loc[row_label, col_label] vs df.iloc[row_index, col_index]

6.2 Filtering, Sorting, and Selecting

Example: “Find top 3 countries by average revenue, excluding missing values.”

PYTHON
top_countries = (
    df.dropna(subset=["revenue"])
      .groupby("country")["revenue"]
      .mean()
      .sort_values(ascending=False)
      .head(3)
)

Be able to chain operations clearly and explain each step.

6.3 GroupBy and Aggregations

This is one of the most asked Python for data science interview topics.

PYTHON
# Daily active users and revenue per country
daily_metrics = (
    events_df
    .groupby(["date", "country"])
    .agg(
        dau=("user_id", "nunique"),
        revenue=("revenue", "sum"),
        events=("event_id", "count"),
    )
    .reset_index()
)

Understand:

Why nunique vs count
How to rename aggregated columns
The difference between groupby().agg() vs groupby().apply()

6.4 Joins and Merging

Example: “Join user attributes with daily metrics.”

PYTHON
metrics_with_country = daily_metrics.merge(
    users_df[["user_id", "country"]],
    on="user_id",
    how="left",
)

You should be comfortable with:

how types: inner, left, right, outer
Handling duplicate keys and suffixes: suffixes=("_left", "_right")

Pandas Join Types Overview

7. Python for Machine Learning Interviews

Once you’re comfortable with NumPy and Pandas, interviews often move to scikit-learn and model implementation basics.

7.1 scikit-learn API and Pipelines

You should know the standard estimator pattern:

model = Estimator(params...)
model.fit(X_train, y_train)
model.predict(X_test)

Example: Logistic regression with a preprocessing pipeline.

PYTHON
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

clf = Pipeline([
    ("scaler", StandardScaler()),
    ("logreg", LogisticRegression())
])

clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

Be able to explain:

Why scaling is important for some models
How Pipeline ensures identical preprocessing at train and test time
Where you would insert feature engineering steps

7.2 Basic Model Implementation from Scratch

Some ML interview prep includes coding simple models in pure Python/NumPy.

Example: Binary logistic regression with gradient descent (conceptual-level implementation):

PYTHON
import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

class LogisticRegressionGD:
    def __init__(self, lr=0.1, n_iters=1000):
        self.lr = lr
        self.n_iters = n_iters
        self.w = None
        self.b = 0.0

    def fit(self, X, y):
        n, d = X.shape
        self.w = np.zeros(d)
        for _ in range(self.n_iters):
            # predictions
            z = X @ self.w + self.b
            y_pred = sigmoid(z)
            # gradients
            error = y_pred - y
            grad_w = (X.T @ error) / n
            grad_b = error.mean()
            # update
            self.w -= self.lr * grad_w
            self.b -= self.lr * grad_b

    def predict_proba(self, X):
        return sigmoid(X @ self.w + self.b)

    def predict(self, X, threshold=0.5):
        return (self.predict_proba(X) >= threshold).astype(int)

You don’t need to derive gradients in every interview, but you should:

Recognize the pattern: forward pass → loss → gradient → update
Understand the shapes of X, w, y
Be able to debug broadcasting or shape misalignment

8. Performance, Memory, and Scaling in Python

Senior-level interviews often probe whether you understand performance tradeoffs.

8.1 Time Complexity and Big-O Intuition

You don’t need to memorize every detail, but you should know:

list.append is O(1) amortized
x in list is O(n) vs x in set is O(1) average
dict operations are O(1) average
Sorting is O(n log n)

If you’re preparing more algorithmic questions, pattern-based resources like Thita’s DSA patterns roadmap can help, but for data science interviews the focus is usually on collections and loops.

8.2 Efficient Data Processing

Common patterns:

Use itertools for streaming
Use chunk processing for large files
Avoid apply in Pandas when vectorization is possible

PYTHON
# Inefficient
df["log_revenue"] = df["revenue"].apply(lambda x: np.log1p(x))

# Better
df["log_revenue"] = np.log1p(df["revenue"])

For large CSVs:

PYTHON
chunks = []
for chunk in pd.read_csv("events.csv", chunksize=100_000):
    agg = (
        chunk.groupby("country")["revenue"]
             .sum()
             .reset_index()
    )
    chunks.append(agg)

result = pd.concat(chunks).groupby("country")["revenue"].sum().reset_index()

9. Testing, Debugging, and Reproducibility

Interviewers often infer your engineering maturity from how you test and debug.

9.1 Basic Testing Patterns

You don’t need full pytest fluency, but you should:

Write small sanity checks
Compare expected vs actual outputs
Use assertions

PYTHON
def normalize(arr):
    arr = np.asarray(arr)
    return (arr - arr.mean()) / arr.std()

# Simple test
x = np.array([1, 2, 3])
z = normalize(x)
assert abs(z.mean()) < 1e-8
assert abs(z.std() - 1) < 1e-8

9.2 Debugging with Print and Shape Checks

In interviews, you won’t have a full IDE. Rely on:

Printing shapes: print(X.shape)
Inspecting head of DataFrames: print(df.head())
Checking dtypes: print(df.dtypes)

Debugging with Shape Checks

10. Common Python Mistakes in Data Science Interviews

Interviewers see the same issues repeatedly. Avoiding these is an easy way to stand out.

10.1 Using `apply` Everywhere

apply is convenient but often slower and less readable than vectorized operations.

Prefer built-in string methods: df["col"].str.lower()
Prefer NumPy ufuncs: np.log1p(df["revenue"])
Use map or replace for simple value mappings

10.2 Ignoring Copy vs View in Pandas

This often shows up as SettingWithCopyWarning.

PYTHON
# Potentially problematic
subset = df[df["country"] == "US"]
subset["revenue"] = subset["revenue"].fillna(0)  # may or may not modify df

# Safer
subset = df.loc[df["country"] == "US"].copy()
subset["revenue"] = subset["revenue"].fillna(0)

Explain that .copy() creates an explicit copy, making behavior predictable.

10.3 Overusing Global State

In interview code:

Avoid relying on global variables
Pass data explicitly to functions
Make functions pure where possible (no side effects)

This makes your reasoning clearer and your code easier to test.

11. Best Practices for Python in Data Science Interviews

11.1 Write Clean, Readable Code

Use meaningful variable names: user_id, revenue_per_day
Break long expressions into intermediate variables
Add short comments for non-obvious logic

PYTHON
# Compute 7-day rolling average revenue per user
df_sorted = df.sort_values(["user_id", "date"])
df_sorted["rev_7d"] = (
    df_sorted.groupby("user_id")["revenue"]
             .transform(lambda s: s.rolling(window=7, min_periods=1).mean())
)

11.2 Communicate While Coding

Interviewers evaluate how you:

Choose data structures
Trade off simplicity vs performance
Handle edge cases (empty data, missing values, outliers)

Explain your choices:

“I’m using a dict here because we need O(1) lookups by user_id.”
“I’ll filter out rows with missing revenue before computing the mean.”

If you want structured practice on this kind of communication, an AI mock interviewer like Thita’s AI interview simulator can simulate the pressure and format of real interviews.

11.3 Handle Edge Cases Explicitly

Empty inputs
All-NaN columns
Single-row or single-column arrays
Non-unique keys in joins

Even a single if not len(df): return df can demonstrate that you think about robustness.

12. Putting It All Together: A Mini End-to-End Example

Consider a common interview-style task:

You’re given a CSV of user events with columns: user_id, timestamp, event_type, revenue. Compute, for each country, the average 7-day rolling revenue per active user.

Assume you also have a users.csv with user_id and country.

A structured Python solution uses many of the topics above:

PYTHON
import pandas as pd
import numpy as np

def load_data(events_path, users_path):
    events = pd.read_csv(events_path, parse_dates=["timestamp"])
    users = pd.read_csv(users_path)
    return events, users

def preprocess_events(events, users):
    # Join country information
    events = events.merge(users[["user_id", "country"]], on="user_id", how="left")

    # Filter to revenue events only
    events = events[events["revenue"].notna()].copy()

    # Normalize timestamp to date
    events["date"] = events["timestamp"].dt.date

    return events

def compute_rolling_metrics(events):
    # Daily revenue per user
    daily = (
        events.groupby(["user_id", "country", "date"])["revenue"]
              .sum()
              .reset_index()
    )

    # Sort for rolling
    daily = daily.sort_values(["user_id", "date"])

    # 7-day rolling revenue per user
    daily["rev_7d"] = (
        daily.groupby("user_id")["revenue"]
             .transform(lambda s: s.rolling(window=7, min_periods=1).sum())
    )

    # Aggregate to country-level average per active user
    country_daily = (
        daily.groupby(["country", "date"])
             .agg(
                 active_users=("user_id", "nunique"),
                 total_rev_7d=("rev_7d", "sum"),
             )
             .reset_index()
    )

    country_daily["avg_rev_7d_per_user"] = (
        country_daily["total_rev_7d"] / country_daily["active_users"]
    )

    return country_daily

def main(events_path, users_path):
    events, users = load_data(events_path, users_path)
    events = preprocess_events(events, users)
    metrics = compute_rolling_metrics(events)
    return metrics

This snippet exercises:

File I/O
Date parsing
Merging
GroupBy and rolling windows
Clean function design

In an interview, you’d walk through each step and justify choices (e.g., nunique vs count, min_periods=1, left join).

Key Takeaways

Python for data science interviews is less about obscure language features and more about clean, correct, and efficient use of NumPy, Pandas, and scikit-learn.
Master the fundamentals: data structures, mutability, comprehensions, and basic I/O. Many bugs originate here.
Be fluent with NumPy shapes, broadcasting, and vectorization. Avoid Python loops for numerical code where possible.
In Pandas, focus on groupby, joins, filtering, and time-based operations. These are the workhorses of real-world data tasks.
Write code that’s readable, testable, and robust. Explain your decisions aloud during interviews.

If you systematically practice these Python topics with realistic interview-style problems and timed sessions, your data science and ML interview prep will be significantly more effective. For a comprehensive overview, consider following the Complete Data Science Roadmap 2026: Master 72 Essential Topics Across 12 Core Patterns.