Как импортировать файл в python

Обновлено: 03.07.2024

хотя это дает мне все определения в extra.py , когда возможно все, что я хочу, это единственное определение:

что добавить к import заявление, чтобы просто сделать gap С extra.py ?

обновление: ответ ниже устарел. Используйте более позднюю альтернативу выше.

просто import file без '.py ' extension.

вы можете пометить папку как пакет, добавив пустой файл с именем __init__.py .

можно использовать . Он принимает имя модуля в виде строки. (Опять же: имя модуля без '.py ' extension.)

тип help(__import__) для получения более подробной информации.

есть много способов импортировать файл python, все со своими плюсами и минусами.

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

Пример 1, импорт модуля python с python переводчик:

положите это в /home/el/foo/fox.py:

войдите в интерпретатор python:

вы импортировали fox через интерпретатор python, вызвали функцию python what_does_the_fox_say() изнутри fox.py.

Пример 2, Используйте execfile или ( exec в Python 3) в скрипте для выполнения другого файла python в место:

положите это в /home/el/foo2/mylib.py:

положите это в /home/el/foo2/main.py:

функции moobar был импортирован из mylib.py и main.py

Пример 3, Используйте from . импорт. функциональность:

поставить это в /home/el/foo3/chekov.py:

положите это в /home/el/foo3/main.py:

запустите его так:

если вы определили другие функции в chekov.py, они не будут доступны, если вы import *

Пример 4, импорт riaa.py если он находится в другом месте файла, откуда он импортируется

поставить это в /home/el/foo4/stuff/riaa.py:

положите это в /home/el/foo4/main.py:

это импортирует все во внешний файл из другого каталога.

Пример 5, Используйте os.system("python yourfile.py")

Пример 6, импортируйте файл через piggybacking Python startuphook:

поместите этот код в свой домашний каталог в

поместите этот код в свой main.py (может быть где угодно):

Пример 7, Большинство Robust: импорт файлов в python с помощью команды bare import:

создать новую папку /home/el/foo5/
создать новую папку /home/el/foo5/herp

создать пустой файл с именем __init__.py при герпесной:

создайте новый каталог / home/el/foo5/herp / derp

под derp, сделать другой :

под /главная/el/foo5/herp / derp сделать новый файл под названием yolo.py положите это туда:

момент истины, сделайте новый файл /home/el/foo5/main.py и там

пустой __init__.py файл сообщает интерпретатору python, что разработчик намеревается сделать этот каталог импортируемым пакетом.

бонус protip

для импорта определенного файла Python во время выполнения с известным именем:

у вас не так много сложных методов для импорта файла python из одной папки в другую. Просто создайте__init__.py файл для объявления этой папки является пакетом python, а затем перейдите в файл хоста, где вы хотите импортировать просто введите

from root.parent.folder.file import variable, class, whatever

на __init__.py файлы необходимы для того, чтобы Python рассматривал каталоги как содержащие пакеты, это делается для предотвращения непреднамеренного скрытия допустимых модулей, которые возникают позже в пути поиска модуля, каталогами с общим именем, например string.

__init__.py может быть просто пустой файл, но он также может выполнять код инициализации пакета или установить __all__ переменной.

вот два простых способа, которые я понял к настоящему времени, и убедитесь, что ваш "file.py" файл, который вы хотите импортировать как библиотеку, присутствует только в вашем текущем каталоге.

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

этой в должности Майк ворчливый является отличным объяснением __init__.py и его использование для создания, импорта и настройки пакетов python.

Как я импортирую, импортирует файл и использует стенографию его имени.

не забудьте ваш импорта файл ДОЛЖНО БЫТЬ С именем .py расширение

Я хотел бы добавить эту заметку, я не очень ясно в другом месте; внутри модуля / пакета, при загрузке из файлов, имя модуля / пакета должно быть с префиксом mymodule . Представьте mymodule быть макет, как это:

при загрузке somefile.py / otherstuff.py С __init__.py содержимое должно выглядеть так:

просто импортировать файл python в другой файл python

допустим, у меня есть helper.py python файл, который имеет функцию отображения, как,

сейчас app.py, Вы можете использовать функцию просмотра,

I'm working sundar gsv

Примечание: нет необходимости указывать .py расширение.

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

Порой бывает трудно правильно реализовать import с первого раза, особенно если мы хотим добиться правильной работы на плохо совместимых между собой версиях Python 2 и Python 3. Попытаемся разобраться, что из себя представляют импорты в Python и как написать решение, которое подойдёт под обе версии языка.

Содержание

Ключевые моменты

Выражения import производят поиск по списку путей в sys.path .
sys.path всегда включает в себя путь скрипта, запущенного из командной строки, и не зависит от текущей рабочей директории.
Импортирование пакета по сути равноценно импортированию __init__.py этого пакета.

Основные определения

Модуль: любой файл *.py . Имя модуля — имя этого файла.
Встроенный модуль: «модуль», который был написан на Си, скомпилирован и встроен в интерпретатор Python, и потому не имеет файла *.py .

Пакет: любая папка, которая содержит файл __init__.py . Имя пакета — имя папки.

С версии Python 3.3 любая папка (даже без __init__.py ) считается пакетом.

Пример структуры директорий

Обратите внимание, что в корневой папке test/ нет файла __init__.py .

Что делает import

