不幸的是，这个模块需要在包内，有时还需要作为脚本运行。任何想法，我怎么能做到这一点？

像这样的布局是很常见的...

main.py
mypackage/
    __init__.py
    mymodule.py
    myothermodule.py

...像这样...mymodule.py

#!/usr/bin/env python3

# Exported function
def as_int(a):
    return int(a)

# Test function for module  
def _test():
    assert as_int('1') == 1

if __name__ == '__main__':
    _test()

...像这样...myothermodule.py

#!/usr/bin/env python3

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()

...和一个像这样的...main.py

#!/usr/bin/env python3

from mypackage.myothermodule import add

def main():
    print(add('1', '1'))

if __name__ == '__main__':
    main()

...当您运行 或 时，它工作正常，但由于相对导入，因此失败。main.pymypackage/mymodule.pymypackage/myothermodule.py

from .mymodule import as_int

你应该运行它的方式是...

python3 -m mypackage.myothermodule

...但它有点冗长，并且不能很好地与shebang线混合，例如.#!/usr/bin/env python3

对于这种情况，假设名称是全局唯一的，最简单的解决方法是避免使用相对导入，而只使用...mymodule

from mymodule import as_int

...但是，如果它不是唯一的，或者您的包结构更复杂，则需要将包含包目录的目录包含在 中，并像这样操作...PYTHONPATH

from mypackage.mymodule import as_int

...或者，如果您希望它“开箱即用”，您可以先用这个来折叠in代码...PYTHONPATH

import sys
import os

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(os.path.dirname(SCRIPT_DIR))

from mypackage.mymodule import as_int

这有点痛苦，但有一个线索，为什么在某个Guido van Rossum写的一封电子邮件中......

我对此以及机器的任何其他建议摆动都是-1。唯一的用例似乎是运行恰好位于模块目录中的脚本，我一直将其视为反模式。要让我改变主意，你必须说服我，事实并非如此。__main__

在包内运行脚本是否是反模式是主观的，但就我个人而言，我发现它在包含一些自定义wxPython小部件的包中非常有用，因此我可以为任何源文件运行脚本以显示仅包含该小部件以进行测试。wx.Frame

解释

从 PEP 328

相对导入使用模块的 __name__ 属性来确定该模块在包层次结构中的位置。如果模块的名称不包含任何包信息（例如，它被设置为“__main__”），则相对导入将被解析，就好像模块是顶级模块一样，而不管模块在文件系统上的实际位置如何。

在某些时候，PEP 338与PEP 328冲突：

...相对导入依赖于__name__来确定当前模块在包层次结构中的位置。在主模块中，__name__ 的值始终为“__main__”，因此显式相对导入将始终失败（因为它们仅适用于包内的模块）

为了解决这个问题，PEP 366引入了顶级变量__package__：

通过添加新的模块级属性，此 PEP 允许在使用 -m 开关执行模块时自动执行相对导入。模块本身中的少量样板文件将允许相对导入在按名称执行文件时工作。[...]当它 [属性] 存在时，相对导入将基于此属性，而不是模块__name__属性。[...]当主模块由其文件名指定时，__package__属性将设置为 None。[...]当导入系统在模块中遇到显式相对导入时，未设置__package__（或设置为 None），它将计算并存储正确的值（__name__.rpartition（'.'）[0] 对于普通模块和__name__对于包初始化模块）

（强调我的）

如果是 ，则返回空字符串。这就是错误描述中存在空字符串文本的原因：__name__'__main__'__name__.rpartition('.')[0]

SystemError: Parent module '' not loaded, cannot perform relative import

CPython PyImport_ImportModuleLevelObject功能的相关部分：

if (PyDict_GetItem(interp->modules, package) == NULL) {
    PyErr_Format(PyExc_SystemError,
            "Parent module %R not loaded, cannot perform relative "
            "import", package);
    goto error;
}

如果 CPython 无法在 （可作为 sys.modules 访问） 中找到（包的名称），则会引发此异常。由于是“将模块名称映射到已加载的模块的字典”，因此现在很明显，在执行相对导入之前，父模块必须显式绝对导入。packageinterp->modulessys.modules

