Программирование на Python: основы и практика

Введение в Python и настройка окружения

Зачем вам Python в этом курсе

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

научиться писать понятный код;

разобраться с базовыми конструкциями (переменные, условия, циклы, функции);

освоить работу с файлами и модулями;

настроить правильное окружение разработки, чтобы проекты не «ломались» из‑за зависимостей.

К концу этой статьи у вас должно быть установленное окружение и понимание, как запускать Python‑код.

Что такое Python и как он работает

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

Python обычно запускается так:

Вы пишете код в файле (например, main.py) или в интерактивной консоли.

Интерпретатор Python читает ваш код и выполняет его сверху вниз.

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

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

Где используется Python

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

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

Аналитика данных и машинное обучение.

Тестирование: автотесты.

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

Важная мысль про стиль кода

> Beautiful is better than ugly. > Explicit is better than implicit. > Simple is better than complex. > Complex is better than complicated. > ... > Readability counts. > > The Zen of Python (PEP 20) — набор принципов, на которые часто ориентируются Python‑разработчики. PEP 20

Что нужно установить

Для обучения вам понадобится:

Python 3 (интерпретатор и стандартная библиотека).

Текстовый редактор или IDE (например, Visual Studio Code).

Терминал (встроенный в ОС или в редакторе).

Почему именно Python 3

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

Установка Python

Шаг 1. Скачайте Python

Скачивайте Python с официального сайта:

Python Downloads

Рекомендуем ставить актуальную стабильную версию Python 3.

Шаг 2. Установите и проверьте установку

#### Windows

Запустите установщик.

Обязательно отметьте галочку Add python.exe to PATH (или похожую).

Завершите установку.

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

Если команда python не находится, попробуйте:

#### macOS

На macOS Python может уже быть установлен, но важно, чтобы это был Python 3.

Установите Python с сайта:

- Python Downloads

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

#### Linux

Во многих дистрибутивах Python 3 уже есть.

Проверка:

Если Python 3 не установлен, установите через менеджер пакетов вашей системы (команды зависят от дистрибутива).

Текстовый редактор или IDE

Для курса удобно использовать Visual Studio Code.

Visual Studio Code

После установки VS Code поставьте расширение Python:

Python extension for VS Code

Сравнение вариантов

| Вариант | Плюсы | Минусы | Когда выбирать | |---|---|---|---| | Visual Studio Code | Бесплатный, много расширений, удобно для проектов | Нужно один раз настроить | Универсальный вариант для курса | | PyCharm Community | Сильная поддержка Python из коробки | Может быть тяжелее на слабых ПК | Если хотите IDE «всё в одном» | | Любой текстовый редактор + терминал | Минимум лишнего, полезно для понимания | Меньше подсказок | Если любите простоту |

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

pip — стандартный менеджер пакетов Python. Он скачивает и устанавливает библиотеки.

Проверка, что pip доступен:

На macOS/Linux иногда используют python3:

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

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

pip documentation

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

Когда вы устанавливаете библиотеки через pip, они попадают в окружение Python. Если ставить всё «в систему», быстро возникает хаос:

одному проекту нужна одна версия библиотеки;

другому — другая;

в итоге всё конфликтует.

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

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

venv — Creation of virtual environments

Создание виртуального окружения

Перейдите в папку будущего проекта и выполните:

На macOS/Linux, если Python запускается как python3:

Активация виртуального окружения

#### Windows (PowerShell)

#### Windows (cmd)

#### macOS/Linux

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

Установка пакета в виртуальное окружение

Когда окружение активировано:

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

Первый запуск Python

Вариант 1. Интерактивная консоль

Запуск:

Вы увидите приглашение ввода >>>. Попробуйте:

Чтобы выйти:

Windows: Ctrl+Z, затем Enter

macOS/Linux: Ctrl+D

Вариант 2. Запуск файла

Создайте файл main.py:

Запустите:

Рекомендуемая структура проекта на старте

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

project/

- .venv/ (виртуальное окружение) - main.py - README.md (краткое описание проекта)

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

Частые проблемы и как их решать

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

Windows: при установке не отметили добавление в PATH. Переустановите Python, включив опцию Add to PATH, или используйте py.

macOS/Linux: попробуйте python3 вместо python.

Установили пакет, но импорт не работает

Чаще всего причина одна: пакет установили не в то окружение.

Проверьте, какой Python используется:

На Windows вместо этого можно посмотреть путь так:

И убедитесь, что у вас активировано .venv.

VS Code не видит виртуальное окружение

В VS Code выберите интерпретатор Python:

Откройте палитру команд.

Найдите команду выбора интерпретатора.

