笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

迭代器和生成器

作者：笔触狂放9 | 2024-06-27 09:27:24

踩

迭代器和生成器

文章目录

迭代器 (iterator)
- 可迭代对象 (iterable)
- 迭代器对象 (iterator)
生成器 (generator)

迭代器 (iterator)

迭代：每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。
例如：循环获取容器中的元素。

可迭代对象 (iterable)

定义：具有__iter__函数的对象，返回迭代器对象。
语法

创建：

class 可迭代对象名称:

	def __iter__(self):
		return 迭代器
1
2
3
4

使用：

for 变量名 in 可迭代对象:
	语句
1
2

原理：迭代器 = 可迭代对象.iter()

while True:
	try: 
		print(迭代器.__next__())
	except StopIteration:
		break
1
2
3
4
5

for循环原理
可以被for的条件：对象具有__iter__()方法

list01 = [1, 2, 3, 4, 5]
# 迭代
for item in list01:
	print(item)
# 1. 获取迭代器
iterator = list01.__iter__()
while True:
    try:
		# 2. 获取下一个元素
        item = iterator.__next__()
        print(item)
	# 3. 如果没有元素则结束循环
    except StopIteration:
        break
1
2
3
4
5
6
7
8
9
10
11
12
13
14

迭代器对象 (iterator)

定义：可以被next()函数调用并返回下一个值的对象。

语法

class 迭代器类名:

    def __init__(self, 聚合对象):
        self.聚合对象= 聚合对象 

    def __next__(self): 
		if 没有元素:
			raise StopIteration
		return 聚合对象元素
1
2
3
4
5
6
7
8
9

说明：聚合对象通常是容器对象。

作用：
使用者只需通过一种方式，便可简洁明了的获取聚合对象中各个元素，而又无需了解其内部结构。
无论存储数据的具体容器是什么，可以以一种方式获取每个数据。

# 迭代器
class Iterator:

    def __init__(self, data):
        self. __data = data
        self.__index = 0

    def __next__(self):
    	try:
    		item = self.__data[self.__index]
    		self.__index += 1
    		return item
    	except:
    		raise StopIteration()

# 可迭代对象
class StudentManager:

    def __init__(self):
        self.__list_stus = ['吕布', '赵云', '典韦']

    def add_stu(self, name):
        self.__list_stus.append(name)

    def __iter__(self):
        return Iterator(self.__list_stus)


manager = StudentManager()

for item in manager:
    print(item)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

生成器 (generator)

定义：能够动态(循环一次计算一次返回一次)提供数据的可迭代对象。
作用：
在循环过程中，按照某种算法(+=1)推算数据，不必创建容器存储完整的结果，从而节省内存空间。
数据量越大，优势越明显。
以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。
优点：节省内存。
缺点：不能灵活访问数据(索引,切片)。

生成器函数

定义：含有yield语句的函数，返回值为生成器对象。
语法

创建：

def 函数名():
	语句
	yield 数据
1
2
3

调用：

for 变量名 in 函数名():
	语句
1
2

伪代码：生成器 --> 迭代器 + 可迭代对象

class Generator: 
    
    def __iter__(self):
        return self
    
    def __next__(self):
        ... 
1
2
3
4
5
6
7

说明：
调用生成器函数将返回一个生成器对象，不执行函数体。
yield翻译为”产生”或”生成”。
执行过程：
(1) 调用生成器函数会自动创建迭代器对象。
(2) 调用迭代器对象的__next__()方法时才执行生成器函数。
(3) 每次执行到yield语句时返回数据，暂时离开。
(4) 待下次调用__next__()方法时继续从离开处继续执行。

原理：生成迭代器对象的大致规则如下
将yield关键字以前的代码放在next方法中。
将yield关键字后面的数据作为next方法的返回值。

def my_range(end):
    begin = 0
    while begin < end:
        yield begin  # 暂时离开，再次调用继续执行
        begin += 1

for item in my_range(100):
    print(item)  # 0 1 2 3 4
1
2
3
4
5
6
7
8

内置生成器

枚举函数 (enumerate)

语法：

for 变量 in enumerate(可迭代对象):
	语句
for 索引, 元素in enumerate(可迭代对象):
	语句
1
2
3
4

作用：遍历可迭代对象时，可以将索引与元素组合为一个元组。

原理：

def my_enumerate(iterable):
    index = 0
    for item in iterable:
        yield (index, item)
        index += 1

list01 = [1, 2, 3, 4, 5]
for index, item in my_enumerate(list01):
    print(index, item)
# 等价于
for index, item in enumerate(list01):
    print(index, item)
1
2
3
4
5
6
7
8
9
10
11
12

zip

语法：

for item in zip(可迭代对象1, 可迭代对象2….):
	语句
1
2

作用：将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定。

原理：

def my_zip(iterable01, iterable02):
    for i in range(len(iterable01)):
        yield (iterable01[i], iterable02[i])

list01 = ["悟空", "八戒", "沙僧"]
for item in my_zip(list02, list01):
    print(item)
# 等价于
for item in zip(list02, list01):
    print(item)

1
2
3
4
5
6
7
8
9
10
11

生成器表达式

定义：用推导式形式创建生成器对象

语法：变量 = ( 表达式 for 变量 in 可迭代对象 if 真值表达式)

list01 = [1, 2, 3, 4, 5]
for item in (item + 10 for item in list01 if item % 2):
    print(item)
1
2
3

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/762059