迭代器和生成器--附加zip

最新推荐文章于 2022-06-25 11:08:13 发布
最新推荐文章于 2022-06-25 11:08:13 发布
阅读量188 收藏
点赞数
分类专栏： Python笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43907629/article/details/88757766
版权

迭代器使用

在迭代器使用之前，先举个例子：

list01 = [1,2133,345,5,6]
# for item in list01:
#     print(item)

# for 循环原理：
#  1. 获取迭代器对象
#  2. 循环获取下一个元素
#  3. 遇到StopIteration停止迭代


# 可以被for的条件（什么是可迭代对象）：
# 可以获取迭代器对象(具有__iter__方法)


#1. 获取迭代器对象
iterator =  list01.__iter__()
#2. 获取下一个元素
item = iterator.__next__()
print(item)
print(iterator.__next__())
print(iterator.__next__())
print(iterator.__next__())
print(iterator.__next__())
#3. 直到错误 StopIteration 停止
print(iterator.__next__()) 
iterator =  list01.__iter__()


while True:
    try:
        print(iterator.__next__())
    except StopIteration:
        break # 跳出循环

练习题1：(“悟空”,“八戒”,“唐僧”,“沙僧”,“女儿国国王”)
使用while + 迭代器 获取元组所有元素

tuple = ('悟空','八戒','唐僧','沙僧','女儿国国王')
tuple1 = tuple.__iter__()
while True:
    try:
        print(tuple1.__next__())
    except StopIteration:
        break
 结果：
		悟空
		八戒
		唐僧
		沙僧
		女儿国国王

练习2：{“悟空”:2000,“八戒”:3000,“唐僧”:1000,“沙僧”:2800}
不使用for，获取字典所有元素

dict1 = {'悟空':2000, '八戒':3000, '唐僧':1000, '沙僧':2800, }
dict01 = dict1.__iter__()
while True:
    try:
        key = dict01.__next__()
        value = dict1[key]
        print(key,value)
    except StopIteration:
        break
 结果：
		唐僧 1000
		沙僧 2800
		八戒 3000
		悟空 2000

以上的两个代码都是将元组、字典里的元素逐个打印出来。这种我们认为是迭代的使用。

可迭代对象iterable：

每一次对过程的重复称为‘迭代一次’，每一次重复的结果作为下一次迭代的初始值。
可迭代对象iterable：

  1. 定义：具有__iter__函数的对象。可以返回迭代器对象。

  2. 语法：

    ---创建的过程
    class 可迭代对象类名:
        def__iter__(self)
    ---使用
    for 变量名 in 可迭代对象:
        语句

  3. 原理：

    变量 = 可迭代对象.__iter__()
    while True:
        try:
            元素 = 变量.__next__()
        except:
            break

迭代器iterator：

按照惯例，还是还有个参考代码：
4. 参考代码：
```
“”"
迭代器
“”"

class Skill:
    pass


class SkillIterator:
    """
        技能迭代器
    """

    def __init__(self, target):
        self.target = target
        self.index = 0

    # def __next__(self):
    #     item = self.target[self.index]
    #     self.index += 1
    #     return item

    def __next__(self):
        # 如果索引越界  则停止迭代
        if self.index >= len(self.target):
            raise StopIteration()

        item = self.target[self.index]
        self.index += 1
        return item


class SkillManager:
    def __init__(self, skills):
        self.skills = skills

    def __iter__(self):
        # 1. 创建迭代器对象
        # 2. 传递需要迭代的数据
        return SkillIterator(self.skills)


manager = SkillManager([Skill(), Skill(), Skill()])
# for item in manager:
#     print(item)

iterator = manager.__iter__()
# 使用迭代器获取manager中的技能列表
while True:
    try:
        item = iterator.__next__()
        print(item)
    except:
        break

```

  1. 定义：具有__next__的对象，可以获取下一个元素。

  2. 语法：

    class 迭代器名称：
        def __init__(self,参数):
            self.数据 = 参数    #数据就是聚合对象
        def __next__():
            if 没有元素:
                raise Stoplteration  #停止迭代
            return 数据中的元素#聚合对象的元素

  3. 作用：使用者只需要通过一种方式__next__,便可简单明了的获取聚合对象中的元素

  4. 练习题：

    参照下列代码。自定义MyRange类。实现以下效果
参照代码：
for item in range(5)
    print(item) #0 1 2 3 4
实现代码：
for item in MyRange(5):
    print(item) #0 1 2 3 4     

    习题答案：
class MyRangeIterator:
#迭代器
    def __init__(self, stop):
        self.stop = stop
        self.start = 0

    def __next__(self):
    #创建可迭代对象
        if self.start >= self.stop:
            raise StopIteration()
        temp = self.start
        self.start += 1
        return temp


