匿名函数与装饰器

匿名函数的用法

当简单的函数如果太多，写起来相当麻烦，这时可以用匿名函数来代替

from functools import reduce
def fun(*args,**kwargs):

return args,kwargs

print(fun([1,2,3,4,5]))
print(lambda *args,**kwargs:(args,kwargs))
print(reduce(lambda x,y:x+y,[1,2,3,4,5]))

三种print结果对比：

匿名函数的排序应用

info=[
#名称，数量，价格
(‘apple1’,200,32),
(‘apple4’,40,12),
(‘apple3’,40,2),
(‘apple2’,100,23)
]
#通过数量用sorted排序
print(sorted(info,key=lambda x:x[1]))
#通过价格排序
print(sorted(info,key=lambda x:x[1]))
#通过数量与价格双重排序，用数量排序，数量一致，用价格排序
print(sorted(info,key=lambda x:(x[1],x[2])))

另一种高级用法

#itemgetter是一个帮助我们排序的模块

from operator import itemgetter
print(sorted(info,key=itemgetter(1)))
print(sorted(info,key=itemgetter(1,2)))

把一个整数列表（10个元素），要求调整元素顺序，把所有的奇数放在前面，偶数放在后面

import random
a=[random.randint(1,100) for i in range(10)]
#print(a)
print(list(filter(lambda x:x%2!=0,a))+list(filter(lambda x:x%2==0,a)))

装饰器

把一个函数当作参数，返回一个代替版的函数
本质上就是一个返回是函数的函数

作用：在不改变原函数的基础上来给原函数增加功能

#原函数
def fun(age):

print(‘he is %s years old’ %(age))

#装饰器
def outer(func):

def inner(age):

if age<0:

age=0

func(age)

return inner

fun = outer(fun)
fun(-10)

#装饰器
def outer(func):

def inner(age):

if age < 0:

age=0

func(age)

return inner

#语法糖，其功能等同于fun = outer(fun)
#使用@符号将装饰器应用到函数上
@outer

#原函数
def fun(age):

print(‘he is %s years old’ %(age))

fun(-10)

写一个计算函数运行时间的装饰器

import time
import string
import random
li=[random.choice(string.ascii_letters) for i in range(20)]
#运行时间的装饰器
def timeit(func):

def inner(*args,**kwargs):

time_front=time.time()
func()
time_after=time.time()
print(time_after-time_front)

return inner

#语法糖
@timeit
#原函数1
def a1():

a=’’
for i in li:

a+=(i+’,’)

return a

@timeit
#原函数2
def a2():

‘,’.join(li)
return li

#运行
a1()
a2()

装饰器实现一个计时器

装饰器实现一个计时器

import time
import string
import random
import functools
li = [random.choice(string.ascii_letters) for i in range(100)]
#问题1：装饰的函数有返回值
#问题2：如何保留被装饰函数的函数名和帮助信息文档
def timeit(fun):

“”“这是一个装饰器timeit”""
@functools.wraps(fun) #可以保留被装饰函数的函数名和帮助信息文档
def wrapper(*args, **kwargs): # 接收可变参数和关键字参数

“”“这是一个wrapper函数”""
#args:元组 kwargs:字典
#在函数执行之前
start_time = time.time()
#执行函数
res = fun(*args, **kwargs)
#函数执行之后
end_time = time.time()
print(‘运行时间为:%.6f’ % (end_time - start_time))
return res

return wrapper

@timeit
def con_add():

s = ‘’
for i in li:

s += (i + ‘,’)

print(s)

@timeit
def join_add():

print(’,’.join(li))

@timeit
def fun_list(n):

“”“这是fun_list函数，被timeis装饰”""
return [2 * i for i in range(n)]

@timeit
def fun_map(n):

“”“这是fun_map函数，被timeis装饰”""
return map(lambda x:x*2,range(n))

def fun():

“”“这是fun函数”""
print(‘hello’)

con_add()
join_add()
print(fun_list(100))
print(fun_map(100))
print(fun.doc)
print(fun.name)
print(fun_list.doc)
print(fun_map.doc)
print(fun_list.name)
print(fun_map.name)

设计装饰器来判断用户是否为管理员

import functools
import inspect
def is_admin(fun):

@functools.wraps(fun)
def wrapper(*args, **kwargs):

#inspect.getcallargs返回一个字典，key值：形参 value值：对应的实参
inspect_res = inspect.getcallargs(fun, *args, **kwargs)
print(‘inspect的返回值:%s’ %(inspect_res))
if inspect_res.get(‘name’) == ‘root’:

temp = fun(*args,**kwargs)
return temp

else:

print(‘not root user,no permisson add stduent’)

return wrapper

@is_admin
def add_student(name):

print(‘添加学生信息～’)

@is_admin
def del_student(name):

print(‘删除学生信息～’)

