Работа с модулями: создание, подключение инструкциями import и from
Модулем в Python называется любой файл с программой (да-да, все те программы, которые вы писали, можно назвать модулями). В этой статье мы поговорим о том, как создать модуль, и как подключить модуль, из стандартной библиотеки или написанный вами.
Каждая программа может импортировать модуль и получить доступ к его классам, функциям и объектам. Нужно заметить, что модуль может быть написан не только на Python, а например, на C или C++.
Подключение модуля из стандартной библиотеки
Подключить модуль можно с помощью инструкции import. К примеру, подключим модуль os для получения текущей директории:
import указывается название модуля. Одной инструкцией можно подключить несколько модулей, хотя этого не рекомендуется делать, так как это снижает читаемость кода. Импортируем модули time и random.
Использование псевдонимов
Если название модуля слишком длинное, или оно вам не нравится по каким-то другим причинам, то для него можно создать псевдоним, с помощью ключевого слова as.
Инструкция from
Подключить определенные атрибуты модуля можно с помощью инструкции from. Она имеет несколько форматов:
Первый формат позволяет подключить из модуля только указанные вами атрибуты. Для длинных имен также можно назначить псевдоним, указав его после ключевого слова as.
Следует заметить, что не все атрибуты будут импортированы. Если в модуле определена переменная __all__ (список атрибутов, которые могут быть подключены), то будут подключены только атрибуты из этого списка. Если переменная __all__ не определена, то будут подключены все атрибуты, не начинающиеся с нижнего подчёркивания. Кроме того, необходимо учитывать, что импортирование всех атрибутов из модуля может нарушить пространство имен главной программы, так как переменные, имеющие одинаковые имена, будут перезаписаны.
Создание своего модуля на Python
Теперь пришло время создать свой модуль. Создадим файл mymodule.py, в которой определим какие-нибудь функции:
Теперь в этой же папке создадим другой файл, например, main.py:
Выведет:
Поздравляю! Вы сделали свой модуль! Напоследок отвечу ещё на пару вопросов, связанных с созданием модулей:
Как назвать модуль?
Помните, что вы (или другие люди) будут его импортировать и использовать в качестве переменной. Модуль нельзя именовать также, как и ключевое слово (их список можно посмотреть тут). Также имена модулей нельзя начинать с цифры. И не стоит называть модуль также, как какую-либо из встроенных функций. То есть, конечно, можно, но это создаст большие неудобства при его последующем использовании.
Куда поместить модуль?
Туда, где его потом можно будет найти. Пути поиска модулей указаны в переменной sys.path. В него включены текущая директория (то есть модуль можно оставить в папке с основной программой), а также директории, в которых установлен python. Кроме того, переменную sys.path можно изменять вручную, что позволяет положить модуль в любое удобное для вас место (главное, не забыть в главной программе модифицировать sys.path).
Можно ли использовать модуль как самостоятельную программу?
Можно. Однако надо помнить, что при импортировании модуля его код выполняется полностью, то есть, если программа что-то печатает, то при её импортировании это будет напечатано. Этого можно избежать, если проверять, запущен ли скрипт как программа, или импортирован. Это можно сделать с помощью переменной __name__, которая определена в любой программе, и равна "__main__", если скрипт запущен в качестве главной программы, и имя, если он импортирован. Например, mymodule.py может выглядеть вот так:
Для вставки кода на Python в комментарий заключайте его в теги
Доступ к исходному коду Python и байт-коду
Интерпретатор Python компилирует код в байт - код перед выполнением его на виртуальной машине Python.
Вот как просмотреть байт-код функции Python
import dis def fib(n): if n
Функция dis.dis в модуле Дис возвратит декомпилированный байткод функции переданного ему.
Изучение объекта кода функции
CPython разрешает доступ к объекту кода для объекта функции.
__code__ объект содержит необработанный байт - код ( co_code ) функции, а также другую информацию , такую как константы и имена переменных.
def fib(n): if n
Показать исходный код объекта Объекты, которые не являются встроенными
Чтобы напечатать исходный код использования объекта в Python inspect .Обратите внимание, что это не будет работать ни для встроенных объектов, ни для объектов, определенных в интерактивном режиме. Для этого вам понадобятся другие методы, объясненные позже.
Вот как напечатать исходный код метода randint от random модуля:
import random import inspect print(inspect.getsource(random.randint)) # Output: # def randint(self, a, b): # """Return random integer in range [a, b], including both end points. # """ # # return self.randrange(a, b+1)
Просто напечатать строку документации
print(inspect.getdoc(random.randint)) # Output: # Return random integer in range [a, b], including both end points.
Печать полный путь к файлу , в котором метод random.randint определяется:
print(inspect.getfile(random.randint)) # c:\Python35\lib\random.py print(random.randint.__code__.co_filename) # equivalent to the above # c:\Python35\lib\random.py
Объекты, определенные в интерактивном режиме
Если объект определен в интерактивном режиме inspect не может предоставить исходный код , но вы можете использовать dill.source.getsource вместо
# define a new function in the interactive shell def add(a, b): return a + b print(add.__code__.co_filename) # Output: import dill print dill.source.getsource(add) # def add(a, b): return a + b
Исходный код для встроенных функций Python написано на C и может быть доступен только глядя на исходном коде языка Python (размещенные на ртутном или загрузить с https://www.python.org/downloads/source/ ).
print(inspect.getsource(sorted)) # raises a TypeError type(sorted) #
Как посмотреть код модуля python
Python обладает великолепной документацией и предоставляет удобные способы для работы с ней: от официального сайта до встроенной справочной системы.
Работа с документацией является одной из важных составляющих деятельности разработчика. И это не только чтение документации к библиотекам и комментариев в коде, но и документирование собственного кода, а также поддержание его в актуальном состоянии. Качественно задокументированный код во многих случаях упрощает его поддержание и сокращает время на «вхождение» новых сотрудников в проект. Если же речь идет об изучении нового языка программирования, качество документации и поддержка сообщества могут сыграть решающую роль в освоении материала и снизить порог вхождения.
Документация к языку программирования Python обладает всеми качествами, которые отличают «хорошую» документацию от «плохой». Тем не менее, новички часто сталкиваются с рядом вопросов. Как быстро найти информацию о классе или функции? Как самому писать документацию к коду? Какие инструменты можно использовать при документировании кода? На эти вопросы мы и постараемся ответить в статье.
Основной источник информации о Python
Безусловно, основным, наиболее полным и актуальным источником информации о Python является сайт c официальной документацией. Главная страница сайта предоставляет удобную навигацию по разделам.
Важные разделы сайта (полезно начинающим программистам):
- Setup and Usage — содержит информацию об установке и настройке Python на разных платформах;
- Tutorial — учебное пособие для новичков, с которого и рекомендуется начинать свой путь в мир Python;
- Library Reference — подробное описание стандартной библиотеки Python;
- Python HOWTO — различные руководства по конкретным темам;
- Language Reference — раздел для тех кто, хочет знать подробности реализации СPython.
Поиск по сайту с документацией
Для поиска по сайту имеются: окно быстрого поиска по ключевым словам и таблицы с индексами для поиска по названию модуля (класса, метода, переменной). Важно: Python динамично развивается, постоянно добавляются новые возможности и функционал. Если вы хотите работать с актуальной документацией — выберите необходимую вам версию Python в выпадающем меню в шапке сайта.
Создатели Python предусмотрели возможность установить документацию локально на компьютере. Для этого необходимо перейти на страницу загрузки, выбрать версию Python, формат файлов (доступны pdf, epub, html, txt) и способ архивирования. После скачивания и распаковки архива, вы можете пользоваться документацией в полном объеме.
Встроенная справочная система
Чтение объемного справочного руководства полезно на этапе изучения языка. При работе с кодом чаще возникает необходимость получить небольшую справку о работе той или иной функции, получаемых аргументах, или о наличии у класса атрибутов и методов. В таких случаях информация из официальной документации, как правило, избыточна, а поиск по ней может может занять значительное время. В Python для таких случаев существует встроенная справочная система, позволяющая быстро получить краткую справку об объекте.
Небольшое уточнение: поскольку в Python все является объектом, в том числе методы и классы, далее мы будем часто употреблять термин «объект» применительно к целям получения информации.
Доступ к встроенной справочной системе осуществляется с помощью функции help . Для получения справки по тому или иному объекту необходимо в интерпретаторе Python вызвать функцию help , а в качестве аргумента передать сам объект или строку с названием объекта.
В приведенном выше примере, мы вызвали справку по функции ord . В тексте сообщения содержится информация о том, что делает функция и к какому модулю она относится.
Теперь попробуем получить информацию о модуле стандартной библиотеки os .
Почему вызов функции завершился выбросом исключения? Ведь модуль os входит в стандартную библиотеку и маловероятно, что справочная информация по нему не была включена.
Docstring
Чтобы ответить на этот вопрос, давайте разберемся, где хранится справочная информация и как работает функция help . Как уже говорилось выше, все в Python является объектом. Все объекты в Python имеют специальный атрибут __doc__ , предназначенный для хранения строки документации — docstring. Вот как определено понятие docstring в официальной документации: «Docstring — строковый литерал, который встречается как первый оператор в определении модуля, функции, класса или метода. Такой docstring становится специальным атрибутом __doc__ этого объекта».
Посмотрим, что хранится в атрибуте __doc__ объекта ord.
Размещение справки об объекте в исходном коде самого объекта позволяет элегантно решить вопрос хранения информации и доступа к ней. Функция help при передаче ей в качестве аргумента объекта для получения информации о нем, обращается к атрибуту __doc__ этого объекта. Поскольку модуль os не импортирован, он отсутствует в глобальной области видимости и не доступен при вызове функции help . Именно по этой причине мы получаем ошибку. Для решения проблемы достаточно импортировать модуль. Есть еще один способ избежать ошибки и не связанный с импортом объекта — передать в качестве аргумента в функцию help строку с именем объекта.
В этом случае функция help для получения информации будет использовать модуль стандартной библиотеки pydoc , который выполнит импорт объекта и генерацию справки.
Посмотрим на исходный код модуля os и убедимся в том, что docstring и содержимое атрибута os . __doc__ совпадают. Из приведенного кода видно, как определяются в коде docstring. Строки документации заключаются в тройные кавычки и пишутся сразу под заголовком объекта.
Вы уже заметили, что вывод функции help отличается от вывода, полученного через обращение к атрибуту __doc__ объекта. Он более информативен и выводит информацию в виде форматированного текста. У функции help есть еще одна особенность, повышающая удобство работы со справочной системой. При вызове help без аргументов запускается интерактивный режим справочной системы. Для получения справки в нем достаточно набрать только название интересующего нас объекта. Запустив интерактивный режим в отдельном терминале, мы получаем удобный инструмент для работы с документацией.
Встроенная справочная система
Стандартная библиотека Python весьма обширна и содержит большое количество модулей. Помнить их все, в том числе и заложенный функционал, невозможно. Что делать, если мы не помним (не знаем) название модуля, класса или функции? Ниже приведены несколько примеров, помогающих в таких ситуациях.
Получение списка доступных модулей:
Получение ключевых слов:
Получение списка названий встроенных функций:
Весьма полезной и часто используемой разработчиками функцией является dir . В качестве аргумента она принимает объект и возвращает список допустимых атрибутов для этого объекта. Это один из способов узнать, какие методы и атрибуты содержит объект.
Как задокументировать собственный код?
Теперь, когда мы знаем о docstring и работе функции help , мы можем задокументировать свой код. В качестве примера возьмем скрипт factorial. py:
Добавим docstring.
Убедимся в наличии документации по модулю factorial :
Вызов help (factorial) вернет справку:
При создании документации к коду стоит придерживаться правил и рекомендаций, описанных в PEP257 и PEP8. Ссылки на эти документы приведены в конце статьи.
О библиотеке pydoc
Мы уже упоминали модуль стандартной библиотеки pydoc . Он автоматически генерирует документацию из модулей Python. Документация может быть представлена в виде страниц текста на консоли, отображаться в браузере или сохраняться в HTML-файлах.
Команда pydoc позволяет вывести текст справки прямо в терминале (не интерпретаторе Python):
Для создания документации в виде HTML-страниц используется ключ -w . Это позволяет организовать хранение документации отдельно от кода.
Для поиска по docstring модулей используется ключ -k . В качестве аргумента в этом случае передается ключевое слово. В результате будут выведены названия всех модулей в docstring которых встречается ключевое слово.
Обратим ваше внимание на одну особенность поиска по документации при использовании ключа -k . Поиск производится только по первым строкам документации модулей. Тем не менее, данный функционал может быть весьма полезным в некоторых случаях.
Для любителей работать в браузере, предусмотрена возможность запуска HTTP-сервера документации, который будет доступен по порту, указанному после ключа -p .
В третьей версии Python для управления сервером добавлена пара команд: b — открытие страницы документации в браузере, q — завершения работы сервера. При вызове команды pydoc3 с ключом -b произойдет запуск сервера и автоматическое открытие страницы в браузере. В документацию также будут включены модули, расположенные в директории из которой был запущен сервер.
Соблюдение соглашений
При документировании кода важно соблюдать принятые в языке программирования соглашения. Для решения этих задач существуют различные инструменты. В этой статье мы становимся на одном из них — модуле pydocstyle .
Модуль pydocstyle — это инструмент статического анализа для проверки соответствия docstring соглашениям, принятым в Python. Установка модуля осуществляется с помощью менеджера пакетов pip:
Модули¶
Как можно использовать код повторно, помещая его в функции, мы уже видели. А что, если нам понадобится повторно использовать различные функции в других наших программах? Как вы уже, наверное, догадались, ответ — модули.
Существуют разные способы составления модулей, но самый простой — это создать файл с расширением .py , содержащий функции и переменные.
Другой способ — написать модуль на том языке программирования, на котором написан сам интерпретатор Python. Например, можно писать модули на языке программирования C, которые после компиляции могут использоваться стандартным интерпретатором Python.
Модуль можно импортировать в другую программу, чтобы использовать функции из него. Точно так же мы используем стандартную библиотеку Python. Сперва посмотрим, как использовать модули стандартной библиотеки.
Пример: (сохраните как using_sys.py )
import sys print('Аргументы командной строки:') for i in sys.argv: print(i) print('\n\nПеременная PYTHONPATH содержит', sys.path, '\n')
Вывод:
$ python3 using_sys.py we are arguments Аргументы командной строки: using_sys.py we are arguments Переменная PYTHONPATH содержит ['', 'C:\\Windows\\system32\\python30.zip', 'C:\\Python30\\DLLs', 'C:\\Python30\\lib', 'C:\\Python30\\lib\\plat-win', 'C:\\Python30', 'C:\\Python30\\lib\\site-packages']
Как это работает:
В начале мы импортируем модуль sys командой import . Этим мы говорим Python, что хотим использовать этот модуль. Модуль sys содержит функции, относящиеся к интерпретатору Python и его среде, т. е. к системе (system).
Когда Python выполняет команду import sys , он ищет модуль sys . В данном случае это один из встроенных модулей, и Python знает, где его искать.
Если бы это был не скомпилированный модуль, т. е. модуль, написанный на Python, тогда интерпретатор Python искал бы его в каталогах, перечисленных в переменной sys.path . Если модуль найден, выполняются команды в теле модуля, и он становится доступным. Обратите внимание, что инициализация 1 происходит только при первом импорте модуля.
Доступ к переменной argv в модуле sys предоставляется при помощи точки, т. е. sys.argv . Это явно показывает, что это имя является частью модуля sys . Ещё одним преимуществом такого обозначения является то, что имя не конфликтует с именем переменной argv , которая может использоваться в вашей программе.
Переменная sys.argv является списком строк (списки будут детально обсуждаться в одной из последующих глав). Она содержит список аргументов командной строки, т. е. аргументов, переданных программе из командной строки.
Если вы используете среду разработки 2 для написания и запуска программ, поищите где-нибудь в её меню возможность передавать параметры командной строки.
В нашем примере, когда мы запускаем " python using_sys.py we are arguments ", мы запускаем модуль using_sys.py командой python , а всё, что следует далее — аргументы, передаваемые программе 3 . Python сохраняет аргументы командной строки в переменной sys.argv для дальнейшего использования.
Помните, что имя запускаемого сценария 4 всегда является первым аргументом в списке sys.argv . Так что в приведённом примере 'using_sys.py' будет элементом sys.argv[0] , 'we' -- sys.argv[1] , 'are' — sys.argv[2] , а 'arguments' -- sys.argv[3] . Помните, что в Python нумерация начинается с 0, а не с 1.
sys.path содержит список имён каталогов, откуда импортируются модули. Заметьте, что первая строка в sys.path пуста; эта пустая строка показывает, что текущая директория также является частью sys.path , которая совпадает со значением переменной окружения PYTHONPATH . Это означает, что модули, расположенные в текущем каталоге, можно импортировать напрямую. В противном случае придётся поместить свой модуль в один из каталогов, перечисленных в sys.path .
Помните, что текущий каталог — это каталог, в котором была запущена программа. Выполните " import os; print(os.getcwd()) ", чтобы узнать текущий каталог программы.
Файлы байткода .pyc¶
Импорт модуля — относительно дорогостоящее мероприятие, поэтому Python предпринимает некоторые трюки для ускорения этого процесса. Один из способов -- создать байт-компилированные файлы (или байткод) с расширением .pyc , которые являются некой промежуточной формой, в которую Python переводит программу (помните раздел Введение о том, как работает Python?). Такой файл .pyc полезен при импорте модуля в следующий раз в другую программу — это произойдёт намного быстрее, поскольку значительная часть обработки, требуемой при импорте модуля, будет уже проделана. Этот байткод также является платформо-независимым.
Обычно файлы .pyc создаются в том же каталоге, где расположены и соответствующие им файлы .py . Если Python не может получить доступ для записи файлов в этот каталог, файлы .pyc созданы не будут.
Оператор from . import . ¶
Чтобы импортировать переменную argv прямо в программу и не писать всякий раз sys. при обращении к ней, можно воспользоваться выражением " from sys import argv ".
Для импорта всех имён, использующихся в модуле sys , можно выполнить команду " from sys import * ". Это работает для любых модулей.
В общем случае вам следует избегать использования этого оператора и использовать вместо этого оператор import , чтобы предотвратить конфликты имён и не затруднять чтение программы.
Пример:
from math import * n = int(input("Введите диапазон:- ")) p = [2, 3] count = 2 a = 5 while (count n): b=0 for i in range(2,a): if ( i sqrt(a)): if (a % i == 0): print(a,"непростое") b = 1 else: pass if (b != 1): print(a,"простое") p = p + [a] count = count + 1 a = a + 2 print(p)
Имя модуля — name¶
У каждого модуля есть имя, и команды в модуле могут узнать имя их модуля. Это полезно, когда нужно знать, запущен ли модуль как самостоятельная программа или импортирован. Как уже упоминалось выше, когда модуль импортируется впервые, содержащийся в нём код исполняется. Мы можем воспользоваться этим для того, чтобы заставить модуль вести себя по-разному в зависимости от того, используется ли он сам по себе или импортируется в другую программа. Этого можно достичь с применением атрибута модуля под названием __name__ .
Пример: (сохраните как using_name.py )
if __name__ == '__main__': print('Эта программа запущена сама по себе.') else: print('Меня импортировали в другой модуль.')
Вывод:
$ python3 using_name.py Эта программа запущена сама по себе. $ python3 >>> import using_name Меня импортировали в другой модуль. >>>
Как это работает:
В каждом модуле Python определено его имя — __name__ 5 . Если оно равно '__main__' , это означает, что модуль запущен самостоятельно пользователем, и мы можем выполнить соответствующие действия.
Создание собственных модулей¶
Создать собственный модуль очень легко. Да вы всё время делали это! Ведь каждая программа на Python также является и модулем. Необходимо лишь убедиться, что у неё установлено расширение .py . Следующий пример объяснит это.
Пример: (сохраните как mymodule.py )
def sayhi(): print('Привет! Это говорит мой модуль.') __version__ = '0.1' # Конец модуля mymodule.py
Выше приведён простой модуль. Как видно, в нём нет ничего особенного по сравнению с обычной программой на Python. Далее посмотрим, как использовать этот модуль в других наших программах.
Помните, что модуль должен находиться либо в том же каталоге, что и программа, в которую мы импортируем его, либо в одном из каталогов, указанных в sys.path .
Ещё один модуль (сохраните как mymodule_demo.py ):
import mymodule mymodule.sayhi() print ('Версия', mymodule.__version__)
Вывод:
$ python mymodule_demo.py Привет! Это говорит мой модуль. Версия 0.1
Как это работает:
Обратите внимание, что мы используем всё то же обозначение точкой для доступа к элементам модуля. Python повсеместно использует одно и то же обозначение точкой, придавая ему таким образом характерный "Python-овый" вид и не вынуждая нас изучать всё новые и новые способы делать что-либо.
Вот версия, использующая синтаксис from..import (сохраните как mymodule_demo2.py ):
from mymodule import sayhi, __version__ sayhi() print('Версия', __version__)
Вывод mymodule_demo2.py такой же, как и mymodule_demo.py .
Обратите внимание, что если в модуле, импортирующем данный модуль, уже было объявлено имя __version__ , возникнет конфликт. Это весьма вероятно, так как объявлять версию любого модуля при помощи этого имени — общепринятая практика. Поэтому всегда рекомендуется отдавать предпочтение оператору import , хотя это и сделает вашу программу немного длиннее.
Вы могли бы также использовать:
from mymodule import *
Это импортирует все публичные имена, такие как sayhi , но не импортирует __version__ , потому что оно начинается с двойного подчёркивания
Одним из руководящих принципов в Python является "Явное лучше Неявного". Выполните команду " import this ", чтобы узнать больше, а также просмотрите это обсуждение, в котором приводятся примеры по каждому из принципов.
Функция dir¶
Встроенная функция dir() возвращает список имён, определяемых объектом. Например, для модуля в этот список входят функции, классы и переменные, определённые в этом модуле.
Эта функция может принимать аргументы. Если в качестве аргумента указано имя модуля, она возвращает список имён, определённых в этом модуле. Если никакого аргумента не передавать, она вернёт список имён, определённых в текущем модуле.
Пример:
$ python3 >>> import sys # получим список атрибутов модуля 'sys' >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__s tderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_compact_freelists', '_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', ' byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle' , 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfil esystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize', 'maxunicode ', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platfor m', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit ', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_in fo', 'warnoptions', 'winver'] >>> dir() # получим список атрибутов текущего модуля ['__builtins__', '__doc__', '__name__', '__package__', 'sys'] >>> a = 5 # создадим новую переменную 'a' >>> dir() ['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys'] >>> del a # удалим имя 'a' >>> dir() ['__builtins__', '__doc__', '__name__', '__package__', 'sys'] >>>
Как это работает:
Сперва мы видим результат применения dir к импортированному модулю sys . Видим огромный список атрибутов, содержащихся в нём.
Затем мы вызываем функцию dir , не передавая ей параметров. По умолчанию, она возвращает список атрибутов текущего модуля. Обратите внимание, что список импортированных модулей также входит туда.
Чтобы пронаблюдать за действием dir , мы определяем новую переменную a и присваиваем ей значение, а затем снова вызываем dir . Видим, что в полученном списке появилось дополнительное значение. Удалим переменную/атрибут из текущего модуля при помощи оператора del , и изменения вновь отобразятся на выводе функции dir .
Замечание по поводу del : этот оператор используется для удаления переменной/имени, и после его выполнения, в данном случае — del a , к переменной a больше невозможно обратиться — её как будто никогда и не было.
Обратите внимание, что функция dir() работает для любого объекта. Например, выполните " dir('print') ", чтобы увидеть атрибуты функции print , или " dir(str) ", чтобы увидеть атрибуты класса str .
Пакеты¶
К настоящему времени вы, вероятно, начали наблюдать некоторую иерархию в организации ваших программ. Переменные обычно находятся в функциях. Функции и глобальные переменные обычно находятся в модулях. А что, если возникнет необходимость как-то организовать модули? Вот здесь-то и выходят на сцену пакеты.
Пакеты — это просто каталоги с модулями и специальным файлом __init__.py , который показывает Python, что этот каталог особый, так как содержит модули Python.
Представим, что мы хотим создать пакет под названием "world" с субпакетами "asia", "africa" и т. д., которые, в свою очередь, будут содержать модули "india", "madagascar" и т. д.
Для этого следовало бы создать следующую структуру каталогов:
| - / | |---- world/ | |---- __init__.py | |---- asia/ | | |---- __init__.py | | |---- india/ | | |---- __init__.py | | |---- foo.py | |---- africa/ | |---- __init__.py | |---- madagascar/ | |---- __init__.py | |---- bar.py
Пакеты — это удобный способ иерархически организовать модули. Такое часто встречается в стандартной библиотеке.
Резюме¶
Точно так же, как функции являются многократно используемыми фрагментами программ, модули являются многократно используемыми программами. Пакеты — это способ иерархической организации модулей. Стандартная библиотека Python является примером такого набора пакетов и модулей.
Мы увидели, как пользоваться этими модулями и создавать свои.
Далее мы познакомимся с некоторыми интересными концепциями, называемыми "структуры данных".
- Инициализация — ряд действий, производимых при начальной загрузке (прим. перев.) ↩
- IDE — от англ. "Integrated Development Environment" -- "интегрированная среда разработки" (прим. перев.) ↩
- "we are arguments" — англ. "мы аргументы" (прим. перев.) ↩
- Программу на интерпретируемом языке программирования также называют сценарием или скриптом (прим. перев.) ↩
- name - англ. "имя" (прим. перев.) ↩