这是我的项目结构

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

这里我的模块A导入模块B，主导入模块A

我在模块A中添加了下面的代码段以导入模块B

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

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

这是解决方案吗？

将其放入包的__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中都有效。

我在使用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测试时会调用这些测试用例。

这是我如何设置项目及其导入的；

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

不幸的是，这个模块需要在包中有时需要作为脚本运行。知道我怎么做吗实现这一目标？

这样的布局很常见。。。

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

…一个肌肉热模块。。。

#!/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()

…还有一个像这样的男人。。。

#!/usr/bin/env python3

from mypackage.myothermodule import add

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

if __name__ == '__main__':
    main()

…当您运行main.py或mypackage/mymodule.py时，它工作得很好，但由于相对导入，mypackage/myothermodule.py失败。。。

from .mymodule import as_int

你应该用的方式是。。。

python3 -m mypackage.myothermodule

……但它有些冗长，与#/usr/bin/env python3。

对于这种情况，最简单的解决方法是避免使用相对导入，而只使用。。。

from mymodule import as_int

…虽然，如果它不是唯一的，或者您的包结构更复杂，您需要在PYTHONPATH中包含包含您的包目录的目录，并这样做。。。

from mypackage.mymodule import as_int

…或者如果你想让它“开箱即用”，你可以先用这个。。。

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写的电子邮件中。。。

我对这件事和任何其他提议的无聊事都持反对态度__机械唯一的用例似乎是运行发生的脚本生活在模块的目录中，我一直认为反模式。要让我改变主意，你必须说服我它不是。

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

TL；博士

您只能相对导入同一包中另一个模块内的模块。

概念澄清

我们在books/docs/articles中看到了很多示例代码，它们向我们展示了如何相对导入模块，但当我们这样做时，它失败了。

原因是，简单地说，我们没有按照python模块机制的预期运行代码，即使代码编写得完全正确。这就像某种运行时的事情。

模块加载取决于您如何运行代码。这就是困惑的根源。

什么是模块？

当且仅当模块被另一个文件导入时，它才是python文件。给定一个文件mod.py，它是一个模块吗？是和否，如果您运行python-mod.py，它不是一个模块，因为它没有导入。

什么是套餐？

包是包含Python模块的文件夹。

顺便说一下，如果您不需要任何包初始化或自动加载子模块，那么python 3.3中不需要__init__.py。您不需要在目录中放置空白__init__.py。

这证明只要有文件被导入，包就只是一个文件夹。

---

真实答案

现在，这个描述变得更加清晰了。

您只能相对导入同一包中另一个模块内的模块。

给定目录：

. CWD
|-- happy_maker.py # content: print('Sends Happy')
`-- me.py # content: from . import happy_maker

运行python-me.py，我们尝试了没有已知父包的相对导入

me.py是直接运行的，它不是一个模块，我们不能在其中使用相对导入。

解决方案1

使用import happy_maker而不是from。导入happy_maker

解决方案2

将工作目录切换到父文件夹。

. CWD
|-- happy
|   |-- happy_maker.py
    `-- me.py

运行python-m happy.me。

当我们在包含happy的目录中时，happy是一个包，me.py，happy_maker.py是模块，我们现在可以使用相对导入，我们仍然希望运行me.py。所以我们使用-m，这意味着将模块作为脚本运行。

---

Python习语

. CWD
|-- happy
|   |-- happy_maker.py # content: print('Sends Happy')
|   `-- me.py # content: from . import happy_maker
`-- main.py # content: import happy.me

这种结构就是python习语。main是我们的脚本，Python中的最佳实践。最后，我们到达了那里。

---

兄弟姐妹或祖父母

另一个常见需求：

.
|-- happy
|   |-- happy_maker.py
|   `-- me.py
`-- sad
    `-- sad_maker.py

我们想在me.py中导入sad_maker，怎么做？

首先，我们需要在同一个包中实现快乐和悲伤，所以我们必须升级到目录级别。然后从。。伤心地在me.py中导入sadmaker。

仅此而已。

将要导入的文件移动到外部目录有帮助。当主文件在其自己的目录中生成任何其他文件时，这是非常有用的。前任：之前：

Project  
|---dir1  
|-------main.py  
|-------module1.py  

之后：

Project  
|---module1.py  
|---dir1  
|-------main.py