Python 3. Модули
Что такое модули в Python
Модулем в Python 3 является любой файл с кодом, то есть файл с расширением .py. Имя модуля — это имя файла без расширения. Модули можно импортировать в другие модули, это решает следующие задачи:
- Модуль можно использовать многократно. Например, вы можете написать свой модуль, который будете применять для написания других программ. Или вы можете использовать чужие модули Python, чтобы не реализовывать функциональность, которую уже реализовали другие программисты.
- Благодаря модулям можно разбить одну большую программу на несколько частей (модулей). И работать с ними по отдельности.

Импортирование модулей
Для импорта модуля используется два оператора:
- import — импорт модуля, при котором к объектам модуля (переменным, функциям и т.д.) можно обращаться через имя модуля;
- from — извлечение отдельных объектов из модуля, при этом к таким объектам можно будет обращаться напрямую.
Ниже разберём разницу на примерах.
Давайте напишем следующий модуль mod_1.py:
a = 15
my_str = "test_string"
def hello():
print("Hello World!")
Оператор import
Теперь напишем основную программу, в которую импортируем наш модуль с помощью оператора import. А затем выполним функцию из модуля:
import mod_1
mod_1.hello()
Hello World!
Важно положить файл основной программы и модуля в один каталог. Ниже я объясню где Python ищет файлы модулей.
Оператор from
Теперь импортируем наш модуль с помощью оператора from. Здесь после оператора from идёт имя модуля, а затем оператор import и имя импортируемого объекта:
from mod_1 import hello
hello()
Hello World!
Из примера видно, что мы обращаемся к функции hello() напрямую.
Кстати, чтобы импортировать все объекты с помощью from … import используется такая конструкция:
from mod_1 import *
hello()
print(a)
Hello World!
15
Разница между import и from
В предыдущих примерах вы должны были увидеть разницу между import и from … import. Если используется import, вы должны обращаться к объектам модуля через точку (имя_модуля.имя_объекта). А если используется from … import, то вы можете обращаться к объектам модуля напрямую.

