函数名的运用闭包以及迭代器

Posted zzliu

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了函数名的运用闭包以及迭代器相关的知识,希望对你有一定的参考价值。

函数名的运用

函数名是一种特殊的变量,函数名加上括号后表示函数执行,除此之外,函数名还可以进行如下几条操作:

1. 作为变量赋值

1 def func():
2     print(666)
3 
4 
5 f1 = func
6 f2 = f1
7 f2()   # 打印666

 

2. 作为容器内数据类型的元素

应用场景:需要调用多个函数的时候

方法一:

 1 def func1():
 2     print(111)
 3 
 4 
 5 def func2():
 6     print(222)
 7 
 8 
 9 def func3():
10     print(333)
11 
12 
13 func_list = [func1, func2, func3]
14 for func in func_list:
15     func()

执行结果

111
222
333

方法一里面是按照顺序执行函数,如果我们指定要执行某些函数呢,来看方法二

方法二:

 1 def func1():
 2     print(111)
 3 
 4 
 5 def func2():
 6     print(222)
 7 
 8 
 9 def func3():
10     print(333)
11 
12 
13 dic = {
14     1: func1,
15     2: func2,
16     3: func3
17 }
18 
19 for k in dic.keys():
20     dic[k]()

把函数放在字典里,想执行哪个就执行哪个

 

3. 作为函数的参数

1 def func(f):
2     f()
3 
4 
5 def func1():
6     print(222)
7 
8 
9 func(func1)    # 222

 

4. 作为函数的返回值

1 def func(x):
2     return x
3 
4 
5 def func1():
6     print("in func1")
7 
8 
9 func(func1)()   # in func1

实际上,函数名是第一类对象,第一类对象的特点:

1. 可在运行期间创建

2. 可用作函数参数或返回值

3. 可存入变量的实体

笼统来说,第一类变量就是普通变量

 

闭包

首先抛出一个问题:为什么要有闭包?来看两个例子

实例一:

 1 def func(step):
 2     num = 1
 3     num += step
 4     print(num)
 5 
 6 
 7 j = 0
 8 while j < 5:
 9     func(3)
10     j += 1

执行结果

4
4
4
4
4

上面是没有使用闭包的情况,下面来看使用闭包的情况

实例二:

 1 def wrapper(step):
 2     num = 1
 3 
 4     def inner():
 5         nonlocal num    # 引用num,与return inner形成闭包
 6         num += step     # 此时num在inner执行完了之后不会被清理,会作为下一次的起始值
 7         print(num)
 8     return inner
 9 
10 
11 f = wrapper(3)
12 j = 0
13 while j < 5:
14     f()
15     j += 1

执行结果

4
7
10
13
16

首先来看函数的结构,这是一个嵌套函数,wrapper函数里面嵌套一个inner函数,要知道,在函数外面是不能直接调用内层函数的,那么我们怎么做呢?答案是通过return,我们可以把外层函数的返回值设置为内层函数名,这样层层返回,就可以在外界调用任意位置的内层函数。可是这和闭包又有什么关系呢?当然有啦,比如说我想调用inner函数对num进行操作,那么我是不是得让inner的外层函数wrapper的返回值设置为inner啊,其次还得在inner内部设置nonolocal,要不然就不能对num就行操作,其实在内层函数引用外层函数的变量,然后外层函数返回内层函数这样就形成了闭包,总结一下,关于闭包:

1. 内层函数对外层函数(非全局)变量的引用

2. 闭包只存在于内层函数中

3. 函数都要逐层返回,最终返回给最外层函数

下面来看一个例子,

1 def func(n):  # 相当于n=name
2     def inner():
3         print(n)
4 
5     return inner
6 
7 
8 name = "Hanser"
9 f = func(name)

这个是不是闭包呢,答案是肯定的,这里的n传入func里面后是存放于func的名称空间里的,inner的print(n)就是内层函数对外层函数的引用,然后func的返回值是内层函数名inner,所以这个是闭包。这样判断是不是有点麻烦啊,那么有没有简单的办法呢,有的,python提供了判断闭包的方法: __closure__,来看代码

 1 def func1(a):
 2     n = 1
 3 
 4     def func2():
 5         nonlocal n
 6         n += a
 7 
 8         def func3():
 9             nonlocal n
10             n *= a
11             print(n)
12         return func3
13     return func2
14 
15 
16 f = func1(3)  # f = func2
17 print(f.__closure__[0].cell_contents)    # 获取引用的外层函数的变量,如果能获取到,就是闭包
18 print(f.__closure__[1].cell_contents)    #
19 # print(f.__closure__[2].cell_contents)    # 报错,没有第三个
20 
21 print("------我是华丽丽的分割线-------")
22 
23 f1 = func1(3)()     # f1 = func3
24 print(f1.__closure__[0].cell_contents)
25 print(f1.__closure__[1].cell_contents)
26 # print(f1.__closure__[2].cell_contents)     # 报错,没有第三个

