python高阶函数实例分析

一、map函数（执行）

1.map原理：

2.对[1,2,3]、 [4,5,6] 、[7,8,9]三个列表一一对应求和

##from collections import Iterable

def add(*num):
    return sum(num)

m = map(add, [1, 2, 3], [4, 5, 6], [7, 8, 9])
##map函数必须是可迭代对象
print(type(m), isinstance(m, Iterable))   ##显示m类型，判断是否可迭代
for i in m:
   print(i, end='\t')

3.把列表中的所有数字转为字符串

print(list(map(str,[1,2,3,4])))
##调用map的结果为map类型，强制转化为list类型显示

二、reduce函数（累积）

1.reduce原理：

2.输入一个整数，求其阶乘

from functools import reduce   ##在函数工具中导入reduce模块

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

n = int(input('Please input a num:'))
print(reduce(add, range(1, n + 1)))

三、filter函数（过滤）

1.filter原理：

2.输出1-100之间的偶数（奇数）

def ot_sort(num):
    return num % 2 == 0

print([i for i in filter(ot_sort, range(1,101))])
print([i for i in range(2,101,2)]) ##列表生成式更简单

3.输出1-100之间的素数（合数）

 def prime(I):
     if I <= 0:
         return False
     elif I == 1 or I == 2:
         return True
     else:
         for item in range(2, I):
             if I % item == 0:
                 return False
         else:
             return True

 print([i for i in filter(prime, range(1,101))])

四、sorted函数（排序）

1.对info列表，以商品价格排序

info = [
    ['001', 'apple', 1000, 2],
    ['002', 'xiaomi', 10, 2000],
    ['003', 'Oppo', 200, 1900],
    ['004', 'computer', 900, 5000]
]
def sorted_price(item):  
    return item[3]  ##相当于返回info[index][3]

print(sorted(info,key=sorted_price))  ##以key为关键字对info排序

2.输入数据长度，对输入的整型数排序，所有的0放前面

def reverce(num):   ##将数字转化为0、1
    if num == 0:
        return 0
    else:
        return 1

n = int(input('length:'))  ##字符长度，即列表长度
l = [int(input('num:')) for i in range(n)]  ##生成列表
print(sorted(l, key=reverce))
##下面结果为：7 2 0 0 而不是：2 7 0 0，说明sort只识别0、1，不识别转化前的数字
print(sorted(l, key=reverce,reverse=True))

五、装饰器

1.计算test函数的运行时间

import time   ##导入time模块

def compute_time(fun):   ##闭包，函数里嵌套函数
    def wrapper():
        start = time.time()   ##调用函数前的时间戳
        fun()
        end = time.time()  ##调用函数后的时间戳
        print('%s Time is %ss' % (fun.__name__, end - start))

    return wrapper
 ##注意：使用语法糖的函数必须在test函数前定义，脚本按前后顺序执行
@compute_time  ##语法糖，相当于test = compute_time(test)
def test():
    print('gun,fastly')
    time.sleep(1)

# test = compute_time(test)
test()

2.要求显示日志：时间 函数名 执行时间 执行结果

import time

def log(fun):
    def wrapper():
        start = time.time()
        result = fun()
        end = time.time()
        print(time.ctime(), fun.__name__, end - start, result)
##time.ctime()显示当前时间，fun.__name__显示函数名
    return wrapper

@log
def test():
    time.sleep(2) ##休眠时间
    return 'it is a test'

@log
def phone():
    time.sleep(0.2)
    return 'New iPhone is 803/804'

test()  #3调用函数
phone()

3.解包

In [20]: l=[1,2,3]
In [21]: print(*l)  ##直接打印会报错
  File "", line 1
    print(*l)
          ^
SyntaxError: invalid syntax
In [22]: def test(*args):
   ....:     print(args)
   ....:     
In [23]: test(l)  ##但是函数可以
([1, 2, 3],)

4.要求：函数具备可变参数、关键字参数

import time
import random   

