生成器

目錄

• 異常處理：
• 迭代器
  • --python中一切皆對象
  • 迭代器對象： 含有__iter__方法的對象
  • --總結：
  • 可迭代對象：
  • 迭代器對象：
  • 特色：
  • 缺點：
  • FOR循環原理：
  • 迭代器：
  • 三元表達式：
  • 列表推導式（算法）：
  • 字典生成式：
  • ZIP方法：(兩個列表)--》經過解壓縮函數生成一個字典
• 生成器 ：
  • --含有關鍵字yield的函數
  • yield：
  • yield / return 的區別：
  • 生成器表達式：
  • 生成器表達式和列表推導式的區別：
• 遞歸
  • 函數的嵌套調用：函數嵌套函數，
  • 遞歸兩個階段：

異常處理：

def forl(iterable):
    iterator  = iterable.__iter__()
    while True:
        try:
            print(iterator.__next__())
        except Exception as e:
            print(e)
            break
forl([1,2,3,4,5,6,7,8,9])

迭代器

迭代器：迭代的工具。迭代是更新換代，迭代也能夠說成是重複，而且但每一次的重複都是基於上一次的結果來的

--python中一切皆對象

迭代器對象： 含有__iter__方法的對象

--總結：

可迭代對象：

1. python中內置str、list、tuple、dict、set、file（除了數字類型）

2. 內置含有__iter__方法的對象

--只有字符串和列表以來索引取值。其餘可迭代類型沒法依賴索引取值。

迭代器對象：

可迭代對象執行__iter__方法獲得的返回值，而且可迭代對象會有一個__next___方法

特色：

1.內置__next__方法，執行該方法會拿到迭代器對象中一個值

2.內置有__iter__方法，執行該方法會拿到迭代器自己

3。文件自己就是一個迭代器對象

缺點：

1.取值麻煩，只能一個一個取，而且只能日後取，值取了就沒有

2.沒法使用len()方法獲取長度

FOR循環原理：

--for 循環-》迭代器循環，in後面必須是可迭代的對象

由於迭代器使用__iter__後仍是迭代器自己，所以for循環不用考慮in後面的對象是可迭代對象仍是迭代器對象

迭代器：

可迭代對象使用__iter__方法後變成一個可迭代器對象，這個迭代器對象只是佔用了一小塊內存空間，只有使用__next__後纔會取出一個值。

三元表達式：

x = 20
y = 10

print(f"x if  x > y else y: {x if x >y else: y}")

列表推導式（算法）：

it = [i for i in range(10)]
it = [i**2 for i in range(10)]
#  i**2 -->改變  ，range(n) --可迭代對象
print(it)

字典生成式：

dic = {}
dic = {i:i*2 for i in range(10)}
print(dic)

ZIP方法：(兩個列表)--》經過解壓縮函數生成一個字典

it1 = ['a','b','c']
it2 = ['1','2','3']
dic = {k: v for k,v in zip(it1,it2)}
print(dic)
for -- 循環內有常處理

生成器 ：

--含有關鍵字yield的函數

yield的英語單詞的意思是生產，在函數中凡是出現yield關鍵字，在調用函數時，就不會繼續執行函數的代碼，而是會返回一個值

-生成器的本質就是迭代器，同時不單單是迭代器。

yield：

1.提供一種自定義迭代器的方式

2.能夠暫停住函數，並提供當前的返回值

yield / return 的區別：

相同點：二者都是在函數內部使用，均可以返回值，而且返回值沒有類型合格書的限制。

不一樣點：return只能返回一次值，yield能夠返回屢次值

生成器表達式：

1.把列表推導式的[] 換成() 就是生成器表達式

2.有點：節省內存，一次只有一個值在內存中

t = (i for i in range(10))
print(t)
print(f"next(t): {next(t)}」)

生成器表達式和列表推導式的區別：

列表推導式至關於直接給你一筐蛋，而生成器表達式至關於給你一隻老母雞

遞歸

函數的嵌套調用：函數嵌套函數，

函數的遞歸調用：是一種特殊的嵌套調用，可是它在調用一個函數的過程當中，又直接或間接地調用了它自身。

死遞歸：遞歸函數不斷地調用函數自身，那麼這個遞歸函數將會進入一個死循環---》定義函數就會開闢內存空間

直接調用指的是：直接在函數內部調用函數自身

修改調用層數：

import sys
sys.setrecursionlimit(10000)
def foo(n):
    print('from foo',n)
    foo(n+1)
foo(0)

間接調用指的是：不在原函數體內調用函數自身，而是經過其餘的方法間接調用函數自身。

遞歸兩個階段：

1.遞推：一層一層遞歸調用下去，進入下一層遞歸的問題規模都將會縮小

2.回溯： 遞歸必需要有一個明確的結束條件，在知足該條件開始一層一層回溯

遞歸的精髓在於經過不斷的重複逼近一個最終的結果

遞歸的本質：乾重復的·活

原則： 1.有控制結束的條件

2.遞歸必需要有規律

二分法應用：

nums = [1,3,7,11,22,34,55,78,111,115]
for item in nums:
    if item == 10:
        print('find it')
        break
else:
    print('not exists')
列表元素多：--二分查找
def search(search_num, nums):
    mid_index = len(nums)//2
    print(nums)
    if not nums:
        print('not exists')
        return
    if search_num > nums[mid_index]:
        # in the right 
        nums = nums[mid_index+1:] #切片
        search(search_num, nums)
    elif search_num < nums[mid_index]:
        # in the left
        nums = nums[:mid_index]
        search(search_num, nums)
    else:
        print('find it')


search(7, nums)