Memahami Penutupan dalam Python

Dalam Python, penutupan ialah konsep penting yang membolehkan fungsi "mengingat" persekitaran di mana ia dicipta, walaupun selepas fungsi itu selesai dilaksanakan. Penutupan membolehkan kami melaksanakan fungsi stateful tanpa menggunakan pembolehubah global atau kejadian kelas.

Dalam siaran ini, kami akan meneroka penutupan dengan melaksanakan kaunter mudah menggunakan kata kunci bukan tempatan. Mari kita selaminya!

Apakah Penutupan?

Penutupan berlaku apabila fungsi bersarang merujuk kepada pembolehubah daripada skop lampirannya, membenarkannya mengekalkan akses kepada pembolehubah tersebut walaupun selepas fungsi melampirkan selesai dilaksanakan. Penutupan amat berguna apabila anda ingin merangkum keadaan atau gelagat dalam fungsi.

Kata Kunci bukan tempatan

Dalam Python, kami menggunakan kata kunci bukan tempatan untuk mengubah suai pembolehubah dalam skop lampiran terdekat yang bukan global. Tanpa kata kunci bukan tempatan, fungsi dalaman tidak boleh mengubah suai pembolehubah dalam skop yang disertakan; ia sebaliknya akan mencipta pembolehubah tempatan baharu. Kata kunci bukan tempatan menyelesaikan masalah ini dengan memberitahu Python bahawa kami mahu bekerja dengan pembolehubah daripada skop yang disertakan.

Melaksanakan Kaunter dengan Penutupan

Mari kita cipta fungsi pembilang mudah yang menggunakan penutupan untuk menjejaki kiraan tanpa bergantung pada pembolehubah global atau kelas.

Langkah 1: Tentukan Fungsi make_counter

Kami akan mencipta fungsi yang dipanggil make_counter, yang akan mengembalikan kenaikan fungsi dalaman. Fungsi dalaman akan meningkatkan pembolehubah kiraan setiap kali ia dipanggil.

Langkah 2: Gunakan bukan tempatan untuk Mengubah Suai Pembolehubah Kira

Untuk memastikan fungsi kenaikan mengubah suai pembolehubah kiraan yang ditakrifkan dalam skop fungsi make_counter, kami akan menggunakan kata kunci bukan setempat.

Berikut ialah pelaksanaannya:

def make_counter():
    count = 0  # Variable in the enclosing scope

    def increment():
        nonlocal count  # Tell Python to modify the `count` from the enclosing scope
        count += 1  # Increment the counter
        return count  # Return the current count

    return increment  # Return the inner function, which forms the closure

Langkah 3: Menggunakan Kaunter

Sekarang kita mempunyai fungsi make_counter, kita boleh mencipta contoh pembilang dan memanggilnya beberapa kali untuk melihat kenaikan pembilang.

counter = make_counter()

print(counter())  # Output: 1
print(counter())  # Output: 2
print(counter())  # Output: 3
print(counter())  # Output: 4
print(counter())  # Output: 5

Penjelasan

• Pembolehubah kiraan dimulakan kepada 0 dalam fungsi make_counter.
• Setiap kali kami memanggil fungsi kenaikan (yang dikembalikan oleh make_counter), ia mengubah suai pembolehubah kiraan dalam skop yang disertakan menggunakan kata kunci bukan setempat. Terima kasih kepada sifat penutupan, fungsi kenaikan mengekalkan akses untuk mengira walaupun selepas fungsi make_counter selesai melaksanakan.

Mengapa Menggunakan Penutupan?

Penutupan menyediakan cara yang berkuasa dan elegan untuk merangkum keadaan dalam fungsi. Ia amat berguna dalam senario di mana:

• Anda mahu menjejaki nilai tanpa mendedahkannya kepada skop global.
• Anda memerlukan fungsi untuk mengingati keadaan sebelumnya merentas berbilang panggilan (seperti contoh balas kami).
• Anda tidak mahu menggunakan pembolehubah global atau membuat kelas untuk pengurusan keadaan mudah.

Penutupan boleh digunakan untuk kes penggunaan yang lebih maju seperti penghias, penghafalan dan panggil balik.

Atas ialah kandungan terperinci Memahami Penutupan dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!