Путь к Python-разработчику в 2026

План обучения и рабочее окружение разработчика

Эта статья открывает курс «Путь к Python-разработчику в 2026». Здесь мы сделаем две вещи:

Соберём реалистичный план обучения, чтобы понимать что и в каком порядке изучать.

Настроим рабочее окружение разработчика, чтобы вы могли писать код как в реальной работе: проекты, зависимости, запуск, тесты и контроль версий.

Каким бывает Python-разработчик в 2026

Python используют в разных направлениях. Важно выбрать основную цель — тогда план будет проще и быстрее.

Backend-разработчик: пишет серверную логику веб‑приложений, API, работает с базами данных.

Автоматизация и скрипты: автоматизирует рутину (файлы, отчёты, интеграции с сервисами).

Data/ML: анализ данных, обучение моделей, пайплайны.

В этом курсе базовая траектория будет ориентирована на универсальный фундамент, который подходит всем направлениям, а ближе к середине вы сможете сделать акцент на выбранной специализации.

Принцип обучения: от маленьких проектов к рабочим навыкам

Чтобы прогресс был измеримым, опирайтесь на четыре правила:

Учитесь через проекты: каждая тема закрепляется кодом.

Пишите каждый день: даже 20–40 минут лучше, чем редкие «забеги».

Держите всё в Git: так вы будете видеть историю развития и учиться работать как в команде.

Доведите окружение до автоматизма: запуск, зависимости, форматирование и тесты не должны «ломать темп».

> «We are what we repeatedly do. Excellence, then, is not an act, but a habit.» — Will Durant (часто приписывается Аристотелю). Цитата

План обучения: дорожная карта до уровня Junior

Ниже — примерная траектория. Сроки зависят от вашего времени, но логика порядка тем важнее дат.

| Этап | Что изучаете | Зачем это нужно | Результат этапа | |---|---|---|---| | База Python | синтаксис, типы, функции, модули, ошибки | чтобы уверенно писать небольшие программы | несколько консольных утилит | | Практика кода | работа с файлами, JSON, HTTP, ООП, коллекции | чтобы решать реальные задачи и структурировать код | мини‑проект с вводом/выводом | | Инструменты разработчика | Git, виртуальные окружения, зависимости, линтер/форматтер | чтобы код был поддерживаемым и воспроизводимым | репозиторий «как на работе» | | Тестирование | unit‑тесты, фикстуры, покрытие | чтобы изменения не ломали проект | проект с тестами | | Веб и базы (для backend) | HTTP, API, БД, ORM, миграции | чтобы писать серверные приложения | API‑сервис + база | | Деплой и эксплуатация | конфиги, переменные окружения, логирование, контейнеры (по необходимости) | чтобы приложение работало вне вашего ноутбука | развёрнутый сервис |

!Визуальная «дорожная карта» показывает порядок тем и итог каждого этапа

Как организовать неделю, чтобы не перегореть

Один из самых устойчивых форматов — короткие регулярные сессии.

5 дней в неделю: практика и чтение.

1 день: мини‑проект или улучшение текущего проекта.

1 день: отдых или лёгкое повторение.

Пример распределения времени (адаптируйте под себя):

40% — практика (код руками).

30% — разбор ошибок и чтение документации.

20% — маленький проект.

10% — заметки и рефлексия: что получилось, что повторить.

Рабочее окружение разработчика: что это и зачем

Рабочее окружение — это набор инструментов и правил, которые позволяют:

запускать проекты одинаково на любом компьютере;

изолировать зависимости одного проекта от другого;

поддерживать единый стиль кода;

быстро находить ошибки;

вести историю изменений.

Ниже — минимальный набор, который считается нормой для Python‑разработчика.

Установка Python и проверка версии

Откуда устанавливать Python

Рекомендуемые источники:

Официальный сайт: Python Downloads

Официальная документация: Python Documentation

После установки проверьте версию:

Если команда не находится, на некоторых системах нужно использовать:

Что такое интерпретатор

Python — интерпретируемый язык. Интерпретатор — это программа, которая читает ваш .py файл и выполняет инструкции.

Проекты и зависимости: venv и pip

Почему нельзя «ставить всё в систему»

Если вы устанавливаете пакеты «глобально», проекты начинают конфликтовать: одному нужен пакет версии 1.x, другому — 2.x. Это типичная причина хаоса у новичков.

Виртуальное окружение venv

Виртуальное окружение — это отдельная папка с собственным Python и установленными пакетами для конкретного проекта.

Создание окружения внутри проекта:

Активация:

Установка пакетов через pip

pip — стандартный менеджер пакетов Python.

Фиксация зависимостей в файл:

Установка зависимостей на другом компьютере:

Редактор и IDE: где писать код

Вам нужен инструмент с подсветкой ошибок, автодополнением и удобным запуском.

Два популярных варианта:

Visual Studio Code: лёгкий редактор с расширениями. Visual Studio Code

PyCharm: мощная IDE, часто удобна для новичков благодаря подсказкам. PyCharm

Минимально полезные функции, которые стоит включить:

автоматическое форматирование;

подсветка неиспользуемых переменных;

быстрый запуск тестов;

встроенный терминал.

Стиль кода и качество: PEP 8, форматтер и линтер

PEP 8

PEP 8 — руководство по стилю Python‑кода: отступы, имена переменных, длина строк и другие правила. PEP 8

Форматтер и линтер — в чём разница

Форматтер автоматически приводит код к единому стилю.

Линтер ищет потенциальные ошибки и плохие практики.

Один из популярных современных инструментов, который часто используют и как линтер, и для части форматирования — ruff. Ruff

Если вы пока не хотите выбирать инструменты, зафиксируйте в голове главное: в реальной разработке стиль кода автоматизируют.

Git: контроль версий — базовый навык

Git сохраняет историю изменений в проекте. Это нужно, чтобы:

откатываться к рабочему состоянию;

экспериментировать без страха;

отправлять код на проверку;

работать в команде.

Установка и документация:

Git

Книга: Pro Git

Минимальные команды для старта:

Структура папок проекта: простой шаблон

Для учебных и небольших проектов подойдёт такая структура:

README.md — что это за проект и как запустить.

requirements.txt — зависимости.

