Implikasi skop penjana dan kata kunci `hasil`

Fungsi menggunakan hasil akan menjadi penjana, dan apabila dipanggil, mereka mengembalikan objek penjana dan bukannya dilaksanakan dengan segera; 2. Pembolehubah tempatan penjana tidak akan dimusnahkan semasa jeda hasil, tetapi akan diteruskan dengan bingkai penjana sehingga penjana habis atau ditutup; 3. Kitaran hayat berubah -ubah boleh menyebabkan peningkatan penggunaan memori, terutamanya apabila merujuk kepada objek besar; 4. Apabila digabungkan dengan penutupan, peraturan LEGB masih diikuti, tetapi masalah pengikatan akhir pembolehubah gelung perlu diselesaikan dengan segera mengikat (seperti nilai parameter lalai); 5. .Close () hendaklah dipanggil secara eksplisit untuk memastikan bahawa akhirnya menghalang pelaksanaan dilakukan untuk mengelakkan kelewatan dalam pembersihan sumber. Penjana mempengaruhi ingatan dan tingkah laku dengan memperluaskan masa survival pembolehubah, tetapi tidak mengubah peraturan skop leksikal.

Apabila membincangkan implikasi skop penjana dan kata kunci yield dalam python, penting untuk memahami bagaimana yield mengubah fungsi menjadi objek penjana dan bagaimana skop berubah -ubah dalam konteks tersebut. Tidak seperti fungsi biasa, penjana mengekalkan keadaan antara panggilan, yang mempengaruhi bagaimana nama diselesaikan dan apabila pembolehubah dimusnahkan.

Bagaimana yield perubahan fungsi tingkah laku

Apabila yield digunakan dalam fungsi, Python merawat berfungsi sebagai fungsi penjana . Memanggilnya tidak melaksanakan badan fungsi dengan segera; Sebaliknya, ia mengembalikan objek penjana yang boleh diulang.

 def my_generator ():
    x = 10
    hasil x
    x = 5
    hasil x

gen = my_generator ()
cetak (seterusnya (gen)) # 10
cetak (seterusnya (gen)) # 15

Di sini, x mengekalkan nilainya antara panggilan yield . Kegigihan ini mempunyai skop dan implikasi seumur hidup : Pembolehubah tempatan dalam fungsi penjana tidak dimusnahkan apabila fungsi "menjeda" pada yield . Mereka berterusan dalam bingkai penjana sehingga penjana habis atau sampah yang dikumpulkan.

Skop berubah -ubah dan seumur hidup dalam penjana

Dalam fungsi biasa, pembolehubah tempatan dibuat apabila fungsi dipanggil dan dimusnahkan apabila ia kembali. Tetapi dalam penjana:

• Pembolehubah tempatan berterusan merentasi titik yield .
• Bingkai timbunan penjana tetap hidup selagi objek penjana wujud.
• Pembolehubah hanya dibersihkan apabila penjana ditutup, keletihan, atau dipadam.

Pertimbangkan contoh ini:

 kaunter def ():
    kiraan = 0
    Walaupun benar:
        kiraan hasil
        kiraan = 1

c = kaunter ()
cetak (seterusnya (c)) # 0
Cetak (seterusnya (c)) # 1

count pembolehubah hidup dalam skop penjana, walaupun fungsi itu kelihatan "berhenti sejenak." Ini berbeza dengan penutupan atau skop fungsi biasa - pelaksanaannya dengan skop tempatan yang dipelihara .

Ini boleh membawa kepada penggunaan memori yang lebih tinggi jika objek besar dirujuk dalam penjana, kerana mereka tidak akan dibebaskan sehingga penjana selesai.

Penutup dan yield : Berhati -hati untuk mengikat lewat

Penjana berinteraksi dengan penutupan dan melampirkan skop seperti fungsi lain, tetapi perkara masa. Kerana pelaksanaan ditangguhkan, isu mengikat lewat dapat terjadi:

 def create_generators ():
    Gens = []
    untuk saya dalam julat (3):
        Gens.Append ((lambda: (hasil i)) ())
    Kembali ke Gens

untuk g dalam create_generators ():
    cetak (seterusnya (g)) # semua cetak 2!

Tunggu - ini tidak berfungsi seperti yang diharapkan. Sebenarnya, menggunakan yield di dalam lambda adalah tidak sah (SyntaxError). Tetapi walaupun dalam fungsi penjana biasa, penutupan pembolehubah gelung boleh menjadi rumit:

 def make_generators ():
    penjana = []
    untuk saya dalam julat (3):
        def gen ():
            Hasil i
        penjana.append (gen ())
    Generator pulangan

untuk g dalam make_generators ():
    cetak (seterusnya (g)) # semua cetak 2

Isu di sini bukan dengan yield per se, tetapi dengan bagaimana penutupan menangkap i dengan rujukan. Kata kunci yield tidak mengubah peraturan scoping-penjana masih mengikuti peraturan LEGB (tempatan, melampirkan, global, terbina dalam) Python.

Untuk membetulkannya, mengikat pembolehubah awal:

 def gen_with_fixed_i (i):
    Hasil i

penjana = [gen_with_fixed_i (i) untuk i dalam julat (3)]

Pemadanan penjana dan __del__

Oleh kerana bingkai penjana memegang rujukan kepada pembolehubah tempatan, rujukan bulat dapat menghalang pembersihan tepat pada masanya. Python biasanya mengendalikan ini melalui koleksi sampah, tetapi ia adalah sesuatu yang perlu diperhatikan dalam aplikasi jangka panjang.

Anda boleh menutup penjana secara manual dengan .close() untuk mencetuskan pembersihan:

 def Resource_Generator ():
    Cetak ("Sumber Pembukaan")
    Cuba:
        menghasilkan "data"
    Akhirnya:
        Cetak ("Sumber Penutupan")

gen = sumber_generator ()
cetak (seterusnya (gen))
gen.close () # memastikan akhirnya blok berjalan

Tanpa .close() , blok finally mungkin tidak berjalan sehingga penjana adalah sampah yang dikumpulkan - tidak dapat diramalkan dalam cpython disebabkan oleh pengiraan rujukan, tetapi terutama risiko dalam pypy atau di bawah tekanan ingatan.

Oleh itu, sementara yield tidak mengubah peraturan scoping lexical, ia mengubah seumur hidup pembolehubah tempatan dan memperkenalkan kekayaan. Ini bermaksud:

• Pembolehubah dalam fungsi penjana hidup lebih lama daripada fungsi biasa.
• Penjana secara tidak sengaja boleh menyimpan objek besar dalam ingatan.
• Tingkah laku penutupan masih mengikuti peraturan python standard - berhati -hati dengan mengikat lewat.
• Sentiasa pertimbangkan pembersihan, terutamanya apabila menguruskan sumber.

Pada asasnya, penjana memanjangkan skop dalam masa , bukan dalam ruang nama - tetapi itu cukup untuk memberi kesan kepada memori dan tingkah laku dengan ketara.

Atas ialah kandungan terperinci Implikasi skop penjana dan kata kunci `hasil`. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!