При импорте модуля Python выполняет весь код в нём. При импорте пакета Python выполняет код в файле пакета __init__.py , если такой имеется. Все объекты, определённые в модуле или __init__.py , становятся доступны импортирующему.

Встроенные функции Python: какие нужно знать и на какие не стоит тратить время

Основы import и sys.path

Вот как оператор import производит поиск нужного модуля или пакета согласно документации Python:

директории, содержащей исходный скрипт (или текущей директории, если файл не указан);
директории по умолчанию, которая зависит от дистрибутива Python;
PYTHONPATH (список имён директорий; имеет синтаксис, аналогичный переменной окружения PATH ).

Технически документация не совсем полна. Интерпретатор будет искать не только файл (модуль) spam.py , но и папку (пакет) spam .

Обратите внимание, что Python сначала производит поиск среди встроенных модулей — тех, которые встроены непосредственно в интерпретатор. Список встроенных модулей зависит от дистрибутива Python, а найти этот список можно в sys.builtin_module_names (Python 2 и Python 3). Обычно в дистрибутивах есть модули sys (всегда включён в дистрибутив), math , itertools , time и прочие.

В отличие от встроенных модулей, которые при поиске проверяются первыми, остальные (не встроенные) модули стандартной библиотеки проверяются после директории запущенного скрипта. Это приводит к сбивающему с толку поведению: возможно «заменить» некоторые, но не все модули стандартной библиотеки. Допустим, модуль math является встроенным модулем, а random — нет. Таким образом, import math в start.py импортирует модуль из стандартной библиотеки, а не наш файл math.py из той же директории. В то же время, import random в start.py импортирует наш файл random.py .

Sportmaster Lab , Санкт-Петербург, Москва, Краснодар, можно удалённо , От 100 000 до 350 000 ₽

Кроме того, импорты в Python регистрозависимы: import Spam и import spam — разные вещи.

Функцию pkgutil.iter_modules() (Python 2 и Python 3) можно использовать, чтобы получить список всех модулей, которые можно импортировать из заданного пути:

Чуть подробнее о sys.path

Чтобы увидеть содержимое sys.path , запустите этот код:

Документация Python описывает sys.path так:

Список строк, указывающих пути для поиска модулей. Инициализируется из переменной окружения PYTHONPATH и директории по умолчанию, которая зависит от дистрибутива Python.

При запуске программы после инициализации первым элементом этого списка, path[0] , будет директория, содержащая скрипт, который был использован для вызова интерпретатора Python. Если директория скрипта недоступна (например, если интерпретатор был вызван в интерактивном режиме или скрипт считывается из стандартного ввода), то path[0] является пустой строкой. Из-за этого Python сначала ищет модули в текущей директории. Обратите внимание, что директория скрипта вставляется перед путями, взятыми из PYTHONPATH .

Источник: Python 2 и Python 3

Документация к интерфейсу командной строки Python добавляет информацию о запуске скриптов из командной строки. В частности, при запуске python <script>.py .

Если имя скрипта ссылается непосредственно на Python-файл, то директория, содержащая этот файл, добавляется в начало sys.path , а файл выполняется как модуль main .

Источник: Python 2 и Python 3

Итак, повторим порядок, согласно которому Python ищет импортируемые модули:

Модули стандартной библиотеки (например, math , os ).

Модули или пакеты, указанные в sys.path :

Если интерпретатор Python запущен в интерактивном режиме:
- sys.path[0] — пустая строка '' . Это значит, что Python будет искать в текущей рабочей директории, из которой вы запустили интерпретатор. В Unix-системах эту директорию можно узнать с помощью команды pwd .

Если мы запускаем скрипт командой python <script>.py :

Обратите внимание, что при запуске скрипта для sys.path важна не директория, в которой вы находитесь, а путь к самому скрипту. Например, если в командной строке мы находимся в test/folder и запускаем команду python ./packA/subA/subA1.py , то sys.path будет включать в себя test/packA/subA/ , но не test/ .

Кроме того, sys.path общий для всех импортируемых модулей. Допустим, мы вызвали python start.py . Пусть start.py импортирует packA.a1 , а a1.py выводит на экран sys.path . В таком случае sys.path будет включать test/ (путь к start.py ), но не test/packA (путь к a1.py ). Это значит, что a1.py может вызвать import other , так как other.py находится в test/ .

Всё о init.py

У файла __init__.py есть две функции:

Превратить папку со скриптами в импортируемый пакет модулей (до Python 3.3).
Выполнить код инициализации пакета.

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

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

Как было сказано ранее, любая директория, содержащая файл __init__.py , является пакетом. Например, при работе с Python 2.7 start.py может импортировать пакет packA , но не packB , так как в директории test/packB/ нет файла __init__.py .

Это не относится к Python 3.3 и выше благодаря появлению неявных пакетов пространств имён. Проще говоря, в Python 3.3+ все папки считаются пакетами, поэтому пустые файлы __init__.py больше не нужны.

Допустим, packB — пакет пространства имён, так как в нём нет __init__.py . Если запустить интерактивную оболочку Python 3.6 в директории test/ , то мы увидим следующее:

Выполнение кода инициализации пакета

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

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

Вывод после запуска python start.py :

Примечание Если a1.py вызовет import a2 , и мы запустим python a1.py , то test/packA/__init__.py не будет вызван, несмотря на то, что a2 вроде бы является частью пакета packA . Это связано с тем, что когда Python выполняет скрипт (в данном случае a1.py ), содержащая его папка не считается пакетом.

