Как посмотреть содержимое библиотеки python
Перейти к содержимому

Как посмотреть содержимое библиотеки python

  • автор:

Модули и их импорт в Python

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

Чтобы разрешить проблему доступа к дополнительным возможностям языка, в программировании стало общепринятой практикой использовать так называемые модули, пакеты и библиотеки. Каждый модуль содержит коллекцию функций и классов, предназначенных для решения задач из определенной области. Так в модуле math языка Python содержатся математические функции, модуль random позволяет генерировать псевдослучайные числа, в модуле datetime содержатся классы для работы с датами и временем, модуль sys предоставляет доступ к системным переменным и т. д.

Количество модулей для языка Python огромно, что связано с популярностью языка. Часть модулей собрана в так называемую стандартную библиотеку. Стандартная она потому, что поставляется вместе с установочным пакетом. Однако существуют сторонние библиотеки. Они скачиваются и устанавливаются отдельно.

Для доступа к функционалу модуля, его надо импортировать в программу. После импорта интерпретатор «знает» о существовании дополнительных классов и функций и позволяет ими пользоваться.

В Питоне импорт осуществляется командой import . При этом существует несколько способов импорта. Рассмотрим работу с модулем на примере math . Итак,

>>> import math 

Ничего не произошло. Однако в глобальной области видимости появилось имя math . Если до импорта вы упомянули бы имя math , то возникла бы ошибка NameError . Теперь же

>>> math

В программе завелся объект math , относящийся к классу module .

Чтобы увидеть перечень функций, входящих в этот модуль, воспользуемся встроенной в Python функцией dir() , передав ей в качестве аргумента имя модуля:

>>> dir(math) ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp'] 

Проигнорируем имена с двойными подчеркиваниями. Все остальное – имена функций и констант (переменных, которые не меняют своих значений), включенных в модуль math. Чтобы вызвать функцию из модуля, надо впереди написать имя модуля, поставить точку, далее указать имя функции, после чего в скобках передать аргументы, если они требуются. Например, чтобы вызвать функцию pow из math, надо написать так:

>>> math.pow(2, 2) 4.0 

Обратите внимание, эта другая функция pow() , не та, что встроена в сам язык. «Обычная» функция pow() возвращает целое, если аргументы целые числа:

>>> pow(2, 2) 4 

Для обращения к константе скобки не нужны:

>>> math.pi 3.141592653589793 

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

>>> help(math.gcd) Help on built-in function gcd in module math: gcd(*integers) Greatest Common Divisor. (END) 

Для выхода из интерактивной справки надо нажать клавишу q . В данном случае сообщается, что функция вычисляет наибольший общий делитель. Описание модулей и их содержания также можно посмотреть в официальной документации на сайте python.org.

Второй способ импорта – это когда импортируется не сам модуль, а только необходимые функции из него.

>>> from math import gcd, sqrt, hypot 

Перевести можно как «из модуля math импортировать функции gcd , sqrt и hypot «.

В таком случае при их вызове не надо перед именем функции указывать имя модуля:

>>> gcd(100, 150) 50 >>> sqrt(16) 4.0 >>> hypot(3, 4) 5.0 

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

>>> from math import * 

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

>>> pi = 3.14 >>> from math import pi >>> pi 3.141592653589793 

Здесь исчезает значение 3.14, присвоенное переменной pi . Это имя теперь указывает на число из модуля math . Если импорт сделать раньше, чем присвоение значения pi , то будет все наоборот:

>>> from math import pi >>> pi = 3.14 >>> pi 3.14 

В связи с этим более опасен именно импорт всех функций. Так как в этом случае очень легко не заметить подмены значений идентификаторов.

Однако можно изменить имя идентификатора из модуля на какое угодно:

>>> from math import pi as P >>> P 3.141592653589793 >>> pi 3.14 