class MyRange:
    def __init__(self, stop):
        self.stop = stop

    def __iter__(self):
        return MyRangeIterator(self.stop)


for item in MyRange(5):
    print(item)  # 0  1   2   3 4

迭代———yield：

还是以上述代码为例：

class Skill:
    pass


# class SkillIterator:
#
#     def __init__(self, target):
#         self.target = target
#         self.index = 0
#
#     def __next__(self):
#         # 如果索引越界  则停止迭代
#         if self.index >= len(self.target):
#             raise StopIteration()
#         item = self.target[self.index]
#         self.index += 1
#         return item


class SkillManager:
    def __init__(self, skills):
        self.skills = skills

    def __iter__(self):# 15:30 上课
        # SkillIterator(self.skills)
        # 本质：
        #     解释器检测到yield关键字，就会生成迭代器对象。
        # 自动生成迭代器的大致规则：
        #     1. yield 关键字以前的代码会放到__next__方法中
        #     2. yield 关键字后面的数据会作为__next__方法的返回值
        # 现象：
        #     调用当前方法时，不执行。
        #     当调用__next__方法时，才执行。
        #     执行到 yield 关键字，暂时离开。
        #     当再次调用__next__方法时，继续执行。
        #     执行到 yield 关键字，暂时离开。
        #     .....

        # print("我的第一次")
        # yield self.skills[0]
        #
        # print("我的第二次")
        # yield self.skills[1]
        #
        # print("我的第三次")
        # yield self.skills[2]

        for i in range(len(self.skills)):
            yield  self.skills[i]


manager = SkillManager([Skill(), Skill(), Skill()])
# for item in manager:
#     print(item)

iterator = manager.__iter__()
while True:
    try:
        item = iterator.__next__()
        print(item)
    except Exception as e:
        print(type(e))
        break

生成器generator：

  1. 生成器的本质：

    """生成器本质
class MyRangeIterator:
    def __init__(self, stop):
        self.stop = stop
        self.start = 0

    def __next__(self):
        if self.start >= self.stop:
            raise StopIteration()
        temp = self.start
        self.start += 1
        return temp


class MyGenerator:
    def __init__(self, stop):
        self.stop = stop

    def __iter__(self):
         return MyRangeIterator(self.stop)

for item in MyGenerator(5):
    print(item)
    
g01 = MyGenerator(5)
iter01 = g01.__iter__()
while True:
    try:
        print(iter01.__next__())
    except:
        break
"""

  2. 练习题：将MyRange修改为yield

    def my_range(stop):
    start = 0
    while start < stop:
        yield start
        start += 1

for item in my_range(5):
    print(item)  # 0  1   2   3 4

  3. 定义：能够动态（循环一次，计算一次返回一次）提供数据的可迭代对象

  4. 作用：在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，而节省内存空间，数据量越大，优势越明显

  5. 惰性操作：在需要的时候才计算结果，

生成器函数：

  1. 定义：含有yield关键字的函数，返回值是生成器对象，

  2. 语法：

    --创建：
        def 方法名():
            ...
            yield 数据
    --使用
    for 变量名 in 方法名():
        语句

  3. 本质：

    --创建
    class 生成器名称:
        def __iter__(self):
            return 迭代器对象
    --使用
    生成器变量名 = 生成器名称()
    迭代器变量名 = 变量名.__iter__()
    while True:
        try:
            print(迭代器变量名.__next__())
        except:
            break

  4. 语法说明：

    --调用生成器函数会返回迭代器对象，不执行函数体。
    --执行过程：
        1.调用生成器函数，自动创建迭代器对象，
        2.调用迭代器对象的__next__()方法才执行生成器函数体
        3.每次执行到yield关键字是返回数据，暂时离开。
        4.带下次调用__next__()方法继续执行。

  5. 生成迭代器对象原理：

     1.将yield关键字以前的代码放到__next__()方法中。
 2.将yield关键字以后的数据作为__next___()方法返回值。

生成器表达式

按照惯例，先熟悉代码。
list01 = [2,3,4,5]

# list02 = []
# for item in list01:
#     list02.append(item ** 2)

# 列表推导式
list02 = [item ** 2 for item in list01] # 执行过后，内存中就存储了所有数据
for item in list02:
    print(item)
# 生成器表达式
g03 = (item ** 2 for item in list01) # 执行过后，没有计算结果。
print(g03)
for item in g03: # 循环一次  计算一次  返回一次
    print(item)
  1. 语法：(表达式 for 变量 in 可迭代对象 [if 条件])
  2. 定义：用推导式语法创建的生成器对象。

