kata kunci nonlokal dengan Python 2.x

Saya mencoba menerapkan closure dengan Python 2.6 dan saya perlu mengakses variabel nonlokal tetapi sepertinya kata kunci ini tidak tersedia di python 2.x. Bagaimana cara mengakses variabel nonlokal dalam closure di versi python ini?

Fungsi dalam dapat membaca variabel nonlokal di 2.x, hanya saja tidak mengikatnya kembali. Ini menjengkelkan, tetapi Anda bisa mengatasinya. Buat saja kamus, dan simpan data Anda sebagai elemen di dalamnya. Fungsi dalam tidak dilarang untuk mengubah objek yang dirujuk oleh variabel nonlokal.

Untuk menggunakan contoh dari 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

Solusi berikut ini terinspirasi oleh jawaban Elias Zamaria , tetapi berlawanan dengan jawaban tersebut, jawaban tersebut menangani banyak panggilan dari fungsi luar dengan benar. "Variabel" inner.ybersifat lokal untuk panggilan saat ini outer. Hanya itu bukan variabel, karena itu dilarang, tetapi atribut objek (objek adalah fungsinya innersendiri). Ini sangat jelek (perhatikan bahwa atribut hanya dapat dibuat setelah innerfungsi ditentukan) tetapi tampaknya efektif.

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)

Daripada kamus, ada lebih sedikit kekacauan di kelas nonlokal . Mengubah contoh @ ChrisB :

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

Kemudian

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

Setiap panggilan outer () membuat kelas baru dan berbeda yang disebut konteks (bukan hanya instance baru). Jadi ini menghindari kewaspadaan @ Nathaniel tentang konteks bersama.

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

assert f() == 5

Saya pikir kuncinya di sini adalah apa yang Anda maksud dengan "akses". Seharusnya tidak ada masalah dengan membaca variabel di luar lingkup closure, misalnya,

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

harus bekerja seperti yang diharapkan (pencetakan 3). Namun, menimpa nilai x tidak akan berhasil, misalnya,

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

akan tetap mencetak 3. Dari pemahaman saya tentang PEP-3104, inilah yang dimaksud dengan kata kunci nonlokal. Seperti yang disebutkan di PEP, Anda dapat menggunakan kelas untuk mencapai hal yang sama (agak berantakan):

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

Ada cara lain untuk mengimplementasikan variabel nonlokal dengan Python 2, jika ada jawaban di sini yang tidak diinginkan karena alasan apa pun:

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

Tidak ada gunanya menggunakan nama fungsi dalam pernyataan penugasan variabel, tetapi terlihat lebih sederhana dan lebih bersih daripada meletakkan variabel dalam kamus. Nilainya diingat dari satu panggilan ke panggilan lainnya, seperti dalam jawaban Chris B.

Berikut adalah sesuatu yang terinspirasi dari saran Alois Mahdal dalam komentarnya tentang jawaban lain :

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)

Memperbarui

Setelah melihat kembali hal ini baru-baru ini, saya terkejut dengan bagaimana dekorator-seperti itu — ketika saya sadar bahwa menerapkannya sebagai seseorang akan membuatnya lebih umum & berguna (meskipun melakukannya bisa dibilang menurunkan keterbacaannya sampai taraf tertentu).

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

Perhatikan bahwa kedua versi bekerja dengan Python 2 dan 3.

Ada kutil dalam aturan pelingkupan python - tugas membuat variabel lokal ke lingkup fungsi yang langsung melingkupinya. Untuk variabel global, Anda akan menyelesaikannya dengan globalkata kunci.

Solusinya adalah dengan memperkenalkan objek yang dibagi di antara dua cakupan, yang berisi variabel yang bisa berubah, tetapi itu sendiri direferensikan melalui variabel yang tidak ditetapkan.

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

Alternatifnya adalah beberapa peretasan cakupan:

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

Anda mungkin bisa menemukan beberapa trik untuk mendapatkan nama parameter outer, dan kemudian meneruskannya sebagai varname, tetapi tanpa bergantung pada nama outerAnda ingin menggunakan kombinator Y.

Cara lain untuk melakukannya (meskipun terlalu bertele-tele):

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

Memperluas solusi elegan Martineau di atas menjadi kasus penggunaan yang praktis dan agak kurang elegan, saya dapatkan:

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)

Gunakan variabel global

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

Secara pribadi, saya tidak suka variabel global. Tapi, proposal saya didasarkan pada https://stackoverflow.com/a/19877437/1083704 jawaban

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

di mana pengguna perlu mendeklarasikan variabel global ranks, setiap kali Anda perlu memanggil report. Peningkatan saya menghilangkan kebutuhan untuk menginisialisasi variabel fungsi dari pengguna.