В данном случае константа pi из модуля импортируется под именем P . Другой смысл подобных импортов – сокращение имен, так как есть модули с длинными именами, а имена функций и классов в них еще длиннее. Если в программу импортируется всего пара сущностей, и они используются в ней часто, то имеет смысл переименовать их на более короткий вариант. Сравните:

>>> import calendar >>> calendar.weekheader(2) 'Mo Tu We Th Fr Sa Su' 
>>> from calendar import weekheader as week >>> week(3) 'Mon Tue Wed Thu Fri Sat Sun' 

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

Практическая работа. Создание собственного модуля

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

from math import pi, pow def rectangle(a, b): return round(a * b, 2) def triangle(a, h): return round(0.5 * a * h, 2) def circle(r): return round(pi * pow(r, 2), 2) 

Здесь также иллюстрируется принцип, что один модуль может импортировать другие. В данном случае импортируются функции из модуля math .

Поместите данный код в отдельный файл square.py . Однако куда поместить сам файл?

Когда интерпретатор Питона встречает команду импорта, то просматривает на наличие файла-модуля определенные каталоги. Их перечень можно увидеть по содержимому sys.path :

>>> import sys >>> sys.path ['', '/usr/lib/python310.zip', '/usr/lib/python3.10', '/usr/lib/python3.10/lib-dynload', '/home/pl/.local/lib/python3.10/site-packages', '/usr/local/lib/python3.10/dist-packages', '/usr/lib/python3/dist-packages'] 

Это список адресов в Linux. В Windows он будет несколько другим. Первый элемент – пустая строка, что обозначает текущий каталог, т.е. место, где сохранена сама программа, импортирующая модуль. Если вы сохраните файл-модуль и файл-программу в одном каталоге, то интерпретатор без труда найдет модуль.

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

Можно добавить в sys.path свой каталог. Однако в этом случае либо код программы должен содержать команды изменения значения sys.path , либо надо править конфигурационный файл операционной системы. В большинстве случаев лучше так не делать.

Поместите файл square.py в тот же каталог, где будет исполняемая программа. Ее код должен включать инструкцию импорта модуля square (при импорте расширение файла не указывается) и вызов той функции и с теми аргументами, которые ввел пользователь. То есть у пользователя надо спросить, площадь какой фигуры он хочет вычислить. Далее запросить у него аргументы для соответствующей функции. Передать их в функцию из модуля square , а полученный оттуда результат вывести на экран.

Примечание. Исполнение модуля как самостоятельного скрипта, а также создание строк документации, которые отображает встроенная в Python функция help() , будут рассмотрены в курсе объектно-ориентированного программирования.

Примеры решения и дополнительные уроки в pdf-версии курса

X Скрыть Наверх

Python. Введение в программирование

Где найти описание подключаемых модулей в Python?

Как узнать, какие есть функции в подключаемых модулях Python, что они делают и как их используют в коде?

Отслеживать
user262779
задан 6 дек 2018 в 20:14
Магомед Азизов Магомед Азизов
31 1 1 серебряный знак 3 3 бронзовых знака

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Это можно сделать с помощью встроенной функции help , например, из интерактивной консоли. Для этого передайте ей как параметр имя модуля, о котором хотите узнать, в виде строки. Так вы можете получить описание стандартного или установленного модуля. Например:

