20181130(装饰器补充,叠加多个装饰器,有参装饰器,三元表达式,生成式,匿名函数,内置函数)

Posted real-admin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了20181130(装饰器补充,叠加多个装饰器,有参装饰器,三元表达式,生成式,匿名函数,内置函数)相关的知识,希望对你有一定的参考价值。

 

一、装饰器的补充

1、函数属性的传递

Python装饰器(decorator)在实现的时候,被装饰后的函数其实已经是另外一个函数了(函数名等函数属性会发生改变),为了不影响,Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。写一个decorator的时候,最好在实现之前加上functools的wrap,它能保留原有函数的名称和docstring。
简言之:导入wraps,即可将原函数的属性(解释文本等)传递给装饰器中对应的函数。
from functools import wraps  #从 functools导入wraps
?
def outter(func):
   @wraps(func)  #相当于一个装饰器,将func的属性传递给wraps
   def wrapper(*args,**kwargs):
       res=func(*args,**kwargs)
       return res
   return wrapper
?
@outter #index=outter(index) #index=wrapper
def index():
   """
  这是index函数....
  """
   print(‘from index‘)
?
?
index()
print(index.__doc__)  #输出index的说明文档
print(index.__name__)  #输出index的名字,index是函数的内存地址
输出结果为:
from index
?
   这是index函数....
   
index
?

 

1、叠加多个装饰器

加载顺序(outter函数的调用顺序):自下而上

执行顺序(wrapper函数的执行顺序):自上而下

# 叠加多个装饰器
# 1. 加载顺序(outter函数的调用顺序):自下而上
# 2. 执行顺序(wrapper函数的执行顺序):自上而下
?
?
def outter1(func1): #func1=wrapper2的内存地址
   print(‘加载了outter1‘)
   def wrapper1(*args,**kwargs):
       print(‘执行了wrapper1‘)
       res1=func1(*args,**kwargs)
       return res1
   return wrapper1
?
def outter2(func2): #func2=wrapper3的内存地址
   print(‘加载了outter2‘)
   def wrapper2(*args,**kwargs):
       print(‘执行了wrapper2‘)
       res2=func2(*args,**kwargs)
       return res2
   return wrapper2
?
def outter3(func3): # func3=最原始的那个index的内存地址
   print(‘加载了outter3‘)
   def wrapper3(*args,**kwargs):
       print(‘执行了wrapper3‘)
       res3=func3(*args,**kwargs)
       return res3
   return wrapper3
?
?
?
@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址
@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址
@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址
def index():
   print(‘from index‘)
?
print(‘======================================================‘)
index()
输出结果为:
加载了outter3
加载了outter2
加载了outter1
======================================================
执行了wrapper1
执行了wrapper2
执行了wrapper3
from index

 

技术分享图片

 

import time
?
def timmer(func):
   def aaa(*args,**kwargs):
       start=time.time()
       res=func(*args,**kwargs)
       stop=time.time()
       print(‘run time is %s‘ %(stop -start))
       return res
   return aaa
?
def auth(func):
   def bbb(*args,**kwargs):
       name=input(‘name>>>: ‘).strip()
       pwd=input(‘pwd>>>: ‘).strip()
       if name == ‘egon‘ and pwd == ‘123‘:
           print(‘login successfull‘)
           res=func(*args,**kwargs)
           return res
       else:
           print(‘user or pwd error‘)
   return bbb
?
@auth
@timmer  #注意此处装饰器的先后顺序,调整装饰器的先后顺序,会得到不同的结果。
def index():
   time.sleep(1)
   print(‘from index‘)
?
index()

 

2、有参装饰器:三层的闭包函数

对于装饰器,三层就够了(第一层传参数,第二层传函数,第三层执行添加的功能和源代码)

import time
from functools import wraps
current_user={‘user‘:None}
?
def auth(engine=‘file‘):
   def outter(func):
       @wraps(func)
       def wrapper(*args,**kwargs):
           if current_user[‘user‘] is not None:
               res=func(*args,**kwargs)
               return res
?
           user=input(‘username>>>: ‘).strip()
           pwd=input(‘password>>>: ‘).strip()
?
           if engine == ‘file‘:
               # 基于文件的认证
               if user == ‘egon‘ and pwd == ‘123‘:
                   print(‘login successfull‘)
                   current_user[‘user‘]=user
                   res=func(*args,**kwargs)
                   return res
               else:
                   print(‘user or password error‘)
           elif engine == mysql‘:
               # 基于mysql的认证
               print(‘基于mysql的认证‘)
           elif engine == ‘ldap‘:
               # 基于ldap的认证
               print(‘基于ldap的认证‘)
           else:
               print(‘不知道engine‘)
       return wrapper
   return outter
?
@auth(‘ldap‘) #@outter #index=outter(index) # index=wrapper #注意此处传参的方法
def index():
   time.sleep(1)
   print(‘from index‘)