Выберите Python из .venv.

(Названия пунктов могут немного отличаться в зависимости от версии VS Code, но смысл один: редактор должен запускать код тем Python, который в вашем окружении.)

Что дальше по курсу

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

запуск python в терминале;

запуск файла main.py;

создание и активация виртуального окружения .venv.

Базовый синтаксис: типы данных, операции, ввод-вывод

Связь с предыдущей темой

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

Как читать примеры и запускать код

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

В интерактивной консоли (REPL), запустив python и вводя команды по строке

В файле main.py, запуская python main.py

Если вы используете виртуальное окружение .venv, убедитесь, что оно активировано, а VS Code выбрал интерпретатор из .venv.

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

Переменная в Python — это имя, которое ссылается на некоторое значение.

Пример:

Здесь:

name и age — имена переменных

= — оператор присваивания

справа находятся значения: строка и целое число

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

Имена чувствительны к регистру: name и Name — разные переменные

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

Нельзя начинать имя с цифры и использовать пробелы

Рекомендации по стилю кода описаны в PEP 8: PEP 8

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

У каждого значения в Python есть тип — он определяет, какие операции допустимы.

Проверить тип можно функцией type():

Основные типы

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

Примеры:

!Шпаргалка по базовым типам данных и их назначению

Важное про bool

Логический тип часто получается из сравнений:

Операции: что можно делать со значениями

Арифметика

| Операция | Пример | Результат | |---|---|---| | сложение | 2 + 3 | 5 | | вычитание | 5 - 2 | 3 | | умножение | 4 * 2 | 8 | | деление | 5 / 2 | 2.5 | | целочисленное деление | 5 // 2 | 2 | | остаток от деления | 5 % 2 | 1 | | степень | 2 ** 3 | 8 |

Пример:

Операции сравнения

Они возвращают True или False.

| Операция | Смысл | Пример | |---|---|---| | == | равно | x == 10 | | != | не равно | x != 10 | | > | больше | x > 10 | | < | меньше | x < 10 | | >= | больше или равно | x >= 10 | | <= | меньше или равно | x <= 10 |

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

Используются для объединения условий:

and — истинно, если истинны оба условия

or — истинно, если истинно хотя бы одно

not — инвертирует значение

Пример:

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

Строки в Python имеют тип str.

Полезные операции со строками

| Операция | Пример | Что делает | |---|---|---| | конкатенация | "a" + "b" | склеивает строки | | повторение | "ha" * 3 | повторяет строку | | длина | len("abc") | возвращает количество символов | | индекс | "abc"[0] | возвращает символ по позиции |

Пример:

Форматирование строк

Самый удобный современный способ — f-строки:

Здесь в фигурных скобках {} можно писать выражения:

Коллекции: как хранить много значений

Когда данных больше одного, используют коллекции.

Список list

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

Частые операции:

доступ по индексу: numbers[0]

изменение: numbers[1] = 99

длина: len(numbers)

Кортеж tuple

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

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

Словарь dict

Словарь хранит пары ключ → значение.

Если ключа нет, обращение user["missing"] вызовет ошибку. Позже вы изучите безопасные способы получения значений.

Множество set

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

Ввод и вывод: print() и input()

Вывод: print()

print() печатает значения в терминал.

По умолчанию print() разделяет аргументы пробелом и заканчивает строку переводом строки.

Ввод: input()

input() читает строку от пользователя.

Ключевой момент:

input() всегда возвращает тип str

Если вам нужно число, его надо преобразовать.

Преобразование типов

Из строки в число

Если пользователь введет не число (например, abc), int() вызовет ошибку. Позже вы научитесь обрабатывать такие ситуации.

Для дробных чисел используют float():

Из числа в строку

Иногда нужно склеить текст и число. Для этого можно использовать str() или f-строку.

Частые ошибки новичков

Склеивание строки и числа

Так нельзя:

Правильно так:

Непонимание, что input() возвращает строку

Чтобы получилось 4:

Деление и тип результата

Операция / почти всегда возвращает float, даже если делится нацело:

Мини-итог

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

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

основные типы: int, float, str, bool, None

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

базовые коллекции: list, tuple, dict, set

ввод-вывод: print() и input()

преобразование типов: int(), float(), str()

Официальная справка по встроенным типам и функциям: Built-in Types, Built-in Functions

Что дальше

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

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

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

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

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

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

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

Как программа принимает решения: if, elif, else

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

Базовая форма if

Здесь:

age >= 18 возвращает True или False

если условие истинно, выполняется блок с отступом

Ветвление if + else

Несколько веток: elif

Важно про отступы

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

