Язык программирования Python: основы и практика

Введение в Python и настройка среды разработки

Что такое Python и зачем он нужен

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

Python используют для:

автоматизации рутинных задач (скрипты)

веб-разработки (серверная часть)

анализа данных и машинного обучения

тестирования и DevOps-инструментов

обучения программированию

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

Как будет устроена практика в курсе

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

написать код

запустить и посмотреть результат

исправить ошибки

постепенно улучшать структуру проекта

!Схема показывает повторяющийся цикл: написали код → запустили → посмотрели вывод → исправили → повторили.

Версии Python: что выбирать

Python развивается, и важно понимать разницу между основными версиями:

Python 2 — устарел и больше не поддерживается

Python 3 — актуальная ветка, её и нужно устанавливать

Рекомендация для курса:

устанавливайте последнюю стабильную версию Python 3

Официальная страница загрузки:

Python Downloads

Установка Python

Windows

Что важно при установке:

включить опцию добавления Python в PATH (обычно это галочка Add python.exe to PATH)

Проверка после установки (в PowerShell или cmd):

Если команда не найдена, часто помогает одно из решений:

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

проверить, что Python добавлен в переменную окружения PATH

попробовать команду py --version (часто доступна на Windows)

macOS

Проверка версии:

На macOS системный python может быть не тем, который вам нужен, поэтому обычно используют python3.

Linux

Чаще всего Python уже установлен. Проверьте:

Если нет — установите через менеджер пакетов вашего дистрибутива (например, apt, dnf, pacman).

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

Using Python

Интерпретатор, скрипт и REPL

Python — интерпретируемый язык: вы запускаете программу через интерпретатор.

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

запускать файл со скриптом, например python main.py

работать в интерактивном режиме REPL (ввели команду → сразу получили результат)

Пример REPL (после команды python или python3):

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

Выбор редактора и IDE

Вам нужен инструмент, где удобно:

писать код

запускать программы

видеть ошибки

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

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

Visual Studio Code (лёгкий редактор + расширения)

PyCharm (IDE, ориентированная на Python)

Ссылки:

Visual Studio Code

Python extension for Visual Studio Code

PyCharm

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

если вы раньше не работали с IDE, начните с VS Code

если хотите максимум инструментов из коробки, попробуйте PyCharm

Терминал и рабочая папка проекта

Важно различать:

где лежит ваш файл (папка проекта)

откуда вы запускаете команду (текущая директория терминала)

Почти всегда запуск выглядит так:

При этом терминал должен быть открыт в папке, где лежит main.py.

Виртуальные окружения: зачем они нужны

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

Идея простая:

у каждого проекта свой набор установленных пакетов

установка пакетов не загрязняет систему

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

Создание и активация venv

Создайте папку проекта, зайдите в неё, затем:

Активация:

Windows (PowerShell):

Windows (cmd):

macOS/Linux:

Признак активации — в начале строки терминала обычно появляется имя окружения, например (.venv).

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

venv — Creation of virtual environments

pip: установка библиотек

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

Примеры:

установить пакет:

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

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

установить зависимости из файла:

Справка:

pip documentation

Первый проект: запуск программы

Создайте папку проекта, например python-course, и файл main.py.

Код в main.py:

Запуск из терминала (находясь в папке проекта):

Если у вас macOS/Linux и команда python указывает не на Python 3, используйте:

Типичные ошибки на старте и как их диагностировать

Команда python не найдена

Возможные причины:

Python не установлен

Python установлен, но не добавлен в PATH

используется не та команда (например, нужно python3)

Запускается не та версия Python

Проверьте версию:

и при необходимости:

Ошибка с виртуальным окружением

Частые причины:

окружение не активировано и пакеты ставятся не туда

в IDE выбран не тот интерпретатор

Что делать:

активировать .venv

в настройках IDE выбрать интерпретатор из .venv

Как подготовиться к следующим темам

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

открыть терминал и перейти в папку проекта

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

запустить файл main.py

