"语法糖",从字面上看应该是一种语法。"糖",可以理解为简单、简洁。其实我们也已经意识到,没有这些被称为 "语法糖" 的语法,我们也能实现相应的功能,而 只是 Python 解释器会把这些特定格式的语法翻译成原本那样复杂的代码逻辑而已,没有什么太高深的东西。
到目前为止,我们使用和介绍过的语法糖有:
这里会再介绍两个:
顾名思义,列表生成式就是一个用来生成列表的特定语法形式的表达式。
- [exp
- for iter_var in iterable]
相当于这样的过程:
- L = []
- for iter_var in iterable:
- L.append(exp)
- [exp
- for iter_var in iterable if_exp]
相当于这样的过程:
- L = []
- for iter_var in iterable:
- if_exp:
- L.append(exp)
- [exp
- for iter_var_A in iterable_A
- for iter_var_B in iterable_B]
每迭代 iterable_A 中的一个元素,就把 ierable_B 中的所有元素都迭代一遍。
相当于这样的过程:
- L = []
- for iter_var_A in iterable_A:
- for iter_var_B in iterable_B:
- L.append(exp)
其实列表生成式也是 Python 中的一种 "语法糖",也就是说列表生成式应该是 Python 提供的一种生成列表的简洁形式,应用列表生成式可以快速生成一个新的 list。它最主要的应用场景是:
我们可以对几个生成列表的要求分别通过 "不使用列表生成式" 和 "使用列表生成式" 来实现,然后做个对比总结。
- # 不使用列表生成式实现
- list1 = list(range(3, 11))
- # 使用列表生成式实现
- list2 = [x for x in range(3, 11)]
- # 不使用列表生成式实现
- list3 = []
- for n in range(3, 11):
- list3.append(2*n + 1)
- # 使用列表生成式实现
- list4 = [2*n + 1 for n in range(3, 11)]
- L = [3, 7, 11, 14,19, 33, 26, 57, 99]
- # 不使用列表生成式实现
- list5 = []
- for x in L:
- if x < 20:
- list5.append(x)
- # 使用列表生成式实现
- list6 = [x for x in L if x > 20]
- L1 = ['香蕉', '苹果', '橙子']
- L2 = ['可乐', '牛奶']
- # 不使用列表生成式实现
- list7 = []
- for x in L1:
- for y in L2:
- list7.append((x, y))
- # 使用列表生成式实现
- list8 = [(x, y) for x in L1 for y in L2]
- D = {'Tom': 15, 'Jerry': 18, 'Peter': 13}
- # 不使用列表生成式实现
- list9 = []
- for k, v in D.items():
- list9.append((k, v))
- # 使用列表生成式实现
- list10 = [(k, v) for k, v in D.items()]
可见,使用列表生成式确实要方便、简洁很多,使用一行代码就搞定了。
我觉得,大家应该已经发现这里说的列表生成式的功能与之前 中讲到的 map() 和 filter() 高阶函数的功能很像,比如下面两个例子:
- L = ['TOM', 'Peter', 10, 'Jerry']
- # 用列表生成式实现
- list1 = [x.lower() if isinstance(x, str) else x for x in L]
- # 用map()函数实现
- list2 = list(map(lambda x: x.lower() if isinstance(x, str) else x, L))
- L = ['TOM', 'Peter', 10, 'Jerry']
- # 用列表生成式实现
- list3 = [x.lower() for x in L if isinstance(x, str)]
- # 用map()和filter()函数实现
- list4 = list(map(lambda x: x.lower(), filter(lambda x: isinstance(x, str), L)))
从名字上来看,生成器应该是用来生成数据的。
按照某种算法不断生成新的数据,直到满足某一个指定的条件结束。
构造生成器的两种方式:
如果计算过程比较简单,可以直接把列表生成式改成 generator;但是,如果计算过程比较复杂,就只能通过包含 yield 的函数来构造 generator。
- # 使用类似列表生成式的方式构造生成器
- g1 = (2*n + 1 for n in range(3, 6))
- # 使用包含yield的函数构造生成器
- def my_range(start, end):
- for n in range(start, end):
- yield 2*n + 1
- g2 = my_range(3, 6)
- print(type(g1))
- print(type(g2))
输出结果:
- <class 'generator'>
- <class 'generator'>
在执行过程中,遇到 yield 关键字就会中断执行,下次调用则继续从上次中断的位置继续执行。
要调用生成器产生新的元素,有两种方式:
- print(next(g1))
- print(next(g1))
- print(next(g1))
- print(next(g1))
输出结果:
- 7
- 9
- 11
- Traceback (most recent call last):
- File "***/generator.py", line 26, in <module>
- print(next(g1))
- StopIteration
- print(next(g2))
- print(next(g2))
- print(next(g2))
- print(next(g2))
输出结果:
- 7
- 9
- 11
- Traceback (most recent call last):
- File "***/generator.py", line 31, in <module>
- print(next(g2))
- StopIteration
可见,使用 next() 方法遍历生成器时,最后是以抛出一个
异常终止。
- StopIeration
- for x in g1:
- print(x)
- for x in g2:
- print(x)
两个循环的输出结果是一样的:
- 7
- 9
- 11
可见,使用循环遍历生成器时比较简洁,且最后不会抛出一个
异常。因此使用循环的方式遍历生成器的方式才是被推荐的。
- StopIeration
- def my_range(start, end):
- for n in range(start, end):
- ret = yield 2*n + 1
- print(ret)
- g3 = my_range(3, 6)
- print(g3.send(None))
- print(g3.send('hello01'))
- print(g3.send('hello02'))
输出结果:
- 7
- hello01
- 9
- hello02
- 11
- print(next(g3))
- print(next(g3))
- print(next(g3))
输出结果:
- 7
- None
- 9
- None
- 11
结论:
因为列表生成式是直接创建一个新的 list,它会一次性地把所有数据都存放到内存中,这会存在以下几个问题:
而生成器中的元素是按照指定的算法推算出来的,只有调用时才生成相应的数据。这样就不必一次性地把所有数据都生成,从而节省了大量的内存空间,这使得其生成的元素个数几乎是没有限制的,并且操作的返回时间也是非常快速的(仅仅是创建一个变量而已)。
我们可以做个试验:对比一下生成一个 1000 万个数字的列表,分别看下用列表生成式和生成器时返回结果的时间和所占内存空间的大小:
- import time
- import sys
- time_start = time.time()
- g1 = [x for x in range(10000000)]
- time_end = time.time()
- print('列表生成式返回结果花费的时间: %s' % (time_end - time_start))
- print('列表生成式返回结果占用内存大小:%s' % sys.getsizeof(g1))
- def my_range(start, end):
- for x in range(start, end):
- yield x
- time_start = time.time()
- g2 = my_range(0, 10000000)
- time_end = time.time()
- print('生成器返回结果花费的时间: %s' % (time_end - time_start))
- print('生成器返回结果占用内存大小:%s' % sys.getsizeof(g2))
输出结果:
- 列表生成式返回结果花费的时间: 0.8215489387512207
- 列表生成式返回结果占用内存大小:81528056
- 生成器返回结果花费的时间: 0.0
- 生成器返回结果占用内存大小:88
可见,生成器返回结果的时间几乎为 0,结果所占内存空间的大小相对于列表生成器来说也要小的多。
我们经常在 Python 的文档中看到 "Iterable" 这个此,它的意思是 "可迭代对象"。那么什么是可迭代对象呢?
目前我们已经知道的可迭代(可用于 for 循环)的数据类型有:
可以使用 isinstance() 来判断一个对象是否是 Iterable 对象:
- from collections import Iterable
- print(isinstance([], Iterable))
。
很明显上面讲的生成器也是迭代器。当然,我们可以使用 isinstance() 来验证一下:
- from collections import Iterator
- print(isinstance((x for x in range(5)), Iterator))
输出结果为:
- True
实际上,Python 中的 Iterator 对象表示的是一个数据流,Iterator 可以被 next() 函数调用被不断返回下一个数据,直到没有数据可以返回时抛出
异常错误。可以把这个数据流看做一个有序序列,但我们无法提前知道这个序列的长度。同时,Iterator 的计算是惰性的,只有通过 next() 函数时才会计算并返回下一个数据。(此段内容来自 )
- StopIteration
也就是说:迭代器、生成器和可迭代对象都可以用 for 循环去迭代,生成器和迭代器还可以被 next() 方函数调用并返回下一个值。
来源: