1.20 python----sort方法，匿名函数（lambda），生成校验码，装饰器

1、sort的方法和函数：正向排序，反向排序

1）方法

li = [5,3,2,4]
li.sort(reverse=True)
print(li)

[5, 4, 3, 2]

2）函数

li = [5, 3, 2, 4]
a = sorted(li, reverse=True)
print(a)

[5, 4, 3, 2]

3）按照不同的key值排序

例子：按照不同的商品名称 商品数量 商品价格排序

info = {
    # 商品名称  商品数量  商品价格
    ('apple1', 200, 32),
    ('apple2', 40, 12),
    ('apple3', 40, 2),
    ('apple4', 1000, 23),
    ('apple5', 40, 5),
}

print(sorted(info))


# 按照商品数量进行排序：
def sorted_by_count(x):
    return x[1]


def sorted_by_price(x):
    return x[2]


def sorted_by_count_price(x): ##先按照数量排序，如果一样按照价格排序
    return x[1], x[2]


print(sorted(info, key=sorted_by_count))
print(sorted(info, key=sorted_by_price))
print(sorted(info, key=sorted_by_count_price))

实验结果：

[('apple1', 200, 32), ('apple2', 40, 12), ('apple3', 40, 2), ('apple4', 1000, 23), ('apple5', 40, 5)]
[('apple2', 40, 12), ('apple3', 40, 2), ('apple5', 40, 5), ('apple1', 200, 32), ('apple4', 1000, 23)]
[('apple3', 40, 2), ('apple5', 40, 5), ('apple2', 40, 12), ('apple4', 1000, 23), ('apple1', 200, 32)]
[('apple3', 40, 2), ('apple5', 40, 5), ('apple2', 40, 12), ('apple1', 200, 32), ('apple4', 1000, 23)]

练习：

(2018-携程-春招题)题目需求:
给定一个整形数组， 将数组中所有的0移动到末尾， 非0项保持不变；
在原始数组上进行移动操作， 勿创建新的数组;
# 输入:
    第一行是数组长度， 后续每一行是数组的一条记录;
    4
    0
    7
    0
    2
# 输出:
    调整后数组的内容;
    4
    7
    2
    0
    0

代码

def sort_0(x):
    return x == 0

#输入
len = int(input())
li = [len]
for i in range(len):
    li.append(int(input()))
##排序
li = sorted(li, key=sort_0)
##输出
for i in li:
    print(i)

结果

4
0
7
0
2
4
7
2
0
0

2、匿名函数lambda

1）匿名函数的含义和使用

匿名函数的关键字为lambda，冒号前面是形参 冒号后面是返回值

练习1：求1-5的平方

from functools import reduce


def add(x, y):
    return x + y


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

print(list(map(lambda x: x ** 2, range(5))))

结果：

15
[0, 1, 4, 9, 16]

练习2：求10的阶乘

代码：

from functools import reduce
print(reduce(lambda x,y:x*y ,range(1,11)))

结果：

3628800

2）匿名函数的默认参数，可变参数，关键字参数

一、匿名函数的默认参数

f = lambda x,y=2:x**y
print(f(3))
print(f(2,4))

9
16

二、匿名函数的可变参数

f = lambda *args:sum(args)
print(f(1,2,3,45,6))

57

三、匿名函数的关键字参数

f = lambda **kwargs:kwargs.values()
print(f(name='fentiao',age=10))

dict_values(['fentiao', 10])

匿名函数练习：使用匿名函数排序

list = [0, 7, 0, 1, 2, 1, 5, 1, 7, 8, 0, 67, 1, 3, 4]
print(sorted(list, key=lambda x: x == 0))

[7, 1, 2, 1, 5, 1, 7, 8, 67, 1, 3, 4, 0, 0, 0]

3、字符串练习

练习：随机生成验证码

import random
import string

code_str = string.ascii_letters + string.digits  ##生成字母+数字的全部内容
print(code_str)


def gen_code(len=4):                   ##生成校验码的函数
    return ''.join(random.sample(code_str, len)) ##从字母或数字里面选择一个，然后根据长度，生成校验码，默认为4


# print(gen_code())
print([gen_code() for i in range(50)]) ##生成50个校验码

实验结果：

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
['U3Bv', '512g', 'DuM0', 'uYPZ', 'UHcI', '4fdW', 'rFLd', 'v4FQ', '7eOf', 'pTev', 'GdJC', 'gCtq', 'pFDI', 'MYor', 'wrWf', 'MBYs', 'lmF6', 'GiXF', 'tBgu', 'i2Yw', 'VvKO', 'aPmu', 'mWAw', '1pHU', 'TkwQ', 'KbSh', 'RxAe', 'wE4y', 'bykN', 'TCDt', 'l4Ig', 'KhoE', 'POCe', 'Jjr7', '048I', 'gPZW', 'uRKQ', 'NOVv', 'JXgA', '6zFJ', 'dN4r', 'GlNy', 'NkiC', 'j2q5', 'sBtu', 'N5VB', 'GyTq', 'uaAd', '4PzW', 'QsYL']

