Variables Python globales, locales et non locales

Dans ce didacticiel, vous découvrirez les variables globales Python, les variables locales, les variables non locales et où les utiliser.

Vidéo :Variables locales et globales Python

Variables globales

En Python, une variable déclarée en dehors de la fonction ou dans une portée globale est appelée variable globale. Cela signifie qu'une variable globale est accessible à l'intérieur ou à l'extérieur de la fonction.

Voyons un exemple de la façon dont une variable globale est créée en Python.

Exemple 1 :créer une variable globale

x = "global"

def foo():
    print("x inside:", x)


foo()
print("x outside:", x)

Sortie

x inside: global
x outside: global

Dans le code ci-dessus, nous avons créé x comme variable globale et défini un foo() pour imprimer la variable globale x . Enfin, nous appelons le foo() qui imprimera la valeur de x .

Et si vous voulez changer la valeur de x dans une fonction ?

x = "global"

def foo():
    x = x * 2
    print(x)

foo()

Sortie

UnboundLocalError: local variable 'x' referenced before assignment

La sortie affiche une erreur car Python traite x comme variable locale et x n'est pas non plus défini dans foo() .

Pour que cela fonctionne, nous utilisons le global mot-clé. Visitez Python Global Keyword pour en savoir plus.

Variables locales

Une variable déclarée dans le corps de la fonction ou dans la portée locale est appelée variable locale.

Exemple 2 :Accéder à une variable locale en dehors de la portée

def foo():
    y = "local"


foo()
print(y)

Sortie

NameError: name 'y' is not defined

La sortie affiche une erreur car nous essayons d'accéder à une variable locale y dans une portée globale alors que la variable locale ne fonctionne qu'à l'intérieur de foo() ou portée locale.

Voyons un exemple sur la façon dont une variable locale est créée en Python.

Exemple 3 :créer une variable locale

Normalement, nous déclarons une variable à l'intérieur de la fonction pour créer une variable locale.

def foo():
    y = "local"
    print(y)

foo()

Sortie

local

Jetons un coup d'œil au problème précédent où x était une variable globale et nous voulions modifier x à l'intérieur de foo() .

Variables globales et locales

Ici, nous allons montrer comment utiliser des variables globales et des variables locales dans le même code.

Exemple 4 :Utilisation de variables globales et locales dans le même code

x = "global "

def foo():
    global x
    y = "local"
    x = x * 2
    print(x)
    print(y)

foo()

Sortie

global global 
local

Dans le code ci-dessus, nous déclarons x en tant que global et y comme variable locale dans le foo() . Ensuite, nous utilisons l'opérateur de multiplication * pour modifier la variable globale x et nous imprimons les deux x et y .

Après avoir appelé le foo() , la valeur de x devient global global car nous avons utilisé le x * 2 imprimer deux fois global . Après cela, nous imprimons la valeur de la variable locale y c'est-à-dire local .

Exemple 5 :Variable globale et variable locale de même nom

x = 5

def foo():
    x = 10
    print("local x:", x)


foo()
print("global x:", x)

Sortie

local x: 10
global x: 5

Dans le code ci-dessus, nous avons utilisé le même nom x pour la variable globale et la variable locale. Nous obtenons un résultat différent lorsque nous imprimons la même variable car la variable est déclarée dans les deux portées, c'est-à-dire la portée locale à l'intérieur de foo() et portée globale en dehors de foo() .

Lorsque nous imprimons la variable à l'intérieur de foo() il affiche local x: 10 . C'est ce qu'on appelle la portée locale de la variable.

De même, lorsque nous imprimons la variable en dehors du foo() , il affiche x global :5 . C'est ce qu'on appelle la portée globale de la variable.

Variables non locales

Les variables non locales sont utilisées dans les fonctions imbriquées dont la portée locale n'est pas définie. Cela signifie que la variable ne peut être ni dans la portée locale ni dans la portée globale.

Voyons un exemple d'utilisation d'une variable non locale en Python.

Nous utilisons nonlocal mots-clés pour créer des variables non locales.

Exemple 6 :Créer une variable non locale

def outer():
    x = "local"

    def inner():
        nonlocal x
        x = "nonlocal"
        print("inner:", x)

    inner()
    print("outer:", x)


outer()

Sortie

inner: nonlocal
outer: nonlocal

Dans le code ci-dessus, il y a un inner() imbriqué fonction. Nous utilisons nonlocal mots-clés pour créer une variable non locale. Le inner() la fonction est définie dans le périmètre d'une autre fonction outer() .

Remarque :Si on change la valeur d'une variable non locale, les changements apparaissent dans la variable locale.

Fonction Python Anonyme/Lambda Mot-clé global Python

Python