python高阶函数

一、map函数（执行）
1.map原理：

map( ) 函数接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元素,并把结果作为新的 list 返回

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’)

1
2
3
4
5
6
7
8
9
10

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

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

调用map的结果为map类型，强制转化为list类型显示

1
2

二、reduce函数（累积）
1.reduce原理：

把一个函数作用在一个序列[x1, x2, x3…]上,这个函数必须接收两个参数,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)))

1
2
3
4
5
6
7

三、filter函数（过滤）
1.filter原理：

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

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)]) ##列表生成式更简单

1
2
3
4
5

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))])

1
2
3
4
5
6
7
8
9
10
11
12
13

四、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排序

1
2
3
4
5
6
7
8
9
10

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

例：输入 4 0 7 0 2 输出 0 0 7 2

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
2
3
4
5
6
7
8
9
10
11

五、装饰器
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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.解包

*args : 解包元组
**kwargs ： 解包字典
注意：python2：解包在函数中可以执行，print则不行；python3：函数、print均可

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],)

1
2
3
4
5
6
7
8
9
10
11

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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

六、装饰器的应用
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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’)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

七、匿名函数 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’})