установить пакет через pip внутри окружения

На следующем шаге мы начнём изучать базовый синтаксис Python: переменные, типы данных, ввод-вывод и простые операции.

Синтаксис, типы данных и управляющие конструкции

Как связана эта тема с предыдущей

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

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

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

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

Пример с условием:

Практическое правило:

используйте 4 пробела для каждого уровня отступа

Комментарии

Комментарии помогают объяснять код и не выполняются интерпретатором.

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

Инструкция и выражение

Важно различать:

выражение вычисляет значение, например 2 + 2

инструкция выполняет действие, например if ...: или print(...)

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

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

Переменная в Python появляется в момент присваивания.

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

используйте понятные имена: total, user_name, price

регистр важен: Age и age это разные имена

обычно используют стиль snake_case: user_name

Динамическая типизация

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

Это удобно, но требует аккуратности: 10 и "10" это разные вещи.

Встроенные типы данных

Ниже самые важные типы, которые будут постоянно встречаться в курсе.

Числа: int и float

int это целые числа, например -3, 0, 42

float это числа с дробной частью, например 3.14, 0.5

Что означают операции:

a / b обычное деление

a // b целочисленное деление (берётся только целая часть результата)

a % b остаток от деления

Строки: str

Строка это последовательность символов.

Полезные операции:

конкатенация (склеивание) через +

длина строки через len(s)

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

Логический тип: bool

bool имеет два значения:

True

False

Часто получается в результате сравнения:

Логические операции:

and это логическое и

or это логическое или

not это логическое не

Коллекции: list, tuple, dict, set

На старте достаточно понимать, что они хранят и когда применяются.

list список, изменяемая упорядоченная коллекция

tuple кортеж, неизменяемая упорядоченная коллекция

dict словарь, хранит пары ключ → значение

set множество, хранит уникальные элементы

Примеры:

Официальная справка по встроенным типам:

Built-in Types

Приведение типов

Частая ситуация: данные пришли как строка, а вам нужно число.

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

int("123")

float("3.14")

str(123)

bool(x)

Важно: int("12.5") вызовет ошибку, потому что строка не выглядит как целое число.

Ввод и вывод

Вывод: print

print печатает значения.

Ввод: input

input читает строку из терминала.

Важно помнить:

input всегда возвращает str

Если нужен int:

Управляющие конструкции

Управляющие конструкции позволяют программе принимать решения и повторять действия.

!Схема показывает ветвление if и повторение в цикле

Условный оператор if

Синтаксис:

Правила:

после if, elif, else ставится двоеточие :

тело блока пишется с отступом

Сравнения

Основные операторы сравнения:

== равно

!= не равно

<, <=, >, >=

Пример:

Истинность значений

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

0, 0.0

пустая строка ""

пустой список []

пустой словарь {}

None

Пример:

Цикл while

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

Важно:

если не менять значения, влияющие на условие, можно получить бесконечный цикл

Цикл for и range

for обычно используют для перебора последовательностей.

range(5) создаёт последовательность чисел 0, 1, 2, 3, 4.

Частые варианты:

range(n) от 0 до n - 1

range(a, b) от a до b - 1

range(a, b, step) с шагом step

break и continue

Иногда нужно управлять циклом вручную.

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

continue переходит к следующей итерации

Пример break:

Пример continue:

Официальная документация по управляющим конструкциям:

More Control Flow Tools

Типичные ошибки новичков

IndentationError из-за неверных отступов или смешивания табов и пробелов

путаница = и ==

попытка сложить строку и число без приведения типов, например "10" + 5

ожидание, что input вернёт число, хотя он возвращает строку

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

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

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

Функции, модули и работа с пакетами

Связь с предыдущими темами

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

выносить повторяющуюся логику в функции

разбивать проект на модули (файлы .py)

подключать пакеты из интернета через pip и фиксировать зависимости

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

!Схема показывает как функции живут в модулях, модули в пакете, а внешние зависимости ставятся через pip в виртуальное окружение