src/ — исходный код.

tests/ — тесты.

.gitignore — что не добавлять в Git.

Пример структуры:

Важно: папку .venv/ в Git обычно не добавляют.

Документация — ваш главный «второй преподаватель»

Привычка читать документацию отличает разработчика от человека, который просто повторяет уроки.

Полезные источники:

Python Documentation

Python Tutorial

Практический навык на будущее: учитесь искать ответы по ключевым словам на английском, потому что документация и большинство обсуждений — на английском.

Чек-лист готовности к следующим статьям

К следующей статье курса у вас должно быть готово:

установлен Python и вы умеете проверить его версию;

создана папка проекта и виртуальное окружение .venv;

вы умеете ставить зависимости через pip;

выбран редактор (VS Code или PyCharm) и вы умеете запускать скрипт;

создан Git‑репозиторий и сделан первый коммит.

Основы Python: синтаксис, типы, функции и модули

Эта статья продолжает старт курса «Путь к Python-разработчику в 2026». В предыдущей статье вы настроили рабочее окружение: Python, venv, pip, редактор и Git. Теперь задача другая: уверенно писать небольшой, понятный код и собирать его в части, как это делается в реальных проектах.

Цель статьи: дать базу, на которой дальше строятся практические темы (файлы, HTTP, ООП, тесты, веб).

Как запускается Python-код

Есть два основных способа работать с Python.

Скрипт: вы пишете файл something.py и запускаете его командой python something.py.

Интерактивный режим (REPL): вы запускаете python и проверяете идеи построчно.

Для курса основной формат будет скриптами и маленькими проектами.

Полезные ссылки:

The Python Tutorial

Built-in Functions

Базовый синтаксис: что важно запомнить сразу

Отступы и блоки кода

В Python блоки кода задаются отступами, а не фигурными скобками.

Практическое правило: используйте 4 пробела на уровень вложенности и не смешивайте табы с пробелами.

Переменные и присваивание

Переменная в Python создаётся в момент присваивания.

Имена переменных обычно пишут в стиле snake_case.

Комментарии

Однострочный комментарий начинается с #.

Ввод и вывод

input() всегда возвращает строку, даже если вы ввели число.

Типы данных: из чего строятся программы

Тип данных определяет, какие значения можно хранить и какие операции с ними доступны.

Простые (скалярные) типы

| Тип | Пример | Для чего используется | |---|---|---| | int | 42 | целые числа | | float | 3.14 | числа с дробной частью | | str | "hello" | текст | | bool | True / False | логика, условия | | NoneType | None | «нет значения» |

Пример приведения типов (часто нужно после input()):

Коллекции: несколько значений в одном объекте

| Тип | Пример | Изменяемый | Когда удобен | |---|---:|:---:|---| | list | [1, 2, 3] | да | последовательность, которую нужно менять | | tuple | (1, 2, 3) | нет | фиксированная последовательность | | dict | { "a": 1 } | да | ключ → значение | | set | {1, 2, 3} | да | уникальные элементы, быстрые проверки «есть ли» |

Ключевая идея: изменяемость.

Изменяемые объекты можно менять «на месте» (например, list, dict).

Неизменяемые нужно создавать заново при изменениях (например, str, tuple).

Примеры:

Полезные встроенные функции для типов

type(x) показывает тип.

len(x) длина строки/списка/словаря.

sorted(iterable) сортировка (возвращает новый список).

Управляющие конструкции: как задаётся логика

Условия: if / elif / else

Условия используют выражения, которые дают True или False.

Цикл for

for в Python перебирает элементы последовательности.

Часто используется range().

Цикл while

while выполняется, пока условие истинно.

break и continue

break прерывает цикл.

continue пропускает текущую итерацию.

Функции: переиспользование и структура

Функция — именованный блок кода, который можно вызывать многократно.

Объявление и возврат значения

Если return не указан, функция возвращает None.

Параметры по умолчанию

Важное правило: не используйте изменяемые значения как параметры по умолчанию.

Плохо:

Хорошо:

Причина: значения по умолчанию вычисляются один раз при создании функции и могут «накапливать» изменения между вызовами.

Именованные аргументы

Python позволяет явно указывать, какой параметр вы задаёте.

Докстроки

Докстрока — строка в начале функции, которую используют инструменты и IDE.

Ошибки и исключения: нормальная часть разработки

Когда что-то идёт не так, Python выбрасывает исключение.

Пример безопасного преобразования ввода в число:

try содержит код, который может упасть.

except обрабатывает ожидаемую ошибку.

else выполняется только если ошибки не было.

Модули: как разносить код по файлам

Когда файл разрастается, его нужно разделять. В Python это делают с помощью модулей.

Модуль — файл .py.

Пакет — папка с Python-кодом (обычно с файлом __init__.py).

Импорт модулей

Импорт конкретного имени:

Импорт с псевдонимом:

Как сделать свой модуль

Структура:

utils.py:

main.py:

Если вы используете структуру с src/, следите за тем, как вы запускаете код: проще всего запускать точку входа проекта (например, main.py) из корня проекта так, как настроит IDE.

!Схема показывает, что модуль — это файл, и как один файл импортирует функции из другого

__name__ == "__main__": зачем это нужно

Это стандартный способ разделить:

код, который выполняется при запуске файла напрямую;

код, который должен быть доступен при импорте.

Если файл импортируют как модуль, main() автоматически не вызовется.

Ссылка из документации:

Executing modules as scripts

Стандартная библиотека: что полезно знать с самого начала

Python поставляется с большим набором готовых модулей. Несколько особенно частых:

pathlib для работы с путями и файлами.

json для JSON.

datetime для дат и времени.

Справочник:

The Python Standard Library

Мини-практика в рамках статьи: собрать всё вместе

Ниже пример маленькой программы, где есть типы, условия, функция и импорт из стандартной библиотеки.

Чек-лист перед тем, как двигаться дальше

Вы понимаете, почему отступы критичны для структуры программы.

Вы различаете базовые типы (int, str, bool, None) и коллекции (list, dict и другие).

Вы умеете писать функции, возвращать значения и использовать параметры по умолчанию безопасно.

Вы можете разнести код по двум файлам и импортировать функцию из своего модуля.

