Как загрузить модуль в python

Запускаемые модули и пакеты — Python: Настройка окружения

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

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

Смоделируем описанную выше ситуацию. Так будет выглядеть исходный скрипт:

# file def greet(who): print(f'Hello, who>!') greet('Bob') greet('Ann') 

Теперь посмотрим на новый скрипт, в котором мы хотим переиспользовать функцию greet из первого скрипта:

# file from first_script import greet greet('Thomas') 

Запустим первый скрипт, а затем — второй. Оба файла расположены в текущей директории:

При выполнении второго скрипта выполнился и первый, хотя мы всего лишь импортировали из него одну функцию — такова цена за простоту написания скриптов.

Файл первого скрипта содержит определения и непосредственные действия, поэтому при загрузке файла при импорте модуля эти действия будут выполнены.

Теперь представьте, что мы бы импортировали скрипт, в котором не просто что-то печатается на экран, а удаляются какие-то файлы.

Выходит, нам нужно как-то различать ситуации двух типов:

1. Модуль работает как скрипт — выполняем побочные действия
2. Модуль или его содержимое импортируются — не выполняем побочные действия

Специальная переменная __name__

Рассмотрим механизм импорта при загрузке модуля в первый раз — а именно первый для текущего запуска интерпретатора.

Во время первой загрузки интерпретатор добавляет в модуль несколько переменных специального вида. Этих переменных довольно много, но нам пока интересна одна — переменная __name__ .

Кажется, что у переменной необычное имя — в нем целых четыре символа подчеркивания. На самом деле такие имена часто встречаются в Python-коде и как правило имеют какой-то специальный смысл. Опытный разработчик обычно помнит наизусть пару десятков таких переменных, поэтому про эти переменные любят спрашивать на собеседованиях.

Посмотрим, что хранит переменная __name__ в каждом конкретном случае:

• Если происходит обычный импорт, то эта переменная содержит полное имя модуля
• Если происходит запуск в качестве скрипта, то переменная получает специальное значение — строку ‘__main__’

Глядя на значение этой переменной, мы можем отличать запуск в качестве скрипта от импортирования.

Слово main используется во многих языках для именования функции, которая вызывается автоматически при старте программы. Потому и в Python это слово используется в похожем смысле.

Давайте вернемся к нашему примеру и перепишем first_script.py с применением этого нового знания:

# file def greet(who): print(f'Hello, who>!') if __name__ == '__main__': greet('Bob') greet('Ann') 

Теперь наш скрипт не будет приветствовать Боба и Энн, если мы будем импортировать модуль.

Функция main

Наш скрипт first_script.py уже достаточно хорош, но можно немного его улучшить.

В теле условия if __name__… перечислен набор действий, которые выполняются при запуске скрипта. Со временем таких действий может стать достаточно много.

Нередко происходят ситуации, когда нужно переиспользовать этот кусок кода. Поэтому существует соглашение: в теле условия if __name__… делают всего один вызов функции main без аргументов. Эту функцию объявляют выше в этом же модуле. При этом само условие принято располагать в самом конце модуля скрипта.

С учетом всех описанных рекомендаций финальная версия скрипта first_script.py будет выглядеть так:

#!/usr/bin/env python3 def greet(who): print(f'Hello, who>!') def main(): greet('Bob') greet('Ann') if __name__ == '__main__': main() 

Такой скрипт можно:

• Запускать непосредственно
• Запускать из других скриптов, вызывая функцию main
• Использовать как библиотеку

Запускаемые пакеты

Рассмотрим немного необычный, но все же встречающийся случай — запуск пакета.

Может показаться, что раз при загрузке пакета всегда загружается модуль __init__.py , то функцию main и условие нужно располагать в нем.

Но запуск пакетов реализован несколько иначе: при загрузке пакета интерпретатор ищет __main__.py и выполняет его как скрипт. Здесь мы не будем углубляться в причины — просто запомним, что исполняемые пакеты всегда содержат скрипт __main__.py .

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях:

Установка модулей в Python

Когда вы в первый раз начинаете работу в качестве программиста в Python, вы, скорее всего, не задумываетесь о том, как именно вам нужно установить внешний пакет или модуль. Но когда эта нужда возникает, вам захочется сделать это как можно быстрее! Пакеты Python можно легко найти в интернете. Большая часть популярных пакетов может быть найдена в PyPI (Python Package Index). Также множество пакетов Python можно найти на github, и bitbucket, а также в Google Code. В данной статье мы рассмотрим следующие методы установки пакетов Python:

• Установка из источника
• easy_install
• pip
• Другие способы

Модули

Модуль в языке 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 3

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