add_student(‘linux’)
del_student(‘root’)

结果展示：

装饰器练习1

#创建装饰器， 要求如下：
#1. 创建add_log装饰器， 被装饰的函数打印日志信息；
#2. 日志格式为: [字符串时间] 函数名: xxx， 运行时间：xxx, 运行返回值结果:xxx

import functools
import time
def add_log(fun):

@functools.wraps(fun)
def wrapper(*args,**kwargs):

start_time = time.time()
res = fun(*args,**kwargs)
end_time = time.time()
print(’[%s] 函数名:%s,运行时间:%.5f,运行返回值结果:%d’ %(time.ctime(),fun.name,end_time-start_time,res))
return res

return wrapper

@add_log
def add(x,y):

time.sleep(1)
return x+y

add(1,10)

结果展示：

多个装饰器调用与执行顺序

#装饰器1
def decorator_a(fun):

print(‘Get in decorator_a’)
def inner_a(*args,**kwargs):

print(‘Get in inner_a’)
return fun(*args,**kwargs)

return inner_a

#装饰器2
def decorator_b(fun):

print(‘Get in decorator_b’)
def inner_b(*args,**kwargs):

print(‘Get in inner_b’)
return fun(*args,**kwargs)

return inner_b

“”"
当有多个装饰器的时候，从下到上调用
真实的warpper内容是从上到下执行的
“”"
@decorator_b
@decorator_a
def f(x):

print(‘Gat in f’)
return x * 2

f(1)

调用与执行顺序：

完整的登录以及权限认证系统

[‘root’,‘admin’,‘redhat’]
在实际的应用场景中，会采用多个装饰器先验证是否登陆成功，再验证权限是否足够

import functools
import inspect
def is_admin(fun):

@functools.wraps(fun)
def wrapper(*args, **kwargs):

#inspect.getcallargs返回一个字典，key值：形参 value值：对应的实参
inspect_res = inspect.getcallargs(fun, *args, **kwargs)
print(‘inspect的返回值:%s’ %(inspect_res))
if inspect_res.get(‘name’) == ‘root’:

temp = fun(*args,**kwargs)
return temp

else:

print(‘not root user,no permisson add stduent’)

return wrapper

login_session = [‘root’,‘admin’,‘redhat’]
def is_login(fun):

@functools.wraps(fun)
def wrapper(*args,**kwargs):

if args[0] in login_session:

temp = fun(*args,**kwargs)
return temp

else:

print(‘Error:%s未登陆！’ %(args[0]))

return wrapper

@is_login
@is_admin
def add_student(name):

print(‘添加学生信息～’)

add_student(‘admin’)

结果展示：

装饰器练习2

编写装饰器required_ints, 条件如下:
#1). 确保函数接收到的每一个参数都是整数;
#2). 如果参数不是整形数， 打印 TypeError:参数必须为整形

import functools
def isint(func):

@functools.wraps(func)
def inner(*args,**kwargs):

for i in args:

if isinstance(i,int):

continue

else:

print(‘TYPEERROR’)
exit()

res = func(*args, **kwargs)
print(res)
return res

return inner

@isint
def main(a,b):

return a+b

main(1,2)
main(1,‘2’)

结果展示：

装饰器练习3

制作一个装饰器，在函数运行结束时，输出该函数的运行时间，函数名以及返回值结果

import functools
import time
def log(kind): # kind = ‘local1’

def add_log(fun):

@functools.wraps(fun)
def wrapper(*args,**kwargs):

start_time = time.time()
res = fun(*args,**kwargs)
end_time = time.time()
print(’<%s> [%s] 函数名:%s,运行时间:%.5f,运行返回值结果:%d’ %(kind,time.ctime(),fun.name,end_time-start_time,res))
return res

return wrapper

return add_log

@log(‘local1’)
#log(‘local1’)===>返回值：add_log
#add = add_log(add)
def add(x,y):

time.sleep(1)
return x+y

print(add(1,2))

结果展示：

装饰器练习4

编写装饰器required_types, 条件如下:
1). 当装饰器为@required_types(int,float)确保函数接收到的每一个参数都是int或者float类型;
2). 当装饰器为@required_types(list)确保函数接收到的每一个参数都是list类型;
3). 当装饰器为@required_types(str,int)确保函数接收到的每一个参数都是str或者int类型;
4). 如果参数不满足条件， 打印 TypeError:参数必须为xxxx类型

import functools
def required_types(*type):

def required(func):

@functools.wraps(func)
def inner(*args,**kwargs):

for i in args:

if isinstance(i,type):

continue

else:

print(‘TypeError:参数必须为%s类型’ %([i for i in type]))
exit()

res=func(*args,**kwargs)
print(res)
return res

return inner

return required

@required_types(str,int)
def f(*args):

return args

f(‘q’,1.2)

结果展示：