Shulou(Shulou.com)06/02 Report--

This article mainly explains "what is the skill of Python closure". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what is the skill of Python closure".

1. Closures: replace classes with functions

Sometimes we define a class with only one method (except _ _ init__ ()), which can be replaced by using a closure. A closure is an inner function surrounded by an outer function that can get variables in the scope of the outer function (even if the outer function has been executed). So closures can hold additional variable environments for use in function calls. Consider the following example, which allows users to obtain URL through some kind of template scheme.

From urllib.request import urlopenclass UrlTemplate: def _ init__ (self, template)-> None: self.template = template def open (self, * * kwargs): return urlopen (self.template.format_map (kwargs)) yahoo = UrlTemplate ('http://finance.yahoo.com/d/quotes.csv?s={names}&f={fields}') for line in yahoo.open (names='IBM,AAPL,FB') Fields = 'sllclv'): print (line.decode (' utf-8'))

This class can be replaced by a simple function:

Def urltempalte (template): # pass kwargs def opener (* * kwargs): return urlopen (template.format_map (kwargs)) return openeryahoo = urltempalte ('http://finance.yahoo.com/d/quotes.csv?s={names}&f={fields}')for line in yahoo (names='IBM,AAPL,FB', fields =' sllclv'): print (line.decode ('utf-8') when the function is called again with the object

In many cases, the reason we use a class with a single method is that we need to save extra state for the class method to use. The only purpose of the UrlTemplate class we mentioned above is to store the value of template somewhere and then use it in the open () method. Using closures to solve this problem is shorter and more elegant, and we use the opener () function to remember the value of the parameter template, which is then used in subsequent calls.

So when you write code that needs to add additional state to the function, be sure to consider using closures.

two。 Access variables defined in the closure

We know that the inner layer of the closure can be used to store the variable environment that the function needs to use. Next, we can extend the closure through functions so that the variables defined in the inner layer of the closure can be accessed and modified.

Generally speaking, the variables defined by the inner layer of the closure are completely isolated from the outside world. If you want to access and modify them, you need to write access functions (accessor function, that is, getter/setter methods), and attach them as functional properties to the closure to provide access support to the inner variables:

Def sample (): n = 0 # closure function def func (): print ("n =", n) # access function (accessor function) That is, the getter/setter method def get_n (): return n def set_n (value): # you must add nolocal to modify the inner variable nonlocal n n = value # as a function attribute with func.get_n = get_n func.set_n = set_n return func

The test results of the algorithm are as follows:

F = sample () f () # n = 0f.set_n (10) f () # n = 10print (f.get_n ()) # 10

As you can see, get_n () and set_n () work much like instance methods. Be sure to attach get_n () and set_n () as function attributes, otherwise you will get an error: 'function' object has no attribute' set_n' when calling set_n () and get_n ().

If we want the closure to be fully simulated as a class instance, we need to copy the schema inner-level function into an instance's dictionary and return it.

Examples are as follows:

Import sysclass ClosureInstance: def _ init__ (self, locals=None)-> None: if locals is None: locals= sys._getframe (1). F_locals # Update instance dictionary with callables self.__dict__.update ((key, value) for key Value in locals.items () if callable (value) # Redirect special methods def _ _ len__ (self): return self.__dict__ ['_ len__'] () # Example usedef Stack (): items = [] def push (item): items.append (item) def pop (): return items.pop () def _ _ len__ ( ): return len (items) return ClosureInstance ()

The corresponding test results are shown below:

S = Stack () print (s) # s.push (10) s.push (20) s.push ('Hello') print (len (s)) # 3print (s.pop ()) # Helloprint (s.pop ()) # 20print (s.pop ()) # 10

The function of using closure model classes is faster than traditional class implementation methods. For example, we use the following class as a test comparison.

Class Stack2: def _ init__ (self)-> None: self.items = [] def push (self, item): self.items.append (item) def pop (self): return self.items.pop () def _ len__ (self): return len (self.items)

Here are our test results:

From timeit import timeits = Stack () print (timeit ('s.push (1); s.pop ()', 'from _ main__ import s')) # 0.98746542s = Stack2 () print (timeit (' s.push (1); s.pop ()', 'from _ main__ import s')) # 1.07070521

You can see that the version with closures is about 8% faster. Because for instances, most of the test calls are spent on accessing instance variables, while closures are faster because no additional self variables are involved.

However, this kind of trick should be used carefully in the code, because this method is actually quite weird compared to a real class. Features such as inheritance, properties, descriptors, or class methods cannot be used in this method. And we need some tricks to make special methods work (such as our implementation of _ _ len__ () in ClosureInstance above). However, this is still a very academically valuable example of what can be achieved by providing access mechanisms within closures.

Thank you for your reading, the above is the content of "what are the skills of Python closures?" after the study of this article, I believe you have a deeper understanding of what the skills of Python closures are, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.