L'utilisation de variables globales dans une fonction

Si je suis la compréhension de votre situation correctement, ce que vous voyez est le résultat de la façon Python gère local (fonction) et le global (module) les espaces de noms.

Dire que vous avez un module comme ceci:

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

Vous pourriez vous attendent pour imprimer 42, mais au lieu de l'impression 5. Comme cela a déjà été mentionné, si vous ajoutez un " global " déclaration de func1(), puis func2() imprime 42.

def func1():
    global myGlobal
    myGlobal = 42

Ce qui se passe ici est que Python suppose que tout nom qui est attribué à, n'importe où au sein d'une fonction est locale à cette fonction, sauf s'il est explicitement dit dans le cas contraire. Si c'est seulement lecture à partir d'un nom, et le nom n'existe pas localement, il va essayer de trouver le nom dans tout contenant étendues (par exemple, le module de portée mondiale).

Lorsque vous affectez 42 pour le nom myGlobal, par conséquent, Python crée une variable locale que les ombres de la variable globale du même nom. Que le local est hors de portée et est le garbage collector quand func1() retourne; pendant ce temps, func2() ne peut jamais voir autre chose que de la (non modifié) nom global. Notez que cet espace de décision qui se passe au moment de la compilation, et non pas à l'exécution -- si vous étiez à la lecture de la valeur de myGlobal à l'intérieur de func1() avant d'attribuer à elle, vous obtiendrez un UnboundLocalError, parce que Python a déjà décidé qu'il doit être une variable locale, mais il n'a pas eu du tout de valeur associée avec elle encore. Mais en utilisant la " global déclaration, vous dites à Python qu'il faut chercher ailleurs pour le nom au lieu de les affecter à l'échelle locale.

(Je crois que ce comportement trouve son origine principalement par le biais d'une optimisation locale des espaces de noms, sans ce comportement, Python VM devra effectuer au moins trois recherches de noms à chaque fois un nouveau nom est attribué à l'intérieur d'une fonction (pour s'assurer que le nom n'existe pas déjà au module/builtin niveau), qui permettrait de ralentir une opération très courante.)

Python utilise une simple heuristique de décider qui il doit charger une variable à partir d', entre le local et le global. Si un nom de variable apparaît sur le côté gauche d'une affectation, mais n'est pas déclaré mondiale, il est considéré comme local. Si elle n'apparaît pas sur le côté de main 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 affectation dans foo(), est la seule LOAD_FAST variable.

En plus de la déjà les réponses existantes et de le rendre plus confus:

En Python, les variables qui ne sont référencés à l'intérieur d'une fonction sont
implicitement mondiale. Si une variable est affectée d'une valeur de n'importe où
au sein de la fonction du corps, il est supposé pour être un local. Si une variable
est jamais assigner une nouvelle valeur à l'intérieur de la fonction, la variable est
implicitement local, et vous avez besoin de l'indiquer explicitement que "global".

Bien qu'un peu surprenant au premier abord, un moment de explique
c'. D'une part, exigeant mondial pour les variables assignées fournit un
bar contre les effets secondaires imprévus. D'autre part, si le mondial était
requis pour toutes les références globales, vous seriez en utilisant mondiale de tous les
temps. Vous devez déclarer comme mondiales chaque référence à un construit-dans
fonction ou à un composant d'un module importé. Ce serait le désordre
la défaite de l'utilité de la déclaration mondiale pour l'identification
des effets secondaires.

Source: Quelles sont les règles pour des variables locales et globales en Python?.

Avec l'exécution en parallèle, les variables globales peuvent provoquer des résultats inattendus si vous ne comprenez pas ce qui se passe. Voici un exemple d'utilisation d'une variable globale dans le traitement multiple. Nous pouvons clairement voir que chaque processus fonctionne avec sa propre copie de la variable:

import multiprocessing
import os
import random
import sys
import time

def worker(new_value):
    old_value = get_value()
    set_value(random.randint(1, 99))
    print('pid=[{pid}] '
          'old_value=[{old_value:2}] '
          'new_value=[{new_value:2}] '
          'get_value=[{get_value:2}]'.format(
          pid=str(os.getpid()),
          old_value=old_value,
          new_value=new_value,
          get_value=get_value()))

def get_value():
    global global_variable
    return global_variable

def set_value(new_value):
    global global_variable
    global_variable = new_value

global_variable = -1

print('before set_value(), get_value() = [%s]' % get_value())
set_value(new_value=-2)
print('after  set_value(), get_value() = [%s]' % get_value())

processPool = multiprocessing.Pool(processes=5)
processPool.map(func=worker, iterable=range(15))

De sortie:

before set_value(), get_value() = [-1]
after  set_value(), get_value() = [-2]
pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]
pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]
pid=[53970] old_value=[23] new_value=[ 4] get_value=[50]
pid=[53970] old_value=[50] new_value=[ 6] get_value=[14]
pid=[53971] old_value=[42] new_value=[ 5] get_value=[31]
pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]
pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]
pid=[53970] old_value=[14] new_value=[ 7] get_value=[21]
pid=[53971] old_value=[31] new_value=[ 8] get_value=[34]
pid=[53972] old_value=[44] new_value=[ 9] get_value=[59]
pid=[53973] old_value=[94] new_value=[10] get_value=[87]
pid=[53970] old_value=[21] new_value=[11] get_value=[21]
pid=[53971] old_value=[34] new_value=[12] get_value=[82]
pid=[53972] old_value=[59] new_value=[13] get_value=[ 4]
pid=[53973] old_value=[87] new_value=[14] get_value=[70]