Вы понимаете смысл конструкции if __name__ == "__main__":.

ООП, исключения и работа с файлами

В предыдущих статьях вы настроили рабочее окружение и освоили базовый синтаксис Python: типы, функции и модули. Теперь мы переходим к трём навыкам, которые превращают набор скриптов в поддерживаемые программы:

ООП (объектно-ориентированное программирование) — помогает упаковывать данные и логику вместе и строить расширяемый код.

Исключения — позволяют предсказуемо обрабатывать ошибки вместо падений программы.

Работа с файлами — нужна, чтобы читать и сохранять данные: конфиги, отчёты, логи, JSON.

Связка этих тем почти всегда встречается в реальных задачах: вы загружаете данные из файла, обрабатываете их объектами и корректно реагируете на ошибки ввода/вывода.

ООП: что это и зачем

ООП — это стиль программирования, где вы моделируете предметную область через объекты.

Класс — «чертёж» объекта.

Объект (экземпляр) — конкретная «реализация» класса.

Атрибуты — данные объекта.

Методы — функции, которые работают с данными объекта.

Ссылка на документацию:

Классы в Python (официальная документация)

Класс и объект: минимальный пример

Что здесь важно:

__init__ — метод инициализации объекта.

self — ссылка на текущий объект. Через self вы читаете и меняете состояние объекта.

!Диаграмма «класс и экземпляры» показывает, что класс — шаблон, а объекты содержат конкретные данные

Состояние и поведение: почему это удобно

Главная идея: объект хранит состояние и предоставляет поведение.

В процедурном стиле вы часто передаёте в функции много параметров.

В ООП объект хранит нужные данные внутри, а методы используют их напрямую.

Это особенно полезно, когда сущность «живёт» долго и через неё проходит много операций: корзина покупок, клиент API, соединение с БД, список задач.

Инкапсуляция: договорённость о том, что можно менять

В Python нет «жёстких» модификаторов доступа как в некоторых языках, но есть соглашения:

public_name — публичный атрибут, можно использовать снаружи.

_internal_name — внутренний атрибут, лучше не трогать снаружи.

Пример: делаем метод, который контролирует изменение состояния.

Здесь важно:

мы не даём «сломать» баланс напрямую;

ошибки превращаем в понятные исключения (ValueError).

Композиция и наследование: как строить большие структуры

Есть два базовых способа «собирать» систему.

Композиция: один объект содержит другой.

Наследование: один класс расширяет другой.

Практическое правило для новичка: чаще выбирайте композицию, а наследование используйте, когда действительно есть отношение «это является».

Пример композиции:

Пример наследования:

Датаклассы: удобный способ хранить данные

Если ваш класс в основном хранит данные, полезно знать про dataclasses.

Модуль dataclasses (официальная документация)

Такой класс автоматически получает понятный __init__ и удобное строковое представление.

Исключения: как писать код, который не ломается

Исключения — механизм обработки ошибок. Python выбрасывает исключение, когда не может продолжать выполнение.

Ошибки и исключения (официальная документация)

Базовый шаблон try/except/else/finally

Смысл блоков:

try — потенциально опасный код.

except — обработка ожидаемой ошибки.

else — выполняется, если ошибки не было.

finally — выполняется всегда (часто используется для освобождения ресурсов).

!Схема показывает, как выбираются ветки try/except/else и что finally выполняется всегда

Когда нужно поднимать исключение самим

Вы поднимаете исключение (raise), когда обнаружили некорректное состояние и хотите остановить текущую операцию понятным способом.

Пользовательские исключения

Полезно создавать свои исключения, когда вы хотите отделить «ошибки домена» от технических.

Дальше вы можете ловить StorageError и обрабатывать его отдельно, не путая с ValueError или FileNotFoundError.

Работа с файлами: чтение, запись, кодировка, пути

Файлы — это самый простой способ долговременного хранения данных.

Ключевые понятия:

Путь к файлу (где файл находится).

Режим открытия (чтение, запись, дозапись).

Кодировка (важно для текста).

Контекстный менеджер with (гарантирует закрытие файла).

Ссылки на документацию:

Функция open (официальная документация)

Модуль pathlib (официальная документация)

Почему лучше использовать pathlib

pathlib.Path даёт удобные операции с путями, которые одинаково работают на Windows/macOS/Linux.

Чтение и запись текста

Запись (перезапишет файл):

Чтение целиком:

Построчное чтение (лучше для больших файлов):

Режимы открытия: короткая таблица

| Режим | Значение | Типичная задача | |---|---|---| | "r" | чтение | прочитать файл | | "w" | запись (перезапись) | создать новый файл или перезаписать | | "a" | дозапись | добавить строки в конец | | "rb" | чтение байтов | изображения, архивы | | "wb" | запись байтов | сохранить бинарные данные |

Кодировка и типовые ошибки

Для текста почти всегда явно указывайте encoding="utf-8". Иначе на разных ОС возможны проблемы.

Типовые исключения при работе с файлами:

FileNotFoundError — файла нет.

PermissionError — нет прав.

IsADirectoryError — попытка открыть папку как файл.

UnicodeDecodeError — неверная кодировка при чтении.

Пример безопасного чтения:

!Иллюстрация объясняет связку pathlib + with + обработка исключений

Мини-проект: список задач с сохранением в JSON

Ниже пример программы, где используется сразу всё из статьи:

ООП: классы Task и TodoList.

Исключения: обработка ошибок чтения/записи.

Файлы: сохранение в tasks.json.

Также используется стандартный модуль json.

Модуль json (официальная документация)

Что стоит заметить:

TodoList отвечает за операции со списком задач и за хранение в файле.

Ошибки файловой системы (OSError) «прячутся» внутрь StorageError, чтобы внешний код работал с понятной категорией ошибок.

Файл открывается через with, поэтому закрывается автоматически даже при ошибках.

Как это связано с дальнейшими темами курса

Эта статья готовит вас к следующим шагам:

В веб-разработке те же принципы применяются к HTTP-клиентам, сервисам и репозиториям данных.

В тестировании вы будете проверять методы классов и сценарии исключений.

В работе с базами данных файлы часто заменяются на БД, но архитектура (слои, обработка ошибок) остаётся похожей.