>>> help('math') Help on built-in module math: NAME math DESCRIPTION This module is always available. It provides access to the mathematical functions defined by the C standard. FUNCTIONS acos(. ) acos(x) Return the arc cosine (measured in radians) of x. acosh(. ) acosh(x) Return the inverse hyperbolic cosine of x. asin(. ) asin(x) Return the arc sine (measured in radians) of x. asinh(. ) asinh(x) Return the inverse hyperbolic sine of x. atan(. ) atan(x) Return the arc tangent (measured in radians) of x. atan2(. ) atan2(y, x) Return the arc tangent (measured in radians) of y/x. Unlike atan(y/x), the signs of both x and y are considered. atanh(. ) atanh(x) Return the inverse hyperbolic tangent of x. ceil(. ) ceil(x) Return the ceiling of x as an Integral. This is the smallest integer >= x. copysign(. ) copysign(x, y) Return a float with the magnitude (absolute value) of x but the sign of y. On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0. cos(. ) cos(x) Return the cosine of x (measured in radians). cosh(. ) cosh(x) Return the hyperbolic cosine of x. degrees(. ) degrees(x) Convert angle x from radians to degrees. erf(. ) erf(x) Error function at x. erfc(. ) erfc(x) Complementary error function at x. exp(. ) exp(x) Return e raised to the power of x. expm1(. ) expm1(x) Return exp(x)-1. This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. fabs(. ) fabs(x) Return the absolute value of the float x. factorial(. ) factorial(x) -> Integral Find x!. Raise a ValueError if x is negative or non-integral. floor(. ) floor(x) Return the floor of x as an Integral. This is the largest integer int greatest common divisor of x and y hypot(. ) hypot(x, y) Return the Euclidean distance, sqrt(x*x + y*y). isclose(. ) isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) -> bool Determine whether two floating point numbers are close in value. rel_tol maximum difference for being considered "close", relative to the magnitude of the input values abs_tol maximum difference for being considered "close", regardless of the magnitude of the input values Return True if a is close in value to b, and False otherwise. For the values to be considered close, the difference between them must be smaller than at least one of the tolerances. -inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is not close to anything, even itself. inf and -inf are only close to themselves. isfinite(. ) isfinite(x) -> bool Return True if x is neither an infinity nor a NaN, and False otherwise. isinf(. ) isinf(x) -> bool Return True if x is a positive or negative infinity, and False otherwise. isnan(. ) isnan(x) -> bool Return True if x is a NaN (not a number), and False otherwise. ldexp(. ) ldexp(x, i) Return x * (2**i). lgamma(. ) lgamma(x) Natural logarithm of absolute value of Gamma function at x. log(. ) log(x[, base]) Return the logarithm of x to the given base. If the base not specified, returns the natural logarithm (base e) of x. log10(. ) log10(x) Return the base 10 logarithm of x. log1p(. ) log1p(x) Return the natural logarithm of 1+x (base e). The result is computed in a way which is accurate for x near zero. log2(. ) log2(x) Return the base 2 logarithm of x. modf(. ) modf(x) Return the fractional and integer parts of x. Both results carry the sign of x and are floats. pow(. ) pow(x, y) Return x**y (x to the power of y). radians(. ) radians(x) Convert angle x from degrees to radians. sin(. ) sin(x) Return the sine of x (measured in radians). sinh(. ) sinh(x) Return the hyperbolic sine of x. sqrt(. ) sqrt(x) Return the square root of x. tan(. ) tan(x) Return the tangent of x (measured in radians). tanh(. ) tanh(x) Return the hyperbolic tangent of x. trunc(. ) trunc(x:Real) -> Integral Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method. DATA e = 2.718281828459045 inf = inf nan = nan pi = 3.141592653589793 FILE (built-in) 

Также можно поискать документацию интересующего модуля в Интернете. Документацию стандартных модулей можно найти в официальной документации языка python, здесь. Информацию о сторонних модулях можно найти на PyPI. Например, вот документация модуля numpy.

Ликбез по пакетам и шпаргалка по модулям в Python

Ликбез по пакетам и шпаргалка по модулям в Python главное изображение

Как вы, возможно знаете, код на Python хранится в модулях (modules), которые могут быть объединены в пакеты (packages). Это руководство призвано подробно рассказать именно о пакетах, однако совсем не упомянуть модули нельзя, поэтому я немного расскажу и о них. Многое из того, что применимо к модулям, справедливо и для пакетов, особенно если принять во внимание тот факт, что каждый, как правило, ведёт себя как модуль.

Кратко о модулях

Модуль в Python — это файл с кодом. Во время же исполнения модуль представлен соответствующим объектом, атрибутами которого являются:

  1. Объявления, присутствующие в файле.
  2. Объекты, импортированные в этот модуль откуда-либо.

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

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