?
@auth(‘mysql‘) #@outter # home=outter(home) #home=wrapper #注意此处传参的方法
def home(name):
   print(‘welcome %s‘ %name)
?
index()
home(‘egon‘)
?
输出结果:
username>>>: egon
password>>>: 123
基于ldap的认证
username>>>: egon
password>>>: 123
基于mysql的认证

 

二、三元表达式

只能将if else这种简单的取代,有elif的不行。

res=‘ok‘ if False else ‘no‘  #条件成立输出左侧的值,否则输出右侧的值,可以简化if。。。else语句。
print(res)
输出结果为:
no
三、生成式

列表生成式

# l=[]
# for i in range(10):
#     if i>4:
#         l.append(i**2)
# print(l)  
上下代码功能一致
l=[i**2 for i in range(10) if i >4]  #后面不能使用else,无论是if else还是for else,可以对循环的参数进行操作
print(l)
输出结果为:
[25, 36, 49, 64, 81]
?
?
# 映射和判断
names=[‘egon‘,‘go_on‘,‘kevin‘,‘wxx‘]
print([name.upper() for name in names]) #映射关系
print([name for name in names if name.endswith(‘on‘)])  #判断关系
print([name.upper() for name in names if name.endswith(‘on‘)])  #映射叠加判断关系
输出的结果:
[‘EGON‘, ‘GO_ON‘, ‘KEVIN‘, ‘WXX‘]
[‘egon‘, ‘go_on‘]
[‘EGON‘, ‘GO_ON‘]

 

字典生成式:key和value需要有对应关系才好处理。

res={i:i**2 for i in range(10) if i > 3} #注意字典的生成格式
print(res)
?
print({i for i in ‘hello‘})  #注意此处生成的是集合!
输出结果为:
{4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
{‘e‘, ‘h‘, ‘l‘, ‘o‘}

 

四、匿名函数:匿名函数就是只定义了一个函数的内存地址,主要用于临时使用一次的场景。
a=(lambda x,y:x+y)(1,2)  #格式为“lambda 参数:表达式”后接括号内输入参数,匿名函数自带return,可以得到返回值
print(a)
输出结果为3

 

五、内置函数

1、max和min

print(max([10,11,-3,23]))  #max会从列表中先取出两个值比较,再将较大的和下一个值比较
输出结果为:
23
比较value的值,然后输出对应的key:
salaries={
   ‘egon‘:3000,
   ‘alex‘:100000000,
   ‘wupeiqi‘:10000,
   ‘yuanhao‘:2000
}
?
def func(k):
   return salaries[k]
?
print(max(salaries,key=lambda k:salaries[k]))  #此处第一个salaries是一个序列,其中的元素会被遍历,作为参数k进行函数的运算,不理解的话看下面
print(min(salaries,key=func))  #其实没有必要做成有名函数,匿名函数就可以了。
# for循环的结果         比较依据
# ‘egon‘               3000
# ‘alex‘               100000000
# ‘wupeiqi‘             10000
# ‘yuanhao‘             2000
输出结果为:
alex
yuanhao
?
max的解释:
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
字典是可迭代的,结果为key值,
salaries={
   ‘egon‘:3000,
   ‘alex‘:100000000,
   ‘wupeiqi‘:10000,
   ‘yuanhao‘:2000
}
?
l=list(salaries)
print(l)
输出结果为:
[‘egon‘, ‘alex‘, ‘wupeiqi‘, ‘yuanhao‘]
?
res=max((1,2),[1,1],key = lambda x : x[1])
print(res)
输出结果为:
(1, 2)

sorted函数:

def sorted(*args, **kwargs): # real signature unknown
  """
  Return a new list containing all items from the iterable in ascending order.
   
  A custom key function can be supplied to customize the sort order, and the
  reverse flag can be set to request the result in descending order.
  """
   
以升序返回包含iterable中所有项的新列表。
可以提供自定义键功能来自定义排序顺序,以及可以设置反向标志以按降序请求结果。

 

匿名函数与其他函数的结合应用:

salaries={
   ‘egon‘:3000,
   ‘alex‘:100000000,
   ‘wupeiqi‘:10000,
   ‘yuanhao‘:2000
}
print(sorted(salaries,key=lambda k:salaries[k],reverse=True)) #字典中的key变成序列作为参数传入后面的匿名函数,由升序改为降序排列。
输出结果为:
[‘alex‘, ‘wupeiqi‘, ‘egon‘, ‘yuanhao‘]

 

 

 

以上是关于20181130(装饰器补充,叠加多个装饰器,有参装饰器,三元表达式,生成式,匿名函数,内置函数)的主要内容,如果未能解决你的问题,请参考以下文章

Python记录11:叠加多个装饰器+有参装饰器

叠加装饰器与迭代器

叠加多个装饰器

python之有参装饰器_02

第十三天 叠加多个装饰器 迭代器 生成器

叠加装饰器迭代器