Skip to content

study-guide.md

Latest commit

 

History

History
121 lines (79 loc) · 6.95 KB

study-guide.md

File metadata and controls

121 lines (79 loc) · 6.95 KB

Study Guide

How to get the most out of this course.

The Golden Rule

Understand the problem before you write code.

For every exercise, every project milestone, every challenge:

  1. Read the problem. Read it again.
  2. Describe the solution in plain English.
  3. Write pseudocode (structured English, not Python).
  4. Then write Python.

This feels slow at first. It saves enormous amounts of time once problems get complex.

Where to Start

The course is designed to be worked through in order, starting from Part 1. If you are a complete beginner, that is where you should start.

If you already have programming experience, this quick checklist will help you find your entry point.

Can you confidently do all of these in Python?

  • Write a function with parameters and return values
  • Use lists, dictionaries, and loops
  • Read from and write to files
  • Handle exceptions with try/except

If yes, start at Part 3: Building Real Programs -- modules, project structure, Git, testing, and APIs.

Already comfortable with Part 3 topics too? Other entry points:

Whichever part you start at, check the prerequisites listed at the bottom of each part's overview page.

Recommended Pace

This course is designed for self-paced study. There is no deadline. Two realistic approaches:

Steady pace (recommended)

  • Weekdays: 30-45 minutes. Read one module section, do one exercise.
  • Weekends: 60-90 minutes. Work on the part project or tackle challenge exercises.
  • Expected time per module: 2-4 hours across multiple sessions.
  • Expected time per part: 2-4 weeks.
  • Total course: 6-12 months.

Intensive pace

  • Daily: 2-3 hours of focused study.
  • Expected time per part: 1-2 weeks.
  • Total course: 2-4 months.

Both approaches work. Consistency matters more than intensity.

How to Approach a Module

  1. Read the Introduction and Learning Objectives. Know what you are about to learn and why.
  2. Work through the Concepts section. Type every code example into your own editor and run it. Experiment -- change values, break things, see what happens.
  3. Study the Worked Examples. Before reading the solution, try to solve the problem yourself. Even a partial attempt makes the solution more meaningful.
  4. Do the Exercises. Most modules provide starter files (exercise_01.py, exercise_02.py, etc.) in the exercises directory. Read the exercise brief in exercises.md first, then open the matching starter file and implement your solution. Each exercise is labelled by type (function, class, script, test, or design) so you know what kind of work to expect. Start with Practice, move to Challenge, attempt Extension. If you can do Exercises 1-3 comfortably, it is fine to move on -- the Extension exercise is there when you want extra practice.
  5. Verify your work. In early modules, starter files include expected output in the comments -- run your file and compare. In later coding modules, if check.py is present, run pytest check.py -v for automated checks.
  6. Review Key Takeaways. Can you explain each point in your own words? If not, revisit that section.
  7. Check Further Reading if you want to go deeper on any topic.

Once you reach Module 13, keep the standard venv/python -m pip model in mind, but use uv as the recommended day-to-day workflow for adding packages and running project commands.

How to Approach a Project

Projects are broken into milestones. Each milestone produces a working program.

  1. Read the full project brief first. Understand the end goal before starting.
  2. Work through one milestone at a time. Do not skip ahead. Each milestone ends with an "After this milestone" checkpoint that tells you what you should be able to do before continuing.
  3. Plan before coding. Each milestone should start with pseudocode or a written plan. The harder projects include a "First step" suggestion to help you get started without freezing.
  4. Test as you go. After each milestone, run your program and verify it works against the checkpoint.
  5. Compare with the reference solution, where provided, only after completing a milestone, not before.

How to Use Solutions

Every exercise and project milestone has a reference solution. Use them well:

  1. Attempt first. Always try the exercise yourself before looking at the solution. Even a partial attempt makes the solution more meaningful.
  2. Compare structure, not just output. When you read a solution, look at how it is organised -- the function names, the decomposition, the error handling. That teaches judgement, not just correctness.
  3. Close it and re-implement. If you read a solution to get unstuck, close the file and write your own version from memory. Understanding a solution is not the same as being able to write one.
  4. Do not copy-paste solutions. Typing the code yourself builds muscle memory and forces you to process each line.

Common Mistakes to Avoid

Copying code without understanding it. If you cannot explain what a line does, you have not learned it. Type it yourself, then modify it.

Skipping exercises. Reading about programming is not programming. The exercises are where learning actually happens.

Moving on too quickly. If a concept feels shaky, spend another session on it. There is no prize for finishing fast.

Trying to memorise syntax. You do not need to memorise every method on every type. You need to understand concepts well enough to look up the syntax when you need it. That is what documentation and cheatsheets are for.

Comparing yourself to others. Everyone learns at a different pace. The only measure that matters is whether you understand more today than you did yesterday.

Getting Unstuck

When you are stuck on a problem:

  1. Re-read the error message carefully. Python error messages are helpful once you learn to read them.
  2. Simplify. Reduce the problem to the smallest version that still fails.
  3. Print intermediate values. Add print() calls to see what your variables actually contain.
  4. Take a break. Five minutes away from the screen often unsticks you faster than another hour of staring.
  5. Check the hints. Exercises include collapsible hints for a reason.
  6. Read the solution, then close it and try again. Understanding a solution is not the same as being able to write one.

Tools You Will Need

  • Python 3.14+ -- see Prerequisites for installation
  • A text editor -- VS Code is recommended (free, excellent Python support)
  • A terminal -- Command Prompt or PowerShell on Windows, Terminal on macOS/Linux
  • Git -- needed from Part 3 onwards
  • uv -- recommended from Module 13 onward for package management and running project commands