def log(fun):  ##装饰器加入可变参数、关键字参数，防止调用不同函数报错
    def wrapper(*args, **kwargs):  ##形参
        start = time.time() 
        result = fun(*args, **kwargs)  ##实参，函数传入的参数
        end = time.time()   ##time.ctime()当前时间
        print(time.ctime(), fun.__name__, end - start, result)

    return wrapper


@log
def Sum(x, y):
    time.sleep(random.random())  ##0-1之间的随机数
    return x * y

@log
def test():
    time.sleep(2)
    return 'it is a test'

Sum(2,3)   ##装饰器修改后，可调用不同参数的函数
test()

5.函数说明

import functools  ##函数工具

def log(fun):
    @functools.wraps(fun)  ##函数log的说明不改变Sum函数原有属性
    def wrapper(*args, **kwargs):  ##形参
        """
        this is a wrapper
        """
        pass
    return wrapper
def Sum(x, y):
    """    ##Sum函数属性
    add function   ##函数的参数说明
    :param x: num1 ---> int or float
    :param y: num ---> int or float
    :return: num1 + num 2  ##返回值说明
    """ 
    pass

六、装饰器的应用

1.判断用户是否为admin，是就执行，不是就报错

 1.判断用户是否为admin，是就执行，不是就报错
def admin(fun):  ##定义装饰器
    def wrapper(*args,**kwargs):
        if kwargs['name']=='admin':  ##判断是否为admin用户
            fun(*args,**kwargs)
        else:
            print('No Pression')
    return wrapper

@admin  ##语法糖
def qq(name):  ##定义新函数
    print('Hello QQ')

qq(name='westos')  ##调用函数，例westos用户登陆QQ

2.两个装饰器原理

def decorator_a(func):  # func=f
    print('Get in decorator_a')

    def inner_a(*args, **kwargs):
        print('Get in inner_a')
        return func(*args, **kwargs)  # f(1)

    return inner_a

def decorator_b(func):  # decorator_b(inner_a)
    print('Get in decorator_b')

    def inner_b(*args, **kwargs):
        print('Get in inner_b')
        return func(*args, **kwargs)  # inner_a(1)

    return inner_b

@decorator_b  ##两个装饰器从下往上调用，从上往下执行
@decorator_a
def fun():
    print('Get in f')

fun()

3.判断用户是否登陆，若没有登陆则报错；若登陆，判断用户是否为admin，是执行，不是就报错

import functools  ##导入函数工具模块，函数说明不受影响

def admin(fun):  ##定义装饰器函数，判断登陆用户
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        if kwargs['name'] == 'admin':
            fun(*args, **kwargs)
        else:
            print('No Pression')

    return wrapper

loger = ['westos', 'admin', 'root']  ##用户列表

def is_log(fun):  ##定义装饰器，判断用户是否登陆
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        if kwargs['name'] in loger:
            fun(*args, **kwargs)
        else:
            print('Error:No Logging')

    return wrapper

@is_log  ##两个装饰器，先判断是否登陆，再判断登陆用户
@admin
def qq(name):
    print('Hello QQ')

qq(name='admin')

七、匿名函数 lambda

from functools import reduce  ##导入reduce模块

print(list(map(lambda x: x + 1, range(10))))
##实现1-10数字的输出（0-9，自加1）
print(reduce(lambda x, y: x * y, range(1, 6)))
##实现5的阶乘
print(list(filter(lambda n: n % 2 == 0, range(10))))
##显示10以内的偶数，即过滤掉奇数
num = [0, 2, 0, 4, 1]
print(sorted(num, key=lambda n: 0 if n == 0 else 1))
##对num列表排序，将0放在前面，其他数字放后面
f = lambda *args, **kwargs: (1, 2)  ##以元组形式传递参数，自动解包
f1 = lambda *args, **kwargs: (args, kwargs)
print(f())  ##输出元组：(1, 2)
print(f1(1, 2, 3, 4, test='hello')) 
##输出元组：((1, 2, 3, 4), {'test': 'hello'})