导入模块中全局变量的可见性[重复]

问题描述：

我在 Python 脚本中导入模块时遇到了一些困难。我会尽力描述错误、为什么会遇到错误以及为什么我要采用这种特殊方法来解决我的问题（我将在稍后描述）：

假设我有一个模块，其中定义了一些实用函数/类，它们引用了将导入此辅助模块的命名空间中定义的实体（让“a”成为这样的实体）：

模块1：

def f():
    print a

然后我有主程序，其中定义了“a”，我想将这些实用程序导入到其中：

import module1
a=3
module1.f()

执行该程序将引发以下错误：

Traceback (most recent call last):
  File "Z:Pythonmain.py", line 10, in <module>
    module1.f()
  File "Z:Pythonmodule1.py", line 3, in f
    print a
NameError: global name 'a' is not defined

过去（两天前，呃）有人问过类似的问题，也提出了几种解决方案，但我认为这些解决方案都不符合我的要求。以下是我的具体情况：

我正在尝试编写一个 Python 程序，该程序连接到 MySQL 数据库服务器并使用 GUI 显示/修改数据。为了简洁起见，我在一个单独的文件中定义了一组辅助/实用程序 MySQL 相关函数。但是它们都有一个公共变量，我最初在实用程序模块中定义了该变量，它是来自 MySQLdb 模块的游标对象。后来我意识到游标对象（用于与数据库服务器通信）应该在主模块中定义，以便主模块和导入到其中的任何内容都可以访问该对象。

最终结果可能是这样的：

实用程序模块.py：

def utility_1(args):
    code which references a variable named "cur"
def utility_n(args):
    etcetera

我的主要模块：

程序.py：

import MySQLdb, Tkinter
db = MySQLdb.connect('blahblah...')
cur = db.cursor()  # cur is defined!
from utilities_module import *

然后，只要我尝试调用任何实用程序函数，它就会触发前面提到的“全局名称未定义”错误。

一个特别的建议是在实用程序文件中添加一条from program import cur声明，例如：

实用程序模块.py：

from program import cur
#rest of function definitions

但这是循环导入或类似的东西，而且归根结底，它也会崩溃。所以我的问题是：

我到底怎样才能让cur主模块中定义的对象对导入的辅助函数可见呢？

解决方案 1：

Python 中的全局变量对于模块来说是全局的，而不是对所有模块都是全局的。（很多人对此感到困惑，因为在 C 语言中，除非你明确说明，否则全局变量在所有实现文件中都是相同的static。）

有不同的方法可以解决这个问题，具体取决于您的实际使用情况。

在开始之前，先问问自己这是否真的需要全局化。也许你真的想要一个类，f作为实例方法，而不仅仅是一个自由函数？那么你可以这样做：

import module1
thingy1 = module1.Thingy(a=3)
thingy1.f()

如果您确实想要一个全局的，但它只是被使用module1，请在该模块中设置它。

import module1
module1.a=3
module1.f()

另一方面，如果a被很多模块共享，则将其放在其他地方，并让每个人都导入它：

import shared_stuff
import module1
shared_stuff.a = 3
module1.f()

…并且，在module1.py中：

import shared_stuff
def f():
    print shared_stuff.a

from除非变量旨在作为常量，否则不要使用导入。from shared_stuff import a将创建一个新a变量，该变量初始化为shared_stuff.a导入时引用的任何内容，并且这个新a变量不会受到赋值的影响shared_stuff.a。

或者，在极少数情况下，您确实需要它像内置模块一样真正在任何地方都是全局的，请将其添加到内置模块中。 Python 2.x 和 3.x 之间的确切细节有所不同。 在 3.x 中，它的工作原理如下：

import builtins
import module1
builtins.a = 3
module1.f()

解决方案 2：

作为一种解决方法，您可以考虑在外层设置环境变量，如下所示。

主要文件：

import os
os.environ['MYVAL'] = str(myintvariable)

我的模块.py：

import os

myval = None
if 'MYVAL' in os.environ:
    myval = os.environ['MYVAL']

作为额外的预防措施，处理 MYVAL 未在模块内部定义的情况。

解决方案 3：

这篇文章只是我遇到的 Python 行为的观察。如果你做了和我下面一样的事情，那么上面读到的建议可能对你不起作用。

即，我有一个包含全局/共享变量的模块（如上所述）：

#sharedstuff.py

globaltimes_randomnode=[]
globalist_randomnode=[]

然后我有了使用以下代码导入共享内容的主模块：

import sharedstuff as shared

