python 递归,迭代器,生成器,面向过程编程

一.递归和迭代
1.递归：函数调用自身
2.迭代：一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值

while True: #只是单纯地重复，因而不是迭代
    print('===>') 
    
l=[1,2,3]
count=0
while count < len(l): #迭代
    print(l[count])
    count+=1

3.递归算法:
(1)思想:常见的解决问题的方法,即把问题逐渐简单化

• 如解决斐波那契数列的计算,汉诺塔,快排

(2)构成:包括两部分

1.递归头:什么时候不调用自身方法;也就是结束条件
    没有递归头将陷入死循环
def a1():
    print('a1')
    a1()
2.递归体:什么时候需要调用自身方法

递归计算阶乘:

def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)
print(factorial(10))
#结果:3628800

二.迭代器协议
1.迭代器协议:对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么引起一个StopIteration异常，以终止迭代（只能往后不能往前）
2.迭代器iterator:有next方法，实现了迭代器协议的对象(如何实现:对象内部定义一个_iter_()方法)—>可作用于next()的对象

iterator的计算是惰性的:python的iterator对象表示的是一个数据流,可以把这个数据流看做是一个有序序列,但不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据

'hello'.__iter__
(1,2,3).__iter__
[1,2,3].__iter__
{'a':1}.__iter__
{'a','b'}.__iter__
open('a.txt').__iter__

iterator均为iterable object;反之不一定

常见的iterator有文件句柄file handler/生成器generator
list/dict/str/set/tuple/file非iterator,但可通过iter()转换成iterator

3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具(for循环,sum,min,max等)使用迭代器协议访问对象
4.迭代器对象:即内置有__iter__又内置有__next__方法的对象
5.迭代器优缺点：

• 优点：
  提供一种统一的、不依赖于索引的迭代方式
  惰性计算，节省内存
• 缺点：
  无法获取长度（只有在next完毕才知道到底有几个值）
  一次性的，只能往后走，不能往前退

三.for循环机制
1.本质:循环所有对象，全部使用迭代器协议
2.(str/list/tuple/dict/set/file)都不是可迭代对象，不过在for循环时调用了其内部的_iter_()方法，将其变成了可迭代对象
3.工作原理:
执行in后对象的dic.iter()方法，得到一个迭代器对象iter_dic
执行iter_dic._ next_(),将得到的值赋值给k,然后执行循环体代码
重复前过程，直到捕捉到异常StopIteration,结束循环

#使用索引，只适用于序列类型
l=[1,2,3]
index=0
while index<len(l):
    print(l[index])
    index+=1

遵循迭代器协议访问方式
dic={'a':1,'b':2,'c':3}
iter_dic=dic.__iter__() #得到迭代器对象，迭代器对象即有__iter__又有__next__，但是：迭代器.__iter__()得到的仍然是迭代器本身
iter_dic.__iter__() is iter_dic #True

print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
#print(iter_dic._next_()) #抛出异常StopIteration/结束标志

#while循环模拟for循环
dic={"k1":1,"k2":2,"k3":3}
iter_dic=dic.__iter__()
while True:
    try:
        k=next(iter_dic)
        print(dic[k])   #这两行等价于print(iter_dic._next_())
    except StopIteration:
        break
        
#这么写太丑陋了，需要自己捕捉异常，控制next，使用for循环完成

#基于for循环，可以不再依赖索引去取值，也适用于非序列类型
dic={'a':1,'b':2,'c':3}
for k in dic:
    print(dic[k])   #结果为1  2  3

四.生成器generator
1.生成器：可理解为一种数据类型，自动实现迭代器协议(其他类型需调用自己内置的_iter_()方法)—可迭代对象
2.获得方法：生成器函数；生成器表达式
3.为延迟操作（在需要时产生结果而非立即产生结果）提供支持—节约内存

人口信息.txt   文件内容：
{"name":北京,"population":10}
{"name":江苏,"population":1000}
{"name":上海,"population":10}
{"name"浙江,"population":950}

def get_pop(filename):
    with open(filename) as f:
        for line in f: 
            p=eval(line)        
            yield p["population"]   
gen=get_pop("人口信息.txt")

all_pop=sum(gen)
for p in gen:
    print(p/all_pop)
#执行上述代码不会有任何输出，因为*生成器只能遍历一次*，sum时即已遍历，for时无法再遍历