Использование объектов из импортированного модуля или пакета

Есть 4 разных вида импортов:

import <пакет>
import <модуль>
from <пакет> import <модуль или подпакет или объект>
from <модуль> import <объект>

Пусть X — имя того, что идёт после import :

Если X — имя модуля или пакета, то для того, чтобы использовать объекты, определённые в X , придётся писать X.объект .
Если X — имя переменной, то её можно использовать напрямую.
Если X — имя функции, то её можно вызвать с помощью X() .

Опционально после любого выражения import X можно добавить as Y . Это переименует X в Y в пределах скрипта. Учтите, что имя X с этого момента становится недействительным. Частым примером такой конструкции является import numpy as np .

Аргументом для import может быть как одно имя, так и их список. Каждое из имён можно переименовать с помощью as . Например, следующее выражение будет действительно в start.py : import packA as pA, packA.a1, packA.subA.sa1 as sa1 .

Пример: нужно в start.py импортировать функцию helloWorld() из sa1.py .

Решение 1: from packA.subA.sa1 import helloWorld . Мы можем вызвать функцию напрямую по имени: x = helloWorld() .
Решение 2: from packA.subA import sa1 или то же самое import packA.subA.sa1 as sa1 . Для использования функции нам нужно добавить перед её именем имя модуля: x = sa1.helloWorld() . Иногда такой подход предпочтительнее первого, так как становится ясно, из какого модуля взялась та или иная функция.
Решение 3: import packA.subA.sa1 . Для использования функции перед её именем нужно добавить полный путь: x = packA.subA.sa1.helloWorld() .

Прим. перев. После переименования с помощью as новое имя нельзя использовать в качестве имени пакета или модуля для последующих импортов. Иными словами, команда вроде следующей недействительна: import packA as pA, pA.a1 .

Используем dir() для исследования содержимого импортированного модуля

После импортирования модуля можно использовать функцию dir() для получения списка доступных в модуле имён. Допустим, мы импортируем sa1 . Если в sa1.py есть функция helloWorld() , то dir(sa1) будет включать helloWorld :

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

Импортирование пакета по сути равноценно импортированию его __init__.py . Вот как Python на самом деле видит пакет:

После импорта становятся доступны только те объекты, что определены в __init__.py пакета. Поскольку в packB нет такого файла, от import packB (в Python 3.3.+) будет мало толку, так как никакие объекты из этого пакета не становятся доступны. Последующий вызов модуля packB.b1 приведёт к ошибке, так как он ещё не был импортирован.

Абсолютный и относительный импорт

При абсолютном импорте используется полный путь (от начала корневой папки проекта) к желаемому модулю.

При относительном импорте используется относительный путь (начиная с пути текущего модуля) к желаемому модулю. Есть два типа относительных импортов:

При явном импорте используется формат from .<модуль/пакет> import X , где символы точки . показывают, на сколько директорий «вверх» нужно подняться. Одна точка . показывает текущую директорию, две точки .. — на одну директорию выше и т. д.
Неявный относительный импорт пишется так, как если бы текущая директория была частью sys.path . Такой тип импортов поддерживается только в Python 2.

В документации Python об относительных импортах в Python 3 написано следующее:

Единственный приемлемый синтаксис для относительных импортов — from .[модуль] import [имя] . Все импорты, которые начинаются не с точки . , считаются абсолютными.

Источник: What’s New in Python 3.0

В качестве примера допустим, что мы запускаем start.py , который импортирует a1 , который импортирует other , a2 и sa1 . Тогда импорты в a1.py будут выглядеть следующим образом:

Явные относительные импорты:

Неявные относительные импорты (не поддерживаются в Python 3):

Учтите, что в относительных импортах с помощью точек . можно дойти только до директории, содержащей запущенный из командной строки скрипт (не включительно). Таким образом, from .. import other не сработает в a1.py . В результате мы получим ошибку ValueError: attempted relative import beyond top-level package .

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

Имейте в виду, что относительные импорты основаны на имени текущего модуля. Так как имя главного модуля всегда "__main__" , модули, которые должны использоваться как главный модуль приложения, должны всегда использовать абсолютные импорты.

Источник: Python 2 и Python 3

Примеры

Пример 1: sys.path известен заранее

Если вы собираетесь вызывать только python start.py или python other.py , то прописать импорты всем модулям не составит труда. В данном случае sys.path всегда будет включать папку test/ . Таким образом, все импорты можно писать относительно этой папки.

Пример: файлу в проекте test нужно импортировать функцию helloWorld() из sa1.py .

Решение: from packA.subA.sa1 import helloWorld (или любой другой эквивалентный синтаксис импорта).

Пример 2: sys.path мог измениться

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

Пример: пусть start.py нужно импортировать a2 , которому нужно импортировать sa2 . Предположим, что start.py всегда запускается напрямую, а не импортируется. Также мы хотим иметь возможность запускать a2 напрямую.

Звучит просто, не так ли? Нам всего лишь нужно выполнить два импорта: один в start.py и другой в a2.py .

Проблема: это один из тех случаев, когда sys.path меняется. Когда мы выполняем start.py , sys.path содержит test/ , а при выполнении a2.py sys.path содержит test/packA/ .

