一、可迭代对象（Iterable）
可迭代对象是指可以被for循环遍历的对象，或者具有__iter__()方法的对象。可迭代对象允许你获取其迭代器。常见的可迭代对象包括列表（list）、元组（tuple）、字典（dict）和集合（set）。
from collections.abc import Iterable, Iterator, Generator
i = 100
s = "hello"
l = [1, 2, 3]
t = (1, 2, 3)
d = {"name": "qiku"}
set0 = {1, 2, 3}
print(isinstance(i, Iterable),
isinstance(s, Iterable),
isinstance(l, Iterable),
isinstance(t, Iterable),
isinstance(d, Iterable),
isinstance(set0, Iterable))
# False True True True True True
二、迭代器（Iterator）
迭代器是一个具有__iter__()和__next__()方法的对象。通过__iter__()方法，迭代器返回其自身的引用。__next__()方法用于获取迭代器的下一个元素。当没有更多元素时，__next__()方法将引发StopIteration异常。
自定义迭代器类 ： MyDatas类实现了__iter__和__next__方法，使其成为一个迭代器。
from collections.abc import Iterable, Iterator,
class MyDatas:
def __init__(self, n):
self.datas = [i for i in range(1, n + 1)]
self.current_index = 0
def __iter__(self):
return self
def __next__(self):
if self.current_index >= len(self.datas):
raise IndexError
else:
current = self.datas[self.current_index]
self.current_index += 1
return current
md = MyDatas(5)
print(isinstance(md, Iterable), isinstance(md, Iterator))
#True True
三、生成器（Generator）
生成器是一种特殊的迭代器，它使用yield语句来产生一系列值。生成器在函数中使用yield表达式时创建，每次调用next()时执行到yield表达式，返回一个值，并在下一次调用时从该点继续执行。
生成器的优点：
- 可迭代大型数据集：即使数据集太大不适合一次性加载到内存中
Python中列表和生成器表达式的内存大小
__sizeof__() 方法返回一个对象所占用的内存量，以字节为单位。
列表的内存占用不仅包括存储列表对象本身的内存，还包括存储列表中每个元素的内存。
生成器对象通常占用较少的内存，因为它们是按需生成值的。
l0 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
print(l0.__sizeof__()) # 200
print(l0[15]) # 16
#
t0 = (i for i in range(1, 1000000000))
print(t0.__sizeof__()) # 184
print(isinstance(t0, Iterable), isinstance(t0, Iterator), isinstance(t0, Generator))
#True True True
print(next(t0), next(t0)) #1 2
my_datas函数是一个生成器，使用yield语句产生值。
from collections.abc import Iterable, Iterator, Generator
def my_datas():
yield 1
yield 2
yield 3
yield 10
yield 20
yield 30
return 100
r = my_datas()
print(type(r))#<class 'generator'>
while True:
try:
print(next(r))
except StopIteration as e:
print("取完了", e) # 1 2 3 10 20 30 取完了 100
break
四、装饰器（Decorator）
装饰器是一种设计模式，用于修改或增强函数、方法或类的行为，而不需要改变其本身的代码
使用@cost_time语法将cost_time装饰器应用于my_sort1和my_sort2函数，以测量它们执行所需的时间。
def cost_time(f):
def calc():
start = time.time()
f()
print(f"函数{f.__name__}开销:{time.time() - start}")
return calc
cost_time(lambda: print("醒醒啦"))()
datas = [random.randint(0, 10000) for i in range(10000)]
datas2 = datas.copy()
@cost_time
def my_sort1():
datas.sort(reverse=True)
# print(datas)
@cost_time
def my_sort2():
datas3 = sorted(datas2, reverse=True)
# print(datas3)
# my_sort1 = cost_time(my_sort1)
my_sort1()
# my_sort2 = cost_time(my_sort2)
my_sort2()
