Stop rebuilding the same report by hand.

1 Series vs. DataFrame

A Series is one labeled column of data. A DataFrame is a full table — many Series sharing the same row index. jobs["Price"] hands you back a Series; jobs itself is the DataFrame.

2 Reading data in

import pandas as pd

jobs = pd.read_csv("jobs.csv")

One line replaces "open the file, find the delimiter, guess the header row" — pandas handles all of it and hands you a DataFrame.

3 First look: head(), info(), dtypes

jobs.head()    # first 5 rows — a quick sanity check
jobs.info()    # row count, columns, non-null counts, dtypes
jobs.dtypes    # just the column types

Three commands, thirty seconds, and you already know how many rows you have, which columns might have missing values, and whether anything got loaded as the wrong type.

1 Finding and handling missing values

jobs["JobType"].isna()          # True/False mask of missing cells
jobs.dropna(subset=["JobType"]) # remove rows with a missing JobType
jobs.fillna({"Notes": "None"})  # or fill missing values instead

isna() never changes your data — it just tells you where the gaps are, so you can decide: drop the row, or fill it with something sensible.

2 Fixing types

jobs["Price"] = jobs["Price"].str.replace("$", "").astype(float)

A stray "$" in a CSV export turns a numeric column into text. Strip it, then astype() converts it back into something you can actually do math on.

3 Cleaning text columns

jobs["JobType"] = jobs["JobType"].str.strip().str.title()
jobs = jobs[jobs["JobType"] != ""]

.str.strip() removes stray whitespace, .str.title() normalises capitalisation, and a boolean filter drops blank rows — the pandas equivalent of Power Query's Applied Steps.

1 The basic pattern

jobs.groupby("JobType")["Price"].sum()

Split the table into buckets by JobType, then sum Price within each bucket. Swap .sum() for .mean(), .count(), or .median() for a different summary of the same groups.

2 Multiple aggregations at once

jobs.groupby("JobType").agg(
    TotalRevenue=("Price", "sum"),
    AvgMargin=("Margin", "mean"),
    JobCount=("JobID", "count"),
)

.agg() with named arguments computes several summaries in one pass and hands back clearly labeled columns — the exact shape of a report table.

3 Combining tables with merge()

jobs_with_city = pd.merge(jobs, customers, on="CustomerID")
jobs_with_city.groupby("City")["Price"].sum()

merge() is pandas' join — line up rows from two tables on a shared key, same idea as a SQL JOIN or a Power BI relationship, so you can group Jobs by a Customer attribute like City.

1 Vectorized operations

import numpy as np

prices = jobs["Price"].to_numpy()
prices_with_tax = prices * 1.08   # applied to every element at once

NumPy applies math to a whole array in one step instead of a manual loop — the engine pandas itself is built on, and dramatically faster on large data.

2 describe() — the five-second summary

jobs["Price"].describe()

One call returns count, mean, standard deviation, min, the quartiles, and max — the fastest way to understand a column's spread before you chart it.

3 Correlation

jobs["Price"].corr(jobs["Cost"])

A single number from -1 to 1 summarising how strongly two numeric columns move together. Useful for spotting relationships — but correlation never proves one causes the other.

1 Choosing the right chart

Comparing separate categories → bar chart. A trend over time → line chart. The relationship between two numeric columns → scatter plot. Matching the chart to the question is the actual skill — matplotlib syntax is just the mechanics.

2 matplotlib basics

import matplotlib.pyplot as plt

plt.bar(jobs_by_type.index, jobs_by_type["Price"])
plt.title("Revenue by Job Type")
plt.xlabel("Job Type"); plt.ylabel("Revenue")
plt.show()

Build the chart, label the axes, give it a title, then show it. Skipping the labels is how a perfectly good chart becomes unreadable to anyone but you.

3 seaborn: matplotlib with better defaults

import seaborn as sns

sns.scatterplot(data=jobs, x="Cost", y="Price", hue="Status")

seaborn is built directly on top of matplotlib — same engine, nicer default styling, and higher-level statistical chart types like this one, which colours points by an extra category for free.

1 Packaging the routine into a function

def summarise_jobs(csv_path):
    jobs = pd.read_csv(csv_path)
    jobs = clean_jobs(jobs)
    jobs["Margin"] = jobs["Price"] - jobs["Cost"]
    return jobs.groupby("JobType").agg(
        TotalRevenue=("Price", "sum"),
        AvgMargin=("Margin", "mean"),
        JobCount=("JobID", "count"),
    ).sort_values("TotalRevenue", ascending=False)

Every step from Modules 1-3, in one callable function. Run it on any month's export and get the same trustworthy summary, instantly.

2 Exporting the result

summary = summarise_jobs("march.csv")
summary.to_excel("march_report.xlsx")

.to_excel() writes the DataFrame straight to a real file — the step that turns a script's output into something you can actually email to someone.

3 Running it as a script

if __name__ == "__main__":
    summarise_jobs("jobs.csv").to_excel("report.xlsx")
    print("Report generated.")

This guard keeps reusable functions reusable — the file can be imported elsewhere without re-running itself, or run directly to generate a report on demand (or on a schedule, via cron or Task Scheduler).