чаще всего применяют 4 пробела

смешивать табы и пробелы не стоит

!Диаграмма показывает, как if/else выбирает один из двух путей выполнения

Логика в условиях: and, or, not

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

Полезный приём: если вы получаете True/False через сравнение, можно сразу присваивать результат переменной, как в примере выше.

Повторение действий: циклы

Циклы позволяют выполнять один и тот же блок кода много раз.

Цикл while

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

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

Цикл for

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

range() для последовательностей чисел

Если нужно повторить действие N раз или пройти по числам, используют range().

Частые формы:

range(n) даёт числа от 0 до n - 1

range(a, b) даёт числа от a до b - 1

range(a, b, step) задаёт шаг

Пример со шагом:

!Иллюстрация помогает увидеть разницу: while зависит от условия, for перебирает элементы

Управление циклом: break и continue

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

break

break немедленно прерывает цикл.

continue

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

Полезный шаблон: проверка ввода в цикле

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

Здесь:

.strip() убирает пробелы по краям

.lower() делает строку в нижнем регистре

Функции: как упаковать логику в понятные блоки

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

Зачем нужны функции

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

улучшают читаемость

упрощают тестирование и поиск ошибок

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

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

Как объявить функцию: def

Здесь:

greet это имя функции

name это параметр

вызов greet("Аня") передаёт аргумент

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

Функция может вернуть значение с помощью return.

Ключевое различие:

print() показывает значение пользователю

return отдаёт значение обратно в программу

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

Ранний return

return завершает функцию сразу.

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

Можно задавать значения по умолчанию.

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

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

Область видимости: где «живут» переменные

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

Термины:

локальная переменная создаётся внутри функции

глобальная переменная объявлена на уровне файла

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

Докстроки: как кратко документировать функцию

В Python принято писать строку документации первой строкой внутри функции.

Такой текст можно посмотреть через help().

Мини-итог

В этой статье вы изучили основу логики программ:

ветвления if, elif, else

логические выражения в условиях

циклы while и for, а также range()

управление циклом через break и continue

создание функций через def, параметры и return

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

Что дальше

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

Коллекции, строки, файлы и обработка исключений

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

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

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

строки, чтобы чистить, разбирать и форматировать текст

файлы, чтобы читать и сохранять данные вне программы

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

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

Built-in Types

Text Sequence Type — str

Reading and Writing Files

Errors and Exceptions

Коллекции: как выбирать и использовать

В Python самые частые коллекции: list, tuple, dict, set. Правильный выбор упрощает код.

Краткая памятка

| Коллекция | Что хранит | Порядок | Изменяемость | Типичный сценарий | |---|---|---|---|---| | list | элементы | сохраняется | изменяемая | список задач, товары, числа | | tuple | элементы | сохраняется | неизменяемая | координаты, фиксированные данные | | dict | ключ → значение | сохраняется | изменяемая | настройки, карточка пользователя | | set | уникальные элементы | не гарантируется | изменяемая | уникальные теги, устранение дублей |

Списки list: индексы, срезы, методы

Индексы и отрицательные индексы

Срезы

Срез берёт часть списка: items[start:stop:step].

Частые методы списка

append(x) добавляет элемент в конец

extend(iterable) добавляет много элементов

insert(i, x) вставляет по индексу

remove(x) удаляет первое вхождение значения

pop(i) удаляет и возвращает элемент (по умолчанию последний)

sort() сортирует на месте

reverse() разворачивает на месте

Пример:

Важный момент: изменяемость

Список можно менять после создания:

Это полезно, но требует аккуратности при передаче списка в функции.

Кортежи tuple: когда нужна неизменяемость

Кортеж похож на список, но его нельзя изменить.

Кортежи часто используют:

для фиксированных наборов значений

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

Словари dict: ключи, значения и безопасное получение

Словарь хранит пары ключ → значение.

Добавление и обновление

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

Безопасное получение: get

user["missing"] вызывает KeyError, если ключа нет. Часто лучше использовать get.

Множества set: уникальность и операции над множествами

Множество автоматически убирает дубликаты.

Базовые операции

Как итерироваться по коллекциям

Вы уже использовали for. Здесь важные варианты.

enumerate: индекс + элемент

zip: параллельный перебор

Списковые включения: компактная обработка данных

Списковое включение создаёт новый список из другого итерируемого объекта.

С условием:

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

Строки str: методы, срезы, поиск и форматирование

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

Срезы у строк такие же, как у списков

Частые методы строк

