Cakupan kelas bertingkat?

Saya mencoba memahami ruang lingkup dalam kelas bersarang dengan Python. Ini contoh kode saya:

class OuterClass:
    outer_var = 1
    class InnerClass:
        inner_var = outer_var

Pembuatan kelas tidak selesai dan saya mendapatkan kesalahan:

<type 'exceptions.NameError'>: name 'outer_var' is not defined

Mencoba inner_var = Outerclass.outer_vartidak berhasil. Saya mendapat:

<type 'exceptions.NameError'>: name 'OuterClass' is not defined

Saya mencoba mengakses statis outer_vardari InnerClass.

Apakah ada cara untuk melakukan ini?

class Outer(object):
    outer_var = 1

    class Inner(object):
        @property
        def inner_var(self):
            return Outer.outer_var

Ini tidak persis sama dengan hal serupa yang berfungsi dalam bahasa lain, dan menggunakan pencarian global alih-alih membatasi akses ke outer_var. (Jika Anda mengubah objek apa yang Outerterikat dengan nama , maka kode ini akan menggunakan objek itu saat dijalankan berikutnya.)

Jika Anda malah ingin semua Innerobjek memiliki referensi ke Outerkarena outer_varsebenarnya adalah atribut instance:

class Outer(object):
    def __init__(self):
        self.outer_var = 1

    def get_inner(self):
        return self.Inner(self)
        # "self.Inner" is because Inner is a class attribute of this class
        # "Outer.Inner" would also work, or move Inner to global scope
        # and then just use "Inner"

    class Inner(object):
        def __init__(self, outer):
            self.outer = outer

        @property
        def inner_var(self):
            return self.outer.outer_var

Perhatikan bahwa kelas bersarang agak tidak umum di Python, dan tidak secara otomatis menyiratkan segala jenis hubungan khusus antara kelas. Anda lebih baik tidak bersarang. (Anda masih dapat menyetel atribut kelas Outerke Inner, jika Anda mau.)

Saya pikir Anda cukup melakukan:

class OuterClass:
    outer_var = 1

    class InnerClass:
        pass
    InnerClass.inner_var = outer_var

Masalah yang Anda temui adalah karena ini:

Blok adalah bagian dari teks program Python yang dieksekusi sebagai satu unit. Berikut ini adalah blok-blok: modul, badan fungsi, dan definisi kelas.
(...)
Cakupan mendefinisikan visibilitas nama dalam blok.
(...)
Cakupan nama yang didefinisikan dalam blok kelas terbatas pada blok kelas; itu tidak meluas ke blok kode metode - ini termasuk ekspresi generator karena diimplementasikan menggunakan ruang lingkup fungsi. Artinya, berikut ini akan gagal:

   class A:  

       a = 42  

       b = list(a + i for i in range(10))

http://docs.python.org/reference/executionmodel.html#naming-and-binding

Artinya di atas:
badan fungsi adalah blok kode dan metode adalah fungsi, maka nama yang ditentukan dari badan fungsi yang ada dalam definisi kelas tidak meluas ke badan fungsi.

Parafrase ini untuk kasus Anda:
definisi kelas adalah blok kode, maka nama yang ditentukan dari definisi kelas dalam yang ada dalam definisi kelas luar tidak mencakup definisi kelas dalam.

Anda mungkin lebih baik jika Anda tidak menggunakan kelas bersarang. Jika Anda harus bersarang, coba ini:

x = 1
class OuterClass:
    outer_var = x
    class InnerClass:
        inner_var = x

Atau nyatakan kedua kelas sebelum menumpuknya:

class OuterClass:
    outer_var = 1

class InnerClass:
    inner_var = OuterClass.outer_var

OuterClass.InnerClass = InnerClass

(Setelah ini Anda bisa del InnerClassjika perlu.)

Solusi termudah:

class OuterClass:
    outer_var = 1
    class InnerClass:
        def __init__(self):
            self.inner_var = OuterClass.outer_var

Ini mengharuskan Anda untuk bersikap eksplisit, tetapi tidak membutuhkan banyak usaha.

Dalam Python, objek yang bisa berubah diteruskan sebagai referensi, sehingga Anda bisa meneruskan referensi kelas luar ke kelas dalam.

class OuterClass:
    def __init__(self):
        self.outer_var = 1
        self.inner_class = OuterClass.InnerClass(self)
        print('Inner variable in OuterClass = %d' % self.inner_class.inner_var)

    class InnerClass:
        def __init__(self, outer_class):
            self.outer_class = outer_class
            self.inner_var = 2
            print('Outer variable in InnerClass = %d' % self.outer_class.outer_var)

Semua penjelasan dapat ditemukan di Dokumentasi Python Tutorial Python

Untuk kesalahan pertama Anda <type 'exceptions.NameError'>: name 'outer_var' is not defined. Penjelasannya adalah:

Tidak ada singkatan untuk mereferensikan atribut data (atau metode lain!) Dari dalam metode. Saya menemukan bahwa ini benar-benar meningkatkan keterbacaan metode: tidak ada kemungkinan membingungkan variabel lokal dan variabel instan saat melihat sekilas melalui suatu metode.

dikutip dari The Python Tutorial 9.4

Untuk kesalahan kedua Anda <type 'exceptions.NameError'>: name 'OuterClass' is not defined

Ketika definisi kelas dibiarkan normal (melalui akhir), objek kelas dibuat.

dikutip dari Tutorial Python 9.3.1

Jadi ketika Anda mencoba inner_var = Outerclass.outer_var, Quterclassitu belum dibuat, itu sebabnyaname 'OuterClass' is not defined

Penjelasan yang lebih rinci tapi membosankan untuk kesalahan pertama Anda:

Meskipun kelas memiliki akses ke cakupan fungsi yang melingkupi, mereka tidak bertindak sebagai cakupan yang melingkupi kode yang disarangkan di dalam kelas: Python mencari fungsi yang melingkupi nama yang direferensikan, tetapi tidak pernah ada kelas yang melingkupinya. Artinya, kelas adalah cakupan lokal dan memiliki akses ke cakupan lokal yang melingkupi, tetapi tidak berfungsi sebagai cakupan lokal yang melingkupi kode bersarang lebih lanjut.

dikutip dari Learning.Python (5th) .Mark.Lutz