一、装饰器

无参装饰器:

1、示例1:

 1 import time  #加载时间模块
 2 def war(name):  #定义装饰器
 3     def wari():
 4         start = time.time()  #定义开始时间
 5         name()    #相当于执行下面的函数
 6         stop = time.time()    #定义结束时间
 7         print("run time is %s" %(stop-start))  #给原来函数加入的新功能
 8     return wari
 9 @war
10 def info():
11     time.sleep(3)
12     print('we are famly!!')
13
14 info()

执行@war的时候就表示运行了war(name)这个函数,然后把下面的函数名赋值给name,就表示info=war(info),现在取到的只是info这个函数的内存地址,在装饰器上运行name()就相当于执行这个info()函数

示例2:

 1 def war(name):
 2     def wari(*args,**kwargs):
 3         start = time.time()
 4         name(*args,**kwargs)
 5         stop = time.time()
 6         print("run time is %s" %(stop-start))
 7     return wari
 8 @war
 9 def info():
10     time.sleep(3)
11     print('we are famly!!')
12
13 @war
14 def auth(name,password):
15     time.sleep(2)
16     print('login success!')
17
18 @war
19 def ero(x):
20     time.sleep(1)
21     print('hello %s' %x)
22
23 info()
24
25 auth('xyy',123)
26 ero('xyp')

有参装饰器:

示例1:

 1 def auth1(auth_type):
 2         def auth(func):
 3              def war(*args,**kwargs):
 4                  if auth_type == 'file':
 5                     name = input("username: ")
 6                     pwd =  int(input("password: "))
 7                     if name  == "xyy" and pwd == 123:
 8                         print("login successfull!")
 9                         func(*args,**kwargs)
10                     else:
11                         print("login error!")
12                 elif auth_type == 'sql':
13                     print('输入错误')
14            return war
15        return auth
16
17
18 @auth1(auth_type='sql') #write=auth(write)
19 def write():
20 print('welcome to my home!')
21 write()

二、迭代器
1、例子1:有下标的类型

 1 l = ['a','b','c','d','e'] #定义一个列表
 2 i = l.__iter__() #生成一个迭代器
 3
 4 while True: #循环这个生成器
 5   try: #监听
 6     print(i.__next__()) #循环取下一个值
 7 except StopIteration: #监听的关键字
 8   break    #退出循环
 9
10 或:
11 i = 0
12 while i < len(l):
13   print(l[i])
14   i += 1
15
16 或:
17 for i in l: #直接循环遍历一遍
18   print(i)
19
20 或:
21 for i in range(len(l)): #先取下标的的长度再取对应的值
22   print(l[i])
23 PS:try和except相当于一个if判断

例子2:没下标的类型

1 dic = {'a':1,'b':2,'c':3}
2 i = dic.__iter__()
3 while True:
4   try:
5     print(i.__next__())
6 except StopIteration:
7   break

例子3:文件类型

1 with open('war.txt','r+',encoding='utf8') as f:
2 a = f.__iter__()
3 while True:
4   try:
5     print(a.__next__(),end='')
6 except StopIteration:
7   break

2、判断是否是可迭代和是否是迭代器:

 1 from collections import Iterable,Iterator #加载模块
 2 s = "xyyp"
 3 l = ['a','b','c']
 4 t = (1,2,3,4)
 5 d = {"s":1,"a":4}
 6 f = open('war.txt')
 7 (1)Iterable判断是否可迭代:
 8 print(isinstance(s,Iterable)) -->True
 9 print(isinstance(l,Iterable)) -->True
10 print(isinstance(t,Iterable)) -->True
11 print(isinstance(d,Iterable)) -->True
12 print(isinstance(f,Iterable)) -->True
13 (2)Iterator判断是否是迭代器:
14 print(isinstance(s,Iterator)) -->False
15 print(isinstance(l,Iterator)) -->False print(isinstance(t,Iterator)) -->False
16 print(isinstance(d,Iterator)) -->False
17 print(isinstance(f,Iterator)) -->True

PS:只有文件是可迭代对象并且是迭代器。

小结:
迭代器优点:
1,迭代器提供了一种不依赖于索引的取值方式,这样可以遍历那些没有索引的可迭代对象,比如:字典,集合,文件。
2,迭代器于列表比较,迭代器是惰性计算的,更节省内存空间。

