Core Concepts of Python for Analytics

The Big Picture

These five tools form a layered stack. Jupyter is the workspace, NumPy is the math engine, Pandas handles data, and Matplotlib/Seaborn turn it into visuals.

1. Jupyter Notebooks — Your Workspace

Jupyter is where you do all your analysis work. It runs in your browser and organizes your work into cells — each cell is either code (Python) or text (Markdown). Run a cell and the output appears right below it.

Why it matters: Jupyter lets you explore data interactively. You write a bit of code, see the result, tweak it, and keep going. No need to run an entire script from top to bottom — just run one cell at a time.

Key features:

• Code cells — Write and execute Python. Output (tables, charts, numbers) renders inline.
• Markdown cells — Add headings, explanations, links, and formatted notes alongside your code.
• Inline charts — Matplotlib and Seaborn plots render directly below the cell that creates them.
• Rich output — DataFrames display as formatted HTML tables with scrolling.

Essential keyboard shortcuts:

# Install Jupyter (one time)
pip install jupyterlab

# Launch it
jupyter lab

# In a cell, type and press Shift+Enter:
print("Hello, analytics!")

2. NumPy — The Math Engine

NumPy (Numerical Python) is the foundation under Pandas, Matplotlib, and most of the Python data science ecosystem. Its killer feature is the ndarray — a fast, memory-efficient array that supports vectorized operations.

Why it matters: Python loops are slow. NumPy replaces them with C-compiled, vectorized operations that run 10-100x faster. When Pandas calculates a column mean or filters rows, it's using NumPy under the hood.

Core operations:

import numpy as np

# Create arrays
arr = np.array([10, 20, 30, 40, 50])
zeros = np.zeros(5)          # [0, 0, 0, 0, 0]
ones = np.ones((3, 3))       # 3x3 matrix of 1s
rng = np.arange(0, 100, 10)  # [0, 10, 20, ..., 90]

# Vectorized math (no loops needed)
arr * 2         # [20, 40, 60, 80, 100]
arr + 10        # [20, 30, 40, 50, 60]
np.sqrt(arr)    # square root of each element

# Statistics
np.mean(arr)    # 30.0
np.std(arr)     # 14.14
np.median(arr)  # 30.0
np.min(arr)     # 10
np.max(arr)     # 50

# Conditional selection
np.where(arr > 25, "high", "low")
# ['low', 'low', 'high', 'high', 'high']

Why NumPy is 100x faster than Python loops:

• Contiguous memory — NumPy arrays are stored as a single block of memory (like a C array), not scattered Python objects.
• Vectorized operations — Operations like arr * 2 are compiled C code that processes the entire array at once, with no Python loop overhead.
• Broadcasting — NumPy automatically handles operations between arrays of different shapes (e.g., multiplying a 1D array by a scalar, or adding a row vector to every row of a matrix).

3. Pandas — The Star of the Show

Pandas is the heart of Python data analytics. It gives you two data structures: Series (a single column) and DataFrame (a table of rows and columns — like a spreadsheet or SQL table). If you learn one thing from this page, learn the DataFrame.

Series vs DataFrame:

• Series — A one-dimensional labeled array. Think of it as a single column in a spreadsheet. Has an index (row labels) and values.
• DataFrame — A two-dimensional table. Collection of Series sharing the same index. This is what you'll use 95% of the time.

Reading data:

import pandas as pd

# From CSV (most common)
df = pd.read_csv("claims.csv")

# From Excel
df = pd.read_excel("report.xlsx", sheet_name="Sheet1")

# From SQL database
import sqlite3
conn = sqlite3.connect("analytics.db")
df = pd.read_sql("SELECT * FROM claims", conn)

# Quick look at the data
df.head()        # First 5 rows
df.shape         # (rows, columns)
df.dtypes        # Column data types
df.describe()    # Summary statistics
df.info()        # Memory usage + column info

Selecting and filtering:

# Select columns
df["amount"]                     # Single column (Series)
df[["payer", "amount"]]          # Multiple columns (DataFrame)

# Select rows by position
df.iloc[0]                       # First row
df.iloc[0:5]                     # First 5 rows

# Select rows by label
df.loc[df["payer"] == "Aetna"]   # All Aetna rows

# Filter with conditions
df.query("amount > 1000")
df[df["amount"] > 1000]          # Same result, different syntax
df.query("payer == 'Aetna' and amount > 500")

Grouping and aggregating:

