Python >> Tutoriel Python >  >> Python

Comment utiliser des variables globales dans une fonction Python ?

Résumé : Utilisez le global mot clé pour déclarer une variable globale dans la portée locale d'une fonction afin qu'elle puisse également être modifiée ou utilisée en dehors de la fonction. Pour utiliser des variables globales dans les modules, créez un module de configuration spécial et importez le module dans notre programme principal. Le module est disponible en tant que nom global dans notre programme. Comme chaque module a une seule instance, toute modification apportée à l'objet module est répercutée partout.

Problème : Étant donné une fonction; comment y utiliser une variable globale ?

Exemple :

def foo():
  # Some syntax to declare the GLOBAL VARIABLE "x"
  x = 25 # Assigning the value to the global variable "x"

def func():
# Accessing global variable defined in foo()   
  y = x+25
  print("x=",x,"y=",y)

foo()
func()

Résultat attendu :

x= 25 y= 50

Dans l'exemple ci-dessus, on nous a donné une fonction nommée foo() qui renvoie une variable globale x tel que la valeur de x peut être utilisé dans une autre fonction nommée func() . Voyons rapidement comment nous pouvons utiliser le global mot-clé pour résoudre notre problème.

Solution : utilisation de l'outil Global Mot clé

Nous pouvons utiliser le global comme préfixe à n'importe quelle variable afin de la rendre globale dans une portée locale.

def foo():
  global x
  x = 25

def func():
  y = x+25
  print("x=",x,"y=",y)

foo()
func()

Sortie :

x= 25 y= 50

Maintenant que nous connaissons déjà notre solution, nous devons passer en revue certains des concepts de base nécessaires à une solide compréhension de notre solution. Alors, sans plus tarder, discutons-en un par un.

Portée variable en Python

La portée d'une variable est la région ou la partie du programme où la variable est accessible directement. Discutons des différentes étendues de variables disponibles en Python.

Portée locale

Lorsqu'une variable est créée à l'intérieur d'une fonction, elle n'est disponible que dans le cadre de cette fonction et cesse d'exister si elle est utilisée en dehors de la fonction. Ainsi la variable appartient à la portée locale de la fonction.

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

foo()

Sortie :

local

Champ d'application

Une portée englobante se produit lorsque nous avons des fonctions imbriquées. Lorsque la variable est dans la portée de la fonction extérieure, cela signifie que la variable est dans la portée englobante de la fonction. Par conséquent, la variable est visible dans le cadre des fonctions internes et externes.

Exemple :

def foo():
  scope = "enclosed"
  def func():
    print(scope)
  func()

foo()

sortie :

enclosed

Dans l'exemple ci-dessus, la variable scope est à l'intérieur de la portée englobante de la fonction foo() et disponible dans le foo() ainsi que func() fonctions.

Portée mondiale

Une variable globale est une variable qui est déclarée dans une portée globale et peut être utilisé dans l'ensemble du programme ; cela signifie qu'il est accessible à l'intérieur comme à l'extérieur de la portée d'une fonction. Une variable globale est généralement déclarée en dehors des fonctions, dans le corps principal du code Python.

Exemple :

name = "FINXTER"

def foo():
    print("Name inside foo() is ", name)


foo()
print("Name outside foo() is :", name)

Sortie :

Name inside foo() is FINXTER
Name outside foo() is : FINXTER

Dans l'exemple ci-dessus, name est une variable globale accessible à l'intérieur comme à l'extérieur de la portée de la fonction foo(). Voyons ce qui se passe si vous essayez de changer la valeur de la variable globale name à l'intérieur de la fonction.

name = "FINXTER"

def foo():
    name = name + "PYTHON"
    print("Name inside foo() is ", name)


foo()

Sortie :

Traceback (most recent call last):
  File "main.py", line 8, in <module>
    foo()
  File "main.py", line 4, in foo
    name = name + "PYTHON"
UnboundLocalError: local variable 'name' referenced before assignment

Nous obtenons un UnboundLocalError dans ce cas, car Python traite name en tant que variable locale dans foo() et name n'est pas défini dans foo() . Si vous souhaitez en savoir plus sur l'erreur UnboundLocalError et sur la manière de la résoudre, lisez-la dans le didacticiel de notre blog ici.

Portée intégrée

La portée intégrée est la portée la plus large disponible en python et contient des mots clés, des fonctions, des exceptions et d'autres attributs intégrés à Python. Les noms dans la portée intégrée sont disponibles dans tout le programme python. Il est chargé automatiquement au moment de l'exécution d'un programme/script Python.

