Python 之列表/集合/字典解析式、生成器表达式、迭代器和可迭代对象的深入浅出

最新推荐文章于 2022-04-05 15:02:12 发布

Lee木木

最新推荐文章于 2022-04-05 15:02:12 发布

阅读量382

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/weixin_44983653/article/details/113776560

版权

Python 专栏收录该内容

63 篇文章 12 订阅

订阅专栏

本文深入介绍了Python中的列表解析式、生成器表达式及其优势，包括多条件和多元素解析，以及相关示例。同时，详细讲解了集合解析式、迭代器和可迭代对象的概念与用法，强调了生成器的延迟计算特性与内存占用优势。

摘要由CSDN通过智能技术生成

Python 之列表/集合/字典解析式、生成器表达式、迭代器和可迭代对象的深入浅出

1、列表解析式 List Comprehension
2、生成器表达式 Generator Expression
3、集合解析式
- 3.1 语法
- 3.2 示例
4、集合解析式
- 4.1 语法
- 4.2 示例
5、迭代器
- 5.1 概念
- 5.2 示例
6、可迭代对象
- 6.1 概念
- 6.2 示例
7、总结

1、列表解析式 List Comprehension

1.1 语法

[ 返回值 for 元素 in 可迭代对象 if 条件 ]
使用中括号[]，内部是 for 循环，if 条件语句可选
返回一个新的列表

1.2 优势

列表解析式是一种语法糖
编译器会优化，不会因为简写而影响效率，反而因优化提高了效率
减少程序员工作量，减少出错
简化了代码，但可读性强

1.3 多条件列表解析式

[expr for item in iterable if cond1 if cond2 if cond3 ...]

上面代码等价于下面代码：

# 适合于 一斜到底 单分支 if 语句
ret = []
for item in iterable:
	if cond1:
		if cond2:
			if cond3:
				ret.append(expr)

1.4 多元素列表解析式

[expr for i in iterable1 for j in iterable2]

上面代码等价于下面代码：

ret = []

for i in iterable1:
	for j in iterable2:
		ret.append(expr)

1.4 示例

1.4.1 获取 10 以内的偶数

# 方法一
even = []

for i in range(10):
    if i % 2 == 0:
        even.append(i)

print(even)

[0, 2, 4, 6, 8]

# 方法二
even = [x for x in range(10) if x % 2 == 0]

print(even)

[0, 2, 4, 6, 8]

两种方法的效率比较

# Jupyter Notebook 环境
%%timeit
even = [] 

for i in range(100):
    if i % 2 == 0:
        even.append(i)

6.03 µs ± 26.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

# Jupyter Notebook 环境
%timeit ([i for i in range(100) if i % 2 == 0])

4.57 µs ± 26 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

1.4.2 以下代码生成的列表是什么

print() 函数的返回值为 None，所以生成的列表是 5 个 None

newlist = [print(i) for i in range(5)]

print('newlist = {}'.format(newlist))

0
1
2
3
4
newlist = [None, None, None, None, None]

1.4.3 20以内，既能被 2 整除又能被 3 整除的数

[i for i in range(20) if i % 2 == 0 and i % 3 ==0]

# [0, 6, 12, 18]

[i for i in range(20) if i % 2 == 0 if i % 3 ==0]

# [0, 6, 12, 18]

1.4.4 思考以下列表解析式生成的列表

[(x, y) for x in 'abc' for y in range(2)]

# [('a', 0), ('a', 1), ('b', 0), ('b', 1), ('c', 0), ('c', 1)]

[[x, y] for x in 'abc' for y in range(2)]

# [['a', 0], ['a', 1], ['b', 0], ['b', 1], ['c', 0], ['c', 1]]

[{x, y} for x in 'abc' for y in range(2)]

# [{0, 'a'}, {1, 'a'}, {0, 'b'}, {1, 'b'}, {0, 'c'}, {1, 'c'}]

[(i, j) for i in range(7) if i > 4 for j in range(20, 25) if j > 22]

[(i, j) for i in range(7) for j in range(20, 25) if i > 4 if j > 22]

[(i, j) for i in range(7) for j in range(20, 25) if i > 4 and j > 22]