Чек-лист готовности

Вы умеете создать класс с __init__, атрибутами и методами.

Вы понимаете, что такое инкапсуляция и зачем поднимать исключения через raise.

Вы можете обработать типовые исключения при вводе и при работе с файлами.

Вы умеете читать и писать текстовые файлы через pathlib и with.

Вы можете собрать маленькую программу, которая сохраняет состояние между запусками.

Алгоритмы, структуры данных и практика задач

Эта статья продолжает курс «Путь к Python-разработчику в 2026». Ранее вы научились писать функции и модули, разобрали ООП, исключения и работу с файлами. Теперь добавим то, что почти всегда проверяют на собеседованиях и что реально помогает писать быстрый и надёжный код:

Алгоритмы: как решать типовые задачи шаг за шагом.

Структуры данных: как хранить данные так, чтобы операции были быстрыми.

Практика задач: как тренироваться так, чтобы прогресс был измеримым.

Цель: выстроить базовый набор инструментов, с которым вы сможете решать задачи на массивы, строки, словари, файлы и простые графы, а также уверенно обсуждать сложность решений.

Что такое алгоритм и почему важны структуры данных

Алгоритм — это точная последовательность шагов, которая приводит от входных данных к результату.

Структура данных — способ хранения данных, который определяет, насколько быстро вы сможете:

искать элементы

добавлять и удалять

поддерживать порядок

брать минимум или максимум

Одна и та же задача может решаться разными комбинациями алгоритма и структуры данных. В Python часто выигрывает не хитрый код, а правильный выбор контейнера: list, dict, set, deque.

Оценка сложности: как думать про скорость без замеров

Когда мы говорим «это решение быстрое», обычно имеют в виду не секунды на вашем ноутбуке, а то, как время и память растут при увеличении входных данных.

Для этого используют асимптотическую сложность (нотация Big-O):

— время почти не зависит от размера данных

— время растёт примерно пропорционально количеству элементов

— становится резко медленнее при росте данных

— растёт медленно (типично для деления пополам)

Где:

— размер входа, например количество элементов в списке

— логарифм, в задачах обычно означает сколько раз можно делить вход пополам, пока не останется 1 элемент

Важно: Big-O — это модель роста, а не точный таймер.

!Сравнение того, как растёт время алгоритмов при увеличении входных данных

Полезная ссылка для углубления:

Time complexity

Базовые структуры данных в Python и типовые сложности

Ниже — практическая «шпаргалка» по контейнерам, которые вы будете использовать чаще всего.

| Структура | Когда использовать | Типичные операции | Ожидаемая сложность | |---|---|---|---| | list | упорядоченная последовательность | доступ по индексу, добавление в конец | доступ , append | | list | частые вставки в начало или середину | вставка insert(0, x) | обычно | | dict | ключ → значение, быстрый доступ | get, присваивание, проверка ключа | обычно | | set | уникальные элементы и быстрые проверки | in, добавление | обычно | | collections.deque | очередь, двусторонние операции | appendleft, popleft | |

Ссылки на документацию:

Built-in Types

collections.deque

Почему list медленно вставляет в начало

list — это динамический массив. Если вы делаете insert(0, x), элементы приходится сдвигать вправо. Поэтому для очереди используйте deque.

Пример очереди:

Паттерны решения задач, которые встречаются чаще всего

Паттерн — это повторяемая схема. Вы не заучиваете решения, вы учитесь узнавать тип задачи.

Частотный словарь: считаем элементы

Задачи вида «найти самый частый элемент», «проверить анаграммы», «сгруппировать» почти всегда решаются через dict.

Ключевая идея: dict.get(key, default).

Два указателя: работаем с концами или с окном

Два указателя — техника, когда вы ведёте два индекса (например, слева и справа) и сдвигаете их по правилу.

Типовые применения:

задачи на отсортированных массивах

проверка палиндрома

поиск пары с заданной суммой в отсортированном массиве

Пример: проверить, есть ли пара чисел в отсортированном списке с суммой target.

Почему это быстро: каждый указатель двигается не более раз, значит итоговая сложность обычно .

Стек: «последним пришёл — первым вышел»

Стек полезен для:

проверки корректности скобок

отмены действий

обходов (например, DFS) в простых вариантах

В Python стек чаще всего делают обычным списком, используя append и pop.

Бинарный поиск: делим пополам

Бинарный поиск применим, когда данные отсортированы или когда есть монотонное условие вида «всё левее подходит, всё правее не подходит».

Сложность обычно : на каждом шаге остаётся примерно половина диапазона.

Если вам нужен готовый инструмент для вставки и поиска позиции в отсортированном списке, изучите:

bisect

Куча и приоритет: быстро брать минимум

Иногда задача звучит как:

«найди k минимальных»

«всегда выбирай следующий элемент с минимальной стоимостью»

Тогда используйте кучу через модуль heapq.

heapq

Пример: взять k минимальных элементов.

Как превращать решение задачи в поддерживаемый код

Алгоритмическая задача — это не только «нашёл идею», но и качество реализации. Используйте привычки из предыдущих статей.

Делайте функции маленькими и тестируемыми

Правило: одна функция — одна ответственность.

отдельно парсинг входа

отдельно вычисление

отдельно вывод

Это напрямую продолжает тему модулей и функций из предыдущей части курса.

Ошибки — это часть контракта

Если вход может быть неверным, лучше явно сообщать об этом через исключения.

Такой стиль согласуется с тем, как вы уже работали с try и raise.

Если данные большие, думайте про память

Иногда проблема не во времени, а в том, что вы грузите в память слишком много.

для больших файлов чаще используйте построчное чтение

не храните всё, если можно обрабатывать потоково

Это продолжает тему работы с файлами: with, pathlib, чтение по строкам.

План практики задач: как тренироваться эффективно

Ниже — рабочий процесс, который обычно даёт результат быстрее, чем хаотичное решение сотен задач.

Выберите тему на неделю: например, словари и частоты.

Решите 8–15 задач одной темы, чтобы паттерн закрепился.

На каждую задачу пишите короткий разбор в README.md проекта:

- идея - структура данных - сложность - типовая ошибка, которую вы допустили или могли допустить

Раз в неделю возвращайтесь к 2–3 старым задачам и решайте заново без подсказок.

