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

Убедитесь, что в dirBar есть файл __init__.py - это превращает каталог в пакет Python.

Если вы структурируете свой проект таким образом:

src\
  __init__.py
  main.py
  dirFoo\
    __init__.py
    Foo.py
  dirBar\
    __init__.py
    Bar.py

Затем из Foo.py вы сможете:

import dirFoo.Foo

Или же:

from dirFoo.Foo import FooObject

Согласно комментарию Тома, для этого требуется, чтобы папка src была доступна либо через site_packages, либо через ваш путь поиска. Кроме того, как он упоминает, __init__.py неявно импортируется, когда вы впервые импортируете модуль в этот пакет / каталог. Обычно __init__.py - это просто пустой файл.

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

import sys
sys.path.insert(0, <path to dirFoo>)
import Bar

Это соответствующий PEP:

http://www.python.org/dev/peps/pep-0328/

В частности, предположим, что dirFoo - это каталог выше dirBar ...

В dirFoo \ Foo.py:

from ..dirBar import Bar

Самый простой способ - использовать sys.path.append ().

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

# mod_name is the filename without the .py/.pyc extention
py_mod = imp.load_source(mod_name,filename_path) # Loads .py file
py_mod = imp.load_compiled(mod_name,filename_path) # Loads .pyc file 

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

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

Также эти функции могут быть полезны:

imp.find_module(name[, path])
imp.load_module(name, file, pathname, description)

Добавьте файл __init__.py:

dirFoo\
    Foo.py
    dirBar\
        __init__.py
        Bar.py

Затем добавьте этот код в начало Foo.py:

import sys
sys.path.append('dirBar')
import Bar

На мой взгляд, лучший выбор - поместить __ init __.py в папку и вызвать файл с

from dirBar.Bar import *

Не рекомендуется использовать sys.path.append (), потому что что-то может пойти не так, если вы используете то же имя файла, что и существующий пакет python. Я не тестировал это, но это будет неоднозначно.

import os
import sys
lib_path = os.path.abspath(os.path.join(__file__, '..', '..', '..', 'lib'))
sys.path.append(lib_path)

import mymodule

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

Допустим, у вас есть такой каталог:

lib/abc.py

Затем просто сохраните пустой файл в папке lib с именем

__init__.py

А затем используйте

from lib.abc import <Your Module name>

Храните файл __init__.py в каждой папке иерархии модуля импорта.

Предполагая, что оба ваших каталога являются настоящими пакетами Python (внутри них есть файл __init__.py), вот безопасное решение для включения модулей относительно местоположения скрипта.

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

 import os, sys, inspect
 # realpath() will make your script run, even if you symlink it :)
 cmd_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]))
 if cmd_folder not in sys.path:
     sys.path.insert(0, cmd_folder)

 # Use this if you want to include modules from a subfolder
 cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"subfolder")))
 if cmd_subfolder not in sys.path:
     sys.path.insert(0, cmd_subfolder)

 # Info:
 # cmd_folder = os.path.dirname(os.path.abspath(__file__)) # DO NOT USE __file__ !!!
 # __file__ fails if the script is called in different ways on Windows.
 # __file__ fails if someone does os.chdir() before.
 # sys.argv[0] also fails, because it doesn't not always contains the path.

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

Предупреждение! Я действительно не знаю, что происходит, когда текущий модуль находится внутри файла egg. Вероятно, это тоже не удается.

from .dirBar import Bar

вместо:

from dirBar import Bar

на всякий случай может быть установлен другой dirBar и запутать читателя foo.py.

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

import os, sys
from subprocess import Popen, PIPE
try:
    path = Popen("find / -name 'file' -type f", shell=True, stdout=PIPE).stdout.read().splitlines()[0]
    if not sys.path.__contains__(path):
        sys.path.append(path)
except IndexError:
    raise RuntimeError("You must have FILE to run this program!")

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

Вот способ импортировать файл с одного уровня выше, используя относительный путь.

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

#to import from one level above:
cwd = os.getcwd()
os.chdir("..")
below_path =  os.getcwd()
sys.path.append(below_path)
os.chdir(cwd)

Быстрый и грязный способ для пользователей Linux

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

ln -s (path)/module_name.py

или же

ln -s (path)/package_name

Примечание. «Модуль» - это любой файл с расширением .py, а «пакет» - это любая папка, содержащая файл __init__.py (который может быть пустым). С точки зрения использования модули и пакеты идентичны - оба предоставляют содержащиеся в них «определения и операторы» по запросу с помощью команды import.

См .: http://docs.python.org/2/tutorial/modules.html

Самый простой способ без каких-либо изменений в вашем скрипте - установить переменную среды PYTHONPATH. Поскольку sys.path инициализируется из этих мест:

1. Каталог, содержащий входной скрипт (или текущий каталог).
2. PYTHONPATH (список имен каталогов с одинаковыми синтаксис как переменная оболочки PATH).
3. Значение по умолчанию, зависящее от установки.

Просто беги:

export PYTHONPATH=/absolute/path/to/your/module

Ваш sys.path будет содержать указанный выше путь, как показано ниже:

print sys.path

['', '/absolute/path/to/your/module', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10', '/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7', '/usr/lib/python2.7/dist-packages/ubuntu-sso-client', '/usr/lib/python2.7/dist-packages/ubuntuone-client', '/usr/lib/python2.7/dist-packages/ubuntuone-control-panel', '/usr/lib/python2.7/dist-packages/ubuntuone-couch', '/usr/lib/python2.7/dist-packages/ubuntuone-installer', '/usr/lib/python2.7/dist-packages/ubuntuone-storage-protocol']

Пример относительного sys.path:

# /lib/my_module.py
# /src/test.py


if __name__ == '__main__' and __package__ is None:
    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../lib')))
import my_module

На основании ответа это.

В этом случае, чтобы импортировать Bar.py в Foo.py, сначала я бы превратил эти папки в пакеты Python следующим образом:

dirFoo\
    __init__.py
    Foo.py
    dirBar\
        __init__.py
        Bar.py

Тогда я бы сделал это в Foo.py так:

from .dirBar import Bar

Если бы я хотел, чтобы пространство имен выглядело как Bar.что бы ни или

from . import dirBar

Если бы я хотел использовать пространство имен dirBar.Bar.что бы ни. Этот второй случай полезен, если у вас есть больше модулей в пакете dirBar.

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

Решение:

У меня есть сценарий в D:/Books/MyBooks.py и некоторые модули (например, oldies.py). Мне нужно импортировать из подкаталога D:/Books/includes:

import sys,site
site.addsitedir(sys.path[0] + '\\includes')
print (sys.path)  # Just verify it is there
import oldies

Поместите print('done') в oldies.py, чтобы убедиться, что все в порядке. Этот способ всегда работает, потому что согласно определению Python, sys.path, инициализируемый при запуске программы, первый элемент этого списка, path[0], является каталогом, содержащим сценарий, который использовался для вызова интерпретатора Python.

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

Другое решение - установить пакет Py-require, а затем использовать следующее в Foo.py

import require
Bar = require('./dirBar/Bar')

Я не разбираюсь в питоне, поэтому, если в моих словах что-то не так, просто скажите мне. Если ваша файловая иерархия устроена следующим образом:

project\
    module_1.py 
    module_2.py

module_1.py определяет функцию под названием func_1(), module_2.py:

from module_1 import func_1

def func_2():
    func_1()

if __name__ == '__main__':
    func_2()

и вы запускаете python module_2.py в cmd, он выполнит то, что определяет func_1(). Обычно мы импортируем те же файлы иерархии. Но когда вы напишете from .module_1 import func_1 в module_2.py, интерпретатор Python скажет No module named '__main__.module_1'; '__main__' is not a package. Итак, чтобы исправить это, мы просто сохраняем только что внесенные изменения, перемещаем оба модуля в пакет и делаем третий модуль в качестве вызывающего для запуска module_2.py.

project\
    package_1\
        module_1.py
        module_2.py
    main.py

main.py:

from package_1.module_2 import func_2

def func_3():
    func_2()

if __name__ == '__main__':
    func_3()

Но причина, по которой мы добавляем . перед module_1 в module_2.py, заключается в том, что если мы этого не сделаем и запустим main.py, интерпретатор Python скажет No module named 'module_1', это немного сложно, module_1.py находится рядом с module_2.py. Теперь я позволяю func_1() в module_1.py что-то делать:

def func_1():
    print(__name__)

что __name__ записывает, кто вызывает func_1. Теперь мы сохраняем . перед module_1, запускаем main.py, он будет печатать package_1.module_1, а не module_1. Это указывает на то, что тот, кто называет func_1(), находится в той же иерархии, что и main.py, . подразумевает, что module_1 находится в той же иерархии, что и сам module_2.py. Таким образом, если точки нет, main.py распознает module_1 в той же иерархии, что и он сам, он может распознавать package_1, но не то, что находится «под» ним.

Теперь давайте немного усложним. У вас есть config.ini, и модуль определяет функцию для его чтения в той же иерархии, что и main.py.

project\
    package_1\
        module_1.py
        module_2.py
    config.py
    config.ini
    main.py

И по какой-то неизбежной причине вы должны вызвать его с помощью module_2.py, поэтому он должен импортировать из более высокой иерархии.

 import ..config
 pass

Две точки означают импорт из более высокой иерархии (три точки относятся к более высокому уровню и т. д.). Теперь запускаем main.py, интерпретатор скажет: ValueError:attempted relative import beyond top-level package. "Пакет верхнего уровня" здесь - main.py. Просто потому, что config.py находится рядом с main.py, они находятся в одной иерархии, config.py не находится «под» main.py, или он не «возглавляется» main.py, поэтому он находится за пределами main.py. Чтобы исправить это, самый простой способ:

project\
    package_1\
        module_1.py
        module_2.py
    config.py
    config.ini
main.py

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

Просто вы можете использовать: from Desktop.filename import something

Пример:

given that the file is name test.py in directory Users/user/Desktop , and will import everthing.

код:

from Desktop.test import *

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

Это тоже работает, и это намного проще, чем что-либо с модулем sys:

with open("C:/yourpath/foobar.py") as f:
    eval(f.read())