Python 3 中的相对导入

把它放在你包的 __init__.py 文件中：

# For relative imports to work in Python 3.6
import os, sys; sys.path.append(os.path.dirname(os.path.realpath(__file__)))

假设你的包是这样的：

├── project
│   ├── package
│   │   ├── __init__.py
│   │   ├── module1.py
│   │   └── module2.py
│   └── setup.py

现在在你的包中使用常规导入，比如：

# in module2.py
from module1 import class1

这适用于 python 2 和 3。

---

我遇到了这个问题。 hack 解决方法是通过 if/else 块导入，如下所示：

#!/usr/bin/env python3
#myothermodule

if __name__ == '__main__':
    from mymodule import as_int
else:
    from .mymodule import as_int


# Exported function
def add(a, b):
    return as_int(a) + as_int(b)

# Test function for module  
def _test():
    assert add('1', '1') == 2

if __name__ == '__main__':
    _test()

---

SystemError：父模块''未加载，无法执行相对导入

这意味着您正在将包内的模块作为脚本运行。在包中混合脚本是棘手的，应尽可能避免。改用导入包并运行 scripty 函数的包装脚本。

如果您的顶级目录称为 foo，它位于您的 PYTHONPATH 模块搜索路径中，并且您在其中有一个包 bar（它是您希望在其中包含 __init__.py 文件的目录），脚本不应放在 bar 内，而应在 foo 最多内继续存在。

请注意，scripts 与此处的 modules 不同之处在于它们用作 python 命令的文件名参数，可以使用 python <filename> 或通过 #! (社邦）线。它直接作为 __main__ module 加载（这就是 if __name__ == "__main__": 在脚本中起作用的原因），并且没有包上下文可用于相对导入。

您的选择

如果可以的话，使用 setuptools（或诗歌或 flit，可以帮助简化打包）打包您的项目，并创建控制台脚本入口点；使用 pip 安装项目然后创建知道如何正确导入包的脚本。你可以使用 pip install -e . 在本地安装你的包，所以它仍然可以就地编辑。

否则，永远不要使用 python path/to/packagename/file.py，总是使用 python path/to/script.py 和 script.py 可以使用 from packagename import ...。

作为后备，您可以使用 -m 命令行开关来告诉 Python 导入模块并将其用作 __main__ 文件。但是，这不适用于 shebang 行，因为不再有脚本文件。如果您使用 python -m foo.bar 并且 foo/bar.py 在 sys.path 目录中找到，那么它会被导入并作为 __main__ 使用正确的包上下文执行。如果 bar 也是一个包，在 foo/ 中，它必须有一个 __main__.py 文件（因此 foo/bar/__main__.py 作为 sys.path 目录的路径）。

在极端情况下，通过直接设置 __package__ 添加 Python 用于解析相对导入的元数据；文件 foo/bar/spam.py，可作为 foo.bar.spam 导入，被赋予全局 __package__ = "foo.bar"。它只是另一个全局变量，如 __file__ 和 __name__，由 Python 在导入时设置。

在 sys.path 上

以上所有要求您的包可以导入，这意味着它需要在 sys.path 中列出的目录（或 zipfile）之一中找到。这里也有几个选项：

找到 path/to/script.py 的目录（因此 path/to）会自动添加到 sys.path。执行 python path/to/foo.py 将 path/to 添加到 sys.path。

如果您打包了项目（使用 setuptools、poetry、flit 或其他 Python 打包工具）并安装了它，则该包已经添加到正确的位置。

作为最后的手段，自己将正确的目录添加到 sys.path 中。如果包可以相对于脚本文件定位，请使用脚本全局命名空间中的 __file__ 变量（例如使用 pathlib.Path 对象，HERE = Path(__file__).resolve().parent 是对文件目录的引用生活在，作为绝对路径）。

---

对于 PyCharm 用户：

我也得到了 ImportError: attempted relative import with no known parent package，因为我添加了 . 符号来消除 PyCharm 解析错误。 PyCharm 错误地报告无法找到：

lib.thing import function

如果您将其更改为：

.lib.thing import function

它使错误静音，但随后您会得到上述 ImportError: attempted relative import with no known parent package。只需忽略 PyCharm 的解析器。这是错误的，尽管它说了什么，但代码运行良好。

---

为了避免这个问题，我设计了一个使用 repackage 包的解决方案，它已经为我工作了一段时间。它将上层目录添加到 lib 路径：