g.send(value):触发生成器函数的一次运行，并将value传给(上次停留在的)yield

def test(): 
    print("start")
    first=yield 1    
    print("1",first)
    yield 2
    print("2")
t=test()
res=t._next_()   
print(res)   #结果为start   1
res=t.send(None)   
print(res)   #结果为1   None   2

五.生成器函数
1.生成器函数:常规函数定义，但是用yield语句而非return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数状态，以便下次从离开处继续
2.yield语句可执行多次

#只要函数内部包含有yield关键字，那么函数名()得到的结果就是生成器，并且不会执行函数内部代码
def func():
    print('====>first')
    yield 1
    print('====>second')
    yield 2
    print('====>third')
    yield 3
    print('====>end')   #yield可执行多次

g=func()
print(g)    #结果为<generator object func at 0x0000000002184360> 
print(g._next_())   #结果为'---->first'   1
print(g._next_())   #结果为'---->second'   2   #yield只能通过_next_()一个个执行

#生产者-消费者模型(协程函数)：
def consumer(name):
    print("我是%s,我准备开始吃包子了"%name)
    while True:
        baozi=yield
        print("%s很开心地把%s吃掉了"%(name,baozi))

def producer():
    c1=consumer("A")
    c2=consumer("B")    
    c1._next_()
    c2._next_()
    for i in range(10):
        c1.send("包子%s"%i)
        c2.send("包子%s"%i)

producer()

六.协程函数:如果一个函数内部yield的使用方法是表达式形式的话，如x=yield，那么该函数成为协程函数

#yield关键字的另外一种使用形式：表达式形式的yield
def eater(name):
    print('%s 准备开始吃饭啦' %name)
    food_list=[]
    while True:
        food=yield food_list   #用food变量接住send过来的值
        print('%s 吃了 %s' % (name,food))
        food_list.append(food)

g=eater('egon')
g.send(None) 
#对于表达式形式的yield,第一次使用时必须传None
#g.send(None)=next(g)=g.next()
g.send('蒸羊羔')
g.send('蒸鹿茸')
g.send('蒸熊掌')
g.send('烧素鸭')
g.close()
g.send('烧素鹅')
g.send('烧鹿尾')
#结果为：
#egon 准备开始吃饭啦
#egon 吃了 蒸羊羔
#egon 吃#了 蒸鹿茸
#egon 吃了 蒸熊掌
#egon 吃了 烧素鸭
#Traceback (most recent call last):
#  File "G:\programm\0.txt", line 17, in <module>
#    g.send('烧素鹅')
#StopIteration

七.生成器表达式和列表解析
1.生成器表达式:类似于列表推导，但生成器返回按需产生结果的一个对象，而非一次构建一个列表（比列表解析省内存）
2.列表解析：内含二(g.next())/三元表达式的列表

l=[i for i in range(5)]=[0,1,2,3,4]

egg_list=['鸡蛋%s'%i for i in range(10)]   #列表解析
#该行等价于：
#egg_list=[]
#for i in range(10)
#egg_list.append('鸡蛋%s'%i)
laomuji=('鸡蛋%s'%i for i in range(10))   #生成器表达式
print(laomuji)
print(next(laomuji))   #next本质就是调用_next_()   #结果为"鸡蛋1"
print(laomuji._next_())   #结果为"鸡蛋2"

把列表解析的[ ]换成( )就是生成器表达式

3.三元运算/表达式：

name="linhaifeng"
res="sb" if name == "alex" else "shuai"   #三元表达式
print(res)   #结果为shuai

l=['鸡蛋%s' %i for i in range(10) if i>5]=['鸡蛋5','鸡蛋7','鸡蛋8','鸡蛋9']

没有四元表达式，有两元表达式

八.面向过程编程
1.定义：面向过程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么，基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式
2.优点：复杂的问题流程化，进而简单化
3.缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身
4.应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd

流水线1：
用户输入用户名、密码--->用户验证--->欢迎界面

流水线2：
用户输入sql--->sql解析--->执行功能

#=============复杂的问题变得简单
#注册功能:
#阶段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: 接收用户输入账号与密码,完成合法性校验

#ps:talk内对用户名\密码\角色的合法性校验也可以摘出来做成单独的功能,但本例就写到一个函数内了,力求用更少的逻辑来为大家说明过程式编程的思路

示例:复杂的问题变得简单,但扩展功能麻烦