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

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

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

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

除非变量旨在成为常量，否则不要使用 import。 将创建一个新变量，该变量初始化为导入时引用的任何内容，并且此新变量不会受到赋值 的影响。fromfrom shared_stuff import aashared_stuff.aashared_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）

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

导入模块

module.addglobals（全局（））

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

main.py：

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

mymodule.py：

import os

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

作为额外的预防措施，当模块中未定义 MYVAL 时，请处理这种情况。

由于我在上面的答案中没有看到它，我想我会添加我的简单解决方法，即为需要调用模块的全局变量的函数添加一个参数，然后在调用时将字典传递到函数中;例如：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

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

更新

为了测试这个理论，我创建了一个模块并将其放在 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，这并不重要。

这仍然是一种糟糕的形式，也是一种不好的做法，但有时它更容易。尤其是当你编写的代码不会有很长的寿命时。