từ khóa nonlocal trong Python 2.x

Tôi đang cố gắng triển khai một bao đóng trong Python 2.6 và tôi cần truy cập một biến phi địa phương nhưng có vẻ như từ khóa này không khả dụng trong python 2.x. Làm cách nào để truy cập các biến phi địa phương trong các bao đóng trong các phiên bản python này?

Các hàm bên trong có thể đọc các biến phi địa phương trong 2.x, chỉ cần không lặp lại chúng. Điều này thật khó chịu, nhưng bạn có thể giải quyết nó. Chỉ cần tạo một từ điển và lưu trữ dữ liệu của bạn dưới dạng các phần tử trong đó. Các hàm bên trong không bị cấm thay đổi các đối tượng mà các biến phi địa phương tham chiếu đến.

Để sử dụng ví dụ từ Wikipedia:

def outer():
    d = {'y' : 0}
    def inner():
        d['y'] += 1
        return d['y']
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

Giải pháp sau đây được lấy cảm hứng từ câu trả lời của Elias Zamaria , nhưng trái ngược với câu trả lời đó xử lý nhiều lệnh gọi của hàm ngoài một cách chính xác. "Biến" inner.ylà cục bộ cho cuộc gọi hiện tại của outer. Chỉ nó không phải là một biến, vì điều đó bị cấm, mà là một thuộc tính đối tượng (đối tượng là innerchính hàm ). Điều này rất xấu (lưu ý rằng thuộc tính chỉ có thể được tạo sau khi innerhàm được xác định) nhưng có vẻ hiệu quả.

def outer():
    def inner():
        inner.y += 1
        return inner.y
    inner.y = 0
    return inner

f = outer()
g = outer()
print(f(), f(), g(), f(), g()) #prints (1, 2, 1, 3, 2)

Thay vì một từ điển, có ít sự lộn xộn hơn đối với một lớp phi địa phương . Sửa đổi ví dụ của @ ChrisB :

def outer():
    class context:
        y = 0
    def inner():
        context.y += 1
        return context.y
    return inner

Sau đó

f = outer()
assert f() == 1
assert f() == 2
assert f() == 3
assert f() == 4

Mỗi lệnh gọi bên ngoài () tạo ra một lớp mới và riêng biệt được gọi là ngữ cảnh (không chỉ đơn thuần là một thể hiện mới). Vì vậy, nó tránh được @ Nathaniel cẩn thận về ngữ cảnh được chia sẻ.

g = outer()
assert g() == 1
assert g() == 2

assert f() == 5

Tôi nghĩ rằng chìa khóa ở đây là những gì bạn có nghĩa là "truy cập". Sẽ không có vấn đề gì khi đọc một biến bên ngoài phạm vi đóng, ví dụ:

x = 3
def outer():
    def inner():
        print x
    inner()
outer()

sẽ hoạt động như mong đợi (in 3). Tuy nhiên, ghi đè giá trị của x không hoạt động, ví dụ:

x = 3
def outer():
    def inner():
        x = 5
    inner()
outer()
print x

sẽ vẫn in 3. Theo hiểu biết của tôi về PEP-3104, đây là những gì từ khóa phi địa phương có nghĩa là bao gồm. Như đã đề cập trong PEP, bạn có thể sử dụng một lớp để thực hiện điều tương tự (hơi lộn xộn):

class Namespace(object): pass
ns = Namespace()
ns.x = 3
def outer():
    def inner():
        ns.x = 5
    inner()
outer()
print ns.x

Có một cách khác để triển khai các biến phi địa phương trong Python 2, trong trường hợp bất kỳ câu trả lời nào ở đây là không mong muốn vì bất kỳ lý do gì:

def outer():
    outer.y = 0
    def inner():
        outer.y += 1
        return outer.y
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

Việc sử dụng tên của hàm trong câu lệnh gán của biến là hơi thừa, nhưng đối với tôi thì nó trông đơn giản và gọn gàng hơn là đặt biến vào từ điển. Giá trị được ghi nhớ từ lệnh gọi này đến lệnh gọi khác, giống như trong câu trả lời của Chris B.

