document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-01-25 23:11:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Delete 20180207 Python Global Keyword (With Examples).md

Browse Source
This commit is contained in:
MjSeven 2018-02-23 22:56:01 +08:00 committed by GitHub
parent 9269aadd5e
commit c2e8d0e7e7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 0 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

188
sources/tech/20180207 Python Global Keyword (With Examples).md
View File

@ -1,188 +0,0 @@
Translating by MjSeven
Python Global Keyword (With Examples)
======
Before reading this article, make sure you have got some basics of [Python Global, Local and Nonlocal Variables][1].
### Introduction to global Keyword
In Python, `global` keyword allows you 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.
#### Rules of global Keyword
The basic rules for `global` keyword in Python are:
* When we create a variable inside a function, it’s local by default.
* When we define a variable outside of a function, it’s global by default. You don’t have to use `global` keyword.
* We use `global` keyword to read and write a global variable inside a function.
* Use of `global` keyword outside a function has no effect
#### Use of global Keyword (With Example)
Let’s take an example.
##### Example 1: Accessing global Variable From Inside a Function
```
c = 1 # global variable
def add():
print(c)
add()
```
When we run above program, the output will be:
```
1
```
However, we may have some scenarios where we need to modify the global variable from inside a function.
##### Example 2: Modifying Global Variable From Inside the Function
```
c = 1 # global variable
def add():
c = c + 2 # increment c by 2
print(c)
add()
```
When we run above program, the output shows an error:
```
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 3: Changing Global Variable From Inside a Function using global
```
c = 0 # global variable
def add():
global c
c = c + 2 # increment by 2
print("Inside add():", c)
add()
print("In main:", c)
```
When we run above program, the output will be:
```
Inside add(): 2
In main: 2
```
In the above program, we define c as a global keyword inside the `add()` function.
Then, we increment the variable c by `1`, i.e `c = c + 2`. After that, we call the `add()` function. Finally, we print global variable c.
As we can see, change also occured on the global variable outside the function, `c = 2`.
### Global Variables Across Python Modules
In Python, we create a single module `config.py` to hold global variables and share information across Python modules within the same program.
Here is how we can share global variable across the python modules.
##### Example 4 : Share a global Variable Across Python Modules
Create a `config.py` file, to store global variables
```
a = 0
b = "empty"
```
Create a `update.py` file, to change global variables
```
import config
config.a = 10
config.b = "alphabet"
```
Create a `main.py` file, to test changes in value
```
import config
import update
print(config.a)
print(config.b)
```
When we run the `main.py` file, the output will be
```
10
alphabet
```
In the above, we create three files: `config.py`, `update.py` and `main.py`.
The module `config.py` stores global variables of a and b. In `update.py` file, we import the `config.py` module and modify the values of a and b. Similarly, in `main.py` file we import both `config.py` and `update.py` module. Finally, we print and test the values of global variables whether they are changed or not.
### Global in Nested Functions
Here is how you can use a global variable in nested function.
##### Example 5: Using a Global Variable in Nested Function
```
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)
```
The output is :
```
Before calling bar: 20
Calling bar now
After calling bar: 20
x in main : 25
```
In the above program, we declare global variable inside the nested function `bar()`. Inside `foo()` function, x has no effect of global keyword.
Before and after calling `bar()`, the variable x takes the value of local variable i.e `x = 20`. Outside of the `foo()` function, the variable x will take value defined in the `bar()` function i.e `x = 25`. This is because we have used `global` keyword in x to create global variable inside the `bar()` function (local scope).
If we make any changes inside the `bar()` function, the changes appears outside the local scope, i.e. `foo()`.
--------------------------------------------------------------------------------
via: https://www.programiz.com/python-programming/global-keyword
作者：[programiz][a]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://www.programiz.com
[1]:https://www.programiz.com/python-programming/global-local-nonlocal-variables