一、迭代器
1.迭代器定义
迭代是一个重复的过程，每次重复一次迭代，并且每次迭代的结果都是下一次迭代的初始值。
l = ["aaa","bbb","ccc"]
count = 0
while count< len(l): #每次重复完成后count都是下一次的初始值
print(l[count])
count+=1
需要迭代器的原因：对于序列类型str、list、tuple可以依赖索引迭代取值，对于dict、set、文件需要提供不依赖索引取值的方式。
可迭代对象：具有内置__iter__方法的对象。字符串、列表、元组、字典、集合和文件均为可迭代对象。
迭代器对象：可迭代对象执行obj.__iter__()方法后得到的结果为迭代器对象。迭代器对象内置有__iter__和__next__方法。文件对象为迭代器对象。
总结：
1.可迭代对象不一定是迭代器对象。
2.迭代器对象一定是可迭代对象。
3.调用obj.__iter__()方法，可得到迭代器对象，若本身为迭代器对象，执行该方法得到的仍然是它本身。
2.迭代器的使用
可迭代对象调用obj.__iter__()方法得到迭代器对象后，可使用obj.__next__()迭代取值，迭代器对象可直接调用obj.__next__()取值。
obj.__next__（）等同于next(obj)，取完值后调用__next__会抛出StopIteration异常。
#每次调用__next__方法取一次值，取完之后再调用该方法会抛出StopIteration异常 l = ["aaa","bbb","ccc"] iter_list = l.__iter__() print(iter_list.__next__()) print(iter_list.__next__()) print(iter_list.__next__()) print(iter_list.__next__())
使用try...except捕获异常
d = {"a":212,"b":111,"c":222}
iter_dict = d.__iter__()
while True:
try:
print(next(iter_dict)) #字典迭代取到的为key
except StopIteration:
break
for循环原理
for k in obj
a）调用in后的obj__iter=obj.__iter__()得到一个迭代器对象。
b) 执行k=obj_iter.__next__()将取到的值赋给k，然后执行循环体。
c)重复过程2，直到捕获到StopInteration异常，结束循环。
3.迭代器的优缺点
优点：
a) 提供一种统一的、不依赖索引的取值方式，为for循环的实现提供了依据。
b) 迭代器同一时间在内存中只有一个值，更节省内存。
缺点：
a) 只能往后取值，为一次性的。
b) next执行完之前，不能统计值得个数，无获取长度。
二、生成器
1.生成器定义
只要函数内部包含有yield关键字，那么执行func()的到的就是生成器，不会执行函数内部代码，并且生成器就是迭代器。
def func():
print("1111111111")
yield 1
print("2222222222")
yield 2
print("3333333333")
yield 3
g = func() #g为生成器，生成器就是迭代器
print(next(g)) #func()开始执行到第一个yield，并且打印yield返回值
print(next(g)) #func()执行到第二个yield，并且打印yield返回值
print(next(g))
yield的功能：
a) yield提供了一种自定义迭代器的方法
b) yield于return的区别：yield可以返回多次值，return只能返回一次值。函数暂停与再继续的状态有yield保存。
模拟管道，实现tail -f access.log | grep "404"
1 #tail -f access.log|grep "404"
2 import time
3 def tail(filepath):
4 with open(filepath,‘rb‘) as f:
5 f.seek(0,2)
6 while True:
7 line = f.readline()
8 if line:
9 yield line
10 else:
11 time.sleep(0.05)
12
13 def grep(lines,pattern):
14 for line in lines: #调用tail后得到生成器对象，可使用for来迭代其中每一行内容
15 line =line.decode(‘UTF-8‘)
16 if pattern in line:
17 yield line
18
19 res = grep(tail("access.log"),"404") #res也为生成器对象，可使用for来迭代取值
20 for line in res:
21 print(line)
2.协程函数
表达式形式的yield，在使用时，第一次必须穿None，g.send(None)等同于next(g)
1 def eater(name):
2 print("%s开始吃了"%name)
3 food_list = []
4 while True:
5 food = yield food_list
6 print("%s吃了%s"%(name,food))
7 food_list.append(food)
8
9 g = eater("xxx") #创建生成器g
10 res1 = g.send(None) #初始化yield，拿到返回的空列表
11 print(res1)
12 res2 = g.send("米饭") #发送"米饭"给yield，继续执行代码到下一个yield，返回列表给res2
13 print(res1)
14 g.close() #结束迭代
15 res3 = g.send("面条") #无法发送和获取值
16 print(res3)
实现功能：grep -rl ‘python‘ /etc
1 #从某个路径下搜索所有包含某个字符串的文件的路径
2 import os
3
4 def init(func):
5 def inner(*args,**kwargs):
6 res = func(*args,**kwargs)
7 next(res)
8 return res
9 return inner
10
11 #列出某个路径下所有文件的绝对路径
12 @init
13 def list_path(target):
14 while True:
15 file_path = yield
16 g = os.walk(file_path)
17 for pardir,_,files in g:
18 for file in files:
19 abs_path = "%s\%s"%(pardir,file)
20 target.send(abs_path)
21
22 #打开某个文件
23 @init
24 def openner(target):
25 while True:
26 abs_path = yield
27 with open(abs_path,"rb") as f:
28 target.send((abs_path,f))
29
30 #读取文件中每一行
31 @init
32 def read_line(target):
33 while True:
34 abs_path,f = yield
35 for line in f:
36 flag = target.send((abs_path,line))
37 if flag:
38 break
39
40 #从一行中查找某个字符
41 @init
42 def find_str(target,pattern):
43 flag = False #用于判断某个文件是否包含有重复的某个字符
44 pattern = pattern.encode("utf-8")
45 while True:
46 abs_path,line = yield flag
47 if pattern in line:
48 target.send(abs_path)
49 flag = True
50
51 #将结果打印出来
52 @init
53 def print_path():
54 while True:
55 abs_path = yield
56 print(abs_path)
57
58 g = list_path(openner(read_line(find_str(print_path(),"abcdef"))))
59 g.send(r"D:\PycharmProjects")
3.yield总结
a) 可以把函数做成迭代器
b) 对比return，可以返回多次值，可以挂起/保存函数的运行状态
三、面向过程编程
面向过程是一种思路和思想，不依赖于具体的语言或语法，核心思想是过程二字，即按照流水线式分步骤解决问题。
优点是复杂问题流程化，分解为简单的小功能。
缺点是可扩展性差，修改流水线任一阶段，会影响到其他阶段。
适合扩展性要求不高的场景，入linux内核、git、httpd等。
四、三元表达式、列表推导式、生成器表达式
1.三元表达式
name = input(">>:").strip()
res = "SB" if name=="xxx" else "NB" #满足if条件，则返回if前的值，不满足则返回else后的值
print(res)
2、列表推导式
l = [str(i)+"xxx" for i in range(1,10)] #为1-10所有数字添加后缀 print(l) l = [str(i)+"xxx" for i in range(1,20) if i%2==0] #1-20所有偶数加后缀 print(l)
3、生成器表达式
将列表推导式的[]换为()就是生成器表达式。
#生成老母鸡，需要使用时调用next下蛋
>>> chicken = ("鸡蛋%s"%i for i in range(1,10))
>>> chicken
<generator object <genexpr> at 0x000001AFD64CDF68>
>>> next(chicken)
‘鸡蛋1‘
>>> list(chicken) #第一个鸡蛋已经下过了，chicken可迭代，因此可转为列表
[‘鸡蛋2‘, ‘鸡蛋3‘, ‘鸡蛋4‘, ‘鸡蛋5‘, ‘鸡蛋6‘, ‘鸡蛋7‘, ‘鸡蛋8‘, ‘鸡蛋9‘]
4、声明式编程
a) 将l=[‘xxx‘,‘abc_sb‘,‘aaa‘,‘bbb‘]中的字母全部变大写
l=[‘xxx‘,‘abc_sb‘,‘aaa‘,‘bbb‘] l = [i.upper()for i in l] print(l)
b) 将l=[‘xxx‘,‘abc_sb‘,‘aaa‘,‘bbb‘]中以sb结尾的名字过滤掉，然后保存剩下的名字长度
l=[‘xxx‘,‘abc_sb‘,‘aaa‘,‘bbb‘]
l = [len(i) for i in l if not i.endswith("sb")]
print(l)
c) 求文件test.txt中最长的行的长度（长度按字符个数算，需要使用max函数）
with open("test.txt",‘r‘,encoding="utf-8") as f:
res = max(len(line) for line in f)
print(res)
d) 求文件test.txt中总共包含的字符个数？思考为何在第一次之后的n次sum求和得到的结果为0？（需要使用sum函数）
with open("test.txt",‘r‘,encoding="utf-8") as f:
res = sum(len(line) for line in f)
print(res)
生成器只能往后取值，已经取完一次值后，再对生成器做求和结果为0
五、递归和二分法
1.递归调用定义
在调用一个函数的过程中，直接或间接调用了该函数本身，称之为递归调用。
递归调用分为两个阶段:递推和回溯。
python中使用sys.gettrcursionlimit()查看可递归调用的层数。
import sys
print(sys.getrecursionlimit()) #默认支持1000层递归调用
l=[1,[2,[3,[4,[5,[6,[7,]]]]]]]
def func(l):
for item in l:
if type(item) is list:
func(item)
else:
print(item)
func(l)
2.python中递归调用特点
python中递归调用效率低，需要在进入下一次递归时保留当前状态。其他语言中有尾递归优化，python中没有，并且对层级做了限制。
递归使用的要求：
a) 必须有一个明确的结束条件
b) 每次进入更深一层递归时，问题规模比上一次有所减少
c) 递归效率不高，层数过多易导致栈溢出
3.二分法
1 l = [2,3,5,6,8,12,15,16,19,22,35,45,56,62,98,122,321]
2 def binary_search(l,num):
3 print(l)
4 mid_index = len(l)//2
5 if len(l) != 0:
6 if num < l[mid_index]:
7 binary_search(l[0:mid_index-1],num)
8 elif num > l[mid_index]:
9 binary_search(l[mid_index+1:],num)
10 else:
11 print("find it")
12 else:
13 print("can‘t find %s" % num)
14 binary_search(l,321)
二分法
六、匿名函数
匿名函数一次性使用，随时随需定义，可应用在max、min、sorted、map、reduce、filter等函数中。
#找出薪水最高的人
salaries = {
‘abc‘:3222,
‘def‘:111,
‘aaa‘:431,
‘xxx‘:4133
}
#普通方法
g = zip(salaries.values(),salaries.keys()) #g为迭代器
print(max(g)) #max按照每次取值的第一个数来比较
#定义函数的方法，打印出薪水最高的人的名字
def func(k):
return salaries[k]
print(max(salaries,key=func)) #排序是按照key来排序，结果展示按照salaries默认结果展示
#使用匿名函数
print(max(salaries,key=lambda k:salaries[k]))
七、内置函数
sorted
#薪水排序，输出人名
salaries = {
‘abc‘:3222,
‘def‘:111,
‘aaa‘:431,
‘xxx‘:4133
}
print(sorted(salaries,key=lambda k:salaries[k]))
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))
map
#给列表中所有元素批量添加后缀
#普通方法
names = [‘xxx‘,‘aaa‘,‘eee‘]
l =[]
for name in names:
res = "%s_SB"%name
l.append(res)
print(l)
#使用map添加
g = map(lambda name:‘%s_SB‘%name,names)
print(g) #g为迭代器
print(list(g))
filter
#筛选出某个序列中特定元素
names = ["xxx_sb","aaa_sb","sss","ee_sb"]
g = filter(lambda i:i.endswith("sb"),names)
print(g)
print(list(g))
reduce
#筛选出某个序列中特定元素 #某个序列中连续两个元素进行处理 from functools import reduce print(reduce(lambda x,y:x+y,range(1,101),100)) #最后的100为初始值，可以不添加。
原文地址：https://www.cnblogs.com/gehan/p/8097450.html