Функции: зачем они нужны

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

Функции помогают:

уменьшать дублирование кода

делать программу понятнее за счёт говорящих имён

изолировать логику и проще тестировать

Документация: Определение функций (Python Tutorial)

Как объявлять и вызывать функцию

Функция создаётся с помощью def.

Правила, которые важно запомнить:

после имени функции идут круглые скобки с параметрами

тело функции пишется с отступом

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

Параметры и аргументы

Термины часто путают:

параметры — переменные в объявлении функции

аргументы — реальные значения при вызове

return: как функция возвращает результат

return завершает выполнение функции и отдаёт значение наружу.

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

Локальные и глобальные переменные (область видимости)

Переменные, созданные внутри функции, обычно не видны снаружи.

Если переменная объявлена вне функции, она глобальная (в рамках файла), и её можно читать внутри функции.

Практическое правило:

старайтесь передавать данные в функцию через параметры и получать через return

Это делает код предсказуемее и проще для отладки.

Значения параметров по умолчанию

Параметр может иметь значение по умолчанию.

Важно:

параметры без значения по умолчанию должны идти до параметров с значением по умолчанию

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

Вы можете передавать аргументы по имени — это повышает читаемость.

Функции как строительные блоки программы

Типичная стратегия:

в main.py оставить только запуск сценария

основную логику разнести по функциям

Пример:

Код работает, но его можно улучшить: при импорте такого файла main() выполнится автоматически. Ниже разберём, как это правильно устроить через модули и точку входа.

Модули: как устроен import

Модуль в Python — это обычный файл .py, который можно импортировать.

Документация: Модули (Python Tutorial)

Пример: выносим функции в отдельный файл

Пусть структура проекта такая:

main.py

utils.py

Файл utils.py:

Файл main.py:

Варианты импорта

Чаще всего используют такие формы:

import utils

from utils import sum_to

import utils as u

Пример с import utils:

Практическое правило:

если вы используете много функций из модуля, удобен import module

если вы используете 1–2 функции, удобен from module import name

__name__ и точка входа

Когда Python запускает файл напрямую, у него __name__ равно строке "__main__". Когда файл импортируют как модуль, __name__ равно имени модуля.

Это позволяет писать код, который:

выполняется при запуске файла

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

Так принято оформлять точку входа в программах и учебных проектах.

Пакеты: модуль из нескольких файлов

Пакет — это папка с Python-кодом, которая обычно содержит файл __init__.py.

Документация: Пакеты (Python Tutorial)

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

main.py

myapp/

myapp/__init__.py

myapp/utils.py

myapp/utils.py:

main.py:

Что даёт пакет:

можно группировать код по смыслу (например, myapp/io.py, myapp/math.py)

проще масштабировать проект без гигантского main.py

Работа с внешними пакетами: pip и PyPI

PyPI — основной каталог пакетов Python.

сайт: Python Package Index (PyPI)

Установка пакета

Убедитесь, что вы активировали виртуальное окружение, затем:

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

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

Использование установленного пакета

Пример запроса (только как демонстрация импорта):

Как фиксировать зависимости: requirements.txt

Чтобы другой человек (или вы на другом компьютере) поставил те же библиотеки, зависимости фиксируют в файле requirements.txt.

Сохранить текущие зависимости:

Установить зависимости из файла:

Практическое правило:

добавляйте requirements.txt в проект, если используете внешние пакеты

Типичные ошибки и как их избегать

ModuleNotFoundError: модуль не найден.

Причина: пакет не установлен в текущее окружение или вы запускаете не тем интерпретатором.

Решение: активируйте .venv, проверьте интерпретатор в IDE, переустановите пакет через pip.

Конфликт имён.

Причина: вы назвали свой файл так же, как популярный пакет, например requests.py.

Решение: переименуйте файл, удалите лишние .pyc при необходимости.

Код выполняется при импорте.

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

Решение: используйте if __name__ == "__main__": для запуска сценария.