4、装饰器

1）装饰器的基本定义

装饰器：
    把一个函数当作参数，返回一个替代版的函数
    本质上就是一个返回函数的函数
    
“在不改变原函数的基础上，给函数增加功能”

引例：下面这个例子并不是装饰器的真正用法，是帮助理解的。

def func1():                    ##定义fun1函数，
    print('hello python')


def outer(a):                     ##定义装饰器函数，a为输入的形参，并且形参为一个函数，这个函数是被修饰的函数
    def inner():                  ##重新定义一个函数，这个函数将来返回替换原来的函数
        a()                       ##被装饰的函数执行
        print('~~~~~~~~~~~~~~~')  ##新加的功能，打印一行波浪线
    return inner                  ##返回一个函数


func1 = outer(func1)              ##新的函数赋予fun1
func1()                           ##执行这个函数

结果：

hello python
~~~~~~~~~~~~~~~

实例：如何使用装饰器给函数添加运行时的时间

import time                 ##加载time库


def decorator(func):          ##装饰器
    def wrapper():            ##定义函数
        print(time.time())    ##time.time（）输出当前的时间
        func()                ##被修饰的函数执行

    return wrapper            ##返回函数


@decorator                    ##f1函数使用装饰器修饰
def f1():                     ##f1函数的定义
    print('This is a function')


f1()                          ##运行

结果：

1548747821.3771389
This is a function
 

实例2：

import time

def decorator(func):
    def wrapper(*args,**kwargs):  ##装饰器可以接受任意数量的参数和字典
        print(time.time())
        func(*args,**kwargs)
    return wrapper

@decorator
def f1(func_name):
    print('This is function ' + func_name)

@decorator
def f2(func_name1,func_name2):
    print('This is function ' + func_name1)
    print('This is function ' + func_name2)

@decorator
def f3(func_name1,func_name2,**kwargs):
    print('This is function ' + func_name1)
    print('This is function ' + func_name2)
    print(kwargs)

f1('test')
f2('test1','test2')
f3('test1','test2',a=1,b=2,c='westos')

实验结果：

1548748412.9629793
This is function test
1548748412.9630575
This is function test1
This is function test2
1548748412.9630857
This is function test1
This is function test2
{'a': 1, 'b': 2, 'c': 'westos'}

2）如何返回函数名和函数注释

print(add_student.__doc__)        ##返回函数的注释
print(add_student.__name__)        ##返回函数名

如何返回被装饰函数的函数名和函数注释
在装饰器内添加

@functools.wraps(fun)

练习1：实现函数计时器

代码：

import time
import random
import string
import functools     ##里面有wraps装饰器

#问题1：被装饰的函数有返回值
#问题2：如何保留被装饰函数的函数名和帮助信息文档

li = [random.choice(string.ascii_letters) for i in range(100)]
# print(li)

def timeit(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        """这是一个wrapper函数"""
        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():
    """这是for循环"""
    s = ''
    for i in li:
        s += (i + ',')
    print(s)


@timeit
def join_add():
    """这是join方法"""
    print(','.join(li))

@timeit
def fun_list(n):
    """这是fun_list函数"""
    return [i * 2 for i in range(n)]

@timeit
def fun_map(n):
    """这是fun_map函数"""
    return list(map(lambda x:x*2,range(n)))


con_add()
join_add()
print(con_add.__doc__)
print(con_add.__name__)
print(join_add.__doc__)
print(join_add.__name__)

print(fun_list(5000))
print(fun_map(5000))

实验结果：

d,x,N,Q,z,C,D,E,s,T,e,X,t,P,d,c,h,u,M,W,G,i,q,A,B,m,K,v,Q,D,s,A,R,U,r,I,M,q,n,R,D,a,H,s,t,l,q,B,m,U,O,L,Z,j,D,P,a,T,E,Q,M,D,g,g,A,u,S,U,U,A,N,L,k,w,E,U,V,J,e,r,K,C,R,z,Q,V,u,O,Z,E,N,J,u,n,j,i,n,q,h,h,
运行时间为:0.000048
d,x,N,Q,z,C,D,E,s,T,e,X,t,P,d,c,h,u,M,W,G,i,q,A,B,m,K,v,Q,D,s,A,R,U,r,I,M,q,n,R,D,a,H,s,t,l,q,B,m,U,O,L,Z,j,D,P,a,T,E,Q,M,D,g,g,A,u,S,U,U,A,N,L,k,w,E,U,V,J,e,r,K,C,R,z,Q,V,u,O,Z,E,N,J,u,n,j,i,n,q,h,h
运行时间为:0.000008
这是for循环
con_add
这是join方法
join_add
运行时间为:0.000006
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]
运行时间为:0.000018
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

