Python之旅.第三章.函數3.30

標籤：tin   編程   dig   文字   5.2.1   代碼   可迭代對象   line   輸入密碼   

一、迭代器

1、什麼是迭代？：迭代是一個重複的過程，並且每次重複都是基於上一次的結果而來

2、要想瞭解迭代器到底是什嗎？必須先瞭解一個概念，即什麼是可迭代的對象？
可迭代的對象:在python中，但凡內建有__iter__方法的對象，都是可迭代的對象
num=1

以下都是可迭代的對象
str1=‘hello‘
list1=[1,2,3]
tup1=(1,2,3)
dic={‘x‘:1}
s1={‘a‘,‘b‘,‘c‘}
f=open(‘a.txt‘,‘w‘,encoding=‘utf-8‘)

3、迭代器：迭代取值工具，可迭代的對象執行__iter__方法得到的傳回值就是迭代器對象
dic={‘x‘:1,‘y‘:2,‘z‘:3}
iter_dic=dic.__iter__()
print(iter_dic.__next__())
print(iter_dic.__next__())

s1={‘a‘,‘b‘,‘c‘}
iter_s1=s1.__iter__()
print(iter_s1.__next__())
print(iter_s1.__next__())

list1=[1,2,3]
iter_list1=list1.__iter__()
print(iter_list1.__next__())

4、可迭代的對象vs迭代器對象？
‘‘‘
可迭代的對象：str，list，tuple，dict，set，file
1、擷取可迭代對象的方式：無須擷取，python內建str，list，tuple，dict，set，file都是可迭代對象
2、特點：
    內建有__iter__方法的都叫可迭代的對象，執行該方法會拿到一個迭代器對象

 迭代器對象：檔案對象本身就是迭代器對象
1、擷取迭代器對象的方式：
    執行可迭代對象的__iter__方法，拿到的傳回值就是迭代器對象
2、特點：
    內建有__next__方法，執行該方法會拿到迭代器對象中的一個值
    內建有__iter__方法，執行該方法會拿到迭代器本身

‘‘‘

x=‘hello‘

iter_x=x.__iter__()
iter_x.__next__
print(iter_x.__iter__().__iter__() is iter_x)


檔案本身就是迭代器對象
str1=‘hello‘
list1=[1,2,3]
tup1=(1,2,3)
dic={‘x‘:1}
s1={‘a‘,‘b‘,‘c‘}
f=open(‘a.txt‘,‘w‘,encoding=‘utf-8‘)
f.__next__()


5、迭代器的優缺點分析
5.1 迭代器的優點：
5.1.1、提供了一種可不依賴於索引的取值方式
l=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)
iter_l=l.__iter__()
while True:
    try:
        print(iter_l.__next__())
    except StopIteration:
        break

5.1.2 迭代器更加節省記憶體
item=range(0,100000000000000000000000000000000000000000000)
print(item)


5.2迭代器的缺點：
5.2.1、取值麻煩，只能一個一個取，只能往後取，
5.2.2、並且是一次性的,無法用len擷取長度

x=[1,2,3]
iter_x=x.__iter__()
while True:
    try:
        print(iter_x.__next__())
    except StopIteration:
        break
print(‘第二次=================================》‘)
iter_x=x.__iter__()
while True:
    try:
        print(iter_x.__next__())
    except StopIteration:
        break

6. for迴圈原理分析：
6.1、for 迴圈稱之為迭代器迴圈，in後跟的必須是可迭代的對象
6.2、for迴圈會執行in後對象的__iter__方法，拿到迭代器對象
6.3、然後調用迭代器對象的__next__方法，拿到一個傳回值賦值給line，執行一次迴圈體
6.4、周而復始，直到取值完畢，for迴圈會檢測到異常自動結束迴圈
l=open(‘a.txt‘,‘r‘,encoding=‘utf-8‘)
for line in l: #iter_l=l.__iter__()
    print(line)

for item in {‘x‘:1,‘y‘:2}:
    print(item)

二、產生器

產生器：
函數內包含有yield關鍵字，
再調用函數，就不會執行函數體代碼，拿到的傳回值就是一個產生器對象
def chicken():
    print(‘=====>first‘)
    yield 1
    print(‘=====>sencond‘)
    yield 2
    print(‘=====>third‘)
    yield 3

obj=chicken()
print(obj)
產生器本質就是迭代器，也就是說產生器的玩法其實就是迭代器的玩法
print(obj.__iter__() is obj)
res=obj.__next__()
print(res)