Источники задач:

LeetCode

Codewars

Для честной проверки скорости используйте:

timeit

Мини-проект для закрепления: анализ лог-файла

Чтобы связать алгоритмы со «взрослой» практикой, сделайте небольшой проект, который читает текстовый файл и строит статистику.

Идея:

вы читаете файл построчно

извлекаете ключ (например, имя пользователя или код ошибки)

считаете частоты через dict

выводите топ-10 самых частых

Это объединяет:

работу с файлами (pathlib, with)

исключения (файл не найден, неверный формат)

структуры данных (dict, возможно heapq для топа)

Пример функции для топа через сортировку:

Чек-лист готовности

Вы понимаете смысл , , , на уровне интуиции.

Вы выбираете dict и set, когда нужна быстрая проверка принадлежности.

Вы используете deque для очереди, а не list.

Вы узнаёте паттерны: частотный словарь, два указателя, стек, бинарный поиск.

Вы умеете оформить решение как чистую функцию и обработать плохой ввод через исключения.

Git, командная строка и командная разработка

В прошлых статьях курса «Путь к Python-разработчику в 2026» вы настроили окружение (venv, pip, редактор) и написали первые программы, а также потренировались в ООП, исключениях и работе с файлами. Теперь пришло время освоить то, что превращает “код на ноутбуке” в рабочий процесс разработчика:

Командная строка: быстро запускать программы, управлять файлами, работать с окружением.

Git: сохранять историю изменений и безопасно экспериментировать.

Командная разработка: ветки, pull request, code review, разрешение конфликтов.

Цель статьи: чтобы вы могли вести проект как в команде: делать понятные коммиты, работать с ветками, отправлять изменения на удалённый репозиторий и проходить ревью.

!Диаграмма: локальная работа, синхронизация с удалённым репозиторием и Pull Request

Командная строка как рабочий инструмент

Командная строка (терминал) — это способ управлять компьютером через команды. В разработке она нужна, потому что многие инструменты (Python, pip, Git, тесты, линтеры) одинаково работают в терминале на любой машине.

Навигация по папкам и базовые операции

Команды отличаются на Windows и macOS/Linux, но смысл один.

Три базовых понятия:

текущая директория: папка, “внутри” которой вы сейчас находитесь

абсолютный путь: путь от корня диска/системы

относительный путь: путь от текущей директории

Команды навигации:

pwd (macOS/Linux) показывает текущую папку

cd путь перейти в папку

ls (macOS/Linux) или dir (Windows) показать содержимое

Пример типичного сценария в проекте:

Запуск Python и работа с виртуальным окружением

Из первой статьи вы уже знаете, зачем нужен venv. В терминале это выглядит так:

Важно: активированное окружение меняет какой Python и какие пакеты используются при запуске.

Перенаправление вывода и “пайпы”

Это полезно для логов и диагностики.

команда > файл записать вывод в файл (перезаписать)

команда >> файл дописать в конец файла

команда1 | команда2 передать вывод первой команды во вторую

Примеры:

Переменные окружения

Переменная окружения — это настройка, которую получает программа при запуске (например, режим окружения, токены, пути к файлам).

Примеры установки:

Практическая идея: секреты (токены, пароли) лучше передавать через переменные окружения, а не хранить в коде.

Git: что именно он сохраняет

Git — система контроля версий. Она хранит историю изменений проекта.

Три базовых объекта, которые нужно понять:

репозиторий: папка проекта, где Git хранит историю

коммит: “снимок” изменений с сообщением

ветка: указатель на цепочку коммитов (обычно есть main)

Документация:

Git

Pro Git (книга)

Состояния файлов: рабочая директория, staging area, коммит

В Git файл обычно проходит три шага:

Вы меняете файл в проекте.

Вы добавляете изменения в staging area (индекс), то есть “подготовка к коммиту”.

Вы создаёте коммит.

Минимальный цикл:

Команды для понимания состояния:

git status что изменилось

git diff что именно изменилось (до git add)

git diff --staged что попадёт в коммит (после git add)

Как создать репозиторий и первый коммит

Если вы ещё не сделали это в первом модуле, вот короткая схема:

.gitignore: что не должно попадать в репозиторий

Файл .gitignore говорит Git, какие файлы не отслеживать.

Типичные кандидаты на игнорирование в Python-проекте:

.venv/

__pycache__/

.pytest_cache/

.mypy_cache/

.ruff_cache/

.env (если там секреты)

Пример .gitignore:

Полезный ресурс для шаблонов:

gitignore.io

Удалённый репозиторий: GitHub и origin

В команде код хранится на удалённом репозитории (часто GitHub). Обычно его называют origin.

git clone скачать репозиторий себе

git push отправить свои коммиты на сервер

git pull забрать изменения с сервера и применить локально

Официальная справка GitHub:

About pull requests

Первый пуш проекта на GitHub

Общий сценарий:

Флаг -u запоминает связь ветки с удалённой, чтобы дальше можно было писать просто git push.

Командная разработка: ветки, Pull Request, ревью

В команде почти никогда не коммитят напрямую в main. Вместо этого используют ветки.

Ветки: зачем они нужны

Ветка позволяет работать над задачей изолированно.

Практическая модель:

main всегда в рабочем состоянии

для каждой задачи создаётся ветка feature/... или fix/...

изменения проходят ревью в Pull Request

Создать ветку и переключиться:

Если у вас старый Git, аналог:

Pull Request: что это такое

Pull Request (PR) — запрос на вливание вашей ветки в основную ветку через проверку.

Обычно PR включает:

описание задачи и подхода

список изменений

результаты тестов или краткую инструкцию проверки

Code review (ревью кода) — когда другой разработчик смотрит ваш PR и оставляет комментарии.

Ключевая привычка: ревью — это не “критика”, а способ снизить риск ошибок и улучшить качество.

Как синхронизироваться с main

Пока вы работали в своей ветке, main мог обновиться. Перед PR (или в процессе) обновляйтесь:

Это создаст merge-коммит, если были изменения, и заранее покажет возможные конфликты.

Конфликты слияния: почему возникают и как решать

Конфликт возникает, когда Git не может автоматически совместить изменения: например, два человека изменили одни и те же строки в одном файле.

Типичный сценарий:

Вы делаете git merge main в своей ветке.

Git сообщает о конфликте.

Вы открываете файл, видите конфликтные блоки.

Редактируете файл до корректного состояния.

Делаете git add и завершаете merge коммитом.

Команды:

Если вы начали merge и хотите его отменить:

Практический совет: при конфликтах сначала добейтесь запуска программы и прохождения тестов, и только потом завершайте merge.

Качество истории: маленькие коммиты и понятные сообщения

История Git — это инструмент, который помогает команде разбираться в проекте.

Рекомендации:

коммит должен решать одну задачу

сообщение коммита должно объяснять что и зачем

не коммитьте “мусор”: временные файлы, большие логи, результаты запуска

Примеры хороших сообщений:

Add JSON storage for tasks

Fix parsing of empty input

Refactor TodoList to separate storage

Примеры плохих сообщений:

fix

updates

лол

Если вы ошиблись в сообщении последнего коммита:

Минимальный рабочий процесс “как в команде”

Ниже — компактный, но реалистичный процесс для ваших учебных проектов.

Обновить main.

Создать ветку под задачу.

Делать небольшие коммиты.

Запустить проект и тесты локально.

Отправить ветку в origin.

Открыть PR и пройти ревью.

Исправить замечания, если они есть.

Команды, которые вы будете использовать постоянно:

Как это связано с остальным курсом

Эта статья соединяет все предыдущие навыки в “инженерный цикл”:

вы пишете код модулями и классами, как в статье про ООП

вы храните состояние в файлах и понимаете типовые ошибки ввода/вывода

вы решаете задачи и оформляете решения как чистые функции

вы фиксируете изменения в Git так, чтобы их можно было проверять, обсуждать и безопасно откатывать

Дальше, когда появятся тесты, веб и базы данных, Git и терминал станут основой ежедневной работы.

Чек-лист готовности

Вы уверенно используете терминал для запуска Python и управления venv.

Вы понимаете цикл edit → git add → git commit.

Вы умеете работать с ветками и отправлять их в origin.

Вы понимаете смысл Pull Request и code review.

Вы знаете, как выглядит merge conflict и как его разрешать.

Базы данных и SQL: проектирование и работа из Python

В предыдущих статьях курса «Путь к Python-разработчику в 2026» вы уже:

настроили окружение и научились запускать проекты

освоили функции, модули и ООП

работали с файлами и JSON

познакомились с алгоритмами и структурой кода

выстроили рабочий процесс через Git и терминал

Следующий логичный шаг: научиться хранить данные так, как это делают реальные приложения. Файлы подходят для простых задач, но как только появляются связи между сущностями, поиск по условиям, конкурентный доступ и требования к целостности данных, почти всегда появляется база данных.

> “Data is a precious thing and will last longer than the systems themselves.” — Tim Berners-Lee (Wikiquote: Tim Berners-Lee)

Что такое база данных и где в этом месте SQL

База данных — это система хранения данных, которая помогает:

надёжно сохранять данные между запусками

быстро искать и фильтровать

поддерживать целостность (например, чтобы не появлялись «задачи без пользователя»)

безопасно работать нескольким пользователям или процессам

Реляционная база данных хранит данные в таблицах, а связи между таблицами строятся через ключи.

SQL (Structured Query Language) — язык запросов, которым вы:

создаёте таблицы и ограничения

добавляете и меняете данные

делаете выборки с фильтрацией и сортировкой

соединяете данные из нескольких таблиц

В этой статье мы будем опираться на:

SQLite для локальной разработки и учебных проектов

общие принципы, которые один-в-один работают в PostgreSQL

Полезные справочники:

Документация sqlite3 в Python

Сайт SQLite

Документация PostgreSQL

PEP 249: Python Database API Specification v2.0

Модель данных: таблицы, строки, столбцы и ключи

Минимальные понятия:

Таблица — набор однотипных записей (например, tasks).

Строка (row) — одна запись (например, одна задача).

Столбец (column) — поле записи (например, title).

Первичный ключ (primary key) — уникальный идентификатор строки (часто id).

Внешний ключ (foreign key) — ссылка на строку в другой таблице (например, task.user_id -> users.id).

Проектирование схемы: как не «закопать» проект в хаос

Правило: храните факты один раз

Если одно и то же значение хранится в нескольких местах, вы рано или поздно получите рассинхрон.

Пример плохой идеи: хранить в tasks поле username строкой. Если пользователь переименовался, придётся обновлять тысячи строк.

Правильнее: завести таблицу users, а в tasks хранить user_id.

Нормализация на бытовом уровне

Без углубления в теорию достаточно помнить 3 практических принципа:

одна ячейка — одно значение (не хранить в поле список через запятую)

данные про сущность — в её таблице

связи оформляйте ключами, а не «дублированием текста»

Ограничения: база должна защищать ваши данные

Ограничения (constraints) — это «правила», которые база проверяет сама. Типовые:

NOT NULL запрещает пустое значение

UNIQUE запрещает дубли

CHECK проверяет условие

FOREIGN KEY запрещает «битые ссылки» на несуществующие строки

Практическая мысль: валидация в Python полезна, но защита в базе обязательна.

Мини-схема для проекта задач: пользователи и задачи

Соберём простую модель, которая продолжает мини-проект TodoList из статьи про файлы, но теперь хранение будет в базе.

Сущности:

users: пользователь

tasks: задача пользователя

Связь: один пользователь имеет много задач.

!Схема показывает две таблицы и связь «один пользователь — много задач».

SQL на практике: DDL и DML

SQL-запросы условно делят на две группы:

DDL (Data Definition Language) — создание и изменение структуры (CREATE TABLE, ALTER TABLE).

DML (Data Manipulation Language) — работа с данными (SELECT, INSERT, UPDATE, DELETE).

Создание таблиц (DDL)

Пример схемы для SQLite:

Замечания:

В SQLite нет отдельного типа BOOLEAN, поэтому часто используют INTEGER со значениями 0 и 1.

PRAGMA foreign_keys = ON; включает проверку внешних ключей в SQLite.

Индекс (CREATE INDEX) ускоряет типовые запросы, например выборку задач конкретного пользователя.

