Прошлый урок был посвящён обработке ошибок через try и except, и это отличная база: даже безобидная строчка import порой заканчивается ошибкой, а теперь читатель знает, что любую ошибку можно поймать и спокойно разобраться в причине. Настал черёд темы, после которой программы перестают быть огромными простынями кода. Модули позволяют не писать всё с нуля, а брать готовые детали из стандартной библиотеки или из собственных файлов. Разберёмся, как подключать чужой и свой код, где Python ищет модули и почему почти каждый новичок однажды видит на экране ModuleNotFoundError.

Модуль это обычный файл с кодом Python

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

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

Отдельный подарок начинающему - стандартная библиотека Python. Это сотни модулей, которые устанавливаются вместе с интерпретатором, скачивать ничего не нужно. Есть модули для математики и случайных чисел, для работы с файлами и папками, для дат и времени, для форматов json и csv, для сетевых запросов. Многие новички искренне удивляются, сколько задач решается без единой сторонней установки: генератор отчёта, шифрование строки, разбор адреса сайта - всё это уже лежит в коробке. Осталось научиться коробку открывать, и вся наука здесь сводится к одному слову import.

Синтаксис import и обращение через точку

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

import math

print(math.sqrt(144))   # 12.0
print(math.pi)          # 3.141592653589793
print(math.ceil(4.2))   # 5
print(math.floor(4.8))  # 4

Разберём содержимое построчно. Функция sqrt извлекает квадратный корень, константа pi хранит число пи с пятнадцатью знаками после запятой, ceil округляет дробь всегда вверх, floor всегда вниз. На числе 4.2 разница видна мгновенно: ceil даёт пятёрку, floor оставляет четвёрку. Для денежных расчётов и статистики такие разные округления пригождаются чаще, чем кажется.

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

Подключить можно сразу несколько модулей, перечислив их через запятую: import math, random, os. Однако стиль оформления кода PEP 8 рекомендует писать каждый import на отдельной строке, так при чтении сразу видно полный список зависимостей. И ещё одна тонкость, которую мало кто объясняет вслух: точечное обращение защищает от конфликта имён. В программе может быть своя функция length, своя переменная speed, и они никак не столкнутся с одноимёнными вещами внутри модулей, потому что живут по разным адресам.

Выборочное подключение через from и псевдонимы import as

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

from math import sqrt, pi

print(sqrt(225))  # 15.0
print(pi > 3.14)  # True

Теперь sqrt и pi вызываются напрямую, без приставки. Код короче и чище, но у медали есть обратная сторона: импортированные имена свободно гуляют по программе, и если ниже по коду объявить собственную функцию sqrt, она молча перезапишет импортированную, и программа начнёт считать ерунду. Поэтому опытные разработчики держатся негласного правила: обращение через модуль по умолчанию, а выборочный from import - только для широко известных имён, вроде math.pi, у которых мало шансов на встречу с двойником.

Третья форма - псевдонимы. Длинное имя модуля можно сократить:

import random as rnd

print(rnd.randint(1, 6))  # бросок кубика

Слово as создаёт короткое второе имя, и дальше в коде используется оно. В реальных проектах встречаются общепринятые сокращения: import datetime as dt, import numpy as np, import pandas as pd. Такие псевдонимы понятны каждому, кто читал хоть пару чужих программ. А вот выдумывать личные шифры вроде import math as m не стоит: сэкономленные три буквы обернутся минутами недоумения у того, кто откроет файл после автора.

Готовые модули math random и os под повседневные задачи

Пару слов стоит сказать о модулях, без которых не обходится почти ни один учебный проект. Модуль random отвечает за случайность, и у него три рабочих лошадки. randint выдаёт случайное целое число в диапазоне, причём обе границы включаются. choice выбирает один случайный элемент из списка. shuffle перемешивает список прямо на месте.

import random

secret = random.randint(1, 100)  # число для игры в угадайку
move = random.choice(["камень", "ножницы", "бумага"])
cards = ["6", "7", "8", "9", "10"]
random.shuffle(cards)
print(secret, move, cards)

Бросок кубика в настольной игре, случайный вопрос из списка, перемешанная колода карт, тестовые данные для проверки функции - всё это решается одной строчкой. Именно на random строятся первые игрушечные проекты вроде угадайки числа, и теперь понятно, откуда в них берётся загаданное значение.

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

Модуль os - мост между программой и операционной системой. Он умеет узнавать текущую папку, перечислять содержимое каталога и собирать пути к файлам.

import os

