python函数式编程

函数式编程是一种编程范式，它强调使用纯函数、无副作用和不可变性。在Python中，可以使用高阶函数（接受其他函数作为参数的函数）和lambda表达式来实现函数式编程。

Python函数式编程主要包括以下内容：

头等函数：在Python中，函数被视为一等公民，这意味着函数可以像其他数据类型一样被赋值给变量、作为参数传递给其他函数、存储在数据结构中，以及作为返回值。
函数作为对象：由于Python中的函数也是对象，可以将函数赋值给变量，然后通过这个变量来调用函数。
高阶函数：这类函数可以接受其他函数作为参数，或者将其他函数作为结果返回。例如，内置的map()、filter()和reduce()函数就是典型的高阶函数。
匿名函数：即lambda表达式，它允许快速定义单行的小型函数，通常用于临时使用的小功能。
偏函数：是固定一个或多个函数参数的函数，它返回一个新的函数，该新函数接受剩余的参数。在Python中，functools模块提供了partial函数，用于创建偏函数。

扫一扫欢迎关注，一起学习！

1. 头等函数

在Python中，函数被视为一等公民，这意味着函数与其他数据类型（如整数、字符串等）处于平等地位。这种特性使得函数可以像其他数据类型一样被赋值给变量、作为参数传递给其他函数、存储在数据结构中，以及作为返回值。具体来说，头等函数主要包括以下几个方面：

函数赋值：可以将函数赋值给一个变量，然后通过这个变量来调用该函数。
函数作为参数：函数可以作为参数传递给另一个函数。这是高阶函数的一个特点，它们可以接受函数作为输入，或者将函数作为输出返回。
函数作为返回值：函数可以作为另一个函数的返回值。这使得可以在运行时动态地创建和返回函数，增加了编程的灵活性。
函数存储在数据结构中：函数可以存储在列表、字典等数据结构中，这使得可以组织和分类不同的函数，便于管理和调用。
函数式编程的思维方式：函数式编程鼓励将问题分解为一系列函数调用，每个函数完成单一的任务，这样可以使程序更加模块化，易于理解和维护。

# 定义一个函数，接受一个数字作为参数，返回这个数字的两倍
def multiply_by_two(x):
    return x * 2

# 创建一个包含数字的列表
numbers = [1, 2, 3, 4, 5]

# 使用map函数和multiply_by_two函数，将列表中的每个元素都乘以2
result = map(multiply_by_two, numbers)

# 将结果转换为列表并打印输出
print(list(result))  
# 输出：[2, 4, 6, 8, 10]

2. 匿名函数

匿名函数是指没有具体名称的函数，它允许快速定义单行的简单函数，通常用于临时使用的小功能。

在Python中，可以使用lambda关键字来创建匿名函数。

# 定义一个匿名函数，接受一个参数n，返回n的平方
square = lambda n: n * n

# 调用匿名函数
result = square(5)
print(result)  # 输出：25

3. 偏函数

偏函数是指固定一个函数的部分参数，生成一个新的函数。在Python中，可以使用functools.partial函数来创建偏函数。

例如，我们有一个求平方的函数square：

def square(x):
    return x * x

使用functools.partial来创建一个只传入一个参数的偏函数

import functools

square_of_2 = functools.partial(square, 2)
print(square_of_2())  # 输出：4

4. 闭包

闭包是指一个函数可以访问并操作其外部作用域中的变量。在Python中，闭包是通过嵌套函数实现的。

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))  # 输出：15

4.1. 闭包的优点

主要包括保护变量、避免全局污染和实现私有成员。

闭包可以使得内部函数访问外部函数的变量，这些变量会被保留在内存中，即使外部函数执行完毕。这样可以在多次调用内部函数时保持变量的状态，实现数据的持久化。
闭包通过创建私有作用域来避免全局变量的污染。由于闭包内部的变量不会被外部环境直接访问，这有助于减少因全局变量过多而引起的命名冲突和意外修改的风险。
闭包可以实现私有成员的存在。在面向对象的编程中，闭包可以用来模拟类的私有属性和方法，这些私有成员只能通过特定的接口访问，而不能直接从外部访问，从而增强了封装性。

4.2. 主要应用场景

封装和保护

闭包可以用来封装和保护变量，使得这些变量不会被外部环境所影响。例如，在计数器或累加器中，可以使用闭包来保存计数状态。

def counter(start=0):
    count = [start]
    def increment():
        count[0] += 1
        return count[0]
    return increment

my_counter = counter()
print(my_counter())  # 输出：1
print(my_counter())  # 输出：2

缓存

闭包可以用于缓存函数的结果，避免重复计算。这在处理递归或计算密集型任务时特别有用。

def memoize(f):
    cache = {}
    def decorated_function(*args):
        if args in cache:
            return cache[args]
        else:
            cache[args] = f(*args)
            return cache[args]
    return decorated_function

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 输出：55

实现特定的设计模式

闭包可以用于实现某些设计模式，如单例模式、策略模式等。例如，在单例模式中，可以使用闭包来确保类只有一个实例。

def singleton(cls):
    instances = []
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instance = super().__new__(cls)
            instances.append(instance)
            return instance
    return wrapper

@singleton
class MyClass:
    pass

a = MyClass()
b = MyClass()
print(a is b)  # 输出：True