Variables globales et locales Python

Je suis un développeur de logiciels avec un grand intérêt pour l’analyse de données et les statistiques.

Les variables globales sont les variables qui sont déclarées en dehors de la portée d’une fonction mais qui peuvent être utilisées dans une fonction. Pour déclarer et utiliser une variable globale, nous pouvons utiliser le mot-clé « global » avant le nom de la variable.

Essayons de mieux comprendre le concept à l’aide de quelques exemples.

Variable définie à l’intérieur de la fonction et utilisée à l’extérieur

Considérez le code suivant.

#!/usr/bin/python3
 
def myFunct():
    a = 20
    print(a)
    
myFunct()
print(a)

Le code entraînera une NameError car la variable a n’est visible que pour la fonction nommée myFunct. Le print(a) vers la fin du programme échoue car le programme suppose que la variable n’a pas encore été définie. C’est parce que la variable « a » est locale à la fonction nommée myFunct().

La sortie du programme ci-dessus sera : Traceback (appel le plus récent en dernier) : 20 Fichier « G:\workspaces\py_ws\MyProj\org\pythontutorials\globalvslocal\globalAndLocal.py », ligne 13, dans print(a) NameError : nom ‘a’ n’est pas défini

Nous pouvons ajouter global a à myFunct() avant de définir et d’imprimer la valeur afin de faire fonctionner le code. Considérez le code amélioré ci-dessous :

#!/usr/bin/python3
 
def myFunct():
    global a
    a = 20
    print("Inside myfunct(): a = ", a)
    
myFunct()
print("Value of a after first call to myFunct: a = ", a)
a = 10
print("After setting new value outside myFunct: a = ", a)
myFunct()
print("After calling myFunct for second time: a = ", a)

La sortie du code ci-dessus sera la suivante :

À l’intérieur de myfunct() : a = 20 Valeur de a après le premier appel à myFunct : a = 20 Après avoir défini une nouvelle valeur en dehors de myFunct : a = 10 À l’intérieur de myfunct() : a = 20 Après avoir appelé myFunct pour la deuxième fois : a = 20

Fonction extérieure définie variable et utilisée à l’intérieur

Prenons un autre exemple :

#!/usr/bin/python3
def callMe():
    print(msg)
    msg = "Called"
    
msg = "Calling..."
callMe()
print(msg)

Que se passera-t-il si nous exécutons le code ? Fonctionnera-t-il avec succès ?
La sortie du code ci-dessus ressemblera à ceci :

Faites défiler pour continuer

Traceback (appel le plus récent en dernier) : Fichier « G:\workspaces\py_ws\MyProj\org\pythontutorials\globalvslocal\scopedOutside.py », ligne 12, dans callMe() Fichier « G:\workspaces\py_ws\MyProj\org\ pythontutorials\globalvslocal\scopedOutside.py », ligne 8, dans callMe print(s) UnboundLocalError : variable locale ‘msg’ référencée avant l’affectation

Si nous inspectons attentivement le code, nous pouvons voir que la variable msg est affectée de la valeur « Calling » en dehors de la fonction callMe. Ensuite, callMe() est appelé. Même si msg est déclaré en dehors de la fonction avant qu’elle ne soit appelée, Python « suppose » que nous voulons une variable locale en raison de l’affectation à msg à l’intérieur de callMe(), donc l’instruction print renvoie ce message d’erreur.

Habituellement, une variable utilisée à l’intérieur d’une fonction est considérée comme une variable locale, si elle n’a pas été déclarée comme une variable globale.

Pour corriger l’erreur, nous devons modifier le code comme suit :

#!/usr/bin/python3
def callMe():
    global msg
    print(msg)
    msg = "Called"
    
msg = "Calling..."
callMe()
print(msg)

Maintenant, il devrait imprimer « Calling » et « Called » sur deux lignes distinctes comme prévu. La sortie du programme ci-dessus sera la suivante :

Appel… Appelé

Variables dans les fonctions imbriquées

Il est possible de définir une fonction à l’intérieur d’une autre fonction. Ces fonctions sont appelées fonctions imbriquées.

Considérez le code suivant :

#!/usr/bin/python3
def outer():
    x = 10
    def inner():
        global x
        x = 2
    print("Before calling inner(): x = ", x)
    print("Calling inner() now... ")
    inner()
    print("After calling inner(): x = ", x)
    
outer()
print("x in main: " + str(x))

La sortie du code ci-dessus sera :

Avant d’appeler inner() : x = 10 Appeler inner() maintenant… Après avoir appelé inner() : x = 10 x dans main : 2

Dans le programme ci-dessus, la valeur de x est conservée sous la forme 10 dans la fonction outer() indépendamment de ce que inner() fait avec la variable. Après avoir appelé inner(), une variable globale existe avec la valeur 2. Étant donné que outer() appelle à son tour inner(), l’instruction print dans main imprime la valeur affectée à une variable globale par inner().

© 2019 Sam Shepards