# How This Course Works

How Python for Data Analysis works on ask-codey.com, from reading a lesson and trying its Do It to exercises with a notebook to explore and a module pytest checks, chapter checks, module assessments and the projects you build.

Novice · Python · Updated November 19, 2026

By Gregor Dzierzon

## After this lesson you can

- Describe how this course's lessons, Do Its, Check yourself blocks, exercises, chapter checks, module assessments and projects fit together

## Key takeaways

- The course has five modules. Each one ends with a mini-capstone, a project of its own, and an assessment that passes at 80%, with three tries a day.
- Skills are short "you can do this" statements. They are what the questions test and what your progress counts.
- A wrong answer in Check yourself is useful news, not a failure. Read the explanation, look back at the lesson, and carry on.
- An exercise comes with its own data, a notebook to explore in and a module to finish. pytest checks the module, and the exercise is done when every test passes and you've handed it in.
- Covered counts the lessons you've finished. Mastered counts the skills you've shown you know, with three clean answers to questions that come at each skill from at least two different angles.

This course is self-study: you go at your own pace, and the course itself tells you how you're doing. Here is what it's made of, and how to get the most from each part.

## The shape of the course

| Part | What it is |
|---|---|
| **Module** | A big stage of the course, ending with a project |
| **Chapter** | One subject, such as Getting Started with Data Analysis or Grouping and Summarizing |
| **Topic** | A group of lessons inside a chapter |
| **Lesson** | One idea, explained with small examples you can run |

The five modules, and the project each one ends with:

| Module | What you learn | The project |
|---|---|---|
| 1. Notebooks and Tables | Notebooks, the Python data work uses, and loading files into pandas | Bean Street Coffee: A First Look |
| 2. Cleaning Data | Missing values, wrong types, duplicates, messy text and dates | Clean a Year of Bike Rides |
| 3. Answering Questions | Filtering, sorting, grouping, joining and reshaping tables | Five Questions from the Manager |
| 4. Charts | Line, bar, scatter and histogram charts that stay honest | Library Loans at a Glance |
| 5. A Report Someone Can Use | A notebook that tells a story, a report script, and tests | The Monthly Report That Rebuilds Itself |

Each lesson has a level from 1 to 4: level 1 meets an idea for the first time, and higher levels go deeper.

## Skills, Do Its and Check yourself

Most lessons list their **skills**: short "you can do this" statements, such as *Run a cell in a notebook and tell what it shows*. Skills are what the questions test and what your progress counts.

Some lessons have a **Do it**: a small task in the lesson's own example, solved in a box right on the page, with tests that tick as your code works. Python runs in your browser for it, with its standard library only, so only lessons in plain Python have one; lessons that need pandas or matplotlib are practiced in the chapter's exercise, on your own computer.

A **Check yourself** block near a lesson's end asks one to three short questions, then shows the answer and why. A wrong answer is useful news, not a failure: read the explanation, look back at the lesson, and carry on.

## Exercises

**Exercise:** lessons give you a small analysis to finish. Most are a folder of starter files on GitHub: **its own data**, made by a `seed.py` script that writes the same made-up rows on every computer; **a notebook** to explore in; **a module to finish**, a `.py` file whose functions answer the questions; and **tests**, small programs that call your functions and check what comes back.

You copy it to your computer with Git, open it in VS Code, make its virtual environment (its README shows how), and run the tests in the terminal:

```bash
python -m pytest
```

**pytest** is a **test runner**: it finds the tests in the folder, runs them, and lists which pass and which fail. At first they fail, and that's expected: each function you finish turns its tests green. The tests check the module, because a test can call a function in a `.py` file but not a notebook cell. The first exercise is the exception: its tests read a saved notebook.

When every test passes, you push your work to a repository of your own on GitHub and submit its address on the lesson page, which completes the lesson. *Get the Exercise Code with Git* and *Hand In Your Work with Git* show each step.

## Checks, assessments and projects

- A **chapter check** is a short quiz on the chapter's skills, with a few from the chapter before. Take it as often as you like: it's practice, and it tells you what to review.
- A **module assessment** ends each module. **80% passes**. You get three tries a day, then a 24-hour rest before the next three. Every attempt draws different questions, so a retake is a fair new try, not a memory test.
- A **mini-capstone** ends each module: a project you build with everything the module taught. It comes with a brief, starter files, milestones that break it into steps, and a short checklist, called a **rubric**, that you score your own work against.
- The **final capstone** is the course's final assessment; there's no big final test. You analyze a dataset you choose, with your own questions, tested answers, charts and a write-up.

## Covered, Mastered, and who gets what

Signed in, the course keeps two separate records of your progress:

- **Covered:** the lessons you've finished.
- **Mastered:** the skills you've shown you know. A skill is mastered when you answer three different questions about it cleanly, meaning right the first time and without a hint, from at least two different angles: one might ask what a cell shows, another which cell to run first. A later miss drops it back, so mastery stays honest.

**Everyone** can read every lesson and answer its questions. **Signed in**, your answers count toward your skills, and you can tick lessons as done. **With Premium, or if you own this course,** you also get course progress on every page, the chapter checks, the module assessments, and the **Certificate of Completion**: every lesson covered and every module assessment passed.

A good rhythm: read a lesson and run its examples, answer Check yourself, do the chapter's exercise and its check, and when a module's skills are mastered, take its assessment and build its project.

## Check yourself

1 question to try on the lesson page.

## So what

The course is built so you always know where you stand: what you've read, what you've mastered, what to practice next, and what you've built.

## Key terms

- [pytest](https://www.ask-codey.com/glossary/pytest)
- [Test Runner](https://www.ask-codey.com/glossary/test-runner)

Source: https://www.ask-codey.com/lessons/data-how-this-course-works
