Python: Модули
Для создания модуля нужно создать файл с расширением py, содержащий функции и переменные. Другой способ – написать модуль на другом языке программирования, например, можно писать модули на языке C, которые после компиляции могут использоваться стандартным интерпретатором Python.
Модуль можно импортировать в другую программу, чтобы использовать функции из него. Посмотрим, как использовать модули стандартной библиотеки Python.
import sys print('Аргументы командной строки:') for i in sys.argv: print(i) print('\n\nПеременная PYTHONPATH содержит', sys.path, '\n')
В начале мы импортируем модуль sys командой import. Этим мы говорим Python, что хотим использовать этот модуль. Модуль sys содержит функции, относящиеся к интерпретатору Python и его среде, т.е. к системе (system).
Когда Python выполняет команду import sys, он ищет модуль sys. В данном случае это один из встроенных модулей, и Python знает, где его искать.
Если бы это был не скомпилированный модуль, т.е. модуль, написанный на Python, тогда интерпретатор Python искал бы его в каталогах, перечисленных в переменной sys.path. Если модуль найден, выполняются команды в теле модуля, и он становится доступным. Обратите внимание, что инициализация происходит только при первом импорте модуля.
Доступ к переменной argv в модуле sys предоставляется при помощи точки, т.е. sys.argv. Это явно показывает, что это имя является частью модуля sys. Ещё одним преимуществом такого обозначения является то, что имя не конфликтует с именем переменной argv, которая может использоваться в вашей программе.
Переменная sys.argv является списком строк. Она содержит список аргументов командной строки, т.е. аргументов, переданных программе из командной строки.
sys.path содержит список имён каталогов, откуда импортируются модули. Модули, расположенные в текущем каталоге, можно импортировать напрямую. В противном случае придётся поместить свой модуль в один из каталогов, перечисленных в sys.path.
Помните, что текущий каталог – это каталог, в котором была запущена программа. Чтобы узнать текущий каталог программы, выполните сценарий.
import os print(os.getcwd())
Одной инструкцией можно подключить несколько модулей, хотя так не рекомендуется делать.
import time, random
Если не удастся найти модуль для импортирования, то возбудится исключение ImportError. Если не будет найден указанный атрибут модуля, то возбудится исключение AttributeError.
Если название модуля слишком длинное, или оно вам не нравится по каким-то другим причинам, то для него можно создать псевдоним, с помощью ключевого слова as.
import math as cat print(cat.floor(4.7))
from
Для импорта всех имён, использующихся в модуле, можно выполнить команду from:
from sys import *
Следует заметить, что не все атрибуты будут импортированы. Если в модуле определена переменная __all__ (список атрибутов, которые могут быть подключены), то будут подключены только атрибуты из этого списка. Если переменная __all__ не определена, то будут подключены все атрибуты, не начинающиеся с нижнего подчёркивания. Кроме того, необходимо учитывать, что импортирование всех атрибутов из модуля может нарушить пространство имён главной программы, так как переменные, имеющие одинаковые имена, будут перезаписаны.
Можно указывать отдельные переменные из модуля.
from sys import argv
У каждого модуля есть имя, и команды в модуле могут узнать имя их модуля. Это полезно, когда нужно знать, запущен ли модуль как самостоятельная программа или импортирован. Когда модуль импортируется впервые, содержащийся в нём код исполняется. Мы можем воспользоваться этим для того, чтобы заставить модуль вести себя по-разному в зависимости от того, используется ли он сам по себе или импортируется в другую программу. Этого можно достичь с применением атрибута модуля под названием __name__.
if __name__ == '__main__': print('Эта программа запущена сама по себе.') else: print('Меня импортировали в другой модуль.')
Создание собственного модуля
Создать собственный модуль очень легко. Каждая программа на Python также является и модулем. Необходимо лишь убедиться, что у неё установлено расширение py. Создадим файл mymodule.py.
def sayhi(): print('Привет! Это говорит мой модуль.') __version__ = '0.1'
Как использовать созданный модуль в других программах? Помните, что модуль должен находиться либо в том же каталоге, что и программа, в которую мы импортируем его, либо в одном из каталогов, указанных в sys.path.
Создадим новый файл и импортируем наш модуль.
import mymodule mymodule.sayhi() print('Version', mymodule.__version__)
Другой способ импортирования.
from mymodule import sayhi, __version__ sayhi() print('Version', __version__)
Обратите внимание, что если в модуле, импортирующем данный модуль, уже было объявлено имя __version__, возникнет конфликт. Поэтому всегда рекомендуется отдавать предпочтение оператору import, хотя это и сделает программу немного длиннее.
Вариант со звёздочкой имеет свои особенности — это импортирует все публичные имена, такие как sayhi, но не импортирует __version__, потому что оно начинается с двойного подчёркивания.
from mymodule import *
Встроенная функция dir() поможет узнать список имён, определяемых объектом. Например, можно получить список функций, классов и переменных, входящих в модуль. Функция может принимать аргументы. Если в качестве аргумента указано имя модуля, она возвращает список имён, определённых в этом модуле. Если никакого аргумента не передавать, она вернёт список имён, определённых в текущем модуле.
Функция dir() применима к функциям и классам. Выполните dir(‘print’), чтобы увидеть атрибуты функции print, или dir(str), чтобы увидеть атрибуты класса str.
Пакеты
Модули можно сгруппировать в пакеты. Пакеты – это просто каталоги с модулями и специальным файлом __init__.py, который указывает, что этот каталог особый, так как содержит модули.
Импорт модуля – относительно дорогостоящее мероприятие, поэтому Python предпринимает некоторые шаги для ускорения этого процесса. Один из способов – создать байткод с расширением pyc, которые являются некой промежуточной формой, в которую Python переводит программу. Такой файл полезен при импорте модуля в следующий раз в другую программу – это произойдёт намного быстрее, поскольку значительная часть обработки, требуемой при импорте модуля, будет уже проделана. Этот байткод также является платформонезависимым. Обычно файлы pyc создаются в том же каталоге, где расположены и соответствующие им файлы py. Если Python не может получить доступ для записи файлов в этот каталог, файлы pyc созданы не будут.
Как найти местоположение модуля Python?
Скрипт на Python использует некий модуль. С помощью какой команды можно найти его местоположение на диске машины?
Отслеживать
9,356 4 4 золотых знака 40 40 серебряных знаков 56 56 бронзовых знаков
задан 23 апр 2017 в 10:11
369 1 1 золотой знак 7 7 серебряных знаков 17 17 бронзовых знаков
find . -name «нейкий модуль»
23 апр 2017 в 10:23
2 ответа 2
Сортировка: Сброс на вариант по умолчанию
import some_module import sys import os for path in sys.path: if os.path.exists(os.path.join(path, 'some_module')): print('some_module is here: <>'.format(path)) «Трюк» здесь заключается в том, что где бы интерпретатор не встретил строку
from somewhere import something он ищет somewhere в sys.path . И если не находит — выбрасывается исключение ImportError . При этом при запуске интерпретатора, текущий путь (или при запуске скрипта python path/to/script.py путь path/to ) добавляется в sys.path .
2-й вариант (попроще):
import some_module print(some_module.__file__) >>> import openpyxl >>> print (openpyxl.__file__) D:\Python\lib\site-packages\openpyxl-2.3.0_b1-py2.7.egg\openpyxl\__init__.pyc >>> Но 2-й вариант можно «обмануть», явно определив в модуле переменную __file__
Модули
Модуль в языке Python представляет отдельный файл с кодом, который можно повторно использовать в других программах.
Для создания модуля необходимо создать собственно файл с расширением *.py , который будет представлять модуль. Название файла будет представлять название модуля. Затем в этом файле надо определить одну или несколько функций.
Допустим, основной файл программы называется main.py . И мы хотим подключить к нему внешние модули.
Для этого сначала определим новый модуль: создадим в той же папке, где находится main.py, новый файл, который назовем message.py . По умолчанию интерпретатор Python ищет модули по ряду стандартных путей, один из которых — это папка главного, запускаемого скрипта. Поэтому, чтобы интерпретатор подхватил модуль message.py, для простоты оба файла поместим в один проект.
Соответственно модуль будет называться message . Определим в нем следующий код:
hello = "Hello all" def print_message(text): print(f"Message: ")
Здесь определена переменная hello и функция print_message, которая в качестве параметра получает некоторый текст и выводит его на консоль.
В основном файле программы — main.py используем данный модуль:
import message # подключаем модуль message # выводим значение переменной hello print(message.hello) # Hello all # обращаемся к функии print_message message.print_message("Hello work") # Message: Hello work
Для использования модуля его надо импортировать с помощью оператора import , после которого указывается имя модуля: import message .
Чтобы обращаться к функциональности модуля, нам нужно получить его пространство имен . По умолчанию оно будет совпадать с именем модуля, то есть в нашем случае также будет называться message .
Получив пространство имен модуля, мы сможем обратиться к его функциям по схеме
Например, обращение к функции print_message() из модуля message:
message.print_message("Hello work")
И после этого мы можем запустить главный скрипт main.py, и он задействует модуль message.py. В частности, консольный вывод будет следующим:
Hello all Message: Hello work
Подключение функциональности модуля в глобальное пространство имен
Другой вариант настройки предполагает импорт функциональности модуля в глобальное пространство имен текущего модуля с помощью ключевого слова from :
from message import print_message # обращаемся к функии print_message из модуля message print_message("Hello work") # Message: Hello work # переменная hello из модуля message не доступна, так как она не импортирована # print(message.hello) # print(hello)
В данном случае мы импортируем из модуля message в глобальное пространство имен функцию print_message() . Поэтому мы сможем ее использовать без указания пространства имен модуля как если бы она была определена в этом же файле.
Все остальные функции, переменные из модуля недоступны (как например, в примере выше переменная hello). Если мы хотим их также использовать, то их можно подключить по отдельности:
from message import print_message from message import hello # обращаемся к функции print_message из модуля message print_message("Hello work") # Message: Hello work # обращаемся к переменной hello из модуля message print(hello) # Hello all
Если необходимо импортировать в глобальное пространство имен весь функционал, то вместо названий отдельных функций и переменных можно использовать символ зводочки * :
from message import * # обращаемся к функции print_message из модуля message print_message("Hello work") # Message: Hello work # обращаемся к переменной hello из модуля message print(hello) # Hello all
Но стоит отметить, что импорт в глобальное пространство имен чреват коллизиями имен функций. Например, если у нас том же файле определена функция с тем же именем до ее вызова, то будет вызываться функция, которая определена последней:
from message import * print_message("Hello work") # Message: Hello work - применяется функция из модуля message def print_message(some_text): print(f"Text: ") print_message("Hello work") # Text: Hello work - применяется функция из текущего файла
Таким образом, одноименная функция текущего файла скрывает функцию из подключенного модуля.
Установка псевдонимов
При импорте модуля и его функциональности мы можем установить для них псевдонимы. Для этого применяется ключевое слово as , после которого указывается псевдоним. Например, установим псевдоним для модуля:
import message as mes # модуль message проецируется на псевдоним mes # выводим значение переменной hello print(mes.hello) # Hello all # обращаемся к функии print_message mes.print_message("Hello work") # Message: Hello work
В данном случае пространство имен будет называться mes , и через этот псевдоним можно обращаться к функциональности модуля.
Подобным образом можно установить псевдонимы для отдельной функциональности модуля:
from message import print_message as display from message import hello as welcome print(welcome) # Hello all - переменная hello из модуля message display("Hello work") # Message: Hello work - функция print_message из модуля message
Здесь для функции print_message из модуля message устанавливается псевдоним display, а для переменной hello — псевдоним welcome. И через эти псевдонимы мы сможем к ним обращаться.
Псевдонимы могут быть полезны, когда нас не устраивают имена функций и переменных, например, они слишком длинные, и мы хотим их сократить, либо мы хотим дать им более описательные, с нашей точки зрения, имена. Либо если в текущем файле уже есть функциональность с теми же именами, и с помощью установки псевдонимов мы можем избежать конфликта имен. Например:
from message import print_message as display def print_message(some_text): print(f"Text: ") # функция print_message из модуля message display("Hello work") # Message: Hello work # функция print_message из текущего файла print_message("Hello work") # Text: Hello work
Имя модуля
В примере выше модуль main.py, который является главным, использует модуль message.py. При запуске модуля main.py программа выполнит всю необходимую работу. Однако, если мы запустим отдельно модуль message.py сам по себе, то ничего на консоли не увидим. Ведь модуль message просто определяет функцию и переменную и не выполняет никаких других действий. Но мы можем сделать так, чтобы модуль message.py мог использоваться как сам по себе, так и подключаться в другие модули.
При выполнении модуля среда определяет его имя и присваивает его глобальной переменной __name__ (с обеих сторон по два подчеркивания). Если модуль является запускаемым, то его имя равно __main__ (также по два подчеркивания с каждой стороны). Если модуль используется в другом модуле, то в момент выполнения его имя аналогично названию файла без расширения py. И мы можем это использовать. Так, изменим содержимое файла message.py :
hello = "Hello all" def print_message(text): print(f"Message: ") def main(): print_message(hello) if __name__ == "__main__": main()
В данном случае в модуль message.py для тестирования функциональности модуля добавлена функция main . И мы можем сразу запустить файл message.py отдельно от всех и протестировать код.
Следует обратить внимание на вызов функции main:
if __name__ == "__main__": main()
Переменная __name__ указывает на имя модуля. Для главного модуля, который непосредственно запускается, эта переменная всегда будет иметь значение __main__ вне зависимости от имени файла.
Поэтому, если мы будем запускать скрипт message.py отдельно, сам по себе, то Python присвоит переменной __name__ значение __main__ , далее в выражении if вызовет функцию main из этого же файла.
Однако если мы будем запускать другой скрипт, а этот — message.py — будем подключать в качестве вспомогательного, для message.py переменная __name__ будет иметь значение message . И соответственно метод main в файле message.py не будет работать.
Данный подход с проверкой имени модуля является более рекомендуемым подходом, чем просто вызов метода main.
В файле main.py также можно сделать проверку на то, является ли модуль главным (хотя в прицнипе это необязательно):
import message def main(): message.print_message("Hello work") # Message: Hello work if __name__ == "__main__": main()
Python предоставляет ряд встроенных модулей, которые мы можем использовать в своих программах. В следующих статьях рассмотрим основные из них.
Где хранятся модули в Python?
Система модулей даёт возможность логически организовать код на 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 вышеописанных места поиска.
Получаем список всех модулей Python
Чтобы получить полный список модулей, установленных на ПК, используют команду help("modules") .
Создаём свой модуль в 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)
Пакеты модулей в 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 в пакет модулей уже не обязательно, но мы рекомендуем всё же делать это, чтобы обеспечить обратную совместимость.
