Compte tenu du 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 dans la B()variable de fonction best dans la portée externe, mais pas dans la portée globale. Est-il possible de modifier la bvariable à partir de la B()fonction? Je peux sûrement le lire d'ici et print(), mais comment le modifier?

Python 3.x a le nonlocalmot - clé . Je pense que cela fait ce que vous voulez, mais je ne sais pas si vous utilisez python 2 ou 3.

L'instruction non locale fait que les identificateurs répertoriés font référence à des variables précédemment liées dans la portée englobante la plus proche. Ceci est important car le comportement par défaut pour la liaison consiste à rechercher d'abord l'espace de noms local. L'instruction permet au code encapsulé de relier des variables en dehors de la portée locale en plus de la portée globale (module).

Pour python 2, j'utilise généralement simplement un objet mutable (comme une liste ou un dict), et je mute la valeur au lieu de réaffecter.

exemple:

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

foo()

Les sorties:

[1, 1]

Vous pouvez utiliser une classe vide pour contenir une portée temporaire. C'est comme le 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()

Cela donne la sortie interactive suivante:

>>> outer_fn()
8 27
>>> fs = FnScope()
NameError: name 'FnScope' is not defined

Je suis un peu nouveau dans Python, mais j'ai lu un peu à ce sujet. Je pense que le mieux que vous obtiendrez est similaire à la solution de contournement Java, qui consiste à envelopper votre variable externe 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 Python 3. On dirait que nonlocalc'est votre réponse.

Non, vous ne pouvez pas, du moins de cette manière.

Parce que l '"opération set" créera un nouveau nom dans la portée actuelle, qui couvre le nom extérieur.

Pour quiconque regarde cela beaucoup plus tard, une solution de contournement plus sûre mais plus lourde est. Sans avoir besoin de passer des variables comme paramètres.

def outer():
    a = [1]
    def inner(a=a):
        a[0] += 1
    inner()
    return a[0]

La réponse courte qui fonctionnera automatiquement

J'ai créé une bibliothèque python pour résoudre ce problème spécifique. Il est publié sous la dissidence, alors utilisez-le comme vous le souhaitez. Vous pouvez l'installer avec pip install seapieou consulter la page d'accueil ici https://github.com/hirsimaki-markus/SEAPIE

user@pc:home$ pip install seapie

from seapie import Seapie as seapie
def A():
    b = 1

    def B():
        seapie(1, "b=2")
        print(b)

    B()
A()

les sorties

2

les arguments ont la signification suivante:

• Le premier argument est la portée de l'exécution. 0 signifierait local B(), 1 signifie parent A()et 2 signifierait grand-parent <module>aka global
• Le deuxième argument est une chaîne ou un objet de code que vous souhaitez exécuter dans la portée donnée
• Vous pouvez également l'appeler sans arguments pour le shell interactif dans votre programme

La longue réponse

C'est plus compliqué. Seapie fonctionne en éditant les cadres dans la pile d'appels à l'aide de l'API CPython. CPython est la norme de facto, donc la plupart des gens n'ont pas à s'en soucier.

Les mots magiques qui vous intéressent probablement le plus si vous lisez ceci sont les suivants:

frame = sys._getframe(1)          # 1 stands for previous frame
parent_locals = frame.f_locals    # true dictionary of parent locals
parent_globals = frame.f_globals  # true dictionary of parent globals

exec(codeblock, parent_globals, parent_locals)

ctypes.pythonapi.PyFrame_LocalsToFast(ctypes.py_object(frame),ctypes.c_int(1))
# the magic value 1 stands for ability to introduce new variables. 0 for update-only

Ce dernier forcera les mises à jour à passer dans la portée locale. Les portées locales sont cependant optimisées différemment de la portée globale, de sorte que l'introduction de nouveaux objets pose quelques problèmes lorsque vous essayez de les appeler directement s'ils ne sont initialisés d'aucune façon. Je vais copier quelques moyens de contourner ces problèmes à partir de la page github

• Assingn, importer et définir au préalable vos objets
• Assigner au préalable un espace réservé à vos objets
• Réaffecter l'objet à lui-même dans le programme principal pour mettre à jour la table des symboles: x = locals () ["x"]
• Utilisez exec () dans le programme principal au lieu d'appeler directement pour éviter l'optimisation. Au lieu d'appeler x do: exec ("x")

Si vous pensez que l'utilisation exec()n'est pas quelque chose que vous voulez utiliser, vous pouvez émuler le comportement en mettant à jour le vrai dictionnaire local (et non celui renvoyé par les locaux ()). Je vais copier un exemple de https://faster-cpython.readthedocs.io/mutable.html

import sys
import ctypes

def hack():
    # Get the frame object of the caller
    frame = sys._getframe(1)
    frame.f_locals['x'] = "hack!"
    # Force an update of locals array from locals dict
    ctypes.pythonapi.PyFrame_LocalsToFast(ctypes.py_object(frame),
                                          ctypes.c_int(0))

def func():
    x = 1
    hack()
    print(x)

func()

Production:

hack!

Je ne pense pas que tu devrais vouloir faire ça. Les fonctions qui peuvent modifier les choses dans leur contexte englobant sont dangereuses, car ce contexte peut être écrit à l'insu de la fonction.

Vous pouvez le rendre explicite, soit en faisant de B une méthode publique et C une méthode privée dans une classe (le meilleur moyen probablement); ou en utilisant un type mutable tel qu'une liste et en le passant explicitement à C:

def A():
    x = [0]
    def B(var): 
        var[0] = 1
    B(x)
    print x

A()

Vous pouvez, mais vous devrez utiliser la déclaration globale (ce n'est pas une très bonne solution comme toujours lorsque vous utilisez des variables globales, mais cela fonctionne):

def A():
    global b
    b = 1

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

    B()
A()

Je ne sais pas s'il y a un attribut d'une fonction qui donne le __dict__de l'espace extra-atmosphérique de la fonction quand cet espace extérieur n'est pas l'espace global == le module, ce qui est le cas lorsque la fonction est une fonction imbriquée, en Python 3.

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

Donc, les seules possibilités pour faire ce que vous voulez sont:

1) utiliser un objet mutable, comme l'ont dit d'autres

2)

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 présente 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 b global après exécution deA() a été modifié et il peut ne pas être souhaité ainsi

C'est le cas uniquement s'il y a un objet avec l'identifiant b dans l'espace de noms global