С импортом в start.py нет никаких проблем. Так как этот модуль всегда запускается напрямую, мы знаем, что при его выполнении в sys.path всегда будет test/ . Тогда импортировать a2 можно просто с помощью import packA.a2 .

С импортом в a2.py немного сложнее. Когда мы запускаем start.py напрямую, sys.path содержит test/ , поэтому в a2.py импорт будет выглядеть как from packA.subA import sa2 . Однако если запустить a2.py напрямую, то в sys.path уже будет test/packA/ . Теперь импорт вызовет ошибку, так как packA не является папкой внутри test/packA/ .

Вместо этого мы могли бы попробовать from subA import sa2 . Это решает проблему при запуске a2.py напрямую, однако теперь создаёт проблему при запуске start.py . В Python 3 это приведёт к ошибке, потому что subA не находится в sys.path (в Python 2 это не вызовет проблемы из-за поддержки неявных относительных импортов).

Запускаем	from packA.subA import sa2	from subA import sa2
start.py	Нет проблем	В Py2 нет проблем, в Py3 ошибка ( subA не в test/ )
a2.py	Ошибка ( packA не в test/packA/ )	Нет проблем

Использование относительного импорта from .subA import sa2 будет иметь тот же эффект, что и from packA.subA import sa2 .

Вряд ли для этой проблемы есть чистое решение, поэтому вот несколько обходных путей:

1. Использовать абсолютные импорты относительно директории test/ (т. е. средняя колонка в таблице выше). Это гарантирует, что запуск start.py напрямую всегда сработает. Чтобы запустить a2.py напрямую, запустите его как импортируемый модуль, а не как скрипт:

В консоли смените директорию на test/ .
Запустите python -m packA.a2 .

2. Использовать абсолютные импорты относительно директории test/ (средняя колонка в таблице). Это гарантирует, что запуск start.py напрямую всегда сработает. Чтобы запустить a2.py напрямую, можно изменить sys.path в a2.py , чтобы включить test/packA/ перед импортом sa2 .

Примечание Обычно этот метод работает, однако в некоторых случаях переменная __file__ может быть неправильной. В таком случае нужно использовать встроенный пакет inspect . Подробнее в этом ответе на StackOverflow.

3. Использовать только Python 2 и неявные относительные импорты (последняя колонка в таблице).

4. Использовать абсолютные импорты относительно директории test/ и добавить её в переменную среды PYTHONPATH . Это решение не переносимо, поэтому лучше не использовать его. О том, как добавить директорию в PYTHONPATH , читайте в этом ответе.

Пример 3: sys.path мог измениться (вариант 2)

А вот ещё одна проблема посложнее. Допустим, модуль a2.py никогда не надо запускать напрямую, но он импортируется start.py и a1.py , которые запускаются напрямую.

В этом случае первое решение из примера выше не сработает. Тем не менее, всё ещё можно использовать остальные решения.

Пример 4: импорт из родительской директории

Если мы не изменяем PYTHONPATH и стараемся не изменять sys.path программно, то сталкиваемся со следующим основным ограничением импортов в Python: при запуске скрипта напрямую невозможно импортировать что-либо из его родительской директории.

Например, если бы нам пришлось запустить python sa1.py , то этот модуль не смог бы ничего импортировать из a1.py без вмешательства в PYTHONPATH или sys.path .

На первый взгляд может показаться, что относительные импорты (например from .. import a1 ) помогут решить эту проблему. Однако запускаемый скрипт (в данном случае sa1.py ) считается «модулем верхнего уровня». Попытка импортировать что-либо из директории над этим скриптом приведёт к ошибке ValueError: attempted relative import beyond top-level package .

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

Python 2 vs Python 3

Мы разобрали основные отличия импортов в Python 2 и Python 3. Они ещё раз изложены здесь наряду с менее важными отличиями:

Общее / Ключевые моменты

инструкция import осуществляет поиск модулей в списке путей, содержащемся в переменной sys.path ;
sys.path всегда включает путь к скрипту, запущенному в настоящий момент времени в командной строке и однозначно задает рабочую директорию для текущего сеанса командной строки;
концептуально импорт пакета происходит, как импорт файла пакета __init__.py .

Основные определения

модуль: любой файл с расширением *.py . Именем модуля является имя файла.
встроенный модуль: модуль (написанный на С ), который интегрирован непосредственно в интерпретатор Python и следовательно не имеет отдельного файла с расширением *.py .
пакет: любая папка содержащая файл с именем __init\__.py . Имя пакета совпадает с именем папки. В Python 3.3 и выше любая папка (даже без файла __init\__.py ) считается пакетом.
объект: в Python почти всё является объектом: функции, классы, переменные и т.д.

Пример структуры директории

Обратите внимание, что мы не размещаем __init\__.py в корневой папке test/ .

Что такое import ?

Когда вы импортируете модуль, Python запускает код из файла модуля. Когда вы импортируете пакет, Python сначала запускает код из файла пакета __init__.py , если такой файл существует. После этого все объекты, определенные в файле модуля или __init__.py пакета, становятся доступны.

Основы использования оператора import и переменной sys.path

В соответствии с документацией Python, оператор import ищет корректный модуль или пакет для импорта в соответствии со следующими правилами.

