Нелокальный оператор Python

Сравните это без использования nonlocal:

x = 0
def outer():
    x = 1
    def inner():
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 0

Для этого, используя nonlocal, где x inner() теперь также x outer():

x = 0
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 2
# global: 0

Если бы мы использовали global, он бы привязал x к правильному «глобальному» значению:

x = 0
def outer():
    x = 1
    def inner():
        global x
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 2

Короче говоря, он позволяет вам присваивать значения переменной во внешней (но неглобальной) области. См. Подробности в PEP 3104.

Поиск в Google по запросу "python nonlocal" обнаружил предложение, PEP 3104, который полностью описывает синтаксис и аргументы, лежащие в основе утверждения. Короче говоря, он работает точно так же, как оператор global, за исключением того, что он используется для ссылки на переменные, которые не являются ни глобальными, ни локальными для функции.

Вот краткий пример того, что вы можете с этим сделать. Генератор счетчиков можно переписать, чтобы использовать это так, чтобы он больше походил на идиомы языков с замыканиями.

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

Очевидно, вы можете написать это как генератор, например:

def counter_generator():
    count = 0
    while True:
        count += 1
        yield count

Но, хотя это совершенно идиоматический питон, похоже, что первая версия будет немного более очевидной для новичков. Правильное использование генераторов путем вызова возвращаемой функции - обычная путаница. Первая версия явно возвращает функцию.

@ooboo:

Берется «самый близкий» к исходной точке ссылки. Это называется «лексическая область видимости» и является стандартом уже более 40 лет.

Члены класса Python действительно находятся в словаре под названием __dict__ и никогда не будут доступны с помощью лексической области видимости.

Если вы не укажете nonlocal, но укажете x = 7, будет создана новая локальная переменная «x». Если вы укажете nonlocal, он найдет «ближайший» «x» и назначит ему. Если вы укажете nonlocal и не укажете «x», появится сообщение об ошибке.

Ключевое слово global всегда казалось мне странным, поскольку оно с радостью игнорирует все остальные «x», кроме самого внешнего. Странный.

help ('нелокальный') Оператор nonlocal

---

    nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*

Оператор nonlocal заставляет перечисленные идентификаторы ссылаться на ранее связанные переменные в ближайшей охватывающей области. Это важно, поскольку по умолчанию привязка выполняется сначала в локальном пространстве имен. Оператор позволяет инкапсулированному коду повторно связывать переменные вне локальной области, помимо глобальной (модульной) области.

Имена, перечисленные в операторе nonlocal, в отличие от имен, перечисленных в операторе global, должны относиться к ранее существовавшим привязкам во включающей области (область, в которой должна быть создана новая привязка, не может быть определена однозначно).

Имена, перечисленные в операторе nonlocal, не должны конфликтовать с ранее существовавшими привязками в локальной области.

Смотрите также:

PEP 3104 - доступ к именам во внешних областях - спецификация для оператора nonlocal.

Связанные разделы справки: global, NAMESPACES

Источник: Справочник по языку Python

Цитата из Справочника по Python 3:

Оператор nonlocal заставляет перечисленные идентификаторы ссылаться на ранее связанные переменные в ближайшей охватывающей области, за исключением глобальных переменных.

Как сказано в справке, в случае нескольких вложенных функций изменяется только переменная в ближайшей включающей функции:

def outer():
    def inner():
        def innermost():
            nonlocal x
            x = 3

        x = 2
        innermost()
        if x == 3: print('Inner x has been modified')

    x = 1
    inner()
    if x == 3: print('Outer x has been modified')

x = 0
outer()
if x == 3: print('Global x has been modified')

# Inner x has been modified

«Ближайшая» переменная может находиться на расстоянии нескольких уровней:

def outer():
    def inner():
        def innermost():
            nonlocal x
            x = 3

        innermost()

    x = 1
    inner()
    if x == 3: print('Outer x has been modified')

x = 0
outer()
if x == 3: print('Global x has been modified')

# Outer x has been modified

Но это не может быть глобальная переменная:

def outer():
    def inner():
        def innermost():
            nonlocal x
            x = 3

        innermost()

    inner()

x = 0
outer()
if x == 3: print('Global x has been modified')

# SyntaxError: no binding for nonlocal 'x' found

Мое личное понимание «нелокального» оператора (и прошу прощения, так как я новичок в Python и программировании в целом) заключается в том, что «нелокальный» - это способ использовать глобальные функции в повторяющихся функциях, а не тело самого кода. . Глобальный оператор между функциями, если хотите.

с «нелокальными» внутренними функциями (т.е. вложенными внутренними функциями) может получить разрешение на чтение & 'запись' для этой конкретной переменной внешней родительской функции . А нелокальный можно использовать только внутри внутренних функций, например:

a = 10
def Outer(msg):
    a = 20
    b = 30
    def Inner():
        c = 50
        d = 60
        print("MU LCL =",locals())
        nonlocal a
        a = 100
        ans = a+c
        print("Hello from Inner",ans)       
        print("value of a Inner : ",a)
    Inner()
    print("value of a Outer : ",a)

res = Outer("Hello World")
print(res)
print("value of a Global : ",a)