Нелокален израз на 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

---

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

Изразът nonlocal кара изброените идентификатори да препращат към предварително обвързани променливи в най-близкия обхващащ обхват. Това е важно, тъй като поведението по подразбиране за обвързване е първо да се търси локалното пространство от имена. Изявлението позволява на капсулиран код да свързва отново променливи извън локалния обхват освен глобалния (модулен) обхват.

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

Имената, изброени в оператор nonlocal, не трябва да се сблъскват с вече съществуващи обвързвания в локалния обхват.

Вижте също:

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

Свързани теми за помощ: глобално, NAMESPACES

Източник: Справочник за езика Python

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

Нелокалният израз кара изброените идентификатори да се отнасят към предварително обвързани променливи в най-близкия обхващащ обхват, с изключение на глобалните.

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

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)