Skip to main content
Learning Center
Python Programming

Python Foundations

A beginner-friendly, original Python course for adults and young adults who want to read, review, modify, and debug Python, especially AI-generated Python, rather than memorize syntax.

Modules
15
Lessons
46
Estimated time
About 20 hours of lessons
Before you start
Beginner friendly. No programming experience needed.

Times are planning estimates from each lesson's stated length, not measured completion times.

Start lesson 1: How Python Programs RunTry the sample exercise: Names and Expressions: Binding, Rebinding, and Order of Operations

Reading and practice are open to everyone. Saving your progress needs an account with access to this course.

What the practice looks like

Python ProgrammingSample from Names and Expressions
base_value = 120000
option_years = 2
option_rate = 0.4

option_value = base_value * option_rate * option_years
ceiling = base_value + option_value

option_rate = 0.6

print(f"Option value: {option_value:,.0f}")
print(f"Ceiling: {ceiling:,.0f}")

What does this print?

Check your prediction
Option value: 96,000
Ceiling: 216,000

Line 8 rebinds option_rate after both values were computed, so neither printed number changes.

Course roadmap

Modules are in the recommended order, and every lesson is open from day one.

  1. Module 0: Orientation, Python with AI

    How Python programs run, the read/predict/modify/run/debug/explain workflow, where each kind of work belongs, and when to reach for ChatGPT versus Claude Code.

    1. How Python Programs RunStart here25 min
    2. The Learning Workflow: Read, Predict, Modify, Run, Debug, Explain20 min
    3. Two Places Python Runs: This Page and Your Machine25 min

  2. Module 1: Values, Variables, and Expressions

    The five value types you meet immediately, how names are bound and rebound, how expressions combine them, and how to turn a record into readable output without changing what it stores.

    1. Values and Types: Text, Numbers, True/False, and Nothing25 min
    2. Names and Expressions: Binding, Rebinding, and Order of Operations25 min
    3. Formatted Output and Untidy Text25 min

  3. Module 2: Decisions and Validation

    Comparisons and boolean logic, branching that stays readable, truthiness traps, and the first explainable matching rule for the opportunity review assistant.

    1. Comparisons and Boolean Logic25 min
    2. Branching That Stays Readable25 min
    3. Explainable Matching Rules30 min

  4. Module 3: Collections and Iteration

    Lists, tuples, dictionaries, and sets, how to choose between them, and how to loop over many opportunity records to produce a shortlist instead of judging one record at a time.

    1. Lists and Tuples: Ordered Data You Can and Cannot Change25 min
    2. Dictionaries and Sets: Addressing Data by Name25 min
    3. Looping Over Records: Filtering, Counting, and the First Shortlist30 min

  5. Module 4: Functions and Program Structure

    Naming a piece of work so it can be called, tested, and replaced: parameters, return values, scope, docstrings, type hints, and the refactor that turns the shortlist script into small explainable parts.

    1. Defining and Calling Functions25 min
    2. Return Values, Scope, and Side Effects25 min
    3. Decomposing the Shortlist Script30 min

  6. Module 5: Errors, Debugging, and Testing

    Reading a traceback for what it actually says, handling the failures worth handling, and writing the tests that stop a repaired bug from coming back.

    1. Reading a Traceback25 min
    2. Exceptions, and the Failures Worth Handling25 min
    3. Writing Tests, and Fixing a Regression30 min

  7. Module 6: Files, JSON, CSV, and Data Quality

    Reading and writing text safely, parsing the two formats published data actually arrives in, and turning untidy input into validated records with errors a person can act on.

    1. Text Files, Encodings, and the Lines You Did Not Expect25 min
    2. JSON: Nested Data and the Keys That Are Not There25 min
    3. CSV Output and the Normalisation Step30 min

  8. Module 7: APIs and Web Data

    What an HTTP request and response actually contain, how pagination, rate limits, timeouts, and retries shape a real client, and how to build that client against stored fixtures so every part of it can be tested with no network and nothing to configure.

    1. HTTP and the Shape of an API Contract25 min
    2. Pagination, Rate Limits, and Retries That Stop25 min
    3. A Client Boundary You Can Test Without a Network30 min

  9. Module 8: Data Analysis

    Thinking in rows and columns, grouping and aggregating a batch of opportunities, and recognising the analyses that are arithmetically correct and still misleading.

    1. Thinking in Rows and Columns25 min
    2. Grouping, Aggregating, and Stating the Denominator25 min
    3. Analysis That Is Correct and Still Wrong30 min

  10. Module 9: SQL and Persistent Data

    Storing opportunity records in a real database, asking questions of them in SQL, joining normalised tables, and doing all of it with parameterised queries and versioned migrations.

    1. Tables, Rows, and a First Query25 min
    2. Normalised Tables, Joins, and Grouped Answers25 min
    3. Parameters, Transactions, and Versioned Migrations30 min

  11. Module 10: Automation and Reliable Scripts

    Turning working code into a repeatable local command: virtual environments and dependencies, configuration and logging, arguments, idempotent re-runs, and the Git habits that make a mistake reversible.

    1. Modules, Packages, and an Isolated Environment25 min
    2. Arguments, Configuration, and Logs That Do Not Leak25 min
    3. Running It Twice: Idempotency, Git, and Reviewing an Automation30 min

  12. Module 11: Object-Oriented Python and Maintainability

    What a class buys you and what it costs, dataclasses for records, composition and duck typing instead of inheritance hierarchies, and how to justify choosing one design over another.

    1. Classes and Dataclasses: When a Record Deserves a Type25 min
    2. Composition, Duck Typing, and Depending on a Shape25 min
    3. Two Designs for One Feature, and How to Choose30 min

  13. Module 12: Web Apps and Service Boundaries

    The server side of the request and response you met in Module 7: routes, validated inputs, honest error responses, and a small read-only local interface over the shortlist that other software can call.

    1. The Server Side: Lifecycle, Routes, and Handlers25 min
    2. Validating at the Boundary, and Errors That Help the Right People25 min
    3. A Read-Only Local Interface Over the Shortlist30 min

  14. Module 13: AI-Assisted Software Development

    Framing a task an assistant can complete and you can check, reading a generated diff for the change nobody asked for, and the risks worth refusing outright.

    1. Framing a Task So the Result Can Be Checked25 min
    2. Reading a Diff for the Change Nobody Asked For30 min
    3. Invented APIs, Stale Advice, and What Never Gets Pasted25 min

  15. Module 14: The Opportunity Review Assistant

    Every thread in this course assembled into one finished project: scope and a data dictionary, a fixture-backed client, normalisation and explainable matching, storage and reporting, four categories of test, a read-only local interface, one reviewed AI-assisted change, and the operational documents that make it somebody else's to run.

    1. Capstone Phase 1 and 2: Scope, Data Dictionary, and Loading the Batch30 min
    2. Capstone Phase 3 and 4: Normalisation, Validation, and Explainable Rules30 min
    3. Capstone Phase 5 to 7: Storage, Reporting, and the Test Suite30 min
    4. Capstone Phase 8 to 11: The API Contract, the Interface, One Reviewed Change, and the Handover30 min

learning.goultergroup.com

The interactive parts of this page have not loaded. Reading and links still work; reload the page to try again.