"""
1.匿名函数的关键字为 lambda 冒号前面是形参 冒号后面是返回值
"""
info = [
# 商品名称 商品数量 商品价格
('apple1', 200, 32),
('apple4', 40, 12),
('apple3', 40, 2),
('apple2', 1000, 23)
]
print(sorted(info))
# 按照商品数量进行排序
# print(sorted(info,key=lambda x:x[1]))
# # 按照商品价格进行排序
# print(sorted(info,key=lambda x:x[2]))
# print(sorted(info,key=lambda x:(x[1],x[2])))
from operator import itemgetter
# 按照商品数量进行排序
print(sorted(info,key=itemgetter(1)))
print(sorted(info,key=itemgetter(2)))
print(sorted(info,key=itemgetter(1,2)))
"""
奇偶数排序
# 问题描述： 有一个整数列表(10个元素)， 要求调整元素顺序，
# 把所有的奇数放在前面， 偶数放在后面，
"""
装饰器：
把一个函数当作参数，返回一个替代版的函数
本质上就是一个返回函数的函数
"在不改变原函数的基础上，给函数增加功能"
装饰器的对象
def desc(fun): # 需要传递一个函数，要装饰的函数
def add_info(): # 装饰器函数里要嵌套函数
print('元旦快乐～')
fun()
#print('欢迎光临西部开源～')
return add_info # 返回值是嵌套的函数对象
@desc # 如何调用装饰器(两种方式)
def logout():
print('logout...')
logout()
def login():
print('login....')
login = desc(login) # 返回值是一个函数
login()
"""
装饰器实现一个计时器
# 创建装饰器， 要求如下：
# 1.装饰器实现一个计时器
# 2. 装饰器， 被装饰的函数打印日志信息；
# 3. 日志格式为: [字符串时间] 函数名: xxx， 运行时间：xxx, 运行返回值结果:xxx
"""
import random
import time
import string
import functools
# 问题1：装饰的函数有返回值
# 问题2：如何保留被装饰函数的函数名和帮助信息文档
li = [random.choice(string.ascii_letters + string.digits) for i in range(100)]
def beautiful(user):
def timeit(fun):
"""这是装饰器timeit"""
@functools.wraps(fun) # 显示被装饰函数的函数名和帮助信息文档
def inner(*args, **kwargs): # 接收可变参数和关键字参数
"""这是inner函数"""
# print('函数名：%s'%fun)
# args:元组 kwargs:字典
# 在函数执行之前
start_time = time.time()
# 执行函数
res = fun(*args, **kwargs)
# 函数执行之后
stop_time = time.time()
# print('运行的时间为：%.6f'%(stop_time-start_time))
print('<%s>\t[%s]\t函数名：%s \t运行的时间为：%.6f\t 运行的返回值结果:%s' % (
user, time.ctime(), fun.__name__, stop_time - start_time, res))
return res
return inner
return timeit
@beautiful('kiosk')
def sum_num():
s = ''
for i in li:
s += (i + ',')
return s
@beautiful('root')
def sum_num_join():
return ','.join(li)
@beautiful('westos')
def fun_v(n): # 添加函数帮助信息文档
"""这是fun_v函数，被timeit装饰"""
return [i * 2 for i in range(n)]
@beautiful('redhat')
def fun_map(n):
return list(map(lambda x: x * 2, range(n)))
sum_num()
sum_num_join()
fun_v(50)
fun_map(50)
print(fun_v.__doc__) # 查看被装饰的函数信息文档
print(fun_v.__name__) # 查看被装饰函数的名称
"""
当有多个装饰器的时候，从下到上调用
真实的warpper内容是从上到下执行的
"""
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
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
def decorator_c(fun):
print('Get in decorator_c')
def inner_c(*args, **kwargs):
print('Get in inner_c')
return fun(*args, **kwargs)
return inner_c
# 外壳从下到上，装饰从上到下
@decorator_a
@decorator_b
@decorator_c
def f(x):
print('Get in f')
return x * 2
print(f(3))
"""
['root','admin','redhat']
在实际的应用场景中，会采用多个装饰器先验证是否登陆成功，再验证权限是否足够
"""
import functools
import inspect
def is_admin(fun):
@functools.wraps(fun)
def inner(*args,**kwargs):
# inspect.getcallargs返回一个字典，key值：形参 value值：对应的实参
res = inspect.getcallargs(fun,*args,**kwargs)
if res.get('name')=='root':
ret = fun(*args,**kwargs)
return ret
else:
print('you have no perssion')
return inner
def is_login(fun):
@functools.wraps(fun)
def wrpper(*args,**kwargs):
if args[0] in li:
#你的输入永远在第0个索引，查看是否在列表里
ret = fun(*args,**kwargs)
return ret
else:
print('Not have this user')
return wrpper
@is_login#先查看是否存在该用户
@is_admin#再判断是否拥有超级权限
def user_add(name):
print('welcome !')
li = ['root','westos','redhat']
user_add('root')
user_add('haha')
user_add('westos')
编写装饰器required_ints, 条件如下:
# 1). 确保函数接收到的每一个参数都是整数;
# 2). 如果参数不是整形数， 打印 TypeError:参数必须为整形
import functools
def required_ints(fun):
@functools.wraps(fun)
def inner(*args,**kwargs):
for i in args:
if not isinstance(i,int):#判断是否为整形
print('TypeError:参数必须是整型')
return
else:
ret = fun(*args,**kwargs)
return ret
return inner
@required_ints
def repuired(*args,**kwargs):
print('参数正确')
repuired(3,3,4,5,5.5)
repuired(3,3,4,5,5)
给装饰器加上参数，即为3个def
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))
# 编写装饰器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(*types):
# if types == 'int,float':
def required_int(fun):
@functools.wraps(fun)
def reqired_inner(*args, **kwargs):
for i in args:
if not isinstance(i, (types)): # 返回的types是元组格式，须转换非元组格式
print('TypeError:参数必须是%s' % (str(types)))
return
else:
res = fun(*args, **kwargs)
return res
return reqired_inner
return required_int
@required_types(float, int)
def required_input(*args, **kwargs):
print('参数正确')
required_input('d', 'h', 7)
required_input(2, 3, 4.5)
@required_types(list)
def required_input_2(*args, **kwargs):
print('参数正确')
required_input_2([1, 2, 3])
required_input_2(1, 2, 3)
@required_types(str, int)
def required_input_3(*args, **kwargs):
print('参数正确')
required_input_3('westos', 3, 4)
required_input_3('westos', 3, 4.0)