执行结果

3
1
------我是华丽丽的分割线-------
3
4

总结一下,判断步骤:

(1)找到要判断的内层函数(line16和line23)

(2)获取该内层函数引用的外层函数的变量

(3)能获取到,是闭包;否则不是闭包

这里有一个小知识点:获取到的引用的外层函数的变量顺序传入的参数------->外层函数定义的变量

 

闭包作用

正常程序执行时,遇到函数,随着函数的结束而关闭临时名称空间,闭包的本质就是闭包会创建一个空间,这个空间不会随着函数的结束而关闭,因而之后可以继续调用,这是非常有用的,闭包的引用场景:

1. 装饰器

2. 爬虫

来看一个爬虫实例

 1 from urllib.request import urlopen
 2 
 3 
 4 def but():
 5     content = urlopen("https://book.douban.com/annual/2018?source=navigation#1").read()    # 获取网页源代码
 6 
 7     def get_content():
 8         return content
 9     return get_content
10 
11 
12 fn = but()
13 print(id(fn()))    # 2505706231536
14 print(id(fn()))    # 2505706231536  两个id一样,证明第一次获取的内容没有消失,第二次是直接调用第一次的内容
15 content1 = fn()   # 获取内容
16 print(content1.decode("utf-8"))   # 解码

 

执行结果

2505706231536
2505706231536
<!doctype html>

<html lang="zh-cmn-Hans">

    <head>
        <meta charset="utf-8">
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover">
        <meta name="apple-mobile-web-app-capable" content="yes">
        <link rel="shortcut icon" href="https://img3.doubanio.com/favicon.ico">
        <meta name="format-detection" content="telephone=no">
        <meta name="url_name" content="book_annual2018">
        <meta name="user_id" content="">
        <meta property="og:site_name" content="豆瓣" />
        <meta property="og:title" content="豆瓣2018年度读书榜单" />
        <meta property="og:description" content="这一年不可错过的好书都在这里了" />
        <meta property="og:url" content="https://book.douban.com/annual/2018?source=broadcast" />
        <meta property="og:image" content="https://img3.doubanio.com/img/files/file-1545618075.jpg" />
        <title>豆瓣2018年度读书榜单</title>
        <script>
            window.ITHIL = {};
            ITHIL.isFrodo = False === True;
            ITHIL.isWechat = False === True;
        </script>
        <script>
            var _hmt = _hmt || [];
            (function() {
                var hm = document.createElement("script");
                var hash = 2018 === 2018 ? 6e5dcf7c287704f738c7febc2283cf0c : 16a14f3002af32bf3a75dfe352478639
                hm.src = "https://hm.baidu.com/hm.js?" + hash;
                var s = document.getElementsByTagName("script")[0]; 
                s.parentNode.insertBefore(hm, s);
            })();
        </script>
    </head>
    <body>
        <div id="app"></div>
        <script src="https://img3.doubanio.com/f/ithil/31683c94fc5c3d40cb6e3d541825be4956a1220d/js/lib/es5-shim.min.js"></script>
        <script src="https://img3.doubanio.com/f/ithil/a7de8db438da176dd0eeb59efe46306b39f1261f/js/lib/es6-shim.min.js"></script>
            <script src="https://img3.doubanio.com/dae/cdnlib/libs/jweixin/1.0.0/jweixin.js"></script>
                <script src="https://img3.doubanio.com/f/ithil/b92012acc8222b31e7f1307c154fdb90b56d64d1/gen/ithil2018.bundle.js"></script>
            <div alt="main-pic" style="display: none">
                <img type="hidden" alt="cover" src="https://img3.doubanio.com/img/files/file-1545618075.jpg">
            </div>
    </body>
</html>

content内容不会随着but函数的结束而消失,这个非常有用,因为获取内容后还要进行筛选等操作,而请求一次因为网络延时等原因是非常耗时间的,有了闭包,就不用再次去请求获取内容,节省了很多时间。

迭代器

在讲迭代器之前,先来看一下可迭代对象,什么是可迭代对象呢,可迭代对象的定义是:内部含有__iter__方法的对象。

判断方法

方法一:

s1 = "hello"
print(dir(s1))   # 返回的方法里面有__iter__()就是可迭代对象
print("__iter__" in dir(s1))   # True

执行结果

