Free to read ยท Three levels

Python: from first programs to maintainable systems

A complete bilingual theory course in Python programming, with traced examples, worked exercises, and reliable engineering practices.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

Learn Python by reasoning about names, objects, control flow, and contracts before scaling to modules, tests, data pipelines, and maintainable interfaces. Each level contains six substantial lessons with explained examples, common failures, worked exercises, and official references.

Runnable examples are self-contained and use only the Python standard library. They use synthetic data and temporary or in-memory storage, with an explicit Python 3.11 baseline and version-specific discussion where newer interpreter behavior matters.

What you will learn

  • Trace values, mutation, control flow, and function calls accurately.
  • Build validated record pipelines and focused regression tests.
  • Use protocols, generators, decorators, and context managers deliberately.
  • Choose concurrency with explicit lifetime and build assumptions.
  • Measure performance and maintain safe, documented package APIs.

Your learning path

Three levels

Foundations

Build and trace small programs with explicit values, control flow, functions, collections, and files.

  1. Running Python and reasoning about a program
  2. Values, types, and expressions
  3. Decisions, loops, and invariants
  4. Functions, contracts, and scope
  5. Collections and Unicode text
  6. Files and structured data
Explore this level

Reliable programs

Organize modules, validate records, model state, and verify behavior through focused tests.

  1. Modules, packages, and isolated environments
  2. Errors, exceptions, and debugging
  3. Testing contracts with the standard library
  4. Comprehensions and iterator pipelines
  5. Classes, dataclasses, and ownership
  6. Reliable records, CSV, and time
Explore this level

Maintainable systems

Design behavioral interfaces, manage lazy and concurrent work, measure costs, and protect package boundaries.

  1. Protocols, special methods, and type contracts
  2. Generators, delegation, and bounded streams
  3. Decorators and resource contexts
  4. Async, threads, processes, and the GIL
  5. Profiling, algorithmic cost, and memory
  6. Maintainable packages, safe boundaries, and APIs
Explore this level

Who this is for

  • New programmers willing to trace small examples.
  • Developers strengthening testing, data processing, and API design.

Before you start

  • Basic computer and text-editor skills.
  • Python 3.11 or later for running examples; no external packages are needed.

Related technical solutions

Resolve ModuleNotFoundError and interpreter mismatchesIdentify the interpreter actually running the program, distinguish import names from distributions, and repair one project environment without changing the system installation.Diagnose SyntaxError and IndentationError safelyUse the reported location as evidence, inspect surrounding structure, and verify corrected syntax without executing the program.Resolve TypeError, unexpected None, and conversion failuresTrace the actual value to its origin, separate conversion from validation, and repair the contract that introduced the wrong type.