先看这样一种情况

from urllib.request import urlopen

class UrlTemplate:
    def __init__(self, template):
        self.template = template

    def open(self, **kwargs):
        return urlopen(self.template.format_map(kwargs))

那么这个类应该怎么使用呢？

my = UrlTemplate("mytemplae")
my.open()

仔细观察这个类除 __init__() 方法外只定义了一个方法的类。为了简化代码，你想将它转换成一个函数

如何简化这个类的操作呢？

def urltemplate(template):
    def opener(**kwargs):
        return urlopen(template.format_map(kwargs))
    return opener



# 使用
yahoo = urltemplate('http://finance.yahoo.com/d/quotes.csv?s={names}&f={fields}')
for line in yahoo(names='IBM,AAPL,FB', fields='sl1c1v'):
    print(line.decode('utf-8'))

可以看到这样一个情况在函数内部又定义了另一个函数

def urltemplate(template):
			def opener(**kwargs):
						return urlopen(template.format_map(kwargs))

			return opener

大家一定很迷惑这个过程，稍微修改一下个代码

from  urllib.request import urlopen

def urltemplate(template):
    def opener(**kwargs):
        print("template  " ,template)
        print(kwargs)
        return urlopen(template.format_map(kwargs))
    print("=====")
    return opener

# Example use
yahoo = urltemplate('https://www.baidu.com/')
for line in yahoo(names='IBM,AAPL,FB', fields='sl1c1v'):
    # print(line.decode('utf-8'))
    pass

=====
template   https://www.baidu.com/
{'names': 'IBM,AAPL,FB', 'fields': 'sl1c1v'}

通过观察输出可以看到下面的代码实际没有做多余的事情，

保是打印了内容

print("=====")

yahoo = urltemplate('https://www.baidu.com/')

它返回的是 opener这个函数，当我们调用 opener这个函数时

def opener(**kwargs):
        print("template  " ,template)
        print(kwargs)
        return urlopen(template.format_map(kwargs))

可以发现 opener函数只需要传递kv这样的参数，而 template参数可以直接使用

如果调试程序发现当我们调用 opener方法时，它依旧可以获取template变量的值

这涉及到Pythor 的一个重要知识闭包

Python闭包

Python 中的 Closure 是一个函数对象，它记住封闭范围中的值，即使它们在内存中不存在。

• 它是将函数与环境一起存储的记录：将函数的每个自由变量（在本地使用但在封闭作用域中定义的变量）与创建闭包时名称绑定到的值或引用相关联的映射。
• 与普通函数不同，闭包允许函数通过闭包的值或引用的副本访问这些捕获的变量，即使函数在其范围之外调用也是如此。

def outerFunction(text):
 
    def innerFunction():
        print(text)
 
    innerFunction()
 
 
if __name__ == '__main__':
    outerFunction('Hey!')

从上面的代码中可以看出，Python 中的闭包有助于调用其范围之外的函数。函数 innerFunction 的作用域仅在 outerFunction 内部。但是通过使用 Python 闭包，我们可以轻松地扩展其范围以调用其范围之外的函数。

import logging 
logging.basicConfig(filename='example.log',
                    level=logging.INFO) 
 
def logger(func): 
    def log_func(*args): 
        logging.info( 
            'Running "{}" with arguments {}'.format(func.__name__,
                                                    args)) 
        print(func(*args)) 
         
    # Necessary for closure to
    # work (returning WITHOUT parenthesis) 
    return log_func             
 
def add(x, y): 
    return x+y 
 
def sub(x, y): 
    return x-y 
 
add_logger = logger(add) 
sub_logger = logger(sub) 
 
add_logger(3, 3) 
add_logger(4, 5) 
 
sub_logger(10, 5) 
sub_logger(20, 10) 

其实你会发现一个现象函数的闭包其实是内部函数可以持有外部函数的对象。这样就形成了一个闭包。