[__add__, __class__, __contains__, __delattr__, __dir__, __doc__, __eq__, __format__, __ge__, __getattribute__, __getitem__, __getnewargs__, __gt__, __hash__, __init__, __init_subclass__, __iter__, __le__, __len__, __lt__, __mod__, __mul__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__, __rmod__, __rmul__, __setattr__, __sizeof__, __str__, __subclasshook__, capitalize, casefold, center, count, encode, endswith, expandtabs, find, format, format_map, index, isalnum, isalpha, isdecimal, isdigit, isidentifier, islower, isnumeric, isprintable, isspace, istitle, isupper, join, ljust, lower, lstrip, maketrans, partition, replace, rfind, rindex, rjust, rpartition, rsplit, rstrip, split, splitlines, startswith, strip, swapcase, title, translate, upper, zfill]
True

 

f = open("goods.txt", encoding="utf-8", mode="r")
print(dir(f))
print("__iter__" in dir(f))

执行结果

[_CHUNK_SIZE, __class__, __del__, __delattr__, __dict__, __dir__, __doc__, __enter__, __eq__, __exit__, __format__, __ge__, __getattribute__, __getstate__, __gt__, __hash__, __init__, __init_subclass__, __iter__, __le__, __lt__, __ne__, __new__, __next__, __reduce__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __str__, __subclasshook__, _checkClosed, _checkReadable, _checkSeekable, _checkWritable, _finalizing, buffer, close, closed, detach, encoding, errors, fileno, flush, isatty, line_buffering, mode, name, newlines, read, readable, readline, readlines, seek, seekable, tell, truncate, writable, write, writelines]
True

 

方法二:

1 from collections import Iterable
2 from collections import Iterator
3 l1 = [1, 2, 3]
4 print(isinstance(l1, Iterable))  # 判断是否是可迭代对象
5 print(isinstance(l1, Iterator))  # 判断是否是迭代器

执行结果

True
False

那么什么是迭代器呢,迭代器在可迭代对象的基础上增加了__next__方法(取值用),可迭代对象可以转化成迭代器,你猜的没错,就是用__iter__方法

1 obj = s1.__iter__()    # 方法一:可迭代对象转化成迭代器
2 # obj = iter(s1)         # 方法二:可迭代对象转化成迭代器
3 print(obj.__next__())   # a
4 print(obj.__next__())   # b
5 print(obj.__next__())   # c
6 print(obj.__next__())   # d
7 print(obj.__next__())   # 报错 StopIteration

执行结果

a
b
c
d

分析上述代码可以发现规律,__next__方法每次只取一个值,当取值个数超出时会报错,此外__next__()方法可以用next()方法代替。

1 s2 = [1, 2, 3]
2 obj = s2.__iter__()
3 print(obj.__next__())
4 print(next(obj))   # 与__next__一样

执行结果

1
2

 

运用迭代器和while循环还可以模拟for循环,来看代码

1 lst = [1, 2, 3, 4, 5]
2 obj = iter(lst)
3 while True:
4     try:
5         print(next(obj))
6     except StopIteration:
7         break

执行结果

1
2
3
4
5

试试字典

1 dic = {"name": "hanser", "age": 18, "height": 148}
2 obj = iter(dic)
3 while True:
4     try:
5         print(next(obj))
6     except StopIteration:
7         break

执行结果

name
age
height

对字典直接取值取出的是key,如果想取value或者键值对把dic换成dic.values()或dic.items()就行

1 dic = {"name": "hanser", "age": 18, "height": 148}
2 obj = iter(dic.values())
3 while True:
4     try:
5         print(next(obj))
6     except StopIteration:
7         break

执行结果

hanser
18
148

总结一下:

可迭代对象:内部含有__iter__方法的对象

  str, list, tuple, dic, set, range(), 文件句柄都是可迭代对象

迭代器:内部含有__iter__方法和__next__方法的对象

  str, list, tuple, dic, set, range()不是迭代器

  文件句柄是迭代器

判断可迭代对象和迭代器的方法

  "__iter__" in dir(s), "__next__" in dir(s)

  isinstance(s, Iterable), isinstance(s, Iterator)

可迭代对象转化成迭代器

  __iter__(), iter()

迭代器特点

  节省内存,迭代器只存放下一个对象的值

  惰性机制,next一次取一个值

  单项取值,不走回头路

利用迭代器和while循环可以模拟for循环

 

以上是关于函数名的运用闭包以及迭代器的主要内容,如果未能解决你的问题,请参考以下文章

第一类对象 闭包和迭代器

第十一天 函数名的使用以及第一类对象, 闭包, 迭代器

闭包和迭代器

python之函数名,闭包迭代器

python 小兵迭代器

python函数名的应用闭包和迭代器