print(os.getcwd())                        # текущая рабочая папка
print(os.listdir())                       # файлы и папки в ней
path = os.path.join("docs", "plan.txt")   # путь для любой системы
print(path)

Главная ценность os.path.join в том, что он сам подставляет правильный разделитель: на Windows это обратный слеш, на Linux и macOS обычный. Программа с таким путём перестаёт зависеть от того, на какой машине её запустят. Заглянуть в устройство любого модуля помогают встроенные функции: help(math) печатает справку, dir(math) перечисляет все имена внутри. Это два самых честных источника знаний, доступных прямо в консоли.

Собственный модуль из своего файла

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

# файл my_tools.py
SPEED_OF_SOUND = 340.0

def km_to_miles(km):
    return km * 0.6214

def average(numbers):
    return sum(numbers) / len(numbers)

Рядом лежит второй файл report.py, который подключает первый по имени, без всяких регистраций и настроек:

# файл report.py
import my_tools

print(my_tools.SPEED_OF_SOUND)         # 340.0
print(my_tools.km_to_miles(100))
print(my_tools.average([4, 8, 15, 16, 23, 42]))  # 18.0

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

Здесь же кроется сюрприз, который ставит новичков в тупик: при импорте код модуля выполняется целиком, один раз. Если в my_tools.py остался отладочный print, он сработает в момент подключения и выведет строку в чужой программе. Чтобы проверочный код жил только при прямом запуске файла, существует классическая конструкция:

def average(numbers):
    return sum(numbers) / len(numbers)

if __name__ == "__main__":
    print(average([1, 2, 3]))  # сработает лишь при запуске файла напрямую

Переменная __name__ равна строке "__main__" только тогда, когда файл запустили как программу; при импорте из другого скрипта условие ложно, и проверка молчит. Этот приём встречается практически в каждом профессиональном модуле, и после сегодняшнего урока его смысл читается как открытая книга.

Пути поиска модулей и ошибка ModuleNotFoundError

Откуда интерпретатор знает, где физически лежит math? Порядок поиска строгий и короткий. Сначала Python смотрит в папку, где лежит запущенный скрипт, затем проходит по списку папок из sys.path, а в конце заглядывает в site-packages, куда попадают установленные пакеты. Убедиться своими глазами можно за секунду:

import sys

print(sys.path[:3])

Первым элементом списка обычно идёт пустая строка либо точка, и это обозначение текущей папки. Отсюда практический вывод: собственный модуль находят по месту жительства рядом со скриптом, а сторонние - по прописке в site-packages. Дополнительно путь можно расширить через переменную окружения PYTHONPATH, но на старте обучения хватает двух первых пунктов.

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

try:
    import my_settings
except ModuleNotFoundError:
    my_settings = None
    print("Файл настроек не найден, работаем со значениями по умолчанию")

Такой сценарий типичен для конфигурации: программа проверяет файл настроек и вежливо откатывается к значениям по умолчанию, если его нет. Причины самой ошибки укладываются в короткий список. Опечатка в имени модуля, ведь import Random и import random - разные строки. Файл лежит не в той папке, например в подкаталоге, куда Python без подсказки не заглянет. Файл не сохранён перед запуском, классика редакторов с ручным сохранением. И самая коварная причина: имя собственного файла совпало с именем стандартного модуля. Файл random.py в папке проекта перехватывает настоящий random, и программа падает с загадочной ошибкой внутри чужого кода. Лечится переименованием файла и удалением папки __pycache__, где интерпретатор хранит скомпилированный кэш.

Практические привычки при работе с импортом

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

  1. Все import стоят вверху файла, чтобы список зависимостей был виден с первого взгляда;
  2. Сначала подключаются модули стандартной библиотеки, потом собственные, и группы разделяются пустой строкой;
  3. Имена собственных файлов никогда не совпадают с именами стандартных модулей;
  4. Псевдонимы применяются экономно и только общепринятые, понятные чужому читателю;
  5. Незнакомый модуль сначала изучают через help и dir, и лишь потом используют вслепую.

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

Подключение модулей - это ещё и смена масштаба мышления. Программист перестаёт писать каждую функцию руками и начинает собирать программу из готовых узлов, как конструктор: своя математика из my_tools, случайности из random, пути из os. Полезная привычка на будущее: прежде чем изобретать функцию, стоит на секунду проверить, нет ли готовой в стандартной библиотеке, и в половине случаев она обнаруживается. А в следующем уроке на сцену выходит работа с файлами: данные наконец переезжают из переменных в долговременное хранилище, и вместе с только что освоенными модулями os и json это будет особенно уместно.