注意：问题 18018 中的补丁添加了另一个 if 块，该块将在上述代码之前执行：

if (PyUnicode_CompareWithASCIIString(package, "") == 0) {
    PyErr_SetString(PyExc_ImportError,
            "attempted relative import with no known parent package");
    goto error;
} /* else if (PyDict_GetItem(interp->modules, package) == NULL) {
    ...
*/

如果（如上所述）为空字符串，则错误消息将为package

ImportError: attempted relative import with no known parent package

但是，您只能在Python 3.6或更高版本中看到这一点。

解决方案 #1：使用 -m 运行脚本

考虑一个目录（它是一个Python包）：

.
├── package
│   ├── __init__.py
│   ├── module.py
│   └── standalone.py

包中的所有文件都以相同的 2 行代码开头：

from pathlib import Path
print('Running' if __name__ == '__main__' else 'Importing', Path(__file__).resolve())

我包括这两行只是为了使操作顺序变得明显。我们可以完全忽略它们，因为它们不会影响执行。

__init__.py和 module.py 仅包含这两行（即，它们实际上是空的）。

standalone.py 还尝试通过相对导入导入 module.py：

from . import module  # explicit relative import

我们很清楚这将失败。但是，我们可以使用 -m 命令行选项运行该模块，该选项将“在 sys.path 中搜索命名模块，并将其内容作为__main__模块执行”：/path/to/python/interpreter package/standalone.py

vaultah@base:~$ python3 -i -m package.standalone
Importing /home/vaultah/package/__init__.py
Running /home/vaultah/package/standalone.py
Importing /home/vaultah/package/module.py
>>> __file__
'/home/vaultah/package/standalone.py'
>>> __package__
'package'
>>> # The __package__ has been correctly set and module.py has been imported.
... # What's inside sys.modules?
... import sys
>>> sys.modules['__main__']
<module 'package.standalone' from '/home/vaultah/package/standalone.py'>
>>> sys.modules['package.module']
<module 'package.module' from '/home/vaultah/package/module.py'>
>>> sys.modules['package']
<module 'package' from '/home/vaultah/package/__init__.py'>

-m为您完成所有导入内容并自动设置，但您可以在__package__

解决方案#2：手动设置__package__

请将其视为概念证明，而不是实际的解决方案。它不太适合在实际代码中使用。

PEP 366 有解决此问题的方法，但是，它不完整，因为仅进行设置是不够的。您需要在模块层次结构中导入至少 N 个前面的包，其中 N 是将搜索要导入的模块的父目录数（相对于脚本的目录）。__package__

因此

1. 将当前模块的第 N 个前置任务的父目录添加到sys.path

2. 从中删除当前文件的目录sys.path

3. 使用当前模块的完全限定名导入其父模块

4. 从 2 设置为完全限定的名称__package__

5. 执行相对导入

我将从解决方案 #1 中借用文件，并添加更多子包：

package
├── __init__.py
├── module.py
└── subpackage
    ├── __init__.py
    └── subsubpackage
        ├── __init__.py
        └── standalone.py

这次 standalone.py 将使用以下相对导入从包包中导入 module.py

from ... import module  # N = 3

我们需要在该行前面加上样板代码，以使其正常工作。

import sys
from pathlib import Path

if __name__ == '__main__' and __package__ is None:
    file = Path(__file__).resolve()
    parent, top = file.parent, file.parents[3]

    sys.path.append(str(top))
    try:
        sys.path.remove(str(parent))
    except ValueError: # Already removed
        pass

    import package.subpackage.subsubpackage
    __package__ = 'package.subpackage.subsubpackage'

from ... import module # N = 3

它允许我们按文件名执行 standalone.py：

vaultah@base:~$ python3 package/subpackage/subsubpackage/standalone.py
Running /home/vaultah/package/subpackage/subsubpackage/standalone.py
Importing /home/vaultah/package/__init__.py
Importing /home/vaultah/package/subpackage/__init__.py
Importing /home/vaultah/package/subpackage/subsubpackage/__init__.py
Importing /home/vaultah/package/module.py

