声明：突然看到这篇文章，发现了c语言中使用全局变量的错误，特转之。

首先看一段代码(https://gist.github.com/3760736)

func.c

int

buf

=

0

;

void

func

()

{

buf

=

2

;

/* Do something else */

}

view raw func.c This Gist brought to you by  GitHub.

main.c

#include

int

buf

;

void

func

();

int

main

()

{

buf

=

1

;

func

();

printf

(

"%d

\n

"

,

buf

);

return

0

;

}

view raw main.c This Gist brought to you by  GitHub.

编译两个文件，输出的结果是怎样的呢？一眼看上去，可能会输出1，因为两个全局变量buf在不同文件中，又没有extern声明，显然是两个嘛。然而实际上它的运行结果却是2，这说明了这两个文件中引用到的其实是一个变量！

这是为什么呢？原因是在编译时，C语言编译器将全局符号标记为strong和weak两类：

函数和初始化的全局符号被标记为strong

未初始化的全局符号被标记为weak

连接时，连接器对多重定义的全局符号的解析原则如下：

同一个符号不允许有多个strong定义；

假如一个符号有一个strong定义和多个weak定义，那么采用该符号的strong定义；

假如一个符号有多个weak定义，那么选取任意一个weak定义

由于两个变量一个初始化了，一个没有初始化，所以一个是strong，一个是weak，所以连接器在符号解析时会把他们当成一个。

如果我们把main.c中的buf也初始化了：

#include

int

buf

=

0

;

void

func

();

int

main

()

{

buf

=

1

;

func

();

printf

(

"%d

\n

"

,

buf

);

return

0

;

}

view raw func.c This Gist brought to you by  GitHub.

再次编译就会发现

duplicate symbol _buf in:

/var/folders/44/_cc501qx1jd1p5bfrjbk6b100000gn/T//ccZ87C6g.o

/var/folders/44/_cc501qx1jd1p5bfrjbk6b100000gn/T//ccZlES8n.o

ld: 1 duplicate symbol for architecture x86_64

collect2: ld returned 1 exit status

这是因为两个全局变量都是strong的。

理解的都没问题。但我想聊聊出现这种情况的原因。在讲原因之前，需要先知道python中变量的搜索顺序，这个顺序是 LGB (不考虑闭包情况)即local本地，global全局，builtin内建。比如：

a = 1

def test():

a = 3

print(a)

test()

函数内声明了局部变量 a ，在打印中使用，在本地环境中命中，因此使用的是 3。

也许你会问这个知识点我早就知道了，这和本问题有什么关系呢？

有的，难道你不觉得奇怪吗？报错是变量未初始化，而不是变量未定义。

题目中函数内 c= c+1 就已经表明了声明的变量 c 是属于局部变量的。 按理说，先执行赋值语句右侧，而此时 c 并没有声明，应该在全局环境命中才对啊。所以想象中的结果应该是局部变量 c = 2 而全局变量的 c 保持原值。

但是，这只都是想当然。讲了这么多其实我是想引出，python虽然是动态语句，但它还是会对代码做扫描工作的，会有收集有用的静态信息。函数的应该信息会放在 code 对象中，里面的信息就包含了局部变量名称的集合，可以通过 co_varnames 得到，如下：

c = 1

def test():

c= c+1

a = 3 # 另一个局部变量

print(c)

print(test.__code__.co_varnames) # ('c', 'a')

因此，函数test在执行前，变量 c 就已经被声明在局部变量环境中了，而不是我们自认为的当赋值语句运行后才会在局部变量里。于是，这就导致了报错信息是变量未初始化而不是变量未定义。

====== 分割线 =========

题主评论要求：

关于变量的初始化，定义，创建这三者关系，能帮忙疏导一下理解吗?

这三个意思基本差不多，没必要分得太开。把变量环境理解成一个字典 name_env = dict() 其实就很好理解了(事实上python底层也确实是这样处理的)。对于在这个环境内要创建一个名为 a 的变量，就可以是 name_env['a'] = value 的形式了。

这个过程也就是赋值语句形如 a = value 时会调用赋值的指令 STORE_NAME 。我们看一下这个赋值过程你就理解了。

这部分代码在 ceval.c 中，详见 ceval.c

TARGET(STORE_NAME) {

PyObject *name = GETITEM(names, oparg);

PyObject *v = POP();

PyObject *ns = f->f_locals;

int err;

if (ns == NULL) {

PyErr_Format(PyExc_SystemError,

"no locals found when storing %R", name);

Py_DECREF(v);

goto error;

}

if (PyDict_CheckExact(ns))

err = PyDict_SetItem(ns, name, v);

else

err = PyObject_SetItem(ns, name, v);

Py_DECREF(v);

if (err != 0)

goto error;

DISPATCH();

}

代码不多，可以逐个分析下，第一行获得的 name 就是赋值语句 a = value 的 a，a以python类型 str 形式存在。第二行 v 从栈中获取，也就是 value 的值。第三行 ns 是从帧对象中获得局部变量环境(大多数情况下是个字典类型，如果帧环境不在函数或类中，取得的是全局变量环境)。PyDict_SetItem(ns, name, v); 和 PyObject_SetItem(ns, name, v); 就可以理解为 ns[name] = v 和 setattr(ns, name, v) 了，创建过程就是这样了。

变量究竟是创建还是初始化还是覆盖已有的变量值，其实底层并不关心。

回到本地中，本地变量的符号表会保存在静态信息里面，我猜测搜索变量时有优先去静态信息中得到信息，来更快的知道变量应该是在局部还是全局中查找吧。

In this tutorial, We will look into Python Global Variables. We will learn how to define a global variable and then how to access them in a function.

在本教程中，我们将研究Python全局变量。 我们将学习如何定义全局变量，然后如何在函数中访问它们。

Python中的全局变量 (Global Variables in Python)

Global Variables are defined outside a function. We can access a global variable in all parts of the Python program.

全局变量在函数外部定义。 我们可以在Python程序的所有部分中访问全局变量。

Python全局变量示例 (Python Global Variables Example)

Let’s look at a simple example to declare a global variable. Then we will use this global variable in a function.

让我们看一个声明全局变量的简单示例。 然后，我们将在函数中使用此全局变量。

website = "JournalDev.com"


def return_website():
    return website


print(f'My favorite website is {return_website()}')

Output:

输出：

My favorite website is JournalDev.com

The variable “website” is defined in the program, outside of a function. So, it becomes a global variable.

变量“网站”在程序中的函数外部定义。 因此，它成为一个全局变量。

使用全局关键字访问全局变量 (Using global keyword to access global variable)

If there is a variable defined inside a function with the same name, then we have to use global keyword to access the global variable. Otherwise, the local variable value will be used.

如果在函数内部定义了一个具有相同名称的变量，那么我们必须使用global关键字来访问全局变量。 否则，将使用局部变量值。

Let’s look at a quick example to use the global keyword to access global variables.

让我们看一个使用global关键字访问全局变量的简单示例。

website = "JournalDev.com"


def print_website():
    global website
    print(f'My favorite website is {website}')

    website = 'Wikipedia.com'
    print(f'My favorite website is {website}')


print_website()

Output:

输出：

My favorite website is JournalDev.com
My favorite website is Wikipedia.com

If we don’t use the global keyword, the program will throw error message “UnboundLocalError: local variable referenced before assignment”.

如果我们不使用global关键字，则程序将抛出错误消息“ UnboundLocalError：分配前引用的本地变量”。

The best practice is to avoid using the same name as the global variable and stay away from the name conflicts.

最佳做法是避免使用与全局变量相同的名称，并避免名称冲突。

Python globals（）函数快速入门 (Quick word on Python globals() function)

Python globals() function return a dictionary representing the current global symbol table. This dictionary contains the global variables name and its values. We can use this function to get quick information on all the global variables.

Python globals（）函数返回一个表示当前全局符号表的字典 。 该词典包含全局变量名称及其值。 我们可以使用此功能来获取有关所有全局变量的快速信息。

Python program maintains program information in symbol tables.

Python程序在符号表中维护程序信息。

There are two types of symbol tables:

符号表有两种类型：

1. Local Symbol Table – stores information related to the local scope of the program.
   本地符号表 –存储与程序的本地范围有关的信息。
2. Global Symbol Table – stores information related to global scope of the program.
   全局符号表 –存储与程序的全局范围有关的信息。

Python symbol table contains details about variable names, methods, classes, etc.

Python符号表包含有关变量名称，方法， 类等的详细信息。

Python globals() function doesn’t accept any arguments.

Python globals（）函数不接受任何参数。

print(globals())

Output:

输出：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10a99b358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/github/journaldev/Python-3/basic_examples/python_globals_example.py', '__cached__': None}

It also prints the python script from where this function is called.

它还会在调用此函数的位置打印python脚本。

Let’s see the output if the same function is called from the Python interpreter.

让我们看看是否从Python解释器调用了相同的函数的输出。

$ python3.7
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24) 
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print(globals())
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>>

