Dado el siguiente código:

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()

Porque el código en la B()función variable bestá en el alcance externo, pero no en el alcance global. ¿Es posible modificar la bvariable desde dentro de la B()función? Seguro que puedo leerlo desde aquí y print(), pero ¿cómo modificarlo?

Python 3.x tiene la nonlocalpalabra clave . Creo que esto hace lo que quieres, pero no estoy seguro de si estás ejecutando Python 2 o 3.

La declaración no local hace que los identificadores enumerados se refieran a variables vinculadas previamente en el ámbito adjunto más cercano. Esto es importante porque el comportamiento predeterminado para el enlace es buscar primero en el espacio de nombres local. La declaración permite que el código encapsulado vuelva a vincular variables fuera del ámbito local además del ámbito global (módulo).

Para python 2, generalmente solo uso un objeto mutable (como una lista o dict) y muto el valor en lugar de reasignarlo.

ejemplo:

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

foo()

Salidas:

[1, 1]

Puede usar una clase vacía para contener un ámbito temporal. Es como el mutable pero un poco más bonito.

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()

Esto produce el siguiente resultado interactivo:

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

Soy un poco nuevo en Python, pero he leído un poco sobre esto. Creo que lo mejor que obtendrá es similar a la solución alternativa de Java, que consiste en envolver su variable externa en una lista.

def A():
   b = [1]
   def B():
      b[0] = 2
   B()
   print(b[0])

# The output is '2'

Editar: Supongo que esto probablemente era cierto antes de Python 3. Parece que nonlocales tu respuesta.

No, no puedes, al menos de esta manera.

Porque la "operación set" creará un nuevo nombre en el ámbito actual, que cubre el exterior.

Para cualquiera que vea esto mucho más tarde, una solución alternativa más segura pero más pesada es. Sin necesidad de pasar variables como parámetros.

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

La respuesta corta que simplemente funcionará automágicamente

Creé una biblioteca de Python para resolver este problema específico. Se lanza bajo la falta de escucha, así que úselo como desee. Puede instalarlo pip install seapieo consultar la página de inicio aquí 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()

salidas

2

los argumentos tienen el siguiente significado:

• El primer argumento es el alcance de ejecución. 0 significaría local B(), 1 significa padre A()y 2 significa abuelo <module>también conocido como global
• El segundo argumento es una cadena o un objeto de código que desea ejecutar en el ámbito dado
• También puede llamarlo sin argumentos para shell interactivo dentro de su programa

La respuesta larga

Esto es más complicado. Seapie funciona editando los marcos en la pila de llamadas usando la api CPython. CPython es el estándar de facto, por lo que la mayoría de la gente no tiene que preocuparse por ello.

Las palabras mágicas que probablemente te interesen más si estás leyendo esto son las siguientes:

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

Esto último obligará a las actualizaciones a pasar al ámbito local. Sin embargo, los ámbitos locales se optimizan de manera diferente al ámbito global, por lo que la introducción de nuevos objetos tiene algunos problemas cuando intenta llamarlos directamente si no se inicializan de ninguna manera. Copiaré algunas formas de eludir estos problemas de la página de github

• Assingn, importe y defina sus objetos de antemano
• Assingn marcador de posición a sus objetos de antemano
• Reasignar el objeto a sí mismo en el programa principal para actualizar la tabla de símbolos: x = locals () ["x"]
• Utilice exec () en el programa principal en lugar de llamar directamente para evitar la optimización. En lugar de llamar a x do: exec ("x")

Si siente que el uso exec()no es algo con lo que quiera ir, puede emular el comportamiento actualizando el diccionario local verdadero (no el devuelto por locals ()). Copiaré un ejemplo 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()

Salida:

hack!

No creo que debas querer hacer esto. Las funciones que pueden alterar cosas en su contexto circundante son peligrosas, ya que ese contexto puede escribirse sin el conocimiento de la función.

Puede hacerlo explícito, ya sea haciendo de B un método público y C un método privado en una clase (probablemente la mejor manera); o usando un tipo mutable como una lista y pasándolo explícitamente a C:

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

A()

Puede, pero tendrá que usar la declaración global (no es una solución realmente buena como siempre cuando se usan variables globales, pero funciona):

def A():
    global b
    b = 1

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

    B()
A()

No sé si hay un atributo de una función que da el __dict__del espacio exterior de la función cuando este espacio exterior no es el espacio global == el módulo, que es el caso cuando la función es una función anidada, en Python 3.

Pero en Python 2, hasta donde yo sé, no existe tal atributo.

Entonces, las únicas posibilidades para hacer lo que quieras son:

1) usar un objeto mutable, como dicen otros

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()

resultado

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

.

No un

La solución de Cédric Julien tiene un inconveniente:

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

resultado

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

La b global después de la ejecución deA() se ha modificado y puede que no se desee

Ese es el caso solo si hay un objeto con el identificador b en el espacio de nombres global