GVKun编程网logo

python中的绝对导入不起作用，相对导入起作用（python中的绝对导入不起作用,相对导入起作用的方法）

17

对于想了解python中的绝对导入不起作用，相对导入起作用的读者，本文将是一篇不可错过的文章，我们将详细介绍python中的绝对导入不起作用,相对导入起作用的方法，并且为您提供关于python2.5中

对于想了解python中的绝对导入不起作用，相对导入起作用的读者，本文将是一篇不可错过的文章，我们将详细介绍python中的绝对导入不起作用,相对导入起作用的方法，并且为您提供关于python 2.5中的相对导入、Python 3 中的相对导入、Python 3中的相对导入、python 包的相对导入与绝对导入使用的有价值信息。

本文目录一览：

python中的绝对导入不起作用，相对导入起作用（python中的绝对导入不起作用,相对导入起作用的方法）

python中的绝对导入不起作用，相对导入起作用（python中的绝对导入不起作用,相对导入起作用的方法）

我似乎无法让绝对导入在python中工作。这是我的文件结构：

a/  b/    __init__.py  __init__.py  foo.py

foo.py：

# Including or removing the __future__ import has no effectfrom __future__ import absolute_importfrom a import b  # just `import b` works fineprint "success!"

我反而得到：

ImportError: No module named a

这到底是怎么回事？我觉得我缺少基本的东西。尽管这个例子很简单，但我需要绝对导入才能为实际项目工作，因此仅用相对导入替换导入是不可行的。我正在使用python
2.7.13

预先感谢您的任何见解！

答案1

小编典典

由于未显示，因此我必须假设您正在运行pythona/foo.py，这会将脚本（''a''）的目录放在开始的位置sys.path，而实际上您希望将当前目录放在的开始sys.path。

您应该运行python -m a.foo它将正确初始化sys.path项目结构的根目录。

这是我以其他方式写过的更深入的论文，这个问题可以解决。

python 2.5中的相对导入

python 2.5中的相对导入

我知道在Python中有很多关于相同导入问题的问题，但是似乎没有人能够提供正确用法的清晰示例。

比方说，我们有一个包mypackage有两个模块foo和bar。在内部，foo我们需要能够访问bar。

因为我们仍在开发中，mypackage所以不在中sys.path。

我们希望能够：

  • 进口 mypackage.foo
  • foo.py作为脚本运行，并执行本部分中的示例用法或测试__main__。
  • 使用Python 2.5

我们必须如何在foo.py中进行导入，以确保它在所有这些情况下都可以工作。

# mypackage/__init__.py...# mypackage/foo/__init__.py...# mypackage/bar.py  def doBar()    print("doBar")# mypackage/foo/foo.pyimport bar # fails with module not foundimport .bar #fails due to ValueError: Attempted relative import in non-packagedef doFoo():    print(doBar())if __name__ == ''__main__'':    doFoo()

答案1

小编典典

查看来自PEP 328的以下信息：

相对导入使用模块的__name__属性来确定该模块在包层次结构中的位置。如果模块的名称不包含任何程序包信息（例如，将其设置为’main‘），则相对导入的解析就好像该模块是顶级模块一样，无论该模块实际位于文件系统上的哪个位置。

当您foo.py以脚本运行时，该模块的__name__是’main‘，因此您无法进行相对导入。即使mypackage开启了，这也是正确的sys.path。基本上，您只能从模块导入相对导入。

以下是解决此问题的几种选择：

1）在中foo.py，检查是否__name__ == ‘main‘有条件地添加mypackage到sys.path：

if __name__ == ''__main__'':    import os, sys    # get an absolute path to the directory that contains mypackage    foo_dir = os.path.dirname(os.path.join(os.getcwd(), __file__))    sys.path.append(os.path.normpath(os.path.join(foo_dir, ''..'', ''..'')))    from mypackage import barelse:

2）始终bar使用导入from mypackage import bar，并foo.py以一种mypackage自动可见的方式执行：

$ cd <path containing mypackage>

$ python -m mypackage.foo.foo

Python 3 中的相对导入

Python 3 中的相对导入

我想从同一目录中的另一个文件导入一个函数。

有时它对我有用，from .mymodule import myfunction但有时我得到：

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

有时它适用于from mymodule import myfunction，但有时我也会得到：

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

我不明白这里的逻辑，我找不到任何解释。这看起来完全随机。

有人可以向我解释这一切背后的逻辑是什么吗？

答案1

小编典典

不幸的是，这个模块需要在包中，有时它还需要作为脚本运行。知道我怎么能做到这一点吗？

有这样的布局很常见......

main.pymypackage/    __init__.py    mymodule.py    myothermodule.py

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

#!/usr/bin/env python3# Exported functiondef as_int(a):    return int(a)# Test function for module  def _test():    assert as_int(''1'') == 1if __name__ == ''__main__'':    _test()

……myothermodule.py像这样……

#!/usr/bin/env python3from .mymodule import as_int# Exported functiondef add(a, b):    return as_int(a) + as_int(b)# Test function for module  def _test():    assert add(''1'', ''1'') == 2if __name__ == ''__main__'':    _test()

……还有main.py这样的……

#!/usr/bin/env python3from mypackage.myothermodule import adddef 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.

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

from mymodule import as_int

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

from mypackage.mymodule import as_int

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

import sysimport osSCRIPT_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
写的电子邮件中，有一个线索可以解释为什么......

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

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

Python 3中的相对导入

Python 3中的相对导入

我想从同一目录中的另一个文件导入函数。

有时它对我有用，from .mymodule import myfunction但有时我得到：

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

有时它可与一起使用from mymodule import myfunction，但有时我也会得到：

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

我不了解这里的逻辑，也找不到任何解释。这看起来完全是随机的。

有人可以向我解释所有这些背后的逻辑是什么？

答案1

小编典典

不幸的是，该模块需要位于程序包内部，有时还需要作为脚本运行。知道如何实现吗？

像这样的布局很普遍…

main.pymypackage/    __init__.py    mymodule.py    myothermodule.py

… mymodule.py像这样…

#!/usr/bin/env python3# Exported functiondef as_int(a):    return int(a)# Test function for module  def _test():    assert as_int(''1'') == 1if __name__ == ''__main__'':    _test()

......一个myothermodule.py像这样…

#!/usr/bin/env python3from .mymodule import as_int# Exported functiondef add(a, b):    return as_int(a) + as_int(b)# Test function for module  def _test():    assert add(''1'', ''1'') == 2if __name__ == ''__main__'':    _test()

… main.py这样的…

#!/usr/bin/env python3from mypackage.myothermodule import adddef 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

…但是它有点冗长，并且无法与诸如的shebang行混合使用#!/usr/bin/env python3。

假设名称mymodule在全球范围内是唯一的，这种情况下最简单的解决方法是避免使用相对导入，而只需使用…

from mymodule import as_int

…尽管它不是唯一的，或者您的包结构更复杂，您仍需要在中包含包含包目录的目录PYTHONPATH，并按以下步骤进行操作…

from mypackage.mymodule import as_int

…或者如果您希望它“开箱即用”工作，则可以PYTHONPATH使用此方法首先获取in代码…

import sysimport osPACKAGE_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)))from mypackage.mymodule import as_int

这有点痛苦，但是有一个线索可以说明为什么某位Guido van Rossum写的电子邮件中 …

我对此表示怀疑，也对任何其他提议的__main__ 机械装置都为-1 。唯一的用例似乎是正在运行的脚本，它们恰好位于模块的目录中，我一直将其视为反模式。为了让我改变主意，您必须说服我不要。

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

python 包的相对导入与绝对导入使用

python 包的相对导入与绝对导入使用

一、错误使用，造成的错误描述如下：

ModuleNotFoundError: No module named ''__main__.operation''; ''__main__'' is not a package

ModuleNotFoundError: No module named ''operation''

ValueError: attempted relative import beyond top-level package
 

二、实例目录结构：

cur_path
│
├─packages
│   ├─__init__.py
│   ├─ui.py
│   │
│   ├─operation
│   │    ├─__init__.py
│   │    ├─mixed_operation.py
│   │    └─simple_operation.py
│   │
│   └─util
│       ├─__init__.py
│       ├─add.py
│       ├─div.py
│       ├─mul.py
│       └─sub.py
└─main.py

三、示例：

1、main.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from packages.ui import main
if __name__ == "__main__":
    main()

2、packages/ui.py

from .operation.mixed_operation import mix
def main():
    mix()
if __name__ == "__main__":
    main()

3、packages/operation/mixed_operation.py

from .simple_operation import *
def mix():
    num = one_add_two() + three_mul_four() + five_sub_six() + seven_sub_eight()
    print("1 + 2 + 3 * 4 + 5 - 6 + 7 / 8 = ", num)

4、packages/operation/simple_operation.py

from ..util.add import add
from ..util.sub import sub
from ..util.mul import mul
from ..util.div import div
def one_add_two():
    return add(1, 2)
    
def three_mul_four():
    return mul(3, 4)
    
def five_sub_six():
    return sub(5, 6)
    
def seven_sub_eight():
    return div(7, 8)
    
__all__ = ["one_add_two", "three_mul_four", "five_sub_six", "seven_sub_eight"]

5、packages/util/add.py

def add(a, b):
    return a + b

6、packages/util/div.py

def div(a, b):
    return a / b

7、packages/util/mul.py

def mul(a, b):
    return a * b

8、packages/util/sub.py

def sub(a, b):
    return a - b

四、运行方式：

1、正确运行方式：

python -m packages.ui
python main.py

2、错误运行方式以及错误描述

# 直接运行的脚本中不能含有相对导入
python packages/ui.py
Traceback (most recent call last):
  File "packages/ui.py", line 6, in <module>
    from .operation.mixed_operation import mix
ModuleNotFoundError: No module named ''__main__.operation''; ''__main__'' is not a package
################################

# 模块方式，引入当前需要添加.号
# ui.py中的from后没有.
python -m packages.ui
packages\ui.py", line 3, in <module>
    from operation.mixed_operation import mix
ModuleNotFoundError: No module named ''operation''

 

 

 

今天关于python中的绝对导入不起作用，相对导入起作用和python中的绝对导入不起作用,相对导入起作用的方法的分享就到这里，希望大家有所收获，若想了解更多关于python 2.5中的相对导入、Python 3 中的相对导入、Python 3中的相对导入、python 包的相对导入与绝对导入使用等相关知识，可以在本站进行查询。

本文标签：

上一篇为什么numpy.zeros占用很少的空间（numpy数据占用内存空间大小）

下一篇Python，安装matplotlib时出错（python安装matplotlib库出错）

相关文章