Дано наступний код:

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

Оскільки код у B()функціональній змінній bзнаходиться у зовнішній області, але не в глобальній області. Чи можна змінювати bзмінну зсередини B()функції? Звичайно, я можу прочитати його звідси і print(), але як це змінити?

Python 3.x має nonlocalключове слово . Я думаю, що це робить те, що ти хочеш, але я не впевнений, чи працюєш у python 2 або 3.

Нелокальний оператор змушує перелічені ідентифікатори посилатися на раніше пов'язані змінні в найближчій області, що обгороджує. Це важливо, оскільки поведінка за замовчуванням для прив'язки - це спочатку пошук локального простору імен. Заява дозволяє інкапсульованому коду відновлювати змінні за межами локальної області, крім глобальної (модульної) області.

Для python 2, як правило, я просто використовую змінений об'єкт (наприклад, список чи диктант) та замінюю значення замість переназначення.

приклад:

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

foo()

Виходи:

[1, 1]

Ви можете використовувати порожній клас, щоб утримувати тимчасовий діапазон. Це як мінливий, але трохи гарніший.

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

Це дає наступний інтерактивний вихід:

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

Я трохи новачок у Python, але я читав трохи про це. Я вважаю, що найкраще, що ви збираєтеся отримати, - це схожа на обробка Java, яка полягає в загортанні зовнішньої змінної у список.

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

# The output is '2'

Редагувати: Я думаю, це було вірно ще до Python 3. Схоже, nonlocalце ваша відповідь.

Ні, ви не можете, принаймні таким чином.

Тому що "встановлена ​​операція" створить нове ім'я в поточному обсязі, яке охоплює зовнішнє.

Для тих, хто дивиться на це набагато пізніше на безпечніший, але важчий спосіб вирішення. Без необхідності передавати змінні як параметри.

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

Коротка відповідь, яка просто працюватиме автоматично

Я створив бібліотеку пітонів для вирішення цієї конкретної проблеми. Він випущений під нерозбірливістю, тому використовуйте його як завгодно. Ви можете встановити його pip install seapieабо перевірити домашню сторінку тут 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()

виходи

2

аргументи мають таке значення:

• Перший аргумент - це сфера виконання. 0 означатиме місцевий B(), 1 означає батьківський A()і 2 означатиме бабусь і дідусь <module>ака
• Другий аргумент - це об'єкт рядка або коду, який потрібно виконати в заданій області
• Ви також можете викликати його без аргументів для інтерактивної оболонки всередині вашої програми

Довга відповідь

Це складніше. Seapie працює, редагуючи кадри в стеку викликів за допомогою CPython api. CPython є де-факто стандартом, тому більшість людей не повинні турбуватися про це.

Магічні слова, з якими ви, мабуть, переймаєтесь, якщо ви це читаєте:

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

Останні змусять оновлення перейти у локальну сферу. Однак локальні області застосування оптимізовані інакше, ніж глобальна сфера, тому інтродукція нових об'єктів має певні проблеми, коли ви намагаєтесь викликати їх безпосередньо, якщо вони не ініціалізовані жодним чином. Я скопію кілька способів обійти ці проблеми зі сторінки github

• Заздалегідь визначте, імпортуйте та визначте свої об'єкти
• Заздалегідь визначте заповнювач заповнення об’єктів
• Призначте об'єкт собі в основній програмі для оновлення таблиці символів: x = locals () ["x"]
• Використовуйте exec () в основній програмі замість прямого виклику, щоб уникнути оптимізації. Замість виклику x do: exec ("x")

Якщо ви відчуваєте, що використовувати exec()не те, з чим ви хочете піти, ви можете наслідувати поведінку, оновивши справжній локальний словник (не той, який повертається місцевими жителями ()). Я скопію приклад із 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()

Вихід:

hack!

Я не думаю, що ти повинен цього робити. Функції, які можуть змінювати речі в контексті, що їх обговорює, небезпечні, оскільки цей контекст може бути записаний без відома функції.

Ви можете зробити це явним або, зробивши B загальнодоступним методом і C приватним методом у класі (мабуть, найкращий спосіб); або використовуючи тип, що змінюється, наприклад список і явно передаючи його на C:

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

A()

Ви можете, але вам доведеться використовувати глобальний склад (не дуже хороше рішення, як завжди, коли ви використовуєте глобальні змінні, але це працює):

def A():
    global b
    b = 1

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

    B()
A()

Я не знаю, чи є атрибут функції, який видає __dict__зовнішній простір функції, коли цей космічний простір не є глобальним простором == модулем, що є випадком, коли функція є вкладеною функцією, в Python 3.

Але в Python 2, наскільки я знаю, немає такого атрибута.

Тож єдині можливості робити те, що ви хочете, це:

1) використання об'єкта, що змінюється, як говорять інші

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

результат

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

.

Нота

У рішення Седріка Жульєна є недолік:

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

результат

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

Глобальний b після виконання A()був модифікований, і його можна не бажати

Це справа лише в тому випадку, якщо в глобальному просторі імен є об'єкт з ідентифікатором b