存在同名模块时从内置库导入

Question

情况： - 我的 project_folder 中有一个名为 calendar 的模块 - 我想使用 Python 库中的内置日历类 - 当我使用 from calendar import Calendar 时，它会抱怨，因为它试图从我的模块加载。

我进行了几次搜索，但似乎找不到解决问题的方法。

• How to access a standard-library module in Python when there is a local module with the same name?
• http://docs.python.org/whatsnew/2.5.html
• How to avoid writing the name of the module all the time when importing a module in python?

无需重命名我的模块有什么想法吗？

Answer 1

不需要更改模块的名称。相反，您可以使用 absolute_import 来更改导入行为。例如stem/socket.py，我按如下方式导入套接字模块：

from __future__ import absolute_import
import socket

这仅适用于 Python 2.5 及更高版本；它启用了 Python 3.0 及更高版本中的默认行为。 Pylint 会抱怨代码，但它完全有效。

Answer 2

其实解决这个问题比较容易，但是实现总是有点脆弱，因为它依赖于python导入机制的内部，并且在未来的版本中可能会发生变化。

（以下代码显示了如何加载本地和非本地模块以及它们如何共存）

def import_non_local(name, custom_name=None):
    import imp, sys

    custom_name = custom_name or name

    f, pathname, desc = imp.find_module(name, sys.path[1:])
    module = imp.load_module(custom_name, f, pathname, desc)
    f.close()

    return module

# Import non-local module, use a custom name to differentiate it from local
# This name is only used internally for identifying the module. We decide
# the name in the local scope by assigning it to the variable calendar.
calendar = import_non_local('calendar','std_calendar')

# import local module normally, as calendar_local
import calendar as calendar_local

print calendar.Calendar
print calendar_local

如果可能的话，最好的解决方案是避免使用与标准库或内置模块名称相同的名称来命名您的模块。

Answer 3

解决此问题的唯一方法是自己劫持内部导入机制。这并不容易，而且充满危险。你应该不惜一切代价避免圣杯形状的信标，因为危险太危险了。

改为重命名您的模块。

如果您想了解如何劫持内部导入机制，您可以在这里了解如何做到这一点：

• The Importing Modules section of the Python 2.7 documentation
• The Importing Modules section of the Python 3.2 documentation
• PEP 302 - New Import Hooks

有时有充分的理由陷入这种危险之中。你给出的理由不在其中。重命名你的模块。

如果你走上危险的道路，你会遇到的一个问题是，当你加载一个模块时，它会以一个“官方名称”结束，这样 Python 就可以避免再次解析该模块的内容。模块的“官方名称”到模块对象本身的映射可以在sys.modules中找到。

这意味着如果你在一个地方import calendar，任何导入的模块都将被认为是正式名称为calendar的模块，以及在其他任何地方对import calendar的所有其他尝试，包括在其他代码中的主要 Python 库，将获得该日历。

也许可以使用 Python 2.x 中的 imputil module 设计一个客户导入器，这会导致从某些路径加载的模块首先在 sys.modules 以外的其他地方查找它们正在导入的模块或类似的东西。但这是一件非常麻烦的事情，而且无论如何它在 Python 3.x 中都行不通。

你可以做一件极其丑陋和可怕的事情，它不涉及挂钩导入机制。这是您可能不应该做的事情，但它可能会起作用。它将您的calendar 模块变成系统日历模块和日历模块的混合体。感谢Boaz Yaniv 提供skeleton of the function I use。将其放在您的 calendar.py 文件的开头：

import sys

def copy_in_standard_module_symbols(name, local_module):
    import imp

    for i in range(0, 100):
        random_name = 'random_name_%d' % (i,)
        if random_name not in sys.modules:
            break
        else:
            random_name = None
    if random_name is None:
        raise RuntimeError("Couldn't manufacture an unused module name.")
    f, pathname, desc = imp.find_module(name, sys.path[1:])
    module = imp.load_module(random_name, f, pathname, desc)
    f.close()
    del sys.modules[random_name]
    for key in module.__dict__:
        if not hasattr(local_module, key):
            setattr(local_module, key, getattr(module, key))

copy_in_standard_module_symbols('calendar', sys.modules[copy_in_standard_module_symbols.__module__])

Answer 4

接受的解决方案包含现已弃用的方法。

importlib 文档here 提供了一个很好的示例，说明了直接从 python >= 3.5 的文件路径加载模块的更合适方法：

import importlib.util
import sys

# For illustrative purposes.
import tokenize
file_path = tokenize.__file__  # returns "/path/to/tokenize.py"
module_name = tokenize.__name__  # returns "tokenize"

spec = importlib.util.spec_from_file_location(module_name, file_path)
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
spec.loader.exec_module(module)

因此，您可以从路径加载任何 .py 文件并将模块名称设置为您想要的任何名称。因此，只需将 module_name 调整为您希望模块在导入时具有的任何自定义名称。

要加载一个包而不是单个文件，file_path 应该是包的根路径__init__.py

Answer 5

我想提供我的版本，它结合了 Boaz Yaniv 和 Omnifarious 的解决方案。它将导入模块的系统版本，与之前的答案有两个主要区别：

• 支持“点”表示法，例如。 package.module
• 是系统模块上 import 语句的直接替换，这意味着您只需替换那一行，如果已经对模块进行了调用，它们将按原样工作

把它放在可以访问的地方，这样你就可以调用它（我的 __init__.py 文件中有我的）：

class SysModule(object):
    pass

def import_non_local(name, local_module=None, path=None, full_name=None, accessor=SysModule()):
    import imp, sys, os

    path = path or sys.path[1:]
    if isinstance(path, basestring):
        path = [path]

    if '.' in name:
        package_name = name.split('.')[0]
        f, pathname, desc = imp.find_module(package_name, path)
        if pathname not in __path__:
            __path__.insert(0, pathname)
        imp.load_module(package_name, f, pathname, desc)
        v = import_non_local('.'.join(name.split('.')[1:]), None, pathname, name, SysModule())
        setattr(accessor, package_name, v)
        if local_module:
            for key in accessor.__dict__.keys():
                setattr(local_module, key, getattr(accessor, key))
        return accessor
    try:
        f, pathname, desc = imp.find_module(name, path)
        if pathname not in __path__:
            __path__.insert(0, pathname)
        module = imp.load_module(name, f, pathname, desc)
        setattr(accessor, name, module)
        if local_module:
            for key in accessor.__dict__.keys():
                setattr(local_module, key, getattr(accessor, key))
            return module
        return accessor
    finally:
        try:
            if f:
                f.close()
        except:
            pass

示例

我想导入 mysql.connection，但我有一个本地包已经称为 mysql（官方 mysql 实用程序）。所以为了从系统mysql包中获取连接器，我替换了这个：

import mysql.connector

有了这个：

import sys
from mysql.utilities import import_non_local         # where I put the above function (mysql/utilities/__init__.py)
import_non_local('mysql.connector', sys.modules[__name__])

结果

# This unmodified line further down in the file now works just fine because mysql.connector has actually become part of the namespace
self.db_conn = mysql.connector.connect(**parameters)

Answer 6

更改导入路径：

import sys
save_path = sys.path[:]
sys.path.remove('')
import calendar
sys.path = save_path