插件窝 干货文章 Python迭代器、生成器、协程使用方式

Python迭代器、生成器、协程使用方式

迭代 class self 使用 117    来源:    2024-10-17

什么是迭代

迭代是访问集合元素的一种方式。(迭代和遍历非常相似)

什么是迭代器(Iterator)

迭代器是一种对象,可以记住遍历的位置的对象。迭代器对象从集的第一个元素开始访问,直到所有的元素被访问完结束。

在迭代一个可迭代对象的时候,实际上就是先获取该对象提供的一个迭代器,然后通过这个迭代器来依次获取对象中的每一个数据。

可迭代对象

某种数据可以通过for....in....的循环语法从其中依次拿到数据进行使用的数据类型,这种数据类型被称为可迭代对象

检测某个对象是否是可迭代对象的方法isinstance(待检测对象,Iterable)

该方法检测待检测对象是不是Iterable迭代类的子类

如果是返回True,如果不是返回False

from collections.abc import Iterable
 
"""
isinstance(待检测对象,Iterable(迭代类,固定写法))
判断待检测对象是不是迭代类的一个子类
返回值:True可以迭代
    False不可以迭代
"""
string="fhsudfoh"
result=isinstance([1,2,3],Iterable)
print(result)

for循环的本质

for循环的本质是在对一个迭代器进行操作。

首先,for循环在遍历可迭代对象的时候会把可迭代对象通过函数iter()或__iter__方法返回一个迭代器,然后在对这个迭代器对象进行操作。

迭代器可以用next()或__next__方法得到返回值,当把所有的值取完时会抛出StopIteration错误,这个错误在for循环中python会自己处理,不会展示给开发者。

自定义一个列表

class MyList(object):
# 重写初始化方法,初始化一个数组用来存储数据
    def __init__(self):
        self.list = []
 
    def __iter__(self):
# iter方法返回一个myIterator迭代器对象
        self.myiterator = MyIterator(self.list)
        return self.myiterator
 
    def additer(self, values):
# additer方法用于添加数据
        self.list.append(values)
 
 
class MyIterator(object):
# 初始化一个下标和接收一个外部的数组变量
    def __init__(self, my_list):
        self.list = my_list
        self.index = 0
 
    def __iter__(self):
        pass
# 当对象被迭代器返回后会自动寻找next方法,进行迭代
    def __next__(self):
        if self.index < len(self.list):
            data = self.list[self.index]
            self.index += 1
            return data
        else:
            raise StopIteration
 
 
if __name__ == "__main__":
    mylist = MyList()
    mylist.additer("张三")
    mylist.additer("李四")
    mylist.additer("王五")
    for value in mylist:
        print(value)

实现一个斐波那契数列

class feibonaqi(object):
    def __init__(self, num):
        self.fei_list = []
        self.num = num
        self.a = 1
        self.b = 1
        self.fei_index = 0
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if self.fei_index < self.num:
            data = self.a
            self.a, self.b = self.b, self.a + self.b
            self.fei_index += 1
            return data
        else:
            raise StopIteration
 
 
if __name__ == '__main__':
    fei = feibonaqi(5)
    for i in fei:
        print(i)

什么是生成器(generator)

生成器是一个特殊的迭代器,使用了 yield 的函数被称为生成器(generator)。

yield 是一个关键字,用于定义生成器函数,生成器函数是一种特殊的函数,可以在迭代过程中逐步产生值,而不是一次性返回所有结果。当在生成器函数中使用 yield 语句时,函数的执行将会暂停,并将 yield 后面的表达式作为当前迭代的值返回。然后,每次调用生成器的 next() 方法或使用 for 循环进行迭代时,函数会从上次暂停的地方继续执行,直到再次遇到 yield 语句。可以逐步产生值,而不需要一次性计算并返回所有结果。

调用一个生成器函数,返回的是一个迭代器对象。

生成器对象可以使用send()方法进行传参。

生成器中也可以使用return,当语句执行到return语句之后,生成器会终止迭代,抛出停止迭代的异常。

创建生成器的两种方式

使用推导式创建

result_list = (x * 2 for x in range(10))
print(result_list)
# 使用生成器生成一个偶数数列[0,2,4,6,8,10,12,14,16,18]
# 这边使用next先取出第一个值,后面for循环遍历出来的结果是从0后面开始的
value = next(result_list)
print(value)
 
for i in result_list:
    print(i, end=" ")

使用函数创建

def mygenerator():
    num_list = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
    num_index = 0
    while True:
        if num_index < len(num_list):
            yield num_list[num_index]
        num_index += 1
 
 
if __name__ == '__main__':
    mg = mygenerator()
    value = next(mg)
    print(value)
 
    value = next(mg)
    print(value)
 
    value = next(mg)
    print(value)

使用generator实现斐波那契数列

def feibonaqi(num):
    a = 1
    b = 1
    count_index = 0
    while count_index < num:
        data = a
        a, b = b, a + b
        count_index += 1
        yield data
 
 
if __name__ == '__main__':
    fei = feibonaqi(5)
    # data=next(fei)
    # print(data)
    # data=next(fei)
    # print(data)
    # data=next(fei)
    # print(data)
    # data=next(fei)
    # print(data)
    # data=next(fei)
    # print(data)
    for value in fei:
        print(value)