Что дальше

Теперь вы умеете:

оформлять логику в функциях и возвращать результат через return

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

организовывать код в пакеты

подключать внешние зависимости через pip и фиксировать их в requirements.txt

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

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

Связь с предыдущими темами

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

В Python большую часть практических задач решают комбинацией:

подходящей структуры данных (list, dict, set)

аккуратного перебора (циклы, enumerate, zip)

нескольких алгоритмических шаблонов (подсчёт, поиск, сортировка, два указателя)

!Сравнение основных структур данных и типовых задач

Список: list

list — упорядоченная изменяемая коллекция. Подходит, когда важен порядок и элементы можно добавлять/удалять.

Основные операции со списками

Примеры:

Доступ по индексу:

Срезы:

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

индексация начинается с 0

отрицательные индексы читаются с конца

срез создаёт новый список, а не «вид» на исходный

Кортеж: tuple

tuple — упорядоченная неизменяемая коллекция.

Используйте tuple, когда:

набор значений не должен меняться

вы хотите зафиксировать структуру данных (например, точка (x, y))

Пример:

Словарь: dict

dict хранит пары ключ → значение.

Ключевые идеи:

доступ по ключу обычно намного удобнее, чем поиск по списку

ключ должен быть хешируемым (например, str, int, tuple из хешируемых элементов)

Основные операции со словарём

Безопасное чтение через get:

Перебор словаря:

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

Словари (dict)

Множество: set

set хранит уникальные элементы и отлично подходит для:

удаления дублей

проверки «входит ли элемент»

операций над множествами (пересечение, объединение)

Примеры:

Операции множеств:

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

Множества (set)

Как выбирать структуру данных

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

| Задача | Лучше всего подходит | Почему | |---|---|---| | Хранить последовательность с порядком | list | индексация, добавление, перебор | | Зафиксировать набор значений | tuple | неизменяемость, читаемость | | Хранить соответствия «ключ → значение» | dict | быстрый доступ по ключу | | Хранить уникальные значения | set | уникальность и быстрые проверки in |

Время выполнения: почему это важно

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

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

проверка x in some_list может быть медленной на больших списках, потому что иногда приходится просмотреть почти все элементы

проверка x in some_set и x in some_dict обычно быстрее, потому что структура оптимизирована для поиска

Иногда это описывают асимптотикой.

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

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

Здесь — число элементов в коллекции.

> Важно: для dict и set быстрый доступ — это типичное поведение в среднем. В редких случаях возможны отклонения, но для учебных и большинства практических задач можно считать это хорошей моделью.

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

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

Подсчёт частот через словарь

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

Почему это удобно:

dict хранит счётчик по ключу

get(key, 0) решает проблему «ключа ещё нет»

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

Методы словаря: get

Накопление результата (reduce-подход)

Идея: пройти по данным и обновлять переменную-аккумулятор.

Пример: сумма положительных чисел.

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

Построение новых коллекций: генераторы списков

Генератор списка — компактный способ создать новый список из существующего.

Практическое правило:

если логика в выражении становится сложной, лучше вернуться к обычному циклу и append, чтобы код читался легче

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

List comprehensions

Два указателя для отсортированных данных

Шаблон «два указателя» часто используют, когда данные отсортированы.

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

Почему это эффективно:

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

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

!Иллюстрация приёма «два указателя» для поиска пары

Бинарный поиск (поиск в отсортированном списке)

Если список отсортирован, можно искать элемент не перебором, а делением пополам.

В Python для этого часто используют модуль bisect.

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

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

Модуль bisect

Сортировка и ключи сортировки

Сортировка — один из самых частых шагов подготовки данных.

Пример: отсортировать список строк по длине.

Сортировка списка на месте:

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

sorted

list.sort

Типичные ошибки при работе со структурами данных

попытка обратиться к несуществующему ключу словаря через d[key] вместо d.get(key)

изменение списка во время перебора (часто приводит к пропускам элементов)

ожидание, что set сохранит порядок элементов

