Why this course exists
Most people learn pandas as a pile of disconnected tricks - a groupby here, a plot there - and never feel like an analyst. This course fixes that with one real, messy dataset and one real question: what does the data job market actually look like? You'll load it, clean it, interrogate it, chart it, and by Session 8 ship a report you'd be proud to post. Every method you learn earns its place by moving that project forward. This is the hands-on sequel to learn-python-with-phoebe - if you can write a loop and a function, you're ready.
The data-analysis stack 5 min live
Four libraries do 95% of Python data analysis, and they stack. Understand the stack once and every tutorial you read afterward slots into place.
LiveWhy the stack, not one giant library3 min▶
Each layer does one thing well and hands off to the next. pandas doesn't reinvent fast math - it sits on NumPy. seaborn doesn't redraw pixels - it drives matplotlib. That separation is why the ecosystem moves fast and why your skills transfer: learn the DataFrame once and it works whether you're plotting, modeling, or exporting.
- NumPy is the base: arrays and vectorized math, thousands of times faster than Python loops (Session 2).
- pandas is where you live: labeled tables - the DataFrame - for loading, cleaning, grouping, joining (Sessions 3-5).
- matplotlib + seaborn turn tables into pictures (Sessions 6-7).
- Jupyter is the workbench: you write a line, run it, see the table or chart immediately - the tight feedback loop that makes analysis feel alive.
Ask an analyst what tool they use and they'll say "pandas" - but every pandas session is quietly standing on NumPy, and every chart they paste into a deck came out of matplotlib. Knowing the stack means when something breaks, you know which layer to look at.
Self-studyWhere the profiling libraries fit2 min read▶
Three small libraries save hours by showing you the mess before you touch it - we install them today and lean on them in Session 4:
| Library | What it gives you | Used in |
|---|---|---|
| ydata-profiling | One line -> a full HTML report: every column's distribution, missing %, correlations, warnings | Session 1 first look |
| missingno | Visual maps of missingness - matrix, bar, heatmap - so gaps become patterns you can see | Session 4 cleaning |
| sweetviz | A prettier profile + easy two-dataset comparison | Self-study alternative |
Your workspace, cleanly 5 min live
One isolated environment with everything pinned. Do this once and you never fight version conflicts mid-analysis. We use conda - it handles Python and the scientific packages together.
LiveCreate the environment3 min · then Demo 1▶
An environment is a sealed box of package versions. Naming it after the project (data-analysis) means next month's project gets its own box and nothing collides. If you prefer plain venv and pip, that works too - the package list is the same.
LiveLaunch Jupyter and sanity-check2 min▶
Self-studyNotebook habits that keep you sane2 min read▶
- Run top to bottom before you trust it. Out-of-order cells lie. Restart kernel + Run All is your reality check.
- One idea per cell. Small cells make it obvious which line broke and let you re-run cheaply.
- Keep the raw file untouched. Never overwrite the CSV you downloaded - load it, transform a copy, save outputs under new names. Your ground truth stays clean.
- Markdown cells are free. A one-line note above a block ("parsing salary into a number") turns a notebook into something future-you can read.
The analysis workflow 3 min live
Every real analysis walks the same six steps. This course is those steps, one per session block - so the skill you build is the workflow itself, not just the syntax.
LiveThe step people skip - and pay for2 min▶
Step 2, profile, is the one beginners skip and experts never do. Jumping from load straight to charts means you plot dirty data and draw confident wrong conclusions. Ten minutes profiling saves ten hours of "wait, why is the average salary $2 million?" (answer: three rows had salary in cents, and you never looked).
A classic job-market analysis went viral for claiming a median data-science salary far above reality. The cause: the dataset mixed hourly, monthly, and yearly pay in one column and nobody profiled it. Correct step 2, correct headline. Skip it, mislead thousands.
One dataset, eight sessions 2 min live
The whole course is one build. No toy tables - by Session 8 you've produced a real report on a real labor market, from a dataset with real problems.
LiveThe dataset and the deliverable2 min▶
We use LinkedIn Job Postings (2023-2024) from Kaggle - about 124,000 postings across several linked tables (postings, companies, skills, salaries). It's genuinely messy: roughly 70% of postings have no salary, pay is split across min/max/period columns, job titles are free text, and there are duplicates. That mess is not a bug - it's the curriculum.
- The question: what does the data / analytics / AI job market look like - which roles, which skills, what pay, where?
- The deliverable (Session 8): a tight report - five charts, five findings, and a simple model that predicts salary from role and location - clean enough to post on LinkedIn with your name on it.
Environment + Jupyter, live ★ 8 min · everyone sets up
Run the Part 2 create command. While it resolves (a minute or two), make a project folder: mkdir data-job-market && cd data-job-market.
conda activate data-analysis, then pip install ydata-profiling missingno sweetviz.
jupyter lab - a browser tab opens. New notebook, rename it 01-first-look.ipynb.
Run the Part 2 "prove the stack is alive" cell. Two version numbers, no errors - you're operational.
pip install for everything - fix conda after class. Today's win is the first look, not the plumbing.
Load the data, take the first look ★ 10 min · everyone loads
Download the dataset from Kaggle (kaggle.com/datasets/arshkon/linkedin-job-postings), unzip it into your project folder.
Load the main table and look at its shape and first rows:
Watch what isna().mean() shows: the salary columns light up near 70% missing. You haven't written a cleaning line yet and the data has already told you its biggest problem. That's the whole point of looking first - the dataset briefs you if you let it.
One-line automated profile ★ 4 min · follow along
Let ydata-profiling do in one line what would take an hour by hand:
Scroll the report: distributions, missing-value counts, correlations, and a "Warnings" tab that flags high-cardinality and missing columns for you.
Write one markdown cell: the three things this profile tells me about the data. That note is your cleaning to-do list for Session 4.
This week ◐ 30 min total
- Finish the setup if the session ran short - environment created, Jupyter launching, dataset downloaded. This gates Session 2.
- Load every table in the dataset (not just postings.csv) and run
.shape+.head()on each. Note which tables share an ID column - that's the Session 5 join, previewed. - Generate a full profile (drop
minimal=True, run on the whole frame) and save it as HTML. Read it end to end once. - Write your three observations in a markdown cell. Bring them - Session 4 turns them into cleaning code.
- Optional: skim Kaggle's free "Pandas" micro-course lesson 1 - this session covered its ground, but the exercises are good reps.
Three questions before you go 🎯 ◐ 90 seconds
1 · In the analysis stack, what sits at the base, under pandas?
pandas is built on NumPy arrays. Learn the base and everything above it makes more sense - that's Session 2.
2 · Why profile the data (step 2) before cleaning or charting?
Skip the look and you plot dirty data. Ten minutes profiling saves ten hours of chasing a wrong headline.
3 · What did isna().mean() reveal about the LinkedIn dataset?
The dataset briefs you if you let it. Missing salary is the mess Session 4 tackles head-on.
Official sources covered
This session teaches the working content of the official pandas and NumPy docs, the free Kaggle micro-courses, and Wes McKinney's open-access Python for Data Analysis (3e). Certificates, graded exercises, and videos stay on those platforms - links provided.