以及一些实际填充这些数组的其他模块。这些由主模块调用。退出这些其他模块时，我可以清楚地看到数组已填充。但是当在主模块中读回它们时，它们是空的。这对我来说相当奇怪（好吧，我是 Python 新手）。但是，当我将主模块中导入 sharedstuff.py 的方式更改为：

from globals import *

它起作用了（数组已填充）。

只是说

解决方案 4：

函数使用其定义a = 3模块的全局变量。例如，您不应该设置 ，而应该设置module1.a = 3。因此，如果您希望cur在 中将其用作全局变量utilities_module，请设置utilities_module.cur。

更好的解决方案：不要使用全局变量。将所需的变量传递到需要它的函数中，或者创建一个类来将所有数据捆绑在一起，并在初始化实例时传递它。

解决方案 5：

解决这一特定问题最简单的方法是在模块中添加另一个函数，将光标存储在模块的全局变量中。然后所有其他函数也可以使用它。

模块1：

cursor = None

def setCursor(cur):
    global cursor
    cursor = cur

def method(some, args):
    global cursor
    do_stuff(cursor, some, args)

主程序：

import module1

cursor = get_a_cursor()
module1.setCursor(cursor)
module1.method()

解决方案 6：

由于全局变量是特定于模块的，您可以将以下函数添加到所有导入的模块，然后使用它来：

• 添加单数变量（字典格式）作为全局变量

• 将您的主模块全局变量传输给它。

添加全局变量 = lambda x: globals().update(x)

然后您需要传递当前全局变量的是：

导入模块

模块.添加全局变量（globals()）

解决方案 7：

更新

为了测试这个理论，我创建了一个模块并将其放在 pypi 上。一切都运行良好。

pip install superglobals

简短回答

这在 Python 2 或 3 中可以正常工作：

import inspect

def superglobals():
    _globals = dict(inspect.getmembers(
                inspect.stack()[len(inspect.stack()) - 1][0]))["f_globals"]
    return _globals

另存为superglobals.py并在另一个模块中使用：

from superglobals import *

superglobals()['var'] = value

扩展答案

您可以添加一些额外的功能，使其更具吸引力。

def superglobals():
    _globals = dict(inspect.getmembers(
                inspect.stack()[len(inspect.stack()) - 1][0]))["f_globals"]
    return _globals

def getglobal(key, default=None):
    """
    getglobal(key[, default]) -> value
    
    Return the value for key if key is in the global dictionary, else default.
    """
    _globals = dict(inspect.getmembers(
                inspect.stack()[len(inspect.stack()) - 1][0]))["f_globals"]
    return _globals.get(key, default)

def setglobal(key, value):
    _globals = superglobals()
    _globals[key] = value

def defaultglobal(key, value):
    """
    defaultglobal(key, value)

    Set the value of global variable `key` if it is not otherwise st
    """
    _globals = superglobals()
    if key not in _globals:
        _globals[key] = value

然后如此使用：

from superglobals import *

setglobal('test', 123)
defaultglobal('test', 456)
assert(getglobal('test') == 123)

理由

“python纯度联盟”对这个问题的回答是完全正确的，但在某些环境（例如IDAPython）中，它基本上是单线程的，具有大型全局实例化API，所以这并不那么重要。

这仍然是不好的形式，也不值得鼓励，但有时这样做更容易。尤其是当你编写的代码不会有很长的生命周期时。

解决方案 8：

由于我没有在上面的答案中看到它，我想我会添加我的简单解决方法，即只向global_dict需要调用模块的全局变量的函数添加一个参数，然后在调用时将字典传递给函数；例如：

# external_module
def imported_function(global_dict=None):
    print(global_dict["a"])


# calling_module
a = 12
from external_module import imported_function
imported_function(global_dict=globals())

>>> 12

解决方案 9：

实现此目的的 OOP 方法是将模块变成一个类，而不是一组未绑定的方法。然后，您可以使用__init__或 setter 方法来设置来自调用者的变量，以供模块方法使用。

解决方案 10：

您可以从父模块调用的函数内部使用......

import inspect


def caller_globals(key):
    return inspect.currentframe().f_back.f_globals.get(key, None)

我尝试了检查模块中的几种不同方法来做类似的事情，但我发现，除非在调用模块调用的函数中使用，否则大多数方法都是无用的。

另外，如果您在 a 内部使用它module0.module1.module2.func并且想要来自 module0 的全局变量，那么...

from inspect import currentframe
from types import FrameType


def caller_globals(f_back: FrameType) -> dict:
    if 'module0.py' not in f_back.f_globals['__file__']:
        f_back = caller_globals(f_back = f_back.f_back)

    return f_back.f_globals


f_globals = caller_globals(f_back = currentframe().f_back)