导入模块中全局变量的可见性

我在导入 Python 脚本中的模块时遇到了一些困难。我会尽力描述这个错误，为什么我会遇到它，以及为什么我要用这个特殊的方法来解决我的问题(我将在下面描述) :

假设我有一个模块，其中定义了一些实用函数/类，这些函数/类引用了名称空间中定义的实体，这个辅助模块将被导入到这个名称空间中(假设“ a”是这样一个实体) :

单元1:

def f():
print a

然后我有一个主程序，其中定义了“ a”，我想把这些实用程序导入其中:

import module1
a=3
module1.f()

执行程序将触发以下错误:

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

在过去(两天前，d’uh)也有人问过类似的问题，也有人提出了一些解决方案，但我并不认为这些方案真的符合我的要求。以下是我的特殊背景:

我正在尝试制作一个 Python 程序，它可以连接到 MySQL 数据库服务器，并用 GUI 显示/修改数据。为了简洁起见，我在一个单独的文件中定义了一组辅助/实用 MySQL 相关函数。但是它们都有一个公共变量，我最初定义的是 在里面实用程序模块，它是来自 MySQLdb 模块的 光标对象。 后来我意识到 光标对象(用于与数据库服务器通信)应该在 main 模块 < strong > 中定义，这样主模块和导入到它的任何东西都可以访问该对象。

最终结果会是这样的:

Utilities _ module. 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”语句，例如:

Utilities _ module. py:

from program import cur
#rest of function definitions

Py:

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

但是这是循环导入或者类似的东西，底线是，它也崩溃了，所以我的问题是:

我到底怎样才能使“ cur”对象(定义在主模块中)对导入到其中的辅助函数可见？

感谢您的时间和我最深切的道歉，如果解决方案已被张贴在其他地方。我只是自己找不到答案，我的书里也没有更多的把戏了。

206932 次浏览
小开

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

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

小开
最佳答案

Python 中的 Globals 是全局 一个模块，而不是跨所有模块。(许多人对此感到困惑，因为在 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()

在模块1.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()
小开

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

也就是说，我有一个包含全局/共享变量(如上所述)的模块:

#sharedstuff.py


globaltimes_randomnode=[]
globalist_randomnode=[]

然后我有了导入共享内容的主模块:

import sharedstuff as shared

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

from globals import *

它工作(数组被填充)。

说说而已

小开

这个特殊问题的最简单的解决方案是在模块中添加另一个函数，该函数将游标存储在模块的全局变量中。那么所有其他函数也可以使用它。

单元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()
小开

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

  • 添加单数变量(字典格式)作为这些变量的全局变量
  • 将 总台模块的全局变量传输给它 .

Addglobals = lambda x: globals () . update (x)

那么，你需要传递给当前全球化的信息是:

导入模块

Addglobals (globals ())

小开

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

Py:

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

Py:

import os


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

作为额外的预防措施，处理模块中没有定义 MYVAL 的情况。

小开

因为我还没有在上面的答案中看到它，所以我想我应该添加一个简单的解决方案，就是在需要调用模块的全局变量的函数中添加一个 global_dict参数，然后在调用时将 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
小开

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

小开

更新

为了验证这个理论，我创建了一个模块，并把它放在 Pypi 上。

pip install superglobals

长话短说

这在 Python2或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 的单线程环境，它只是 没那么重要。

这仍然是不好的形式和鼓励的坏习惯，但有时它只是更容易。特别是当您正在编写的代码不会有很长的生命时。


提交答案