Что такое пакеты python
Python. Урок 13. Модули и пакеты
Модули и пакеты значительно упрощают работу программиста. Классы, объекты, функции и константы, которыми приходится часто пользоваться можно упаковать в модуль, и, в дальнейшем, загружать его в свои программы при необходимости. Пакеты позволяют формировать пространства имен для работы с модулями.
Модули в Python
Что такое модуль в Python?
Под модулем в Python понимается файл с расширением .py. Модули предназначены для того, чтобы в них хранить часто используемые функции, классы, константы и т.п. Можно условно разделить модули и программы: программы предназначены для непосредственного запуска, а модули для импортирования их в другие программы. Стоит заметить, что модули могут быть написаны не только на языке Python, но и на других языках (например C).
Как импортировать модули в Python?
Самый простой способ импортировать модуль в Python это воспользоваться конструкцией:
import имя_модуля
Импорт и использование модуля math, который содержит математические функции, будет выглядеть вот так.
За один раз можно импортировать сразу несколько модулей, для этого их нужно перечислить через запятую после слова import:
import имя_модуля1, имя_модуля2
Если вы хотите задать псевдоним для модуля в вашей программе, можно воспользоваться вот таким синтаксисом:
import имя_модуля as новое_имя
Используя любой из вышеперечисленных подходов, при вызове функции из импортированного модуля, вам всегда придется указывать имя модуля (или псевдоним). Для того, чтобы этого избежать делайте импорт через конструкцию from … import…
from имя_модуля import имя_объекта
При этом импортируется только конкретный объект (в нашем примере: функция cos), остальные функции недоступны, даже если при их вызове указать имя модуля.
Для имортирования нескольких функций из модуля, можно перечислить их имена через запятую.
from имя_модуля import имя_объекта1, имя_объекта2
Импортируемому объекту можно задать псевдоним.
from имя_модуля import имя_объекта as псевдоним_объекта
Если необходимо импортировать все фукнции, классы и т.п. из модуля, то воспользуйтесь следующей формой оператора from … import …
from имя_модуля import *
Пакеты в Python
Что такое пакет в Python?
Пакет в Python – это каталог, включающий в себя другие каталоги и модули, но при этом дополнительно содержащий файл __init__.py. Пакеты используются для формирования пространства имен, что позволяет работать с модулями через указание уровня вложенности (через точку).
Для импортирования пакетов используется тот же синтаксис, что и для работы с модулями.
Использование пакетов в Python
Рассмотрим следующую структуру пакета:
Пакет fincal содержит в себе модули для работы с простыми процентами ( simper.py ), сложными процентами ( compper.py ) и аннуитетами ( annuity.py ).
Для использования фукнции из модуля работы с простыми процентами, можно использовать один из следующих вариантов:
Файл __init__.py может быть пустым или может содержать переменную __all__, хранящую список модулей, который импортируется при загрузке через конструкцию
from имя_пакета import *
Например для нашего случая содержимое __init__.py может быть вот таким:
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”. 
Поделиться
Пакеты — Основы языка Python
Мы уже знаем, что в Python код хранится в отдельных файлах, называемых модулями. Но если начать делить код достаточно большого проекта на модули, то довольно быстро может возникнуть желание сгруппировать несколько модулей «по смыслу». Или же мы захотим вынести часть модулей из проекта с целью их использования в других проектах. Для объединения модулей в группы служат пакеты (packages).
Итак, пакет — это директория (далее «каталог») с файлами модулей, имеющая имя в формате «snake_case» и содержащая, помимо прочего, специальный модуль с именем » __init__.py «. Именно наличие этого специального файла подсказывает интерпретатору Python, что каталог следует воспринимать именно как пакет.
Простейший пакет
Давайте рассмотрим пример простейшего пакета. Пусть пакет состоит из каталога package и модуля __init__.py внутри этого каталога:
Файл __init__.py пусть содержит код:
Это, хотя и небольшой, но уже полноценный пакет. Его можно импортировать так же, как мы импортировали бы модуль:
Заметьте — мы не импортировали файл __init__.py непосредственно. При первом обращении к пакету Python автоматически импортирует модуль __init__.py в этом пакете. Поэтому, очевидно, нельзя импортировать «просто каталог» — ведь каталог без файла __init__.py не будет полноценным пакетом!
Содержимое пакета
С простым пакетом всё ясно — его можно использовать как модуль. Но давайте уже перейдём к группировке в пакете нескольких модулей! Для этого в пакет положим ещё два модуля:
Содержимое модуля constants.py :
Содержимое модуля functions.py :
Этот вариант самый понятный: в строчке вызова функции greet сразу видно, откуда пришла функция, а откуда — её аргумент. Но писать имя пакета и имя модуля каждый раз — утомительно! Давайте импортируем саму функцию и аргумент:
Так строчка вызова функции выглядит гораздо лучше! Но помните, что тому, кто будет читать этот код в дальнейшем, потребуется посмотреть в блок импортов, чтобы узнать, откуда функция и константа появились.
Пакеты и импорты
Импорты в Python бывают двух видов: абсолютные и относительные. Понимание разницы становится особенно важным, когда вы начинаете работать с пакетами.
Абсолютные импорты
Абсолютный импорт выглядит как указание полного пути до модуля, включающего все пакеты и подпакеты (subpackages) — да, любой пакет может содержать не только модули, но и вложенные пакеты! Полные пути гарантируют однозначность: интерпретатору всегда понятно, что и откуда импортируется, и читать такие импорты проще.
Относительные импорты
Относительные импорты выглядят так:
Какие же импорты использовать?
Я придерживаюсь мнения большинства: нужно всегда использовать абсолютные импорты! Даже если вы внутри одного пакета один модуль импортируете в другой. Да, при использовании абсолютных импортов приходится писать чуть больше. Но понятность кода — слишком полезное свойство, чтобы от него отказываться!
Остались вопросы? Задайте их в разделе «Обсуждение»
Вам ответят команда поддержки Хекслета или другие студенты.
Нашли опечатку или неточность?
Выделите текст, нажмите ctrl + enter и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.
Что-то не получается или материал кажется сложным?
Загляните в раздел «Обсуждение»:
Об обучении на Хекслете
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно.
Наши выпускники работают в компаниях:
С нуля до разработчика. Возвращаем деньги, если не удалось найти работу.
Ликбез по пакетам и шпаргалка по модулям в Python
О чём пойдёт речь
Как вы, возможно знаете, код на Python хранится в модулях (modules), которые могут быть объединены в пакеты (packages). Это руководство призвано подробно рассказать именно о пакетах, однако совсем не упомянуть модули нельзя, поэтому я немного расскажу и о них. Многое из того, что применимо к модулям, справедливо и для пакетов, особенно если принять во внимание тот факт, что каждый, как правило, ведёт себя как модуль.
Кратко о модулях
Модуль в Python — это файл с кодом. Во время же исполнения модуль представлен соответствующим объектом, атрибутами которого являются:
При этом определения и импортированные сущности ничем друг от друга не отличаются: и то, и другое — это всего лишь именованные ссылки на некоторые объекты первого класса (такие, которые могут быть переданы из одного участка кода в другой как обычные значения).
Такое единообразие удобно, например, при рефакторинге: мы можем разделить один разросшийся модуль на несколько, а потом импортировать вынесенные определения в оригинальный модуль. При этом с точки зрения внешнего наблюдателя переработанный модуль будет иметь те же атрибуты, которые имел до внесения изменений, а значит у пользователей модуля ничего в коде не сломается.
Модули и видимость содержимого
В Python нет настоящего сокрытия атрибутов объектов, поэтому и атрибуты объекта модуля так или иначе всегда доступны после импорта последнего. Однако существует ряд соглашений, которые влияют на процесс импортирования и поведение инструментов, работающих с кодом.
Так атрибуты, имя которых начинается с одиночного подчёркивания, считаются как бы помеченными «для внутреннего использования», и обычно не отображаются в IDE при обращению к объекту «через точку». И linter обычно предупреждает об использовании таких атрибутов, мол, «небезопасно!». «Опасность» состоит в том, что автор кода имеет полное право изменять состав таких атрибутов без уведомления пользователей кода. Поэтому программист, использовавший в своём коде приватные части чужого кода рискует в какой-то момент получить код, который перестанет работать при обновлении сторонней библиотеки.
Итак, мы можем определять публичные атрибуты модуля, приватные атрибуты (так называют упомянутые выше атрибуты «для внутреннего пользования»). И данное разделение касается не только определений, содержащихся в самом модуле, но и импортируемых сущностей. Ведь все импортированные объекты становятся атрибутами и того модуля, в который они импортированы.
Живой пример видимости атрибутов модулей.
Рассмотрим пример, демонстрирующий всё вышеописанное. Пусть у нас будет два файла:
А эти атрибуты не будут видны:
Импорт import other_module я не рассматриваю как тривиальный случай.
Теперь рассмотрим импорт всего содержимого module:
Последствия импорта from other_module import * тоже очевидны и я их не рассматриваю.
Наконец-то, пакеты!
Импортирование пакетов
Пакет с единственным модулем __init__.py при импорте ведёт себя как обычный модуль. Содержимое инициализирующего модуля определяет атрибуты объекта пакета.
Прочие модули пакета и вложенные пакеты не импортируются автоматически вместе с пакетом-родителем, но могут быть импортированы отдельно с указанием полного имени. Важный момент: при импортировании вложенного модуля всегда сначала импортируются модули инициализации всех родительских пакетов (если оные ещё ни разу не импортировались, но об этом я расскажу ниже).
Рассмотрим, к примеру, следующую структуру директорий и файлов:
Так что же, если мы загрузим парочку вложенных модулей, то для каждого будет выполняться загрузка всех __init__.py по дороге? Не будет! Подсистема интерпретатора, отвечающая за загрузку модулей, кэширует уже загруженные пакеты и модули. Каждый конкретный модуль загружается ровно один раз, в том числе и инициализирующие модули __init__.py (короткие имена модулей хоть и одинаковы, но полные имена всегда разные). Все последующие импортирования модуля не приводят к его загрузке, только лишь нужные атрибуты копируются в соответствующие области видимости.
Пакеты и __all__
Вот структура пакета:
Файл же package/__init__.py содержит следующее (и только это!):
Указанный автоматизм достаточно ограничен: не работает «вглубь», например — не импортирует «через звёздочку» указанные модули и подпакеты. Если же вам вдруг такого захочется, вы всегда сможете на соответствующих уровнях в __init__.py сделать from x import * и получить в корневом пакете плоскую область видимости со всем нужным содержимым. Но такое нужно довольно редко, потому что «не помогает» ни IDE, ни ручному поиску по коду. Впрочем, знать о фиче и иметь её в виду — не вредно, как мне кажется.
Изучайте Python на Хекслете Первые курсы в профессии Python-программист доступны бесплатно сразу после регистрации. Начните сегодня, учитесь в комфортном для вас темпе.
Пакеты, модули и точки входа
Более того, модули __main__ нельзя импортировать обычным способом, поэтому можно не бояться случайного импорта и писать команды прямо на верхнем уровне: всё равно странно в модуле с именем __main__ проверять, что его имя равно __main__ (хе-хе!).
PEP 420, или неявные пространства имён
Раз уж развёл ликбез, расскажу и про эту штуку.
Долгое время в Python пакеты были обязаны иметь файл __init__.py — наличие этого файла позволяло отличить пакет от обычной директории с модулями (с которыми Python работать не мог). Но с версии Python3.3 вступил в силу PEP 420, позволяющий создавать пространства имён «на вырост».
Тут стоит отметить, что с полноценными пакетами подобное не срабатывало ранее и не будет работать в будущем. Если среди путей пакет с модулем инициализации находится в первый раз, все последующие пакеты с тем же именем будут проигнорированы. Это защищает вас от смешивания сторонних пакетов с системными. И даже просто от ошибок именования: назвав пакет так же, как называется встроенный пакет или модуль, вы получите ошибку — ваши определения не будут импортироваться.
Пакеты — пространства имён (Namespace Packages, NP) — а именно так называются пакеты без инициализации — не могут объединяться с полноценными пакетами, поэтому добавить что-то в системный пакет вам также не удастся. И тут всё защищено!
Важно: помните, если встретятся обычный пакет и NP с одинаковым именем, то победит обычный пакет! А NP, сколько бы их не было, не будут загружены!
Циклические импорты
Если же приспичивает, и импортировать что-то «ну очень нужно», то можно попробовать обойтись локальным импортом:
Да, это костыль. Но иногда полезный. В идеале — до ближайшего большого рефакторинга. Поэтому настраивайте linter на ловлю локальных импортов и стремитесь убирать такие костыли хоть когда-нибудь!
Поиск пакетов и модулей
Пайтон ищет модули и пакеты в директориях, во время исполнения перечисленных в списке sys.path — по порядку от первого пути к последнему.
В этом списке пути до стандартных библиотек обычно расположены раньше, чем директории со сторонними пакетами, чтобы нельзя было случайно заменить стандартный пакет сторонним (помним: кто первый, того и тапки — среди нескольких с одинаковыми именами загружается первый попавшийся пакет).
Обычно пути трогать не нужно, всё вполне нормально «работает само». Но если очень хочется, то путей у вас несколько:
Первый способ — простой и понятный. Не сложнее добавления пути до исполняемых файлов в PATH (даже синтаксис тот же).
Кстати, когда вы используете виртуальные окружения, sys.path будет содержать пути до локальных копий стандартных библиотек. Именно это позволяет виртуальному окружению быть самодостаточным (работать на любой машине с подходящей ОС — даже без установленного в систему Python!).
Что не было раскрыто?
Я специально не стал рассказывать про
Темы эти насколько интересны, настолько и велики. На наше счастье, самим разбираться в такой тонкой и сложной машинерии приходится редко. Мы просто пользуемся готовыми магическими артефактами, а зачаровывают их другие 🙂 Если же вы захотите научиться магии, документация вам в руки.
Как использовать пакеты Python
Russian (Pусский) translation by Ilya Nikov (you can also view the original English article)
Пакеты Python позволяют разбивать большие системы и организовывать их модули согласованным образом, которые вы и другие люди можете эффективно повторно использовать. Девиз Python «Батареи включены» означает, что он поставляется с предустановленным множеством полезных пакетов в стандартной библиотеке.
Но есть и множество удивительных сторонних пакетов, которыми вы можете воспользоваться. В этом уроке вы узнаете все, что вам нужно знать о том, какие именно пакеты, как импортировать модули из пакетов, изучим встроенный пакет в стандартной библиотеке Python и научимся устанавливать сторонние пакеты.
Что такое пакеты?
Чтобы просмотреть весь Zen Python, введите import this в интерактивном сеансе Python:
Пространства имен помогают в организации кода и предотвращении конфликтов имен. Это важно, когда несколько человек работают вместе или при использовании пакетов, разработанных другими людьми.
Хотя пакеты представляют собой иерархию подпакетов и модулей, которые являются файлами, иерархия не имеет файловой системы, на которой пакеты и подпакеты являются каталогами и подкаталогами. Это намного более гибко, чем это.
Пример пакета
Давайте посмотрим на пакет под названием «ansible». Это не пакет из стандартной библиотеки. Вы увидите позже, как найти и установить сторонние пакеты. Теперь давайте просто рассмотрим структуру дерева файлов.
Пакеты будут устанавливаться обычно в каталог site-packages интерпретатора Python, который будет находиться где-нибудь (в зависимости от версии, ОС и дистрибутива) под «lib». На Mac для Python 2.7 он будет находиться в папке /lib/python2.7/site-packages». Вот как организован пакет «ansible»:
Существует два модуля и 15 каталогов. Каждый каталог является суб-пакетом основного доступного пакета. Заглядывая в каталог ansible/utils, мы видим, что он содержит дополнительные модули и еще один дополнительный пакет:
Путь поиска
Чтобы импортировать модуль path.py из unsible/utils, вам необходимо использовать следующую команду:
Если вы также хотите использовать стандартный модуль os.oath, вы будете использовать следующую команду:
Теперь вы можете использовать один или оба модуля без конфликтов из-за пространства имен, к которому они принадлежат.
Изучение стандартной библиотеки
В стандартной библиотеке много пакетов. Это стоит изучить, когда вам нужно выполнить какую-то задачу, и вы не знаете, как это сделать. Существует очень высокая вероятность того, что для любой задачи общего назначения, такой как математика, интеграция с оболочкой, интеграция ОС, строковые манипуляции, сетевые и общие форматы файлов, в стандартной библиотеке имеется хорошо продуманный, хорошо исполняемый и хорошо протестированный пакет.
Вы действительно можете доверять стандартным библиотечным пакетам, потому что простому пакету очень непросто попасть в стандартную библиотеку. Либо пакет был разработан основными разработчиками Python, либо он был сильно пересмотрен и часто использовался на местах в качестве сторонней библиотеки, прежде чем его переместили в стандартную библиотеку.
Вот все пакеты в стандартной библиотеке, организованные по темам.
Просмотр PyPI
PyPI организует пакеты в индексе просмотра. Вы можете просматривать и искать по темам, среде, структуре, разработке, статусу, целевой аудитории, лицензии, естественному языку, языку программирования (да, есть пакеты Python, поддерживающие многие языки программирования) и операционной системе.
Существует также различие между пакетами Python 2 и Python 3, и вы можете увидеть, насколько популярным является пакет по количеству последних загрузок. Например, пакет ansible доступен в PyPI, и вот его метаданные:
Установка пакетов
Используйте пипетку для установки колеса: pip install wheel
Если вы используете более раннюю версию Python, подумайте об обновлении. Если вы не можете, вам нужно будет установить pip, setuptools и wheel самостоятельно. Проверьте инструкции.
Пакеты Python всегда устанавливаются в среду. Общей практикой, на которой я не буду здесь останавливаться, является использование виртуальных сред для управления несколькими независимыми установками Python с различными интерпретаторами и / или различными наборами установленных пакетов.
Лучшие практики
Python packaging authority предоставляет множество рекомендаций по лучшим методам упаковки. Это важно, потому что это область активного развития, и рекомендации быстро развиваются.
Кроме того, если вы хотите сделать что-то особенное, например, устанавливать пакеты из альтернативных репозиториев вместо PyPI или использовать более сложный метод, вы найдете отличные обсуждения и практические советы.
Заключение
Если вы новичок в Python, вы изучаете основной язык и весело проводите с ним время. Довольно скоро вы открываете стандартную библиотеку, и по мере того, как вы приобретаете больше опыта, вы все больше и больше выигрываете от ее богатства.
Следующим этапом вашей эволюции как Pythonista открытие сообщества Python и PyPI. Пакеты в качестве единицы развертывания многоразового кода Python позволяют использовать эту экосистему.
Пакеты Python — создание и доступ
Пакеты Python помогают нам управлять модулями и скриптами Python. Это обычные каталоги со сценарием инициализации — __init__.py.
Как создать пакет Python?
Мы можем создать пакет, выполнив следующие шаги.
Что мы можем сохранить в пакете?
В общем, пакет — это каталог в наших компьютерных системах. Единственное отличие — это обязательное включение файла __init__.py.
Можно ли создавать подпакеты?
Да, мы можем создать пакет внутри другого пакета. Мы также должны следовать правилам упаковки, чтобы создать подпакет.
Примеры
Давайте рассмотрим несколько примеров создания и использования пакетов.
1. Создание пакета
2. Добавление модулей
Допустим, у нас есть два модуля Python — math.py и str_utils.py. У них есть несколько функций, которые будут использоваться в нашей программе.
Мы хотим добавить эти модули в наши пакеты. Просто скопируйте эти файлы в каталог пакетов, где вы хотите сохранить эти модули.
3. Импорт пакета
Синтаксис для импорта модуля Python внутри пакета:
Вот код my_script.py для доступа к модулям из пакетов и вызова их функций.
Мы также можем импортировать модуль, используя синтаксис ниже:
Вот обновленный пример доступа к модулям «math» и «str_utils» в нашей программе.
4. Импорт * из пакета
Мы можем импортировать каждый модуль из пакета, используя следующий синтаксис.
В этом случае Python ищет в sub_package2 пакеты, модули и функции. Это может вызвать побочные эффекты из-за импорта того, чего вы не хотите. Кроме того, это очень долгий процесс.
Мы можем определить список импортируемых модулей, создав переменную __all__ в файле __init__.py.
утилиты / __ init__.py:
утилиты / строки / __ init__.py:
Обновленный код my_script.py:
Обратите внимание, что код python в __init__.py выполняется первым, когда пакеты инициализируются и импортируются.
Как добавить пакет в системный путь
Невозможно всегда зависеть от иерархии каталогов для импорта модулей пакета. Мы можем добавить наш собственный пакет в переменную sys.path, а затем импортировать их в любой скрипт.
Пакеты в Python позволяют нам разделить наши прикладные модули и скрипты на логические модули. Это сохраняет нашу базу кода чистой и простой в обслуживании.