其他答案回答了你的问题。关于Python中的名称，要知道的另一件重要的事情是，它们在每个作用域上要么是本地的，要么是全局的。

举个例子:

value = 42

def doit():
    print value
    value = 0

doit()
print value

您可能会猜测，value = 0语句将赋值给一个局部变量，而不会影响在doit()函数外部声明的同一个变量的值。您可能会更惊讶地发现上面的代码无法运行。函数内部的语句打印值产生一个UnboundLocalError。

原因是Python已经注意到，在函数的其他地方，你分配了name value，而且value也没有声明为全局的。这使它成为一个局部变量。但是当你试图打印它时，本地名称还没有定义。在这种情况下，Python不会像其他一些语言那样返回到将名称作为全局变量来查找。从本质上讲，如果在函数中任何地方定义了同名的局部变量，则无法访问全局变量。

Global使变量对模块(模块作用域)中的所有内容可见，就像您在模块本身的顶层定义了它一样。它在模块外部是不可见的，在它被设置之前，它不能从模块中导入，所以不用麻烦，这不是它的用途。

全球何时能解决实际问题?(注意:仅在Python 3上检查。)

# Attempt #1, will fail
# We cannot import ``catbus`` here
# as that would lead to an import loop somewhere else,
# or importing ``catbus`` is so expensive that you don't want to 
# do it automatically  when importing this module

top_level_something_or_other = None

def foo1():
    import catbus
    # Now ``catbus`` is visible for anything else defined inside ``foo()`` 
    # at *compile time*
    bar()  # But ``bar()`` is a call, not a definition. ``catbus`` 
           # is invisible to it.

def bar():
    # `bar()` sees what is defined in the module
    # This works:
    print(top_level_something_or_other)
    # This doesn't work, we get an exception: NameError: name 'catbus' is not defined
    catbus.run()

这可以用global来修复:

# Attempt #2, will work
# We still cannot import ``catbus`` here
# as that would lead to an import loop somewhere else,
# or importing ``catbus`` is so expensive that you don't want to 
# do it automatically  when importing this module

top_level_something_or_other = None

def foo2():
    import catbus
    global catbus  # Now catbus is also visible to anything defined 
                   # in the top-level module *at runtime* 
    bar()

def bar():
    # `bar` sees what is defined in the module and when run what is available at run time
    # This still works:
    print(top_level_something_or_other)
    # This also works now:
    catbus.run()

如果bar()在foo中定义，这就不需要了:

# Attempt 3, will work
# We cannot import ``catbus`` here
# as that would lead to an import loop somewhere else,
# or importing ``catbus`` is so expensive that you don't want to 
# do it automatically  when importing this module

top_level_something_or_other = None

def foo3():

    def bar():
        # ``bar()`` sees what is defined in the module *and* what is defined in ``foo()``
        print(top_level_something_or_other)
        catbus.run()

    import catbus
    # Now catbus is visible for anything else defined inside foo() at *compile time*
    bar()  # Which now includes bar(), so this works

通过在foo()之外定义bar()， bar()可以被导入到可以直接导入catbus的东西中，或者在单元测试中模拟它。

全局是一种代码气味，但有时你需要的正是像全局这样的肮脏黑客。不管怎样，“global”对它来说是个坏名字，因为在python中没有全局作用域这样的东西，它一直是模块。

虽然你可以在没有global关键字的情况下访问全局变量，但如果你想修改它们，你必须使用global关键字。例如:

foo = 1
def test():
    foo = 2 # new local foo

def blub():
    global foo
    foo = 3 # changes the value of the global foo

在这里，你只是访问了list sub。

Global使变量为Global

def out():
    global x
    x = 1
    print(x)
    return


out()

print (x)

这使得'x'就像函数外的普通变量一样。如果你把全局变量拿出来，它就会报错，因为它不能在函数中打印变量。

def out():
     # Taking out the global will give you an error since the variable x is no longer 'global' or in other words: accessible for other commands
    x = 1
    print(x)
    return


out()

print (x)

访问名称和分配名称是不同的。在本例中，您只是访问一个名称。

如果在函数中赋值给某个变量，则假定该变量为局部变量，除非将其声明为全局变量。如果没有，就假定它是全局的。

>>> x = 1         # global 
>>> def foo():
        print x       # accessing it, it is global

>>> foo()
1
>>> def foo():   
        x = 2        # local x
        print x 

>>> x            # global x
1
>>> foo()        # prints local x
2

在函数外部声明的任何变量都被假定为全局变量，只有在函数内部声明它们时(构造函数除外)，你必须指定变量为全局变量。