# [(5, 23), (5, 24), (6, 23), (6, 24)]

1.4.4 列表解析式里的列表元素

从下例可以看出，列表解析式里的列表元素 id 不一样，所以不是同一个引用列表

list1 = [[1, 0] for x in 'abce' for y in range(2)]

print(list1)

for i in range(len(list1)):
    print(id(list1[i]))

[[1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0], [1, 0]]
117234952
117235016
117235272
117235208
117235144
117235080
117235400
117235336

2、生成器表达式 Generator Expression

2.1 语法

( 返回值 for 元素 in 可迭代对象 if 条件 )
列表解析式中的方括号换为小括号就行了
返回一个生成器

2.2 生成器表达式本质

列表解析式是立即返回值
生成器表达式是 按需计算（或称惰性求值、延迟计算）
生成器表达式是需要的时候才计算值

2.3 生成器特点

可迭代对象
迭代器

2.4 生成器表达式优势

计算方式：生成器表达式延迟计算，列表解析式立即计算
内存占用：
1、但从返回值本身来说，生成器表达式省内存，列表解析式返回新的列表
2、生成器没有数据，占用内存极少，它是使用时一个个返回数据。如果将这些返回的数据合起来占用的内存和列表解析式差不多。但是，它不需要立即占用那么多内存
3、列表解析式构造新的列表需要立即占用内存，不管你是否李捷使用这么多数据
计算速度
1、单看计算时间，生成器表达式耗时非常短，列表解析式耗时长
2、但是生成器本身并没有返回任何值，只返回了一个生成器对象
3、列表解析式构造并返回了一个新的列表，所以耗时较长

2.5 示例

2.5.1 从示例来看列表解析式和生成器表达式区别

2.5.1.1 生成器表达式

从下面示例中可以总结出：

生成器表达式是延迟计算，可以使用 next(g)获取
生成器表达式返回一个迭代器，可以迭代
从前到后走完一遍后，不能回头
使用 for 可以遍历生成器
如果生成器已迭代完毕，使用 next() 会报错，使用 for 不会

g = ('{:04}'.format(i) for i in range(5))
print(1, 'g is {}.'.format(g))
print(2, 'type(g) is {}.'.format(type(g)))

print(3, next(g))
for x in g:
    print(x)

print('4============4')

for x in g:
    print(x), type(x)
    
print('5============5')

print(6, next(g))

1 g is <generator object <genexpr> at 0x00000000077D9548>.
2 type(g) is <class 'generator'>.
3 0000
0001
0002
0003
0004
4============4
5============5
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-65-8121dfd1b116> in <module>
     13 print('5============5')
     14 
---> 15 print(6, next(g))

StopIteration:

2.5.1.2 列表解析式

从下面示例中可以总结出：

列表解析式是立即计算
列表解析式返回的不是迭代器，返回可迭代对象列表
从前到后走完一遍后，可以再次回头迭代

g = ['{:04}'.format(i) for i in range(5)]
print(1, 'g is {}.'.format(g))
print(2, 'type(g) is {}.'.format(type(g)))

for x in g:
    print(x)

print('3============3')

for x in g:
    print(x), type(x)
    
print('4============4')

1 g is ['0000', '0001', '0002', '0003', '0004'].
2 type(g) is <class 'list'>.
0000
0001
0002
0003
0004
3============3
0000
0001
0002
0003
0004
4============4

3、集合解析式

3.1 语法

{ 返回值 for 元素 in 可迭代对象 if 条件 }
列表解析式中的中括号换为大括号即可
立即返回一个集合

3.2 示例

set1 = {(x, x+1) for x in range(5)}
print(set1, type(set1))

# {(0, 1), (1, 2), (4, 5), (2, 3), (3, 4)} <class 'set'>

set2 = {(i, j) for i in range(2) for j in range(2)}
print(set2, type(set2))

# {(0, 1), (1, 0), (0, 0), (1, 1)} <class 'set'>

{[x] for x in range(5)}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-69-a39ffa943c7e> in <module>
----> 1 {[x] for x in range(5)}

<ipython-input-69-a39ffa943c7e> in <setcomp>(.0)
----> 1 {[x] for x in range(5)}