Модули и видимость содержимого

В Python нет настоящего сокрытия атрибутов объектов, поэтому и атрибуты объекта модуля так или иначе всегда доступны после импорта последнего. Однако существует ряд соглашений, которые влияют на процесс импортирования и поведение инструментов, работающих с кодом.

Так атрибуты, имя которых начинается с одиночного подчёркивания, считаются как бы помеченными «для внутреннего использования», и обычно не отображаются в IDE при обращению к объекту «через точку». И linter обычно предупреждает об использовании таких атрибутов, мол, «небезопасно!». «Опасность» состоит в том, что автор кода имеет полное право изменять состав таких атрибутов без уведомления пользователей кода. Поэтому программист, использовавший в своём коде приватные части чужого кода рискует в какой-то момент получить код, который перестанет работать при обновлении сторонней библиотеки.

Итак, мы можем определять публичные атрибуты модуля, приватные атрибуты (так называют упомянутые выше атрибуты «для внутреннего пользования»). И данное разделение касается не только определений, содержащихся в самом модуле, но и импортируемых сущностей. Ведь все импортированные объекты становятся атрибутами и того модуля, в который они импортированы.

Есть и третья группа атрибутов — атрибуты, добавляемые в область видимости при импортировании всего содержимого модуля («со звёздочкой», from module import * ). Если ничего явно не указывать, то при таком импортировании в текущую область видимости добавятся все публичные атрибуты модуля. Помимо данного умолчания существует и возможность явно указать, что конкретно будет экспортировано при импорте со звёздочкой. Для управления названным методом импорта существует атрибут __all__ , в который можно положить список (а ещё лучше — кортеж) строк с именами, которые будут экспортироваться.

Живой пример видимости атрибутов модулей.

Рассмотрим пример, демонстрирующий всё вышеописанное. Пусть у нас будет два файла:

# Файл "module.py" from other_module import CAT, DOG as _DOG, _GOAT FISH = 'fish' MEAT = 'meat' _CARROT = 'carrot' __all__ = ('FISH', '_CARROT') 
# Файл "other_module.py" CAT = 'cat' DOG = 'dog' _GOAT = 'goat' 

Рассмотрим сначала обычный импорт import module . Если импортировать модуль таким образом, то IDE, REPL и остальные инструменты «увидят» у модуля следующие атрибуты:

  • FISH , MEAT т.к. имена констант — публичные,
  • CAT , т.к. константа импортирована под публичным именем.

А эти атрибуты не будут видны:

  • _DOG , т.к. при импортировании константа переименована в приватной манере,
  • _GOAT , т.к. импортирована по своему приватному имени (тут линтер может и поругать за обращение к приватному атрибуту модуля!),
  • _CARROT , ибо приватная константа.

Импорт import other_module я не рассматриваю как тривиальный случай.

Теперь рассмотрим импорт всего содержимого module:

from module import * 

После импортирования в текущей области видимости мы получим ровно два новых имени: FISH и _CARROT — именно они перечислены в атрибуте __all__ . Заметьте, что в данном случае при массовом импорте добавится даже приватный атрибут, потому что он явно указан!

Последствия импорта from other_module import * тоже очевидны и я их не рассматриваю.

Наконец-то, пакеты!

Пакет в Python — директория с обязательным модулем __init__.py . Остальное содержимое опционально и может включать в себя и модули, и другие пакеты.

Импортирование пакетов

Пакет с единственным модулем __init__.py при импорте ведёт себя как обычный модуль. Содержимое инициализирующего модуля определяет атрибуты объекта пакета.

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

Рассмотрим, к примеру, следующую структуру директорий и файлов:

Когда мы импортируем модуль submodule.py , то фактически происходит следующее (именно в таком порядке):

  1. загружается и выполняется модуль package/__init__.py ,
  2. загружается и выполняется package/subpackage/__init__.py ,
  3. наконец, импортируется package/subpackage/submodule.py .

При импорте package.module предварительно загружается только package/__init__.py .

