roadmap.en.md

Python Study Guide Roadmap

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

This roadmap tracks both the educational curriculum and the repository foundation that supports it. Phase numbers describe the intended learning sequence, while repository work may prepare later sections earlier when doing so establishes useful standards.

Status legend

• Complete: the planned scope is available and reviewed.
• In progress: useful material exists, but the planned scope is not finished.
• Planned: the phase has not started as a complete learning section.

Current progress

Phase	Status	Current result
0. Project foundation	Complete	Foundation available, audited, and officially completed
1. Fundamentals	Complete	Six reviewed chapters cover execution, input/output, variables and naming, built-in data types, type inspection, and type conversion
2. Strings and numbers	Complete	Four reviewed chapters cover string creation, common methods, numeric and Boolean behavior, floating-point precision, and common numeric built-ins
3. Collections	Complete	Six reviewed chapters cover lists, tuples, dictionaries, sets, and choosing a collection by intent
4. Program flow	Complete	Eight reviewed chapters cover conditions, branching, structural pattern matching, for, iteration helpers, while, loop control, and choosing and combining flow tools by intent
5. Functions	Complete	Nine reviewed chapters cover def, calls, required inputs, returned values, scope, type hints, safe defaults, flexible arguments, function composition, and explicit data flow
6. Comments, documentation, and clean code	Complete	Six reviewed chapters are available and the pilot educational section is officially complete
7. Errors, files, and modules	In progress	Chapters 01–02 cover handling runtime exceptions and deliberately raising, re-raising, chaining, and defining custom exceptions
8. Standard library	Planned	Curriculum not started
9. External libraries	Planned	Curriculum not started
10. Practical projects	Planned	Curriculum not started

Phases 0, 1, 2, 3, 4, 5, and 6 are complete. Phase 7 is in progress with both exception handling and deliberate exception raising now available before the later file and module chapters. Phase 6 continues to provide the editorial and quality model for later sections.

Phase 0: Project foundation

Completed

• Multilingual root README files
• Initial scalable project structure
• Multilingual contribution guidelines
• GitHub pull request and issue templates
• Community standards and reporting guidance
• Consistent editorial chapter format
• MIT License
• Project authorship and maintenance records
• Pull-request-based workflow and protected main branch
• Repository instructions for contributors and AI agents
• Responsible AI-assisted development guide
• Multilingual roadmap and project-structure documentation
• Automated quality checks for Python files, approved examples, internal links, and repository structure
• Original visual identity and repository assets
• Final navigation, terminology, accessibility, and status audit
• Officially mark Phase 0 as complete

Planned non-blocking follow-up

• Refine and replace visual assets with high-quality exports after the final logo framing is complete.

Phase 1: Fundamentals

• How Python runs a program
• print() and input()
• Variables and naming
• Built-in data types
• type() and isinstance()
• Type conversion

Phase 2: Strings and numbers

• String creation and indexing
• Common string methods
• int, float, and bool
• Numeric built-ins: round(), abs(), min(), max(), and sum()

Phase 3: Collections

• List creation, indexing, and slicing
• Modifying lists and common list methods
• Tuples and immutability
• Dictionaries: keys and values
• Sets and unique values
• Choosing the right collection

Phase 4: Program flow

See the section learning path.

• Conditions, comparisons, and Boolean logic
• if, elif, and else
• match and case: structural pattern matching
• for loops and iteration
• range(), enumerate(), and zip()
• while loops and state-driven repetition
• break, continue, and loop else
• Choosing and combining program flow

Phase 4 intentionally builds trustworthy conditions first, uses them for conditional branching, introduces structural pattern matching, moves into repetition with for, adds helpers for numeric progressions, positions, and parallel iteration, introduces state-driven repetition with while, adds deliberate loop control with break, continue, and loop else, and closes by teaching how to choose and combine those tools according to intent. Chapters 01–08 are complete and Phase 4 is officially complete.

Phase 5: Functions

See the section learning path.

• Defining and calling functions
• Parameters and arguments
• Return values
• Scope
• Type hints
• Default values
• *args and **kwargs
• Functions working together
• Data flow between functions

Phase 5 is complete. Chapter 01 establishes def, calls, reuse, execution order, naming, pass, implicit None, and the connection with program flow. Chapter 02 adds required parameters, positional and basic keyword arguments, argument expressions, call errors, and input-flow tracing. Chapter 03 adds return, reusable results, branch-specific and early returns, None, and tuple returns. Chapter 04 adds local and global names, function-local namespaces, lookup, shadowing, NameError, UnboundLocalError, and cautious use of global. Chapter 05 adds parameter and return annotations, built-in and collection type hints, -> None, str | None, annotation metadata, and the distinction between static type information, runtime validation, and conversion. Chapter 06 adds default values, selective positional and keyword overrides, definition-time evaluation, the mutable-default trap, and the safe None pattern for fresh mutable objects. Chapter 07 adds variable-length positional and keyword argument collection with *args and **kwargs, tuple and dictionary behavior inside the function, simple mixed signatures, basic type hints for collected values, and the distinction between definition-side collection and later call-side unpacking. Chapter 08 composes helpers and coordinating functions, passes returned results between steps, keeps dependencies explicit through parameters and returns, combines functions with conditions and loops, distinguishes reusable calculation from presentation, and introduces simple call graphs. Chapter 09 closes the phase by tracing caller-to-parameter-to-return flow, local parameter bindings, rebinding versus mutation, tuple and None results, explicit pipelines, collection transformations, and the difference between call graphs and data-flow traces.

Phase 6: Comments, documentation, and clean code

See the section learning path.

• When and why to comment
• When not to comment
• Useful and harmful comments
• Docstrings
• Meaningful names and self-explanatory code
• TODO, FIXME, NOTE, and related task markers
• Comments versus logging
• PEP 8 and readability

Phase 6 is officially complete and provides the editorial and quality model for the remaining learning sections.

Phase 7: Errors, files, and modules

See the section learning path.

• try, except, else, and finally
• raise and custom exceptions
• open() and with
• TXT, CSV, and JSON
• Imports, modules, and packages

Phase 7 is in progress. Chapter 01 establishes runtime exception handling, specific handlers, else, finally, propagation, and narrow failure boundaries. Chapter 02 adds deliberate raise, choosing built-in versus custom exception types, bare re-raising, explicit chaining, and raise versus assert. The next planned chapter is open() and with.

Phase 8: Standard library

• pathlib
• datetime
• json
• csv
• logging
• collections
• itertools
• decimal
• os and shutil

Phase 9: External libraries

• pandas
• openpyxl
• requests
• pytest

Phase 10: Practical projects

• Grade calculator
• User registration
• Expense tracker
• CSV analyzer
• Report generator
• File organizer
• Fictional reconciliation workflow
• Simulated automation flow

Each project should include:

• requirements;
• design notes;
• implementation;
• explanation;
• test ideas;
• extension challenges;
• portfolio discussion.

Ongoing quality gates

Every phase should preserve:

• technical accuracy;
• multilingual consistency;
• original and public-safe examples;
• privacy-safe data;
• executable Python examples when appropriate;
• internal navigation integrity;
• PEP 8 awareness;
• documentation of meaningful structure changes;
• honest dependency and version assumptions.

The roadmap will evolve as the project grows, but changes should preserve the progression from beginner concepts to integrated practical work.