迭代器缺点:
1,无法获取迭代器的长度,使用不如列表索引取值灵活。
2,一次性,只能往后取值,不能倒着取值

三、生成器和协程函数

1、生成器就是一个函数,这个函数内包含有yield这个关键字。

2、生成器和和return的区别在于return只能返回一次函数的值就结束了,yield能返回多次值。

3、yield把函数变成了生成器,生成器也就是迭代器。

示例1:

 1 def count(x): #定义函数
 2   print('start count')
 3   while x > 0: #函数内容
 4   yield x    #返回值
 5   x -= 1
 6 print('done')
 7
 8 g = count(5) #执行函数 并把返回值赋给一个变量,最后生成迭代器
 9 while True:    #while循环迭代器
10   try:
11     print(next(g))
12 except StopIteration:
13   break

4、协程函数:
示例1:

 1 def eater(name): #定义函数
 2   print('%s waiting food' %name)
 3   food_list=[] #定义空列表
 4   while True:
 5     food = yield food_list #yield返回值赋值给food
 6     print('%s get %s,to start eat' %(name,food))
 7     food_list.append(food) #每传入一个值添加到列表里面去
 8
 9 e = eater('钢蛋') #生成迭代器
10 print(next(e)) #输出迭代器内容
11 print(e.send('包子')) #send传入的值可以直接赋给yield
12 print(e.send('大葱包子'))
13 print(e.send('大蒜包子'))
14 print(e.send('韭菜包子'))

小结:
send和next()的区别:
1、如果函数内yield是表达式形式(food=yield),那么必须先next触发函数的执行。
2、二者的共同之处都可以让函数在上一次暂停的位置继续运行,不同之处在于send在触发下一次代码的执行时,会顺便给yield传一个值。

四、面向过程函数编程:
示例:

 1 import os #加载os模块
 2 def decorate(func): #定义next装饰器
 3   def t_layer(*args,**kwargs):
 4     res = func(*args,**kwargs)
 5     next(res)
 6     return res
 7   return t_layer
 8
 9 @decorate #调用装饰器
10 def path(target): #定义文件路径生成器
11   while True:
12     dir_name = yield
13     g = os.walk(dir_name)
14     for i in g:
15       for x in i[-1]:
16         file_path = "%s\\%s" %(i[0],x)
17         target.send(file_path)
18
19 @decorate
20 def opener(target): #定义读取文件内容的生成器
21   while True:
22     file_path = yield
23     with open(file_path) as f:
24       target.send((file_path,f))
25
26 @decorate
27 def cat(target):    #定义看文件内容的生成器
28   while True:
29     file_path,f = yield
30     for line in f:
31     target.send((file_path,line))
32
33 @decorate
34 def grep(pattern,target): #定义一个过滤文件内容的生成器
35   while True:
36     file_path,line = yield
37     if pattern in line:
38     target.send(file_path)
39
40 @decorate
41 def printer():    #定义输出指定文件路径的生成器
42   while True:
43     file_path =yield
44     print(file_path)
45
46 g = path(opener(cat(grep('xlinux',printer())))) #调用生成器
47 g.send('D:\\xyyp')

优点:
  1、体系结构更加清晰。
  2、简化程序的复杂度。
缺点:
  1、可扩展极其的差,所以面向过程的应用场景是:不需要经常变化的软件。

转载于:https://www.cnblogs.com/xyp-blog123/p/7028892.html