res1=obj.__next__()
print(res1)

res2=obj.__next__()
print(res2)

obj.__next__()

1、iter_obj=obj.__iter__()，拿到迭代器
2、出發iter_obj.__next__()，拿到該方法的傳回值，賦值給item
3、周而復始，直到函數內不在有yield，即取值完畢
4、for會檢測到StopIteration異常，結束迴圈
for item in obj:
    print(item)


總結yield：
1、為我們提供了一種自訂迭代器的方式，
   可以在函數內用yield關鍵字，調用函數拿到的結果就是一個產生器，產生器就是迭代器
2、yield可以像return一樣用於傳回值，區別是return只能返回一次值，而yield可返回多次
   因為yield可以儲存函數執行的狀態

def my_range():
    print(‘start........‘)
    n=0
    while True:
        yield n
        n+=1

obj=my_range()
print(obj)

print(obj.__next__())
print(obj.__next__())

for i in my_range():
    print(i)

def my_range(start,stop,step=1):
    n=start
    while n < stop:
        yield n #yield 4
        n+=step #5


obj=my_range(3,7,2) #3,5,
print(obj.__next__())
print(obj.__next__())

for item in my_range(5,10,2):
    print(item)

三、產生器之yield的運算式

def eat(name):
    print(‘%s ready to eat‘ %name)
    food_list=[]
    while True:
        food=yield food_list # food=‘骨頭‘
        food_list.append(food) #food_list=[‘泔水‘,‘骨頭‘]
        print(‘%s start to eat %s‘ %(name,food))


dog1=eat(‘alex‘)

1、必須初始化一次，讓函數停在yield的位置
res0=dog1.__next__()
print(res0)

2、接下來的事，就是喂狗
send有兩方面的功能
1、給yield傳值
2、同__next__的功能
res1=dog1.send(‘泔水‘)
print(res1)
res2=dog1.send(‘骨頭‘)
print(res2)
res3=dog1.send(‘shit‘)
print(res3)

四、面向過程的編程思想

1 面向過程的編程思想
    核心是‘過程‘二字，過程即解決問題的步驟，即先幹什麼，再幹什麼。。。。
    基於面向過程編寫程式就好比在設計一條流水線，是一種機械式的思維方式。


2、示範：

3、總結優缺點：
    優點：複雜的問題流程化，進而簡單化
    缺點：修改一個階段，其他階段都有可能需要做出修改，牽一髮而動全身，即擴充性極差
    應用：用於擴充性要求低的情境

1、步驟一：拿到使用者輸入的合法的資訊：使用者名稱、密碼、餘額、年齡
db_path=‘db.txt‘

def get_uname():
    while True:
        uname=input(‘使用者名稱>>：‘).strip()
        if not uname.isalpha():
            print(‘\033[45m使用者名稱必須為英文字母...\033[0m‘)
            continue
        with open(r‘%s‘ %db_path,‘r‘,encoding=‘utf-8‘) as f:
            for line in f:
                uinfo=line.strip(‘\n‘).split(‘,‘)
                if uname == uinfo[0]:
                    print(‘\033[45m使用者名稱已存在...\033[0m‘)
                    break
            else:
                return uname

def get_pwd():
    while True:
        pwd1=input(‘請輸入密碼>>: ‘).strip()
        pwd2=input(‘再次輸入密碼>>: ‘).strip()
        if pwd1 == pwd2:
            return pwd1
        else:
            print(‘\033[45m兩次輸入的密碼不一致，請重新輸入...\033[0m‘)

def get_bal():
    while True:
        bal=input(‘請輸入餘額: ‘).strip()
        if bal.isdigit():
            # bal=int(bal)
            return bal
        else:
            print(‘\033[45m錢必須是數字，傻叉...\033[0m‘)

def get_age():
    pass

2、步驟二：寫入檔案
def file_hanle(uname,pwd,bal,age):
    with open(r‘%s‘ %db_path,‘a‘,encoding=‘utf-8‘) as f:
        f.write(‘%s,%s,%s,%s\n‘ %(uname,pwd,bal,age))

 註冊功能
def register():
    #步驟1：
    uname=get_uname() #拿到合法的使用者名稱
    pwd=get_pwd() #拿到合法的密碼
    bal=get_bal() #拿到合法的餘額
    #步驟2：
    file_hanle(uname,pwd,bal) #寫入檔案

Python之旅.第三章.函數3.30