我想从同一目录中的另一个文件导入一个函数。
通常，以下工作之一：
from .mymodule import myfunction
from mymodule import myfunction
…但另一个给了我一个错误：
ImportError: attempted relative import with no known parent package
ModuleNotFoundError: No module named 'mymodule'
SystemError: Parent module '' not loaded, cannot perform relative import
这是为什么？
不幸的是，这个模块需要在包中有时需要作为脚本运行。知道我怎么做吗实现这一目标？
这样的布局很常见。。。
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，用于测试目的。
我遇到了这个问题。黑客解决方法是通过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()
解释
来自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无法在interp->模块（可作为sys.modules访问）中找到包（包的名称），则会引发此异常。由于sys.module是“将模块名称映射到已加载的模块的字典”，因此现在很明显，在执行相对导入之前，必须显式绝对导入父模块。
注意：第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
我们很清楚/path/to/python/interpreter package/standalone.py将失败。但是，我们可以使用-m命令行选项运行该模块，该选项将“在sys.path中搜索命名模块并将其内容作为__main__模块执行”：
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'>
-我为您完成所有导入工作并自动设置__package__，但您可以在
解决方案#2：手动设置__package__
请将其视为概念的证明，而不是实际的解决方案。它不太适合在实际代码中使用。
PEP366有一个解决这个问题的方法，但是，它是不完整的，因为仅设置__package__是不够的。您将需要在模块层次结构中至少导入N个前面的包，其中N是要为导入的模块搜索的父目录的数量（相对于脚本的目录）。
因此
将当前模块的第N个前身的父目录添加到sys.path从sys.path中删除当前文件的目录使用当前模块的完全限定名称导入当前模块的父模块将__package__设置为2中的完全限定名称执行相对导入
我将从解决方案#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：使用绝对导入和设置工具
步骤如下-
用等价的绝对进口替换显式相对进口安装程序包以使其可导入
例如，目录结构可能如下
.
├── 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
将工作目录更改为project，然后运行/path/to/python/interpreter setup.py install--user（--user在站点包目录中安装包）（步骤2）：
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借用文件并更改标准。py：
在尝试使用绝对导入从包中导入任何内容之前，请将包的父目录添加到sys.path：导入系统从pathlib导入路径#（如果尚未这样做）file=路径（__file__）.resolve（）parent，root=file.parent，file.parents[1]sys.path.append（str（root））#另外，从sys.path中删除当前文件的目录尝试：sys.path.remove（str（父级））除了ValueError:#已删除通过用绝对导入替换相对导入：来自包导入模块#绝对导入
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建议使用绝对进口，但指出在某些情况下，明确的相对进口是可以接受的：
建议使用绝对导入，因为它们通常更可读并且倾向于表现得更好（或至少给出更好的错误消息）。[…]然而，明确的相对进口是可以接受的替代绝对进口，特别是在处理复杂不需要使用绝对导入的包布局冗长的
如果两个包都在您的导入路径（sys.path）中，并且您想要的模块/类在example.example.py中，那么要访问该类而不进行相对导入，请尝试：
from example.example import fkt
为了避免这个问题，我设计了一个重新包装包装的解决方案，这对我来说已经奏效了一段时间。它将上层目录添加到lib路径：
import repackage
repackage.up()
from mypackage.mymodule import myfunction
使用智能策略（检查调用堆栈），重新打包可以在各种情况下进行相对导入。
将其放入包的__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中都有效。
希望这对外面的人来说是有价值的——我浏览了六篇stackoverflow的帖子，试图找出与上面帖子类似的相对进口。我按照建议设置了所有内容，但仍在运行ModuleNotFoundError：没有名为“my_module_name”的模块
由于我只是在本地开发并四处游玩，所以我没有创建/运行setup.py文件。我显然也没有设置我的巨蟒。
我意识到，当我像以前一样运行代码时，当测试与模块位于同一目录中时，我找不到模块：
$ 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测试/my_module/模块测试.py为了避免调用PYTHONPATH=。，创建一个包含如下内容的setup.py文件，并运行python setup.py开发，将包添加到路径中：
#设置.py从setuptools导入安装程序，find_packages设置(name=“示例”，packages=find_packages（）)
我需要从主项目目录运行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
我有一个类似的问题：我需要一个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)
我正在获取此ImportError：尝试在没有已知父包的情况下进行相对导入
在我的程序中，我使用当前路径中的文件导入其函数。
from .filename import function
然后我用包名修改了当前路径（Dot）。这解决了我的问题。
from package_name.filename import function
我希望上面的答案对你有所帮助。
对于PyCharm用户：
我还收到了ImportError：尝试在没有已知父包的情况下进行相对导入，因为我正在添加。表示法来消除PyCharm解析错误。PyCharm错误地报告无法找到：
lib.thing导入函数
如果您将其更改为：
.lib.thing导入函数
它会使错误静音，但随后会出现前面提到的ImportError：尝试相对导入，但没有已知的父包。忽略PyCharm的解析器。这是错误的，代码运行良好，尽管它说了什么。
将要导入的文件移动到外部目录有帮助。当主文件在其自己的目录中生成任何其他文件时，这是非常有用的。前任：之前：
Project
|---dir1
|-------main.py
|-------module1.py
之后：
Project
|---module1.py
|---dir1
|-------main.py
如果以上任何一项都不适用，则可以显式指定模块。
目录：
├── Project
│ ├── Dir
│ │ ├── __init__.py
│ │ ├── module.py
│ │ └── standalone.py
解决方案：
#in standalone.py
from Project.Dir.module import ...
module-要导入的模块
太长，读不下去了通过在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和Terminal中运行项目了！！
我尝试了以上所有方法，但都没有效果，结果发现我的包名中错误地包含了-。
简而言之，在__init__.py所在的目录中不要有-。在发现这样的无意义之后，我从未感到欢欣鼓舞。
我有一个类似的问题，并通过在工作目录中创建一个指向包的符号链接来解决：
在-s../../..中/我的包我的包
然后照常导入：
导入my_package
我知道这更像是“Linux”解决方案，而不是“Python”解决方案。但这仍然是一种有效的方法。
我的样板，以使包中的模块具有可独立运行的相对导入。
包/模块.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“来自包导入模块”独立运行：python package/module.py或者使用shebang（#！/bin/env-python）：package/module.py
NB！如果模块与包同名，则使用sys.path.append而不是sys.path.insert将导致难以跟踪的错误。例如my_script/my_script.py
当然，如果您的包层次结构中有较高级别的相对导入，那么这是不够的，但在大多数情况下，这是可以的。
我在使用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)
这是我的项目结构
├── 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
这是解决方案吗？
TL；DR：给@Aya的答案，用pathlib库更新，并为未定义__file__的Jupyter笔记本工作：
要导入在..下定义的my_function/my_Folder_where_the_package_lives/my_package.py关于您编写代码的位置。
然后执行以下操作：
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
SystemError:未加载父模块“”，无法执行相对导入
这意味着您正在以脚本的形式运行包内的模块。在包中混合脚本是很棘手的，应该尽可能避免。使用包装脚本来导入包并运行脚本函数。
如果您的顶级目录名为foo，位于PYTHONPATH模块搜索路径上，并且您在那里有一个包栏（这是一个需要__init__.py文件的目录），则脚本不应该放在栏中，而应该最好放在foo中。
请注意，脚本与这里的模块不同，因为它们被用作python命令的文件名参数，可以使用python<filename>，也可以通过#！（shebang）线。它直接作为__main__模块加载（这就是为什么__name__==“__main__”：在脚本中工作），并且没有包上下文可用于构建相对导入。
您的选项
如果可以，可以使用setuptools（或po诗或flit，这有助于简化打包）打包项目，并创建控制台脚本入口点；使用pip安装项目，然后创建知道如何正确导入包的脚本。您可以使用pipinstall-e在本地安装软件包。，所以它仍然可以被编辑。否则，永远不要使用python路径/to/packagename/file.py，始终使用python路径/tio/script.py，script.py可以从packagename导入。。。。作为备用方案，可以使用-m命令行开关告诉Python导入一个模块，并将其用作__main__文件。这对于shebang行不起作用，因为已经没有脚本文件了。如果使用python-m foo.bar，并且在sys.path目录中找到foo/bar.py，则会使用正确的包上下文将其导入并作为__main__执行。如果bar也是一个包，在foo/中，它必须有一个__main__.py文件（所以foo/bar/__main__.p是sys.path目录的路径）。在极端情况下，通过直接设置__package__来添加Python用于解析相对导入的元数据；文件foo/bar/spam.py（可作为foo.bar.spam导入）被赋予全局__package__=“foo.bar”。它只是另一个全局文件，如__file__和__name__，在导入时由Python设置。
在sys.path上
以上所有内容都要求您的包可以导入，这意味着它需要在sys.path中列出的目录（或zip文件）中找到。这里也有几个选项：
找到路径/to/script.py的目录（因此路径/to）会自动添加到sys.path。执行python路径/to/foo.py会将路径/to添加到sys_path。如果您打包了项目（使用setuptools、po诗、flit或其他Python打包工具）并安装了它，那么该包已经添加到正确的位置。作为最后的手段，请自己将正确的目录添加到sys.path。如果包可以相对于脚本文件定位，请使用脚本全局命名空间中的__file__变量（例如，使用pathlib.Path对象，HERE=Path（__file__）.resolve（）。parent是文件所在目录的引用，作为绝对路径）。
从同一目录导入
首先，您可以从同一目录导入。
这是文件结构。。。
Folder
|
├─ Scripts
| ├─ module123.py
|
├─ main.py
├─ script123.py
这是main.py
from . import script123
from Scripts import module123
如您所见，从导入。从当前目录导入。
注意：如果使用IDLE以外的任何方法运行，请确保在运行之前将终端导航到与main.py文件相同的目录。
此外，从本地文件夹导入也有效。
从父目录导入
正如我在GitHub中看到的，有以下方法。
采用以下文件树。。。
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
以下解决方案在Python3上进行了测试
├── classes
| |
| ├──__init__.py
| |
│ ├── userclass.py
| | |
| | └--viewDetails()
| |
| |
│ └── groupclass.py
| |
| └--viewGroupDetails()
|
└── start.py
└~~ uses function1()
现在，为了使用userclass的viewDetails或groupclass的viewGroupDetails，首先在无类目录的_init_.py中定义它。
示例：In_init_.py
from .userclasss import viewDetails
from .groupclass import viewGroupDetails
步骤2:现在，在start.py中，我们可以直接导入viewDetails
示例：在start.py中
from classes import viewDetails
from classes import viewGroupDetails
我为Python创建了一个新的实验性导入库：ultraimport
它使程序员能够对导入进行更多的控制，并使其明确无误。此外，当导入失败时，它还会提供更好的错误消息。
它允许您执行相对的、基于文件系统的导入，无论您如何运行代码，也无论您当前的工作目录是什么，这些导入始终有效。运行脚本或模块并不重要。您也不必更改sys.path，这可能会产生其他副作用。
然后你会改变
from .mymodule import myfunction
to
import ultraimport
myfunction = ultraimport('__dir__/mymodule.py', 'myfunction')
这样，即使您将代码作为脚本运行，导入也始终有效。
像这样导入脚本时的一个问题是，后续的相对导入可能会失败。ultraimport有一个内置的预处理器来自动重写相关的导入。
我在尝试编写一个可以作为模块或可执行脚本加载的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代码，因为它包含在docstring中。
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：忽略（注释）第2行：#-*-模式：python-*-可选；这被称为“模式线”；它告诉Emacs使用Python语法高亮显示，而不是在读取文件时猜测语言是Bash。Python:忽略（注释）Bash：忽略（注释）第3行：“”“truePython:将其视为以“true”开头的未分配文档字符串\nBash：将其视为三个扩展为true的字符串（其中前两个是空字符串）（即“+”+“true”=“true”）；然后它运行为true（它什么都不做）并继续到下一行第4行：exec/usr/bin/env python3-m mylib.args_util“$@”Python：仍然将其视为第3行中文档字符串的一部分。Bash：运行python3-m mylib.args_util，然后退出（它不会分析超出这一行的任何内容）第5行：“”Python：将其视为第3行中文档字符串的结尾。Bash：不解析此行
注意事项
这在Windows上不起作用：解决方法：使用WSL或批处理包装脚本调用python-m mylib.args_util。仅当当前工作目录设置为/path/to/project/时，此操作才有效。解决方法：调用/usr/bin/env时设置PYTHONPATH#!/bin/bash#-*-模式：python-*-“”“真的执行/usr/bin/env python3\PYTHONPATH=“$（cd”$（dirname“$0”）/。。“；pwd）”\-m mylib.args_util“$@”'''
对于那些不同意圭多的人，这里有三句话：
import sys
from pathlib import Path
sys.path.append(str(Path(sys.argv[0]).absolute().parent.parent))
希望有帮助。
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
->vendors
->vendors.py
->main.py
我试着这样打电话
from .vendors.Amazon import Amazom_Purchase
这里它抛出了一个错误，所以我只需删除第一个错误就可以修复它。从声明中
from vendors.Amazon import Amazom_Purchase
希望这有帮助。
如果以下导入：
from . import something
不适用于您，这是因为这是python打包导入，不会与您的常规实现一起使用，下面是一个示例来演示如何使用它：
文件夹结构：
.
└── funniest
├── funniest
│ ├── __init__.py
│ └── text.py
├── main.py
└── setup.py
内部__init__.py添加：
def available_module():
return "hello world"
text.py添加：
from . import available_module
在setup.py中添加
from setuptools import setup
setup(name='funniest',
version='0.1',
description='The funniest joke in the world',
url='http://github.com/storborg/funniest',
author='Flying Circus',
author_email='flyingcircus@example.com',
license='MIT',
packages=['funniest'],
zip_safe=False)
现在，这是安装软件包最重要的部分：
pip install .
在我们的系统中使用相同Python的任何地方，我们现在都可以这样做：
>> import funnies.text as fun
>> fun.available_module()
这应该输出“hello world”
您可以在main.py中测试它（这不需要安装任何软件包）
这也是main.py
import funniest.text as fun
print(fun.available_module())