zip-----将多个可迭代对象的元素组合成一个个元组：

  1. zip：将多个可迭代对象的元素组合成一个个元组

  2. 练习：

    """
    # 练习：my_zip
    list02 = ["A", "B", "C"]
    for item in zip(list01, list02):
        print(item)
"""

def my_zip(target01,target02):# *args
    for i in range(len(target01)):
        yield (target01[i],target02[i])

list01 = ["a", "b", "c"]
list02 = ["A", "B", "C"]

for item in my_zip(list01, list02):
    print(item)

  3. 练习2：

    list01 = ["a", "b", "c"]


# enumerate : 将列表中的每个元素 与 索引 组合为一个元组 16:28
# for item in enumerate(list01):
#     print(item[0],item[1])

def my_enumerate(list_target):
    index = 0
    for item in list_target:
        yield (index, item)
        index += 1
for item in my_enumerate(list01):
	print(item[0], item[1])

for index, item in my_enumerate(list01):
	print(index, item)



#练习：my_zip
#zip：将多个可迭代对象的元素组合成一个个元组。

list02 = ["A", "B", "C"]
for item in zip(list01, list02):
	print(item)
look ahead to
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
汇顶图案批量生成工具(附加阶梯走线自动生成器).zip
01-13
总结来说，汇顶图案批量生成工具和阶梯走线自动生成器是电子设计领域的得力助手，它们简化了复杂的设计任务，降低了错误率，提升了设计质量和生产效率。随着技术的不断发展，这些工具也在不断更新和完善，以满足日益...
开源项目-anacrolix-godo.zip
09-04
5. **调试友好**：为了方便开发者进行调试，godo可能提供附加的选项，如生成调试信息（-gcflags='-N -l'），以便于使用像GDB这样的调试器。 6. **性能监测**：godo可能集成性能分析工具，例如，允许用户在运行时...
python：zip迭代器
OceanStar的博客
10-12 311
【代码】python：zip迭代器。
python：迭代器工具函数，zip() enumerate()
我放低了酒杯
08-21 690
zip(iter1 [, iter2[…]]) 返回一个zip对象，此对象用于生成元组，此元组的每个数据来源于参数中的可迭代对象，当最小的可迭代对象不再提供数据时迭代结束 enumerate(iterable [, start]) 生成带索引的枚举对象， 返回的迭代类型为索引-值对（index-value），默认索引从零开始，也可用start指定 zip示例 number...
zip() 函数, set() 函数, 迭代器， 生成器
Turbo_Come的博客
10-23 828
Python3 基础： zip()函数 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。可以使用 list() 转换来输出列表。 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表。 a = [1,2,3] b = [4,5,6] c = [4,5,6,7...
zip()返回值作为一个迭代器，可以使用list，方便查看
qq_35091353的博客
04-24 742
| 为什么 循环zip返回的对象 第一次有值，第二次就没有值了呢？ 查看zip 文档 zip（） 返回一个zip对象，该对象的next（）方法返回一个元组，其中第i个元素来自第i个可迭代的参数。直到参数序列中最短的迭代被耗尽，然后抛出异常停止迭代，否则 next() 方法将持续返回元组。 重点就是这个‘ “zip对象” 是一个迭代器。 迭代器只能前进，不能后退。 比如说测试一的代码，在f...
Python3 zip()函数与迭代器
Ssrc_mad_donkey的博客
02-13 274
初学Python，看到zip()函数的用法介绍，想着简单试验一下，结果却发现和预想的结果大相径庭。 a = [1, 2, 3] b = [222, 333, 444] c = [33333, 44444, 55555] zipped = zip(a, b, c) print(list(zipped)) print("---") #由于list()函数的实现 需要用尽迭代器 #而zip也是同理，因此一旦list()使用了zipped的迭代器，再交给zip()函数就得不到任何元素。 unzipped = zip
电信设备-具有循环冗余信息码签章比较的涡轮译码器.zip
09-18
CRC码是基于多项式除法的，可以生成一个固定长度的校验码附加到数据后面。当接收到数据后，接收端同样使用这个多项式进行除法运算，如果计算出的余数为零，则认为数据传输正确；否则，表明数据可能在传输中发生了...
leaflet-webpack 入门开发系列七属性查询.zip
最新发布
06-19
结合Webpack的开发服务器和热模块替换（HMR）功能，我们可以快速迭代和调试地图应用。同时，使用断点、日志和测试框架（如Jest或Mocha）来确保代码质量。 综上所述，"leaflet-webpack 入门开发系列七属性查询"涵盖...
参考资料-crc算法及其单片机实现.zip
01-21
3. 在每次迭代中，根据当前数据位和CRC寄存器的值进行异或操作。 4. 如果有输入反射，则先对数据位进行反射。 5. 如果有输出反射，则在计算结束后对CRC寄存器进行反射。 6. 结束后，CRC寄存器的值就是CRC校验码。 ...
pythonzip是迭代器_Python迭代器和zip
weixin_39609170的博客
01-14 174
迭代器就像一个项目流.您只能一次查看流中的项目,并且只能访问第一个元素.要查看流中的某些内容,您需要将其从流中删除,一旦您从流的顶部获取内容,它就会从流中消失.当您调用zip(i,i)时,zip首先查看第一个流并取出一个项目.然后它查看第二个流(恰好是与第一个流相同的流)并取出一个项目.然后它从这两个项目中生成一个元组并反复重复这个元素,直到流中没有任何内容.也许更容易看出我是否在纯python中...
pythonzip是迭代器_Python用zip函数同时遍历多个迭代器示例详解
weixin_42425967的博客
01-14 195
前言本文主要介绍的是Python如何使用zip函数同时遍历多个迭代器，文中的版本为Python3，zip函数是Python内置的函数。下面话不多说，来看详细的内容。应用举例>>> list1 = ['a', 'b', 'c', 'd']>>> list2 = ['apple', 'boy', 'cat', 'dog']>>> for x, y ...
python zip函数的高级用法，消耗迭代器/生成器
sha_ka的博客
03-24 430
In [1]: a = (i for i in range(10)) In [2]: a Out[2]: <generator object <genexpr> at 0x0000027493A53190> In [5]: In [4]: for i in zip(*[a]*2): ...: print(i) ...: (0, 1) (2, 3)...
python基础梳理(十九)迭代器、生成器以及迭代工具函数(zip、enumerate)
KingOfMyHeart的博客
04-05 843
一、迭代器 Iterator 和 生成器 Generator 1.什么是迭代器： 迭代器是访问可迭代对象的一种方式，用迭代器可以访问可迭代 迭代器是指iter（可迭代对象）返回的对象 迭代器可以用next(it)函数获取可迭代对象中的数据 2.迭代器相关的函数 1）iter（iterable） 从可迭代对象中返回一个迭代器，iterable必须是能提供一个迭代器的对象 2）next（ite...
python: for in zip() 并行遍历
热门推荐
颠沛的小丸子
05-14 3万+
list_1 = [1, 2, 3, 4] list_2 = ['a', 'b', 'c'] for x, y in zip(list_1, list_2): print(x, y)
Python：for...in range() 、 for...in enumerate() 、for...in() 、for...in zip()的用法
weixin_40522801的博客
05-17 1万+
0.0
python: for i in zip()实现python中的并行遍历
fengbao24的博客
06-25 4095
for i in zip():实现python中的并行遍历。
Robot Framework 教程 (7) - 使用For循环
weixin_30477293的博客
08-31 1524
在自动化测试过程中，使用For循环来对某个动作进行重复操作是很普遍的行为。在Robot Framework中，各种测试库中均提供了多种方式的For循环结构，在其中覆盖了大部分类型的循环类型。而Robot Framework自身也包含了多种的For循环语法结构，可用于独立编写带循环结构的测试脚本。 For循环可以在TestCase中进行使用，也可以在KeyWrod中进行使用。除了特别简单...
Python：zip函数
jinzhao1993的博客
06-30 882
1. 代码引导先看一段代码：>>> name=('jack','beginman','sony','pcky') >>> age=(2001,2003,2005,2000) >>> for a,n in zip(name,age): print a,n输出： jack 2001 beginman 2003 sony 2005 pcky 2000再看：all={"jack":2001,"beg
react 迭代器和生成器
03-31
React 中的迭代器和生成器与 JavaScript 中的迭代器和生成器类似，用于处理集合或序列的迭代。以下是一些关于 React 迭代器和生成器的基本知识： 1. 迭代器是一种对象，它定义了一种方法来遍历集合中的元素。React 中的迭代器通常是通过使用 for...of 循环来使用的。 2. 生成器是一种函数，它使用 yield 关键字来暂停和恢复函数执行，并生成一个可迭代的序列。React 中的生成器通常用于实现异步操作，如请求数据并等待响应。 3. 在 React 中，可以使用迭代器和生成器来遍历数组、对象、Map 和 Set 等集合类型。 4. React 迭代器和生成器的主要优点是它们提供了一种简单、可读性高的方式来处理集合中的元素。它们还可以帮助减少代码的复杂性和提高代码的可维护性。 总之，React 中的迭代器和生成器是一种非常有用的工具，可以帮助开发人员更轻松地处理集合和序列，并提供更简单、可读性高的代码实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值