Вставка данных (INSERT)

Чтение данных (SELECT)

Выбрать все задачи пользователя:

Выбрать только невыполненные:

Обновление (UPDATE)

Удаление (DELETE)

JOIN: как связывать данные из разных таблиц

JOIN нужен, когда часть информации лежит в одной таблице, а часть — в другой.

Пример: вывести задачи вместе с именем пользователя.

Здесь важно:

JOIN ... ON описывает условие связи

AS задаёт короткие псевдонимы таблиц

Транзакции: как не потерять данные при ошибках

Транзакция — это способ сделать несколько изменений как одно целое:

либо применятся все изменения

либо не применится ничего

Когда это важно:

вы создаёте пользователя и сразу создаёте для него «стартовые» задачи

вы переносите деньги между счетами

вы обновляете несколько таблиц, и нельзя оставлять систему в «полусостоянии»

В терминах действий:

BEGIN начать

COMMIT подтвердить

ROLLBACK откатить

В Python (и большинстве драйверов) транзакции обычно управляются через commit() и rollback().

Работа с SQLite из Python: безопасно и по-взрослому

Почему нельзя собирать SQL строкой

Никогда не подставляйте пользовательский ввод в SQL через f-строки или конкатенацию.

Плохо:

Правильно: используйте параметризованные запросы.

Мини-обёртка над SQLite: подключение, создание схемы, CRUD

Ниже минимальный пример, который можно положить в src/db.py.

Что здесь важно:

? — плейсхолдер параметра в SQLite.

Параметры передаются отдельным кортежем: это защищает от SQL-инъекций.

with self.connect() as con: в sqlite3 автоматически делает commit() при успехе и rollback() при исключении.

row_factory = sqlite3.Row позволяет обращаться к колонкам по имени.

Как встроить базу данных в структуру проекта

Рекомендованная минимальная структура (продолжение идеи из статей про окружение и Git):

Практические заметки:

Бинарный файл базы (todo.sqlite3) в учебных проектах можно хранить локально и добавлять в .gitignore.

Создание схемы (init_schema) удобно вызывать при старте приложения.

Индексы: когда они нужны и почему это не «магия скорости»

Индекс ускоряет поиск и фильтрацию, но замедляет вставки и обновления, потому что индекс тоже нужно поддерживать.

Почти всегда стоит индексировать:

внешние ключи (tasks.user_id), потому что по ним часто фильтруют

поля, по которым часто выбирают подмножество (done, status, created_at)

Признак, что индекс нужен: один и тот же WHERE появляется постоянно.

Типовые ошибки при работе с БД из Python

забыли включить параметризацию и получили уязвимость

не закоммитили изменения и «всё пропало» после завершения программы

храните в одной таблице данные разных сущностей и потом не можете сделать нормальные запросы

нет ограничений, и в таблице появляются записи, которые ломают бизнес-логику

Как это связано со следующими темами

Дальше база данных станет частью более крупной архитектуры:

в веб-разработке вы будете читать и писать данные из API-обработчиков

в тестировании вы будете проверять, что запросы и транзакции работают корректно

в командной разработке вы будете менять схему через миграции и проводить изменения через Pull Request

Чек-лист готовности

Вы понимаете разницу между DDL и DML.

Вы умеете спроектировать две связанные таблицы и объяснить, где первичный и внешний ключ.

Вы используете параметризованные запросы вместо сборки SQL строкой.

Вы понимаете, что такое транзакция и почему commit/rollback важны.

Вы можете реализовать базовый CRUD из Python через sqlite3.

Веб-разработка на Python, тестирование и портфолио

В прошлых статьях курса «Путь к Python-разработчику в 2026» вы собрали рабочее окружение, освоили основы Python, разобрали ООП, исключения и работу с файлами, потренировали алгоритмическое мышление, научились работать с Git и познакомились с базами данных и SQL.

Теперь вы выходите на уровень, где появляется то, что чаще всего ждут от Python-разработчика на практике:

Веб-разработка: писать HTTP-сервисы и API.

Тестирование: уметь доказывать, что код работает и изменения не ломают систему.

Портфолио: уметь упаковать проекты так, чтобы их можно было оценить, запустить и доверять им.

Цель статьи: дать вам устойчивый каркас, по которому вы сможете собрать 1–2 веб-проекта «как в реальной работе» и оформить их в портфолио.

!Картинка объясняет базовую модель HTTP: запрос клиента и ответ сервера

Веб-разработка: базовые понятия без которых не взлетит

Клиент, сервер и API

Клиент: программа, которая отправляет запросы (браузер, мобильное приложение, другой сервер).

Сервер: программа, которая принимает запросы и возвращает ответы.

API: контракт между клиентом и сервером: какие URL есть, какие параметры принимать и что возвращать.

Чаще всего в учебных и рабочих проектах вы будете делать HTTP API, которое возвращает JSON.

Полезные ссылки:

MDN Web Docs: HTTP

MDN Web Docs: HTTP response status codes

HTTP: методы, статусы, тело запроса

HTTP-метод говорит серверу, что вы хотите сделать.

| Метод | Типичный смысл | Пример | |---|---|---| | GET | получить данные | получить список задач | | POST | создать сущность | создать новую задачу | | PUT | заменить сущность целиком | заменить задачу по id | | PATCH | частично изменить | отметить задачу выполненной | | DELETE | удалить | удалить задачу |

HTTP статус-код говорит клиенту, чем закончилась операция.

| Код | Значение | Когда использовать | |---|---|---| | 200 OK | успех | обычный успешный ответ | | 201 Created | создано | успешный POST создания | | 400 Bad Request | плохой ввод | неверные данные запроса | | 401 Unauthorized | не авторизован | нет корректной авторизации | | 404 Not Found | не найдено | нет сущности с таким id | | 500 Internal Server Error | ошибка сервера | непредвиденная ошибка |

Практический принцип: статус-код и тело ответа вместе должны быть понятным сигналом для клиента.

REST как «обычная договорённость»

REST в бытовом смысле означает:

ресурсы описываются существительными, например /tasks

операции описываются HTTP-методами

сервер возвращает предсказуемый JSON

Это не религия, а удобный стандарт общения.

