Python—高阶函数

一、几种常见的函数

1、map函数

1.map原理：
map( ) 函数接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元素,并把结果作为新的 list 返回
2、对列表[1,2,3]和[4,5,6]依次求和

def add(*args):
    return sum(args)
m = map(add,[1,2,3],[4,5,6])    ##map接受的必须是可迭代的对象
for i in m:
    print(i,end= '\t')

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

print(list(map(str, [1, 2, 3])))

2、reduce函数

1.reduce原理：

把一个函数作用在一个序列[x1, x2, x3…]上,这个函数必须接收两个参数,reduce 把结果继续和序列的下一个元素做累积计算
2、输入一个整数，求其阶乘

from functools import reduce
def add(x,y):
    return x*y
n = int(input("请输入数字："))
print(reduce(add,range(1,n+1)))

3、filter函数

1.filter原理：

接收一个函数和一个序列，把传入的函数依次作用于每个元素,然后根据返回值是 True 还是 False 决定保留还是丢弃该元素
2、输出列表里面的偶数

def is_odd(num):
    return num%2 ==0
print(list(filter(is_odd,[12,24,56,33,57])))    ##filter方法
print([i for i in [12,24,56,33,57] if i%2==0])  ##列表生成式方法

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

def is_prime(num):
    if num <=0:
        return False
    elif num ==1 and num ==2:
        return True
    else:
        for i in range(2,num):
            if num%i ==0:
                return False
        else:
            return True
def is_not_prime(num):
    return not is_prime(num)
print(list(filter(is_not_prime,range(1,101))))

4、sorted函数（排序）

# # # 排序： 由大到小
# print(sorted([23,56546,78]))
#
# # # 排序： 由小到大， reverse=True, 代表排序后进行反转;
# print(sorted([23,56546,78], reverse=True))


##对列表的某一项进行排序
info = [
    ['001','apple',1000,2],
    ['002','xiaomi',10,2000],
    ['003','oppo',200,1900]
]

def sorted_by_count(item):
    return item[3]
print(sorted(info,key=sorted_by_count))

升级版：

info = {
    '001':{
        'name':'apple',
        'count':1000,
        'price':2
    },

    '002': {
        'name': 'xiaomi',
        'count': 10,
        'price': 2000
    },
    '003': {
        'name': 'Oppo',
        'count': 200,
        'price': 1900
    }
}


def sorted_by_count(item):
    return item['price']

print(sorted(info.values(), key=sorted_by_count))
print(sorted(info.values(), key=lambda item:item['price']))   

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、计算函数hello执行需要的时间

import time   ##导入模块
def compute_time(fun):    ##闭包，函数里面套嵌函数
    def wrapper():
        start_time = time.time()  ##记录函数执行之前的时间
        fun()
        end_time = time.time()  ##记录函数执行结束的时间
        print("%s函数的执行时间为%ss" %(fun.__name__,end_time-start_time))
    return wrapper
@compute_time      ##语法糖  hello = compute_time(hello)
def hello():
    print("hello")
hello()

2、实现日志记录的装饰器函数

def info_log(fun):   # fun=add
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):   # args=(1,2)   # 形参， 接收可变参数和关键字参数;*args: 接收可变参数; **kwargs: 接收关键字参数;
        """
        this is a wrapper function add log
        """
        start_time = time.time()
        res = fun(*args, **kwargs)    # add(args)  1 2   # 实参, 传递参数, *args, 对于元组解包, **kwargs: 对于字典解包
        end_time = time.time()
        print("%s %s 执行时间为%.2fs  执行结果:%s" % (time.ctime(), fun.__name__, end_time - start_time, res))
        return res
    return wrapper


@info_log   # add = info_log(add)    # add = wrapper
def add(x, y):
    """
    add function
    :param x: num1 -> int
    :param y: num2 -> int
    :return:  num1+num2 -> int
    """
    time.sleep(random.random())
    return x + y


print(add.__name__)
print(add.__doc__)

3、函数的解包

• *args解包元组
• **kwargs解包字典
  在python2中，print不能在函数中执行，但在python3中，解包和print都可

l = [1,2,3,4,5]
print(*l)   ##print方法       
def fun(*args):   ##元组解包
    print(args)
fun(*l)

def fun1(**kwargs):   **字典的解包
    print(kwargs)


info = {'name':'fentiao','age':10}
fun1(**info)

4、装饰器应用2

import functools
def is_admin(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        if kwargs['name'] == 'admin':
            fun(*args,**kwargs)
        else:
            print("no permission")
    return wrapper
login_seesion = ['root','admin','redhat']
def is_login(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        if kwargs['name'] in login_seesion:
            fun(*args,**kwargs)
        else:
            print("%s没有登陆" %(kwargs['name']))
    return wrapper

@is_login
@is_admin
def bbs(name):
    print('bbs......')
bbs(name='redhat')

5、装饰器的执行顺序

当函数套用多个装饰器时，装饰器的调用顺序为从上到下调用

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  # f = decorator_b(inner_a)   # f=inner_b
@decorator_a  # f = decorator_a(f)   f=inner_a
def f(x):
    print('Get in f')
    return x * 2

f(1)

6、匿名函数

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'})