| Метод | Пример | Результат | |---|---|---| | strip() | " hi \n".strip() | "hi" | | lower() | "Py".lower() | "py" | | upper() | "Py".upper() | "PY" | | replace(a, b) | "a-b".replace("-", ":") | "a:b" | | split(sep) | "a,b".split(",") | ['a', 'b'] | | join(list) | ",".join(["a","b"]) | "a,b" | | startswith(x) | "file.txt".startswith("file") | True | | find(x) | "abc".find("b") | 1 |

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

split и join для работы со словами

Форматирование: f-строки и формат чисел

Здесь :.1f означает один знак после запятой.

Файлы: чтение и запись

Файлы позволяют сохранять результат работы программы и загружать данные позже.

!Схема жизненного цикла файла и преимущества with

Открытие файла и кодировка

Самый безопасный и привычный способ: контекстный менеджер with. Он гарантирует закрытие файла.

Пояснения:

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

режим "r" это чтение

encoding="utf-8" важно для корректной работы с кириллицей

Режимы открытия

| Режим | Что делает | |---|---| | "r" | чтение (файл должен существовать) | | "w" | запись (перезаписывает файл) | | "a" | добавление в конец | | "x" | создать новый файл (ошибка, если уже существует) |

Чтение построчно

Удобно для больших файлов.

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

Запись в файл

Частая ошибка: забыть про \n

write() не добавляет перевод строки автоматически. Если вы хотите писать построчно, добавляйте "\n" сами.

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

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

!Схема работы try/except/else/finally

Официальная справка: Errors and Exceptions

Пример: обработка неверного ввода числа

Пояснения:

в блоке try пишут код, который может упасть

except ValueError перехватывает конкретную ошибку преобразования

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

finally: действия, которые должны выполниться всегда

finally полезен, когда нужно гарантированно выполнить завершение операции.

На практике вместо этого обычно используют with open(...), и finally не нужен.

Частые исключения в бытовых задачах

ValueError неправильный формат значения, например int("abc")

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

PermissionError нет прав на чтение или запись

KeyError нет ключа в словаре при обращении d[key]

IndexError индекс выходит за границы списка

Когда использовать dict.get, а когда try/except

Оба подхода нормальны, но задачи разные:

d.get("key") удобно, когда отсутствие ключа это нормальная ситуация

try/except KeyError полезен, когда отсутствие ключа это неожиданно и вы хотите обработать это как ошибку

Пример с get:

raise: как создавать ошибки осознанно

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

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

Небольшой пример: чтение файла, обработка строк и защита от ошибок

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

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

with open(...) безопасно открывает файл

strip() очищает пробелы и перевод строки

continue пропускает пустые строки

try/except защищает от некорректных данных

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

Мини-итог

В этой статье вы расширили практическую базу:

уверенно используете list, tuple, dict, set и понимаете, что выбирать

умеете итерироваться с for, enumerate, zip

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

читаете и записываете файлы через with open(..., encoding="utf-8")

обрабатываете ошибки через try/except/else/finally и при необходимости используете raise

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

Модули, пакеты и мини-проекты для закрепления

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

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

не превращался в один огромный main.py

легко расширялся

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

Для этого Python даёт три базовых инструмента:

модули — файлы с кодом

пакеты — папки с модулями

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

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

The Python Tutorial: Modules

The Python Tutorial: Packages

The Python Standard Library

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

Модуль: что это и зачем он нужен

Модуль в Python — это обычный файл с расширением .py, который содержит код: функции, переменные, классы (классы вы изучите позже) и исполняемые инструкции.

Почему модуль полезен

Разделение ответственности: один файл отвечает за одну область задач

Переиспользование: функции можно импортировать и вызывать в разных местах

Удобство тестирования и отладки: проще найти, где ошибка

Минимальный пример

Создадим два файла.

utils.py:

main.py:

Запуск:

Импорт: как подключать модули

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

Основные формы import

| Форма | Пример | Когда удобно | |---|---|---| | импорт модуля целиком | import math | когда используете много функций из модуля | | импорт конкретного имени | from math import sqrt | когда нужно 1–2 функции и важна краткость | | импорт с псевдонимом | import numpy as np | когда имя длинное или есть стандартный псевдоним | | импорт нескольких имён | from os import path, getenv | когда имён мало и они логически связаны |

Что происходит при импорте

Когда Python впервые выполняет import some_module, он:

Ищет модуль по имени (где именно — разберём ниже)

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

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

Практический вывод: не пишите тяжёлую работу на верхнем уровне модуля, если это не нужно при импорте.

Плохо:

Лучше:

__name__ и запуск как скрипт: защита от нежелательного выполнения

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

Когда файл импортируют, __name__ будет равен имени модуля.

Это позволяет делать так:

Теперь:

