python-常用內建函式和迭代器(四)

阿新 • • 發佈：2021-11-19

1. 常用內建函式
2. 可迭代物件
3. 迭代器物件
4. for迴圈本質
5. 異常捕獲

1. 常用內建函式

1.1 map()

# map()  # 對映
l = [11, 22, 33, 44]
res = map(lambda x: x + 1, l)  # 迴圈獲取列表中的每個元素並交給匿名函式儲存返回值
print(list(res))  # [12, 23, 34, 45]

1.2 zip()

# zip() 拉鍊  按最少元素
l1 = [1, 2, 3, 4, 5]
l2 = ['jason', 'tony', 'xxx', 'tom', 'bob']
res = zip(l1, l2)
print(list(res))
# [(1, 'jason'), (2, 'tony'), (3, 'xxx'), (4, 'tom'), (5, 'bob')]

1.3 max()和min()

# max()求最大值 min()求最小值
l3 = [115, 292, 303, 414, 526, 809, 910, 101]
print(max(l3))  # 910
print(min(l3))  # 101

# 如果只接字典時會將K值進行比較
d1 = {"alex": 1000000,
      "tony": 20000,
      "jason": 3000000,
      "tom": 8900000000,
      }

print(max(d1, key=lambda key: d1[key]))  # tom  迴圈取值再比較大小，返回K
print(min(d1, key=lambda key: d1[key]))  # tony

1.4 filter()

# filter() 過濾
l3 = [115, 292, 303, 414, 526, 809, 910, 101]
res = filter(lambda x: x > 400, l3)
print(list(res))  # [414, 526, 809, 910]

1.5 reduce()

# reduce() 歸總
from functools import reduce

l3 = [115, 292, 303, 414, 526, 809, 910, 101]
res1 = reduce(lambda x, y: x + y, l3)
res2 = reduce(lambda x, y: x + y, l3, 100)  # 還可以繼續新增額外的元素
print(res1) # 3470
print(res2) # 3570

2. 可迭代物件

迭代:迭代即更新換代,每次的更新都必須依賴上一次的結果
迭代提供了一種不依賴索引取值的方
可迭代物件:內建 __intr__方法的都稱之為可迭代物件，內建可通過.的方式檢視
雙下滑線開頭雙下滑線結尾的方法叫雙下方法名，面向物件的時候為了與隱藏變數名區分開

# 通過變數名.__檢視是否有intr
i = 12  # 沒有
f = 11.11  # 沒有
s = 'jason'  # 有
l = [111,22,33,4]  # 有
d = {'username':'jason','pwd':123}  # 有
t = (11,22,33)  # 有
se = {11,22,33}  # 有
b = True  # 沒有
file = open(r'a.txt','w',encoding='utf8')

"""
含有__iter__的有
    字串 列表 字典 元組 集合 檔案物件
上述通常為可迭代物件
"""

# 兩種結果一樣
print(d.__iter__()) # <dict_keyiterator object at 0x7fdf258b4a98>
print(iter(d))

"""
可迭代物件呼叫__iter__方法會變成迭代器物件(老母豬)

__iter__方法在呼叫的時候還有一個簡便的寫法iter()
    一般情況下所有的雙下方法都會有一個與之對應的簡化版本 方法名()
"""

3. 迭代器物件

迭代器物件:即含有__inter__方法，又含有__next__方法
可以讓可迭代物件執行__iter__方法後就可以生成迭代器物件
迭代器物件無論執行多少次__iter__方法還是迭代器物件(本身)
迭代器提供了不依賴於索引取值的方式

# 通過變數名.__檢視是否有next方法
i = 12
f = 11.11
s = 'jason'
l = [111,22,33,4]
d = {'username':'jason','pwd':123}  
t = (11,22,33)  
se = {11,22,33}  
b = True  
file = open(r'a.txt','w',encoding='utf8')


res = s.__iter__()  # 轉成迭代器物件
print(res.__next__())  # 迭代器物件執行__next__方法其實就是在迭代取值(for迴圈) j
print(res.__next__())  # 在取完元素之後會報錯

# 下面結果是一樣的，每次生成新的迭代器物件再執行__next__方法
print(s.__iter__().__next__())  # j
print(s.__iter__().__next__())  # j

4. for迴圈本質

# 迴圈列印每個元素,不使用for迴圈
# __iter__和__next__
l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55]

# 將列表轉為迭代器物件
res = l1.__iter__()
while True:
    print(res.__next__())  # 迴圈執行__next__取值，當取完元素之後會報錯
    
    
for i in l1:
    print(i)
    
'''
for 迴圈內部原理
  1.將關鍵字in後面的資料先呼叫__iter__方法轉為迭代器物件
  2.迴圈執行__next__方法
  3.在取完值後__next__會報錯,但是for迴圈會自動捕獲該錯誤並處理
'''

5. 異常捕獲

# 什麼是異常
	程式碼執行出錯會導致異常 異常發生後如果沒有解決方案則會到底整個程式結束
 
# 異常三個重要組成部分
	1.traceback:提示錯誤的行
  2.XXXError:錯誤的型別
  3.錯誤型別冒號後面的內容:錯誤的詳細原因(仔細看可能就會找到解決的方法)

# 錯誤的種類   
    1.語法錯誤:不被允許的,出現了應該立刻修改!!!
    2.邏輯錯誤:可以被允許的,出現了之後儘快修改即可
   		'''修改邏輯錯誤的過程其實就是在從頭到尾理清思路的過程'''
     
# 基本語法結構
    try:
        有可能會出錯的程式碼
    except 錯誤型別 as e:
        出錯之後對應的處理機制(e是錯誤的詳細資訊)
    except 錯誤型別 as e:
        出錯之後對應的處理機制(e是錯誤的詳細資訊)
    except 錯誤型別 as e:
        出錯之後對應的處理機制(e是錯誤的詳細資訊)

  eg:
  try:
      int('abc')
  except NameError as e:
      print('變數名name不存在',e)
  except ValueError:
      print('值不是純數字')
      
# 捕獲萬能異常
  try:
      # int('abc')
      print(name)
      # l = [11]
      # l[100]
  except Exception:
      print('你來啥都行 無所謂')

"""
異常捕獲句式和萬能異常
    1.有可能會出現錯誤的程式碼才需要被監測
    2.被監測的程式碼一定要越少越好
    3.異常捕獲使用頻率越低越好
"""

# while 使用__next__方法丟擲異常
l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55]
res = l1.__iter__()

try:
    while True:
        print(res.__next__())

except Exception:
    pass