# Group by one column, calculate mean
df.groupby("payer")["amount"].mean()

# Group by multiple columns, multiple aggregations
df.groupby(["payer", "state"]).agg(
    total_amount=("amount", "sum"),
    claim_count=("claim_id", "count"),
    avg_amount=("amount", "mean")
).reset_index()

Merging and joining:

# Inner join (like SQL INNER JOIN)
merged = pd.merge(claims, members, on="member_id")

# Left join (keep all rows from left table)
merged = pd.merge(claims, members, on="member_id", how="left")

# Join on different column names
merged = pd.merge(claims, providers,
                  left_on="npi", right_on="provider_npi")

Handling missing data (NaN):

# Check for missing values
df.isnull().sum()           # Count NaN per column

# Drop rows with any NaN
df.dropna()

# Fill NaN with a value
df["amount"].fillna(0)

# Fill NaN with the column mean
df["amount"].fillna(df["amount"].mean())

4. Matplotlib — The Charting Foundation

Matplotlib is Python's original plotting library. It gives you total control over every element of a chart: axes, labels, colors, sizes, grid lines. The API is inspired by MATLAB's plotting commands.

The Figure/Axes model: Every Matplotlib chart has a Figure (the entire canvas) and one or more Axes (individual plots within the figure). Think of Figure as the whiteboard and Axes as the charts drawn on it.

import matplotlib.pyplot as plt

# Simple line chart
plt.plot([1, 2, 3, 4], [10, 20, 25, 30])
plt.xlabel("Quarter")
plt.ylabel("Revenue ($M)")
plt.title("Quarterly Revenue")
plt.show()

# Bar chart
categories = ["Aetna", "Cigna", "UHC", "Humana"]
values = [2300, 1800, 4500, 1200]
plt.bar(categories, values, color="steelblue")
plt.ylabel("Claims Count")
plt.title("Claims by Payer")
plt.show()

# Scatter plot
plt.scatter(df["age"], df["amount"], alpha=0.5)
plt.xlabel("Patient Age")
plt.ylabel("Claim Amount ($)")
plt.title("Age vs Claim Amount")
plt.show()

Subplots — multiple charts on one figure:

# 1 row, 2 columns
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

ax1.bar(categories, values)
ax1.set_title("Claims by Payer")

ax2.plot([1, 2, 3, 4], [10, 20, 25, 30])
ax2.set_title("Quarterly Trend")

plt.tight_layout()
plt.show()

Labels and formatting:

fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(categories, values, color="steelblue", edgecolor="white")
ax.set_xlabel("Payer", fontsize=12)
ax.set_ylabel("Claims Count", fontsize=12)
ax.set_title("Claims by Payer (2025)", fontsize=14, fontweight="bold")
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
plt.tight_layout()
plt.show()

5. Seaborn — Statistical Visualization

Seaborn is built on top of Matplotlib and designed for statistical visualization. It makes common plot types beautiful by default — better colors, better layouts, and built-in themes. One line of Seaborn code often replaces 10 lines of Matplotlib.

import seaborn as sns

# Histogram (distribution of a single variable)
sns.histplot(df["amount"], bins=30, kde=True)
plt.title("Distribution of Claim Amounts")
plt.show()

# Box plot (compare distributions across groups)
sns.boxplot(x="payer", y="amount", data=df)
plt.title("Claim Amount by Payer")
plt.show()

# Heatmap (correlation matrix)
corr = df[["amount", "age", "los", "charges"]].corr()
sns.heatmap(corr, annot=True, cmap="coolwarm", center=0)
plt.title("Correlation Matrix")
plt.show()

Built-in themes — change the entire look with one line:

# Available styles: darkgrid, whitegrid, dark, white, ticks
sns.set_theme(style="whitegrid")

# Seaborn color palettes
sns.set_palette("husl")        # Vivid colors
sns.set_palette("muted")       # Softer tones
sns.set_palette("coolwarm")    # Diverging (for heatmaps)

When to use Seaborn vs Matplotlib:

• Use Seaborn for statistical plots (histograms, box plots, heatmaps, violin plots, pair plots), exploring data distributions, and quick beautiful charts.
• Use Matplotlib when you need full customization, custom layouts, animations, or chart types Seaborn doesn't offer.
• Mix them freely — Seaborn plots are Matplotlib objects. You can create a Seaborn chart and then customize it with Matplotlib commands.

SQL-to-Pandas Reference

The most common SQL operations and their exact Pandas equivalents. Bookmark this table.