python calculator.py запустит main()

from calculator import add не запустит main(), а только даст доступ к add

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

Откуда Python берёт модули: путь импорта и sys.path

Python ищет импортируемые модули в определённых местах:

текущая папка запуска (обычно папка, где вы запускаете python main.py)

стандартная библиотека Python

установленные пакеты из вашего окружения (например, .venv)

Технически список путей лежит в sys.path.

Пример диагностики:

Частая ошибка: конфликт имён

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

Плохие имена файлов в учебном проекте:

random.py

json.py

sys.py

Почему: при import random Python может импортировать ваш random.py, а не стандартный.

Пакет: папка с модулями

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

Типичная структура:

Тогда можно импортировать так:

Зачем нужен __init__.py

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

Также он может:

выполнять инициализацию пакета (используйте умеренно)

задавать публичное API пакета

Пример аккуратного app/__init__.py:

Теперь можно:

Относительные и абсолютные импорты

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

Абсолютные импорты

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

Плюсы:

читается однозначно

проще понять структуру

Относительные импорты

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

Где:

. означает текущий пакет

.. означает пакет уровнем выше

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

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

если путаетесь, используйте абсолютные импорты, они проще для чтения

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

Стандартная библиотека и внешние пакеты

Стандартная библиотека

Это модули, которые уже идут вместе с Python. Они покрывают множество задач.

Часто используемые модули:

math — математика

random — случайные значения

datetime — даты и время

pathlib — удобная работа с путями

json — чтение и запись JSON

Справочник:

Python Standard Library

Пример с pathlib:

Внешние пакеты (через pip)

Внешние пакеты ставятся через pip в ваше виртуальное окружение.

Команды:

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

pip documentation

Фиксация зависимостей: requirements.txt

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

Частый учебный подход:

Сгенерировать список зависимостей:

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

Совет: если вы ставили много лишнего, лучше формировать requirements.txt осознанно, но для старта pip freeze достаточно.

Как организовать небольшой проект: практичная структура

Ниже базовая структура, которая подходит для мини-проектов курса.

Роли файлов:

main.py — точка входа, обычно только вызывает функции верхнего уровня

app/logic.py — вся основная логика (функции, обработка данных)

app/storage.py — чтение/запись файлов

app/cli.py — ввод-вывод, взаимодействие с пользователем

Так вы не смешиваете всё в одном месте: ввод-вывод отдельно, логика отдельно, файлы отдельно.

Мини-проекты для закрепления: как тренировать модули и пакеты

Ниже несколько мини-проектов. Цель не в “большом функционале”, а в том, чтобы:

разбить код на модули

использовать импорты

аккуратно выделить точку входа

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

Мини-проект: менеджер задач в файле

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

Функции:

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

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

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

Структура модулей:

storage.py читает/пишет файл

logic.py управляет списком задач

cli.py печатает меню и читает команды

main.py запускает приложение

Мини-проект: анализатор текста

Идея: программа читает файл и строит простую статистику.

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

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

количество слов

топ-10 самых частых слов (можно через словарь dict)

Где тренируется:

файлы

строки: lower(), split(), strip()

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

Мини-проект: конвертер валют с кэшированием

Идея: вы вводите сумму и курс, программа конвертирует и сохраняет последние операции в файл.

Где тренируется:

функции и форматирование f-строк

обработка ошибок ввода (try/except ValueError)

модуль storage.py для истории

Мини-проект: сортировщик файлов по расширениям

Идея: программа берёт папку и раскладывает файлы по подпапкам images/, docs/, other/.

Где тренируется:

стандартная библиотека (pathlib, возможно shutil)

исключения (нет прав, файл занят)

аккуратная структура проекта

Документация по полезным модулям:

pathlib — Object-oriented filesystem paths

shutil — High-level file operations

Практические рекомендации по качеству кода

Держите main.py маленьким: он должен “склеивать” части приложения, а не содержать всю логику.

Не смешивайте ввод-вывод и вычисления: функции, которые считают, лучше делать без print() и input().

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

Имена модулей делайте простыми: utils.py, storage.py, cli.py лучше, чем слишком общие helpers.py для всего подряд.

> Programs must be written for people to read, and only incidentally for machines to execute. Structure and Interpretation of Computer Programs

Мини-итог

Теперь вы знаете, как превращать набор упражнений в структурированный проект:

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

пакет — это папка с модулями (обычно с __init__.py)

import выполняет код модуля при первом импорте и делает имена доступными

if __name__ == "__main__": защищает код запуска от выполнения при импорте

зависимости внешних библиотек ставятся через pip и фиксируются в requirements.txt

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