Exemple :

x = 25
print(id(x))

Sortie :

140170668681696

Dans l'exemple ci-dessus, nous n'avons importé aucun module pour utiliser les fonctions print() ou id() . C'est parce que les deux sont dans la portée intégrée.

Après avoir discuté des étendues de variables en Python, discutons de quelques mots clés très importants en Python par rapport aux portées des variables.

Utiliser des variables globales dans une fonction en utilisant le global Mot clé

Nous avons déjà lu sur la portée globale où nous avons appris que chaque variable déclarée dans le corps principal et en dehors de toute fonction dans le code Python est globale par défaut. Cependant, si nous avons une situation où nous devons déclarer une variable globale à l'intérieur d'une fonction comme dans l'énoncé du problème de cet article, alors le mot-clé global vient à notre secours. Nous utilisons le global keyword à l'intérieur d'une fonction pour rendre une variable globale dans la portée locale. Cela signifie que le mot-clé global nous permet de modifier et d'utiliser une variable en dehors de la portée de la fonction dans laquelle elle a été définie.

Voyons maintenant le programme suivant pour comprendre l'utilisation du global mot-clé.

def foo():
    global name
    name = "PYTHON!"
    print("Name inside foo() is ", name)

foo()
name = "FINXTER "+name
print("Name outside foo() is ", name)

Sortie :

Name inside foo() is  PYTHON!
Name outside foo() is  FINXTER PYTHON!

Dans l'exemple ci-dessus, nous avons un nom de variable globale déclaré dans la portée locale de la fonction foo(). Nous pouvons accéder et modifier cette variable en dehors de la portée de cette variable, comme le montre l'exemple ci-dessus.

POINTS À RETENIR

  • Une variable définie en dehors d'une fonction est globale par défaut.
  • Pour définir une variable globale dans une fonction, nous utilisons le global mot-clé.
  • Une variable à l'intérieur d'une fonction sans le global le mot-clé est local par défaut.
  • Utiliser le global mot-clé pour une variable qui est déjà dans la portée globale, c'est-à-dire en dehors de la fonction n'a aucun effet sur la variable.

Variables globales dans les modules

Afin de partager des informations entre les modules Python au sein du même morceau de code, nous devons créer un module de configuration spécial, appelé config ou cfg module. Nous devons importer ce module dans notre programme. Le module est alors disponible en tant que nom global dans notre programme. Étant donné que chaque module a une seule instance, toute modification apportée à l'objet module est répercutée partout.

Examinons l'exemple suivant pour comprendre comment nous pouvons partager des variables globales entre les modules.

Étape 1 : Le fichier config.py est utilisé pour stocker les variables globales.

Étape 2 : Le fichier modify.py est utilisé pour modifier les variables globales.

Étape 3 : Le fichier main.py est utilisé pour appliquer et utiliser les valeurs modifiées de la variable globale.

Sortie après exécution main.py

Le non local Mot clé

Le nonlocal Le mot clé est utile lorsque nous avons une fonction imbriquée, c'est-à-dire des fonctions ayant des variables dans la portée englobante. En d'autres termes, si vous souhaitez changer/modifier une variable qui se trouve dans la portée de la fonction englobante (fonction externe), vous pouvez utiliser le nonlocal mot-clé.

Exemple :

def foo():
  a = 25
  print("Value of 'a' before calling func = ",a)
  def func():
    nonlocal a
    a=a+20
    print("Value of 'a' inside func = ",a)
  func()
  print("Value of 'a' after exiting func = ",a)

foo()

Sortie :

Value of 'a' before calling func =  25
Value of 'a' inside func =  45
Value of 'a' after exiting func =  45

De l'exemple ci-dessus, il est clair que si nous changeons la valeur d'un nonlocal variable la valeur du local la variable change également.

Conclusion

Les points clés que nous avons appris dans cet article sont :

  1. Portées variables :
    • Portée locale
    • Champ d'application
    • Portée mondiale
    • Portée intégrée
  2. Mots clés importants :
    • Le global Mot-clé
      1. Comment utiliser une variable globale dans une fonction ?
      2. Comment utiliser une variable globale sur plusieurs modules ?
    • Le nonlocal Mot clé

J'espère que vous avez trouvé cet article utile et que vous pourrez facilement appliquer les concepts ci-dessus dans votre code. Veuillez vous abonner et rester à l'écoute pour des articles plus intéressants.