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 1else: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 #Trueprint(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 2print("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 1print('====>second')yield 2print('====>third')yield 3print('====>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=yieldprint("%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():breakelse:print('用户必须为字母')while True:password1=input('请输入你的密码: ').strip()password2=input('请再次输入你的密码: ').strip()if password1 == password2:breakelse: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内对用户名\密码\角色的合法性校验也可以摘出来做成单独的功能,但本例就写到一个函数内了,力求用更少的逻辑来为大家说明过程式编程的思路示例:复杂的问题变得简单,但扩展功能麻烦

python 递归,迭代器,生成器,面向过程编程相关推荐

迭代器生成器面向过程编程
迭代器什么是迭代器(iterator)? 器值得某种工具迭代,指的是更新换代的过程,例如应用程序的版本更新,从1.0编程1.1在变成1.2 迭代的目的是要根据上一个结果,产生下一个结果,这是一个重复 ...
函数装饰器生成器面向过程编程
"""# 齐天大圣孙悟空身如玄铁火眼金睛长生不老还有七十二变定义函数与调用函数的基本形式一 ,函数定义的三种形式 1.1 无参函数def foo():print(' ...
面向对象，面向过程编程
很多时候,我们都是用面向对象语言进行面向过程编码. 1. 滥用 getter.setter 方法. 滥用getter,setter方法很容易造成违反封装特性.数据没有访问权限控制,任何代码都可 ...
python是面向对象还是面向过程的语言_关于python是面向对象还是面向过程的分析...
关于python是面向对象还是面向过程的分析发布时间:2020-04-07 16:10:55 来源:亿速云阅读:24 作者:小新今天小编给大家分享的是关于python是面向对象还是面向过程的分析 ...
面向对象与面向过程编程
从语言角度来讲: C是面向过程编程: C++一半是面向过程编程,一半是面向对象编程: Java是面向对象编程. 一.什么是面向对象编程与面向过程编程? 面向过程(Procedure Oriented ...
python全栈开发-Day11 迭代器、生成器、面向过程编程
一. 迭代器一 .迭代的概念迭代器即迭代的工具,那什么是迭代呢? 迭代是一个重复的过程,每次重复即一次迭代,并且每次迭代的结果都是下一次迭代的初始值 while True: #只是单纯地重复,因而 ...
python基础---面向过程编程
面向过程编程核心是过程二字,过程即解决问题的步骤,基于面向过程去设计程序就像是在设计一条工业流水线,是一种机械式的思维方式优点:程序结构清晰可以把复杂的问题简单化,流程化缺点:可扩展性差,一条流 ...
python 3 面向过程编程
python 3 面向过程编程核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就像设计好一条工业流水线,是一种机械式的思维方式. 1.优点:程序结构清晰,可以把复杂的问题简单化,流程 ...
python是一种面向过程的编程语言_python协成与面向过程编程
import os import functools def init(func): @functools.wraps(func) #让warpper的帮助信息同eater相同 def warpper ...

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

python 递归,迭代器,生成器,面向过程编程相关推荐

最新文章

热门文章