TypeError: unhashable type: 'list'

4、集合解析式

4.1 语法

{ 返回值 for 元素 in 可迭代对象 if 条件 }
列表解析式中的中括号换为大括号即可
使用key:value形式
立即返回一个字典

4.2 示例

{x:(x, x+1) for x in range(3)}

# {0: (0, 1), 1: (1, 2), 2: (2, 3)}

{x:[x, x+1] for x in range(3)}

# {0: [0, 1], 1: [1, 2], 2: [2, 3]}

{(x, ):[x, x+1] for x in range(3)}

# {(0,): [0, 1], (1,): [1, 2], (2,): [2, 3]}

{chr(0x41+x):x**2 for x in range(3)}

# {'A': 0, 'B': 1, 'C': 4}

{str(x):y for x in range(3) for y in range(4)}

# {'0': 3, '1': 3, '2': 3}
# 字典赋值会进行覆盖

5、迭代器

5.1 概念

特殊的对象，一定是可迭代对象，具备可迭代对象的特征

通过 iter 方法把一个可迭代对象封装成迭代器

Docstring:
iter(iterable) -> iterator
iter(callable, sentinel) -> iterator

Get an iterator from an object.  In the first form, the argument must
supply its own iterator, or be a sequence.
In the second form, the callable is called until it returns the sentinel.
Type:      builtin_function_or_method

通过 for 方法，迭代迭代器对象
通过 next 方法，迭代迭代器对象
生成器对象，也是迭代器对象
从前到后走完一遍后，不能回头
如果迭代器已迭代完毕，使用 next() 会报错，使用 for 不会

5.2 示例

iter1 = iter(range(3))
print(type(iter1))
print(iter1)
for i in iter1:
    print(i)
print('==============')
for i in iter1:
    print(i)
print('==============')

<class 'range_iterator'>
<range_iterator object at 0x0000000008328830>
0
1
2
==============
==============

iter2 = iter(list(range(3)))
print(type(iter2))
print(iter2)
print(1, next(iter2))
for i in iter2:
    print(i)
print('==============')
print(next(iter2))
print('==============')

<class 'list_iterator'>
<list_iterator object at 0x00000000027CA308>
1 0
1
2
==============
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-107-d48de9f46b81> in <module>
      6     print(i)
      7 print('==============')
----> 8 print(next(iter2))
      9 print('==============')

StopIteration:

6、可迭代对象

6.1 概念

能够通过迭代一次次返回不同元素的对象
1、所谓相同，不是指值是否相同，而是元素在容器中是否是同一个
2、列表中有重复的值，但是索引不同，这就是两个不同的元素
可以迭代，但是未必有序，未必可索引
可迭代对象有：list / tuple / string / bytes / bytearray / range / set / dict / 生成器 / 迭代器
可以使用成员操作符 in / not in
in 本质上对于线性结构就是在遍历对象，非线性结构求 hash

6.2 示例

3 in range(5)  # True
3 in (x for x in range(5))  # True
3 in {x:y for x,y in zip(range(4), range(4, 10))}  # True

7、总结

一般来说，应该多应用解析式，简短高效
如果一个解析式非常复杂，难以读懂，可以拆解为 for 循环
生成器和迭代器是不同的对象，但都是可迭代对象
可迭代对象范围更大，但都可以使用 for 循环遍历
可迭代对象 > 迭代器对象 > 生成器对象

Lee木木

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Python 之列表/集合/字典解析式、生成器表达式、迭代器和可迭代对象的深入浅出

Python 之列表/集合/字典解析式、生成器表达式、迭代器和可迭代对象的深入浅出1、列表解析式 List Comprehension1.1 语法1.2 优势1.3 多条件列表解析式1.4 多元素列表解析式1.4 示例1.4.1 获取 10 以内的偶数1.4.2 以下代码生成的列表是什么1.4.3 20以内，既能被 2 整除又能被 3 整除的数1.4.4 思考以下列表解析式生成的列表2、生成器表达式 Generator Expression2.1 语法2.2 生成器表达式本质2.3 生成器特
复制链接

扫一扫