import repackage
repackage.up()
from mypackage.mymodule import myfunction

Repackage 可以使用智能策略（检查调用堆栈）进行适用于各种情况的相对导入。

---

希望这对那里的人有价值 - 我浏览了六篇 stackoverflow 帖子，试图找出类似于上面发布的内容的相对导入。我按照建议设置了所有内容，但我仍在点击 ModuleNotFoundError: No module named 'my_module_name'

由于我只是在本地开发和玩耍，我没有创建/运行 setup.py 文件。我显然也没有设置我的 PYTHONPATH。

我意识到，当我像测试与模块位于同一目录中时一样运行我的代码时，我找不到我的模块：

$ python3 test/my_module/module_test.py                                                                                                               2.4.0
Traceback (most recent call last):
  File "test/my_module/module_test.py", line 6, in <module>
    from my_module.module import *
ModuleNotFoundError: No module named 'my_module'

但是，当我明确指定路径时，事情开始起作用了：

$ PYTHONPATH=. python3 test/my_module/module_test.py                                                                                                  2.4.0
...........
----------------------------------------------------------------------
Ran 11 tests in 0.001s

OK

因此，如果有人尝试了一些建议，认为他们的代码结构正确并且仍然发现自己处于与我类似的情况，如果您不将当前目录导出到 PYTHONPATH，请尝试以下任一方法：

运行您的代码并显式包含路径，如下所示：$ PYTHONPATH=. python3 test/my_module/module_test.py 为了避免调用 PYTHONPATH=.，创建一个 setup.py 文件，内容如下，然后运行 python setup.py development 将包添加到路径：

# setup.py from setuptools import setup, find_packages setup(name='sample', packages=find_packages() )

---

TL；DR：对@Aya 的回答，使用 pathlib 库进行了更新，并适用于未定义 __file__ 的 Jupyter 笔记本：

您想要导入在 ../my_Folder_where_the_package_lives/my_package.py 下定义的 my_function，这与您编写代码的位置有关。

然后做：

import os
import sys
import pathlib

PACKAGE_PARENT = pathlib.Path(__file__).parent
#PACKAGE_PARENT = pathlib.Path.cwd().parent # if on jupyter notebook
SCRIPT_DIR = PACKAGE_PARENT / "my_Folder_where_the_package_lives"
sys.path.append(str(SCRIPT_DIR))

from my_package import my_function

---

我需要从主项目目录运行 python3 以使其工作。

例如，如果项目具有以下结构：

project_demo/
├── main.py
├── some_package/
│   ├── __init__.py
│   └── project_configs.py
└── test/
    └── test_project_configs.py

解决方案

我会在文件夹 project_demo/ 中运行 python3，然后执行

from some_package import project_configs

---

我在可独立运行的 package 中制作具有相对导入的 module 的样板。

package/module.py

## Standalone boilerplate before relative imports
if __package__ is None:                  
    DIR = Path(__file__).resolve().parent
    sys.path.insert(0, str(DIR.parent))
    __package__ = DIR.name

from . import variable_in__init__py
from . import other_module_in_package
...

现在您可以以任何方式使用您的模块：