Так что же, если мы загрузим парочку вложенных модулей, то для каждого будет выполняться загрузка всех __init__.py по дороге? Не будет! Подсистема интерпретатора, отвечающая за загрузку модулей, кэширует уже загруженные пакеты и модули. Каждый конкретный модуль загружается ровно один раз, в том числе и инициализирующие модули __init__.py (короткие имена модулей хоть и одинаковы, но полные имена всегда разные). Все последующие импортирования модуля не приводят к его загрузке, только лишь нужные атрибуты копируются в соответствующие области видимости.

Пакеты и __all__

В целом атрибут __all__ в модуле инициализации пакета ведёт себя так же, как и в случае с обычным модулем. Но если при импорте пакета «со звёздочкой» среди перечисленных имён встретится имя вложенного модуля, а сам модуль не окажется импортирован ранее в этом же __init__.py , то этот модуль импортируется неявно! Очередной пример это продемонстрирует.

Вот структура пакета:

Файл же package/__init__.py содержит следующее (и только это!):

__all__ = ('a', 'b') 

А импортируем мы from package import * . В области видимости у нас окажутся объекты модулей a и b под своими именами (без полного пути, то есть без package. ). При этом сами модули в коде нигде явно не импортируются! Такая вот «автомагия».

Указанный автоматизм достаточно ограничен: не работает «вглубь», например — не импортирует «через звёздочку» указанные модули и подпакеты. Если же вам вдруг такого захочется, вы всегда сможете на соответствующих уровнях в __init__.py сделать from x import * и получить в корневом пакете плоскую область видимости со всем нужным содержимым. Но такое нужно довольно редко, потому что «не помогает» ни IDE, ни ручному поиску по коду. Впрочем, знать о фиче и иметь её в виду — не вредно, как мне кажется.

Изучайте Python на Хекслете Первые курсы в профессии Python-программист доступны бесплатно сразу после регистрации. Начните сегодня, учитесь в комфортном для вас темпе.

Пакеты, модули и точки входа

С модулем __init__.py разобрались. Настала очередь модуля __main__.py . Этот модуль позволяет сделать пакет исполняемым посредством вызова python -m … . Те из вас, кому знакомо оформление точки входа в модулях, могут догадаться, откуда ноги растут у магического выражения __name__ == ‘__main__’ — да, отсюда! Для остальных напоминаю: чтобы модуль сделать «исполняемым, но не при импорте», в конец модуля дописывается конструкция

if __name__ == '__main__': main() # тут что-то выполняем 

У модуля, который скармливается интерпретатору напрямую ( python file.py ) или в роли претендента на запуск ( python -m module ), атрибут __name__ будет содержать то самое магическое ‘__main__’ . А в остальное время атрибут содержит полное имя модуля. С помощью условия, показанного выше, модуль может решить, что делать при запуске.

У пакетов роль атрибута выполняет специальный файл __main__.py . Когда мы запустим пакет через python path/to/package или python -m package , интерпретатор будет искать и выполнять именно этот файл.

Более того, модули __main__ нельзя импортировать обычным способом, поэтому можно не бояться случайного импорта и писать команды прямо на верхнем уровне: всё равно странно в модуле с именем __main__ проверять, что его имя равно __main__ (хе-хе!).

А ещё модуль __main__.py удобен тем, что его можно класть в корень вашего проекта, после чего запускать проект можно будет с помощью команды python . ! Лаконично, не правда ли?

PEP 420, или неявные пространства имён

Раз уж развёл ликбез, расскажу и про эту штуку.

Долгое время в Python пакеты были обязаны иметь файл __init__.py — наличие этого файла позволяло отличить пакет от обычной директории с модулями (с которыми Python работать не мог). Но с версии Python3.3 вступил в силу PEP 420 , позволяющий создавать пространства имён «на вырост».

