python函数式编程

January 9, 2023

函数式编程指引
https://docs.python.org/zh-cn/3/howto/functional.html

生成器

def gen():
    s = ""
    while True:
        val = (yield s)
        if type(val) is str:
            s += val


y = gen()
print(next(y))  # 相当于 print(y.send(None))
# send 方法向下一个 yield 语句发送值
# yield 若未接收值，则 yield 语句返回 None
# 不过 send 方法无法向刚开始的生成器发送非 None 值
print(y.send("hello"))  # hello
print(y.__next__())  # hello
print(y.send("world"))  # helloworld
y.close()  # 调用 close 方法关闭生成器

map

注意！map 是一个类而不只是函数（因为要实现迭代器）

# 部分定义
class map(Iterator[_S], Generic[_S]):
    @overload
    def __init__(self, __func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> None: ...
    @overload
    def __init__(self, __func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> None: ...


print(list(
    map(lambda x: x**2, [1, 2, 3])
    # [1, 4, 9]
))

print(list(
    map(lambda x, y: (x**2, y**2), [1, 2, 3], [2, 3, 4])
    # [(1, 4), (4, 9), (9, 16)]
))

reduce

# 定义大概可以写成这样
from typing import TypeVar, Iterable, Callable
T = TypeVar('T')
def reduce(function: Callable[[T, T], T], sequence: Iterable[T], initial: T): ...


from functools import reduce
print(
    reduce(lambda x, y: x*10+y, [3, 4, 5], 0)
    # 345
)

print(
    reduce(lambda x, y: x+y, [3, 3, 3], 1)
    # 10
    # 相当于
    # reduce(lambda x, y: x+y, [1, 3, 3, 3])
)

filter

filter 也是一个类，同样是因为要实现迭代器

# 部分定义
class filter(Iterator[_T], Generic[_T]):
    @overload
    def __init__(self, __function: Callable[[_S], TypeGuard[_T]], __iterable: Iterable[_S]) -> None: ...
    @overload
    def __init__(self, __function: Callable[[_T], Any], __iterable: Iterable[_T]) -> None: ...


print(list(
    filter(lambda x: x % 2 == 0, [-2, -1, 0, 1, 2, 3])
    # [-2, 0, 2]
))

装饰器

装饰器是高阶函数

import functools


def decorator(fn):  # fn 是装饰器修饰的函数对象
    # @functools.wraps(fn)
    # functools.wraps 这个装饰器保证被装饰器装饰后的函数还拥有原来的属性
    def wrapper(*args, **kw):  # 装饰器返回的 wrapper 函数是实际调用的函数对象。换言之，装饰器修饰的函数被 wrapper 替代
        # wrapper.__name__ = fn.__name__
        print("{}(args={}, kw={})".format(fn.__name__, args, kw))
        return fn(*args, **kw)
    return wrapper


def decorator_lambda(fn):  # 装饰器就是返回函数的函数。使用匿名函数替代如下
    return lambda *args, **kw: print("{}(args={}, kw={})".format(fn.__name__, args, kw))


def decorator_with_param(*params):  # 带参数的装饰器，是一个返回装饰器的函数
    print("@decorator_with_param{}".format(params))

    def decorator(fn):
        def wrapper(*args, **kw):
            print("{}(args={}, kw={})".format(fn.__name__, args, kw))
            return fn(*args, **kw)
        return wrapper
    return decorator


def decorator_with_param_lambda(*params):  # 使用匿名函数替代如下
    print("@decorator_with_param{}".format(params))
    return lambda fn: lambda *args, **kw: print("{}(args={}, kw={})".format(fn.__name__, args, kw))


# TEST

@decorator
def test1(a, b, c):
    pass


@decorator_with_param("param1", "param2")
def test2(a, b, c):
    pass


test1(1, 2, c=3)
test2(4, 5, c=6)

←Back to home