Импортирование с помощью from … import * может показаться лучше, так как объекты из модуля становятся объектами программы, и к ним можно обращаться напрямую. Но если вы импортируете несколько модулей, а в них окажутся объекты с одинаковыми именами, то программа поломается, так как одни объекты перезапишут другие. К тому же, глядя на код, сложно понять из какого модуля пришла та или иная функция. Поэтому не рекомендует использовать from … import *. В таких случаях лучше использовать оператор import.
Например создадим ещё один модуль (mod_2.py), в нём также будет присутствовать переменная a:
a = 20
И импортируем оба модуля в нашу программу:
import mod_1
import mod_2
print(mod_1.a)
print(mod_2.a)
15
20
А теперь импортируем эти же самые модули с помощью from … import *:
from mod_1 import *
from mod_2 import *
print(a)
20
Как видите, второй модуль переопределил значение переменной a. Но ниже я покажу как это можно обойти.
Задание имени импортируемого модуля
Импортируемому модулю или объекту (если используется оператор from) можно задать имя с помощью оператора as, например:
import mod_1 as m
m.hello()
Hello World!
Это удобно, когда имя модуля длинное. Например, многие сторонние модули принято импортировать с короткими псевдонимами (import numpy as np).
Кстати, это позволяет импортировать объекты с одинаковыми именами с помощью from, следующим образом:
from mod_1 import a as m1a
from mod_2 import a as m2a
print(m1a)
print(m2a)
15
20
Не импортируемые переменные
В модуле можно использовать имена, начинающиеся на нижнее подчёркивание (переменные, функции и т.д.). Такие имена принято считать внутренними, и при импорте через from … import * они не попадают в основную программу.
Например исправим наш второй модуль (mod_2.py):
_a = 20
_b = 30
def my_func():
return(_a + _b)
Импортируем этот модуль в программу и попробуем обратиться к переменным _a и _b:
from mod_2 import *
print(_a, _b)
NameError: name '_a' is not defined
Зато функцию использовать мы сможем, и она спокойно обратится к переменным _a и _b внутри своего модуля:
from mod_2 import *
print(my_func())
50
А вот импортирование с помощью import позволит обращаться к таким объектам:
import mod_2
print(mod_2._a)
20
Также можно явно указать нужное имя, тогда from тоже его импортирует:
from mod_2 import _a
print(_a)
20
Это лишь договорённость между программистами, а не защита. Нижнее подчёркивание говорит: «это внутреннее имя, лучше его не трогать».
Переменная __all__
Управлять тем, что импортируется через from … import *, можно и по-другому. В модуле можно создать список __all__ с именами, которые нужно отдавать наружу. Всё остальное импортировано не будет. Создадим модуль mod_3.py:
__all__ = ["public_func"]
def public_func():
return "public"
def other_func():
return "other"
И попробуем вызвать обе функции:
from mod_3 import *
print(public_func())
print(other_func())
public
NameError: name 'other_func' is not defined
Выполнение модулей
Когда мы импортируем модуль, то его код выполняется. Происходит выполнение в момент импорта. Например, исправим наш второй модуль (mod_2.py) таким образом:
print("Запускает второй модуль")
_a = 20
_b = 30
def my_func():
return(_a + _b)
А в основной программе просто импортируем этот модуль и больше ничего выполнять не будем:
import mod_2
Запускает второй модуль
Но важно понимать, что код модуля выполняется только один раз, при первом импорте. Python запоминает уже загруженные модули (они хранятся в словаре sys.modules), и при повторном импорте просто берёт готовый модуль:
import mod_2
import mod_2
print("Конец")
Запускает второй модуль
Конец
Если вам всё-таки нужно выполнить модуль заново (например, при отладке в интерактивном режиме), то для этого есть функция reload() из модуля importlib:
import importlib
import mod_2
importlib.reload(mod_2)
Запускает второй модуль
Запускает второй модуль
Ещё вы можете заметить, что рядом с вашими файлами появился каталог __pycache__. В нём Python хранит скомпилированный байт-код импортированных модулей (файлы .pyc), чтобы в следующий раз загружать их быстрее. Вручную с ним ничего делать не нужно, а в git его обычно добавляют в .gitignore.
Импортировать модули можно в разных местах основной программы, не обязательно в начале файла. Например можно выполнять импортирование в блоке if, в функции или в других местах вашей программы. Но принято размещать все импорты в начале файла, в таком порядке:
- модули стандартной библиотеки;
- сторонние пакеты;
- ваши собственные модули.
Атрибут модуля __name__
У каждого модуля есть атрибут __name__, который может принимать разные значения:
- Если модуль вызывается как программа верхнего уровня, то этот атрибут принимает значение
__main__. - А если этот модуль импортируется в другой модуль (в основную программу) то атрибут
__name__примет значение имени модуля.
Например, ещё раз изменим код второго модуля и выполним этот модуль:
print(__name__)
if __name__ == '__main__':
print("Запускаем модуль как программу")
else:
print("Запускаем модуль как модуль")
__main__
Запускаем модуль как программу
Теперь импортируем этот модуль в основную программу и выполним её:
import mod_2
mod_2
Запускаем модуль как модуль
Обычно это применяется, когда нужно, чтобы файл можно было и запускать, и импортировать. Весь «полезный» код (функции, классы) остаётся на виду, а то, что должно выполняться только при запуске (тесты, вызов главной функции), прячут под проверку __name__. Типичный шаблон выглядит так:
def main():
print("Запускаем модуль как программу")
if __name__ == '__main__':
main()
Встроенные модули и сторонние пакеты
Все модули, которые вы можете импортировать, можно разделить на три группы:
- встроенные модули — это часть самого интерпретатора;
- стандартная библиотека — модули, которые поставляются вместе с Python;
- сторонние пакеты — то, что вы устанавливаете дополнительно.
Встроенные модули
В Python 3 есть небольшой набор встроенных модулей (built-in modules). Они написаны на языке C и интегрированы в интерпретатор Python. Чтобы посмотреть список встроенных модулей нужно воспользоваться одним из них — модулем sys. Модуль sys предоставляет доступ к системным функциям и переменным. Посмотрим с помощью него на список встроенных модулей:
import sys
print(sys.builtin_module_names)
('_abc', '_ast', '_bisect', '_blake2', '_codecs', '_codecs_cn', '_codecs_hk', '_codecs_iso2022', '_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', '_contextvars', '_csv', '_datetime', '_functools', '_heapq', '_hmac', '_imp', '_interpchannels', '_interpqueues', '_interpreters', '_io', '_json', '_locale', '_lsprof', '_math_integer', '_md5', '_multibytecodec', '_opcode', '_operator', '_pickle', '_random', '_sha1', '_sha2', '_sha3', '_signal', '_sre', '_stat', '_statistics', '_string', '_struct', '_suggestions', '_symtable', '_sysconfig', '_thread', '_tokenize', '_tracemalloc', '_types', '_typing', '_warnings', '_weakref', '_winapi', 'array', 'atexit', 'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 'math', 'mmap', 'msvcrt', 'nt', 'sys', 'time', 'winreg', 'xxsubtype', 'zlib')
Это вывод у меня на Windows и Python 3.15. На Linux или в другой версии Python список будет другим.
Также, с помощью модуля sys можно узнать много другой информации:
import sys
print("Версия Python - ", sys.version, '\n')
print("Модули при импорте ищутся в этих каталогах:", sys.path, '\n')
print("Кодировка - ", sys.getdefaultencoding(), '\n')
print("Платформа: ", sys.platform, '\n')
Версия Python - 3.15.0 (tags/v3.15.0:d220409, Oct 9 2026, 11:55:56) [MSC v.1951 64 bit (AMD64)]
Модули при импорте ищутся в этих каталогах: ['c:\\Users\\user\\Documents\\python', 'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python315\\python315.zip', 'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python315\\DLLs', 'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python315\\Lib', 'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python315', 'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python315\\Lib\\site-packages']
Кодировка - utf-8
Платформа: win32
Стандартная библиотека
Большая часть модулей, которые мы привыкли считать «встроенными», на самом деле относится к стандартной библиотеке (standard library). Она устанавливается вместе с Python, поэтому для её использования ничего дополнительно ставить не нужно. Многие модули стандартной библиотеки написаны на самом Python и лежат в каталоге Lib, который виден в выводе sys.path выше.
Модуль math — содержит множество математических функций, например:
import math
print(math.factorial(5)) # Факториал
print(math.fmod(16, 3)) # Остаток от деления
print(math.log10(1000)) # Логарифм 1000 по основанию 10
print(math.log2(8)) # Логарифм 8 по основанию 2
print(math.sqrt(16)) # Квадратный корень из 16
120
1.0
3.0
3.0
4.0
Модуль os — позволяет работать с операционной системой:
import os
print(os.getcwd()) # Текущая директория
print(os.listdir(path=".")) # Список файлов в директории
print(os.getlogin()) # Имя пользователя
print(os.getpid()) # Текущий pid процесса
C:\Users\user\AppData\Local\Programs\Microsoft VS Code
['69047191fc', '6bab64e2d1', 'bin', 'Code.exe', 'Code.VisualElementsManifest.xml', 'dcd3ad6e36', 'new_Code.exe', 'new_Code.VisualElementsManifest.xml', 'unins000.dat', 'unins000.exe', 'unins000.msg', 'updating_version']
user
3140
У вас значения будут свои.
Начиная с Python 3.10 список имён всей стандартной библиотеки можно получить так:
import sys
print('json' in sys.stdlib_module_names)
print('requests' in sys.stdlib_module_names)
True
False
Модуль json входит в стандартную библиотеку, а requests — нет, это сторонний пакет.
Стоит помнить, что стандартная библиотека со временем меняется. В Python 3.12 удалили модули distutils, imp, asyncore, asynchat и smtpd. А в Python 3.13 убрали ещё два десятка устаревших модулей. Если старый скрипт после обновления Python падает с ModuleNotFoundError, то причина может быть в этом.
Где Python ищет модули
Когда вы пишете import имя, Python ищет модуль в таком порядке:
- Сначала проверяет, не импортирован ли этот модуль уже (
sys.modules). - Затем проверяет встроенные модули.
- После этого просматривает по очереди каталоги из списка
sys.path.
Список sys.path мы уже видели выше. Первым в нём идёт каталог запущенной программы, затем каталоги из переменной окружения PYTHONPATH (если она задана), затем каталоги стандартной библиотеки и каталоги site-packages, куда устанавливаются сторонние пакеты.
Из-за такого порядка есть частая ошибка у начинающих: назвать свой файл так же, как называется модуль стандартной библиотеки. Например, вы создали файл random.py и внутри него написали import random. Python найдёт в первую очередь ваш файл, а не стандартный модуль:
import random
print(random.randint(1, 10))
AttributeError: module 'random' has no attribute 'randint' (consider renaming 'random.py' since it has the same name as the standard library module named 'random' and prevents importing that standard library module)
Поэтому не называйте свои модули как стандартные (random.py, math.py, test.py, json.py и т.п.). Если после создания файла Python ведёт себя странно, то первым делом проверьте имя файла.
Сторонние пакеты
Также в систему можно установить дополнительные модули с помощью утилиты командной строки pip, для этого в командной строке нужно выполнить:
python -m pip install <имя_пакета>
Запуск через python -m pip (в Windows можно py -m pip) гарантирует, что пакет установится именно для того интерпретатора Python, которым вы потом будете запускать программу.
Пакет — это каталог с модулями для решения определённой задачи. На Windows скорее всего эти пакеты будут скачаны в каталог:
C:\Users\<Имя_пользователя>\AppData\Local\Programs\Python\Python<версия>\Lib\site-packages\<имя пакета>
Узнать где лежит конкретный пакет можно командой pip show <имя_пакета>, она выведет строку Location.
Вот ещё несколько полезных команд pip:
pip list # список установленных пакетов
pip show requests # информация о пакете
pip uninstall requests # удалить пакет
pip freeze > requirements.txt # сохранить список пакетов с версиями
pip install -r requirements.txt # установить пакеты из списка
Виртуальные окружения (venv)
Если вы работаете на Linux, то с современными дистрибутивами (например, Debian 12 и новее, Ubuntu 23.04 и новее) вы столкнётесь с такой ошибкой при попытке установить пакет через pip в системный Python:
error: externally-managed-environment
Так сделано специально, чтобы pip не ломал пакеты, которые поставил менеджер пакетов дистрибутива (apt). Правильное решение — создать виртуальное окружение. Это отдельный каталог с копией интерпретатора и своим site-packages, в который можно ставить пакеты, не затрагивая систему:
python3 -m venv .venv
source .venv/bin/activate
pip install requests
В Debian и Ubuntu для этого может понадобиться пакет python3-venv (apt install python3-venv). На Windows окружение активируется командой .venv\Scripts\activate. Чтобы выйти из окружения, выполните deactivate. Для каждого проекта удобно создавать своё окружение, тогда разные проекты не мешают друг другу, даже если им нужны разные версии одного и того же пакета.
Для установки утилит командной строки, написанных на Python, ещё удобно использовать pipx, а в последнее время набирает популярность менеджер пакетов uv
, который делает то же самое, но намного быстрее.
Список всех модулей
Получить список всех модулей (встроенных, стандартных и установленных) можно таким образом:
help('modules')
__future__ _symtable genericpath shlex
__hello__ _sysconfig getopt shutil
__phello__ _testbuffer getpass signal
_abc _testcapi gettext site
_aix_support _testclinic glob smtplib
_android_support _testclinic_limited graphlib socket
_apple_support _testconsole gzip socketserver
_ast _testimportmultiple hashlib sqlite3
### вывод сократил, так как он очень большой
Эта команда импортирует все модули подряд, поэтому может работать долго. А список установленных сторонних пакетов проще посмотреть через pip list.
Примеры пакетов
Я, например, использовал следующие пакеты:
- proxmoxer — для работы с proxmox кластером;
- requests — для http запросов (требуется для proxmoxer);
- pyTelegramBotAPI — для написания ботов для telegram;
- psycopg2 (или более новый psycopg) — для работы с PostgreSQL.
Обратите внимание, что имя пакета для pip install и имя модуля для import не всегда совпадают. Например, пакет pyTelegramBotAPI импортируется как import telebot, а пакет psycopg2-binary — как import psycopg2.
А вообще таких модулей бесчисленное множество, одни позволяют создавать сайты, другие облегчают работу по созданию нейросетей, третьи позволяют создавать десктопные приложения, четвёртые позволяют подключаться к базам данных и так далее. Найти их можно на сайте pypi.org .
Создание своего пакета
Вы и сами можете создать папку для написания своих модулей, а затем импортировать эти модули. Такая папка с модулями и будет пакетом. Например, у нас есть такая структура:
project/
├── main.py
└── mypkg/
└── tools.py
В файле tools.py напишем функцию:
def greet():
print("Привет из пакета")
Теперь из main.py можно импортировать этот модуль тремя способами:
import mypkg.tools
mypkg.tools.greet()
from mypkg import tools
tools.greet()
from mypkg.tools import greet
greet()
Привет из пакета
Привет из пакета
Привет из пакета
То есть название пакета и название модуля разделяются точкой: <название_пакета>.<название_модуля>. Часто в каталог пакета кладут пустой файл __init__.py. Он нужен, чтобы явно пометить каталог как пакет, и в нём можно писать код, который выполнится при импорте пакета. В современных версиях Python для простых случаев этот файл не обязателен.
Итог
После прочтения этой статьи вы должны лучше понимать зачем нужны модули в Python 3. А также должны уметь создавать свои модули и пакеты, использовать встроенные модули и стандартную библиотеку, устанавливать сторонние пакеты (через pip и виртуальные окружения).
Я описал работу трёх операторов: import, from, as. Рассказал про не импортируемые объекты, имена которых начинаются на нижнее подчёркивание, про переменную __all__ и про атрибут __name__. А также про то, что код модуля выполняется один раз и где Python ищет модули.
Если понравилась статья, подпишись на мой канал в VK или Telegram .