Основы языка программирования Python 3

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

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

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

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

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

веб-разработки

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

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

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

> "Beautiful is better than ugly." — The Zen of Python (PEP 20 — The Zen of Python)

Как устроена работа с Python

Интерпретатор и программы

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

Обычно вы будете работать в двух режимах:

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

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

Версии Python

В рамках курса используйте Python 3.10+ (лучше — актуальную стабильную версию). Python 2 давно устарел и для обучения не подходит.

Установка Python

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

Python Downloads

Windows

Скачайте установщик с сайта Python.

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

Обязательно отметьте галочку Add python.exe to PATH.

Выберите установку (обычно подходит стандартная).

macOS

Скачайте установщик с сайта Python.

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

Проверьте, что в терминале запускается именно Python 3.

Linux

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

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

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

Откройте терминал (или PowerShell на Windows) и выполните команды:

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

Также полезно проверить установку pip (менеджера пакетов):

Или:

Если pip не найден, чаще всего помогает команда:

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

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

Рекомендуемые варианты

Visual Studio Code — лёгкий редактор, подходит почти всем новичкам и профессионалам: Visual Studio Code

PyCharm Community Edition — мощная IDE для Python: PyCharm

Минимальная настройка VS Code

Установите VS Code.

Установите расширение Python от Microsoft.

Выберите интерпретатор Python в проекте.

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

Структура проекта: папка, файлы и точка входа

Хорошая привычка с самого начала — хранить код проекта в отдельной папке.

Пример простой структуры:

my_project/

main.py

Файл main.py часто становится точкой входа: его вы запускаете первым.

Первый запуск: файл и интерактивный режим

Запуск файла

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

Запустите в терминале из папки проекта:

Если используется команда python3, то:

Интерактивный режим

Запустите:

И выполните:

Чтобы выйти:

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

macOS/Linux: Ctrl+D

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

Python-проекты часто используют внешние библиотеки, которые ставятся через pip.

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

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

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

Installing Python Modules

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

Зачем нужно виртуальное окружение

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

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

повторять окружение на другом компьютере

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

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

venv — Creation of virtual environments

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

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

Будет создана папка .venv.

Активация

Windows (PowerShell):

Windows (cmd):

macOS/Linux:

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

Проверка, что вы внутри окружения

Выполните:

Вы должны увидеть путь, который указывает на .venv.

Деактивация

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

!Схема показывает связь редактора, терминала, интерпретатора Python и виртуального окружения

Обычно процесс выглядит так:

Создаёте папку проекта.

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

Пишете код в .py файлах.

Запускаете файл через терминал.

Если нужна библиотека — ставите её через pip в активном окружении.

Частые проблемы и быстрые решения

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

На Windows переустановите Python и убедитесь, что включили Add python.exe to PATH

Попробуйте python3 вместо python

Ставится пакет, но код его не видит

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

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

Проверьте, какой python используется: python -c "import sys; print(sys.executable)"

IDE запускает не тот интерпретатор

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

Перезапустите IDE после создания окружения

Что дальше

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

Типы данных, переменные и базовые операции

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

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

Любая программа на Python постоянно создаёт и преобразует значения.

Примеры значений:

10 (целое число)

3.14 (число с дробной частью)

"Привет" (строка)

True (логическое значение)

Когда вы пишете выражение вроде 2 + 2, Python:

берёт значения 2 и 2

выполняет операцию +

получает новое значение 4

Переменные

Переменная — это имя, которое ссылается на значение. Вы создаёте переменную оператором присваивания =.

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

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

Имя переменной должно быть понятным и подчиняться правилам:

используется латиница, цифры и _

имя не может начинаться с цифры

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

нельзя использовать ключевые слова Python (например, class, for, if)

Рекомендованный стиль в Python — snake_case (user_name, total_sum). Эти рекомендации описаны в PEP 8.

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

В Python тип принадлежит значению, а не переменной. Это означает, что одна и та же переменная может в ходе работы программы ссылаться на значения разных типов.

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