директория, содержащая запущенный на исполнение скрипт (или текущий каталог, когда не указан файл).
переменная окружения PYTHONPATH (список имен каталогов с тем же синтаксисом, что и PATH переменная оболочки shell ).
значение по умолчанию, заданное при установке Python.

Технически документация Python является неполной. На самом деле интерпретатор ищет не только файл (то есть, модуль) с именем spam.py , также он будет искать папку (то есть, пакет) с именем spam .
Обратите внимание, что интерпретатор Python сначала ищет список встроенных модулей, то есть модулей, которые интегрированы непосредственно в интерпретатор Python. Состав списка встроенных модулей зависит от типа установки и может быть найден в файлах sys.builtin_module_names (для Python версии 2 и 3). Обычно встроенные модули, которые входят с состав начальной установки, включают в себя sys (всегда устанавливается), math , itertools и time и другие.

В отличие от встроенных модулей (модулей стандартной библиотеки), пути к которым помещаются первыми в списке для поиска при импорте остальные модули в стандартной библиотеке Python появляются после пути каталога текущего скрипта. Это приводит к запутанному поведению: становится возможно «заменить» некоторые, но не все модули в стандартной библиотеке Python.
Например, на моем компьютере (Windows 10, Python 3.6) модуль math является встроенным модулем, тогда как модуль random нет. Таким образом, import math в start.py будет импортировать модуль math из стандартной библиотеки, а не мой собственный файл math.py , находящийся в тот же каталоге.
А оператор import random в start.py будет импортировать мой файл random.py , а не модуль random из стандартной библиотеки.

Функция pkgutil.iter_modules (Python 2 и 3) может использоваться для получения списка всех импортируемых модулей по заданному пути:

Подробнее о sys.path

Чтобы узнать, что находится в переменной sys.path , запустите в командной строке следующие команды или скрипт содержащий инструкции:

Документация Python для sys.path описывает это следующим образом.

Документация для интерфейса командной строки Python добавляет следующее о запуске сценариев из командной строки. В частности, при запуске команды python script.py , происходит следующее.

Если имя сценария ссылается непосредственно на файл с расширением py , то каталог, содержащий этот файл, добавляется в начало sys.path и файл выполняется в качестве основного модуля.
Источник: Python 2 и 3

Давайте рассмотрим порядок, в соответствии с которым интерпретатор Python ищет модули для импорта:

Обратите внимание, что при запуске скрипта Python в sys.path не учитывается, каков ваш текущий «рабочий каталог». Учитывается только о путь к сценарию. Например, если интерпретатор запущен из папки test/ и вы запускаете команду python ./packA/subA/subA1.py , то sys.path включает test/packA/subA/ , а не test/ .

Кроме того, значение sys.path будет использоваться для всех импортированных модулей. Например, предположим, что мы вводим команду python start.py . Пусть start.py импортирует packA.a1 , и пусть a1.py выведет содержимое переменной sys.path . Выводимое содержимое переменной sys.path будет включать test/ (путь к start.py ), а не test/packA/ (путь к a1.py ). Это означает, что скрипт a1.py может вызывать import other , поскольку файл other.py находится в test/ .

Все о init.py

Файл __init__.py выполняет 2 функции.

Преобразование папки со скриптами в импортируемый пакет модулей (до Python 3.3).
Запуск кода инициализации пакета.

Преобразование папки сценариев в импортируемый пакет модулей

Как уже было сказано выше, любой каталог, содержащий файл с именем __init__.py представляет собой пакет Python. Этот файл так же может быть пустым. Например, при запуске скрипта start.py в Python 2.7 можно импортировать пакет packA , но не packB , так как в каталоге test/packB/ нет файла __init__.py .

Это НЕ применимо к Python 3.3 и выше, благодаря принятию неявных пространств имен пакетов. В принципе, Python 3.3+ рассматривает все папки как пакеты, поэтому пустые файлы __init__.py больше не нужны и могут быть опущены.

Например, packB представляет собой пространство имен пакета, поскольку в папке нет файла __init__.py . Если мы запустим интерактивный интерпретатор Python версии 3.6 в каталоге test/ , то получим следующий результат:

Запуск кода инициализации пакета

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

Рассмотрим следующий пример.

Листинг файла test/packA/a1.py :

Листинг файла test/packA/__init__.py :

Листинг файла test/start.py :

Команда python start.py выведет следующее:

Примечание: если в файле a1.py вызывается import a2 , и вы запускаете в командной строке команду python a1.py , то test/packA/__ init__.py НЕ будет вызван, хотя на первый взгляд кажется, что a2 является частью пакета packA . Так происходит потому, что Python запускает скрипт (в нашем случае a1.py ), но содержащая его папка не является пакетом.

Использование объектов из импортированного модуля или пакета

Существует четыре различных вида синтаксиса для записи операторов импорта.

import <package>
import <module>
from <package> import <module or subpackage or object>
from <module> import <object>

Пусть X любое имя после ключевого слова import .

Необязательно, но после любого оператора import X может быть добавлена инструкция вида as Y , например, import X as Y . Эта инструкция переименовывает X в Y в пределах файла скрипта. Обратите внимание, что имя X далее не действительно и его использовать не имеет смысла. Например import numpy as np .

Аргументом при ключевом слове import может быть одно имя или список из нескольких имен. Каждое из этих имен может быть также переименовано с помощью ключевого слова as . Например, следующие инструкции импорта в файле в start.py будут работать правильно: import packA as pA , packA.a1, packA.subA.sa1 as sa1 .

