Utilisation du mot-clé "global" en Python

Question

D'après ce que j'ai compris, Python dispose d'un espace de noms distinct pour les fonctions, donc si je veux utiliser une variable globale dans une fonction, je devrais probablement utiliser global .

Cependant, j'ai été en mesure d'accéder à une variable globale même sans global :

>>> sub = ['0', '0', '0', '0']
>>> def getJoin():
...     return '.'.join(sub)
...
>>> getJoin()
'0.0.0.0'

Est-ce que je rate quelque chose ? En outre, ce qui suit est tiré de la documentation Python :

Noms listés dans une déclaration globale ne doivent pas être définis comme des paramètres formels ou dans une boucle de contrôle for cible, définition de classe, fonction ou une déclaration d'importation.

Si les paramètres formels et la définition de la classe me paraissent logiques, je ne comprends pas la restriction concernant la cible de contrôle de la boucle for et la définition de la fonction.

Answer 1

Le mot-clé global n'est utile que pour modifier ou créer des variables globales dans un contexte local, bien que la création de variables globales soit rarement considérée comme une bonne solution.

def bob():
    me = "locally defined"    # Defined only in local context
    print(me)

bob()
print(me)     # Asking for a global variable

Ce qui précède vous donnera :

locally defined
Traceback (most recent call last):
  File "file.py", line 9, in <module>
    print(me)
NameError: name 'me' is not defined

Alors que si vous utilisez le global la variable devient disponible "en dehors" de la portée de la fonction, devenant ainsi une variable globale.

def bob():
    global me
    me = "locally defined"   # Defined locally but declared as global
    print(me)

bob()
print(me)     # Asking for a global variable

Donc le code ci-dessus vous donnera :

locally defined
locally defined

En outre, en raison de la nature de python, vous pourriez également utiliser global pour déclarer des fonctions, des classes ou d'autres objets dans un contexte local. Cependant, je vous le déconseille car cela provoque des cauchemars si quelque chose ne va pas ou nécessite un débogage.

Answer 2

Bien que vous puissiez accéder aux variables globales sans l'option global si vous voulez les modifier, vous devez utiliser le mot-clé global mot-clé. Par exemple :

foo = 1
def test():
    foo = 2 # new local foo

def blub():
    global foo
    foo = 3 # changes the value of the global foo

Dans votre cas, vous accédez simplement à la liste sub .

Answer 3

C'est la différence entre l'accès, le nom et la liaison à l'intérieur d'un champ.

Si vous êtes simplement à la recherche d'un variable pour lire sa valeur, vous avez accès au niveau mondial ainsi qu'une portée locale.

Toutefois, si vous affecter à une variable dont le nom n'est pas dans la portée locale, vous êtes à la liaison de ce nom dans ce champ (et si ce nom existe également en tant que global, vous aurez le cacher).

Si vous voulez être en mesure d'attribuer le nom global, vous devez dire à l'analyseur à l'utilisation de la dénomination globale plutôt que de lier un nouveau nom local - qui est ce que le "global" mot-clé.

La liaison n'importe où à l'intérieur d'un bloc fait que le nom partout dans ce bloc à être liés, ce qui peut provoquer certaines plutôt bizarre, conséquences (p. ex. UnboundLocalError soudainement apparaître précédemment code de travail).

>>> a = 1
>>> def p():
    print(a) # accessing global scope, no binding going on
>>> def q():
    a = 3 # binding a name in local scope - hiding global
    print(a)
>>> def r():
    print(a) # fail - a is bound to local scope, but not assigned yet
    a = 4
>>> p()
1
>>> q()
3
>>> r()
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    r()
  File "<pyshell#32>", line 2, in r
    print(a) # fail - a is bound to local scope, but not assigned yet
UnboundLocalError: local variable 'a' referenced before assignment
>>> 

Answer 4

Les autres réponses répondent à votre question. Une autre chose importante à savoir sur les noms en Python est qu'ils sont soit locaux, soit globaux sur une base per-scope.

Considérez ceci, par exemple :

value = 42

def doit():
    print value
    value = 0

doit()
print value

Vous pouvez probablement deviner que le value = 0 sera affectée à une variable locale et n'affectera pas la valeur de la même variable déclarée en dehors de l'instruction doit() fonction. Vous serez peut-être plus surpris de découvrir que le code ci-dessus ne fonctionnera pas. La déclaration print value à l'intérieur de la fonction produit un UnboundLocalError.

La raison en est que Python a remarqué que, ailleurs dans la fonction, vous attribuez le nom value et aussi value n'est déclaré nulle part global . Cela en fait une variable locale. Mais lorsque vous essayez de l'imprimer, le nom local n'a pas encore été défini. Python dans ce cas ne retombe pas plutôt que de rechercher le nom en tant que variable globale, comme le font certains autres langages. En fait, vous ne pouvez pas accéder à une variable globale si vous avez défini une variable locale du même nom. partout dans la fonction.

Answer 5

Accéder à un nom et attribuer un nom sont deux choses différentes. Dans votre cas, vous accédez simplement à un nom.

Si vous assignez une variable dans une fonction, cette variable est supposée être locale à moins que vous ne la déclariez globale. En l'absence de déclaration, elle est considérée comme globale.

>>> x = 1         # global 
>>> def foo():
        print x       # accessing it, it is global

>>> foo()
1
>>> def foo():   
        x = 2        # local x
        print x 

>>> x            # global x
1
>>> foo()        # prints local x
2