Đây là điều gì đó được truyền cảm hứng từ một gợi ý mà Alois Mahdal đưa ra trong một bình luận về một câu trả lời khác :

class Nonlocal(object):
    """ Helper to implement nonlocal names in Python 2.x """
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)


def outer():
    nl = Nonlocal(y=0)
    def inner():
        nl.y += 1
        return nl.y
    return inner

f = outer()
print(f(), f(), f()) # -> (1 2 3)

Cập nhật

Sau khi nhìn lại điều này gần đây, tôi đã bị ấn tượng bởi nó giống như một nhà trang trí - khi nó cho tôi thấy rằng việc triển khai nó như một người sẽ làm cho nó chung chung và hữu ích hơn (mặc dù làm như vậy có thể làm giảm khả năng đọc của nó ở một mức độ nào đó).

# Implemented as a decorator.

class Nonlocal(object):
    """ Decorator class to help implement nonlocal names in Python 2.x """
    def __init__(self, **kwargs):
        self._vars = kwargs

    def __call__(self, func):
        for k, v in self._vars.items():
            setattr(func, k, v)
        return func


@Nonlocal(y=0)
def outer():
    def inner():
        outer.y += 1
        return outer.y
    return inner


f = outer()
print(f(), f(), f()) # -> (1 2 3)

Lưu ý rằng cả hai phiên bản đều hoạt động trên cả Python 2 và 3.

Có một vấn đề trong quy tắc xác định phạm vi của python - phép gán làm cho một biến cục bộ trở thành phạm vi hàm bao quanh ngay lập tức của nó. Đối với một biến toàn cục, bạn sẽ giải quyết điều này bằng globaltừ khóa.

Giải pháp là giới thiệu một đối tượng được chia sẻ giữa hai phạm vi, có chứa các biến có thể thay đổi, nhưng chính nó được tham chiếu thông qua một biến không được gán.

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

Một giải pháp thay thế là một số hackery phạm vi:

def outer(v):
    def inner(varname = 'v', scope = locals()):
        scope[varname] += 1
        return scope[varname]
    return inner

Bạn có thể tìm ra một số thủ thuật để lấy tên của tham số outer, sau đó chuyển nó dưới dạng varname, nhưng không dựa vào tên outerbạn muốn, bạn cần sử dụng bộ tổ hợp Y.

Một cách khác để làm điều đó (mặc dù nó quá dài dòng):

import ctypes

def outer():
    y = 0
    def inner():
        ctypes.pythonapi.PyCell_Set(id(inner.func_closure[0]), id(y + 1))
        return y
    return inner

x = outer()
x()
>> 1
x()
>> 2
y = outer()
y()
>> 1
x()
>> 3

Mở rộng giải pháp thanh lịch Martineau ở trên sang một trường hợp sử dụng thực tế và hơi kém thanh lịch mà tôi nhận được:

class nonlocals(object):
""" Helper to implement nonlocal names in Python 2.x.
Usage example:
def outer():
     nl = nonlocals( n=0, m=1 )
     def inner():
         nl.n += 1
     inner() # will increment nl.n

or...
    sums = nonlocals( { k:v for k,v in locals().iteritems() if k.startswith('tot_') } )
"""
def __init__(self, **kwargs):
    self.__dict__.update(kwargs)

def __init__(self, a_dict):
    self.__dict__.update(a_dict)

Sử dụng một biến toàn cục

def outer():
    global y # import1
    y = 0
    def inner():
        global y # import2 - requires import1
        y += 1
        return y
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

Cá nhân tôi không thích các biến toàn cục. Tuy nhiên, đề xuất của tôi dựa trên câu trả lời https://stackoverflow.com/a/19877437/1083704

def report():
        class Rank: 
            def __init__(self):
                report.ranks += 1
        rank = Rank()
report.ranks = 0
report()

nơi người dùng cần khai báo một biến toàn cục ranks, mỗi khi bạn cần gọi report. Cải tiến của tôi loại bỏ nhu cầu khởi tạo các biến hàm từ người dùng.