装饰器,迭代器,生成器相关推荐

  1. python装饰器+迭代器+生成器

    1.函数嵌套:在调用一个函数的过程中,调用了其他函数 def f1():x=1def f2():print('from f2')f2() f1() 2.名称空间与作用域 a. 名称空间:存放名字与变量 ...

  2. Python中的装饰器,迭代器,生成器

    1. 装饰器 装饰器他人的器具,本身可以是任意可调用对象,被装饰者也可以是任意可调用对象. 强调装饰器的原则:1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式 装饰器的目标:在遵循1和2的 ...

  3. python的装饰器、迭代器、yield_python装饰器,迭代器,生成器,协程

    python装饰器[1] 首先先明白以下两点 #嵌套函数 defout1():definner1():print(1234) inner1()#当没有加入inner时out()不会打印输出1234,当 ...

  4. python基础二 函数 递归 装饰器 迭代器 生成器 内置函数 二分法应用

    函数 迭代器 生成器 拆包和装包 tup=("j1","a1","c1","k1") a,b,c,d=tup print ...

  5. 函数进阶---闭包/装饰器/迭代器/生成器---高级特性

    待完成... 转载于:https://www.cnblogs.com/py-coder/p/10037232.html

  6. day4 匿名函数、装饰器、生成器、迭代器、内置函数、 json 与 pickle 模块

    文章目录 1.列表生成式 2.匿名函数 3.装饰器 4.生成器 5.迭代器 6.内置函数 7.json & pickle 序列化与反序列化 1.列表生成式 可通过特定语句便捷生成列表 list ...

  7. day11 - 15(装饰器、生成器、迭代器、内置函数、推导式)

    day11:装饰器(装饰器形成.装饰器作用.@语法糖.原则.固定模式) 装饰器形成:最简单的.有返回值的.有一个参数的.万能参数 函数起的作用:装饰器用于在已经完成的函数前后增加功能 语法糖:使代码变 ...

  8. python的装饰器迭代器与生成器_python3 装饰器、列表生成器、迭代器、内置方法详解等(第四周)...

    前言: 为什么要学习python3? 原因: 1.学习一门语言能力 2.通过该语言能力完成测试自动化以及独立完成自测框架知识 那么我要做什么呢? 1.每天花十个小时完成python3的学习 要在什么地 ...

  9. 装饰器,生成器,迭代器

    文章目录 装饰器 什么是装饰器 为什么使用装饰器 装饰器的使用场景 用户认证,判断用户是否登录 计算函数运行时间(算是一个功能,在项目中用的不多) 记录日志 redis缓存 装饰器1----能够适应9 ...

  10. Python基础教程:带参装饰器、生成器、迭代器、for循环迭代器、枚举

    带参装饰器 装饰器为被装饰的函数添加新功能,需要外界参数 outer参数固定一个,就是func inner参数固定和被装饰的参数固定,也不能添加新参数 可以借助函数的嵌套定义,外层给内层传参 def ...

最新文章

  1. 如何下载DELL服务器VMware ESXi镜像
  2. 解决:无法解析的外部符号__iob_func
  3. DIV+CSS网页布局常用的一些基础知识
  4. Spring Security——SessionManagement中InvalidSessionStrategy自定义——简单跳过Fitter过滤刷新Session
  5. java8新特性stream深入解析
  6. Windbg在Managed App中设置函数断点的几种方法
  7. 使用Hystrix DSL创建弹性骆驼应用程序
  8. MySQL 聚合函数(一)聚合(组合)函数概述
  9. 碎片试自学软件测试?我靠自己整理的这套方,案既充实了自己也得到了涨薪
  10. 【265天】跃迁之路——程序员高效学习方法论探索系列(实验阶段23-2017.10.28)...
  11. urllib携带登录信息
  12. 东北大学文科能学计算机专业吗,东北大学有哪些好专业,文科理科专业分别有哪些...
  13. Win7系统自带 计算器 详细使用方法
  14. Android反射系统截图Api
  15. video视频,audio音频基础学习
  16. matlab DFA算法计算Hurst指数
  17. c语言面试(c语言面试基础知识)
  18. 李子柒为什么可以火爆全球
  19. 电子通信类相关专业面试
  20. php空间自动发邮件,PHP 发送QQ邮件【实例】

热门文章

  1. Java 多线程 —— AQS 原理
  2. 谈谈 final、finally、 finalize 有什么不同?
  3. javaweb通过接口来实现多个文件压缩和下载(包括单文件下载,多文件批量下载)
  4. 基于Java+SpringMvc+vue+element实现驾校管理系统详细设计
  5. ax200网卡支持Linux吗,Deepin 20和Win10双系统中AX200网卡不能用的请关闭快速启动
  6. jacoco入门_Android jacoco 代码覆盖率测试入门
  7. linux启动管理,Linux启动管理 详述
  8. java 双向链表_23张图!万字详解「链表」,从小白到大佬
  9. 【OpenCV 例程200篇】47. 图像增强—直方图匹配
  10. iOS里面MVC模式详解