Apakah kegunaan asas penutupan dalam Python?

Apakah itu penutupan

Penutupan ialah fungsi yang ditakrifkan di dalam fungsi lain dan boleh mengakses Pembolehubah fungsi itu dalam skop, walaupun jika fungsi itu mempunyai selesai pelaksanaan dan telah dimusnahkan. Dengan kata lain, penutupan ialah gabungan fungsi dan persekitarannya.

Ringkasnya, penutupan ialah bentuk khas fungsi yang boleh mengakses pembolehubah di dalam fungsi dari luar fungsi, tetapi pembolehubah ini tidak akan dimusnahkan selepas fungsi tersebut dilaksanakan. Penutupan boleh digunakan dalam Python untuk mencipta kod modular yang boleh digunakan semula.

Penutupan dalam Python

Fungsi dalam Python ialah objek kelas pertama, iaitu, ia boleh dihantar, dirujuk, dikembalikan dan ditetapkan seperti objek lain. Dalam Python, penutupan boleh dilaksanakan melalui sarang fungsi.

Berikut ialah contoh mudah yang menunjukkan cara membuat penutupan:

def outer_function(x): 
    def inner_function(y): 
        return x + y 
    return inner_function 
    
closure = outer_function(10)
print(closure(5))

Dalam contoh ini, outer_function ialah fungsi yang menerima satu parameter, x, Dan mengembalikan a fungsi inner_function. inner_function juga merupakan fungsi yang menerima parameter y dan mengembalikan jumlah x dan y.

Dalam baris terakhir kod, kami membuat penutupan closure dan menetapkan nilai pulangan outer_function(10) (iaitu, inner_function) kepadanya. Kemudian kita panggil fungsi closure, masukkan parameter 5, dan cetak nilai pulangan 15. Dalam contoh ini, nilai x ialah 10 kerana parameter yang kami hantar kepada outer_function ialah 10.

Cara melaksanakan penutupan

Terdapat dua cara untuk melaksanakan penutupan dalam Python: sarang fungsi dan penghias.

Function Nesting

Dalam Python, kita boleh mentakrifkan fungsi, mentakrifkan fungsi lain di dalam fungsi ini, dan kemudian mengembalikan fungsi dalaman ini. Fungsi dalaman ini boleh mengakses pembolehubah fungsi luar, iaitu penutupan.

Kaedah bersarang adalah seperti yang ditunjukkan dalam contoh mudah di atas dan tidak akan diterangkan secara terperinci di sini.

Penghias

Penghias ialah cara lain untuk melaksanakan penutupan dalam Python. Penghias ialah fungsi yang menerima fungsi sebagai hujah dan mengembalikan fungsi baharu. Fungsi baharu boleh menambah beberapa fungsi baharu berdasarkan fungsi asal tanpa mengubah kod fungsi asal.

Berikut ialah contoh mudah yang menunjukkan cara menggunakan penghias untuk melaksanakan penutupan:

def my_decorator(func):
    def wrapper():
        print("Before the function is called.") 
        func() 
        print("After the function is called.") 
    return wrapper 
    
@my_decorator 
def say_hello():
    print("Hello!")
    say_hello()

Dalam contoh ini, kami mentakrifkan fungsi penghias my_decorator dan menambah Ia digunakan untuk fungsi say_hello上. Fungsi penghias menerima fungsi sebagai parameter dan mengembalikan fungsi baharu wrapper. Fungsi wrapper menambah beberapa fungsi baharu berdasarkan fungsi asal say_hello.

Dalam baris terakhir kod, kami memanggil fungsi say_hello dan mencetak perkara berikut:

Sebelum fungsi dipanggil
Helo
Selepas fungsi itu dipanggil.

Melalui penghias, kami berjaya melaksanakan penutupan.

Aplikasi Penutupan

Penutupan mempunyai banyak senario aplikasi dalam Python Berikut ialah beberapa senario biasa:

1 Pelaksanaan tertunda

Penutupan boleh digunakan untuk melaksanakan pelaksanaan tertunda, iaitu, pengiraan hanya dilakukan apabila fungsi dipanggil. Ini boleh meningkatkan prestasi program, terutamanya apabila menilai ekspresi kompleks.

Berikut ialah contoh yang menunjukkan cara menggunakan penutupan untuk melaksanakan pelaksanaan tertunda:

def delayed_sum(a, b):
    def sum(): 
        return a + b 
    return sum 
    
result = delayed_sum(1, 2) 
print(result()) # 3

