Question

我有这个：

g_c = 0

class TestClass():
    global g_c
    def run(self):
        for i in range(10):
            g_c = 1
            print g_c

t = TestClass()
t.run()

print g_c

如何实际修改我的全局变量g_c？

Answer 1

通过在访问它的函数中声明它global：

g_c = 0

class TestClass():
    def run(self):
        global g_c
        for i in range(10):
            g_c = 1
            print g_c

关于global陈述，Python documentation说了这个：

全局语句是一个声明，它适用于整个当前代码块。

Answer 2

您需要在函数中移动global声明：

class TestClass():
    def run(self):
        global g_c
        for i in range(10):
            g_c = 1
            print g_c

Answer 3

我理解使用全局变量有时候是最方便的事情，特别是在使用类使得最简单的事情变得如此困难的情况下（例如multiprocessing）。我在声明全局变量时遇到了同样的问题，并通过一些实验得出结论。

您的类中g_c函数未更改run的原因是g_c中对全局名称的引用未在函数内精确建立。 Python处理全局声明的方式实际上非常棘手。命令global g_c有两个作用：

预先设置密钥"g_c"进入可由内置函数globals()访问的字典中。但是，在为其分配值之前，该键不会出现在字典中。
（潜在地）改变了Python在当前方法中查找变量g_c的方式。

对（2）的充分理解特别复杂。首先，它只会改变，因为如果在方法中没有对名称g_c进行分配，那么Python默认在globals()中搜索它。这实际上是一种相当普遍的事情，就像在代码开头一直导入的方法模块中引用一样。

但是，如果在方法中 where 发生赋值命令，则Python默认在局部变量中查找名称g_c。即使在实际分配之前发生引用也是如此，这将导致经典错误：

UnboundLocalError: local variable 'g_c' referenced before assignment

现在，如果声明global g_c在方法中出现 where ，即使在任何引用或赋值之后，Python也默认在全局变量中找到名称g_c。但是，如果您感觉有实验性并在引用后放置声明，您将收到警告：

SyntaxWarning: name 'g_c' is used prior to global declaration

如果你仔细想想，全局声明在Python中的工作方式显然与Python正常工作的方式一致。只是当你真正想要一个全局变量工作时，规范变得烦人。

这是一个代码，总结了我刚才所说的内容（还有一些观察结果）：

g_c = 0
print ("Initial value of g_c: " + str(g_c))
print("Variable defined outside of method automatically global? "
      + str("g_c" in globals()))

class TestClass():
    def direct_print(self):
        print("Directly printing g_c without declaration or modification: "
              + str(g_c))
        #Without any local reference to the name
        #Python defaults to search for the variable in globals()
        #This of course happens for all the module names you import

    def mod_without_dec(self):
        g_c = 1
        #A local assignment without declaring reference to global variable
        #makes Python default to access local name
        print ("After mod_without_dec, local g_c=" + str(g_c))
        print ("After mod_without_dec, global g_c=" + str(globals()["g_c"]))


    def mod_with_late_dec(self):
        g_c = 2
        #Even with a late declaration, the global variable is accessed
        #However, a syntax warning will be issued
        global g_c
        print ("After mod_with_late_dec, local g_c=" + str(g_c))
        print ("After mod_with_late_dec, global g_c=" + str(globals()["g_c"]))

    def mod_without_dec_error(self):
        try:
            print("This is g_c" + str(g_c))
        except:
            print("Error occured while accessing g_c")
            #If you try to access g_c without declaring it global
            #but within the method you also alter it at some point
            #then Python will not search for the name in globals()
            #!!!!!Even if the assignment command occurs later!!!!!
        g_c = 3

    def sound_practice(self):
        global g_c
        #With correct declaration within the method
        #The local name g_c becomes an alias for globals()["g_c"]
        g_c = 4
        print("In sound_practice, the name g_c points to: " + str(g_c))


t = TestClass()
t.direct_print()
t.mod_without_dec()
t.mod_with_late_dec()
t.mod_without_dec_error()
t.sound_practice()

Answer 4

class flag:
    ## Store pseudo-global variables here

    keys=False

    sword=True

    torch=False


## test the flag class

print('______________________')

print(flag.keys)
print(flag.sword)
print (flag.torch)


## now change the variables

flag.keys=True
flag.sword= not flag.sword
flag.torch=True

print('______________________')

print(flag.keys)
print(flag.sword)
print (flag.torch)

Answer 5

在类中创建变量global非常简单：

a = 0

class b():
    global a
    a = 10

>>> a
10

如何在Python中访问类内部的全局变量

5 个答案: