learning-path.en.md

Full Learning Path

🇺🇸 English · 🇧🇷 Português · 🇪🇸 Español

Use this page as the master table of contents for the course. Every published learning chapter is linked directly here, so you can move through the guide without opening each section index first.

If you are starting from zero, follow the phase order. Completed later phases may already be available before earlier planned phases, but the phase numbers still represent the intended learning sequence.

Status legend

• ✅ Available: published and reviewed
• 🚧 In progress: the phase has started but is not complete
• ⏳ Planned: not yet available as a complete learning section

Phase 1 · Fundamentals ✅

Open the Fundamentals section index

1. How Python runs a program
2. print() and input()
3. Variables and naming
4. Built-in data types
5. type() and isinstance()
6. Type conversion

Phase 2 · Strings and Numbers ✅

Open the Strings and Numbers section index

1. String creation and indexing
2. Common string methods
3. int, float, and bool
4. Numeric built-ins

Phase 3 · Collections ✅

Open the Collections section index

1. List creation, indexing, and slicing
2. Modifying lists and common list methods
3. Tuples and immutability
4. Dictionaries: keys and values
5. Sets and unique values
6. Choosing the right collection

Phase 4 · Program Flow ✅

Open the Program Flow section index

1. Conditions, Comparisons, and Boolean Logic
2. if, elif, and else
3. match and case: Structural Pattern Matching
4. for Loops and Iteration
5. range(), enumerate(), and zip()
6. while Loops and State-Driven Repetition
7. break, continue, and Loop else
8. Choosing and Combining Program Flow

Phase 4 is complete with eight reviewed chapters. The sequence builds trustworthy conditions, conditional branching, structural pattern matching, iterable-driven repetition, iteration helpers, state-driven repetition, deliberate loop control, and finally a decision framework for choosing and combining those tools by intent.

Phase 5 · Functions ✅

Open the Functions section index

1. Defining and Calling Functions
2. Parameters and Arguments
3. Return Values
4. Scope
5. Type Hints
6. Default Values
7. *args and **kwargs
8. Functions Working Together
9. Data Flow Between Functions

Phase 5 is complete with nine reviewed chapters. Chapter 01 establishes definition versus call, Chapter 02 adds required inputs through parameters and arguments, Chapter 03 completes the first input-to-output round trip with return values, Chapter 04 explains local and global names and lookup, Chapter 05 adds parameter and return type hints, collection annotations, str | None, and the distinction between static type information and runtime enforcement, Chapter 06 adds default values, selective overrides, definition-time evaluation, and safe handling of mutable defaults with None, Chapter 07 adds variable-length positional and keyword collection with *args and **kwargs, their tuple/dictionary models, simple mixed signatures, type hints for collected values, and the boundary between definition-side collection and call-side unpacking, Chapter 08 composes helpers and coordinating functions, passes returned values between steps, keeps dependencies explicit, combines functions with conditions and loops, and introduces simple call graphs, and Chapter 09 closes the phase with caller-to-parameter-to-return tracing, local bindings, rebinding versus mutation, tuple and None results, explicit pipelines, and data-flow traces.

Phase 6 · Comments, Documentation, and Clean Code ✅

This phase is already available and is the next recommended phase after Functions for learners following the curriculum from zero.

Open the Comments and Documentation section index

1. Comments in Python
2. Docstrings in Python
3. Meaningful Names and Self-Explanatory Code
4. Task Markers and Technical Follow-up
5. Comments versus Logging in Python
6. PEP 8 and Readability in Python

Phase 7 · Errors, Files, and Modules ✅

Open the Errors, Files, and Modules section index

1. Handling Exceptions with try, except, else, and finally
2. Raising and Custom Exceptions
3. Opening Files Safely with open() and with
4. Working with TXT, CSV, and JSON
5. Organizing Code with Imports, Modules, and Packages

Phase 7 is complete with five reviewed chapters. Chapters 01–02 establish exception handling and deliberate signaling. Chapter 03 adds safe file lifetime and text I/O. Chapter 04 adds TXT, CSV, and JSON data boundaries. Chapter 05 closes the phase with modules, regular packages, __name__, the main guard, import search context, absolute and relative imports, python -m, and dependency design.

Phase 8 · Standard Library ✅

Open the Standard Library section index

1. Working with Filesystem Paths Using pathlib
2. Working with Dates and Time Calculations Using datetime
3. Controlling JSON Serialization and Decoding Contracts
4. Controlling CSV Dialects and Tabular Text Contracts
5. Engineering Logging Pipelines and Runtime Context Contracts
6. Specialized Containers and Collection Contracts
7. Engineering Lazy Iterator Pipelines with itertools
8. Engineering Decimal Precision and Rounding Contracts
9. Engineering OS and Filesystem Operations with os and shutil

Phase 8 is complete with nine reviewed chapters. The sequence moves from path modeling through time, structured data formats, runtime diagnostics, specialized containers, lazy iteration, decimal arithmetic, and finally operating-system and filesystem contracts. Chapter 09 closes the phase with environment state, path-like boundaries, deterministic scanning and traversal, metadata, copy/move/removal behavior, platform capabilities, and archive-safety decisions.

Phase 9 · External Libraries ✅

Open the External Libraries section index

1. ✅ pandas: Working with Tabular Data
2. ✅ openpyxl: Automating Excel Workbooks
3. ✅ requests: Consuming HTTP APIs
4. ✅ pytest: Engineering Automated Tests

Phase 9 is complete with four reviewed chapters. The sequence moves from tabular-data contracts through Excel workbook automation and HTTP/API clients, then closes with pytest 9.1.x automated-testing contracts: discovery, assertions, parametrization, fixtures, temporary resources, monkeypatching, capture, marks, deterministic isolation, and CI behavior.

Phase 10 · Practical Projects 🚧

Open the Practical Projects section index

1. ✅ Expense Tracker
2. ✅ Grade Calculator
3. ✅ User Registration
4. ✅ CSV Analyzer
5. ✅ Report Generator
6. 🚧 File Organizer
7. ⏳ Fictional Reconciliation Workflow
8. ⏳ Simulated Automation Flow

Phase 10 is in progress. Project 01 integrates validated data modeling, exact Decimal money, collections, JSON persistence, CSV export, deterministic temporary-file handling, and automated pytest coverage. Project 02 adds configurable grade policies, exact weighted aggregation, explicit progress-versus-final state, structured reporting, and boundary-focused tests. Project 03 adds canonical identity-like data, Unicode and IDNA normalization, duplicate prevention, secondary lookup indexes, safe indexed-field updates, explicit lifecycle transitions, and mutation-focused tests without introducing authentication. Project 04 adds schema-aware CSV ingestion, typed conversion, row-level rejection diagnostics, structural failures, duplicate identifier checks, deterministic filtering, and aggregation using the standard library. Project 05 adds explicit reporting windows, deterministic summaries, exact two-decimal metrics, immutable report boundaries, TXT/Markdown rendering, format-aware escaping, and UTF-8 file output. Project 06 adds deterministic shallow file discovery, suffix classification, immutable dry-run planning, explicit collision policies, symlink boundaries, (device, inode) identity checks, source/category/root anchoring, bounded staging names, and platform-aware atomic no-replace commit behavior with Linux renameat2(RENAME_NOREPLACE).

Useful navigation

• Repository home
• Full roadmap
• Project structure

As new chapters are published, this page should be updated in the same pull request so the course always has one reliable, one-click navigation path.