Базовые типы данных

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

| Тип | Как пишется | Пример | Что означает | |---|---|---|---| | int | целые числа | -3, 0, 42 | целые значения без дробной части | | float | числа с точкой | 3.14, -0.5 | числа с дробной частью | | str | строки | "Python" | текст (последовательность символов) | | bool | логика | True, False | истинно или ложно | | NoneType | отсутствие значения | None | специальное значение “ничего” |

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

Официально: список встроенных типов и их поведение описаны в документации Python: Built-in Types.

Базовые операции с числами

Арифметика

Важный момент: оператор / в Python 3 всегда даёт float, даже если делится “нацело”.

Целочисленное деление и остаток

Возведение в степень

Порядок выполнения

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

Строки и базовые операции со строками

Строки записываются в кавычках (одинарных или двойных).

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

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

повторение через *

получение длины функцией len()

Сравнения и логические операции

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

Результат сравнения — это bool (True или False).

Логические операторы

and — “и”

or — “или”

not — “не”

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

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

int("42") превращает строку в целое число

float("3.14") превращает строку в число с дробной частью

str(10) превращает число в строку

bool(x) превращает значение в логическое (часто используется в условиях)

Пример:

Если строка не похожа на число, будет ошибка ValueError:

Ввод и вывод

Вывод на экран: print()

Ввод с клавиатуры: input()

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

Если нужно число, делайте преобразование:

Форматирование строк через f-строки

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

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

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

TypeError — вы пытаетесь выполнить операцию над несовместимыми типами

ValueError — вы пытаетесь преобразовать значение в неверный формат

SyntaxError — нарушены правила записи кода (например, забыли кавычку)

Пример TypeError:

Правильно:

Итоги

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

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

отличать базовые типы (int, float, str, bool, None)

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

вводить данные через input() и выводить через print()

преобразовывать типы (int(), float(), str(), bool())

Дальше эти знания станут основой для ветвлений (if) и циклов: там вы будете особенно часто использовать сравнения, bool и преобразования типов.

Условия, циклы и базовые структуры управления

После темы про типы данных, переменные, сравнения и bool пришло время управлять тем, как именно выполняется программа. Для этого в Python используются условия и циклы. Они позволяют:

выполнять код только при выполнении условия

повторять действия много раз

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

Блоки кода и отступы

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

Пример блока после if:

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

обычно используется 4 пробела на один уровень отступа

в одном файле нельзя смешивать табы и пробелы

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

!Как отступы формируют блоки кода в Python

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

Условие позволяет выполнить код только если выражение истинно (True).

Простая форма if

Здесь выражение temperature < 20 имеет тип bool (это вы уже делали в прошлой статье через сравнения).

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

Полная форма if-else

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

elif читается как иначе если и проверяется сверху вниз.

Важно: выполняется только первая подходящая ветка.

Вложенные условия

Внутри одной ветки можно писать другой if.

Часто вложенность можно заменить логическим выражением (так код проще читать):

Истинность значений: как работает bool в условиях

В условии можно писать не только сравнения, но и любое выражение, которое Python может интерпретировать как True или False.

False-значения: 0, 0.0, "" (пустая строка), пустые коллекции, None, и само False

почти всё остальное считается True

Примеры:

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

Цикл while

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

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

Пример: счётчик

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

Пример: ввод до корректного значения

input() возвращает строку, поэтому часто нужны проверки и преобразование типов.

Здесь:

while True создаёт цикл, который сам по себе бесконечен

break завершает цикл, когда ввод корректный

Цикл for

for в Python перебирает элементы последовательности (например, диапазона чисел или строки).

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

Перебор range

range(n) создаёт последовательность чисел от 0 до n - 1.

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

range(5) даёт 0, 1, 2, 3, 4

range(2, 6) даёт 2, 3, 4, 5

range(10, 0, -2) даёт 10, 8, 6, 4, 2

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

Перебор строки

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

