web-dev-qa-db-fra.com

Comment rendre une variable locale (à l'intérieur d'une fonction) globale

Duplicate possible:
tilisation de variables globales dans une fonction autre que celle qui les a créées

J'utilise des fonctions pour que mon programme ne soit pas un désordre, mais je ne sais pas comment transformer une variable locale en variable globale.

pythonfunctionglobal-variableslocal
29
user1396297

Voici deux méthodes pour réaliser la même chose:

tilisation des paramètres et retour (recommandé)

def other_function(parameter):
    return parameter + 5

def main_function():
    x = 10
    print x    
    x = other_function(x)
    print x

Quand vous courez main_function, vous obtiendrez le résultat suivant

>>> 10
>>> 15

tilisation de globals (ne jamais faire cela)

x = 0   # The initial value of x, with global scope

def other_function():
    global x
    x = x + 5

def main_function():
    print x    # Just printing - no need to declare global yet
    global x   # So we can change the global x
    x = 10
    print x
    other_function()
    print x

Maintenant, vous aurez:

>>> 0    # Initial global value
>>> 10   # Now we've set it to 10 in `main_function()`
>>> 15   # Now we've added 5 in `other_function()`
27
Alex L

Déclarez simplement votre variable en dehors de toute fonction:

globalValue = 1

def f(x):
    print(globalValue + x)

Si vous avez besoin de assigner au global depuis la fonction, utilisez l'instruction global:

def f(x):
    global globalValue
    print(globalValue + x)
    globalValue += 1
13
Greg Hewgill

Si vous avez besoin d'accéder aux états internes d'une fonction, vous feriez mieux d'utiliser une classe. Vous pouvez faire en sorte qu'une instance de classe se comporte comme une fonction en la rendant appelable, en définissant __call__:

class StatefulFunction( object ):
    def __init__( self ):
        self.public_value = 'foo'

    def __call__( self ):
        return self.public_value


>> f = StatefulFunction()
>> f()
`foo`
>> f.public_value = 'bar'
>> f()
`bar`
9
Matthew Trevor

L'utilisation de globals créera également un désastre pour votre programme. Je vous suggère donc de faire tout votre possible pour les éviter. Cela dit, "global" est un mot clé en python, vous pouvez donc désigner une variable particulière comme une variable globale, comme suit:

def foo():
    global bar
    bar = 32

Je devrais mentionner qu'il est extrêmement rare que le mot clé "global" soit utilisé. Je suggère donc sérieusement de repenser votre conception.

6
Arafangion

Vous pouvez utiliser la portée du module. Supposons que vous ayez un module appelé utils:

f_value = 'foo'

def f():
    return f_value

f_value est un attribut de module qui peut être modifié par tout autre module qui l’importe. Comme les modules sont des singletons, toute modification apportée à utils d'un module sera accessible à tous les autres modules qui l'ont importé:

>> import utils
>> utils.f()
'foo'
>> utils.f_value = 'bar'
>> utils.f()
'bar'

Notez que vous pouvez importer la fonction par son nom:

>> import utils
>> from utils import f
>> utils.f_value = 'bar'
>> f()
'bar'

Mais pas l'attribut:

>> from utils import f, f_value
>> f_value = 'bar'
>> f()
'foo'

En effet, vous appelez l'objet référencé par l'attribut du module comme étant f_value dans la portée locale, puis en la liant à la chaîne bar, alors que la fonction f fait toujours référence à l'attribut module.

4
Matthew Trevor