Python之路【第六篇】:Python迭代器、生成器、面向過程編程

時間 2019-12-10

標籤 python 之路第六篇迭代成器面向過程編程欄目 Python 简体版

原文原文鏈接

閱讀目錄

1、迭代器

一、迭代的概念

#迭代器即迭代的工具，那什麼是迭代呢？python

#迭代是一個重複的過程，每次重複即一次迭代，而且每次迭代的結果都是下一次迭代的初始值linux

代碼以下：nginx

while True:
    print('==========>') list=[1,2,3] while count < len(1): #迭代 print(1[count]) count+=1

二、爲什麼要用迭代器?什麼是可迭代對象？什麼是迭代器對象？

#一、爲什麼要有迭代器？
對於序列類型：字符串、列表、元祖，咱們可使用索引的方式迭代取出其包含的元素。但對於字典、集合、文件等類型是沒有索引的，若還想取出其內部包含的元素，則必須找出一種不依賴於索引的迭代方式，這就是迭代器


#二、什麼是可迭代對象？
可迭代對象指的是內置有__iter__方法的對象，即obj.__iter__,以下： 'simon'.__iter__ [1,2,3].__iter__ (1,2,3).__iter__ {'a':1}.__iter__ {'a'.'b'}.__iter__ open('test.txt').__iter__ #三、什麼是迭代器對象？ 可迭代對象執行obj.__iter__()獲得的結果就是迭代器對象 而迭代器對象指的是即內置有__iter__又內置有__next__方法的對象 l=['die','erzi','sunzi','chongsunzi'] iter_l=l.__iter__() print(iter_l.__next__()) print(iter_l.__next__()) print(iter_l.__next__()) print(iter_l.__next__()) print(next(iter_l)) #next()--------->iter_l.__next__()  文件類型是迭代器對象 open('test.txt').__iter__ open('test.txt').__next__ #四、注意： 迭代器對象必定是可迭代對象，而可迭代對象不必定是迭代器對象

三、迭代器對象的使用

dic={'a':1,'b':2,'c':3,'d':4}
iter_dic=dic.__iter__() #獲得迭代器對象，迭代器對象即有__iter__又有__next__，可是，迭代器.__iter__()獲得的仍然是迭代器自己
 iter_dic.__iter__() is iter_dic #True print(iter_dic.__next__()) #等同於print(next(iter_idc)) print(iter_dic.__next__())#等同於print(next(iter_idc)) print(iter_dic.__next__())#等同於print(next(iter_idc)) print(iter_dic.__next__())#等同於print(next(iter_idc)) # print(iter_dic.__next__()) #拋出異常StopIteration，或者說結束標誌 #有了迭代器，咱們就能夠不依賴索引迭代取值了 iter_dic=dic.__iter__() while 1: try: k=next(iter_dic) print(dic[k]) except StopIteration: break #這麼寫太醜逼，須要咱們本身捕捉異常，控制next,python這麼牛逼，能不能幫咱們解決呢？請看for循環

四、for循環

#基於for循環，咱們能夠徹底再也不依賴索引去取值了
dic={'a':1,'b':2,'c':3,'d':4}

for k in dic: print(dic[k]) 輸出結果： C:\Python35\python3.exe G:/python_s3/day18/迭代器.py 3 1 4 2 #for循環的工做原理 #一、執行in後對象的dic.__iter__()方法，獲得一個迭代對象iter_dic #二、執行next(iter_dic),將獲得的值賦值給k,而後執行循環體代碼 #三、重複過程2，直到捕捉到異常StopIteration，結束循環

五、迭代器的優缺點

#優勢：
    1、提供一種統一的、不依賴於索引的迭代方式
    2、惰性計算，節省內存

#缺點：

    1、沒法獲取長度(只有在next完畢才知道到底有幾個值)
    二、一次性的，只能日後走，不能往前

2、生成器

一、什麼是生成器

def func():
    print('==========>first')
    yield 1
    print('==========>second')
    yield 2
    print('==========>third')
    yield 3
    print('==========>end')

g=func()
p=g.__iter__()
print(p.__next__())
print(p.__next__())
print(p.__next__())


print(g) #<generator object func at 0x0000000000B81150>
print(next(g))

二、生成器就是迭代器

g.__iter__
g.__next__

#二、因此生成器就是迭代器，所以能夠這樣取值
res=next(g)
print(res)

三、練習

一、自定義函數模擬range(1,7,2)
二、模擬管道，實現功能：tail -f nginx_access.log|grep '404'

#題目一：
def range(start,stop,step=1):
    while start < stop:
        yield start
        start+=step
#執行函數獲得生成器，本質就是迭代器
obj=range(1,7,2)
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj)) #StopIteration


#應用於for循環
for i in range(1,7,2):
    print(i)
輸出結果：
C:\Python35\python3.exe G:/python_s3/day18/生成器.py
1
3
5


#題目二
import time
def tail(filepath):
    with open('filepath','rb') as f:
        f.seek(0,2)
        while True:
            line=f.readline()
            if line:
                yield line
            else:
                time.sleep(0.2)
                
def grep(pattern,lines):
    for line in lines:
        line=line.decode('utf-8')
        if pattern in line:
            yield line
for line in grep('404',tail('access.log')):
    print(line,end='')
    
#測試
with open('nginx_access.log','a',encoding='utf-8') as f:
    f.write('出錯404\n')

四、協程函數

#yield關鍵字的另一種使用形式：表達式形式的yield
def dinner(name):
    print('%s 準備吃飯啦' %name)
    food_list=[]
    while True:
        food=yield food_list
        print('%s 吃了 %s' % (name,food))
        food_list.append(food)