This time there is no __file__ attribute in the output.

这次输出中没有__file__属性。

globals（）字典中的全局变量 (Global Variables in globals() dictionary)

As we mentioned earlier that the global symbol table contains information about the global variables.

如前所述，全局符号表包含有关全局变量的信息。

Let’s see this with a simple example.

让我们用一个简单的例子来看一下。

name = 'Pankaj'

print(globals())

Output:

输出：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10a99b358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/github/journaldev/Python-3/basic_examples/python_globals_example.py', '__cached__': None, 'name': 'Pankaj'}

The global symbol dictionary contains the ‘name’ variable too.

全局符号字典也包含“名称”变量。

One of the features of globals() is that we can modify the variables in the global dictionary. Since it’s a dictionary, we can get the value of a specific key too.

globals（）的功能之一是我们可以修改全局字典中的变量。 由于它是字典，因此我们也可以获取特定键的值。

globals()['name'] = 'David'

print(globals()['name'])

Output: David

输出： David

Let’s see if globals() contains local scope variables or not. For this, let’s define a function and some variables inside it.

让我们看看globals（）是否包含局部作用域变量。 为此，让我们定义一个函数和其中的一些变量。

def fx():
    local = ''
    global gl
    gl = 'Global'


fx()  # calling fx() to set the variables
print(globals())

print(globals()['gl'])

Output:

输出：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10a99b358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/github/journaldev/Python-3/basic_examples/python_globals_example.py', '__cached__': None, 'name': 'David', 'fx': <function fx at 0x10a9331e0>, 'gl': 'Global'}

Global

The ‘gl’ variable is part of the global dictionary because its scope is global. Whereas, ‘local’ variable is not part of the global dictionary because of having local scope.

'gl'变量是全局词典的一部分，因为它的范围是全局的。 而“局部”变量由于具有局部范围，因此不属于全局词典。

结论 (Conclusion)

Python global variables are very easy to define and use. The globals() function returns the global variables and it can be used in debugging the code. We can use it to identify the global scope variables and functions available to the program. We can also modify the global variable data, but that is not advisable and mostly not required in normal programs.

Python全局变量非常易于定义和使用。 globals（）函数返回全局变量，可用于调试代码。 我们可以使用它来识别程序可用的全局范围变量和函数。 我们还可以修改全局变量数据，但这是不可取的，并且在正常程序中通常不是必需的。

Reference: Official Documentation

参考： 官方文档

翻译自: https://www.journaldev.com/22870/global-variables-python