• print() – для вывода данных;
• abs() – для возвращения абсолютного значения числа;
• int() – для преобразования другого типа данных в целое число;
• len() – возвращает длину последовательности либо коллекции.

Модули необходимо использовать, по причине ограниченных функций. Мы подключаем внешние модули и тем самым получаем больше функций.
Модули в Python имеют расширение в конце файла в виде “.py”. Можно ссылаться на функции, классы или переменные в других модулях, с помощью командной строки Python.

Когда мы импортируем модуль test, интерпретатор ищет встроенный модуль. Если не находит, то ищет файл test.py в директории, которую получает из переменной sys.path.
В этой инструкции будут рассмотрены проверка, установка, импорт и изменение длинных названий модулей с функциями. Работать будем на популярном среди клиентов сервере на базе ОС Ubuntu.

Подготовка к импорту

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

Проверка для установки модулей

После установки обновления Python, получаем доступ к ряду модулей. Модули установлены вместе с Python и стандартной библиотекой для минимизированных задач.
Чтобы протестировать Python в командной строке введите:

Откроется командный интерпретатор и после “>>>” сможете выполнять разные функции.
Для проверки активируем виртуальную среду с помощью:

source /testing/testingv/bin/activate
python3

Перед именем появится префикс (testingv), как показано и войдём в командный интерпретатор Python, как показано на рисунке 1.

Импортируем два модуля “math” и “matplotlib”. Math – является встроенным модулем для математических вычислений и команда должна выполнится без ошибки. Matplotlib – библиотека для работы с 2D-графикой, результаты можем посмотреть на рисунке 2.

Выйдем из командного интерпретатора и с помощью pip3 (командный интерпретатор для установки библиотек), установим matplotlib.

exit() – выход из командного интерпретатору;
pip3 install matplotlib

Результат приведён на рисунке 3.

Заново попробуем заново импортировать модули и получаем успешный результат, как показано на рисунке 4.

import math
import matplotlib

Считаем первый шаг выполнен. Смогли установить модуль с использованием pip3 и успешно выполнили импорт.

Импортирование модулей

Выполним выход из командного интерпретатора и создадим файл testing_random.py. Строка с импортированием модулей вставляем в самой верхней части кода или же под шебангом. Шебанг – это #!/usr/bin/env python3 – выполнить файл как программу на Python, используя среду для получения пути к файлу интерпретатора. Импортируем библиотеку random для генерации случайных чисел.

#!/usr/bin/env python3
import random

С импортированием модулей открывается доступ к его функциям. Перед выполнением функции для начала указывается название модуля, ставится точка и указываем название функции. Рассмотрим пример генерации случайных чисел 7 раз от 5 до 15, с использованием функции randint, как показано в следующих строках кода.

import random
print(«Результат:»)
for i in range(7):
print(random.randint(5, 15))

Запустим файл с помощью “python3 testing_random.py”. При выходе получаем 7 столбцов с разными сгенерированными значениями. Например, в нашем случае это следующие данные:

Результат:
6
14
14
12
12
12
12

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

import random
import math

Подредактируем код, при получении результата укажем 7 столбцов сгенерированных данных от 5 до 15, и добавим вывод число Пи.

import random
import math
print(«Результат:»)
for i in range(7):
print(random.randint(5,15))
print(math.pi)

При выполнении данного кода получим следующие данные:

Результат:
9
13
12
15
7
14
13
3.141592653589793

Также с помощью import есть возможность импортировать сразу несколько модулей.

Использование from … import

Оператор from полезен тем, что нам не обязательно указывать название модуля перед использованием функции. Данный процесс упрощает скорость написания кода. В начале указываем какую функцию импортируем из модуля и пишем код. Рассмотрим упрощенный вариант нашего предыдущего кода и результат показан на рисунке 5:

from math import pi
from random import randint
print(«Результат»)
for i in range(7):
print(randint(5,15))
print(pi)

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

Изменение названия модуля и функций

В Python вполне можно заменить название модуля на более короткое название с помощью “as” в начале кода. Данным случаем необходимо воспользоваться, если название модуля уже существует в коде. Также можно заменить модуль с длинным названием, которым мы пользуемся чаще. Пример рассмотрен в следующей строке кода:

import math as m
print(m.pi)
print(m.e)

Результат приведён на рисунке 6.

Вывод чисел констант Пи и Экспонента.
Также с помощью “as” можно скоротать название matplotlib.pyplot, например на pyplt. Можно ознакомиться в официальном руководстве по использованию модуля matplotlib.

Выводы

В инструкции рассмотрели такие возможности, как:

• Импорт модуля;
• Использование функции с использованием названия добавленного модуля;
• Импортирование функции из модуля;
• Использование функции без названия модуля;
• Изменение названия модуля.