Mots-clés Global en Python

Assurez-vous d'avoir maîtrisé le contenu de cet article avant de le lire.Variables globales, locales et non locales en PythonQuelques bases.

Introduction au mot-clé global

En Python, le mot-clé global permet de modifier une variable en dehors de l'aire d'application actuelle. Il est utilisé pour créer des variables globales et les modifier dans un contexte local.

Règles du mot-clé global

Les règles de base du mot-clé global en Python sont :

• Lorsque nous créons une variable à l'intérieur de la fonction, elle est par défaut locale.

• Lorsque nous définissons une variable en dehors de la fonction, elle est par défaut globale. Vous n'avez pas besoin de utiliser le mot-clé global.

• Nous utilisons le mot-clé global pour lire et écrire des variables globales à l'intérieur de la fonction.

• L'utilisation du mot-clé global en dehors de la fonction est inefficace

Utilisation de la variable globale (exemple)

Laissez-nous prendre un exemple.

Example1：Accéder à une variable globale à partir de l'intérieur d'une fonction

c =　1　# Variable globale
def add():
　　　　print(c)
add()

Lorsque nous exécutons le programme ci-dessus, la sortie sera :

1

Cependant, dans certains cas, nous devons modifier une variable globale à partir de l'intérieur d'une fonction.

Example2：Modifier une variable globale à partir de l'intérieur d'une fonction

c =　1　# Variable globale
　　　　
def add():
　　　　c = c　+　2　# Augmenter c de　2
　　　　print(c)
add()

Lorsque nous exécutons le programme ci-dessus, la sortie affiche une erreur :

UnboundLocalError: la variable locale 'c' est référencée avant l'affectation

C'est parce que nous ne pouvons accéder qu'aux variables globales et pas les modifier à partir de l'intérieur d'une fonction.

La solution consiste à utiliser le mot-clé global.

Example3：Utiliser global pour modifier une variable globale à partir de l'intérieur d'une fonction

c = 0 # Variable globale
def add():
　　　　global c
　　　　c = c　+　2　# Augmenter de　2
　　　　print("À l'intérieur de add():", c)
add()
print("Dans main:", c)

Lorsque nous exécutons le programme ci-dessus, la sortie sera :

À l'intérieur de add():　2
Dans main:　2

Dans le programme ci-dessus, nous définissons c comme une variable globale clé à l'intérieur de la fonction add().
Puis, augmentons la variable c1，c = c + 2。Ensuite, nous appelons la fonction add(). Enfin, nous affichons la variable globale c.
Comme nous l'avons vu, les variables globales en dehors des fonctions ont également changé c = 2。

Variables globales entre modules Python

En Python, nous créons un module config.py pour stocker les variables globales et partager des informations entre les modules Python du même programme.

Voici comment nous partageons les variables globales entre modules Python.

Example4：Partage des variables globales entre modules Python

Créer un fichier config.py pour stocker les variables globales

a = 0
b = "empty"

Create an update.py file to change global variables

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

Create a main.py file to test the change of values

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 text, we create three files: config.py, update.py, and main.py.

The module config.py storesaandb'sglobal variables. In the update.py file, we import the config.py module and modifyaandbvalue. Similarly, in the main.py file, we import both the config.py and update.py modules. Finally, we print and test the value of global variables, whether they have changed or not.

Global variables in nested functions

This is the method of using global variables in nested functions.

Example5: Using global variables in nested functions

def foo():
　　　　x =　20
　　　　def bar():
　　　　　　　　global x
　　　　　　　　x =　25
　　　　
　　　　print("Before calling bar:", x)
　　　　print("Call bar immediately")
　　　　bar()
　　　　print("After calling bar:", x)
foo()
print("x in the main body:", x)

Output is:

Before calling bar:　　20
Call bar immediately
After calling bar:　　20
x in the main body:　　25

In the above program, we declare a global variable in the nested function bar(). In the foo() function, x has no effect on the global keyword.
The variable x takes the value of the local variable before and after calling bar, that is, x =20. Outside the foo function, the variable x will take the value defined in the bar function, that is, x =25. This is because we used the global keyword to create a global variable in the bar function (local scope).
If we make any changes in the bar() function, these changes will appear outside the local scope, that is, foo().