装饰器可以使函数执行前和执行后分别执行其他的附加功能,这种在代码运行期间动态增加功能的方式,称之为"装饰器"(Decorator),装饰器的功能非常强大,装饰器一般接受一个函数对象作为参数,以对其进行增强,相当于C++中的构造函数,与析构函数.
装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象.它经常用于有迫切需求的场景,比如：插入日志、性能测试、事务处理、缓存、权限校验等场景.装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用.
◆无参装饰器◆总而言之,装饰器具有如下几个特点:
● 装饰器本身也是一个函数,其作用是,用于装饰其他函数.
● 装饰器是一个闭包函数是嵌套函数,通过外层函数提供嵌套函数的环境
● 装饰器在权限控制,增加额外功能,如增加记录日志,缓存处理,发送邮件用的比较多
原函数中不带参数的装饰器,如下例子假设：我定义了一个函数lyshark(),现在想要在不改变原来函数定义的情况下,在函数运行前打印一段话,函数运行后打印另一段话,此时我们可以使用装饰器的装饰功能来简单的实现这个需求.
>>> import os>>> import sys>>> >>> def outer(function): def inner(): print("主函数开始执行前,会先执行我!") result=function() print("主函数执行结束后,要在执行我!") return result return inner# (1) @ + 函数名,直接作用在需要装饰的函数上一行# (2) 自动执行outer函数并且将下面的函数名lyshark()当做参数传递到outer()# (3) 将outer函数的返回值inner,重新赋值给lyshark()函数>>> @outerdef lyshark(): print("lyshark 的主函数体,装饰器在装饰我(*^_^*)") return "check ok"#==调用并执行函数,结果如下==========================================>>> ret=lyshark()主函数开始执行前,会先执行我!lyshark 的主函数体,装饰器在装饰我(*^_^*)主函数执行结束后,要在执行我!>>> print("lyshark()函数的返回值: ",ret)lyshark()函数的返回值: check◆有参装饰器◆如上代码的执行流程是这样的,步骤如下:
1.当我们调用lyshark()函数时,会自动检查lyshark()函数上是否有装饰器
2.如果有则将lyshark()函数的指针,传递给装饰器outer(function)
3.outer(function)接到指针后,执行嵌套函数内的inner(),则先执行print打印一段话
4.由于lyshark()函数指针,传递给了function变量,执行function()则相当于执行lyshark()
5.紧接着,最后一步执行打印一段结束的话,并执行返回,返回inner
原函数带一个参数的装饰器: 我们在以上的案例中,给装饰器添加一个参数,并在内部使用这个参数.
>>> import os>>> import sys>>> >>> def outer(function): def inner(args): print("主函数开始执行前,会先执行我!") ret=function(args) print("主函数执行结束后,要在执行我!") return ret return inner>>> @outerdef lyshark(args): print(args) return 0#==调用并执行函数,结果如下==========================================>>> ret=lyshark("Hello World!")主函数开始执行前,会先执行我!Hello World!主函数执行结束后,要在执行我!>>> print("lyshark 的返回值是：",ret)lyshark() 函数的返回值是： 0原函数带两个参数的装饰器: 接下来继续演示一下,带有两个参数的装饰器,3个4个,以此类推.
>>> import os>>> import sys>>> >>> >>> def outer(function): def inner(x,y): print("主函数开始执行前,会先执行我!") ret=function(x,y) print("主函数执行结束后,要在执行我!") return ret return inner>>> @outerdef lyshark(x,y): print(x,y) return 0#==调用并执行函数,结果如下==========================================>>> ret=lyshark("Hello","LyShark")主函数开始执行前,会先执行我!Hello LyShark主函数执行结束后,要在执行我!>>> print("lyshark() 函数的返回值是：",ret)lyshark() 函数的返回值是： 0传递一个万能参数: 装饰器也可传递一个万能参数,通过此参数传递列表字典等.
>>> import os>>> import sys>>> >>> def outer(function): def inner(*args,**kwargs): print("主函数开始执行前,会先执行我!") ret=function(*args,**kwargs) print("主函数执行结束后,要在执行我!") return ret return inner>>> @outerdef lyshark(*args): print(args) return 0#==调用并执行函数,结果如下==========================================>>> num=[1,2,3,4,5]>>> ret=lyshark(num)主函数开始执行前,会先执行我!([1,5],)主函数执行结束后,要在执行我!>>> >>> print("lyshark() 函数的返回值是：",ret)lyshark() 函数的返回值是： 0#==调用并执行函数,结果如下==========================================@outerdef lyshark_kw(*args,**kwargs): print(args,kwargs) return 0num=[1,5]kw={"1001":"admin","1002":"guest"}ret=lyshark_kw(num,kw)一次使用两个装饰器装饰函数: 如果一个装饰器不够用的话,我们可以使用两个装饰器,首先将函数与内层装饰器结合然后在与外层装饰器相结合,要理解使用@语法的时候到底执行了什么,是理解装饰器的关键.
>>> import os>>> import sys>>> >>> def outer2(function2): def inner2(*args,**kwargs): print("装饰器2--->【开始】") ret=function2(*args,**kwargs) print("装饰器2--->【结束】") return ret return inner2>>> def outer1(function1): def inner1(*args,**kwargs): print("装饰器1--->【开始】") ret=function1(*args,**kwargs) print("装饰器1--->【结束】") return ret return inner1@outer2@outer1def lyshark(): print("lyshark 函数被执行了")#==调用并执行函数,结果如下==========================================>>> lyshark()装饰器2--->【开始】装饰器1--->【开始】lyshark 函数执行了装饰器1--->【结束】装饰器2--->【结束】#==调用并执行函数,结果如下==========================================@outer1@outer2def lyshark_and(): print("lyshark_and 函数被执行了")>>> lyshark_and()装饰器1--->【开始】装饰器2--->【开始】lyshark_and 函数执行了装饰器2--->【结束】装饰器1--->【结束】前面的装饰器本身没有带参数,如果要写一个带参数的装饰器怎么办,那么我们就需要写一个三层的装饰器,而且前面写的装饰器都不太规范,下面来写一个比较规范带参数的装饰器,下面来看一下代码,大家可以将下面的代码自我运行一下.
给装饰器本身添加参数: 接下来我们将给装饰器本身添加一些参数,使其能够实现参数传递.
>>> import functools>>> import sys>>> >>> def lyshark(temp=""): #指定装饰器默认参数 def decorator(function): #定义装饰器 @functools.wraps(function) #使被装饰的装饰器的函数名不改变 def wrapper(*args,**kwargs): print("主函数开始执行前,会先执行我!") print("{}:{}".format(temp,function.__name__)) #这里调用了装饰器temp变量 ret=function(*args,**kwargs) print("主函数执行结束后,要在执行我!") return ret return wrapper return decorator#==调用并执行函数,结果如下==========================================>>> #如果不给装饰器加参数,那么这个装饰器将使用默认参数 temp="",来填充>>> @lyshark()def test(x): print(x+100)>>> test(100)主函数开始执行前,会先执行我!:test #这里由于没有传递参数则第一项为空,第二项是函数名称`function.__name__`取出的主函数执行结束后,要在执行我!#==调用并执行函数,结果如下==========================================>>> #下面是给装饰器一个参数,将不是用默认参数 temp="",将变成 temp="LyShark">>> @lyshark("LyShark")def test(x): print(x+100)>>> test(100)主函数开始执行前,会先执行我!LyShark:test主函数执行结束后,要在执行我!给装饰器本身添加参数: 接下来我们将给装饰器本身添加两个参数,使其能够传递多个参数.
>>> import sys>>> import os>>> >>> def lyshark(x="Hello",y="LyShark"): def decorator(function): def wrapper(): print("主函数执行前,应先执行我！") print(x,y) ret=function() print("主函数执行后,要执行我！") return ret return wrapper return decorator#==调用并执行函数,结果如下==========================================>>> #使用默认参数的装饰器:此时 x="Hello" y="LyShark">>> @lyshark()def test(): print("我是test(),主函数,装饰器在装饰我")>>> test()主函数执行前,应先执行我！Hello LyShark我是test(),装饰器在装饰我主函数执行后,要执行我！#==调用并执行函数,结果如下==========================================>>> #给装饰器指定参数:此时 x="My name Is :" y="LyShark">>> @lyshark("My name Is :","LyShark")def test(): print("我是test(),主函数，装饰器在装饰我")>>> test()主函数执行前,应先执行我！My name Is : LyShark我是test(),要执行我！测试程序执行时间: 通过使用装饰器,给一个已存在的函数,测试函数的执行时间.
import osimport sysimport timedef showtime(func): def main(): start_time=time.time() func() end_time=time.time() print("程序运行了: %s"%(end_time-start_time)) return main#==调用并执行函数,结果如下==========================================@showtimedef timer(): time.sleep(3) print("执行程序结束....")timer()记录登陆状态(1): 使用装饰器记录登陆状态,下次自动登录.
import osimport sysuser_info={}user_name="admin"pass_word="1233"def check_login(func): def main(): if((user_info.get("is_login",None) ==True) and (user_info.get("is_type",None)==0)): print("你已经登陆过了,不能重复登陆!") func() else: print("你没有登陆,请先登录,在进行此 *** 作") return maindef login(): username=input("输入用户名:").strip() password=input("输入密码:").strip() if username==user_name and password==pass_word: user_info["is_login"]=True user_info["is_type"]=0 print("你好: "+username+"登陆成功,登录状态已被记录") elif username!="" and password!="": print("您输入的用户名,或者密码不正确,请重新输入") else: print("您没有输入任何内容,错误")@check_logindef home(): print("用户登录成功，显示这个函数中的内容.")def main(): while True: temp=input("1.登陆 2.查询状态\n") if(temp=="1"): login() elif(temp=="2"): home() else: continuemain()记录登陆状态(2): 使用装饰器记录登陆状态,下次自动登录.
USER_INFO = {}def check_login(func): def inner(*args,**kwargs): if USER_INFO.get('is_login',None): ret = func() return ret else: print("请登录") return innerdef check_admin(func): def inner(*args,**kwargs): if USER_INFO.get('user_type',None) == 2: ret = func() return ret else: print("无权限查看") return inner@check_login #先检查你是不是登陆了@check_admin #在检查你是不是管理员def index(): """ 管理员用户 """ print('index')@check_logindef home(): """ 普通用户 """ print('home')def login(): user = input("请输入用户名:") if user == 'admin': USER_INFO['is_login'] = True USER_INFO['user_type'] = 2 else: USER_INFO['is_login'] = True USER_INFO['user_type'] = 1def main(): while True: inp = input('1、登录;2、查看信息;3、超级管理员管理\n>:') if inp == '1': login() elif inp == '2': home() elif inp == '3': index()main()Python 生成器
通过列表生成式,我们可以直接创建一个列表.但是,受到内存限制,列表容量肯定是有限的,而且创建一个包含100万个元素的列表,不仅占用很大的存储空间,还会造成大量空间的白白浪费,如果列表元素可以按照某种算法推算出来,这样我们就不必创建完整的List,从而节省大量的空间.在Python中,这种一边循环一边计算的机制,称为生成器(Generator).
生成器是一个特殊的程序,可以被用作控制循环的迭代行为,Python中生成器是迭代器的一种,使用yIEld返回值函数,每次调用yIEld会暂停,而可以使用next()函数和send()函数恢复生成器.
生成器类似于返回值为数组的一个函数,这个函数可以接受参数,可以被调用,但不同于一般的函数会一次性返回包括了所有数值的数组,生成器一次只能产生一个值,这样消耗的内存数量将大大减小,而且允许调用函数可以很快的处理前几个返回值,因此生成器看起来像是一个函数,但是表现得却像是迭代器.
生成器的注意事项,和相关的特性:
● 当我们调用一个生成器函数时,其实返回的是一个迭代器对象
● 在Python语言中,只要表达式中使用了,yIEld函数,通常将此类函数称为生成器(generator)
● 运行生成器时,每次遇到yIEld函数,则会自动保存并暂停执行,直到使用next()方法时,才会继续迭代
● 跟普通函数不同,生成器是一个返回迭代器的函数,只能用于迭代 *** 作,更简单点理解生成器就是一个迭代器
在学习生成器之前,我们先来看一下以下两种情况的对比,第一种方法很简单,只有把一个列表生成式的[]中括号改为()小括号,就创建了一个生成器.
>>> lis = [x*x for x in range(10)]>>> print(lis)[0,1,9,16,25,36,49,64,81]>>> generator = (x*x for x in range(10))>>> print(generator)<generator object <genexpr> at 0x0000022E5C788A98>如上的例子,第一个lis通过列表生成式,创建了一个列表,而第二个generator则打印出一个内存地址,如果我们想获取到第二个变量中的数据,则需要迭代 *** 作,如下所示:
>>> generator = (x*x for x in range(10))>>> print(next(generator))0>>> print(next(generator))1>>> print(next(generator))4>>> print(next(generator))9以上可以看到,generator保存的是算法,每次调用next(generaotr),就计算出他的下一个元素的值,直到计算出最后一个元素,使用for循环可以简便的遍历出迭代器中的数据,因为generator也是可迭代对象.
>>> generator = (x*x for x in range(10))>>> >>> for i in generator: print(i,end="")0149162536496481实例(1): 通过函数,和yIEld关键字,生成几个生成器.
>>> import sys>>> >>> def func(): yIEld 1 yIEld 2 yIEld 3 yIEld 4 yIEld 5>>> temp=func()>>> temp.__next__()1>>> temp.__next__()2>>> temp.__next__()3实例(2): 使用while循环构建一个生成器,并通过for遍历打印出结果.
>>> import sys>>> >>> def yIEldNum(x): y=0 while (y <= x): yIEld y y += 1 >>> yIE=yIEldNum(5)>>> for i in yIE: print(i)012345实例(3): 使用生成器求1-10的平方.
>>> def yIEldNum(): x=1 while (x <=10 ): yIEld x ** 2 x += 1>>> yIE=yIEldNum()>>> >>> for i in yIE: print(i)4163664100实例(4): 使用生成器,自定义实现range函数.
>>> def xrange(num): temp=-1 while True: temp=temp+1 if (temp >= num): return else: yIEld temp>>> xrange(10)<generator object xrange at 0x038E3030>实例(5): 通过使用生成器求斐波那契数列.
>>> def fib(max): n,a,b=0,1 while n < max: yIEld b a,b=b,a+b n+=1 return "done">>> f=fib(5)>>> f<generator object fib at 0x038F4A20>实例(6): 使用生成器,在单个进程情况下实现并发效果.
import timedef consumer(name): print("%s 准备吃包子啦!" %name) while True: baozi = yIEld print("包子[%s]来了,被[%s]吃了!" %(baozi,name)) def producer(name): c = consumer('A') c2 = consumer('B') c.__next__() c2.__next__() print("老子开始准备做包子啦!") for i in range(10): time.sleep(1) print("做了2个包子!") c.send(i) c2.send(i) producer("alex")列表解析是Python迭代机制的一种应用,它常用于实现创建新的列表,因此要放置于[]中,列表解析非常灵活,可以用户快速创建一组相应规则的列表元素,且支持迭代 *** 作.
求阶乘: 通过列表解析式,来实现列表的迭代求阶乘.
>>> temp1 = [1,5]>>> temp2 = [ x ** 2 for x in temp1 ]>>> temp1[1,5]>>> temp2[1,25]求阶乘: 通过列表解析式,实现迭代求阶乘,并且只打印大于2(if x>=2)的数据.
>>> temp1 = [1,5]>>> temp2 = [ x**2 for x in temp if x>=2 ]>>> temp1[1,5]>>> temp2[4,并通过range函数生成相关数据.>>> temp = [ (x**2)/2 for x in range(1,10)]>>> temp[0.5,2.0,4.5,8.0,12.5,18.0,24.5,32.0,40.5]
数据合并: 通过列表解析式,实现迭代将两个列表按照规律合并.
>>> temp1=["x","y","z"]>>> temp2=[1,3]>>> temp3=[ (i,j) for i in temp1 for j in temp2 ]>>> temp3[('x',1),('x',2),3),('y',('z',3)]
文件过滤: 通过使用列表解析,实现文本的过滤 *** 作.
>>> import os>>> file_List=os.Listdir("/var/log")>>> file_log=[ i for i in file_List if i.endswith(".log") ]>>> print(file_log)['boot.log','yum.log','ecs_network_optimization.log','ntp.log']>>> file_log=[ i for i in os.Listdir("/var/log") if i.endswith(".log") ]>>> print(file_log)['boot.log','ntp.log']
◆生成器表达式◆生成器表达式并不真正创建数字列表,而是返回一个生成器对象,此对象在每次计算出一个条目后,把这个条目"产生"(yIEld)出来,生成器表达式使用了"惰性计算"或称作"延迟求值"的机制序列过长,并且每次只需要获取一个元素时,应当考虑使用生成器表达式而不是列表解析.
>>> import sys>>> >>> yIE=( i**2 for i in range(1,10) )>>> next(yIE)1>>> next(yIE)4>>> next(yIE)9
>>> for j in ( i**2 for i in range(1,10)):print(j/2)... 0.52.04.58.012.518.024.532.040.5
Python 迭代器迭代器是访问集合元素的一种方式,迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束.迭代器只能往前不会后退,不过这也没什么,因为人们很少在迭代途中往后退.另外,迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素.迭代器仅仅在迭代到某个元素时才计算该元素,而在这之前或之后,元素可以不存在或者被销毁.这个特点使得它特别适合用于遍历一些巨大的或是无限的集合,比如几个G文件的遍历.
关于迭代器的几个特性:
● 迭代器是一个可以记住遍历的位置的对象
● 字符串,列表或元组对象都可用于创建迭代器
● 迭代器有两个基本的方法：iter()和next()
● 迭代器便于循环比较大的数据集合,节省了内存开支
● 迭代是Python最强大的功能之一,是访问集合元素的一种方式
● next()就相当于调用__next__(),for也是iterable(可迭代)对象
● 访问者不需要关心迭代器内部的结构,仅需通过next()方法不断去取下一个内容
● 迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束.迭代器只能往前不会后退
实例(1): 迭代器的基本用法1.
>>> import sys>>> >>> temp=iter([1,5,6,7,8,9])>>> temp<List_iterator object at 0x03BD1F90>>>> temp.__next__()1>>> temp.__next__()2>>> temp.__next__()3
实例(2): 迭代器的基本用法2.
>>> import sys>>> >>> temp=[1,5]>>> ite=temp.__iter__()>>> print(type(temp),type(ite))<class 'List'> <class 'List_iterator'>>>> next(ite)1>>> >>> next(ite)2>>> next(ite)3>>> next(ite)4
实例(3): 通过while语句遍历迭代对象.
>>> ite=iter([1,5])>>> >>> while True: try: temp=next(ite) print(temp) except stopiteration: break12345
总结 以上是内存溢出为你收集整理的Python 装饰&生成&迭代器全部内容，希望文章能够帮你解决Python 装饰&生成&迭代器所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）