像往常一样运行模块：python -m package.module 将其用作模块：python -c 'from package import module' 独立运行：python package/module.py 或使用 shebang (#!/bin/env python) 只需：包/模块.py

注意！如果您的 module 与您的 package 同名，则使用 sys.path.append 而不是 sys.path.insert 会给您带来难以追踪的错误。例如my_script/my_script.py

当然，如果您有来自包层次结构中更高级别的相对导入，那么这还不够，但在大多数情况下，这还可以。

---

我收到了这个 ImportError：尝试使用没有已知父包的相对导入

在我的程序中，我使用当前路径中的文件来导入其功能。

from .filename import function

然后我用包名修改了当前路径（点）。这解决了我的问题。

from package_name.filename import function

希望以上回答对你有所帮助。

---

我尝试了以上所有方法都无济于事，只是意识到我错误地在我的包名中有一个 -。

简而言之，__init__.py 所在的目录中没有 -。在发现这种愚蠢之后，我从未感到高兴。

---

从同一目录导入

首先，您可以从同一目录导入。

这是文件结构...

Folder
 |
 ├─ Scripts
 |   ├─ module123.py
 |
 ├─ main.py
 ├─ script123.py

这是main.py

from . import script123
from Scripts import module123

如您所见，从 . 导入从当前目录导入。

注意：如果使用除 IDLE 之外的任何东西运行，请确保在运行之前将您的终端导航到与 main.py 文件相同的目录。

此外，从本地文件夹导入也可以。

从父目录导入

如my GitHub gist here所示，有以下方法。

采取以下文件树...

ParentDirectory
 ├─ Folder
 |   |
 |   ├─ Scripts
 |   |   ├─ module123.py
 |   |
 |   ├─ main.py
 |   ├─ script123.py
 |
 ├─ parentModule.py

然后，只需将此代码添加到 main.py 文件的顶部。

import inspect
import os
import sys

current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parent_dir = os.path.dirname(current_dir)
sys.path.insert(0, parent_dir)

from ParentDirectory import Stuff

---

如果两个包都在您的导入路径 (sys.path) 中，并且您想要的模块/类在 example/example.py 中，那么要在没有相对导入的情况下访问该类，请尝试：

from example.example import fkt

---

如果上述方法都不适合您，您可以明确指定模块。

目录：

├── Project
│     ├── Dir
│     │    ├── __init__.py
│     │    ├── module.py
│     │    └── standalone.py

解决方案：

#in standalone.py
from Project.Dir.module import ...

module - 要导入的模块

---

我认为最好的解决方案是为您的模块创建一个包：Here 是有关如何执行此操作的更多信息。

一旦你有了一个包，你就不需要担心相对导入，你可以做绝对导入。

---

我在使用 Django 时经常遇到这种情况，因为很多功能都是从 manage.py 脚本执行的，但我也希望我的一些模块也可以直接作为脚本运行（理想情况下，您可以将它们设为 manage.py指令，但我们还没有）。

这是这样一个项目的模型；

├── dj_app
│   ├── models.py
│   ├── ops
│   │   ├── bar.py
│   │   └── foo.py
│   ├── script.py
│   ├── tests.py
│   ├── utils.py
│   └── views.py
└── manage.py

这里的重要部分是 manage.py、dj_app/script.py 和 dj_app/tests.py。我们还有子模块 dj_app/ops/bar.py 和 dj_app/ops/foo.py，其中包含我们想要在整个项目中使用的更多项目。

问题的根源通常是希望您的 dj_app/script.py 脚本方法在 dj_app/tests.py 中有测试用例，当您运行 manage.py test 时会调用这些测试用例。

这就是我设置项目及其import的方式；

# dj_app/ops/foo.py
# Foo operation methods and classes
foo_val = "foo123"

.

# dj_app/ops/bar.py
# Bar operations methods and classes
bar_val = "bar123"

.

# dj_app/script.py
# script to run app methods from CLI

# if run directly from command line
if __name__ == '__main__':
    from ops.bar import bar_val
    from ops.foo import foo_val

# otherwise
else:
    from .ops.bar import bar_val
    from .ops.foo import foo_val

def script_method1():
    print("this is script_method1")
    print("bar_val: {}".format(bar_val))
    print("foo_val: {}".format(foo_val))


if __name__ == '__main__':
    print("running from the script")
    script_method1()

.

# dj_app/tests.py
# test cases for the app
# do not run this directly from CLI or the imports will break
from .script import script_method1
from .ops.bar import bar_val
from .ops.foo import foo_val 

def main():
    print("Running the test case")
    print("testing script method")
    script_method1()

if __name__ == '__main__':
    print("running tests from command line")
    main()

.

# manage.py
# just run the test cases for this example
import dj_app.tests
dj_app.tests.main()

.

从 manage.py 运行测试用例；

$ python3 manage.py
Running the test case
testing script method
this is script_method1
bar_val: bar123
foo_val: foo123

自行运行脚本；

$ python3 dj_app/script.py
running from the script
this is script_method1
bar_val: bar123
foo_val: foo123

请注意，如果您尝试直接运行 test.py，则会收到错误消息，因此请不要这样做；

$ python3 dj_app/tests.py
Traceback (most recent call last):
  File "dj_app/tests.py", line 5, in <module>
    from .script import script_method1
ModuleNotFoundError: No module named '__main__.script'; '__main__' is not a package

如果我遇到更复杂的导入情况，我通常最终会实现这样的东西来破解它；

import os
import sys
THIS_DIR = os.path.dirname(os.path.realpath(__file__))
sys.path.insert(0, THIS_DIR)
from script import script_method1
sys.path.pop(0)

---

这是我的项目结构

├── folder
|   | 
│   ├── moduleA.py
|   |   |
|   |   └--function1()
|   |       └~~ uses function2()
|   | 
│   └── moduleB.py
|       | 
|       └--function2()
|   
└── main.py
     └~~ uses function1()

这里我的 moduleA 导入 moduleB 和 main 导入 moduleA

我在 moduleA 中添加了以下代码段以导入 moduleB

try:
    from .moduleB import function2 
except:
    from moduleB import function2 

现在我可以单独执行 main.py 和 moduleA.py

这是一个解决方案吗？

---

以下解决方案在 Python3 上进行了测试

├── classes
|   |
|   ├──__init__.py
|   | 
│   ├── userclass.py
|   |   |
|   |   └--viewDetails()
|   |       
|   | 
│   └── groupclass.py
|       | 
|       └--viewGroupDetails()
|   
└── start.py
     └~~ uses function1()

现在，为了使用 userclass 的 viewDetails 或 groupclass 的 viewGroupDetails，首先在 classess 目录的 _init _.py 中定义。

例如：在_init _.py

from .userclasss import viewDetails

from .groupclass import viewGroupDetails

Step2：现在，在start.py中我们可以直接导入viewDetails

例如：在 start.py

from classes import viewDetails
from classes import viewGroupDetails

---

我有一个类似的问题：我需要一个使用通用常量来配合的 Linux 服务和 cgi 插件。这样做的“自然”方法是将它们放在包的 init.py 中，但我无法使用 -m 参数启动 cgi 插件。

我的最终解决方案类似于上面的解决方案 #2：

import sys
import pathlib as p
import importlib

pp = p.Path(sys.argv[0])
pack = pp.resolve().parent

pkg = importlib.import_module('__init__', package=str(pack))

缺点是必须在常量（或常用函数）前加上 pkg：

print(pkg.Glob)

---

将要从中导入的文件移动到外部目录会有所帮助。当您的主文件在其自己的目录中创建任何其他文件时，这非常有用。例如：之前：项目 |---dir1 |-------main.py |-------module1.py 之后：项目 |---module1.py |---dir1 |-- -----main.py

---

TLDR；通过在 python 脚本的入口点添加以下内容，将脚本路径附加到系统路径。

import os.path
import sys
PACKAGE_PARENT = '..'
SCRIPT_DIR = os.path.dirname(os.path.realpath(os.path.join(os.getcwd(), os.path.expanduser(__file__))))
sys.path.append(os.path.normpath(os.path.join(SCRIPT_DIR, PACKAGE_PARENT)))

现在就是这样，您可以在 PyCharma 以及终端中运行您的项目！

---

在尝试编写可以作为模块或可执行脚本加载的 python 文件时，我遇到了类似的问题。

设置

/path/to/project/
├── __init__.py
└── main.py
    └── mylib/
        ├── list_util.py
        └── args_util.py

和：

main.py:

#!/usr/bin/env python3
import sys
import mylib.args_util

if __name__ == '__main__':
    print(f'{mylib.args_util.parseargs(sys.argv[1:])=}')

mylib/list_util.py:

def to_int_list(args):
    return [int(x) for x in args]

mylib/args_util.py:

#!/usr/bin/env python3
import sys
from . import list_util as lu

def parseargs(args):
    return sum(lu.to_int_list(args))

if __name__ == '__main__':
    print(f'{parseargs(sys.argv[1:])=}')

输出

$ ./main.py 1 2 3
mylib.args_util.parseargs(sys.argv[1:])=6

$ mylib/args_util.py 1 2 3
Traceback (most recent call last):
  File "/path/to/project/mylib/args_util.py", line 10, in <module>
    from . import list_util as lu
ImportError: attempted relative import with no known parent package

解决方案

我选择了 Bash/Python 多语言解决方案。该程序的 Bash 版本只是调用 python3 -m mylib.args_util 然后退出。

Python 版本会忽略 Bash 代码，因为它包含在文档字符串中。

Bash 版本忽略 Python 代码，因为它使用 exec 停止解析/运行行。

mylib/args_util.py:

#!/bin/bash
# -*- Mode: python -*-
''''true
exec /usr/bin/env python3 -m mylib.args_util "$@"
'''

import sys
from . import list_util as lu

def parseargs(args):
    return sum(lu.to_int_list(args))

if __name__ == '__main__':
    print(f'{parseargs(sys.argv[1:])=}')

输出

$ ./main.py 1 2 3
mylib.args_util.parseargs(sys.argv[1:])=6

$ mylib/args_util.py 1 2 3
parseargs(sys.argv[1:])=6

解释

第 1 行：#!/bin/bash；这是“shebang”线；它告诉交互式 shell 如何运行这个脚本。 Python：忽略（评论） Bash：忽略（评论）

Python：忽略（评论）

Bash：忽略（评论）

第 2 行：# -*- 模式：python -*- 可选；这称为“模式线”；它告诉 Emacs 在读取文件时使用 Python 语法高亮而不是猜测语言是 Bash。 Python：忽略（评论） Bash：忽略（评论）

Python：忽略（评论）

Bash：忽略（评论）

第 3 行：''''true Python：将其视为以 'true 开头的未分配文档字符串\n Bash：将其视为扩展为 true 的三个字符串（其中前两个是空字符串）（即 '' + '' +“真”=“真”）；然后它运行为真（什么都不做）并继续到下一行

Python：将其视为以 'true\n 开头的未分配文档字符串

Bash：将其视为扩展为 true 的三个字符串（其中前两个是空字符串）（即 '' + '' + 'true' = 'true'）；然后它运行为真（什么都不做）并继续到下一行

第 4 行： exec /usr/bin/env python3 -m mylib.args_util "$@" Python：仍然将其视为第 3 行的文档字符串的一部分。 Bash：运行 python3 -m mylib.args_util 然后退出（它没有解析超出此行的任何内容）

Python：仍然将其视为第 3 行的文档字符串的一部分。

Bash：运行 python3 -m mylib.args_util 然后退出（它不会解析超出此行的任何内容）

第 5 行：''' Python：将此视为第 3 行的文档字符串的结尾。 Bash：不解析此行

Python：将其视为第 3 行的文档字符串的结尾。

Bash：不解析这一行

注意事项

这在 Windows 上不起作用： 解决方法：使用 WSL 或批处理包装器脚本调用 python -m mylib.args_util。

解决方法：使用 WSL 或批处理包装器脚本调用 python -m mylib.args_util。

这仅在当前工作目录设置为 /path/to/project/ 时才有效。解决方法：调用 /usr/bin/env #!/bin/bash # -*- Mode: python -*- ''''true exec /usr/bin/env python3 \ PYTHONPATH="$(cd "$ (dirname "$0")/.." ; pwd)" \ -m mylib.args_util "$@" '''

解决方法：调用 /usr/bin/env #!/bin/bash # -*- Mode: python -*- ''''true exec /usr/bin/env python3 \ PYTHONPATH="$(cd "$ (dirname "$0")/.." ; pwd)" \ -m mylib.args_util "$@" '''

---

我为 Python 创建了一个新的实验性导入库：ultraimport

它使程序员可以更好地控制导入并使它们明确。当导入失败时，它还会提供更好的错误消息。

它允许您执行始终有效的相对、基于文件系统的导入，无论您如何运行代码，也无论您当前的工作目录是什么。运行脚本或模块都没有关系。您也不必更改可能有其他副作用的 sys.path。

然后你会改变

from .mymodule import myfunction

至

import ultraimport
myfunction = ultraimport('__dir__/mymodule.py', 'myfunction')

这样，即使您将代码作为脚本运行，导入也将始终有效。

像这样导入脚本时的一个问题是后续的相对导入可能会失败。 ultraimport 有一个内置的预处理器来自动重写相关的导入。

---

# so that it can be ran as a standalone script with Kernel set in project directory
if __name__ == "__main__":
    import os
    import sys
    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from other_folder.other_file import useful_function

def hello_world():
    useful_function()
    print("hello world")


if __name__ == "__main__":
    hello_world()

这是我的解决方案。我既可以将其作为独立脚本运行，也可以将其作为包的一部分导入而不会出现问题。

很简单，只有当您尝试将项目目录作为独立脚本运行时，它才会将项目目录添加到您的路径中

---

我有一个类似的问题，并通过在工作目录中创建一个指向包的符号链接来解决它：

ln -s ../../../my_package my_package

然后像往常一样导入它：

import my_package

我知道这更像是“Linux”解决方案而不是“Python”解决方案。但它仍然是一种有效的方法。

---