g=dinner('simon')
g.send(None)  #對於表達式形式的yield,在使用時，第一次必須傳None, g.send(None)等同於next(g)
g.send('烤全羊')
g.send('烤腰子')
g.send('羊肉串')
g.send('烤豬蹄')
g.close()
g.send('鴨架')
g.send('熊掌')

五、練習

1、編寫裝飾器，實現初始化協程函數的功能
二、實現功能：grep -rl 'python'  /etc

#題目一：
def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper
@init
def eater(name):
    print('%s 準備開始吃飯啦' %name)
    food_list=[]
    while True:
        food=yield food_list
        print('%s 吃了 %s' % (name,food))
        food_list.append(food)

g=eater('egon')
g.send('蒸羊羔')

#題目二：
#注意：target.send(...)在拿到target的返回值後纔算執行結束
import os
def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper

@init
def search(target):
    while True:
        filepath=yield
        g=os.walk(filepath)
        for dirname,_,files in g:
            for file in files:
                abs_path=r'%s\%s' %(dirname,file)
                target.send(abs_path)
@init
def opener(target):
    while True:
        abs_path=yield
        with open(abs_path,'rb') as f:
            target.send((f,abs_path))
@init
def cat(target):
    while True:
        f,abs_path=yield
        for line in f:
            res=target.send((line,abs_path))
            if res:
                break
@init
def grep(pattern,target):
    tag=False
    while True:
        line,abs_path=yield tag
        tag=False
        if pattern.encode('utf-8') in line:
            target.send(abs_path)
            tag=True
@init
def printer():
    while True:
        abs_path=yield
        print(abs_path)


g=search(opener(cat(grep('你好',printer()))))
# g.send(r'E:\CMS\aaa\db')
g=search(opener(cat(grep('python',printer()))))
g.send(r'E:\CMS\aaa\db')

六、yield總結

#一、把函數作成迭代器
#二、對比return,能夠返回屢次值，能夠掛起/保存函數的運行狀態

3、面向過程編程

#一、首先強調：面向過程編程絕對不是用函數編程這麼簡單，面向過程是一種編程思路、思想，而編程思路是不依賴於具體的語言或語法的。言外之意是即時咱們不依賴於函數，也能夠基於面向過程的思想編寫程序

#二、定義
面向過程的核心是過程二字，過程指的是解決問題的步驟，即先幹什麼再幹什麼

基於面向過程設計程序就比如在設計一條流水線，是一種機械式的思惟方式

#三、優勢：複雜的問題流程化，進而簡單化

#四、缺點：可擴展性差，修改流水線的任意一個階段，都會牽一髮而動全身

#五、應用：擴展性要求不高的場景，典型案例如：linux內核，git,httpd

#六、舉例
流水線1：
用戶輸入用戶名、密碼--->用戶驗證--->歡迎界面

流水線2：
用戶輸入sql--->sql解析--->執行功能

ps：函數的參數傳入，是函數吃進去的食物，而函數return的返回值，是函數拉出來的結果，面向過程的思路就是，把程序的執行當作一串首尾相連的功能，該功能能夠是函數的形式，而後一個函數吃，拉出的東西給另一個函數吃，另一個函數吃了再繼續拉給下一個函數吃。。。git

#=============複雜的問題變得簡單
#註冊功能:
#階段1: 接收用戶輸入帳號與密碼,完成合法性校驗
def talk():
    while True:
        username=input('請輸入你的用戶名: ').strip()
        if username.isalpha():
            break
        else:
            print('用戶必須爲字母')

    while True:
        password1=input('請輸入你的密碼: ').strip()
        password2=input('請再次輸入你的密碼: ').strip()
        if password1 == password2:
            break
        else:
            print('兩次輸入的密碼不一致')

    return username,password1

#階段2: 將帳號密碼拼成固定的格式
def register_interface(username,password):
    format_str='%s:%s\n' %(username,password)
    return format_str

#階段3: 將拼好的格式寫入文件
def handle_file(format_str,filepath):
    with open(r'%s' %filepath,'at',encoding='utf-8') as f:
        f.write(format_str)


def register():
    user,pwd=talk()
    format_str=register_interface(user,pwd)
    handle_file(format_str,'user.txt')


register()


#=============牽一髮而動全身,擴展功能麻煩
#階段1: 接收用戶輸入帳號與密碼,完成合法性校驗
def talk():
    while True:
        username=input('請輸入你的用戶名: ').strip()
        if username.isalpha():
            break
        else:
            print('用戶必須爲字母')

    while True:
        password1=input('請輸入你的密碼: ').strip()
        password2=input('請再次輸入你的密碼: ').strip()
        if password1 == password2:
            break
        else:
            print('兩次輸入的密碼不一致')


    role_dic={
        '1':'user',
        '2':'admin'
    }
    while True:
        for k in role_dic:
            print(k,role_dic[k])

        choice=input('請輸入您的身份>>: ').strip()
        if choice not in role_dic:
            print('輸入的身份不存在')
            continue
        role=role_dic[choice]

    return username,password1,role

#階段2: 將帳號密碼拼成固定的格式
def register_interface(username,password,role):
    format_str='%s:%s:%s\n' %(username,password,role)
    return format_str

#階段3: 將拼好的格式寫入文件
def handle_file(format_str,filepath):
    with open(r'%s' %filepath,'at',encoding='utf-8') as f:
        f.write(format_str)


def register():
    user,pwd,role=talk()
    format_str=register_interface(user,pwd,role)
    handle_file(format_str,'user.txt')


register()


#ps:talk內對用戶名\密碼\角色的合法性校驗也能夠摘出來作成單獨的功能,但本例就寫到一個函數內了,力求用更少的邏輯來爲你們說明過程式編程的思路

示例:複雜的問題變得簡單,但擴展功能麻煩