能够把函数当做参数传递的函数被称为高阶函数。
把传入的函数func作用到iterable中的每个元素中。
map(func, iterable)
参数:
返回值：
示例:
list1 = [1, 2, 3, 4, 5, 6]
def squire_func(x):
return x * x
res = map(squire_func, list1)
print(res) # <map object at 0x0000017520035208>
print(list(res)) # [1, 4, 9, 16, 25, 36]
注：必须要有形参和返回值
reduce()函数同样接收两个参数，一个是函数，一个是Iterable，reduce把返回的结果继续和序列的下一个元素做累积计算。如果提供initial参数，会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。
reduce(function, sequence, initial=None)
注：reduce传入的函数function必须接受2个参数
示例:
from functools import reduce
list1 = [7, 7, 5, 8]
def func(a, b):
return a + b
res = reduce(func, list1)
print(res) # 27
list2 = [1, 2, 3, 4]
print(reduce(lambda x, y: x + y, list2, 3)) # 13
filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定是否保留该元素。
filter(function, iterable)
示例:
list1 = [1, 2, 3, 4, 5, 6]
def func(x):
return x % 2 == 0
res = filter(func, list1)
print(res) # <filter object at 0x00000297C8DE5288>
print(list(res)) # [2, 4, 6]
list2 = [1, 3, 4, 5, 7, 8, 9, 10]
res2 = filter(lambda n: True if n % 2 == 0 else False, list2)
print(list(res2)) # [4, 8, 10]
Python内置的sorted()函数可以对可迭代数据进行排序。
sorted(iterable, key, reverse)
返回值: 列表
示例:
tup1 = (10, 20, -30, 40)
# 从小到大
print(sorted(tup1)) # [-30, 10, 20, 40]
# 从大到小
print(sorted(tup1, reverse=True)) # [40, 20, 10, -30]
# 按照绝对值排序
tup2 = (30, -20, 10, -40, 50)
print(sorted(tup2, key=abs)) # [10, -20, 30, -40, 50]
# 按照自定义函数排序
tup3 = (18, 25, 16, 32)
def func(n):
print(n % 10)
return n % 10
list3 = sorted(tup3, key=func)
print(list3) # [32, 25, 16, 18]
注：sorted()函数可以对任意的容器数据类型进行排序。
在不修改原有代码的情况下，使用装饰器可以为已有函数增加新的功能，装饰器本质上是一个闭包函数。
# 定义装饰器
# 闭包函数的参数有且只有一个并且是函数类型，这个闭包函数被称为装饰器
def decorator(func):
def inner():
print("已经添加登录验证")
func()
return inner
def comment_func():
print("发表评论")
# 调用装饰器对已有函数装饰
comment_func = decorator(comment_func)
# 调用方式不变
comment_func()
通常情况下，我们使用装饰器提供的 @ 语法糖，来简化上面的写法。
# 定义装饰器
# 闭包函数的参数有且只有一个并且是函数类型，这个闭包函数被称为装饰器
def decorator(func):
def inner():
print("已经添加登录验证")
func()
return inner
@decorator # comment_func = decorator(comment_func)
def comment_func():
print("发表评论")
# 调用方式不变
# 实际调用的是内部的inner函数
comment_func()
装饰带有参数的函数
def decorator(func):
def inner(a, b):
print("正在执行加法运算")
func(a, b)
return inner
@decorator
def add_num(num1, num2):
result = num1 + num2
print("结果为：", result)
add_num(1, 2)
装饰带有参数和返回值的函数
def decorator(func):
def inner(a, b):
print("正在努力执行加法运算")
sum = func(a, b)
return sum
return inner
@decorator # add_num = decorator(add_num)
def add_num(num1, num2):
result = num1 + num2
return result
result = add_num(1, 2)
print("结果为：", result) # 结果为: 3
装饰带有不定长参数和返回值的函数
def decorator(func):
def inner(*args, **kwargs):
print("正在执行加法运算")
num = func(*args, **kwargs)
return num
return inner
@decorator # add_num = decorator(add_num), add_num = inner
def add_num(*args, **kwargs):
result = 0
for value in args:
result += value
for value in kwargs.values():
result += value
return result
result = add_num(10, 20)
print("结果为：", result) # 30
多个装饰器的过程：由内到外的一个装饰过程，先执行内部的装饰器，在执行外部的装饰器。
def decorator_b(func):
print("decorator b 执行了")
def inner():
result = "<div>" + func() + "</div>"
return result
return inner
def decorator_a(func):
print("decorator a 执行了")
def inner():
result = "<p>" + func() + "</p>"
return result
return inner
# 原理：content = decorator_b(decorator_a(content))
@decorator_b
@decorator_a
def content():
return "人生苦短，我用python"
res = content()
print(res)
输出内容如下：
decorator a 执行了
decorator b 执行了
<div><p>人生苦短，我用python</p></div>
带有参数的装饰器就是使用装饰器装饰函数的时候可以传入指定的参数。
语法格式：
@装饰器(参数,...)
示例:
def return_decorator(flag):
def decorator(func):
def inner(a, b):
if flag == "+":
print("正在执行加法运算")
elif flag == "-":
print("正在执行减法运算")
func(a, b)
return inner
# 调用函数的时候，可以返回一个装饰器
return decorator
@return_decorator("+") # decorator = return_decorator("+")，add_num = decorator(add_num)
def add_num(a, b):
result = a + b
print(result)
add_num(1, 2)
@return_decorator("-")
def sub_num(a, b):
result = a - b
print(result)
sub_num(1, 2)
使用带有参数的装饰器，其实是在装饰器外面又包裹了一个函数，使用该函数接受参数，返回装饰器。
class MyDecorator(object):
def __init__(self, func):
self.func = func
pass
# 实现__call__方法，让对象变为可调用的对象，可调用的对象能够像函数使用
def __call__(self, *args, **kwargs):
print("在call方法中调用了func函数")
self.func()
@MyDecorator # show = MyDecorator(show)
def show():
print("show方法执行了")
# show() => 对象()
show()
原文：https://www.cnblogs.com/bubbleboom/p/14825094.html