Управление выполнением внутри циклов

break

break немедленно завершает цикл.

continue

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

Полезное правило

> "Readability counts." — The Zen of Python (PEP 20 — The Zen of Python)

Условия и циклы легко сделать запутанными. Хорошие имена переменных, умеренная вложенность и понятные условия помогают поддерживать код.

Типовые задачи, которые решаются условиями и циклами

проверка корректности ввода пользователя

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

поиск первого подходящего элемента (часто с break)

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

Мини-пример: сумма чисел от 1 до n

Здесь n + 1 нужен потому, что range не включает правую границу.

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

IndentationError: неправильные отступы

логическая ошибка в условии (например, перепутали > и <)

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

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

Итоги

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

строить ветвления через if, elif, else

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

писать циклы while и for

использовать range() для перебора чисел

управлять циклом с помощью break и continue

Дальше эти конструкции станут основой для работы со структурами данных (например, списками) и написания более крупных программ, где повторение и выбор ветки — постоянная необходимость.

Коллекции: списки, кортежи, множества и словари

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

Коллекции нужны почти в каждой программе:

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

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

чтобы быстро проверять наличие элемента

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

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

Что общего у коллекций

Чаще всего вы будете использовать 4 типа:

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

tuple (кортеж) — упорядоченная неизменяемая последовательность

set (множество) — неупорядоченная коллекция уникальных элементов

dict (словарь) — отображение ключ → значение

Полезные операции, которые встречаются почти везде:

len(x) — количество элементов

x in collection — проверка наличия элемента (для словаря проверяет наличие ключа)

цикл for для перебора элементов

!Сравнение списков, кортежей, множеств и словарей по идее хранения данных

Списки (list)

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

Создание списка

Индексация и срезы

Индексы начинаются с 0.

Срез — это получение части списка.

Изменение списка

Можно менять элемент по индексу:

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

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

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

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

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

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

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

Примеры:

Подробно про методы списков: Data Structures.

Перебор списка в цикле

Если нужен индекс, используйте range(len(...)):

Кортежи (tuple)

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

Создание кортежа

Одиночный элемент требует запятой:

Зачем нужны кортежи

чтобы хранить набор значений, который не должен меняться (например, координаты)

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

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

Индексация и перебор

У кортежа те же правила индексации и срезов, что и у списка:

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

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

Создание множества

Если добавить повтор, он не появится:

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

Добавление и удаление:

Проверка наличия элемента:

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

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

Практический приём: убрать дубликаты

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

Словари (dict)

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

Создание словаря

Чтение и запись по ключу

Если ключа нет, person["key"] вызовет KeyError. Более безопасный способ — get():

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

Проверка ключа и оператор in

Для словаря in проверяет ключи:

Перебор словаря в цикле

Если нужно сразу и ключ, и значение, используйте items():

Какие бывают ключи

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

int, float, str, bool

tuple (если внутри тоже только неизменяемые значения)

Список (list) ключом быть не может, потому что он изменяемый.

Как выбрать подходящую коллекцию

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

Типовые шаблоны вместе с условиями и циклами

Подсчёт суммы и количества

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

Поиск уникальных значений

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

[] это список, () это кортеж, {} это словарь, а пустое множество создаётся так: set()

dict[key] падает с KeyError, если ключа нет, поэтому часто безопаснее dict.get(key)

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

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

> "There should be one-- and preferably only one --obvious way to do it." — The Zen of Python (PEP 20)

Итоги

Теперь вы знаете четыре базовые коллекции Python и умеете:

создавать list, tuple, set, dict

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

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

использовать множества для уникальности и операций объединения/пересечения

использовать словари для хранения пар ключ → значение и безопасного чтения через get()

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

Функции, область видимости и стиль кода

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

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

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

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

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

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

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

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

внутри функции вы используете знакомые типы (int, str, bool) и операции

условия и циклы обычно живут внутри функций

коллекции (list, dict, set) часто передаются в функции и возвращаются из них