Рассмотрим следующий пример: в файле start.py необходимо импортировать функцию helloWorld() из файла sa1.py .

Решение №1:

затем мы можем вызывать функцию непосредственно по имени:

Решение №2:

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

Иногда это решение предпочтительнее Решения №1 для того чтобы сделать явным вызов функции helloWorld из модуля sa1 .

Решение №3:

Далее необходимо использовать полный путь:

Использование dir() для проверки содержимого импортированного модуля

После импорта модуля, используйте функцию dir() для того чтобы получить список доступных имен модуля. Например, предположим, что вы импортируете sa1 . Если в sa1.py определена функция helloWorld() , то инструкция dir(sa1) в числе прочих выведет имя helloWorld .

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

Импорт пакета концептуально эквивалентен импорту файла __init__.py из папки пакета в качестве модуля. И действительно это так. Вот как Python рассматривает импортируемый пакет:

Скриптам, импортирующим пакеты, доступны лишь те объекты, которые были объявлены в файле пакета __init__.py . Например, так как каталог packB не содержит файла __init__.py , то вызов инструкции import packB в Python 3.3+ будет мало полезен, поскольку никакие объекты при импорте пакета packB не будут доступны. Последующий вызов packB.b1 завершится неудачей, поскольку объект не будет импортирован.

Импорт с использованием абсолютных и относительных путей

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

Импорт по относительному пути использует относительный путь (начинающийся с пути к текущему модулю) до требуемого для импорта модуля. Существует два вида импорта с использованием относительного пути:

явный импорт задается в следующей форме from .<module/package> import X , где <module/package> имеет префикс в виде последовательности имен каталогов, разделенных точками . , которые указывают, на сколько каталогов необходимо переместиться вверх или вниз. При этом одна точка . соответствует текущему каталогу, а две точки .. предписывают переместиться на одну папку вверх и т.д.
неявный импорт записывается так, как будто текущий каталог является частью содержимого переменной sys.path . Неявный относительный импорт поддерживается только Python 2 и не поддерживается Python 3.

В документации Python говорится о том, как Python 3+ обрабатывает импорт по относительному пути:

Единственным верным синтаксисом для импорта по относительному пути является формат from .[module] import name . Все формы инструкции импорта не начинающиеся с точки . интерпретируются как импорт по абсолютному пути.
Источник: What’s New in Python 3.0.

Например, предположим, что мы запускаем на исполнение скрипт start.py , который импортирует a1 , который, в свою очередь, импортирует other , a2 и sa1 . Инструкции import в файле a1.py будут выглядеть следующим образом:

Импорт по относительному пути может выполняться только для модулей в пакете; не допускается использовать эту возможность для ссылки на модули, которые находятся в другом каталоге файловой системы. Обратите внимание, что при импорте по относительному пути, точки .. помогут перемещаться при поиске файла для импорта только выше каталога (но не включая его), содержащего скрипт, запускаемый из командной строки. Таким образом, from .. import other не будет работать в a1.py . Это приводит к ошибке ValueError: attempted relative import beyond top-level package (попытка импорта по относительному пути за пределы пакета верхнего уровня).

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

Обратите внимание, что импорт по относительному пути основан на имени текущего модуля. Поскольку имя основного модуля всегда «main», то модули, предназначенные для использования в качестве основного модуля приложения Python, должны всегда использовать импорт по абсолютному пути.
Источники: Python 2 и 3.

Примеры

Пример 1: содержание sys.path заранее известно

Если вы запускаете скрипты командой python start.py или python other.py , то вам будет очень просто настроить импорт всех модулей. В этом случае переменная sys.path будет всегда включать директорию test/ в списке путей поиска при импорте. Поэтому все операторы импорта могут быть записаны относительно папки test/ .

Например: сценарий в папке test должен импортировать функцию helloWorld() из файла sa1.py .
Решение: from packA.subA.sa1 import helloWorld

Пример 2: содержание sys.path может изменяться

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

Пример: Предположим, что в сценарии start.py необходимо импортировать a2.py , который в свою очередь должен импортировать sa2.py . Предположим, что start.py всегда запускается непосредственно напрямую, и никогда не импортируется. Мы также хотим иметь возможность запускать a2.py самостоятельно. Кажется, все достаточно просто. В конце концов, нам нужно всего лишь два оператора импорта: первый в start.py и второй в a2.py .

Проблема: Это случай, когда sys.path будет изменяться. Когда мы запускаем start.py , переменная sys.path содержит директорию test/ . Когда мы запустим файл a2.py , то sys.path будет содержать test/ packA/ .

Инструкция import в start.py проста для понимания. Зная заранее, что start.py будет всегда запускаться напрямую и никогда не будет импортирован, мы полагаем, что при его запуске путь test/ всегда будет находиться в переменной sys.path . Тогда инструкция для импорта a2.py будет следующая import packA.a2 .

Инструкция import в a2.py более сложна. Когда мы запускаем start.py напрямую, переменная sys.path содержит test/ , поэтому в a2.py следует использовать инструкцию from packA.subA import sa2 . Однако, если после этого мы будем запускать a2.py напрямую, то переменная sys.path будет содержать путь test/packA/ . Теперь инструкция для импорта не будет корректной, поскольку packA не является папкой внутри test/packA/ .

Вместо этого мы могли бы попробовать применить инструкцию from subA import sa2 . Это решит нашу проблему, если мы запускаем a2.py напрямую. Но теперь у нас возникает проблема, когда мы напрямую запускаем start.py . В Python 3 это не будет выполняться, потому что subA не находится в переменной sys.path . Но будет выполняться без ошибок в Python 2, благодаря поддержке неявного импорта с относительными путями.

Таким образом, по использованию инструкции import в файле a2.py имеем:

Инструкция	from packA.subA import sa2	from subA import sa2
start.py	Работает	в Py2 работает , в Py3 не работает (subA нет в test/)
a2.py	Не работает (packA нет в test/packA/)	Работает

Для полноты картины можно попытался использовать импорт по относительному пути: from .subA import sa2 . И это будет соответствовать результату выполнения инструкции from packA.subA import sa2 .

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

Используйте импорт по абсолютному пути и test/ как корневую директорию (средний столбец в таблице выше). Это гарантирует запуск скрипта start.py напрямую. Чтобы запустить a2.py напрямую, необходимо запустить его как импортированный модуль, а не как скрипт. Для этого надо изменить текущую директорию на test/ в консоли, то есть выполнить команду python -m packA.a2 .
Используйте импорт по абсолютному пути и test/ как корневую директорию (средний столбец в таблице выше). Это гарантирует, что будет работать напрямую запуск start.py . Чтобы напрямую запустить a2.py , мы можем изменить значение переменной sys.path в a2.py , для того чтобы включить в список путей для импорта путь test/packA/ , прежде чем sa2.py будет импортирован.

ПРИМЕЧАНИЕ. Обычно этот метод работает. Однако в некоторых установках Python переменная __file__ может быть некорректной. В этом случае вам нужно будет использовать встроенный в стандартную библиотеку Python пакет inspect. Ознакомьтесь с вопросом на StackOverflow для правильного использования приведенных выше инструкций.

это решение не переносимо в другую среду выполнения, поэтому не рекомендуется его применять.
инструкции по его использованию здесь: Как постоянно добавлять директорию в переменную среды PYTHONPATH

Пример 3: содержание sys.path может изменяться (вариант 2)

Более сложная проблема заключается в следующем. Предположим, что a2.py никогда не нужно запускать напрямую, но он импортируется такими файлами, как start.py и a1.py , которые будут запускаться напрямую из консоли.

В этом случае Решение №1 не будет работать. Но другие будут.

Пример 4: Импорт из родительской директории

Если мы не собираемся модифицировать переменные PYTHONPATH и sys.path в коде, то в этом случае основным ограничением импорта является следующее: При непосредственном запуске скрипта через консоль невозможно импортировать что-либо из его родительского каталога.

Например, если вы хотите запустить следующую команду python sa1.py , то невозможно в файле sa1.py что-либо импортировать из a1.py , не прибегая к обходным путям, описанным выше: изменения значений переменных PYTHONPATH или sys.path .

Во-первых, может показаться, что импорт по относительному пути (например, from .. import a1 ) может обойти это ограничение. Однако скрипт, который выполняется (в данном случае sa1.py ) при этом считается «модулем верхнего уровня». Попытка импортировать что-либо из каталога на уровень выше каталога этого скрипта приводит к появлению следующей ошибки: ValueError: attempted relative import beyond top-level package (попытка импорта по относительному пути за пределы пакета верхнего уровня).

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

Python 2 VS. Python 3

Наиболее важные различия между тем, как Python 2 и Python 3 рассматривают инструкции import , были описаны выше. Они снова рассматриваются ниже, наряду с некоторыми другими менее важными отличиями.

Модулем в Python называется любой файл с программой (да-да, все те программы, которые вы писали, можно назвать модулями). В этой статье мы поговорим о том, как создать модуль, и как подключить модуль, из стандартной библиотеки или написанный вами.

Каждая программа может импортировать модуль и получить доступ к его классам, функциям и объектам. Нужно заметить, что модуль может быть написан не только на Python, а например, на C или C++.

Подключение модуля из стандартной библиотеки

Подключить модуль можно с помощью инструкции import. К примеру, подключим модуль os для получения текущей директории:

После ключевого слова import указывается название модуля. Одной инструкцией можно подключить несколько модулей, хотя этого не рекомендуется делать, так как это снижает читаемость кода. Импортируем модули time и random.

После импортирования модуля его название становится переменной, через которую можно получить доступ к атрибутам модуля. Например, можно обратиться к константе e, расположенной в модуле math:

Стоит отметить, что если указанный атрибут модуля не будет найден, возбудится исключение AttributeError. А если не удастся найти модуль для импортирования, то ImportError.

Использование псевдонимов

Если название модуля слишком длинное, или оно вам не нравится по каким-то другим причинам, то для него можно создать псевдоним, с помощью ключевого слова as.

Теперь доступ ко всем атрибутам модуля math осуществляется только с помощью переменной m, а переменной math в этой программе уже не будет (если, конечно, вы после этого не напишете import math, тогда модуль будет доступен как под именем m, так и под именем math).

Инструкция from

Подключить определенные атрибуты модуля можно с помощью инструкции from. Она имеет несколько форматов:

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

Импортируемые атрибуты можно разместить на нескольких строках, если их много, для лучшей читаемости кода:

Второй формат инструкции from позволяет подключить все (точнее, почти все) переменные из модуля. Для примера импортируем все атрибуты из модуля sys:

Следует заметить, что не все атрибуты будут импортированы. Если в модуле определена переменная __all__ (список атрибутов, которые могут быть подключены), то будут подключены только атрибуты из этого списка. Если переменная __all__ не определена, то будут подключены все атрибуты, не начинающиеся с нижнего подчёркивания. Кроме того, необходимо учитывать, что импортирование всех атрибутов из модуля может нарушить пространство имен главной программы, так как переменные, имеющие одинаковые имена, будут перезаписаны.

Создание своего модуля на Python

Теперь пришло время создать свой модуль. Создадим файл mymodule.py, в которой определим какие-нибудь функции:

Теперь в этой же папке создадим другой файл, например, main.py:

Поздравляю! Вы сделали свой модуль! Напоследок отвечу ещё на пару вопросов, связанных с созданием модулей:

Как назвать модуль?

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

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

Что такое модуль

Это отдельный файл, содержащий какой-то код. Любой скрипт, написанный программистом на Python 3, можно назвать модулем. Он может быть как исполняемым, так и подключаемым. Исполняемый модуль содержит код, который самостоятельно выполняет какие-то действия, а подключаемый представляет из себя набор функций, классов и объектов, которые можно использовать для решения задач в другой программе.

Разделение программ на модули даёт ряд преимуществ:

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

Исполняемый и подключаемый модуль

Можно написать такой скрипт, который будет и выполнять какие-то действия (программа), и импортироваться в другие модули (библиотека).

Его важно правильно оформить:

Весь исполняемый код помещается в функцию main() .
Функция main() вызывается после условия:

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

Подключение модуля

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

Программист может без проблем подключить любой модуль, который есть в стандартной библиотеке Python 3. Для подключения специфичных пользовательских инструментов сначала нужно их скачать. Обычно для этого используется пакетный менеджер pip.

Обычное подключение — import

После подключения программа получает доступ ко всем функциям, методам и классам, содержащимся в нём.

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

Вот полный пример использования инструкции import в Python 3:

Использование псевдонимов — as

Некоторые модули имеют длинное и неудобное название. Для удобства и сокращения количества кода программист может заменить его на своё.

Импорт компонентов — from

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

Например, программист хочет использовать только одну функцию из математической библиотеки math . Если он подключит всю библиотеку, то в скрипт добавится более 40 функций, которые будут занимать место. Чтобы добавить в проект какую-то часть, используют ключевое слово from :

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

Можно подключить несколько функций сразу в одной строке. Для этого их надо перечислить через запятую.

Перезагрузка библиотеки

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

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

Если всё же необходимо перезагрузить модуль, на помощью приходит функция reload() из стандартной библиотеки importlib. Перезагрузка не влияет на объекты, ссылающиеся на импортированный модуль, и позволяет реализовать динамическую перезагрузку компонентов программы.

Подключение из другой папки

Библиотеки подключаются очень просто, когда интерпретатор Python знает, где их искать. Python ищет модули:

В папке исполняемого скрипта.
Во встроенных модулях (built-in).
В директориях, определённых в sys.path (также содержит переменную PYTHONPATH).

Чтобы импортировать модуль из другой папки в Python 3, можно сделать следующее:

Для того чтобы директория, содержащая файлы, определялась как пакет, в неё необходимо добавить файл __init__.py. Он показывает интерпретатору Python, что папка — это пакет с модулями.

Начиная с версии Python 3.3, добавлять файл __init__.py в директорию больше не нужно, интерпретатор Python считает все папки пакетами.

Читайте также:

Как импортировать файл в python

есть много способов импортировать файл python, все со своими плюсами и минусами.

Содержание

Ключевые моменты

Основные определения

Пример структуры директорий

Что делает import

Основы import и sys.path

Чуть подробнее о sys.path

Всё о __init__.py

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

Выполнение кода инициализации пакета

Использование объектов из импортированного модуля или пакета

Используем dir() для исследования содержимого импортированного модуля

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

Абсолютный и относительный импорт

Примеры

Пример 1: sys.path известен заранее

Пример 2: sys.path мог измениться

Пример 3: sys.path мог измениться (вариант 2)

Пример 4: импорт из родительской директории

Python 2 vs Python 3

Общее / Ключевые моменты

Основные определения

Пример структуры директории

Что такое import ?

Основы использования оператора import и переменной sys.path

Подробнее о sys.path

Все о __init__.py

Преобразование папки сценариев в импортируемый пакет модулей

Запуск кода инициализации пакета

Использование объектов из импортированного модуля или пакета

Использование dir() для проверки содержимого импортированного модуля

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

Импорт с использованием абсолютных и относительных путей

Примеры

Пример 1: содержание sys.path заранее известно

Пример 2: содержание sys.path может изменяться

Пример 3: содержание sys.path может изменяться (вариант 2)

Пример 4: Импорт из родительской директории

Python 2 VS. Python 3

Подключение модуля из стандартной библиотеки

Использование псевдонимов

Инструкция from

Создание своего модуля на Python

Как назвать модуль?

Что такое модуль

Исполняемый и подключаемый модуль

Подключение модуля

Обычное подключение — import

Использование псевдонимов — as

Импорт компонентов — from

Перезагрузка библиотеки

Подключение из другой папки

Всё о init.py

Все о init.py