7

以下是此测试中的文件：

main.py
app/
 |- __init__.py
 |- master.py
 |- plugin/
 |-  |- __init__.py
 |-  |- p1.py
 |-  |_ p2.py

我们的想法是拥有一个支持插件的应用程序。可以将新的 .py 或 .pyc 文件放入符合我的 API 的插件中。

我master.py在应用程序级别有一个文件，其中包含任何和所有插件可能需要访问的全局变量和函数，以及应用程序本身。就本测试而言，“app”由 app/__init__.py 中的一个测试函数组成。在实践中，应用程序可能会被移动到单独的代码文件中，但是我只是import master在该代码文件中使用来引入对master.

这是文件内容：

主要.py：

import app

app.test()
app.test2()

应用程序/__init__.py：

import sys, os

from plugin import p1

def test():
        print "__init__ in app is executing test"
        p1.test()

def test2():
        print "__init__ in app is executing test2"
        scriptDir = os.path.join ( os.path.dirname(os.path.abspath(__file__)), "plugin" )
        print "The scriptdir is %s" % scriptDir
        sys.path.insert(0,scriptDir)
        m = __import__("p2", globals(), locals(), [], -1)
        m.test()

应用程序/master.py：

myVar = 0

应用程序/插件/__init__.py：

<empty file>

应用程序/插件/p1.py：

from .. import master

def test():
    print "test in p1 is running"
    print "from p1: myVar = %d" % master.myVar

应用程序/插件/p2.py：

from .. import master

def test():
    master.myVar = 2
    print "test in p2 is running"
    print "from p2, myVar: %d" % master.myVar

由于我明确导入了p1模块，所以一切都按预期工作。但是，当我使用__import__导入 p2 时，出现以下错误：

__init__ in app is executing test
test in p1 is running
from p1: myVar = 0
__init__ in app is executing test2
The scriptdir is ....../python/test1/app/plugin
Traceback (most recent call last):
  File "main.py", line 4, in <module>
    app.test2()
  File "....../python/test1/app/__init__.py", line 17, in test2
    m = __import__("p2", globals(), locals(), [], -1)
  File "....../python/test1/app/plugin/p2.py", line 1, in <module>
    from .. import master
ValueError: Attempted relative import in non-package

执行一直通过 test() 函数并在 test2() 尝试执行其__import__语句时立即出错，而 p2 又尝试执行相对导入（当 p1 通过 import 语句显式导入时确实有效，回想一下)

很明显， using__import__所做的事情与 usingimport语句不同。Python 文档指出，使用 import 只是在__import__内部转换为语句，但必须进行更多的操作而不是看起来。

由于该应用程序是基于插件的，因此在主应用程序中编写显式导入语句当然是不可行的。在

我在这里想念什么？使用手动导入模块时，如何让 Python 表现得如预期__import__？似乎我可能没有完全理解相对导入的想法，或者我只是缺少关于导入发生位置的一些东西（即在函数内部而不是在代码文件的根目录）

编辑：我发现了以下可能但不成功的解决方案：

m = __import__("p2",globals(),locals(),"plugin")

（返回与上面相同的错误）

m = __import__("plugin",fromlist="p2")

（返回对 app.plugin 的引用，而不是对 app.plugin.p2 的引用）

m = __import__("plugin.p2",globals(),locals())

（返回对 app.plugin 的引用，而不是对 app.plugin.p2 的引用）

import importlib
m = importlib.import_module("plugin.p2")

（返回：）

Traceback (most recent call last):
  File "main.py", line 4, in <module>
    app.test2()
  File "....../python/test1/app/__init__.py", line 20, in test2
    m = importlib.import_module("plugin.p2")
  File "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/importlib/__init__.py", line 37, in import_module
    __import__(name)
ImportError: No module named plugin.p2
4

3 回答 3

5

我有一个类似的问题。
__import__仅当所有父__init__.py文件为空时才导入子模块。您应该改用 importlib

import importlib

p2 = importlib.import_module('plugin.p2')
于 2013-06-27T13:57:20.077 回答
2

您是否尝试过以下语法：

如何正确使用python的import函数__import__()

它对我有类似的问题...

于 2014-11-27T11:14:36.483 回答
1

我从来没有找到解决方案，所以我最终决定重组程序。

我所做的是将主应用程序设置为一个类。然后，我还把每个插件都改成了一个类。然后，当我使用import加载插件时，我还会在每个插件中实例化具有预定义名称的类，并传入对主应用程序类的引用。

这意味着每个类都可以通过引用直接读取和操作宿主类中的变量。它非常灵活，因为所有插件都可以访问主机类导出的任何内容。

事实证明这更有效，并且不依赖于相对路径和任何其他东西。这也意味着理论上一个 Python 解释器可以同时运行宿主应用程序的多个实例（例如在不同的线程上），并且插件仍然会引用正确的宿主实例。

这基本上是我所做的：

主要.py：

import os, os.path, sys

class MyApp:

    _plugins = []

    def __init__(self):
        self.myVar = 0

    def loadPlugins(self):
        scriptDir = os.path.join ( os.path.dirname(os.path.abspath(__file__)), "plugin" )   
        sys.path.insert(0,scriptDir)
        for plug in os.listdir(scriptDir):
            if (plug[-3:].lower() == ".py"):
                m = __import__(os.path.basename(plug)[:-3])
                self._plugins.append(m.Plugin(self))

    def runTests(self):
        for p in self._plugins:
            p.test()

if (__name__ == "__main__"):
    app = MyApp()
    app.loadPlugins()
    app.runTests()

插件/p1.py：

class Plugin:

    def __init__(self, host):
        self.host = host

    def test(self):
        print "from p1: myVar = %d" % self.host.myVar

插件/p2.py：

class Plugin:

    def __init__(self, host):
        self.host = host

    def test(self):
        print "from p2: variable set"
        self.host.myVar = 1
        print "from p2: myVar = %d" % self.host.myVar

有一些改进的空间，例如，验证每个导入的 .py 文件以查看它是否实际上是一个插件等等。但这按预期工作。

于 2013-06-30T00:18:55.797 回答