Question Utilisation de variables globales dans une fonction


Comment puis-je créer ou utiliser une variable globale dans une fonction?

Si je crée une variable globale dans une fonction, comment puis-je utiliser cette variable globale dans une autre fonction? Ai-je besoin de stocker la variable globale dans une variable locale de la fonction qui a besoin de son accès?


2466
2018-01-08 05:45


origine


Réponses:


Vous pouvez utiliser une variable globale dans d'autres fonctions en la déclarant global dans chaque fonction qui lui assigne:

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar

set_globvar_to_one()
print_globvar()       # Prints 1

J'imagine que la raison en est que, puisque les variables globales sont si dangereuses, Python veut s'assurer que vous savez vraiment que c'est ce que vous jouez en exigeant explicitement le global mot-clé.

Voir d'autres réponses si vous voulez partager une variable globale entre les modules.


3497
2018-01-08 08:39



Si je comprends bien votre situation, ce que vous voyez est le résultat de la façon dont Python gère les espaces de noms locaux (fonction) et globaux (module).

Dites que vous avez un module comme celui-ci:

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

Vous pourriez vous attendre à imprimer 42, mais à la place il imprime 5. Comme cela a déjà été mentionné, si vous ajoutez un 'global'déclaration à func1(), puis func2() va imprimer 42.

def func1():
    global myGlobal
    myGlobal = 42

Qu'est-ce qui se passe ici est que Python suppose que tout nom qui est assigné à, n'importe où dans une fonction, est local à cette fonction, sauf indication contraire explicite. Si c'est seulement en train de lire À partir d'un nom, et le nom n'existe pas localement, il essaiera de rechercher le nom dans toutes les étendues contenant (par exemple, la portée globale du module).

Lorsque vous affectez 42 au nom myGlobalPar conséquent, Python crée une variable locale qui ombrage la variable globale du même nom. Ce local est hors de portée et est ramasser les ordures quand func1() résultats; pendant ce temps, func2() ne peut jamais voir autre chose que le nom global (non modifié). Notez que cette décision d'espace de noms a lieu au moment de la compilation, pas au moment de l'exécution - si vous lisez la valeur de myGlobal à l'intérieur func1() avant de l'assigner, vous obtiendriez un UnboundLocalError, parce que Python a déjà décidé qu'il doit s'agir d'une variable locale mais qu'elle n'a encore aucune valeur associée. Mais en utilisant le 'global'déclaration, vous dites à Python qu'il devrait chercher ailleurs le nom au lieu de lui assigner localement.

