闭包,迭代器

时间 2019-12-13

标签闭包迭代繁體版

原文原文链接

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

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

1，函数名的内存地址；网络

ef 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()

4，函数名能够当作函数的参数；url

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

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

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

5，函数名能够做为函数的返回值；　　spa

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

2、闭包翻译

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

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将结束循环。