Biorąc pod uwagę następujący kod:

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

Ponieważ kod w B()zmiennej funkcji bznajduje się w zakresie zewnętrznym, ale nie w zasięgu globalnym. Czy można modyfikować bzmienną z poziomu B()funkcji? Z pewnością mogę to przeczytać stąd i print(), ale jak to zmodyfikować?

Python 3.x ma nonlocalsłowo kluczowe . Myślę, że robi to, co chcesz, ale nie jestem pewien, czy używasz Pythona 2 czy 3.

Instrukcja nielokalna powoduje, że wymienione identyfikatory odwołują się do poprzednio powiązanych zmiennych w najbliższym obejmującym zakresie. Jest to ważne, ponieważ domyślne zachowanie wiązania polega na przeszukaniu najpierw lokalnej przestrzeni nazw. Instrukcja umożliwia hermetyzowanemu kodowi ponowne wiązanie zmiennych poza zakresem lokalnym poza zakresem globalnym (modułu).

W przypadku Pythona 2 zwykle używam po prostu zmiennego obiektu (takiego jak lista lub dict) i mutuję wartość zamiast ponownie przypisywać.

przykład:

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

foo()

Wyjścia:

[1, 1]

Możesz użyć pustej klasy do przechowywania tymczasowego zakresu. To jest jak zmienne, ale trochę ładniejsze.

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

Daje to następujące interaktywne wyjście:

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

Jestem trochę nowy w Pythonie, ale trochę o tym czytałem. Uważam, że najlepsze, co uzyskasz, jest podobne do obejścia w Javie, które polega na zawinięciu zewnętrznej zmiennej w listę.

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

# The output is '2'

Edycja: Wydaje mi się, że to prawdopodobnie prawda przed Pythonem 3. Wygląda na nonlocalto, że to twoja odpowiedź.

Nie, nie możesz, przynajmniej w ten sposób.

Ponieważ „operacja set” utworzy nową nazwę w obecnym zakresie, który obejmuje zakres zewnętrzny.

Dla każdego, kto patrzy na to znacznie później, jest bezpieczniejsze, ale cięższe obejście. Bez potrzeby przekazywania zmiennych jako parametrów.

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

Krótka odpowiedź, która po prostu zadziała automagicznie

Stworzyłem bibliotekę Pythona do rozwiązania tego konkretnego problemu. Jest uwalniany pod wpływem nielubienia, więc używaj go, jak chcesz. Możesz go zainstalować za pomocą pip install seapielub sprawdzić stronę główną tutaj 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()

wyjścia

2

argumenty mają następujące znaczenie:

• Pierwszy argument to zakres wykonania. 0 oznaczałoby lokalny B(), 1 oznacza rodzica, A()a 2 oznaczałoby dziadka <module>znanego jako globalny
• Drugi argument to łańcuch lub obiekt kodu, który chcesz wykonać w danym zakresie
• Możesz również wywołać ją bez argumentów dla powłoki interaktywnej w swoim programie

Długa odpowiedź

To jest bardziej skomplikowane. Seapie działa poprzez edycję ramek w stosie wywołań przy użyciu interfejsu API CPython. CPython jest de facto standardem, więc większość ludzi nie musi się tym martwić.

Magiczne słowa, które prawdopodobnie najprawdopodobniej Cię interesują, jeśli to czytasz, to:

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

Ten ostatni wymusi przejście aktualizacji do zakresu lokalnego. Zasięg lokalny jest jednak optymalizowany inaczej niż zasięg globalny, więc wprowadzenie nowych obiektów powoduje pewne problemy przy próbie wywołania ich bezpośrednio, jeśli nie zostały one w żaden sposób zainicjowane. Skopiuję kilka sposobów obejścia tych problemów ze strony github

• Wcześniej przypisz, zaimportuj i zdefiniuj swoje obiekty
• Wcześniej przypisuj obiekt zastępczy do obiektów
• Ponownie przypisz obiekt do siebie w programie głównym, aby zaktualizować tablicę symboli: x = locals () ["x"]
• Użyj funkcji exec () w programie głównym zamiast bezpośredniego wywoływania, aby uniknąć optymalizacji. Zamiast wywoływać x wykonaj: exec ("x")

Jeśli czujesz, że używanie exec()nie jest czymś, z czym chciałbyś iść, możesz emulować zachowanie, aktualizując prawdziwy słownik lokalny (a nie ten zwracany przez locals ()). Skopiuję przykład z 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()

Wynik:

hack!

Myślę, że nie powinieneś tego chcieć. Funkcje, które mogą zmieniać rzeczy w otaczającym ich kontekście, są niebezpieczne, ponieważ ten kontekst można zapisać bez znajomości funkcji.

Możesz to uczynić jawnym, albo przez uczynienie B metodą publiczną, a C metodą prywatną w klasie (prawdopodobnie najlepszy sposób); lub używając zmiennego typu, takiego jak lista, i przekazując go jawnie do C:

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

A()

Możesz, ale będziesz musiał użyć statystyki globalnej (niezbyt dobre rozwiązanie, jak zawsze, gdy używasz zmiennych globalnych, ale działa):

def A():
    global b
    b = 1

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

    B()
A()

Nie wiem, czy istnieje atrybut funkcji, który daje __dict__przestrzeń zewnętrzną funkcji, gdy ta przestrzeń zewnętrzna nie jest przestrzenią globalną == moduł, co ma miejsce, gdy funkcja jest funkcją zagnieżdżoną, w Pythonie 3.

Ale w Pythonie 2, o ile wiem, nie ma takiego atrybutu.

Więc jedyne możliwości robienia tego, co chcesz, to:

1) używanie zmiennego obiektu, jak mówią inni

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

wynik

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

.

Nota

Rozwiązanie Cédrica Juliena ma wadę:

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

wynik

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

Globalne b po wykonaniu A()zostało zmodyfikowane i może być inaczej

Dzieje się tak tylko wtedy, gdy istnieje obiekt o identyfikatorze b w globalnej przestrzeni nazw