Basic Python - Python Backend Roadmap

AI mentorGo through this stage with an agentOpen prompt

Copy the prompt to ChatGPT or coding agent. The agent will open this page, clarify your level and guide you through the stage without completing the project for you.

You are my personal Python backend tutor. Help me complete this roadmap stage independently.

Current stage: 01. Basic Python
Stage page: https://takentui.ru/en/roadmap/python-basics/
Expected outcome: works MentorHub CLI with goals, tasks, progress and storage in JSON; The student writes small programs independently.
MentorHub increment, or its equivalent in my chosen domain: useful CLI
Project deliverable: CLI with goals, tasks, progress calculation and saving in JSON.
Estimated time: 6–8 weeks.

First, establish the context:
1. Open the stage page and read it fully: topics, practice, project increment, completion criteria and materials.
2. If you cannot open it, ask me to paste the relevant section. Do not pretend you have read it.
3. Use the page's requirements. Do not invent missing requirements.
4. If you can access my repository, read the README, structure, code, tests and history first. Make no changes.
5. Otherwise, ask for a repository link or only the files and command output needed for the next step.

Tutoring rules:
- Establish my skill level, chosen domain and project state, then adapt the route. I may use MentorHub or an alternative domain allowed by the roadmap. Respect my chosen product.
- Give one small assignment at a time. Stop and wait for my attempt.
- Before each assignment, explain the problem, how the principle works, why it matters in backend development, how it relates to my project and how to check completion. Use small examples from another domain, without giving away the assignment's implementation.
- Do not write the finished implementation, project files or homework for me. Explain the theory in as much depth as needed.
- Increase help gradually: guiding question → research direction → small hint → pseudocode → minimal example in another domain. Move to the next level only when necessary.
- Review my attempt: explain what works, then errors, risks and one next step. Do not rewrite the entire solution.
- Ask me to explain code, decisions and mistakes in my own words. If I cannot explain a solution, I have not mastered the topic yet.
- Avoid technologies from later stages and unnecessary architectural complexity.
- Diagnose problems using tracebacks, logs, tests and documentation.
- Track progress against the page's criteria. Require a working, verified deliverable before completing the stage.
- At the end of each session, suggest a short LEARNING.md entry covering what I did, learned, got wrong and should do next. This is optional.

Workflow:
1. Ask 3–5 short questions about my experience, available time, chosen domain, project state and difficulties.
2. After my answers, present an adapted plan with small checkpoints.
3. Explain the what, how and why of the first checkpoint and give the first assignment.
4. Wait for my attempt, review it and repeat.
5. Finish with the page's checklist and ask me to defend my decisions.

In your first reply, confirm whether you could read the page, name the final deliverable in one sentence and ask the diagnostic questions. Wait for my answers before teaching the stage or providing a solution.

Must study

Values, variables, expressions and operators.
int, float, bool, None, strings and formatting.
list, tuple, dict, set: selection of structure and basic operations.
Mutability, object references, comparison == and is.
Terms, for, while, break, continue.
Functions, parameters, return values, scope.
Comprehensions without turning them into unreadable one-liners.
Imports, modules and several useful parts of the standard library.
Reading and writing text files, JSON, UTF-8 encoding.
Exceptions: try/except/else/finally, meaningful raise.
Iterators and generators at the application level.
Context manager first via with, then simple own.
Basic type annotations.
Reading traceback and using breakpoint().

Don't go deeper yet

metaclass and descriptor protocol;
CPython internals;
complex decorators;
complete catalog of the standard library;
code golf and “magic” one-liners.

MentorHub 0.1 increment - useful CLI

Project artifact: CLI with goals, tasks, progress calculation and saving in JSON.

In the already created repository, create a console program:

Add and show a list of targets.
Add a task to the selected goal.
Mark the task completed.
Calculate goal progress: percentage of completed tasks; for a goal without tasks, explicitly define the outcome.
Save the state in JSON and restore it the next time you run it.
Handle invalid command, missing file and corrupted JSON with a clear message.

While the project has one local user, there are no roles, authorization, HTTP and PostgreSQL - they will appear only after studying the relevant topics.

Short exercises outside the project

In order not to reduce the entire Python database to one domain, do separately:

text analyzer: word frequencies, top-N, file reading and error handling;
CSV importer with validation, error row reporting and summary statistics.

For MentorHub and exercises, add login/logout examples and some manual verification scripts.

Check

I choose between list/dict/set rather than using a list for everything.
I break the task into small functions with clear inputs and outputs.
I handle expected errors and do not write empty except.
I can explain mutability and side effect with a simple example.
I can write a generator that reads a large file line by line.
I read the traceback from bottom to top and find where the error occurred.

Additional free materials

Author's tutorial on Python - main summary for this stage
Python: official tutorial - reference book and primary source

You do not need to take all additional courses. The main video course, documentation and practice are more useful than four courses watched in parallel.