可迭代的：对象下有__iter__方法的都是可迭代的对象 迭代器：对象.__iter__()得到的结果就是迭代器 迭代器的特性： 迭代器.__next__() 取下一个值 优点： 1.提供了一种统一的迭代对象的方式，不依赖于索引 2.惰性计算 缺点： 1.无法获取迭代器的长度 2.一次性的，只能往后取值，不能往前退，不能像索引那样去取得某个位置的值 生成器：函数内带有yield关键字，那么这个函数执行的结果就是生成器 生成器本质就是迭代器 def func(): n=0 while True: yield n n+=1 g=func() res=next(g) res=next(g) for i in g: pass 总结yield的功能： 1.相当于把__iter__和__next__方法封装到函数内部 2.与return比，return只能返回一次，而yield能返回多次 3.函数暂停已经继续运行的状态是通过yield保存的 yield的表达式形式： food=yield def eater(name): print('%s start to eat' %name) while True: food=yield print('%s eat %s' %(name,food)) e=eater('zhejiangF4') #e.send与next(e)的区别 #1.如果函数内yield是表达式形式，那么必须先next(e) #2.二者的共同之处是都可以让函数在上次暂停的位置继续运行，不一样的地方在于 send在触发下一次代码的执行时，会顺便给yield传一个值 #协程函数的定义？ #协程函数的应用？
定义一个简单的装饰器，完成，协和函数先next这个动作、
def init(func): def wrapper(*args,**kwargs): res=func(*args,**kwargs) next(res) return res return wrapper @init #eater=init(eater) def eater(name): print('%s start to eat' % name) food_list=[] while True: food = yield food_list print('%s eat %s' % (name, food)) food_list.append(food) e = eater('zhejiangF4') #wrapper('zhengjiangF4') # print(e) # next(e) #e.send(None) print(e.send('123')) print(e.send('123')) print(e.send('123')) print(e.send('123')) print(e.send('123'))
写个函数，源源不断往外，爬网页
from urllib.request import urlopen def get(): while True: url=yield res=urlopen(url).read() print(res) g=get() next(g) g.send('http://www.python.org')
一个功能，递归，查找，文 件夹下的文件
面向过程，编程思想例题
#grep -rl 'python' C:egon import os,time def init(func): def wrapper(*args,**kwargs): res=func(*args,**kwargs) next(res) return res return wrapper #找到一个绝对路径，往下一个阶段发一个 @init def search(target): '找到文件的绝对路径' while True: dir_name=yield #dir_name='C:\egon' print('车间search开始生产产品：文件的绝对路径') time.sleep(2) g = os.walk(dir_name) for i in g: # print(i) for j in i[-1]: file_path = '%s\%s' % (i[0], j) target.send(file_path) @init def opener(target): '打开文件，获取文件句柄' while True: file_path=yield print('车间opener开始生产产品：文件句柄') time.sleep(2) with open(file_path) as f: target.send((file_path,f)) @init def cat(target): '读取文件内容' while True: file_path,f=yield print('车间cat开始生产产品：文件的一行内容') time.sleep(2) for line in f: target.send((file_path,line)) @init def grep(pattern,target): '过滤一行内容中有无python' while True: file_path,line=yield print('车间grep开始生产产品：包含python这一行内容的文件路径') time.sleep(0.2) if pattern in line: target.send(file_path) @init def printer(): '打印文件路径' while True: file_path=yield print('车间printer开始生产产品：得到最终的产品') time.sleep(2) print(file_path) g=search(opener(cat(grep('python',printer())))) g.send('C:\egon') g.send('D:\dir1') g.send('E:\dir2') #面向过程的编程思想：流水线式的编程思想，在设计程序时，需要把整个流程设计出来 #优点： #1：体系结构更加清晰 #2：简化程序的复杂度 #缺点： #1：可扩展性极其的差，所以说面向过程的应用场景是：不需要经常变化的软件，如：linux内核，httpd，git等软件
列表生成式
面试经常会问到
#三元表达式 # name='alex' # name='egon' # # res='SB' if name == 'alex' else 'shuai' # print(res) # egg_list=[] # # for i in range(100): # egg_list.append('egg%s' %i) # print(egg_list) # #先进行for循环，然后，再去判断if子句，然后，再去执行%i把值打印出来 # l=['egg%s' %i for i in range(100) if i > 50] # print(l) l=[1,2,3,4] s='hello' #把列表l中的每个数字分别与下字符串中的每个字母拼成元组，拼一遍，如（1,'h'）(1,'e'),也可以不加if判断，默认全是真 # l1=[(num,s1) for num in l if num > 2 for s1 in s] # print(l1) # l1=[] # for num in l: # for s1 in s: # t=(num,s1) # l1.append(t) # print(l1) 把下面的，列出文件夹下的文件和列表，进行，列表生成式的改进，列表生成式，本身就是append往里面 # import os # g=os.walk('C:\egon') # file_path_list=[] # for i in g: # # print(i) # for j in i[-1]: # file_path_list.append('%s\%s' %(i[0],j)) # # print(file_path_list) # # g=os.walk('C:\egon') # l1=['%s\%s' %(i[0],j) for i in g for j in i[-1]] # print(l1)
模拟数据库查询
# # l=['egg%s' %i for i in range(100)] # print(l) 如果用列表生成式，列表是保存在内存中的如果数据太大，直接 死掉，所以这时候就要用到生成器，表达式 也很简单，直接用（）括起来就行，然后，再每次next,或者用for来进行迭代，但是要注意，生成器，也即迭代器， 是一次性的，再用，还要再生成 # g=l=('egg%s' %i for i in range(1000000000000000000000000000000000000)) # print(g) # print(next(g)) # print(next(g)) # for i in g: # print(i) # f=open('a.txt')，a这个文件，每一行两边都有空格，需要把空格 去掉 # l=[] # for line in f: # line=line.strip() # l.append(line) # # print(l) # f.seek(0) # l1=[line.strip() for line in f] 列表生成式是中括号，一次全放内存，不推荐， # print(l1) # # f.seek(0) 此鼠标，要返回首页，很好的解释了，迭代器，是一次性的 # g=(line.strip() for line in f) 生成器表达式，惰性的，用一个取一个，不用担心卡死内存 # print(g) # print(next(g)) # f=open('a.txt') # g=(line.strip() for line in f) # l=list(g) # print(l) sum这个函数，()中传的只要是个可迭代的对像，他像for一样，一次next一个，把你传进去的变量， 最后求和 # nums_g=(i for i in range(3)) # # # print(sum([1,2,3,4])) # print(sum(nums_g)) 下图中的b.txt类似于等，把文件里面的值求和 mac 10000 1 电脑 5000 1 # money_l=[] # with open('b.txt') as f: # for line in f: # goods=line.split() # res=float(goods[-1])*float(goods[-2]) # money_l.append(res) # print(money_l) #下面是用声明式编程，进行的求和 # f=open('b.txt') # g=(float(line.split()[-1])*float(line.split()[-2]) for line in f) # # print(sum(g)) # with open('b.txt') as f: # print(sum((float(line.split()[-1])*float(line.split()[-2]) for line in f))) # res=[] # with open('b.txt') as f: # for line in f: # # print(line) # l=line.split() # # print(l) # d={} # d['name']=l[0] # d['price']=l[1] # d['count']=l[2] # res.append(d) # print(res) # with open('b.txt') as f: # res=(line.split() for line in f) # print(res) # dic_g=({'name':i[0],'price':i[1],'count':i[2]} for i in res) # print(dic_g) # apple_dic=next(dic_g) # print(apple_dic['count']) # apple_dict=next(dic_g) # print(apple_dict) #取出单价>10000 with open('b.txt') as f: res=(line.split() for line in f) # print(res) dic_g=({'name':i[0],'price':i[1],'count':i[2]} for i in res if float(i[1]) > 10000) print(dic_g) print(list(dic_g)) # for i in dic_g: # print(i)