迭代器 生成器 內置函數

1.迭代器

　　迭代取值的工具

s = 'hello'
n = 0
while n < len(s):
    print(s[n])  # h  e  l  l  o  
    n += 1
# 每一次迭代都是基於上一次的結果而來的

　　可以迭代取值的數據類型：字符串、列表、元組、集合、字典

　　可迭代對象：只有內置有__iter__方法的都叫可迭代對象,可迭代對象執行內置的__iter__方法獲得的就是該對象的迭代器對象

　　可迭代對象有 str list tuple dict set，文本對象

　　迭代器對象：內置__iter__方法，內置__next__方法,文件對象自己就是迭代器對象

　　ps：迭代器對象必定是可迭代對象，可迭代對象不必定是迭代器對象。

l = [1,2,3,4,5,6]
iter_1 = l.__iter__()  # 生成一個迭代器對象
print(iter_1.__next__())  # 1  若是取完了，會報錯

　　迭代器的對象的取值，必須用__next__

異常處理
l = [1,2,3,4,5,6]
iter_1 = l.__iter__()
while True:
    try:
        print(iter_1.__next__())
    except StopIteration:  # 用來接收沒有值可取時的報錯，
        break

 迭代器的特色：只能日後依次取值，不能後退。

　　__iter__()等價於iter()

for 循環內部本質：

　　1.將 in 後面的對象調用__iter__轉換成迭代器對象

　　2.調用__next__迭代處理

　　3.內部有異常捕獲StopIteration，當__next__報這個錯的時候自動結束循環。

迭代取值：

　　優勢：不依賴索引取值，內存中只佔一份空間，不會致使內存溢出。

　　缺點：不能獲取指定的元素，取完以後，會報StopIteration錯

2.生成器

　　用戶自定義的迭代器

def func():
    print('first')
    yield  9       #  函數內部有yield關鍵字，加括號執行函數的時候不會觸發函數體的運行
    print('second')
    yield 8
g = func()  # 生成器初始化，將函數編程迭代器print(g.__next__())  #yield後面跟的值是調用迭代器__next__方法可以獲得的值
print(g.__next__())  #yield能夠返回一個值，也能夠返回多個值，多個值以元組的形式返回

def my_range(start,end,step):
    while start < end:
        yield start
        start += step
for j in my_range(1,8,2):
    print(j)

def dog(name):
    print('%s'%name)  # egon
    while True:
        food = yield  # yield支持外界傳參
        print('%s吃%s'%(name,food))  # egon吃餃子
g = dog('egon')  # 函數體內有yield關鍵字，調用該函數不會執行函數體代碼，而是將其變成一個迭代器
g.__next__()
g.send('餃子')

　　yield 提供了一種自定義生成器的方法，會將函數的運行狀態暫停住，而後返回值

與return的異同點

　　相同點：均可以返回值，而且均可以返回多個

　　不一樣點：yield能夠返回多個值，而return只能返回一次函數當即結束，yield能夠接受外部傳入的值

res = [i for i in range(1,10) if i != 4]  # 生成器表達式
print(res）

　　生成器不執行任何一行代碼，必須經過__next__觸發代碼的運行

add(n,i):
    return n+i  # n = 10,i = 0  n = 10,i = 10
def test():
    for i in range(4):
        yield i
g=test()
for n in [1,10]:
    g=(add(n,i) for i in g)
    # 第一次for循環g=(add(n,i) for i in test())
    # 第二次for循環g=(add(n,i) for i in (add(n,i) for i in test()))
print(n)
res=list(g)  # res=[20,21,22,23

經常使用內置方法
print(abs(-11.11))  # 求絕對值

l = [0,1,0]
print(all(l))  # 只要有一個爲False就返回False
print(any(l))  # 只要有一個位True就返回True

def index():
    username = '我是局部名稱空間裏面的username'
    print(locals())  # 當前語句在哪一個位置 就會返回哪一個位置所存儲的全部的名字
    print(globals())  # 不管在哪 查看的都是全局名稱空間
index()

print(bin(10))  # 十轉二
print(oct(10))  # 十轉八
print(hex(10))   # 十轉十六
print(int('0b1010',2))  # 二轉十
print(int('0o1010',8))  # 八轉十
print(int('0x1010',16))  # 十六轉十

print(bool(1))  #True
print(bool(0))  # False

s = 'hello'
print(s.encode('utf-8'))  # b'hello'
print(bytes(s,encoding='utf-8'))  # b'hello'

def index():
    passprint(callable(index)) #True

print(chr(97))  # 將數字轉換成ascii碼錶對應的字符
print(ord('z'))  # 將字符按照ascii錶轉成對應的數字
A-Z-->65-90    a-z-->97-122

l = [1,2,3]
print(dir(l))  # dir獲取當前對象名稱空間裏面的名字

total_num,more = divmod(900,11)
if more:
 total_num += 1
print('總頁數:',total_num) # 總頁數: 82

l = ['a','b']
for i,j in enumerate(l,0):
 print(i,j) # 0 a <class 'int'> <class 'str'>

s = """
print('hello baby~')
"""
eval(s)  # hello baby~

s = """
print('hello baby~')
x = 1
y = 2
print(x + y)
"""
exec(s)  # hello baby~   3
# eval不支持邏輯代碼，只支持簡單的python代

# format 三種玩法
# {}佔位
# {index} 索引
# {name} 指名道姓

def login():
    """
    一塊兒嗨皮
    :return:
    """
# print(help(login))

# isinstance 後面統一改方法判斷對象是否屬於某個數據類型
n = 1
print(type(n))
print(isinstance(n,list))  # 判斷對象是否屬於某個數據類型

print(pow(2,4))  # 16 2**4
print(round(1.4))  # 1  比較大小 

面向過程編程　　好處：將複雜的問題流程化，從而簡單化　　壞處：可擴性差 ，一旦修改，總體都會受影響