Est-il possible de modifier les variables en python qui est à l'extérieur, mais pas global, de la portée?

Donné le code suivant:

def A() :
    b = 1

    def B() :
        # I can access 'b' from here.
        print( b )
        # But can i modify 'b' here? 'global' and assignment will not work.

    B()
A()

Pour le code de B() variable de fonction b est à l'extérieur de la portée, mais pas dans la portée globale. Est-il possible de modifier b variable de l'intérieur B() fonction? Certes, je peux le lire à partir d'ici et print(), mais comment le modifier?

Python 3 ou 2 ?
Désolé, bien sûr 2.7 :). Pour python 3 règles de portée a changé.
Vous pouvez aussi longtemps que b est mutable. Une cession à b masque l'extérieur de la portée.
C'est l'un de Python embarras que nonlocal n'a pas été portée à 2.x. C'est une partie intrinsèque de soutien de fermeture.

InformationsquelleAutor grigoryvp | 2011-12-09

python python-2.7

71

Python 3.x a la non mot clé. Je pense que cela ne ce que vous voulez, mais je ne suis pas sûr si vous êtes en cours d'exécution python 2 ou 3.

La non déclaration provoque la liste des identifiants pour se référer à
précédemment liés à des variables dans le plus proche du cadre englobant. C'est
important parce que le comportement par défaut pour la liaison est à la recherche de la
espace de noms local d'abord. La déclaration permet à encapsulé code de
relier des variables en dehors de la portée locale en plus de la mondiale
(module) champ d'application.

Pour python 2, j'ai l'habitude de simplement utiliser un objet mutable (comme une liste, ou dict), et muter la valeur au lieu de les réaffecter.

exemple:
```
def foo():
    a = []
    def bar():
        a.append(1)
    bar()
    bar()
    print a

foo()
```
Sorties:
```
[1, 1]
```
- Une belle façon de le faire est class nonlocal: pass à l'extérieur de la portée. Puis nonlocal.x peut être affecté dans l'intérieur de la portée.
- Jusqu'à maintenant, j'ai déjà deux python conseils qui sont simples, mais très utiles: le vôtre est le deuxième 🙂 Merci @kindall!
- c'est un très bon hack - c'est peu différente de la syntaxe de Python 3 et beaucoup plus lisible que de passer un objet mutable.
- très soigné tas merci 🙂 probablement besoin d'un nom différent, mais parce que ça casse la compatibilité ascendante. En python 3, c'est un mot-clé conflit et sera la cause d'une SyntaxError. Peut-être NonLocal ?
- ou peut-être outer pourrait fonctionner...
- ou, puisque c'est techniquement une classe, Nonlocal? 🙂
- Exemple de code ici: stackoverflow.com/questions/1261875/python-nonlocal-statement
InformationsquelleAutor Adam Wagner
16

Vous pouvez utiliser une classe vide de tenir une temporaire de la portée. C'est comme la mutable mais un peu plus joli.
```
def outer_fn():
   class FnScope:
     b = 5
     c = 6
   def inner_fn():
      FnScope.b += 1
      FnScope.c += FnScope.b
   inner_fn()
   inner_fn()
   inner_fn()
```
Ce rendements suivants interactive sortie:
```
>>> outer_fn()
8 27
>>> fs = FnScope()
NameError: name 'FnScope' is not defined
```
- C'est bizarre que la classe avec ses champs est "visible" dans une fonction interne, mais les variables ne sont pas, à moins que vous définissez à l'extérieur de la variable avec le "non" mot-clé.
InformationsquelleAutor chrisk
8

Je suis un peu en Python, mais j'ai lu un peu à ce sujet. Je crois que le mieux que vous allez obtenir est similaire à Java contourner ce problème, qui est d'envelopper votre extérieur variable dans une liste.
```
def A():
   b = [1]
   def B():
      b[0] = 2
   B()
   print(b[0])

# The output is '2'
```
Edit: je suppose que c'était probablement vrai avant de Python 3. Ressemble nonlocal est votre réponse.
- oui, je sais tous ces trucs. Comme A. b = 1 etc.
InformationsquelleAutor Mike Edwards
4

Pas vous ne pouvez pas, au moins de cette manière.

Parce que le "jeu de l'opération" permettra de créer un nouveau nom dans le champ d'application actuel, qui couvre l'extérieur.
- " qui couvrent l'extérieur" Que voulez-vous dire ? La définition d'un objet avec le nom de b dans une fonction imbriquée n'a aucune influence sur un objet avec le même nom dans l'espace extérieur de cette fonction
- c'est, là où l'instruction d'affectation est, il va introduire le nom de l'ensemble de la portée actuelle. Comme la question de l'exemple de code, si elle est: def C():print( b ) b=2 b=2" introduire le nom de b dans l'ensemble C func champ d'application, de sorte que lors de l'impression(b), il va essayer d'obtenir b dans le local C func portée, mais pas de l'extérieur, le local b a pas encore initialisé, donc il y aura une erreur.
InformationsquelleAutor zchenah
2

Pour tous ceux qui cherchent à ce que beaucoup plus tard sur un plus sûr, mais plus lourd de la solution de contournement est. Sans besoin de passer des variables comme paramètres.
```
def outer():
    a = [1]
    def inner(a=a):
        a[0] += 1
    inner()
    return a[0]
```
InformationsquelleAutor Michael Giba
1

Je ne pense pas que vous devrait envie de le faire. Les fonctions qui peuvent changer les choses dans leur joignant contexte sont dangereux, que ce contexte peut être écrit sans la connaissance de la fonction.

On pourrait le rendre explicite, soit en apportant des B une méthode publique et C une méthode privée dans une classe (la meilleure façon sans doute); ou en utilisant une mutable type comme une liste et de les transmettre explicitement à C:
```
def A():
    x = [0]
    def B(var): 
        var[0] = 1
    B(x)
    print x

A()
```
- Comment pouvez-vous écrire une fonction sans en connaître les fonctions imbriquées à l'intérieur? Fonctions imbriquées et les fermetures sont une partie intrinsèque de la fonction qu'ils sont enfermés dans des.
- Vous devez savoir à propos de l'interface avec les fonctions enfermé dans le vôtre, mais vous ne devriez pas avoir à connaître ce qui se passe à l'intérieur. Aussi, vous ne pouvez pas attendre de savoir ce qui se passe dans les fonctions de ils appel, etc! Si une fonction modifie un non-globales ou non classmember il devrait normalement rendre explicite, par le biais de son interface, c'est à dire prendre comme paramètre.
- Python ne vous force pas à être si bon, bien sûr, d'où le nonlocal mot-clé - mais c'est à vous de l'utiliser avec une grande prudence.
- Je n'ai jamais trouvé grâce aux fermetures de ce genre pour être dangereux à tous, autrement qu'en raison de la langue bizarreries. Pensez à des gens du pays comme une classe temporaire, et les fonctions locales comme les méthodes de la classe, et c'est pas plus compliqué que ça. YMMV, je suppose.
InformationsquelleAutor Sideshow Bob
0

Vous pouvez, mais vous aurez à utiliser le mondial de tresorerie (pas vraiment une bonne solution, comme toujours lors de l'utilisation de variables globales, mais il fonctionne):
```
def A():
    global b
    b = 1

    def B():
      global b
      print( b )
      b = 2

    B()
A()
```
- Voir ma réponse expliquant l'inconvénient potentiel de cette solution
- À l'aide d'une variable globale est complètement différent.
InformationsquelleAutor Cédric Julien

Je ne sais pas si il y a un attribut d'une fonction qui donne la __dict__ de l'espace extérieur de la fonction lors de cet espace extérieur n'est pas l'espace mondial == le module, ce qui est le cas lorsque la fonction est une fonction imbriquée, en Python 3.

Mais en Python 2, pour autant que je sais, il n'y a pas un tel attribut.

De sorte que la seule possibilité de faire ce que vous voulez, c'est:

1) à l'aide d'un objet mutable, comme dit par d'autres

def A() :
    b = 1
    print 'b before B() ==', b

    def B() :
        b = 10
        print 'b ==', b
        return b

    b = B()
    print 'b after B() ==', b

A()

résultat

b before B() == 1
b == 10
b after B() == 10

Nota

La solution de Cédric Julien a un inconvénient:

def A() :
    global b # N1
    b = 1
    print '   b in function B before executing C() :', b

    def B() :
        global b # N2
        print '     b in function B before assigning b = 2 :', b
        b = 2
        print '     b in function B after  assigning b = 2 :', b

    B()
    print '   b in function A , after execution of B()', b

b = 450
print 'global b , before execution of A() :', b
A()
print 'global b , after execution of A() :', b

résultat

global b , before execution of A() : 450
   b in function B before executing B() : 1
     b in function B before assigning b = 2 : 1
     b in function B after  assigning b = 2 : 2
   b in function A , after execution of B() 2
global b , after execution of A() : 2

Le mondial b après l'exécution de A() a été modifié et il est peut-être pas whished donc

C'est le cas seulement si il existe un objet avec un identifiant b dans l'espace de noms global

InformationsquelleAutor eyquem

Vous devez vous connecter pour publier un commentaire.