迭代是访问集合元素的一种方式。（迭代和遍历非常相似）
迭代器是一种对象，可以记住遍历的位置的对象。迭代器对象从集的第一个元素开始访问，直到所有的元素被访问完结束。
在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据。
某种数据可以通过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循环在遍历可迭代对象的时候会把可迭代对象通过函数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)生成器是一个特殊的迭代器，使用了 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)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是一个第三方库可以提供自行调度的微线程，只需要告诉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()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调度的基本单位、协程是单线程中执行多任务的方式
"""
使用协程的方式将网路上的图片下载到本地
核心方法：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()以上为个人经验，希望对您有所帮助。