什么是协程

协程(coroutine)又称为微线程,是一种用户态的轻量级线程。

使用yield可以实现协程,yield可以终止任务执行,并记录任务执行的进度。

协程可以实现一个线程执行多个任务

协程的基本实现

import time
 
 
def work1():
    while True:
        print("正在执行work1。。。。。。。。")
        yield
        time.sleep(0.5)
 
 
def work2():
    while True:
        print("正在执行work2.....。。。。。。。。")
        yield
 
 
if __name__ == '__main__':
    w1 = work1()
    w2 = work2()
    while True:
        next(w1)
        next(w2)

使用greenlet实现协程

"""greenlet是一个第三方库可以提供自行调度的微线程,只需要告诉switch如何运行即可
    1、导入模块
    2、创建greenlet对象
    3、使用switch实现线程的调度
"""
 
import time
from greenlet import  greenlet
 
def work1():
    while True:
        print("正在执行work1。。。。。。。。")
        time.sleep(0.5)
        g2.switch()
 
 
def work2():
    while True:
        print("正在执行work2...............")
        time.sleep(0.5)
        g1.switch()
 
 
if __name__ == '__main__':
    g1 = greenlet(work1)
    g2 = greenlet(work2)
    g1.switch()

使用gevent实现协程

import time
import gevent
from gevent import monkey
 
monkey.patch_all()
"""gevent也是一个第三方库,自动调度协程,自动识别程序中的耗时操作
    使用步骤:
    1、导入模块
    2、指派任务
    g1=gevent.spawn(work1)
    g2=gevent.spawn(work2)
    3、join()让主线程等待协程进行结束后在退出
    注意:gevent默认不识别time.slepp(),识别的是gevent.sleep()
    可以使用打补丁的方式解决,猴子模块
    from gevent import monkey
    破解所有monkey.patch_all()
"""
 
 
def work1():
    while True:
        print("正在执行work1。。。。。。。。")
        time.sleep(0.5)
        # gevent.sleep(0.5)
 
 
def work2():
    while True:
        print("正在执行work2...........")
        time.sleep(0.5)
        # gevent.sleep(0.5)
 
 
if __name__ == '__main__':
    g1 = gevent.spawn(work1)
    g2 = gevent.spawn(work2)
    g1.join()
    g2.join()

进程、线程、协程的区别

进程是资源分配的基本单位、线程是CPU调度的基本单位、协程是单线程中执行多任务的方式

  • 切换效率:协程>线程>进程
  • 高效率方式:进程+协程

选择问题

  • 多进程:密集CPU任务,需要充分使用多核CPU资源(服务器,大量的并行计算)的时候,用多进程
  • 缺陷:多个进程间通信成本高,切换开销大
  • 多线程:密集I/O任务(网络I/O、磁盘I/O、数据库I/O)使用多线程合适
  • 缺陷:同一个时间切片只能运行一个线程,不能做到高并行,但是可以做到高并发
  • 协程:当程序中存在大量不需要CPU的操作时(I/O),适用协程
  • 缺陷:单线程执行,处理密集CPU和本地磁盘IO的时候,性能较低。处理网络I/O性能还是比较高的

使用协程下载网络的图片

"""
使用协程的方式将网路上的图片下载到本地
核心方法:urllib.request.urlopen()打开网址并返回对应的内容(二进制流)
"""
import urllib.request
import gevent
from gevent import monkey
 
monkey.patch_all()
 
 
def down_image(url_image, file_name):
    # 异常处理
    try:
        # 打开网络文件
        request_data = urllib.request.urlopen(url_image)
        # 打开本地文件
        with open(file_name, "wb") as file:
            # 循环读取写入文件
            while True:
                # 从网络中读取1024个字节的数据
                file_data = request_data.read(1024)
                # 判断数据是否为空,不为空就写入,为空就跳出循环
                if file_data:
                    file.write(file_data)
                else:
                    break
    except Exception:
        print("文件%s下载失败" % file_name)
    else:
        print("文件%s下载完成" % file_name)
 
 
def main():
    img_url1 = "https://img1.baidu.com/it/u=1849885514,1853800516&fm=253&fmt=auto&app=138&f=JPG?w=500&h=500"
    img_url2 = "https://img2.baidu.com/it/u=4137380440,3737943568&fm=253&fmt=auto&app=120&f=JPEG?w=1280&h=800"
    img_url3 = ("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fsafe-img.xhscdn.com%2Fbw1%2F4e3acf5c-a0fc-44a2"
                "-99ff-94f69cae80b4%3FimageView2%2F2%2Fw%2F1080%2Fformat%2Fjpg&refer=http%3A%2F%2Fsafe-img.xhscdn.com"
                "&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1709038944&t=f8e32fd271bb9215553250f0deb5e23d")
    # joinall()将传入的线程,等待运行完成在结束进程
    gevent.joinall([
        gevent.spawn(down_image, img_url1, "img1"),
        gevent.spawn(down_image, img_url2, "img2"),
        gevent.spawn(down_image, img_url3, "img3")
    ])
 
 
if __name__ == '__main__':
    main()

总结

以上为个人经验,希望对您有所帮助。