путаница между «изменить объект» и «создать новый» (например, срезы списков создают новый список)

Как связать это с функциями и модулями

Хорошая практика для учебных мини-проектов:

вынести алгоритмы в функции (например, count_words, has_pair_with_sum)

держать ввод-вывод в main()

разнести по модулям: algorithms.py, io.py, main.py

Так ваш код будет проще проверять, расширять и переиспользовать.

Что дальше

Теперь у вас есть база для решения практических задач:

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

знаете несколько ключевых алгоритмических шаблонов

можете оформлять решения в виде функций и модулей

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

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

Связь с предыдущими темами

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

В этой статье вы освоите:

ввод и вывод данных более осмысленно (не только print и input)

чтение и запись файлов

обработку ошибок через исключения

сборку мини-проекта, который объединяет все навыки

!Общая схема: от ввода пользователя до чтения/записи файлов и вывода результата

Ввод-вывод в консоли

print как инструмент форматирования

print умеет больше, чем просто печатать строку.

Печать нескольких значений через пробел по умолчанию

Управление разделителем через sep

Управление окончанием строки через end

input всегда возвращает строку

Даже если пользователь ввёл число, input возвращает str. Поэтому для чисел нужно явное приведение типов.

> Если пользователь введёт не число (например, abc), то int(...) выбросит исключение. В разделе про исключения вы научитесь это обрабатывать.

Файлы: зачем они нужны

Файлы позволяют программе:

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

обрабатывать большие объёмы данных (логи, списки, выгрузки)

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

В Python работа с файлами строится вокруг функции open.

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

open

Открытие файла и менеджер контекста with

Почему важно использовать with

Файл нужно закрывать. Если забыть закрыть файл, можно получить:

утечки ресурсов

проблемы с записью (данные не успели “сброситься” на диск)

блокировки файла в некоторых ОС

Правильный способ в Python — использовать менеджер контекста with, который гарантированно закроет файл.

Здесь:

"data.txt" — путь к файлу

"r" — режим чтения

encoding="utf-8" — кодировка (почти всегда правильный выбор для текстовых файлов)

as f — переменная, через которую вы работаете с файлом

Режимы открытия файла

Ниже самые частые режимы для текстовых файлов.

| Режим | Что делает | Если файла нет | Если файл есть | |---|---|---|---| | "r" | чтение | ошибка | читает | | "w" | запись | создаст | перезапишет | | "a" | добавление в конец | создаст | допишет | | "r+" | чтение и запись | ошибка | читает и пишет |

Практическое правило:

для чтения используйте "r"

для генерации результата “с нуля” используйте "w"

для логов и накопления данных используйте "a"

Чтение текстовых файлов

Прочитать файл целиком: read

Подходит для небольших файлов.

Прочитать файл построчно

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

Здесь rstrip("\n") убирает перевод строки в конце строки (чтобы печать была аккуратнее).

readline и readlines

Используются реже, но важно знать:

readline() читает одну строку

readlines() читает все строки и возвращает список строк

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

Text I/O

Запись текстовых файлов

Перезапись: режим w

Важно:

write не добавляет перевод строки автоматически

"w" удалит старое содержимое файла

Дозапись: режим a

Пути к файлам: относительные и абсолютные

Относительный путь

"data.txt" — это относительный путь. Он означает: файл лежит в текущей рабочей папке, то есть там, откуда вы запускаете программу.

Абсолютный путь

Абсолютный путь указывает файл полностью (например, с диском на Windows).

Практическое правило для учебных проектов:

храните входные файлы рядом с main.py

запускайте программу из папки проекта

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

Модуль pathlib помогает писать более переносимый код.

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

pathlib

Исключения: как Python сообщает об ошибках

Что такое исключение

Исключение — это объект, который Python “выбрасывает”, когда программа не может продолжать выполнение обычным образом.

Примеры типичных исключений:

ValueError — неверное значение (например, int("abc"))

FileNotFoundError — файл не найден