> "Readability counts." — The Zen of Python (PEP 20 — The Zen of Python)

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

Функция объявляется с помощью def, после имени идут скобки с параметрами, а тело задаётся отступами.

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

"Аня" — аргумент (конкретное значение при вызове)

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

Возврат результата: return

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

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

Ранний выход из функции

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

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

Обязательные параметры

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

Если аргумент не передали, берётся значение по умолчанию.

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

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

Важная ловушка: изменяемые значения по умолчанию

Нельзя использовать изменяемые объекты (например, [] или {}) как значения по умолчанию, если вы собираетесь их менять.

Плохо:

Почему так происходит: значение items=[] создаётся один раз при определении функции и затем переиспользуется.

Хорошо:

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

Обработка списка и возврат нового списка

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

Это развитие примера из темы про dict, только логика упакована в функцию.

Побочные эффекты и изменяемость

Функция может:

возвращать значение (предпочтительный способ сообщить результат)

менять переданный объект (побочный эффект)

делать ввод-вывод (print, input, работа с файлами)

Важно помнить: если передать в функцию изменяемую коллекцию (list, dict, set) и изменить её внутри, изменения будут видны снаружи.

Это не всегда плохо, но требует внимательности. На старте курса полезное правило:

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

если функция изменяет объект — пусть это будет очевидно из имени и документации

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

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

!Визуальная схема порядка поиска имён: Local → Enclosing → Global → Builtins

Правило LEGB

Когда Python встречает имя переменной, он ищет его в таком порядке:

Local: внутри текущей функции

Enclosing: во внешних функциях (если функция вложенная)

Global: на уровне файла (модуля)

Builtins: встроенные имена (len, print и другие)

Это называют правилом LEGB. Если имя не найдено — будет NameError.

global и nonlocal

global

Если внутри функции вы присваиваете значение имени, Python считает это имя локальным. Чтобы изменить глобальную переменную, нужно явно указать global.

Рекомендация: злоупотреблять global не стоит. Чаще лучше вернуть новое значение или хранить состояние в структуре данных.

nonlocal

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

Минимальный стиль кода: читаемость и PEP 8

В Python стиль — это часть культуры языка. Основной документ — PEP 8: PEP 8 — Style Guide for Python Code.

Имена

функции и переменные: snake_case (count_words, total_sum)

константы: UPPER_CASE (MAX_RETRIES)

избегайте имён, которые совпадают со встроенными: не называйте переменные list, dict, str

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

стандартный отступ: 4 пробела

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

старайтесь не делать строки слишком длинными (PEP 8 рекомендует ориентироваться на 79 символов)

Пробелы

Комментарии и документация функций

Комментарии объясняют почему, а не что.

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

Официально про docstring: PEP 257 — Docstring Conventions.

Принцип одной ответственности

Хорошая учебная привычка: одна функция — одна понятная задача.

плохо: функция и читает ввод, и печатает, и считает

лучше: отдельно функция расчёта, отдельно ввод-вывод

Практический итог

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

объявлять функции, вызывать их и возвращать значения через return

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

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

объяснять, почему переменная видна или не видна в конкретном месте (LEGB)

писать код более читаемо по базовым правилам PEP 8

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

Модули, пакеты и работа с библиотеками

Когда вы пишете небольшие учебные программы, весь код часто помещается в один файл main.py. Но по мере роста проекта появляется потребность:

разделять код на части

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

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

В Python это делается через модули, пакеты и библиотеки.

Что такое модуль

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

Пример:

utils.py — модуль

main.py — модуль

Когда вы подключаете модуль, Python выполняет его код и даёт доступ к его именам.

Импорт модуля: import

Допустим, у вас есть два файла.

utils.py:

main.py:

Здесь utils.is_even — обращение к функции is_even внутри модуля utils.

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

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

Псевдоним для модуля или имени: as

Или:

Где Python ищет модули

Когда вы пишете import something, Python пытается найти модуль по правилам поиска.

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

