初识 Python： global 关键字
Python
![](/data/attachment/album/201804/19/214422wfy7pvmx4c61ykvq.jpg)


在读这篇文章之前，确保你对 [Python 全局、局部和非局部变量](https://www.programiz.com/python-programming/global-local-nonlocal-variables) 有一定的基础。


### global 关键字简介


在 Python 中，`global` 关键字允许你修改当前范围之外的变量。它用于创建全局变量并在本地上下文中更改变量。


### global 关键字的规则


在 Python 中，有关 `global` 关键字基本规则如下：


* 当我们在一个函数中创建一个变量时，默认情况下它是本地变量。
* 当我们在一个函数之外定义一个变量时，默认情况下它是全局变量。你不必使用 `global` 关键字。
* 我们使用 `global` 关键字在一个函数中来读写全局变量。
* 在一个函数外使用 `global` 关键字没有效果。


### 使用 global 关键字（含示例）


我们来举个例子。


#### 示例 1：从函数内部访问全局变量



```
c = 1 # 全局变量
def add():
    print(c)

add()

```

运行程序，输出为：



```
1

```

但是我们可能有一些场景需要从函数内部修改全局变量。


#### 示例 2：在函数内部修改全局变量



```
c = 1 # 全局变量
def add():
    c = c + 2 # 将 c 增加 2
    print(c)
add()

```

运行程序，输出显示错误：



```
UnboundLocalError: local variable 'c' referenced before assignment

```

这是因为在函数中，我们只能访问全局变量但是不能修改它。


解决的办法是使用 `global` 关键字。


#### 示例 3：使用 global 在函数中改变全局变量



```
c = 0 # global variable

def add():
    global c
    c = c + 2 # 将 c 增加 2
    print("Inside add():", c)

add()
print("In main:", c)

```

运行程序，输出为：



```
Inside add(): 2
In main: 2

```

在上面的程序中，我们在 `add()` 函数中定义了 `c` 将其作为全局关键字。


然后，我们给变量 `c` 增加 `2`，即 `c = c + 2`。之后，我们调用了 `add()` 函数。最后，打印全局变量 `c`。


正如我们所看到的，在函数外的全局变量也发生了变化，`c = 2`。


### Python 模块中的全局变量


在 Python 中，我们创建一个单独的模块 `config.py` 来保存全局变量并在同一个程序中的 Python 模块之间共享信息。


以下是如何通过 Python 模块共享全局变量。


#### 示例 4：在Python模块中共享全局变量


创建 `config.py` 文件来存储全局变量



```
a = 0
b = "empty"

```

创建 `update.py` 文件来改变全局变量



```
import config

config.a = 10
config.b = "alphabet"

```

创建 `main.py` 文件来测试其值的变化



```
import config
import update

print(config.a)
print(config.b)

```

运行 `main.py`，输出为：



```
10
alphabet

```

在上面，我们创建了三个文件： `config.py`, `update.py` 和 `main.py`。


在 `config.py` 模块中保存了全局变量 `a` 和 `b`。在 `update.py` 文件中，我们导入了 `config.py` 模块并改变了 `a` 和 `b` 的值。同样，在 `main.py` 文件，我们导入了 `config.py` 和 `update.py` 模块。最后，我们打印并测试全局变量的值，无论它们是否被改变。


### 在嵌套函数中的全局变量


以下是如何在嵌套函数中使用全局变量。


#### 示例 5：在嵌套函数中使用全局变量



```
def foo():
    x = 20
    def bar():
         global x
         x = 25

    print("Before calling bar: ", x)
    print("Calling bar now")
    bar()
    print("After calling bar: ", x)

foo()
print("x in main : ", x)

```

输出为：



```
Before calling bar: 20
Calling bar now
After calling bar: 20
x in main : 25

```

在上面的程序中，我们在一个嵌套函数 `bar()` 中声明了全局变量。在 `foo()` 函数中， 变量 `x` 没有全局关键字的作用。


调用 `bar()` 之前和之后， 变量 `x` 取本地变量的值，即 `x = 20`。在 `foo()` 函数之外，变量 `x` 会取在函数 `bar()` 中的值，即 `x = 25`。这是因为在 `bar()` 中，我们对 `x` 使用 `global` 关键字创建了一个全局变量（本地范围）。


如果我们在 `bar()` 函数内进行了任何修改，那么这些修改就会出现在本地范围之外，即 `foo()`。




---


via: <https://www.programiz.com/python-programming/global-keyword>


作者：[programiz](https://www.programiz.com) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)


本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


OK
In Python, the `global`

keyword allows us to modify the variable outside of the current scope.

It is used to create a global variable and make changes to the variable in a local context.

Before we learn about the `global`

keyword, make sure you have got some basics of [Python Variable Scope](/python-programming/global-local-nonlocal-variables).

## Access and Modify Python Global Variable

First let's try to access a global variable from the inside of a [function](https://www.programiz.com/python-programming/function),

```
``````
c = 1 # global variable
def add():
print(c)
add()
# Output: 1
```


Here, we can see that we have accessed a global variable from the inside of a function.

However, if we try to modify the global variable from inside a function as:

```
``````
# global variable
c = 1
def add():
# increment c by 2
c = c + 2
print(c)
add()
```


**Output**

UnboundLocalError: local variable 'c' referenced before assignment

This is because we can only access the global variable but cannot modify it from inside the function.

The solution for this is to use the `global`

keyword.

### Example: Changing Global Variable From Inside a Function using global

```
``````
# global variable
c = 1
def add():
# use of global keyword
global c
# increment c by 2
c = c + 2
print(c)
add()
# Output: 3
```


In the above example, we have defined `c` as the `global`

keyword inside `add()`

.

Then, we have incremented the variable `c` by **2**, i.e `c = c + 2`

.

As we can see while calling `add()`

, the value of global variable `c` is modified from **1** to **3**.

## Rules of global Keyword

The basic rules for `global`

keyword in Python are:

- When we create a variable inside a function, it is local by default.
- When we define a variable outside of a function, it is global by default. You don't have to use the
`global`

keyword. - We use the
`global`

keyword to modify (write to) a global variable inside a function. - Use of the
`global`

keyword outside a function has no effect.

**Also Read:**