闭包、迭代器

一、函数名的运用（第一类对象）

       函数名是一个变量，但它是一个特殊的变量，与括号配合可以执行函数的变量。

1，函数名的内存地址

    def func():
        print("呵呵")
    print(func)         # 结果为：<function func at 0x00000000029299D8>   打印出func的内存地址

2，函数名可以赋值给其他变量

    def func():
        print("呵呵")
    
    a = func   # 把函数当成一个变量赋值给另一个变量
    a()    # 函数调用  func()

3，函数名可以当做容器类的元素

    def func1():
        print("呵呵")
    def func2():
        print("呵呵")
    def func3():
        print("呵呵")
    lst = [func1 , func2 , func3]
    for i in lst:
        i()         # 通过for循环依次执行三个函数

4，函数名可以当做函数的参数

    def func():
        print("吃了么")

    def func2(fn):
        print("我是func2")
        fn()    # 执行传递过来的fn
        print("我是func2")

    func2(func)   # 把函数名func当成参数传递给func2的参数fn

5，函数名可以作为函数的返回值

    def func_1():
        print("这里是函数1")
        def func_2():
            print("这里是函数2")
        print("这里是函数1")
        return func_2
    fn = func_1()
    # 执行函数1，函数1返回的是函数2，这时fn指向的就是上面函数2
    # 结果为：
    # 这里是函数1
    # 这里是函数1
    fn()   # 执行上面返回的函数2
    # 结果为：
    # 这里是函数2

二、闭包

什么是闭包？闭包就是内层函数对外层函数（非全局）的变量的引用，如下示例：

    def func():
        a = 10
        def inner():
            print(a)    # 闭包
        inner()
    func()   # 结果为：10

我们可以用__closure__来检测函数是不是闭包，函数名.__closure__返回cell就是闭包，返回None就不是闭包。

    def func():
        a = 10
        def inner():
            print(a)
        inner()
        print(inner.__closure__)  # (<cell at 0x00000000025875B8: int object at 0x0000000058E26D40>,)
    func()

问题：如何在函数外边调用内部函数呢？具体示例如下：

    def outer():
        a = 'hello'
        # 内部函数
        def inner():
            print(a)
        return inner

    fn = outer()    # 访问外部函数，获取到内部函数的内存地址
    fn()   # 访问内部函数

那如果多层嵌套呢？很简单，只需要一层一层的往外层返回就行了，具体示例如下：

    def func1():
        def func2():
            def func3():
                print("嘿嘿")
            return func3
        return func2
    func1()()()   # 执行func3，结果为：嘿嘿

由它我们可以引出闭包的好处，由于我们在外界可以访问内部函数，那这个时候内部函数访问的时间和时机就不一定了，因为在外部，我可以选择在任意的时间去访问内部函数，这个时候，想一想，我们之前说过，如果一个函数执行完毕，则这个函数中的变量以及局部命名空间中内容将会被销毁，在闭包中，如果变量被销毁了，那内部函数将不能正常执行，所以，python规定：如果你在内部函数中访问了外层函数中的变量，那么这个变量将不会消亡，将会常驻在内存中，也就是说，使用闭包，可以保证外层函数中的变量在内存中常驻。这样做有什么好处呢？有非常大的好处，下面来看一个简单的关于爬虫的代码：

    from urllib.request import urlopen

    def but():
        content = urlopen("http://www.xiaohua100.cn/index.html").read()
        def get_content():
            return content
        return get_content

    fn = but()  # 这个时候就开始加载校花100的内容
    # 后面需要用到这里面的内容就不需要再执行非常耗时的网络连接操作了
    content = fn()   # 获取内容
    print(content)

    content2 = fn()   # 重新获取内容
    print(content2)

综上可得：闭包的作用就是让一个变量能够常驻内存，供后面的程序使用。

闭包补充：有如下代码示例：

    def func():
        a = "hello"
        def inner():
            print(a)
        return inner

    func()()  # 耗时，因为想要执行内层函数inner就要先执行一遍外层函数func，没有用到闭包的好处：外层函数变量常驻内存

    fn = func()  # 先执行外层函数func，因为是闭包，所以外层函数变量a常驻内存
    fn()   # 直接执行内层函数inner，用到了闭包的好处，并且后面程序随时可以直接通过fn()执行内层函数,而不用执行外层函数