Выбор веб-фреймворка: что учить в 2026

В Python для веба чаще всего встречаются три имени.

| Фреймворк | Когда выбирать | Что будет в портфолио | |---|---|---| | FastAPI | API-сервисы, микросервисы, современные backend-проекты | OpenAPI/Swagger, типизация, быстрый старт | | Django | «монолит»: админка, шаблоны, ORM, много готового | большой продукт, много встроенных возможностей | | Flask | минимализм и контроль, учебные микропроекты | простой сервис, но больше ручной настройки |

Для траектории «Python-разработчик с упором в backend» практичный выбор: FastAPI.

Ссылки:

FastAPI

Uvicorn

Django

Flask

Мини-проект в вебе: Todo API на FastAPI + SQLite

Вы уже делали TodoList с JSON-файлом и отдельно изучили SQLite и SQL. Теперь вы объединяете всё в веб-сервис.

Минимальная структура проекта

Идея слоёв:

schemas.py описывает вход и выход API

db.py отвечает за доступ к данным (как в статье про БД)

main.py связывает всё в HTTP-эндпоинты

Зависимости

Примечание: httpx нужен для тест-клиента FastAPI.

Схемы данных: что принимает и что возвращает API

src/schemas.py:

Термин схема здесь означает «форма данных». FastAPI использует её для валидации входа и документации.

Доступ к базе данных как отдельный слой

Ниже упрощённый вариант на базе подхода из статьи про SQLite: параметризованные запросы, отдельный класс, понятные исключения.

src/db.py:

Здесь ключевое:

? и кортеж параметров защищают от SQL-инъекций

rowcount помогает понять, было ли обновление

HTTP-эндпоинты в FastAPI

src/main.py:

Что здесь происходит:

FastAPI создаёт приложение

декораторы @app.get, @app.post связывают функцию с URL и HTTP-методом

HTTPException превращает ошибку домена в правильный HTTP-ответ

startup-событие создаёт таблицы перед первым запросом

Запуск сервера:

После запуска откройте автодокументацию:

http://127.0.0.1:8000/docs

Эта страница генерируется автоматически на основе ваших схем и эндпоинтов.

Тестирование: как доказать, что система работает

Тестирование в разработке нужно не для «галочки», а чтобы:

не бояться менять код

быстро находить регрессии, когда вчера работало, а сегодня нет

документировать ожидаемое поведение функций и API

Виды тестов простыми словами

Unit-тесты: проверяют маленькие части кода (функции, методы) изолированно.

Интеграционные тесты: проверяют связку компонентов (например, API + база).

End-to-end: тестируют систему как пользователь (часто через браузер), для старта не обязательны.

!Иллюстрация показывает, почему обычно больше unit-тестов и меньше end-to-end

Pytest: базовый стандарт в Python

pytest популярен, потому что тесты пишутся как обычные функции, а фикстуры позволяют удобно готовить окружение.

Ссылки:

pytest

unittest.mock

Пример unit-теста на логику (если у вас есть чистая функция или метод):

Здесь:

tmp_path это встроенная фикстура pytest, которая даёт временную папку

pytest.raises проверяет, что ваш код корректно сигнализирует об ошибке

Тестирование FastAPI без запуска реального сервера

FastAPI позволяет тестировать API как библиотеку.

tests/test_api.py:

Что важно понять:

тесты должны быть повторяемыми

база для тестов должна быть отдельной (временной)

подмена зависимостей через monkeypatch помогает не трогать «боевую» базу

Что обязательно иметь в учебном проекте

тесты на валидацию ввода и ошибки

тесты на «счастливый путь» (успешные сценарии)

тесты на границы (пустая строка, несуществующий id)

Автоматизация: запуск тестов в CI

Чтобы проект выглядел «по-взрослому», добавьте CI, который запускает тесты при каждом пуше.

GitHub Actions

Даже минимальный workflow даёт доверие: видно, что проект проверяется автоматически.

Портфолио Python-разработчика: что показывать и как упаковать

Портфолио в 2026 оценивают не только по «функциональности», но и по инженерной культуре.

Что обычно хотят увидеть в репозитории

README.md с понятным описанием: что это, для кого и какие возможности.

Инструкция запуска: venv, зависимости, команды.

Примеры запросов к API: curl или коллекция запросов.

Тесты и команда запуска тестов.

Нормальная структура проекта: src/, tests/.

Понятная история Git: небольшие коммиты, ветки, PR (если делаете с другом или сами через fork).

Минимальный шаблон README для API-проекта

Описание проекта в 3–5 строк

Стек: Python, FastAPI, SQLite/PostgreSQL, pytest

Установка и запуск

Запуск тестов

Примеры API-запросов

Ограничения и идеи улучшений

Какие проекты лучше всего работают как портфолио

Ниже примеры, которые хорошо связывают предыдущие статьи курса.

Todo API

Анализатор логов

Небольшой сервис с интеграцией внешнего API

Как усилить любой из этих проектов:

добавить хранение в БД (продолжение статьи про SQL)

добавить обработку ошибок и понятные ответы (продолжение статьи про исключения)

добавить тесты и CI

добавить типизацию и линтер (из окружения и инженерных привычек)

Деплой как бонус

Деплой не обязателен, но сильно усиливает впечатление, если есть публичная ссылка.

Платформы, которые часто используют для небольших сервисов:

Render

Fly.io

Railway

Важная привычка: секреты и конфиги должны задаваться через переменные окружения, а не храниться в репозитории.

Как эта статья связывает весь курс

Вы используете Git и командную строку как основной рабочий цикл.

Вы переносите навыки проектирования данных из SQL в веб-сервис.

Вы применяете ООП и исключения, чтобы отделить «слой API» от «слоя данных».

Вы доказываете работоспособность через тесты.

Вы упаковываете результат в портфолио.

Чек-лист готовности

Вы можете объяснить разницу между GET и POST, и когда возвращать 201.

Вы умеете написать минимальный API на FastAPI и запустить его через uvicorn.

Вы используете параметризованные SQL-запросы и отделяете доступ к данным в отдельный модуль.

Вы пишете unit- и интеграционные тесты в pytest и можете прогнать их одной командой.

Ваш репозиторий можно клонировать и запустить по инструкции из README.md.