【一】迭代器

【1】介紹

迭代器即用來迭代取值的工具，而迭代是重復反饋的過程的活動

其目的通常是為了逼近所需的目標或結果，每一次對過程的重復稱為一次”迭代“

而每一次迭代得到的結果會作為下一次迭代的初始值，單純的重復并不是迭代

while True:
    msg = input('>>: ').strip()
    print(msg)

# 獲取到返回值
num_list = [0, 1, 2, 3, 4, 5]
count = 0
while count < len(num_list):
    # 每一次使用的索引位置就是上一次 +1 后的索引位置
    print(num_list[count])
    count += 1

【二】可迭代對象

【1】什么是可迭代對象

從語法上講，內置有 __ iter __ 方法的對象都是可迭代對象

【2】八大基本數據類型

# 【1】數字類型
# 【1.1】整數類型 --- 不是
num = 1
print(num.__iter__)
'''
Traceback (most recent call last):
  File "E:PythonProjects迭代器.py", line 10, in 
    print(num.__iter__)
AttributeError: 'int' object has no attribute '__iter__'. Did you mean: '__str__'?
'''

# 【1.2】浮點類型 --- 不是
num_float = 1.0
print(num_float.__iter__())
'''
Traceback (most recent call last):
  File "E:PythonProjects迭代器.py", line 20, in 
    print(num_float.__iter__)
AttributeError: 'float' object has no attribute '__iter__'. Did you mean: '__str__'?
'''

# 【2】字符串類型
name = 'chosen'
print(name.__iter__)
# 
print(name.__iter__())
# 

# 【3】布爾類型
is_right = False
print(is_right.__iter__)
'''
Traceback (most recent call last):
  File "E:PythonProjects迭代器.py", line 37, in 
    print(is_right.__iter__)
AttributeError: 'bool' object has no attribute '__iter__'. Did you mean: '__str__'?
'''

# 【4】列表類型
name_list = [1, 2, 3]
print(name_list.__iter__)
# 
print(name_list.__iter__())
# 

# 【5】字典類型
info_dict = {"name": "chosen"}
print(info_dict.__iter__)
# 
print(info_dict.__iter__())
# 

# 【6】元祖類型
num_tuple = (1,)
print(num_tuple.__iter__)
# 
print(num_tuple.__iter__())
# 

# 【7】集合類型
num_set = {1}
print(num_set.__iter__)
# 
print(num_set.__iter__())
# 

【3】總結

非可迭代對象

整數類型

浮點類型

布爾類型

可迭代類型

字符串類型

列表類型

字典類型

元組類型

集合類型

【三】迭代器對象

【1】什么是迭代器對象

調用obj.__iter__()方法返回的結果就是一個迭代器對象(Iterator)。

迭代器對象是內置有 iter 和 next 方法的對象，打開的文件本身就是一個迭代器對象

執行迭代器對象.iter()方法得到的仍然是迭代器本身

而執行迭代器.next()方法就會計算出迭代器中的下一個值。

迭代器是Python提供的一種統一的、不依賴于索引的迭代取值方式，只要存在多個“值”，無論序列類型還是非序列類型都可以按照迭代器的方式取值

【2】八大基本數據類型

# 【1】字符串類型
name_str = 'chosen'
name_iter = name_str.__iter__()
name_iter_two = iter(name_str)
print(name_iter)
print(name_iter_two)
# 
# 
print(name_iter.__next__())
# c
print(next(name_iter))
# h

# 【2】列表類型
name_list = [1, 2, 3]
name_list_iter = iter(name_list)
print(name_list_iter)
# 
print(name_list_iter.__next__())
# 1
print(next(name_list_iter))
# 2

# 【3】字典類型
info_dict = {"name": "chosen", "age": 18}
info_dict_iter = iter(info_dict)
print(info_dict_iter)
# 
print(info_dict_iter.__next__())
# name
print(next(info_dict_iter))
# age

# 【4】元祖類型
num_tuple = (1, 2)
num_tuple_iter = iter(num_tuple)
print(num_tuple_iter)
# 
print(num_tuple_iter.__next__())
# 1
print(next(num_tuple_iter))
# 2

# 【5】集合類型
num_set = {1, 2, 3}
num_set_iter = iter(num_set)
print(num_set_iter)
# 
print(num_set_iter.__next__())
# 1
print(next(num_set_iter))
# 2

【3】總結

# 具有 __iter__() 和 __next__() 的對象就是迭代器對象
# 在八大基本數據類型中
# 除了 整數、浮點數、布爾
# 其他的都是迭代器對象

# 迭代器對象一定是可迭代對象

# 可迭代對象是 具有 __iter__() 的對象 ---> 生成一個可迭代對象
# 迭代器對象是 具有 __iter__()  和 __next__() 的對象 --> 調用上面可迭代對象的 next 方法

【四】迭代器的優缺點

【1】優點

為序列和非序列類型提供了一種統一的迭代取值方式

不使用索引進行取值

取到值的時候會保存到當前的狀態，下一次從這個位置開始向下取值

【2】缺點

除非取盡，否則無法獲取迭代器的長度

只能取下一個值，不能回到開始，更像是’一次性‘的，迭代器產生后的唯一目標就是重復執行next方法直到值取盡，否則就會停留在某個位置，等待下一次調用next；

若是要再次迭代同個對象，你只能重新調用iter方法去創建一個新的迭代器對象，如果有兩個或者多個循環使用同一個迭代器，必然只會有一個循環能取到值。

【五】什么是生成器

通過生成器，可以逐個生成序列中的元素，而無需一次性生成整個序列

生成器在處理大數據集時，具有節省內存、提高效率的特點。

# 假設一個數據庫里 表里面存了1億條數據
# 讀數據時---> 使用 read() 內存會直接爆滿導致電腦卡死
# 使用生成器--->一次取100行進行處理 ---->再取100行進行處理，以此類推

【六】生成器的創建方式

【1】列表推導式

使用列表推導式時，可以將列表推導式的方括號改為圓括號，即可創建一個生成器。

# 列表生成式生成列表
start_list = [x * 2 for x in range(5)]

print(start_list)
# [0, 2, 4, 6, 8]

# 將列表改成元祖，看起來像元祖推導式，其實是一個生成器對象
G = (x * 2 for x in range(5))

print(G)
#  at 0x000001873491CC80>

# 生成器對象可以強轉成列表
print(list(G))
# [0, 2, 4, 6, 8]

【2】yield關鍵字

使用yield關鍵字定義一個生成器函數時，生成器函數中的yield語句會暫停函數執行并返回一個值，下一次調用該函數時會繼續執行并返回下一個值。

def my_generator():
    yield 1
    yield 2
    yield 3

g = my_generator()
print(next(g))  # 輸出：1
print(next(g))  # 輸出：2
print(next(g))  # 輸出：3

【七】生成器案例

def eater():
    print('開始吃飯 ovo ')
    while True:
        food = yield
        print(f'得到的食物是 :>>>> {food}, 開始吃飯嘍 :>>>> {food}')

【1】調用函數

res = eater()
print(res)  # 
print(res.__next__())
# 打印開始吃飯
# None   原因就是在生成器內部的 yield 中沒有返回值
print(res.__next__())
# 打印 得到的食物是 :>>>> None, 開始吃飯嘍 :>>>> None
# None  原因就是在生成器內部的走完了上面的 又回到了 yield 中結果 yield 沒有返回值

【2】向生成器中傳值

res = eater()
print(res)  # 
print(res.__next__())
res.send("魚香肉絲") #得到的食物是 :>>>> 魚香肉絲, 開始吃飯嘍 :>>>> 魚香肉絲 # 想yield 傳值并且讓生成器向下走一下
print(res.__next__()) #得到的食物是 :>>>> None, 開始吃飯嘍 :>>>> None
print(res.send("宮保雞丁")) #得到的食物是 :>>>> 宮保雞丁, 開始吃飯嘍 :>>>> 宮保雞丁
#None

【八】裝飾器 + 生成器

def init_iter(func):
    # func 我的生成器函數
    def inner(*args, **kwargs):
        # g 得到的生成器對象
        g = func(*args, **kwargs)
        # 調用自己生成器向下走
        next(g)
        # 走回來的返回值返回出去
        return g

    return inner

@init_iter
def eater():
    print('開始吃飯 ovo ')
    while True:
        food = yield
        print(f'得到的食物是 :>>>> {food}, 開始吃飯嘍 :>>>> {food}')

res = eater()
res.send("魚香肉絲")
res.send("宮保雞丁")

【九】生成器內部修改可變數據類型

def init_iter(func):
    # func 我的生成器函數
    def inner(*args, **kwargs):
        # g 得到的生成器對象
        g = func(*args, **kwargs)
        # 調用自己生成器向下走
        next(g)
        # 走回來的返回值返回出去
        return g

    return inner


@init_iter
def eater():
    print('開始吃飯 ovo ')
    food_list = []
    while True:
        food = yield
        food_list.append(food)
        print(f'得到的食物是 :>>>> {food}, 開始吃飯嘍 :>>>> {food}')
        print(f'當前后廚已經做好了 :>>>> {food_list}')


res = eater()
res.send("魚香肉絲")
res.send("宮保雞丁")
# 輸出結果:
開始吃飯 ovo 
得到的食物是 :>>>> 魚香肉絲, 開始吃飯嘍 :>>>> 魚香肉絲
當前后廚已經做好了 :>>>> ['魚香肉絲']
得到的食物是 :>>>> 宮保雞丁, 開始吃飯嘍 :>>>> 宮保雞丁
當前后廚已經做好了 :>>>> ['魚香肉絲', '宮保雞丁']

【十】yield + next搭配著使用

def my_range(start, stop, step):
    '''

    :param start: 0
    :param stop: 5
    :param step: 1
    
    '''
    print("start")
    while start < stop:
        yield start
        start += step
    print("end")


res = my_range(0, 5, 1)
print(res)  # 
print(res.__next__()) # 0
print(res.__next__()) # 1
print(res.__next__()) # 2 
print(res.__next__()) # 3
print(res.__next__()) # 4
# 這里會報錯 ---》 把我掏空了 --- 沒有可迭代的值可以被獲取了
print(res.__next__())  # StopIteration

def init_iter(func):
    def inner(*args, **kwargs):
        try:
            generator = func(*args, **kwargs)
            next(generator)
            return generator
        except StopIteration:
            pass

    return inner

def range_(start, stop, step):
    while start < stop:
        yield start
        start += step

# for 循環內部做了異常捕獲
for i in range_(0,5,1):
    print(i)

def my_range(start, stop, step):
    def range_(start, stop, step):
        while start < stop:
            yield start
            start += step

    res = range_(start, stop, step)
    while True:
        try:
            print(res.__next__())
        except StopIteration:
            break

res = my_range(start=1, stop=5, step=1)
res

#輸出結果
0
1
2
3
4
1
2
3
4

鏈接：https://www.cnblogs.com/chosen-yn/p/18143555