如何在 Python 中创建模块范围的变量？ [复制]

Question

有没有办法在模块内部设置一个全局变量？当我尝试以最明显的方式进行操作时，Python 解释器说变量 __DBNAME__ 不存在。

...
__DBNAME__ = None

def initDB(name):
    if not __DBNAME__:
        __DBNAME__ = name
    else:
        raise RuntimeError("Database name has already been set.")
...

在将模块导入另一个文件后

...
import mymodule
mymodule.initDB('mydb.sqlite')
...

回溯是：

... UnboundLocalError：分配前引用了局部变量“DBNAME” ...

有什么想法吗？根据this fellow's 的建议，我正在尝试使用模块设置单例。

Answer 1

这是发生了什么。

首先，Python 真正拥有的唯一全局变量是模块范围的变量。你不能创建一个真正全局的变量；您所能做的就是在特定范围内创建一个变量。 （如果您在 Python 解释器中创建一个变量，然后导入其他模块，则您的变量位于最外层范围内，因此在您的 Python 会话中是全局的。）

创建模块全局变量所需要做的只是分配一个名称。

想象一个名为 foo.py 的文件，包含这一行：

X = 1

现在假设你导入它。

import foo
print(foo.X)  # prints 1

但是，假设您想将模块范围变量之一用作函数内部的全局变量，如您的示例所示。 Python 的默认设置是假设函数变量是本地的。在尝试使用全局变量之前，您只需在函数中添加 global 声明即可。

def initDB(name):
    global __DBNAME__  # add this line!
    if __DBNAME__ is None: # see notes below; explicit test for None
        __DBNAME__ = name
    else:
        raise RuntimeError("Database name has already been set.")

顺便说一下，对于这个例子，简单的if not __DBNAME__ 测试就足够了，因为除了空字符串之外的任何字符串值都将评估为真，因此任何实际的数据库名称都将评估为真。但是对于可能包含可能为 0 的数值的变量，你不能只说if not variablename；在这种情况下，您应该使用is 运算符显式测试None。我修改了示例以添加显式 None 测试。 None 的显式测试永远不会出错，所以我默认使用它。

最后，正如其他人在此页面上所指出的那样，两个前导下划线向 Python 发出信号，表明您希望变量对模块是“私有的”。如果您曾经使用import * from mymodule，Python 不会将带有两个前导下划线的名称导入您的名称空间。但是如果你只是做一个简单的import mymodule 然后说dir(mymodule) 你会在列表中看到“私有”变量，如果你明确引用mymodule.__DBNAME__ Python 不会在意，它只会让你引用它。双前导下划线是您模块用户的主要线索，您不希望他们将该名称重新绑定到他们自己的某个值。

在 Python 中，最好的做法是不要使用 import *，而是通过使用 mymodule.something 或通过显式执行类似 from mymodule import something 的导入来最小化耦合并最大化显式性。

编辑：如果出于某种原因，您需要在没有 global 关键字的非常旧的 Python 版本中执行此类操作，则有一个简单的解决方法。不要直接设置模块全局变量，而是在模块全局级别使用可变类型，并将值存储在其中。

在你的函数中，全局变量名是只读的；您将无法重新绑定实际的全局变量名称。 （如果你在你的函数中分配给那个变量名，它只会影响函数中的局部变量名。）但是你可以使用那个局部变量名来访问实际的全局对象，并在其中存储数据。

你可以使用list，但你的代码会很丑：

__DBNAME__ = [None] # use length-1 list as a mutable

# later, in code:  
if __DBNAME__[0] is None:
    __DBNAME__[0] = name

dict 更好。但最方便的是类实例，你可以使用一个普通的类：

class Box:
    pass

__m = Box()  # m will contain all module-level values
__m.dbname = None  # database name global in module

# later, in code:
if __m.dbname is None:
    __m.dbname = name

（您实际上不需要将数据库名称变量大写。）

我喜欢只使用__m.dbname 而不是__m["DBNAME"] 的语法糖；在我看来，这似乎是最方便的解决方案。但是dict 解决方案也可以正常工作。

使用dict，您可以使用任何可散列值作为键，但如果您对有效标识符的名称感到满意，您可以使用上面提到的Box 之类的普通类。

Answer 2

通过在模块上显式访问模块级变量来显式访问它们

---

简而言之：这里描述的技术与steveha's answer 中的相同，除了，没有创建人工辅助对象来显式范围变量。 相反，模块对象本身被赋予了一个变量指针，因此在从任何地方访问时都提供了明确的范围。 （如局部函数范围内的赋值）.

把它想象成 当前模块 的 self 而不是当前实例！

# db.py
import sys

# this is a pointer to the module object instance itself.
this = sys.modules[__name__]

# we can explicitly make assignments on it 
this.db_name = None

def initialize_db(name):
    if (this.db_name is None):
        # also in local function scope. no scope specifier like global is needed
        this.db_name = name
        # also the name remains free for local use
        db_name = "Locally scoped db_name variable. Doesn't do anything here."
    else:
        msg = "Database is already initialized to {0}."
        raise RuntimeError(msg.format(this.db_name))

As modules are cached and therefore import only once，您可以在任意数量的客户端上导入db.py，操作相同的通用状态：

# client_a.py
import db

db.initialize_db('mongo')

# client_b.py
import db

if (db.db_name == 'mongo'):
    db.db_name = None  # this is the preferred way of usage, as it updates the value for all clients, because they access the same reference from the same module object

# client_c.py
from db import db_name
# be careful when importing like this, as a new reference "db_name" will
# be created in the module namespace of client_c, which points to the value 
# that "db.db_name" has at import time of "client_c".

if (db_name == 'mongo'):  # checking is fine if "db.db_name" doesn't change
    db_name = None  # be careful, because this only assigns the reference client_c.db_name to a new value, but leaves db.db_name pointing to its current value.

---

作为额外的奖励，我发现它总体上非常 Pythonic，因为它非常适合 Python 的 显式优于隐式的策略。

Answer 3

Steveha 的回答对我有帮助，但忽略了一个重要的点（我认为 Wisty 的意思）。如果在函数中只访问变量而不赋值，则不需要 global 关键字。

如果您在没有 global 关键字的情况下分配变量，那么 Python 会创建一个新的局部变量——模块变量的值现在将隐藏在函数中。使用 global 关键字在函数内分配模块 var。

如果您不分配 var，Python 2.7 下的 Pylint 1.3.1 会强制不使用全局变量。

module_var = '/dev/hello'

def readonly_access():
    connect(module_var)

def readwrite_access():
    global module_var
    module_var = '/dev/hello2'
    connect(module_var)

Answer 4

为此，您需要将变量声明为全局变量。但是，也可以使用module_name.var_name 从模块外部 访问全局变量。将此添加为模块的第一行：

global __DBNAME__

Answer 5

你爱上了一个微妙的怪癖。您不能在 python 函数中重新分配模块级变量。我认为这是为了阻止人们意外地在函数内重新分配东西。

您可以访问模块命名空间，只是不应该尝试重新分配。如果你的函数分配了一些东西，它会自动成为一个函数变量——python 不会在模块命名空间中查找。

你可以这样做：

__DB_NAME__ = None

def func():
    if __DB_NAME__:
        connect(__DB_NAME__)
    else:
        connect(Default_value)

但您不能在函数内重新分配__DB_NAME__。

一种解决方法：

__DB_NAME__ = [None]

def func():
    if __DB_NAME__[0]:
        connect(__DB_NAME__[0])
    else:
        __DB_NAME__[0] = Default_value

注意，我不是重新分配__DB_NAME__，我只是在修改它的内容。