Теперь вы можете создавать пакет без __init__.py , и такой пакет сможет существовать полноценно, разве что при импорте содержимого не будет производиться инициализация. Но, конечно же, данное изменение делалось не с целью сэкономить на файлах. Подобные пакеты могут встречаться в путях поиска пакетов (о поиске пакетов я ниже расскажу) более одного раза: все встреченные структуры с общим корневым именем при загрузке схлопнутся в одно пространство имён.

Тут стоит отметить, что с полноценными пакетами подобное не срабатывало ранее и не будет работать в будущем. Если среди путей пакет с модулем инициализации находится в первый раз, все последующие пакеты с тем же именем будут проигнорированы. Это защищает вас от смешивания сторонних пакетов с системными. И даже просто от ошибок именования: назвав пакет так же, как называется встроенный пакет или модуль, вы получите ошибку — ваши определения не будут импортироваться.

Пакеты — пространства имён (Namespace Packages, NP) — а именно так называются пакеты без инициализации — не могут объединяться с полноценными пакетами, поэтому добавить что-то в системный пакет вам также не удастся. И тут всё защищено!

Какая же польза от неявных пространств имён? А вы представьте себя авторами, скажем, игрового движка. Вы хотите весь код держать в общем пространстве имён engine , но при этом не желаете, чтобы весь код поставлялся одним дистрибутивом (не каждому же пользователю нужны все-все компоненты движка). С NP вы можете в нескольких дистрибутивах использовать общее корневое имя engine , но разные подпакеты и подмодули. А на выходе вы получите возможность делать импорты вида

from engine import graphics, sound 

Важно: помните, если встретятся обычный пакет и NP с одинаковым именем, то победит обычный пакет! А NP, сколько бы их не было, не будут загружены!

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

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

Если же приспичивает, и импортировать что-то «ну очень нужно», то можно попробовать обойтись локальным импортом:

### foo.py import bar A = bar(42) 
### bar.py # import foo — тут не импортируем def bar(x): return x + 1 def baz(): import foo # а тут уже можно return foo.A 

Да, это костыль. Но иногда полезный. В идеале — до ближайшего большого рефакторинга. Поэтому настраивайте linter на ловлю локальных импортов и стремитесь убирать такие костыли хоть когда-нибудь!

Поиск пакетов и модулей

Пайтон ищет модули и пакеты в директориях, во время исполнения перечисленных в списке sys.path — по порядку от первого пути к последнему.

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

В списке путей (обычно в начале) присутствует и путь » , означающий текущую директорию. Это, в свою очередь, означает, что модули и пакет в текущем проекте имеют больший приоритет.

Обычно пути трогать не нужно, всё вполне нормально «работает само». Но если очень хочется, то путей у вас несколько:

  1. Использовать переменную окружения PYTHONPATH (значение — строка с путями, разделёнными символом : ),
  2. Во время исполнения изменить sys.path .

Первый способ — простой и понятный. Не сложнее добавления пути до исполняемых файлов в PATH (даже синтаксис тот же).

Второй способ — сложный и требующий внимательности. Дело в том, что sys.path нужно изменять максимально рано — где-нибудь в точке входа. Если не торопиться менять sys.path , то что-то уже может успеть загрузиться до того, как вы перестроите пути для поиска пакетов. А ведь эта загрузка может произойти в другом потоке исполнения! Отлаживать проблемы с очерёдностью загрузки модулей сложно. Лучше просто их не создавать.

Кстати, когда вы используете виртуальные окружения, sys.path будет содержать пути до локальных копий стандартных библиотек. Именно это позволяет виртуальному окружению быть самодостаточным (работать на любой машине с подходящей ОС — даже без установленного в систему Python!).

Что не было раскрыто?

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

  • создание модулей и пакетов на лету (без использования файлов исходников);
  • загрузку модулей не с диска, а из других источников;
  • расширение подсистемы импортирования с целью загрузки в виде объектов-модулей чего-то, не являющегося кодом вовсе (XML, CSV, JSON).