Dalam contoh ini, kami mentakrifkan fungsi delayed_sum yang menerima dua parametera dan b, dan mengembalikan fungsi sum. Apabila kita memanggil fungsi delayed_sum, ia tidak mengira jumlah a dan b, tetapi mengembalikan fungsi sum. Apabila kita memanggil fungsi sum, ia akan mengira jumlah a dan b dan mengembalikan hasilnya.

2. Hasil caching

Penutupan boleh digunakan untuk cache hasil fungsi, terutamanya apabila mengira fungsi kompleks, yang boleh meningkatkan prestasi program.

Berikut ialah contoh yang menunjukkan cara menggunakan penutupan pada keputusan cache:

def memoize(func):
    cache = {} 
    
    def wrapper(*args):
        if args in cache: 
            return cache[args] 
        result = func(*args) 
        cache[args] = result 
        return result 
    return wrapper 
                                        
@memoize 
def fibonacci(n): 
    if n in (0, 1):
        return n 
    return fibonacci(n - 1) + fibonacci(n - 2) 
    
print(fibonacci(10)) # 55

Dalam contoh ini, kami mentakrifkan fungsi penghias memoize yang boleh menyimpan cache hasil Hasil daripada fungsi berhias. Dalam fungsi fibonacci, kami menggunakan penghias memoize untuk mengelakkan pengiraan dua kali nilai dalam jujukan Fibonacci. Apabila kita memanggil fungsi fibonacci buat kali pertama, ia mengira nilai fibonacci(0) dan fibonacci(1) dan menyimpannya dalam cache. Apabila kita memanggil fungsi fibonacci pada kali seterusnya, ia akan terlebih dahulu menyemak sama ada nilai yang diperlukan telah dikira dalam cache Jika ya, ia akan terus mengembalikan hasil dalam cache, jika tidak, ia akan dikira semula.

3. Laksanakan fungsi yang serupa dengan pembolehubah persendirian

Dalam Python, kami tidak boleh mentakrifkan pembolehubah persendirian secara langsung seperti Java dan C++. Walau bagaimanapun, kita boleh menggunakan penutupan untuk mencapai kefungsian yang serupa dengan pembolehubah persendirian.

下面是一个例子，演示了如何使用闭包实现私有变量：

def counter():
    count = 0 
    def inner():
        nonlocal count 
        count += 1 
        return count 
    return inner 
   
c1 = counter() 
c2 = counter() 
print(c1()) # 1 
print(c1()) # 2 
print(c2()) # 1 
print(c2()) # 2

在这个例子中，我们定义了一个counter函数，它返回一个inner函数。inner函数可以访问count变量，而count变量是在counter函数中定义的。由于 Python 中没有直接定义私有变量的语法，我们使用了一个内部函数来访问外部函数中的变量。这样，我们就可以实现类似于私有变量的功能。

在调用c1和c2时，它们返回的inner函数中的count变量是不同的。这是因为每次调用counter函数时，它都会返回一个新的inner函数，每个inner函数都有自己的count变量。

闭包的优缺点

闭包有很多优点，例如：

• 可以避免使用全局变量，提高程序的可维护性；

• 可以实现类似于私有变量的功能，提高程序的安全性；

• 可以实现延迟执行和缓存结果，提高程序的性能。

但是，闭包也有一些缺点，例如：

• 可能会占用较多的内存空间，因为闭包会保留外部函数的状态；

• 可能会导致循环引用的问题，如果闭包中引用了外部函数的变量，而这些变量又引用了闭包中的变量，就会出现循环引用的问题。

小结

Python中的闭包是一种非常强大的编程技术，它可以帮助我们提高程序的可维护性、安全性和性能。通过闭包，我们可以避免使用全局变量、实现类似于私有变量的功能、实现延迟执行和缓存结果等。

要使用闭包，我们需要了解闭包的原理和使用方法。在Python中，可以使用嵌

套函数来实现闭包。在定义闭包时，需要注意外部函数和内部函数的作用域、变量的生命周期等问题，以避免出现意外的错误。

在实际编程中，可以使用闭包来实现许多有用的功能，例如缓存结果、实现状态机、实现装饰器等。对于有经验的Python程序员来说，闭包已经成为不可或缺的一部分。

在使用闭包时，需要注意以下几点：

• 尽量避免在闭包中修改外部函数的变量。如果需要修改变量，应该使用nonlocal关键字。

• 闭包中的变量是在函数定义时绑定的，而不是在函数调用时绑定的。因此，如果在闭包中引用了外部函数的变量，应该确保这些变量在闭包定义时是可用的。

• 闭包中引用的外部函数的变量会一直存在，直到闭包被销毁。因此，如果闭包中引用了外部函数的大量变量，可能会占用大量的内存空间。

Atas ialah kandungan terperinci Apakah kegunaan asas penutupan dalam Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!