Ce que vous dites est d'utiliser la méthode comme ceci:

globvar = 5

def f():
    var = globvar
    print(var)

f()  # Prints 5

Mais la meilleure façon est d'utiliser la variable globale comme ceci:

globavar = 5
def f():
    global globvar
    print(globvar)
f()   #prints 5

Les deux donnent le même résultat.

Vous n'êtes pas en train de ranger le global dans le local d'une variable, il suffit de créer un local de référence au même objet que l'original de votre référence à l'échelle mondiale se réfère. Rappelez-vous que presque tout en Python est un nom faisant référence à un objet, et que rien n'est copié dans le fonctionnement habituel.

Si vous n'avez pas à spécifier explicitement lorsqu'un identifiant pour se référer à un global prédéfini, alors vous seriez probablement avoir à spécifier de manière explicite lorsqu'un identificateur est une nouvelle variable locale à la place (par exemple, avec quelque chose comme le 'var' commande vu en JavaScript). Puisque les variables locales sont plus courantes que les variables globales dans les graves et non-triviale du système, Python système a plus de sens dans la plupart des cas.

Vous pourrait ont une langue qui tentent de deviner, à l'aide d'une variable globale si elle existait ou de créer une variable locale si elle n'a pas. Cependant, ce serait très sujettes à l'erreur. Par exemple, l'importation d'un autre module peut introduire par inadvertance une variable globale du même nom, un changement de comportement de votre programme.

Dans le cas où vous avez une variable locale avec le même nom, vous pouvez utiliser le globals() function.

globals()['your_global_var'] = 42

Écrit explicite les éléments d'un tableau global n'a apparemment pas besoin de la déclaration mondiale, bien que la rédaction de ce "gros" n'ont que la même exigence:

import numpy as np

hostValue = 3.14159
hostArray = np.array([2., 3.])
hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])

def func1():
    global hostValue    # mandatory, else local.
    hostValue = 2.0

def func2():
    global hostValue    # mandatory, else UnboundLocalError.
    hostValue += 1.0

def func3():
    global hostArray    # mandatory, else local.
    hostArray = np.array([14., 15.])

def func4():            # no need for globals
    hostArray[0] = 123.4

def func5():            # no need for globals
    hostArray[1] += 1.0

def func6():            # no need for globals
    hostMatrix[1][1] = 12.

def func7():            # no need for globals
    hostMatrix[0][0] += 0.33

func1()
print "After func1(), hostValue = ", hostValue
func2()
print "After func2(), hostValue = ", hostValue
func3()
print "After func3(), hostArray = ", hostArray
func4()
print "After func4(), hostArray = ", hostArray
func5()
print "After func5(), hostArray = ", hostArray
func6()
print "After func6(), hostMatrix = \n", hostMatrix
func7()
print "After func7(), hostMatrix = \n", hostMatrix

Je suis en ajoutant ce que je n'ai pas vu les autres réponses et il pourrait être utile pour quelqu'un aux prises avec quelque chose de similaire. Le globals() fonction renvoie une mutable symbole mondial de dictionnaire où vous pouvez "comme par magie" rendre les données disponibles pour le reste de votre code.
Par exemple:

from pickle import load
def loaditem(name):
    with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile:
        globals()[name] = load(openfile)
    return True

et

from pickle import dump
def dumpfile(name):
    with open(name+".dat", "wb") as outfile:
        dump(globals()[name], outfile)
    return True

Va vous laisser de sauvegarde/chargement des variables et dans l'espace de noms global. Super pratique, pas muss, pas de chichi. Assez sûr que c'est Python 3.