三，迭代器

       我们之前一直在用可迭代对象进行迭代操作，那么到底什么是可迭代对象？首先我们先回顾一下目前我们所熟知的可迭代对象有哪些，有str，list，tuple，dict，set，那为什么我们可以称它们为可迭代对象呢？因为它们都遵循了可迭代协议，什么是可迭代协议？首先我们看下面一段错误代码：

    # 正确
    s = 'abc'
    for c in s:
        print(c)

    # 错误
    for i in 123:
        print(i)
    # 结果：
    # Traceback (most recent call last):
    #   File "E:/pythonDemo/1-basis/test10.py", line 107, in <module>
    #     for i in 123:
    # TypeError: 'int' object is not iterable

　　注意看报错信息中有这样一句话：'int' object is not iterable，翻译过来就是整数类型对象是不可迭代的，iterable表示可迭代的，表示可迭代协议，那么如何进行验证你的数据类型是否符合可迭代协议，我们可以通过dir函数来查看类中定义好的所有方法。具体示例如下：

    s = "我的哈哈哈"
    print(dir(s))   # 可以打印对象中的方法和函数
    print(dir(str))   # 也可以打印类中声明的方法和函数

　　在打印结果中，寻找__iter__，如果能找到，那么这个类的对象就是一个可迭代对象。我们发现在字符串中可以找到__iter__，继续看一下list，tuple，dict，set，具体如下：

    print(dir(list))
    print(dir(tuple))
    print(dir(dict))
    print(dir(set))
    print(dir(open("test9.py")))   # 文件对象

我们发现这几个可以进行for循环的东西都有__iter__函数，包括range也有，可以自己试一下。

综上可知，通过寻找__iter__可以查看一个对象是否是可迭代对象，除此之外，我们还可以通过isinstence()函数来查看一个对象是什么类型的，具体示例如下：

    ls = [1,2,3]
    ls_iter = ls.__iter__()   # 获取列表ls的迭代器
    from collections import Iterable
    from collections import Iterator
    print(isinstance(ls,Iterable))   # True  ls是可迭代对象的一个实例
    print(isinstance(ls,Iterator))    # False  ls不是迭代器的一个实例
    print(isinstance(ls_iter,Iterable))   # True  ls_iter是可迭代对象的一个实例
    print(isinstance(ls_iter,Iterator))   # True  ls_iter是迭代器的一个实例

综上，我们可以确定，如果对象中有__iter__函数，那么我们认为这个对象遵守了可迭代协议，就可以获取到相应的迭代器，上面代码中的__iter__就是帮我们获取到对象的迭代器，我们使用迭代器中的__next__()来获取到一个迭代器中的元素，那么我们之前讲的for循环的工作原理到底是什么呢？继续看下面代码：

    s = "我爱北京天安门"
    c = s.__iter__()   # 获取迭代器
    print(c.__next__())   # 使用迭代器进行迭代，获取一个元素：我
    print(c.__next__())   # 爱
    print(c.__next__())   # 北
    print(c.__next__())   # 京
    print(c.__next__())   # 天
    print(c.__next__())   # 安
    print(c.__next__())   # 门
    print(c.__next__())   # StopIteration

for循环如下：

    for i in [1,2,3]:
        print(i)

下面使用while循环+迭代器来模拟for循环（必须要掌握）：

    lst = [1,2,3]
    lst_iter = lst.__iter__()
    while 1:
        try:
            i = lst_iter.__next__()
            print(i)
        except StopIteration:
            break

总结：

       Iterable：可迭代对象，内部包含__iter__()函数，不包含__next__()函数；

       Iterator：迭代器，内部包含__iter__()函数，同时包含__next__()函数；

       迭代器特点：

              1，节省内存（下篇生成器中介绍）；

              2，惰性机制（遇到__next__才取一个）；

              3，不能反复，只能向下执行；

       我们可以把要迭代的内容当成子弹，然后呢，获取到迭代器__iter__()，就把子弹都装在弹夹中，然后发射就是__next__()把每一个子弹（元素）打出来，也就是说，for循环的时候，一开始是__iter__()来获取迭代器，后面每次获取元素都是通过__next__()来完成的，当程序遇到StopIteration将结束循环。