На практике важные выводы такие:

Python сначала ищет в стандартной библиотеке и установленных пакетах, затем в папке проекта (и других путях из sys.path).

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

Пример проблемы:

Вы создаёте файл random.py в проекте.

Пишете import random.

Python может импортировать ваш файл вместо стандартного модуля random.

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

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

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

Полезные примеры:

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

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

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

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

json — JSON

Документация: The Python Standard Library.

Пример: модуль math

Документация: math — Mathematical functions.

Пример: модуль json

Документация: json — JSON encoder and decoder.

Что такое пакет

Пакет — это папка с Python-кодом, из которой можно импортировать модули.

Классический признак пакета — наличие файла __init__.py внутри папки (в современных версиях Python существуют и “пакеты без __init__.py”, но на старте курса лучше придерживаться классического варианта).

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

Импорт из main.py:

Что делает __init__.py

Если в папке есть __init__.py, Python воспринимает её как пакет.

Также __init__.py может:

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

“переэкспортировать” удобные имена, чтобы импорт был короче

Пример “переэкспорта”.

myapp/__init__.py:

Тогда можно писать:

Важно: точка в .utils означает “внутри текущего пакета”.

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

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

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

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

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

Относительный импорт использует точки:

from .utils import is_even — из текущего пакета

from ..common import helpers — на уровень выше

Пример (внутри myapp/validators.py):

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

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

в точке входа (main.py) чаще используйте абсолютные импорты

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

Хорошая минимальная идея: держать “логику” отдельно от “ввода-вывода”. Это напрямую связано с темой функций из прошлой статьи.

Вариант структуры:

app/calculations.py:

main.py:

Сторонние библиотеки и pip

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

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

pip — Python package installer

Installing Python Modules

Важнейшее правило: ставьте пакеты в виртуальное окружение

Из прошлой статьи про окружение вы уже знаете venv. Сторонние пакеты нужно устанавливать, когда окружение активировано.

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

Документация библиотеки requests: Requests: HTTP for Humans.

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

Версии пакетов и повторяемость окружения

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

Минимальный подход: requirements.txt

Часто делают так:

Устанавливают пакеты

Сохраняют список зависимостей

В другом окружении устанавливают их из файла

Сохранить зависимости:

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

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

ModuleNotFoundError

Обычно означает одно из двух:

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

вы запускаете код не тем интерпретатором (например, IDE использует не .venv)

Что проверить:

python -c "import sys; print(sys.executable)"

pip --version

Циклические импорты

Это ситуация, когда:

a.py импортирует b.py

b.py импортирует a.py

Часто это признак плохого разделения ответственности. Обычно помогает:

вынести общие части в третий модуль (например, common.py)

перенести импорт внутрь функции (как временное решение)

Импорт “всего”: from module import *

Так делать не стоит: непонятно, какие имена появились в текущем файле, и легко получить конфликты.

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

импортируйте модуль целиком: import module

или импортируйте конкретные имена: from module import name1, name2

Итоги

Теперь вы понимаете основу организации кода в Python:

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

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

import, from ... import ..., as — способы подключать код

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

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

зависимости проекта удобно фиксировать в requirements.txt

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

Файлы, ввод-вывод и обработка исключений

Почти любая полезная программа взаимодействует с внешним миром:

читает данные (из файла, сети, базы данных)

сохраняет результат (в файл, лог, отчёт)

обрабатывает ошибки, которые неизбежно возникают при вводе-выводе

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

Что такое ввод-вывод

Ввод-вывод (I/O) — это любые операции обмена данными между вашей программой и внешними источниками:

клавиатура и экран (input(), print())

файлы на диске

сеть (позже, через библиотеки)

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

!Схема показывает, что файлы — это источник/приёмник данных, а программа преобразует данные в памяти.

Пути к файлам и рабочая папка

Файл на диске задаётся путём.

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

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

Чтобы меньше путаться, полезная привычка: хранить файлы данных рядом с проектом (например, в папке data/) и использовать относительные пути.

