函数

一.高阶函数

1.map:将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

格式:
map(fun, [Iterable])

示例:

def minutes(hour):
    return int(hour * 60)

minutes_list = map(minutes, [1, 1.5, 3])
print(minutes_list)
print(list(minutes_list))

输出:
<map object at 0x000001F0DE502550>
[60, 90, 180]

由于minutes_list是一个Iterator，因此通过list()函数让它把整个序列都计算出来并返回一个list。

2.reduce:把一个函数作用在一个序列[x1, x2, x3, ...]上，reduce把结果继续和序列的下一个元素做累积计算

格式:

from functools import reduce
reduce(fun, [Iterable])

示例:

from functools import reduce

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

total = reduce(add, [1, 2, 3])
print(total)

输出:
6

3.filter:过滤序列

格式:
filter(f, [....])

示例:

def add(x):
    return x % 2 == 0

filter_list = filter(add, [1, 2, 3])
print(list(filter_list))

4.sorted:排序

格式:
sorted([...], key=function, reverse=True)

示例:

print(sorted([1,2,4], key=abs, reverse=True))

二.返回函数和闭包

1.返回函数:

def lazy_sum(*args):
    def sum():
        total = 0
        for x in args:
            total += x
        return total
    return sum

f = lazy_sum(1,2,34)
print(f)
print(f())

输出:
<function lazy_sum.<locals>.sum at 0x00000174FF153BF8>
37

2.闭包

返回函数不要引用任何循环变量，或者后续会发生变化的变量。

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print(count())
print(f1(), f2(), f3())

输出:
[<function count.<locals>.f at 0x0000023B02F03D90>, <function count.<locals>.f at 0x0000023B02F03E18>, <function count.<locals>.f at 0x0000023B02F03EA0>]
9 9 9

你期望输出 1 4 9,但其实输出了9 9 9

如果要输出1 4 9,你需要再创建一个闭包函数

def count():
    fs = []
    def f(j):
        def a():
            return j*j
        return a
    for i in range(1, 4):
        fs.append(f(i))
    return fs

f1, f2, f3 = count()
print(count())
print(f1(), f2(), f3())

输出:
[<function count.<locals>.f.<locals>.a at 0x00000267C2673E18>, <function count.<locals>.f.<locals>.a at 0x00000267C2673EA0>, <function count.<locals>.f.<locals>.a at 0x00000267C2673F28>]
1 4 9

三.匿名函数

格式如:
lambda x: x * x

示例:

f= (lambda x:x*x)(10)
print(f)

也可以将匿名函数作为函数返回:

def func(x):
    return lambda: x*x
print(func(10))
print(func(10)())

输出:
<function func.<locals>.<lambda> at 0x00000212FBA93BF8>
100

四.装饰器:

示例:

import functools

def log(log_text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print("%s: call %s()" % (log_text, func.__name__))
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log('execute')
def now(time_str):
    print(time_str)

now('2018')

输出:
execute: call now()
2018

这与以下代码实现的功能是一致的:

import functools

def log(log_text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print("%s: call %s()" % (log_text, func.__name__))
            return func(*args, **kwargs)
        return wrapper
    return decorator

def now(time_str):
    print(time_str)

#相当于执行了
f = log('execute')(now) #返回了log中的wrapper
f('2019')

五.偏函数

把一些函数的某些参数固定住,返回新函数

#注意分隔符*,这表示在这之后的参数是关键字参数,如果该位置有个可变参数,则不需要分隔符
def log(fun, *, default_text):
    print(default_text)
    return '%s 执行了' % fun


import functools

print(log('send', default_text = 'email'))

default_log = functools.partial(log, default_text='hello')
print(default_log('send'))

输出:
email
send 执行了
hello
send 执行了