Темы эти насколько интересны, настолько и велики. На наше счастье, самим разбираться в такой тонкой и сложной машинерии приходится редко. Мы просто пользуемся готовыми магическими артефактами, а зачаровывают их другие 🙂 Если же вы захотите научиться магии, документация вам в руки.

Где хранятся модули в Python?

Python_Deep_6.11-5020-3e1392.png

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

Модуль в Python — это файл, в котором содержится код на Python. Любой модуль в Python может включать в себя переменные, объявления функций и классов. Вдобавок ко всемe, в модуле может содержаться исполняемый код.

Команда import в Python

Позволяет использовать любой файл Python в качестве модуля в другом файле. Синтаксис прост:

 
import module_1[, module_2[. module_N]

Как только Python-интерпретатор встречает команду import, он выполняет импорт модуля, если он есть в пути поиска Python. Что касается пути поиска Python, то речь идёт о списке директорий, в которых интерпретатор выполняет поиск перед загрузкой модуля. Посмотрите на пример кода при использовании модуля math:

 
import math # Используем функцию sqrt из модуля math print (math.sqrt(9)) # Печатаем значение переменной pi, определенной в math print (math.pi)

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

Команда from . import

Команда from . import даёт возможность выполнить импорт не всего модуля целиком, а лишь конкретного его содержимого:

 
# Импортируем из модуля math функцию sqrt from math import sqrt # Выводим результат выполнения функции sqrt. # Нам больше незачем указывать имя модуля print (sqrt(144)) # Но мы уже не можем получить из модуля то, что не импортировали print (pi) # Выдаст ошибку

Обратите внимание, что выражение from . import не импортирует модуль полностью, а лишь предоставляет доступ к объектам, указанным нами.

Команда from . import *

Также в Python мы можем импортировать из модуля переменные, классы и функции за один раз. Чтобы это выполнить, применяется конструкция from . import *:

 
from math import * # Теперь у нас есть доступ ко всем функция и переменным, определенным в модуле math print (sqrt(121)) print (pi) print (e)

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

Так где хранятся модули в Python?

При импорте модуля, интерпретатор Python пытается найти модуль в следующих местах: 1. Директория, где находится файл, в котором вызывается команда импорта. 2. Директория, определённая в консольной переменной PYTHONPATH (если модуль не найден с первого раза). 3. Путь, заданный по умолчанию (если модуль не найден в предыдущих двух случаях).

Что касается пути поиска, то он сохраняется в переменной path в системном модуле sys. А переменная sys.path включает в себя все 3 вышеописанных места поиска.

2-20219-5cca3e.png

Получаем список всех модулей Python

Чтобы получить полный список модулей, установленных на ПК, используют команду help("modules") .

3-20219-a2b765.png

Создаём свой модуль в Python

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

 
def hello(): print ("Hello from module_1")

А во втором вызовем функцию:

 
from module_1 import hello hello()

После выполнения кода 2-го файла получим:

 
Hello from module_1

Функция dir() в Python

Возвратит отсортированный список строк с содержанием всех имён, определенных в модуле.

 
# на данный момент нам доступны лишь встроенные функции dir() # импортируем модуль math import math # теперь модуль math в списке доступных имен dir() # получим имена, определенные в модуле math dir(math)

4-20219-710929.png

Пакеты модулей в Python

Несколько файлов-модулей с кодом можно объединить в пакеты модулей. Пакет модулей — это директория, включающая в себя несколько отдельных файлов-скриптов.

Представьте, что у нас следующая структура:

 
|_ my_file.py |_ my_package |_ __init__.py |_ inside_file.py

В файле inside_file.py определена некоторая функция foo. В итоге, дабы получить доступ к этой функции, в файле my_file нужно выполнить:

 
from my_package.inside_file import foo

Также нужно обратить внимание на то, есть ли внутри директории my_package файл init.py. Это может быть и пустой файл, сообщающий Python, что директория является пакетом модулей. В Python 3 включать файл init.py в пакет модулей уже не обязательно, но мы рекомендуем всё же делать это, чтобы обеспечить обратную совместимость.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *