问题：从父文件夹导入模块
我正在运行Python 2.5。
这是我的文件夹树：
ptdraft/
nib.py
simulations/
life/
life.py
（我还在__init__.py每个文件夹中，为便于阅读，在此省略）
如何nib从模块内部导入life模块？我希望无需修补sys.path就可以做到。
注意：正在运行的主模块在ptdraft文件夹中。
I am running Python 2.5.
This is my folder tree:
ptdraft/
nib.py
simulations/
life/
life.py
(I also have __init__.py in each folder, omitted here for readability)
How do I import the nib module from inside the life module? I am hoping it is possible to do without tinkering with sys.path.
Note: The main module being run is in the ptdraft folder.
回答 0
看来问题与该模块位于父目录或类似目录中无关。
您需要将包含的目录添加ptdraft到PYTHONPATH
您说过import nib与您合作，这可能意味着您将ptdraft自身（而不是其父项）添加到了PYTHONPATH中。
It seems that the problem is not related to the module being in a parent directory or anything like that.
You need to add the directory that contains ptdraft to PYTHONPATH
You said that import nib worked with you, that probably means that you added ptdraft itself (not its parent) to PYTHONPATH.
回答 1
回答 2
相对导入（如中的from .. import mymodule）仅在包中起作用。要导入当前模块的父目录中的“ mymodule”：
import os,sys,inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)
import mymodule
编辑：__file__属性并不总是给定的。os.path.abspath(__file__)我现在建议不要使用Inspect模块来检索当前文件的文件名（和路径），而不要使用它
Relative imports (as in from .. import mymodule) only work in a package.
To import ‘mymodule’ that is in the parent directory of your current module:
import os,sys,inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)
import mymodule
edit: the __file__ attribute is not always given. Instead of using os.path.abspath(__file__) I now suggested using the inspect module to retrieve the filename (and path) of the current file
回答 3
对于同级软件包的导入问题，我也发表了类似的答案。你可以在这里看到它。
没有sys.path黑客的解决方案
摘要
- 将代码包装到一个文件夹中（例如
packaged_stuff）
setup.py在使用setuptools.setup（）的地方使用创建脚本。- 使用以下命令以可编辑状态安装软件包
pip install -e <myproject_folder>
- 导入使用
from packaged_stuff.modulename import function_name
设定
我假设与问题中的文件夹结构相同
.
└── ptdraft
├── __init__.py
├── nib.py
└── simulations
├── __init__.py
└── life
├── __init__.py
└── life.py
我将其.称为根文件夹，就我而言，它位于中C:\tmp\test_imports。
脚步
1）将A添加setup.py到根文件夹
的内容setup.py可以很简单
from setuptools import setup, find_packages
setup(name='myproject', version='1.0', packages=find_packages())
基本上是“任何” setup.py都可以。这只是一个最小的工作示例。
2）使用虚拟环境
如果您熟悉虚拟环境，请激活一个，然后跳到下一步。虚拟环境的使用不是绝对必需的，但从长远来看（当您正在进行多个项目时），它们确实可以帮助您。最基本的步骤是（在根文件夹中运行）
- 创建虚拟环境
- 激活虚拟环境
. /venv/bin/activate（Linux）或./venv/Scripts/activate（Win）
要了解更多有关此的信息，只需在Google上搜索“ python virtualenv教程”或类似内容即可。除了创建，激活和停用之外，您可能根本不需要任何其他命令。
创建并激活虚拟环境后，控制台应在括号中提供虚拟环境的名称。
PS C:\tmp\test_imports> python -m venv venv
PS C:\tmp\test_imports> .\venv\Scripts\activate
(venv) PS C:\tmp\test_imports>
3）pip以可编辑状态安装项目
安装您的顶级包myproject使用pip。诀窍是-e在执行安装时使用标志。这样，它以可编辑状态安装，并且对.py文件所做的所有编辑将自动包含在已安装的软件包中。
在根目录中，运行
pip install -e . （注意点，它代表“当前目录”）
您还可以看到它是通过使用安装的 pip freeze
(venv) PS C:\tmp\test_imports> pip install -e .
Obtaining file:///C:/tmp/test_imports
Installing collected packages: myproject
Running setup.py develop for myproject
Successfully installed myproject
(venv) PS C:\tmp\test_imports> pip freeze
myproject==1.0
4）通过mainfolder在每次导入之前进行导入
在此示例中，mainfolder将为ptdraft。这样的好处是您不会与其他模块名称（来自python标准库或3rd party模块）发生名称冲突。
用法示例
笔尖
def function_from_nib():
print('I am the return value from function_from_nib!')
life.py
from ptdraft.nib import function_from_nib
if __name__ == '__main__':
function_from_nib()
运行life.py
(venv) PS C:\tmp\test_imports> python .\ptdraft\simulations\life\life.py
I am the return value from function_from_nib!
I posted a similar answer also to the question regarding imports from sibling packages. You can see it here.
Solution without sys.path hacks
Summary
- Wrap the code into one folder (e.g.
packaged_stuff)
- Use create
setup.py script where you use setuptools.setup().
- Pip install the package in editable state with
pip install -e <myproject_folder>
- Import using
from packaged_stuff.modulename import function_name
Setup
I assume the same folder structure as in the question
.
└── ptdraft
├── __init__.py
├── nib.py
└── simulations
├── __init__.py
└── life
├── __init__.py
└── life.py
I call the . the root folder, and in my case it is located in C:\tmp\test_imports.
Steps
1) Add a setup.py to the root folder
The contents of the setup.py can be simply
from setuptools import setup, find_packages
setup(name='myproject', version='1.0', packages=find_packages())
Basically “any” setup.py would work. This is just a minimal working example.
2) Use a virtual environment
If you are familiar with virtual environments, activate one, and skip to the next step. Usage of virtual environments are not absolutely required, but they will really help you out in the long run (when you have more than 1 project ongoing..). The most basic steps are (run in the root folder)
- Create virtual env
- Activate virtual env
. /venv/bin/activate (Linux) or ./venv/Scripts/activate (Win)
To learn more about this, just Google out “python virtualenv tutorial” or similar. You probably never need any other commands than creating, activating and deactivating.
Once you have made and activated a virtual environment, your console should give the name of the virtual environment in parenthesis
PS C:\tmp\test_imports> python -m venv venv
PS C:\tmp\test_imports> .\venv\Scripts\activate
(venv) PS C:\tmp\test_imports>
3) pip install your project in editable state
Install your top level package myproject using pip. The trick is to use the -e flag when doing the install. This way it is installed in an editable state, and all the edits made to the .py files will be automatically included in the installed package.
In the root directory, run
pip install -e . (note the dot, it stands for “current directory”)
You can also see that it is installed by using pip freeze
(venv) PS C:\tmp\test_imports> pip install -e .
Obtaining file:///C:/tmp/test_imports
Installing collected packages: myproject
Running setup.py develop for myproject
Successfully installed myproject
(venv) PS C:\tmp\test_imports> pip freeze
myproject==1.0
4) Import by prepending mainfolder to every import
In this example, the mainfolder would be ptdraft. This has the advantage that you will not run into name collisions with other module names (from python standard library or 3rd party modules).
Example Usage
nib.py
def function_from_nib():
print('I am the return value from function_from_nib!')
life.py
from ptdraft.nib import function_from_nib
if __name__ == '__main__':
function_from_nib()
Running life.py
(venv) PS C:\tmp\test_imports> python .\ptdraft\simulations\life\life.py
I am the return value from function_from_nib!
回答 4
您可以在sys.path中列出的“模块搜索路径”中使用取决于OS的路径。因此您可以轻松添加父目录，如下所示
import sys
sys.path.insert(0,'..')
如果您要添加父/母目录，
sys.path.insert(0,'../..')
这在python 2和3。
You can use OS depending path in “module search path” which is listed in sys.path .
So you can easily add parent directory like following
import sys
sys.path.insert(0,'..')
If you want to add parent-parent directory,
sys.path.insert(0,'../..')
This works both in python 2 and 3.
回答 5
如果无法将模块文件夹添加到PYTHONPATH，则可以在程序中修改sys.path列表，Python解释程序会在其中搜索要导入的模块，python文档说：
导入名为spam的模块时，解释器首先搜索具有该名称的内置模块。如果找不到，它将在变量sys.path给出的目录列表中搜索名为spam.py的文件。sys.path从以下位置初始化：
- 包含输入脚本的目录（或当前目录）。
- PYTHONPATH（目录名称列表，语法与shell变量PATH相同）。
- 取决于安装的默认值。
初始化之后，Python程序可以修改sys.path。包含正在运行的脚本的目录位于搜索路径的开始，在标准库路径之前。这意味着将加载该目录中的脚本，而不是库目录中相同名称的模块。除非打算进行更换，否则这是一个错误。
知道了这一点，您可以在程序中执行以下操作：
import sys
# Add the ptdraft folder path to the sys.path list
sys.path.append('/path/to/ptdraft/')
# Now you can import your module
from ptdraft import nib
# Or just
import ptdraft
If adding your module folder to the PYTHONPATH didn’t work, You can modify the sys.path list in your program where the Python interpreter searches for the modules to import, the python documentation says:
When a module named spam is imported, the interpreter first searches for a built-in module with that name. If not found, it then searches for a file named spam.py in a list of directories given by the variable sys.path. sys.path is initialized from these locations:
- the directory containing the input script (or the current directory).
- PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
- the installation-dependent default.
After initialization, Python programs can modify sys.path. The directory containing the script being run is placed at the beginning of the search path, ahead of the standard library path. This means that scripts in that directory will be loaded instead of modules of the same name in the library directory. This is an error unless the replacement is intended.
Knowing this, you can do the following in your program:
import sys
# Add the ptdraft folder path to the sys.path list
sys.path.append('/path/to/ptdraft/')
# Now you can import your module
from ptdraft import nib
# Or just
import ptdraft
回答 6
对python 2不太了解。
在python 3中，可以按以下方式添加父文件夹：
import sys
sys.path.append('..')
…然后可以从中导入模块
Don’t know much about python 2.
In python 3, the parent folder can be added as follows:
import sys
sys.path.append('..')
…and then one is able to import modules from it
回答 7
这是一个简单的答案，因此您可以了解它的工作原理（小型和跨平台）。
它仅使用内置模块（os，sys和inspect），所以应该工作
在任何操作系统（OS），因为Python是专为上。
较短的答案代码-更少的行和变量
from inspect import getsourcefile
import os.path as path, sys
current_dir = path.dirname(path.abspath(getsourcefile(lambda:0)))
sys.path.insert(0, current_dir[:current_dir.rfind(path.sep)])
import my_module # Replace "my_module" here with the module name.
sys.path.pop(0)
如果少于此行，请用替换第二行import os.path as path, sys, inspect，在（第3行）的开头
添加inspect.，getsourcefile然后删除第一行。
-但是，这会导入所有模块，因此可能需要更多的时间，内存和资源。
我的答案的代码（较长版本）
from inspect import getsourcefile
import os.path
import sys
current_path = os.path.abspath(getsourcefile(lambda:0))
current_dir = os.path.dirname(current_path)
parent_dir = current_dir[:current_dir.rfind(os.path.sep)]
sys.path.insert(0, parent_dir)
import my_module # Replace "my_module" here with the module name.
它使用来自Stack Overflow答案的示例。如何获取
Python中当前执行文件的路径？使用内置工具查找正在运行的代码的源（文件名）。
from inspect import getsourcefile
from os.path import abspath
接下来，无论您想在哪里找到源文件，都只需使用：
abspath(getsourcefile(lambda:0))
我的代码sys.path在的python路径列表中添加了文件路径
因为这允许Python从该文件夹导入模块。
在代码中导入模块之后，
当添加的文件夹中的模块名称与另一个
稍后在程序中导入的模块同名时，最好sys.path.pop(0)换行运行。您需要删除导入之前添加的列表项，而不是其他路径。
如果您的程序未导入其他模块，则不删除文件路径是安全的，因为
在程序结束（或重新启动Python Shell）之后，对
sys.path消失。
有关文件名变量的注释
我的答案没有使用__file__变量来获取正在运行的
代码的文件路径/文件名，因为此处的用户经常将其描述为不可靠的。您不应将其
用于从其他人使用的程序中从父文件夹导入模块。
一些不起作用的示例（引用此 Stack Overflow问题）：
• 在某些平台上找不到•有时不是完整的文件路径
py2exe没有__file__属性，但是有一种解决方法- 当您从IDLE运行时，
execute()没有__file__属性
- 我得到的OS X 10.6
NameError: global name '__file__' is not defined
Here is an answer that’s simple so you can see how it works, small and cross-platform.
It only uses built-in modules (os, sys and inspect) so should work
on any operating system (OS) because Python is designed for that.
Shorter code for answer – fewer lines and variables
from inspect import getsourcefile
import os.path as path, sys
current_dir = path.dirname(path.abspath(getsourcefile(lambda:0)))
sys.path.insert(0, current_dir[:current_dir.rfind(path.sep)])
import my_module # Replace "my_module" here with the module name.
sys.path.pop(0)
For less lines than this, replace the second line with import os.path as path, sys, inspect,
add inspect. at the start of getsourcefile (line 3) and remove the first line.
– however this imports all of the module so could need more time, memory and resources.
The code for my answer (longer version)
from inspect import getsourcefile
import os.path
import sys
current_path = os.path.abspath(getsourcefile(lambda:0))
current_dir = os.path.dirname(current_path)
parent_dir = current_dir[:current_dir.rfind(os.path.sep)]
sys.path.insert(0, parent_dir)
import my_module # Replace "my_module" here with the module name.
It uses an example from a Stack Overflow answer How do I get the path of the current
executed file in Python? to find the source (filename) of running code with a built-in tool.
from inspect import getsourcefile
from os.path import abspath
Next, wherever you want to find the source file from you just use:
abspath(getsourcefile(lambda:0))
My code adds a file path to sys.path, the python path list
because this allows Python to import modules from that folder.
After importing a module in the code, it’s a good idea to run sys.path.pop(0) on a new line
when that added folder has a module with the same name as another module that is imported
later in the program. You need to remove the list item added before the import, not other paths.
If your program doesn’t import other modules, it’s safe to not delete the file path because
after a program ends (or restarting the Python shell), any edits made to sys.path disappear.
Notes about a filename variable
My answer doesn’t use the __file__ variable to get the file path/filename of running
code because users here have often described it as unreliable. You shouldn’t use it
for importing modules from parent folder in programs used by other people.
Some examples where it doesn’t work (quote from this Stack Overflow question):
• it can’t be found on some platforms • it sometimes isn’t the full file path
py2exe doesn’t have a __file__ attribute, but there is a workaround- When you run from IDLE with
execute() there is no __file__ attribute
- OS X 10.6 where I get
NameError: global name '__file__' is not defined
回答 8
这是更通用的解决方案，其中将父目录包含在sys.path中（对我有用）：
import os.path, sys
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))
Here is more generic solution that includes the parent directory into sys.path (works for me):
import os.path, sys
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))
回答 9
我发现以下方法可用于从脚本的父目录导入包。在示例中，我想env.py从app.db包中导入函数。
.
└── my_application
└── alembic
└── env.py
└── app
├── __init__.py
└── db
import os
import sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)
I found the following way works for importing a package from the script’s parent directory. In the example, I would like to import functions in env.py from app.db package.
.
└── my_application
└── alembic
└── env.py
└── app
├── __init__.py
└── db
import os
import sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)
回答 10
上述解决方案也很好。解决此问题的另一种方法是
如果要从顶层目录导入任何内容。然后，
from ...module_name import *
另外，如果要从父目录导入任何模块。然后，
from ..module_name import *
另外，如果要从父目录导入任何模块。然后，
from ...module_name.another_module import *
这样，您可以根据需要导入任何特定方法。
Above mentioned solutions are also fine. Another solution to this problem is
If you want to import anything from top level directory. Then,
from ...module_name import *
Also, if you want to import any module from the parent directory. Then,
from ..module_name import *
Also, if you want to import any module from the parent directory. Then,
from ...module_name.another_module import *
This way you can import any particular method if you want to.
回答 11
对我来说，访问父目录最短和最喜欢的oneliner是：
sys.path.append(os.path.dirname(os.getcwd()))
要么：
sys.path.insert(1, os.path.dirname(os.getcwd()))
os.getcwd（）返回当前工作目录的名称，os.path.dirname（directory_name）返回所传递目录的目录名称。
实际上，在我看来，Python项目体系结构应采用以下方式：子目录中的任何模块都不会使用父目录中的任何模块。如果发生这种情况，则值得重新考虑项目树。
另一种方法是将父目录添加到PYTHONPATH系统环境变量。
For me the shortest and my favorite oneliner for accessing to the parent directory is:
sys.path.append(os.path.dirname(os.getcwd()))
or:
sys.path.insert(1, os.path.dirname(os.getcwd()))
os.getcwd() returns the name of the current working directory, os.path.dirname(directory_name) returns the directory name for the passed one.
Actually, in my opinion Python project architecture should be done the way where no one module from child directory will use any module from the parent directory. If something like this happens it is worth to rethink about the project tree.
Another way is to add parent directory to PYTHONPATH system environment variable.
回答 12
在Jupyter笔记本中
只要您在Jupyter Notebook中工作，这个简短的解决方案就可能有用：
%cd ..
import nib
即使没有__init__.py文件也可以使用。
我在Linux和Windows 7上使用Anaconda3对其进行了测试。
In a Jupyter Notebook
As long as you’re working in a Jupyter Notebook, this short solution might be useful:
%cd ..
import nib
It works even without an __init__.py file.
I tested it with Anaconda3 on Linux and Windows 7.
回答 13
import sys
sys.path.append('../')
import sys
sys.path.append('../')
回答 14
当不在带有__init__.py文件的打包环境中时，pathlib库（包含在> = Python 3.4中）使将父目录的路径附加到PYTHONPATH变得非常简洁直观：
import sys
from pathlib import Path
sys.path.append(str(Path('.').absolute().parent))
When not being in a package environment with __init__.py files the pathlib library (included with >= Python 3.4) makes it very concise and intuitive to append the path of the parent directory to the PYTHONPATH:
import sys
from pathlib import Path
sys.path.append(str(Path('.').absolute().parent))
回答 15
与过去的答案相同的风格-但行数较少：P
import os,sys
parentdir = os.path.dirname(__file__)
sys.path.insert(0,parentdir)
文件返回您正在工作的位置
same sort of style as the past answer – but in fewer lines :P
import os,sys
parentdir = os.path.dirname(__file__)
sys.path.insert(0,parentdir)
file returns the location you are working in
回答 16
使用库。创建一个名为nib的库，使用setup.py安装它，使其驻留在站点程序包中，您的问题将得到解决。您不必将自己制作的所有东西都塞进一个包装中。分解成碎片。
Work with libraries.
Make a library called nib, install it using setup.py, let it reside in site-packages and your problems are solved.
You don’t have to stuff everything you make in a single package. Break it up to pieces.
回答 17
在Linux系统中，您可以创建一个从“ life”文件夹到nib.py文件的软链接。然后，您可以像这样简单地导入它：
import nib
In a Linux system, you can create a soft link from the “life” folder to the nib.py file. Then, you can simply import it like:
import nib