Модуль pathlib

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

Документация: pathlib — Object-oriented filesystem paths.

Открытие файла: функция open

Базовый инструмент — open(path, mode, encoding=...).

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

Ключевые параметры:

path — путь к файлу (строка или Path)

mode — режим открытия

encoding — кодировка (актуально для текстовых файлов)

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

| Режим | Смысл | Если файла нет | Куда ставится курсор | |---|---|---|---| | "r" | чтение | ошибка | в начало | | "w" | запись с перезаписью | создастся | в начало | | "a" | дозапись в конец | создастся | в конец | | "rb", "wb" | двоичный режим | зависит от r/w | зависит от режима |

Для текстовых файлов на практике чаще всего используют "r", "w", "a".

Контекстный менеджер with

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

данные могут не успеть записаться

могут утекать ресурсы

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

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

read: прочитать весь файл

Плюсы: просто.

Минусы: для больших файлов может быть слишком много памяти.

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

Часто файл удобнее обрабатывать по строкам.

Здесь:

for line in f читает файл построчно, не загружая всё сразу

rstrip("\n") убирает символ перевода строки в конце

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

write: записать строку

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

writelines: записать много строк

writelines() принимает список строк и записывает их как есть.

Кодировка и текст

Текстовый файл — это байты на диске, которые интерпретируются как символы по правилам кодировки.

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

явно указывайте encoding="utf-8" при работе с текстом

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

Двоичные файлы

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

В двоичном режиме read() возвращает bytes, а не str.

Практика: простой формат данных «по строке на значение»

На старте полезно хранить данные просто: одна строка — одно значение.

Пример: файл со списком дел todo.txt.

Обратите внимание, как темы курса «склеиваются»:

коллекции (list) хранят задачи в памяти

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

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

Исключения: что это и зачем

Исключение (exception) — это механизм, которым Python сообщает об ошибке во время выполнения.

Примеры исключений, которые вы уже могли видеть:

ValueError при int("сорок")

KeyError при обращении к отсутствующему ключу словаря

FileNotFoundError при чтении несуществующего файла

Документация: Errors and Exceptions.

Исключения особенно важны в I/O, потому что внешние условия ненадёжны:

файла может не быть

файл может быть повреждён

может не хватить прав доступа

пользователь может ввести не то

try-except: перехват ошибок

Минимальная форма:

Здесь:

если в блоке try ошибка — выполнение прыгает в подходящий except

если ошибки нет — except пропускается

Не ловите всё подряд без необходимости

Можно написать except Exception:, но начинающим важно правило:

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

Так код будет более надёжным и понятным.

else и finally

В try есть дополнительные блоки.

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

finally выполняется всегда, даже если была ошибка

На практике finally полезен, когда вы освобождаете ресурсы. При работе с файлами эту задачу почти всегда лучше решает with.

Поднимать исключения самостоятельно: raise

Иногда вы хотите явно запретить некорректные входные данные в функции и сообщить об этом ошибкой.

Плюс такого подхода: функция явно защищает свои требования к данным.

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

FileNotFoundError — файла нет по указанному пути

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

IsADirectoryError — по пути находится папка, а не файл

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

Пример обработки чтения файла с понятным сообщением:

Полезный пример: чтение и запись JSON

JSON часто используется для хранения настроек и данных.

Документация: json — JSON encoder and decoder.

Здесь:

json.dump пишет JSON прямо в файл

json.load читает JSON из файла

json.JSONDecodeError возникает, если файл не является корректным JSON

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

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

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

main.py

storage.py

storage.py:

main.py:

Так ваш код становится:

более читаемым

проще тестируемым

проще расширяемым

Итоги

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

открывать файлы через open() в режимах чтения и записи

безопасно работать с файлами через with

читать файл целиком и построчно

записывать данные в файл

понимать, зачем нужна кодировка utf-8

перехватывать ошибки через try-except, использовать else и finally

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

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