可以在此处找到包装在函数中的更通用的解决方案。用法示例：

if __name__ == '__main__' and __package__ is None:
    import_parents(level=3) # N = 3

from ... import module
from ...module.submodule import thing

解决方案#3：使用绝对导入和设置工具

步骤是 -

1. 将显式相对导入替换为等效绝对导入

2. 安装以使其可导入package

例如，目录结构可能如下所示

.
├── project
│   ├── package
│   │   ├── __init__.py
│   │   ├── module.py
│   │   └── standalone.py
│   └── setup.py

其中 setup.py 是

from setuptools import setup, find_packages
setup(
    name = 'your_package_name',
    packages = find_packages(),
)

其余文件是从解决方案#1中借用的。

安装将允许您导入软件包，而不管您的工作目录如何（假设不会有命名问题）。

我们可以修改 standalone.py 以利用这个优势（步骤1）：

from package import module  # absolute import

将工作目录更改为并运行 （在站点包目录中安装包）（步骤 2）：project/path/to/python/interpreter setup.py install --user--user

vaultah@base:~$ cd project
vaultah@base:~/project$ python3 setup.py install --user

让我们验证现在是否可以将 standalone.py 作为脚本运行：

vaultah@base:~/project$ python3 -i package/standalone.py
Running /home/vaultah/project/package/standalone.py
Importing /home/vaultah/.local/lib/python3.6/site-packages/your_package_name-0.0.0-py3.6.egg/package/__init__.py
Importing /home/vaultah/.local/lib/python3.6/site-packages/your_package_name-0.0.0-py3.6.egg/package/module.py
>>> module
<module 'package.module' from '/home/vaultah/.local/lib/python3.6/site-packages/your_package_name-0.0.0-py3.6.egg/package/module.py'>
>>> import sys
>>> sys.modules['package']
<module 'package' from '/home/vaultah/.local/lib/python3.6/site-packages/your_package_name-0.0.0-py3.6.egg/package/__init__.py'>
>>> sys.modules['package.module']
<module 'package.module' from '/home/vaultah/.local/lib/python3.6/site-packages/your_package_name-0.0.0-py3.6.egg/package/module.py'>

注意：如果您决定走这条路，最好使用虚拟环境来隔离安装软件包。

解决方案#4：使用绝对导入和一些样板代码

坦率地说，安装不是必需的 - 您可以在脚本中添加一些样板代码以使绝对导入工作。

我将从解决方案#1中借用文件并更改 standalone.py：

1. 在尝试使用绝对导入从包中导入任何内容之前，将包的父目录添加到：sys.path

   import sys
   from pathlib import Path # if you haven't already done so
   file = Path(__file__).resolve()
   parent, root = file.parent, file.parents[1]
   sys.path.append(str(root))
   
   # Additionally remove the current file's directory from sys.path
   try:
       sys.path.remove(str(parent))
   except ValueError: # Already removed
       pass
   

2. 将相对导入替换为绝对导入：

   from package import module  # absolute import
   

standalone.py 运行没有问题：

vaultah@base:~$ python3 -i package/standalone.py
Running /home/vaultah/package/standalone.py
Importing /home/vaultah/package/__init__.py
Importing /home/vaultah/package/module.py
>>> module
<module 'package.module' from '/home/vaultah/package/module.py'>
>>> import sys
>>> sys.modules['package']
<module 'package' from '/home/vaultah/package/__init__.py'>
>>> sys.modules['package.module']
<module 'package.module' from '/home/vaultah/package/module.py'>

我觉得我应该警告你：尽量不要这样做，特别是如果你的项目有一个复杂的结构。

作为旁注，PEP 8建议使用绝对导入，但指出在某些情况下，显式相对导入是可以接受的：

建议使用绝对导入，因为它们通常更具可读性，并且往往表现更好（或者至少提供更好的错误消息）。[...]但是，显式相对导入是绝对导入的可接受替代方法，尤其是在处理复杂的包布局时，其中使用绝对导入将不必要地冗长。