Learn Python from first script to a tested application

Understand how Python reads and executes a script, then run, modify, and diagnose a complete program without assuming prior coding experience.

Work with names, integers, floats, strings, booleans, and None while learning how Python binds names to objects instead of fixed storage boxes.

Calculate with Python’s numeric operators, understand division and precedence, and convert external text only after validating what it represents.

Read text safely, normalize user input, format clear output with f-strings, and understand why strings behave as immutable sequences.

Express mutually exclusive decisions with readable conditions, truth values, membership tests, and structural pattern matching where it genuinely helps.

Repeat work with for and while loops, choose stopping rules deliberately, and avoid off-by-one, infinite-loop, and mutation-during-iteration bugs.

Design small functions with clear contracts, parameters, return values, defaults, and keyword arguments while keeping side effects at program boundaries.

Classify syntax, runtime, and logic failures; read tracebacks; isolate assumptions; and use assertions, logging, and small tests to find causes.

Store ordered data with lists and tuples, slice sequences safely, unpack values, and choose mutability based on the meaning of the data.

Model key-value data with dictionaries, enforce uniqueness with sets, iterate safely, and select lookup structures based on the questions your program asks.

Transform iterables with readable comprehensions, consume generator expressions lazily, and decide when an explicit loop communicates the rule better.

Split Python code into cohesive modules, understand import execution and name resolution, and organize a small package without circular dependencies.

Read and write text predictably with context managers, build portable paths with pathlib, and validate JSON data before trusting its shape.

Define validation boundaries, raise precise exceptions, catch only failures you can handle, and preserve useful context instead of hiding defects.

Model domain concepts with classes, enforce invariants, use dataclasses for value-oriented records, and avoid turning every dictionary into an object.

Understand Python’s iteration protocol, build lazy generators, and encapsulate setup and cleanup with context managers for reliable resource handling.

Add useful type annotations, model optional and union values, define structural interfaces with Protocol, and understand what type checkers can and cannot prove.

Write focused tests around observable behavior, use parametrization and fixtures appropriately, and structure code so tests do not depend on console or filesystem accidents.

Create isolated project environments, install and record dependencies deliberately, distinguish applications from libraries, and make setup reproducible.

Combine validated dataclasses, collections, JSON persistence, reports, type hints, tests, and a command-line interface in a finished expense tracker.