(Je crois que ce comportement provient en grande partie d'une optimisation des espaces de noms locaux - sans ce comportement, la VM de Python devrait effectuer au moins trois recherches de noms chaque fois qu'un nouveau nom est assigné à une fonction (pour s'assurer que le nom t existe déjà au niveau du module / intégré), ce qui ralentirait considérablement une opération très courante.)


660
2018-01-08 09:19



Vous voudrez peut-être explorer la notion de espaces de noms. En Python, le module est l'endroit naturel pour global Les données:

Chaque module a sa propre table de symboles privée, qui est utilisée comme table de symboles globale par toutes les fonctions définies dans le module. Ainsi, l'auteur d'un module peut utiliser des variables globales dans le module sans se soucier des conflits accidentels avec les variables globales d'un utilisateur. D'un autre côté, si vous savez ce que vous faites, vous pouvez toucher les variables globales d'un module avec la même notation que celle utilisée pour faire référence à ses fonctions, modname.itemname.

Une utilisation spécifique de global-dans-un-module est décrite ici - how-do-i-share-global-variables-across-modules, et pour l'exhaustivité les contenus sont partagés ici:

La manière canonique de partager des informations entre les modules au sein d'un même programme consiste à créer un module de configuration spécial (souvent appelé config ou cfg). Il suffit d'importer le module de configuration dans tous les modules de votre application; le module devient alors disponible en tant que nom global. Comme il n'y a qu'une seule instance de chaque module, toutes les modifications apportées à l'objet module sont répercutées partout. Par exemple:

Fichier: config.py

x = 0   # Default value of the 'x' configuration setting

Fichier: mod.py

import config
config.x = 1

Fichier: main.py

import config
import mod
print config.x

175
2018-01-08 05:59



Python utilise une heuristique simple pour décider de quelle portée il devrait charger une variable, entre local et global. Si un nom de variable apparaît sur le côté gauche d'une affectation, mais n'est pas déclaré global, il est supposé être local. S'il n'apparaît pas du côté gauche d'une affectation, il est supposé être global.

>>> import dis
>>> def foo():
...     global bar
...     baz = 5
...     print bar
...     print baz
...     print quux
... 
>>> dis.disassemble(foo.func_code)
  3           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (baz)

  4           6 LOAD_GLOBAL              0 (bar)
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  5          11 LOAD_FAST                0 (baz)
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       

  6          16 LOAD_GLOBAL              1 (quux)
             19 PRINT_ITEM          
             20 PRINT_NEWLINE       
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        
>>> 

Voir comment baz, qui apparaît sur le côté gauche d'une cession dans foo(), est le seul LOAD_FAST variable.


75
2017-07-12 12:35



Si vous voulez faire référence à une variable globale dans une fonction, vous pouvez utiliser global mot-clé pour déclarer quelles variables sont globales. Vous n'avez pas besoin de l'utiliser dans tous les cas (comme quelqu'un prétend ici à tort) - si le nom référencé dans une expression ne peut pas être trouvé dans la portée locale ou dans les fonctions dans lesquelles cette fonction est définie, il est recherché parmi les globaux variables

Toutefois, si vous affectez à une nouvelle variable non déclarée comme globale dans la fonction, elle est implicitement déclarée comme locale et elle peut éclipser toute variable globale existante portant le même nom.

En outre, les variables globales sont utiles, contrairement à certains zélotes de la POO qui prétendent le contraire - en particulier pour les petits scripts, où la POO est exagérée.


47
2018-01-08 09:03



En plus des réponses déjà existantes et pour rendre cela plus confus:

En Python, les variables qui sont seulement référencées dans une fonction sont    implicitement global. Si une variable est affectée d'une nouvelle valeur n'importe où   dans le corps de la fonction, il est supposé être un local. Si une variable   est toujours assigné une nouvelle valeur à l'intérieur de la fonction, la variable est   implicitement local, et vous devez le déclarer explicitement comme «global».

Bien qu'un peu surprenant au début, la considération d'un moment explique   ce. D'une part, exiger global pour les variables assignées fournit un   barre contre les effets secondaires involontaires. D'un autre côté, si global était   requis pour toutes les références mondiales, vous utiliseriez global tous les   temps. Vous devez déclarer comme global chaque référence à un built-in   fonction ou à un composant d'un module importé. Ce fouillis serait   vaincre l'utilité de la déclaration globale pour identifier   Effets secondaires.

La source: Quelles sont les règles pour les variables locales et globales dans Python?.


36
2017-07-04 10:23



Si je crée une variable globale dans une fonction, comment puis-je utiliser cette variable dans une autre fonction?

Nous pouvons créer un global avec la fonction suivante:

def create_global_variable():
    global global_variable # must declare it to be a global first
    # modifications are thus reflected on the module's global scope
    global_variable = 'Foo' 

L'écriture d'une fonction n'exécute pas son code. Nous appelons donc le create_global_variable fonction:

>>> create_global_variable()

Utilisation de globals sans modification

Vous pouvez simplement l'utiliser, tant que vous ne vous attendez pas à changer l'objet vers lequel il pointe:

Par exemple,

def use_global_variable():
    return global_variable + '!!!'

et maintenant nous pouvons utiliser la variable globale:

>>> use_global_variable()
'Foo!!!'

Modification de la variable globale depuis l'intérieur d'une fonction

Pour pointer la variable globale sur un objet différent, vous devez utiliser à nouveau le mot-clé global:

def change_global_variable():
    global global_variable
    global_variable = 'Bar'

Notez qu'après avoir écrit cette fonction, le code qui la modifie ne l'est toujours pas:

>>> use_global_variable()
'Foo!!!'

Donc, après avoir appelé la fonction:

>>> change_global_variable()

nous pouvons voir que la variable globale a été changée. le global_variable le nom pointe maintenant à 'Bar':

>>> use_global_variable()
'Bar!!!'

Notez que "global" dans Python n'est pas vraiment global - c'est seulement global au niveau du module. Il n'est donc disponible que pour les fonctions écrites dans les modules dans lesquels il est global. Les fonctions se souviennent du module dans lequel elles sont écrites, donc quand elles sont exportées dans d'autres modules, elles regardent toujours dans le module dans lequel elles ont été créées pour trouver des variables globales.

Variables locales avec le même nom

Si vous créez une variable locale avec le même nom, elle éclipse une variable globale:

def use_local_with_same_name_as_global():
    # bad name for a local variable, though.
    global_variable = 'Baz' 
    return global_variable + '!!!'

>>> use_local_with_same_name_as_global()
'Baz!!!'

Mais l'utilisation de cette variable locale mal nommée ne modifie pas la variable globale:

>>> use_global_variable()
'Bar!!!'

Notez que vous devez éviter d'utiliser les variables locales avec les mêmes noms que les variables globales, sauf si vous savez exactement ce que vous faites et avez une très bonne raison de le faire. Je n'ai pas encore rencontré une telle raison.


31
2018-01-01 19:55