练习2：

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

代码

import time
import functools

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,运行时间:%.6f,运行返回值结果:%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

print(add(1,10))
print(time.ctime())##以标准形式输出时间

结果：

[Tue Jan 29 16:06:24 2019] 函数名:add,运行时间:1.000661,运行返回值结果:11
11
Tue Jan 29 16:06:24 2019

 

练习3：判断是否为root用户

inspect函数：inspect.getcallargs返回值是字典，key值为:形参，value值为:形参对应实参

使用前先载入库函数
import inspect

代码：

import functools
import inspect

def is_root(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        #inspect.getcallargs返回值是字典，key值为:形参，value值为:形参对应实参
        inspect_res = inspect.getcallargs(fun,*args,**kwargs)
        print('inspect_res的返回值为:%s' %inspect_res)
        if inspect_res.get('name') == 'root':
            res = fun(*args,**kwargs)
            return res
        else:
            print('not root user')
    return wrapper

@is_root
def add_student(name):
    print('添加学生信息...')

def del_student(name):
    print('删除学生信息...')

add_student('westos')

实验结果：

inspect_res的返回值为:{'name': 'westos'}
not root user

练习4：判断函数的输入是否为整型

编写装饰器required_ints, 条件如下:
    1). 确保函数接收到的每一个参数都是整数;  # 如何判断变量的类型?
     type(s), isinstance(s,str)
    2). 如果参数不是整形数， 抛出异常raise TypeError(“参数必须为整形”)
"""

代码：

import functools
def required_ints(f):
    @functools.wraps(f)
    def wrapper(*args,**kwargs):
        for arg in args + tuple(kwargs.values()):
            if not isinstance(arg,int):           ##判断是否为int型参数
                raise TypeError('参数必须为整形')   ##raise为抛出异常
        else:
            return f(*args,**kwargs)
    return wrapper

@required_ints
def add(*args,**kwargs):
    return sum(args + tuple(kwargs.values()))

print(add(1,2,3,65,67.5,5,a=1,b=2))

实验结果：

Traceback (most recent call last):
  File "/root/PycharmProjects/shi/day7/测试.py", line 28, in <module>
    print(add(1,2,3,65,67.5,5,a=1,b=2))
  File "/root/PycharmProjects/shi/day7/测试.py", line 19, in wrapper
    raise TypeError('参数必须为整形')
TypeError: 参数必须为整形

练习5：

 编写装饰器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(*kinds):
    def required_ints(f):
        @functools.wraps(f)
        def wrapper(*args,**kwargs):
            for arg in args:
                if not isinstance(arg,kinds):
                    print('TypeError:参数必须为',kinds)
                    break
            else:
                res = f(*args,**kwargs)
                return res
        return wrapper
    return required_ints

@required_types(float,int,list)
def add(a,b):
    return a + b

print(add(1.1,[1,2,3]))

结果：

Traceback (most recent call last):
  File "/root/PycharmProjects/shi/day7/测试.py", line 21, in <module>
    print(add(1.1,[1,2,3]))
  File "/root/PycharmProjects/shi/day7/测试.py", line 12, in wrapper
    res = f(*args,**kwargs)
  File "/root/PycharmProjects/shi/day7/测试.py", line 19, in add
    return a + b
TypeError: unsupported operand type(s) for +: 'float' and 'list'

练习6：多个装饰器的执行顺序

靠近函数的先导入，远离函数的先执行

代码：

def decorator_a(func):
    print('Get in decorator_a')
    def inner_a(*args,**kwargs):
        print('Get in inner_a')
        res = func(*args,**kwargs)
        return res
    return inner_a

def decorator_b(func):
    print('Get in decorator_b')
    def inner_b(*args,**kwargs):
        print('Get in inner_b')
        res = func(*args,**kwargs)
        return res
    return inner_b


@decorator_b
@decorator_a
def f(x):
    print('Get in f')
    return x * 2

f(1)

实验结果：

Get in decorator_a
Get in decorator_b
Get in inner_b
Get in inner_a
Get in f

练习7：判断是否为root用户，升级版本

import functools
import inspect

def is_root(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        #inspect.getcallargs返回值是字典，key值为:形参，value值为:形参对应实参
        inspect_res = inspect.getcallargs(fun,*args,**kwargs)
        print('inspect_res的返回值为:%s' %inspect_res)
        if inspect_res.get('name') == 'root':
            res = fun(*args,**kwargs)
            return res
        else:
            print('not root user')
    return wrapper

login_list = ['root','admin','redhat']

def is_login(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        if args[0] in login_list:
            res = fun(*args,**kwargs)
            return res
        else:
            print('Error:%s未登录' %args[0])
    return wrapper

@is_login
@is_root
def add_student(name):
    print('添加学生信息...')

add_student('root')

实验结果：

inspect_res的返回值为:{'name': 'root'}
添加学生信息...