ZeroDivisionError — деление на ноль

KeyError — нет ключа в словаре при доступе через d[key]

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

Built-in Exceptions

try и except: ловим ошибки и продолжаем работу

Базовый шаблон

Идея:

код в try выполняется “как обычно”

если возникла ошибка, управление переходит в подходящий except

!Понимание маршрута выполнения кода при ошибке и при её отсутствии

else и finally

Иногда удобно разделить “успешный сценарий” и “обязательные действия в конце”.

| Часть | Когда выполняется | Для чего нужна | |---|---|---| | else | если в try не было ошибок | логика успеха | | finally | всегда (и при успехе, и при ошибке) | освобождение ресурсов, финальные действия |

Пример:

Что важно не делать

Не стоит писать “ловим всё” без причины:

Так можно скрыть реальные баги. Лучше ловить конкретные исключения, которые вы действительно ожидаете.

Как “поднимать” исключения самому: raise

Иногда вы хотите явно запретить неверные данные и сообщить об этом стандартным способом.

Здесь:

raise ValueError(...) создаёт и выбрасывает исключение

вызывающий код может поймать его через try/except

Формат данных JSON: удобно для мини-проектов

Текстовые файлы часто хранят не “просто строки”, а структурированные данные. Один из самых популярных форматов — JSON.

Модуль json позволяет:

json.dump записать Python-объект в файл

json.load прочитать из файла обратно в Python-объект

Параметры:

ensure_ascii=False сохраняет кириллицу читаемо

indent=2 делает файл красивым для человека

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

json

Мини-проект: консольный трекер задач

Соберём небольшой проект, который объединяет:

функции и модули

списки и словари

работу с файлом

обработку исключений

Постановка задачи

Сделаем программу todo, которая умеет:

добавлять задачу

показывать список задач

отмечать задачу выполненной

сохранять задачи в todo.json

Структура хранения задач (в памяти) будет такой:

список tasks

каждый элемент — словарь с полями id, text, done

Пример одного элемента:

{"id": 1, "text": "Купить молоко", "done": false}

Архитектура проекта

Предложенная структура файлов:

main.py — точка входа и разбор команды пользователя

storage.py — загрузка и сохранение todo.json

todo.py — операции над задачами (добавить, вывести, завершить)

Так вы практикуете разбиение кода на модули и не превращаете main.py в “простыню”.

Модуль storage.py

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

если файла нет, возвращаем пустой список

если файл битый или чтение невозможно, тоже возвращаем пустой список

сохранение всегда перезаписывает файл актуальным состоянием

Модуль todo.py

main.py: интерфейс через простые команды

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

add — добавить задачу

list — показать задачи

done — завершить по id

exit — выйти

Что вы прокачали этим мини-проектом

Структуры данных: список словарей для хранения сущностей

Алгоритмические приёмы: поиск по списку, подсчёт следующего id

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

Файлы: сохранение состояния между запусками

Исключения: защита от некорректного ввода пользователя

Типичные ошибки и как их диагностировать

FileNotFoundError при чтении

Причина: файл отсутствует, а вы открываете в режиме "r".

Решение: проверяйте существование или создавайте файл заранее, или используйте логику “если нет, вернуть пустое”.

UnicodeDecodeError

Причина: несовпадение кодировки.

Решение: явно указывать encoding="utf-8" и хранить файлы в UTF-8.

json.JSONDecodeError

Причина: файл JSON повреждён или содержит не JSON.

Решение: ловить исключение и восстанавливать пустое состояние или делать резервную копию.

Программа “не видит” файл

Причина: текущая рабочая папка не совпадает с папкой проекта.

Решение: запускать из папки проекта или использовать абсолютные пути, или pathlib с понятной базой.

Что дальше

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

Следующие логичные шаги практики:

тестирование функций (чтобы проверять логику без ручного ввода)

работа с более сложными форматами и источниками данных

усложнение архитектуры мини-проекта (например, команды через аргументы командной строки)