DESCRIPTION.

Spécifie les variables (instances d'objet) dont la valeur pourra être modifiée dans le code une fonction définie par l'utilisateur.

SYNTAXE.

global variable_a , variable_b , ... , variable_n

global ⇨ appel de l’instruction [ OBLIGATOIRE ]

variable ⇨ noms des variables [ optionnel ]

REMARQUES.

global ne doit pas s'utiliser en dehors de la définition d'une méthode ou d'un bloc de script.

Toutes variables déclarées à l'extérieur d'une fonction (def) sont considérées comme globales.

La valeur d'une variable globale pourra être lue dans tous les fonctions personnalisées définies avec l'instruction def, mais elle ne pourra être modifiée que si elle est déclarée comme faisant référence à cette variable globale, grace à l'instruction global, avant toute utilisation de cette variable (lecture ou modification) dans le script de la fonction.

Une variable globale ne doit jamais être utilisée comme variable compteur dans une boucle for, dans une définition class ou avec import.

global permet de définir quelles variables, déclarées au sein d'un bloc de script, devront être conservées en mémoire, avec sa valeur, à la sortie du bloc.

Les variables listées dans l'instruction global, ne doivent pas, avoir été utilisée dans le bloc.

GBL_Variable = 7

def FNC_Test ( ) :

global GBL_Variable 

GBL_Variable = GBL_Variable + 18

print ( GBL_Variable ) 

FNC_Test ( ) 

print ( GBL_Variable ) 

retourne :

25

25

Dans une fonction définie par l'utilisateur avec l'instruction def dans le script, si une valeur est affectée à une variable ayant le même nom qu'une variable de portée de globale, Python considérera qu'il s'agit de 2 variables distingues. A la sortie de la fonction, la valeur de la variable globale ne sera pas modifiée mais toujours accessible, alors que la variable locale sera détruite.

GBL_Variable = 7

def FNC_Test ( ) :

GBL_Variable = 18

print ( GBL_Variable ) 

FNC_Test ( ) 

print ( GBL_Variable ) 

retourne :

18

7

La modification d'une variable créée en dehors de tous blocs de script (portée globale), dans le code d'une fonctions définie par par l'utilisateur avec l'instruction def, lèvera une exception, si on ne l'a pas introduite dans le script de la fonction avec l'instruction global.

GBL_Variable = 7

def FNC_Test ( ) :

GBL_Variable = GBL_Variable + 18

print ( GBL_Variable )

FNC_Test ( ) 

print ( GBL_Variable )

retourne UnboundLocalError: local variable 'GBL_Variable' referenced before assignment 

Les variables listées dans l'instruction global, ne doivent pas, déjà, avoir été utilisée dans le bloc.

def FNC_Test ( ) :

GBL_Variable = 7 

global GBL_Variable 

GBL_Variable = GBL_Variable + 18

print ( GBL_Variable )

FNC_Test ( ) 

print ( GBL_Variable )

retourne name 'GBL_Globale" is assigned to before globale declaration 

On peut remplacer l'usage de l'instruction global en initialisant les variables de portée globale par des objets séquence, ou collection. Ainsi une constante, c'est-à-dire une variable donc la valeur ne devra pas être modifiée, après son initialisation, durant toute la vie de l'application, pourra être une instance d'un tuple ( ) tandis que d'une variables pouvant être réaffectée pourra être une list ( ) ou une paire clé-valeur d'un dict ( ).

LST_Variable = [ 7 ]

TPL_Constante = ( 7 , )

DCT_Donnees = { "valeur" : 7 }

def FNC_Test ( ) :

try : 

LST_Variable  [ 0 ] = LST_Variable  [ 0 ] + 18

DCT_Donnees [ "valeur" ] = DCT_Donnees [ "valeur" ] + 18

TPL_Constante [ 0 ] = TPL_Constante  [ 0 ] + 18

except :

print ( "Les éléments d'une tuples ( ) ne peuvent pas être modifiés !" ) 

FNC_Test ( )

print ( )

print ( LST_Variable )

print ( TPL_Constante )

print ( DCT_Donnees [ "valeur" ] )

retourne :

Les éléments d'une tuples ( ) ne peuvent pas être modifiés !

[25]

(7,)

25

Beaucoup de formateurs préconisent ne pas utiliser de variables à portée globale dans les programmes Python, à cause du phénomène dit : effet de bord. Leur conseil est de remplacer cette pratique par la création d'une classe qui recevra ces variables en tant qu'attributs de cette classe, car de cette façon, elles sont encapsulées dans l'objet, qui dispose de son propre espace en mémoire. Mais cela est en contradiction avec la bonne pratique de programmation, qui souhaite que les attributs d'un objet ne soient modifiables que dans cet objets, par l’intermédiaire des méthodes de sa classe.

class CLS_Variables ( ) :

""" pour mes variables globales """

GBL_Variables = CLS_Variables ( )

GBL_Variables.longueur = 120

GBL_Variables.largeur = 85

for kextention in range ( 4 ) :

GBL_Variables.longueur = GBL_Variables.longueur + GBL_Variables.largeur / 10

GBL_Variables.largeur = 55 * GBL_Variables.longueur / 100 

print  ( f"extention { kextention + 1 } : { GBL_Variables.longueur } x { GBL_Variables.largeur }." )

retourne :

extention 1 : 128.5 x 70.675.

extention 2 : 135.5675 x 74.562125.

extention 3 : 143.0237125 x 78.66304187499999.

extention 4 : 150.89001668749998 x 82.98950917812499.

ou :

class CLS_Variables ( ) :

""" pour mes variables globales """

def __init__ ( self ) :

self.longueur = 120

self.largeur = 85

GBL_Variables = CLS_Variables ( )

for kextention in range ( 4 ) :

GBL_Variables.longueur = GBL_Variables.longueur + GBL_Variables.largeur / 10

GBL_Variables.largeur = ( 55 * GBL_Variables.longueur ) / 100

print  ( f"extention { kextention + 1 } : { GBL_Variables.longueur } x { GBL_Variables.largeur }." )

retourne :

extention 1 : 128.5 x 70.675.

extention 2 : 135.5675 x 74.562125.

extention 3 : 143.0237125 x 78.66304187499999.

extention 4 : 150.89001668749998 x 82.98950917812499.

à la place de :

GBL_Longueur = 120

GBL_Largeur = 85

for kextention in range ( 4 ) :

GBL_Longueur = GBL_Longueur + GBL_Largeur / 10

GBL_Largeur = ( 55 * GBL_Longueur ) / 100

print  ( f"extention { kextention + 1 } : { GBL_Longueur } x { GBL_Largeur }." )

retourne :

extention 1 : 128.5 x 70.675.

extention 2 : 135.5675 x 74.562125.

extention 3 : 143.0237125 x 78.66304187499999.

extention 4 : 150.89001668749998 x 82.98950917812499.

Mais seul acceptable :

class CLS_Variables ( ) :

""" pour mes variables globales """

def __init__ ( self ) :

self.longueur = 120

self.largeur = 85

def FNC_Extention ( self , Qronde ) :

""" Calculer un nombre d’extensions successives """

for kextention in range ( Qronde ) :

self.longueur = self.longueur + self.largeur / 10

self.largeur = ( 55 * self.longueur ) / 100

print  ( f"extention { kextention + 1 } : { self.longueur } x { self.largeur }." )

GBL_Variables = CLS_Variables ( )

GBL_Variables.FNC_Extention ( 4 )

retourne :

extention 1 : 128.5 x 70.675.

extention 2 : 135.5675 x 74.562125.

extention 3 : 143.0237125 x 78.66304187499999.

extention 4 : 150.89001668749998 x 82.98950917812499.

Voir les variables et la méthode globals ( ) pour plus d'informations.