026-lambda表达式与函数式编程

026-lambda表达式与函数式编程

🔴 难度: 高级 | ⏱️ 预计时间: 5小时 | 📋 前置: 024-闭包与作用域

学习目标

完成本章节后，你将能够：

• 掌握lambda表达式的语法和应用场景
• 理解函数式编程的核心概念和原则
• 熟练使用map、filter、reduce等高阶函数
• 掌握函数组合和柯里化技术
• 理解不可变性和纯函数的重要性
• 应用函数式编程解决实际问题

lambda表达式基础

lambda语法和特性

# lambda表达式基础
print("=== lambda表达式基础 ===")

# 基本语法：lambda 参数: 表达式
square = lambda x: x ** 2
print(f"square(5) = {square(5)}")

# 多参数lambda
add = lambda x, y: x + y
print(f"add(3, 4) = {add(3, 4)}")

# 默认参数
greet = lambda name, greeting="Hello": f"{greeting}, {name}!"
print(f"greet('Alice') = {greet('Alice')}")
print(f"greet('Bob', 'Hi') = {greet('Bob', 'Hi')}")

# 可变参数
sum_all = lambda *args: sum(args)
print(f"sum_all(1, 2, 3, 4) = {sum_all(1, 2, 3, 4)}")

# 关键字参数
format_info = lambda **kwargs: ', '.join(f"{k}={v}" for k, v in kwargs.items())
print(f"format_info(name='Alice', age=30) = {format_info(name='Alice', age=30)}")

# 条件表达式
abs_value = lambda x: x if x >= 0 else -x
print(f"abs_value(-5) = {abs_value(-5)}")
print(f"abs_value(3) = {abs_value(3)}")

# 嵌套lambda
power = lambda base: lambda exp: base ** exp
square_func = power(2)
print(f"power(2)(3) = {power(2)(3)}")
print(f"square_func(4) = {square_func(4)}")

lambda与普通函数的对比

# lambda与普通函数的对比
print("\n=== lambda与普通函数的对比 ===")

import timeit
from typing import Callable, List

# 功能相同的lambda和普通函数
def multiply_func(x: int, y: int) -> int:
    """普通函数：两数相乘"""
    return x * y

multiply_lambda = lambda x, y: x * y

# 性能对比
test_data = [(i, i+1) for i in range(1000)]

def test_function():
    return [multiply_func(x, y) for x, y in test_data]

def test_lambda():
    return [multiply_lambda(x, y) for x, y in test_data]

func_time = timeit.timeit(test_function, number=1000)
lambda_time = timeit.timeit(test_lambda, number=1000)

print(f"普通函数执行时间: {func_time:.4f}秒")
print(f"lambda表达式执行时间: {lambda_time:.4f}秒")
print(f"性能差异: {abs(func_time - lambda_time) / min(func_time, lambda_time) * 100:.2f}%")

# 内存使用对比
import sys

print(f"\n内存使用对比:")
print(f"普通函数大小: {sys.getsizeof(multiply_func)} bytes")
print(f"lambda表达式大小: {sys.getsizeof(multiply_lambda)} bytes")

# 功能特性对比
print(f"\n功能特性对比:")
print(f"普通函数名称: {multiply_func.__name__}")
print(f"lambda表达式名称: {multiply_lambda.__name__}")
print(f"普通函数文档: {multiply_func.__doc__}")
print(f"lambda表达式文档: {multiply_lambda.__doc__}")
print(f"普通函数注解: {multiply_func.__annotations__}")
print(f"lambda表达式注解: {multiply_lambda.__annotations__}")

# 适用场景分析
print(f"\n适用场景分析:")
print("lambda表达式适用于:")
print("  - 简单的单行表达式")
print("  - 作为高阶函数的参数")
print("  - 临时使用的小函数")
print("  - 函数式编程风格")

print("\n普通函数适用于:")
print("  - 复杂的多行逻辑")
print("  - 需要文档和注解")
print("  - 可重用的功能")
print("  - 需要调试的代码")

lambda的高级用法

# lambda的高级用法
print("\n=== lambda的高级用法 ===")

from functools import partial, reduce
from operator import add, mul, itemgetter, attrgetter

# 1. 与内置函数结合
print("1. 与内置函数结合:")

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 过滤偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(f"偶数: {even_numbers}")

# 平方映射
squared = list(map(lambda x: x ** 2, numbers))
print(f"平方: {squared}")

# 累积求和
total = reduce(lambda x, y: x + y, numbers)
print(f"总和: {total}")

# 2. 排序中的应用
print("\n2. 排序中的应用:")

students = [
    {'name': 'Alice', 'age': 23, 'grade': 88},
    {'name': 'Bob', 'age': 21, 'grade': 92},
    {'name': 'Charlie', 'age': 22, 'grade': 85},
    {'name': 'Diana', 'age': 24, 'grade': 95}
]

# 按年龄排序
by_age = sorted(students, key=lambda s: s['age'])
print(f"按年龄排序: {[s['name'] for s in by_age]}")

# 按成绩排序（降序）
by_grade = sorted(students, key=lambda s: s['grade'], reverse=True)
print(f"按成绩排序: {[s['name'] for s in by_grade]}")

# 多条件排序
by_multiple = sorted(students, key=lambda s: (s['age'], -s['grade']))
print(f"按年龄升序、成绩降序: {[(s['name'], s['age'], s['grade']) for s in by_multiple]}")

# 3. 条件逻辑
print("\n3. 条件逻辑:")

# 复杂条件判断
classify_number = lambda x: (
    "负数" if x < 0 else
    "零" if x == 0 else
    "小正数" if x < 10 else
    "大正数"
)

test_numbers = [-5, 0, 3, 15]
for num in test_numbers:
    print(f"{num}: {classify_number(num)}")

# 4. 字典和列表操作
print("\n4. 字典和列表操作:")

data = [
    {'product': 'laptop', 'price': 1200, 'quantity': 5},
    {'product': 'mouse', 'price': 25, 'quantity': 50},
    {'product': 'keyboard', 'price': 80, 'quantity': 20}
]

# 计算总价值
total_values = list(map(lambda item: item['price'] * item['quantity'], data))
print(f"各产品总价值: {total_values}")

# 过滤高价值产品
high_value = list(filter(lambda item: item['price'] * item['quantity'] > 1000, data))
print(f"高价值产品: {[item['product'] for item in high_value]}")

# 5. 函数工厂
print("\n5. 函数工厂:")

# 创建数学运算函数
def create_math_func(operation: str) -> Callable:
    operations = {
        'add': lambda x, y: x + y,
        'sub': lambda x, y: x - y,
        'mul': lambda x, y: x * y,
        'div': lambda x, y: x / y if y != 0 else float('inf'),
        'pow': lambda x, y: x ** y,
        'mod': lambda x, y: x % y if y != 0 else 0
    }
    return operations.get(operation, lambda x, y: None)

# 测试函数工厂
operations = ['add', 'mul', 'pow']
for op in operations:
    func = create_math_func(op)
    result = func(3, 4)
    print(f"{op}(3, 4) = {result}")

# 6. 递归lambda（需要技巧）
print("\n6. 递归lambda:")

# 阶乘函数（使用Y组合子技巧）
factorial = (lambda f, n: 1 if n <= 1 else n * f(f, n-1))
print(f"factorial(5) = {factorial(factorial, 5)}")

# 斐波那契数列
fibonacci = (lambda f, n: n if n <= 1 else f(f, n-1) + f(f, n-2))
print(f"fibonacci(10) = {fibonacci(fibonacci, 10)}")

# 更优雅的递归lambda（使用装饰器）
def recursive(func):
    """使lambda支持递归的装饰器"""
    def wrapper(*args, **kwargs):
        return func(func, *args, **kwargs)
    return wrapper

@recursive
def factorial_elegant(f, n):
    return 1 if n <= 1 else n * f(f, n-1)

print(f"factorial_elegant(6) = {factorial_elegant(6)}")

函数式编程核心概念

纯函数和副作用

# 纯函数和副作用
print("\n=== 纯函数和副作用 ===")

import time
from typing import List, Dict, Any
from copy import deepcopy

# 1. 纯函数示例
print("1. 纯函数示例:")

def pure_add(x: int, y: int) -> int:
    """纯函数：相同输入总是产生相同输出，无副作用"""
    return x + y

def pure_multiply_list(numbers: List[int], factor: int) -> List[int]:
    """纯函数：不修改输入，返回新列表"""
    return [n * factor for n in numbers]

def pure_filter_dict(data: Dict[str, Any], condition: Callable) -> Dict[str, Any]:
    """纯函数：过滤字典，返回新字典"""
    return {k: v for k, v in data.items() if condition(k, v)}

# 测试纯函数
original_list = [1, 2, 3, 4, 5]
original_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

print(f"pure_add(3, 4) = {pure_add(3, 4)}")
print(f"pure_add(3, 4) = {pure_add(3, 4)}")  # 相同输入，相同输出

multiplied = pure_multiply_list(original_list, 2)
print(f"原列表: {original_list}")
print(f"乘以2后: {multiplied}")
print(f"原列表未变: {original_list}")

filtered = pure_filter_dict(original_dict, lambda k, v: v > 2)
print(f"原字典: {original_dict}")
print(f"过滤后: {filtered}")
print(f"原字典未变: {original_dict}")

# 2. 非纯函数示例（有副作用）
print("\n2. 非纯函数示例（有副作用）:")

# 全局状态
counter = 0
log_messages = []

def impure_increment():
    """非纯函数：修改全局状态"""
    global counter
    counter += 1
    return counter

def impure_log(message: str) -> None:
    """非纯函数：产生副作用（修改全局列表）"""
    log_messages.append(f"[{time.time()}] {message}")

def impure_modify_list(numbers: List[int]) -> List[int]:
    """非纯函数：修改输入参数"""
    numbers.append(999)  # 副作用：修改输入
    return numbers

# 测试非纯函数
print(f"第一次调用 impure_increment(): {impure_increment()}")
print(f"第二次调用 impure_increment(): {impure_increment()}")
print(f"全局counter: {counter}")

impure_log("测试消息1")
impure_log("测试消息2")
print(f"日志消息: {log_messages}")

test_list = [1, 2, 3]
print(f"修改前: {test_list}")
result = impure_modify_list(test_list)
print(f"修改后: {test_list}")  # 原列表被修改
print(f"返回值: {result}")

# 3. 将非纯函数转换为纯函数
print("\n3. 将非纯函数转换为纯函数:")

def pure_increment(current_value: int) -> int:
    """纯函数版本：接受当前值，返回新值"""
    return current_value + 1

def pure_log(messages: List[str], new_message: str) -> List[str]:
    """纯函数版本：返回新的消息列表"""
    return messages + [f"[{time.time()}] {new_message}"]

def pure_append_list(numbers: List[int], value: int) -> List[int]:
    """纯函数版本：返回新列表"""
    return numbers + [value]

# 测试纯函数版本
current_counter = 0
current_counter = pure_increment(current_counter)
print(f"纯函数计数器: {current_counter}")
current_counter = pure_increment(current_counter)
print(f"纯函数计数器: {current_counter}")

current_logs = []
current_logs = pure_log(current_logs, "纯函数消息1")
current_logs = pure_log(current_logs, "纯函数消息2")
print(f"纯函数日志: {current_logs}")

original_list = [1, 2, 3]
new_list = pure_append_list(original_list, 999)
print(f"原列表: {original_list}")
print(f"新列表: {new_list}")

# 4. 纯函数的优势
print("\n4. 纯函数的优势:")

# 可测试性
def test_pure_functions():
    """纯函数易于测试"""
    assert pure_add(2, 3) == 5
    assert pure_add(0, 0) == 0
    assert pure_add(-1, 1) == 0
    print("所有纯函数测试通过")

test_pure_functions()

# 可缓存性（记忆化）
from functools import lru_cache

@lru_cache(maxsize=128)
def expensive_pure_function(n: int) -> int:
    """昂贵的纯函数，可以安全缓存"""
    print(f"计算 {n} 的复杂运算...")
    time.sleep(0.1)  # 模拟耗时计算
    return n ** 3 + n ** 2 + n + 1

print("\n缓存测试:")
start_time = time.time()
result1 = expensive_pure_function(10)
first_call_time = time.time() - start_time

start_time = time.time()
result2 = expensive_pure_function(10)  # 从缓存获取
second_call_time = time.time() - start_time

print(f"第一次调用时间: {first_call_time:.4f}秒")
print(f"第二次调用时间: {second_call_time:.4f}秒")
print(f"加速比: {first_call_time / second_call_time:.2f}x")

# 并发安全性
import threading

def concurrent_pure_test():
    """纯函数在并发环境中是安全的"""
    results = []
    
    def worker(thread_id: int):
        for i in range(5):
            result = pure_add(thread_id, i)
            results.append(result)
    
    threads = []
    for i in range(3):
        thread = threading.Thread(target=worker, args=(i,))
        threads.append(thread)
        thread.start()
    
    for thread in threads:
        thread.join()
    
    print(f"并发测试结果: {sorted(results)}")

concurrent_pure_test()

不可变性

# 不可变性
print("\n=== 不可变性 ===")

from typing import NamedTuple, FrozenSet
from dataclasses import dataclass, replace
from collections import namedtuple
import copy

# 1. Python内置不可变类型
print("1. Python内置不可变类型:")

# 基本不可变类型
immutable_int = 42
immutable_str = "Hello"
immutable_tuple = (1, 2, 3)
immutable_frozenset = frozenset([1, 2, 3, 4])

print(f"整数: {immutable_int} (id: {id(immutable_int)})")
print(f"字符串: {immutable_str} (id: {id(immutable_str)})")
print(f"元组: {immutable_tuple} (id: {id(immutable_tuple)})")
print(f"冻结集合: {immutable_frozenset} (id: {id(immutable_frozenset)})")

# 尝试"修改"不可变对象
old_id = id(immutable_int)
immutable_int += 1  # 实际上创建了新对象
print(f"\n'修改'后的整数: {immutable_int} (id: {id(immutable_int)})")
print(f"ID是否改变: {old_id != id(immutable_int)}")

# 2. 使用NamedTuple创建不可变对象
print("\n2. 使用NamedTuple创建不可变对象:")

class Point(NamedTuple):
    x: float
    y: float
    
    def distance_from_origin(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5
    
    def move(self, dx: float, dy: float) -> 'Point':
        """返回移动后的新点"""
        return Point(self.x + dx, self.y + dy)

original_point = Point(3.0, 4.0)
print(f"原始点: {original_point}")
print(f"距离原点: {original_point.distance_from_origin()}")

moved_point = original_point.move(1.0, 1.0)
print(f"移动后的点: {moved_point}")
print(f"原始点未变: {original_point}")

# 3. 使用dataclass创建不可变对象
print("\n3. 使用dataclass创建不可变对象:")

@dataclass(frozen=True)
class ImmutablePerson:
    name: str
    age: int
    email: str
    
    def with_age(self, new_age: int) -> 'ImmutablePerson':
        """返回年龄更新后的新对象"""
        return replace(self, age=new_age)
    
    def with_email(self, new_email: str) -> 'ImmutablePerson':
        """返回邮箱更新后的新对象"""
        return replace(self, email=new_email)

person = ImmutablePerson("Alice", 30, "alice@example.com")
print(f"原始人员: {person}")

# 尝试修改会报错
try:
    person.age = 31  # 这会抛出异常
except AttributeError as e:
    print(f"修改失败: {e}")

# 正确的"修改"方式
updated_person = person.with_age(31)
print(f"更新后的人员: {updated_person}")
print(f"原始人员未变: {person}")

# 4. 不可变集合的实现
print("\n4. 不可变集合的实现:")

class ImmutableList:
    """不可变列表实现"""
    
    def __init__(self, items=None):
        self._items = tuple(items or [])
    
    def __getitem__(self, index):
        return self._items[index]
    
    def __len__(self):
        return len(self._items)
    
    def __iter__(self):
        return iter(self._items)
    
    def __repr__(self):
        return f"ImmutableList({list(self._items)})"
    
    def append(self, item) -> 'ImmutableList':
        """返回添加元素后的新列表"""
        return ImmutableList(self._items + (item,))
    
    def extend(self, items) -> 'ImmutableList':
        """返回扩展后的新列表"""
        return ImmutableList(self._items + tuple(items))
    
    def remove(self, item) -> 'ImmutableList':
        """返回移除元素后的新列表"""
        new_items = [x for x in self._items if x != item]
        return ImmutableList(new_items)
    
    def filter(self, predicate) -> 'ImmutableList':
        """返回过滤后的新列表"""
        filtered_items = [x for x in self._items if predicate(x)]
        return ImmutableList(filtered_items)
    
    def map(self, func) -> 'ImmutableList':
        """返回映射后的新列表"""
        mapped_items = [func(x) for x in self._items]
        return ImmutableList(mapped_items)

# 测试不可变列表
original_list = ImmutableList([1, 2, 3, 4, 5])
print(f"原始列表: {original_list}")

appended_list = original_list.append(6)
print(f"添加元素后: {appended_list}")
print(f"原始列表未变: {original_list}")

filtered_list = original_list.filter(lambda x: x % 2 == 0)
print(f"过滤偶数: {filtered_list}")

mapped_list = original_list.map(lambda x: x ** 2)
print(f"平方映射: {mapped_list}")

# 5. 不可变字典的实现
print("\n5. 不可变字典的实现:")

class ImmutableDict:
    """不可变字典实现"""
    
    def __init__(self, data=None):
        self._data = dict(data or {})
    
    def __getitem__(self, key):
        return self._data[key]
    
    def __contains__(self, key):
        return key in self._data
    
    def __iter__(self):
        return iter(self._data)
    
    def __len__(self):
        return len(self._data)
    
    def __repr__(self):
        return f"ImmutableDict({self._data})"
    
    def get(self, key, default=None):
        return self._data.get(key, default)
    
    def keys(self):
        return self._data.keys()
    
    def values(self):
        return self._data.values()
    
    def items(self):
        return self._data.items()
    
    def set(self, key, value) -> 'ImmutableDict':
        """返回设置键值后的新字典"""
        new_data = self._data.copy()
        new_data[key] = value
        return ImmutableDict(new_data)
    
    def delete(self, key) -> 'ImmutableDict':
        """返回删除键后的新字典"""
        new_data = self._data.copy()
        if key in new_data:
            del new_data[key]
        return ImmutableDict(new_data)
    
    def update(self, other) -> 'ImmutableDict':
        """返回更新后的新字典"""
        new_data = self._data.copy()
        new_data.update(other)
        return ImmutableDict(new_data)

# 测试不可变字典
original_dict = ImmutableDict({'a': 1, 'b': 2, 'c': 3})
print(f"原始字典: {original_dict}")

updated_dict = original_dict.set('d', 4)
print(f"添加键值后: {updated_dict}")
print(f"原始字典未变: {original_dict}")

deleted_dict = original_dict.delete('b')
print(f"删除键后: {deleted_dict}")

# 6. 深度不可变性
print("\n6. 深度不可变性:")

def deep_freeze(obj):
    """深度冻结对象，使其完全不可变"""
    if isinstance(obj, dict):
        return ImmutableDict({k: deep_freeze(v) for k, v in obj.items()})
    elif isinstance(obj, list):
        return ImmutableList([deep_freeze(item) for item in obj])
    elif isinstance(obj, set):
        return frozenset(deep_freeze(item) for item in obj)
    else:
        return obj

# 测试深度冻结
complex_data = {
    'users': [
        {'name': 'Alice', 'scores': [85, 92, 78]},
        {'name': 'Bob', 'scores': [90, 88, 95]}
    ],
    'settings': {
        'theme': 'dark',
        'notifications': True
    }
}

frozen_data = deep_freeze(complex_data)
print(f"冻结的复杂数据类型: {type(frozen_data)}")
print(f"用户列表类型: {type(frozen_data['users'])}")
print(f"第一个用户类型: {type(frozen_data['users'][0])}")
print(f"分数列表类型: {type(frozen_data['users'][0]['scores'])}")

# 7. 不可变性的性能考虑
print("\n7. 不可变性的性能考虑:")

import timeit

# 可变vs不可变性能测试
def mutable_operations():
    data = []
    for i in range(1000):
        data.append(i)
    return data

def immutable_operations():
    data = ImmutableList()
    for i in range(1000):
        data = data.append(i)
    return data

mutable_time = timeit.timeit(mutable_operations, number=100)
immutable_time = timeit.timeit(immutable_operations, number=100)

print(f"可变操作时间: {mutable_time:.4f}秒")
print(f"不可变操作时间: {immutable_time:.4f}秒")
print(f"性能差异: {immutable_time / mutable_time:.2f}x")

print("\n不可变性的优势:")
print("  - 线程安全")
print("  - 可预测的行为")
print("  - 易于推理和调试")
print("  - 支持结构共享优化")
print("  - 避免意外修改")

print("\n不可变性的劣势:")
print("  - 内存开销较大")
print("  - 创建新对象的性能开销")
print("  - 学习曲线较陡")
print("  - 某些算法实现复杂")

高阶函数

map、filter、reduce详解

# map、filter、reduce详解
print("\n=== map、filter、reduce详解 ===")

from functools import reduce
from typing import Iterable, Callable, TypeVar, Iterator
import operator
import itertools

T = TypeVar('T')
U = TypeVar('U')

# 1. map函数详解
print("1. map函数详解:")

# 基本用法
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(f"平方: {squared}")

# 多个可迭代对象
numbers1 = [1, 2, 3, 4]
numbers2 = [10, 20, 30, 40]
sums = list(map(lambda x, y: x + y, numbers1, numbers2))
print(f"对应相加: {sums}")

# 字符串处理
words = ['hello', 'world', 'python', 'programming']
capitalized = list(map(str.capitalize, words))
print(f"首字母大写: {capitalized}")

# 类型转换
string_numbers = ['1', '2', '3', '4', '5']
integers = list(map(int, string_numbers))
print(f"字符串转整数: {integers}")

# 复杂对象处理
people = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]

names = list(map(lambda person: person['name'], people))
ages_next_year = list(map(lambda person: person['age'] + 1, people))
print(f"姓名列表: {names}")
print(f"明年年龄: {ages_next_year}")

# 自定义map实现
def my_map(func: Callable[[T], U], iterable: Iterable[T]) -> Iterator[U]:
    """自定义map实现"""
    for item in iterable:
        yield func(item)

custom_squared = list(my_map(lambda x: x ** 2, numbers))
print(f"自定义map结果: {custom_squared}")

# 2. filter函数详解
print("\n2. filter函数详解:")

# 基本过滤
numbers = list(range(1, 11))
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(f"偶数: {even_numbers}")

# 过滤None值
data_with_none = [1, None, 2, None, 3, 4, None, 5]
filtered_data = list(filter(None, data_with_none))  # None作为过滤函数
print(f"过滤None: {filtered_data}")

# 字符串过滤
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
long_words = list(filter(lambda word: len(word) > 5, words))
print(f"长单词: {long_words}")

# 复杂条件过滤
students = [
    {'name': 'Alice', 'grade': 85, 'age': 20},
    {'name': 'Bob', 'grade': 92, 'age': 19},
    {'name': 'Charlie', 'grade': 78, 'age': 21},
    {'name': 'Diana', 'grade': 96, 'age': 20}
]

excellent_students = list(filter(lambda s: s['grade'] >= 90, students))
young_students = list(filter(lambda s: s['age'] < 21, students))
print(f"优秀学生: {[s['name'] for s in excellent_students]}")
print(f"年轻学生: {[s['name'] for s in young_students]}")

# 自定义filter实现
def my_filter(predicate: Callable[[T], bool], iterable: Iterable[T]) -> Iterator[T]:
    """自定义filter实现"""
    for item in iterable:
        if predicate is None:
            if item:  # 真值测试
                yield item
        elif predicate(item):
            yield item

custom_even = list(my_filter(lambda x: x % 2 == 0, numbers))
print(f"自定义filter结果: {custom_even}")

# 3. reduce函数详解
print("\n3. reduce函数详解:")

# 基本累积
numbers = [1, 2, 3, 4, 5]
sum_result = reduce(lambda x, y: x + y, numbers)
product_result = reduce(lambda x, y: x * y, numbers)
print(f"求和: {sum_result}")
print(f"求积: {product_result}")

# 带初始值的reduce
sum_with_initial = reduce(lambda x, y: x + y, numbers, 100)
print(f"带初始值的求和: {sum_with_initial}")

# 找最大值和最小值
max_value = reduce(lambda x, y: x if x > y else y, numbers)
min_value = reduce(lambda x, y: x if x < y else y, numbers)
print(f"最大值: {max_value}")
print(f"最小值: {min_value}")

# 字符串连接
words = ['Hello', 'World', 'Python', 'Programming']
sentence = reduce(lambda x, y: x + ' ' + y, words)
print(f"连接字符串: {sentence}")

# 复杂对象的reduce
orders = [
    {'id': 1, 'amount': 100.0},
    {'id': 2, 'amount': 250.0},
    {'id': 3, 'amount': 75.0},
    {'id': 4, 'amount': 300.0}
]

total_amount = reduce(lambda acc, order: acc + order['amount'], orders, 0.0)
print(f"订单总金额: {total_amount}")

# 构建复杂数据结构
data = [('a', 1), ('b', 2), ('c', 3), ('a', 4), ('b', 5)]
grouped = reduce(
    lambda acc, item: {
        **acc,
        item[0]: acc.get(item[0], []) + [item[1]]
    },
    data,
    {}
)
print(f"分组数据: {grouped}")

# 自定义reduce实现
def my_reduce(func: Callable[[T, T], T], iterable: Iterable[T], initial=None) -> T:
    """自定义reduce实现"""
    iterator = iter(iterable)
    
    if initial is None:
        try:
            value = next(iterator)
        except StopIteration:
            raise TypeError("reduce() of empty sequence with no initial value")
    else:
        value = initial
    
    for item in iterator:
        value = func(value, item)
    
    return value

custom_sum = my_reduce(lambda x, y: x + y, numbers)
print(f"自定义reduce结果: {custom_sum}")

# 4. 组合使用map、filter、reduce
print("\n4. 组合使用map、filter、reduce:")

# 数据处理管道
sales_data = [
    {'product': 'laptop', 'price': 1200, 'quantity': 2, 'discount': 0.1},
    {'product': 'mouse', 'price': 25, 'quantity': 10, 'discount': 0.0},
    {'product': 'keyboard', 'price': 80, 'quantity': 5, 'discount': 0.05},
    {'product': 'monitor', 'price': 300, 'quantity': 3, 'discount': 0.15}
]

# 计算每个产品的实际收入
revenues = list(map(
    lambda item: item['price'] * item['quantity'] * (1 - item['discount']),
    sales_data
))
print(f"各产品收入: {revenues}")

# 过滤高价值产品（收入>200）
high_value_items = list(filter(
    lambda item: item['price'] * item['quantity'] * (1 - item['discount']) > 200,
    sales_data
))
print(f"高价值产品: {[item['product'] for item in high_value_items]}")

# 计算总收入
total_revenue = reduce(
    lambda acc, item: acc + item['price'] * item['quantity'] * (1 - item['discount']),
    sales_data,
    0.0
)
print(f"总收入: {total_revenue:.2f}")

# 链式操作
processed_revenue = reduce(
    lambda x, y: x + y,
    map(
        lambda item: item['price'] * item['quantity'] * (1 - item['discount']),
        filter(
            lambda item: item['quantity'] > 2,
            sales_data
        )
    ),
    0.0
)
print(f"数量>2的产品总收入: {processed_revenue:.2f}")

# 5. 使用operator模块优化
print("\n5. 使用operator模块优化:")

# 使用operator替代lambda
numbers = [1, 2, 3, 4, 5]

# 求和
sum_op = reduce(operator.add, numbers)
print(f"operator求和: {sum_op}")

# 求积
product_op = reduce(operator.mul, numbers)
print(f"operator求积: {product_op}")

# 获取属性
from operator import attrgetter, itemgetter

people_data = [
    {'name': 'Alice', 'age': 30, 'salary': 50000},
    {'name': 'Bob', 'age': 25, 'salary': 45000},
    {'name': 'Charlie', 'age': 35, 'salary': 60000}
]

# 提取姓名
names_op = list(map(itemgetter('name'), people_data))
print(f"operator提取姓名: {names_op}")

# 提取多个字段
name_age = list(map(itemgetter('name', 'age'), people_data))
print(f"operator提取姓名和年龄: {name_age}")

# 6. 性能比较
print("\n6. 性能比较:")

import timeit

large_numbers = list(range(10000))

# 列表推导式 vs map
def list_comp_square():
    return [x ** 2 for x in large_numbers]

def map_square():
    return list(map(lambda x: x ** 2, large_numbers))

list_comp_time = timeit.timeit(list_comp_square, number=1000)
map_time = timeit.timeit(map_square, number=1000)

print(f"列表推导式时间: {list_comp_time:.4f}秒")
print(f"map函数时间: {map_time:.4f}秒")
print(f"性能比: {list_comp_time / map_time:.2f}")

# 生成器表达式 vs filter
def gen_filter():
    return list(x for x in large_numbers if x % 2 == 0)

def filter_func():
    return list(filter(lambda x: x % 2 == 0, large_numbers))

gen_time = timeit.timeit(gen_filter, number=1000)
filter_time = timeit.timeit(filter_func, number=1000)

print(f"生成器表达式时间: {gen_time:.4f}秒")
print(f"filter函数时间: {filter_time:.4f}秒")
print(f"性能比: {gen_time / filter_time:.2f}")

# 7. 惰性求值
print("\n7. 惰性求值:")

# map和filter返回迭代器，支持惰性求值
print("map和filter的惰性特性:")
large_range = range(1000000)

# 创建map对象（不立即计算）
map_obj = map(lambda x: x ** 2, large_range)
print(f"map对象: {map_obj}")
print(f"map对象类型: {type(map_obj)}")

# 只有在需要时才计算
first_five = list(itertools.islice(map_obj, 5))
print(f"前5个平方: {first_five}")

# filter也是惰性的
filter_obj = filter(lambda x: x % 2 == 0, range(20))
print(f"filter对象: {filter_obj}")
even_numbers = list(filter_obj)
print(f"偶数: {even_numbers}")

# 链式惰性操作
chained = map(
    lambda x: x ** 2,
    filter(
        lambda x: x % 3 == 0,
        range(30)
    )
)
print(f"链式操作结果: {list(chained)}")

### 函数组合和柯里化

```python
# 函数组合和柯里化
print("\n=== 函数组合和柯里化 ===")

from functools import partial, reduce
from typing import Callable, Any
import operator

# 1. 函数组合
print("1. 函数组合:")

def compose(*functions):
    """组合多个函数，从右到左执行"""
    return reduce(lambda f, g: lambda x: f(g(x)), functions, lambda x: x)

def pipe(*functions):
    """管道操作，从左到右执行"""
    return reduce(lambda f, g: lambda x: g(f(x)), functions, lambda x: x)

# 定义基础函数
add_one = lambda x: x + 1
multiply_by_two = lambda x: x * 2
square = lambda x: x ** 2
to_string = lambda x: str(x)

# 函数组合示例
composed_func = compose(to_string, square, multiply_by_two, add_one)
result = composed_func(3)  # ((3+1)*2)^2 -> "64"
print(f"组合函数结果: {result}")

# 管道操作示例
piped_func = pipe(add_one, multiply_by_two, square, to_string)
result2 = piped_func(3)  # ((3+1)*2)^2 -> "64"
print(f"管道函数结果: {result2}")

# 更复杂的函数组合
data_processor = pipe(
    lambda data: [x for x in data if x > 0],  # 过滤正数
    lambda data: [x ** 2 for x in data],      # 平方
    lambda data: sum(data),                   # 求和
    lambda total: total / len([x for x in range(-5, 6) if x > 0])  # 平均值
)

test_data = [-2, -1, 0, 1, 2, 3, 4, 5]
processed = data_processor(test_data)
print(f"数据处理结果: {processed}")

# 2. 高级函数组合
print("\n2. 高级函数组合:")

class FunctionComposer:
    """函数组合器类"""
    
    def __init__(self, func=None):
        self.func = func or (lambda x: x)
    
    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)
    
    def then(self, next_func):
        """链式组合"""
        return FunctionComposer(lambda x: next_func(self.func(x)))
    
    def __rshift__(self, other):
        """使用>>操作符进行组合"""
        if callable(other):
            return self.then(other)
        return NotImplemented
    
    def __lshift__(self, other):
        """使用<<操作符进行反向组合"""
        if callable(other):
            return FunctionComposer(lambda x: self.func(other(x)))
        return NotImplemented

# 使用函数组合器
processor = (FunctionComposer(lambda x: x + 1)
            .then(lambda x: x * 2)
            .then(lambda x: x ** 2)
            .then(str))

result = processor(3)
print(f"组合器结果: {result}")

# 使用操作符
processor2 = FunctionComposer(lambda x: x + 1) >> (lambda x: x * 2) >> (lambda x: x ** 2)
result2 = processor2(3)
print(f"操作符组合结果: {result2}")

# 3. 柯里化基础
print("\n3. 柯里化基础:")

def curry(func, arity=None):
    """将函数柯里化"""
    if arity is None:
        arity = func.__code__.co_argcount
    
    def curried(*args):
        if len(args) >= arity:
            return func(*args[:arity])
        else:
            return lambda *more_args: curried(*(args + more_args))
    
    return curried

# 普通函数
def add_three(a, b, c):
    return a + b + c

def multiply_three(a, b, c):
    return a * b * c

# 柯里化函数
curried_add = curry(add_three)
curried_multiply = curry(multiply_three)

print(f"普通调用: {add_three(1, 2, 3)}")
print(f"柯里化调用: {curried_add(1)(2)(3)}")
print(f"部分应用: {curried_add(1, 2)(3)}")

# 创建专用函数
add_10 = curried_add(10)
result = add_10(5)(3)
print(f"add_10(5)(3) = {result}")

multiply_by_2 = curried_multiply(2)
double_and_add = multiply_by_2(1)  # 相当于 lambda x: 2 * 1 * x
result = double_and_add(5)
print(f"multiply_by_2(1)(5) = {result}")

# 4. 使用partial进行部分应用
print("\n4. 使用partial进行部分应用:")

# 基础partial使用
def power(base, exponent):
    return base ** exponent

square_func = partial(power, exponent=2)
cube_func = partial(power, exponent=3)
power_of_10 = partial(power, 10)

print(f"square_func(5) = {square_func(5)}")
print(f"cube_func(3) = {cube_func(3)}")
print(f"power_of_10(2) = {power_of_10(2)}")

# 复杂partial应用
def format_message(template, name, age, city):
    return template.format(name=name, age=age, city=city)

# 创建特定模板的格式化函数
formal_formatter = partial(
    format_message,
    "Dear {name}, you are {age} years old and live in {city}."
)

casual_formatter = partial(
    format_message,
    "Hey {name}! {age} years old in {city}, nice!"
)

print(f"正式格式: {formal_formatter('Alice', 30, 'New York')}")
print(f"随意格式: {casual_formatter('Bob', 25, 'San Francisco')}")

# 5. 高级柯里化模式
print("\n5. 高级柯里化模式:")

class Curried:
    """柯里化装饰器类"""
    
    def __init__(self, func, args=(), kwargs=None):
        self.func = func
        self.args = args
        self.kwargs = kwargs or {}
        self.arity = func.__code__.co_argcount
    
    def __call__(self, *args, **kwargs):
        new_args = self.args + args
        new_kwargs = {**self.kwargs, **kwargs}
        
        total_args = len(new_args) + len(new_kwargs)
        
        if total_args >= self.arity:
            return self.func(*new_args, **new_kwargs)
        else:
            return Curried(self.func, new_args, new_kwargs)
    
    def __repr__(self):
        return f"Curried({self.func.__name__}, args={self.args}, kwargs={self.kwargs})"

@Curried
def calculate(operation, a, b, c=1):
    """计算函数"""
    if operation == 'add':
        return a + b + c
    elif operation == 'multiply':
        return a * b * c
    elif operation == 'power':
        return (a ** b) * c
    else:
        return 0

# 使用柯里化装饰器
add_calc = calculate('add')
multiply_calc = calculate('multiply')

print(f"add_calc(2)(3) = {add_calc(2)(3)}")
print(f"multiply_calc(2, 3, 4) = {multiply_calc(2, 3, 4)}")

# 6. 函数组合与柯里化结合
print("\n6. 函数组合与柯里化结合:")

# 柯里化的数学函数
curried_add = curry(lambda x, y: x + y)
curried_multiply = curry(lambda x, y: x * y)
curried_power = curry(lambda x, y: x ** y)

# 创建专用函数
add_5 = curried_add(5)
multiply_by_3 = curried_multiply(3)
square_it = curried_power(2)

# 组合这些函数
complex_calc = pipe(
    add_5,           # x + 5
    multiply_by_3,   # (x + 5) * 3
    square_it        # ((x + 5) * 3) ** 2
)

result = complex_calc(2)  # ((2 + 5) * 3) ** 2 = 21 ** 2 = 441
print(f"复杂计算结果: {result}")

# 7. 实际应用示例
print("\n7. 实际应用示例:")

# 数据验证管道
def validate_not_empty(data):
    if not data:
        raise ValueError("数据不能为空")
    return data

def validate_type(expected_type):
    def validator(data):
        if not isinstance(data, expected_type):
            raise TypeError(f"期望类型 {expected_type.__name__}，得到 {type(data).__name__}")
        return data
    return validator

def validate_range(min_val, max_val):
    def validator(data):
        if not (min_val <= data <= max_val):
            raise ValueError(f"值必须在 {min_val} 和 {max_val} 之间")
        return data
    return validator

# 创建验证管道
age_validator = pipe(
    validate_not_empty,
    validate_type(int),
    validate_range(0, 150)
)

# 测试验证
try:
    valid_age = age_validator(25)
    print(f"有效年龄: {valid_age}")
    
    invalid_age = age_validator(200)  # 这会抛出异常
except ValueError as e:
    print(f"验证错误: {e}")

# HTTP请求处理管道
def parse_json(response):
    """解析JSON响应"""
    import json
    return json.loads(response)

def extract_field(field_name):
    """提取特定字段"""
    def extractor(data):
        return data.get(field_name)
    return extractor

def transform_data(transformer):
    """转换数据"""
    def transform(data):
        return transformer(data)
    return transform

# 创建API响应处理管道
api_processor = pipe(
    parse_json,
    extract_field('data'),
    extract_field('users'),
    transform_data(lambda users: [user['name'] for user in users if user.get('active', False)])
)

# 模拟API响应
api_response = '''
{
    "status": "success",
    "data": {
        "users": [
            {"name": "Alice", "active": true},
            {"name": "Bob", "active": false},
            {"name": "Charlie", "active": true}
        ]
    }
}
'''

active_users = api_processor(api_response)
print(f"活跃用户: {active_users}")

# 8. 性能考虑
print("\n8. 性能考虑:")

import timeit

# 直接调用 vs 组合函数
def direct_calculation(x):
    return str(((x + 1) * 2) ** 2)

composed_calculation = compose(str, lambda x: x ** 2, lambda x: x * 2, lambda x: x + 1)

# 性能测试
direct_time = timeit.timeit(lambda: direct_calculation(5), number=100000)
composed_time = timeit.timeit(lambda: composed_calculation(5), number=100000)

print(f"直接调用时间: {direct_time:.4f}秒")
print(f"组合函数时间: {composed_time:.4f}秒")
print(f"性能开销: {(composed_time / direct_time - 1) * 100:.2f}%")

print("\n函数组合和柯里化的优势:")
print("  - 代码重用性高")
print("  - 函数更加专一")
print("  - 易于测试和调试")
print("  - 支持函数式编程范式")
print("  - 提高代码可读性")

print("\n注意事项:")
print("  - 可能有性能开销")
print("  - 调试可能更困难")
print("  - 需要适应函数式思维")
print("  - 过度使用可能降低可读性")

实践练习

练习1：函数式数据处理系统

创建一个完整的函数式数据处理系统，支持链式操作和数据转换。

# 练习1：函数式数据处理系统
print("\n=== 练习1：函数式数据处理系统 ===")

from functools import reduce, partial
from typing import Callable, Iterable, Any, List, Dict
import json
import csv
import io
from datetime import datetime, timedelta
import statistics

class DataProcessor:
    """函数式数据处理器"""
    
    def __init__(self, data=None):
        self.data = data or []
        self.operations = []
    
    def __repr__(self):
        return f"DataProcessor(data={self.data[:3]}{'...' if len(self.data) > 3 else ''})"
    
    def pipe(self, operation: Callable) -> 'DataProcessor':
        """添加处理操作到管道"""
        new_processor = DataProcessor(self.data)
        new_processor.operations = self.operations + [operation]
        return new_processor
    
    def execute(self) -> Any:
        """执行所有操作"""
        result = self.data
        for operation in self.operations:
            result = operation(result)
        return result
    
    def collect(self) -> List:
        """收集结果为列表"""
        result = self.execute()
        return list(result) if hasattr(result, '__iter__') and not isinstance(result, (str, dict)) else result
    
    # 数据源操作
    @classmethod
    def from_list(cls, data: List) -> 'DataProcessor':
        """从列表创建"""
        return cls(data)
    
    @classmethod
    def from_csv_string(cls, csv_string: str, has_header=True) -> 'DataProcessor':
        """从CSV字符串创建"""
        reader = csv.DictReader(io.StringIO(csv_string)) if has_header else csv.reader(io.StringIO(csv_string))
        return cls(list(reader))
    
    @classmethod
    def from_json_string(cls, json_string: str) -> 'DataProcessor':
        """从JSON字符串创建"""
        data = json.loads(json_string)
        return cls(data if isinstance(data, list) else [data])
    
    @classmethod
    def range(cls, start: int, stop: int = None, step: int = 1) -> 'DataProcessor':
        """创建数字范围"""
        if stop is None:
            start, stop = 0, start
        return cls(list(range(start, stop, step)))
    
    # 转换操作
    def map(self, func: Callable) -> 'DataProcessor':
        """映射操作"""
        return self.pipe(lambda data: map(func, data))
    
    def filter(self, predicate: Callable) -> 'DataProcessor':
        """过滤操作"""
        return self.pipe(lambda data: filter(predicate, data))
    
    def reduce(self, func: Callable, initial=None) -> 'DataProcessor':
        """归约操作"""
        if initial is None:
            return self.pipe(lambda data: reduce(func, data))
        else:
            return self.pipe(lambda data: reduce(func, data, initial))
    
    def sort(self, key: Callable = None, reverse: bool = False) -> 'DataProcessor':
        """排序操作"""
        return self.pipe(lambda data: sorted(data, key=key, reverse=reverse))
    
    def group_by(self, key_func: Callable) -> 'DataProcessor':
        """分组操作"""
        def grouper(data):
            groups = {}
            for item in data:
                key = key_func(item)
                if key not in groups:
                    groups[key] = []
                groups[key].append(item)
            return groups
        return self.pipe(grouper)
    
    def unique(self, key_func: Callable = None) -> 'DataProcessor':
        """去重操作"""
        if key_func is None:
            return self.pipe(lambda data: list(set(data)))
        else:
            def uniquer(data):
                seen = set()
                result = []
                for item in data:
                    key = key_func(item)
                    if key not in seen:
                        seen.add(key)
                        result.append(item)
                return result
            return self.pipe(uniquer)
    
    def take(self, n: int) -> 'DataProcessor':
        """取前n个元素"""
        return self.pipe(lambda data: list(data)[:n])
    
    def skip(self, n: int) -> 'DataProcessor':
        """跳过前n个元素"""
        return self.pipe(lambda data: list(data)[n:])
    
    def chunk(self, size: int) -> 'DataProcessor':
        """分块操作"""
        def chunker(data):
            data_list = list(data)
            return [data_list[i:i + size] for i in range(0, len(data_list), size)]
        return self.pipe(chunker)
    
    # 聚合操作
    def count(self) -> 'DataProcessor':
        """计数"""
        return self.pipe(lambda data: len(list(data)))
    
    def sum(self) -> 'DataProcessor':
        """求和"""
        return self.pipe(lambda data: sum(data))
    
    def avg(self) -> 'DataProcessor':
        """平均值"""
        return self.pipe(lambda data: statistics.mean(data))
    
    def min(self) -> 'DataProcessor':
        """最小值"""
        return self.pipe(lambda data: min(data))
    
    def max(self) -> 'DataProcessor':
        """最大值"""
        return self.pipe(lambda data: max(data))
    
    # 输出操作
    def to_json(self, indent=None) -> 'DataProcessor':
        """转换为JSON"""
        return self.pipe(lambda data: json.dumps(list(data), indent=indent, ensure_ascii=False))
    
    def to_csv(self, headers=None) -> 'DataProcessor':
        """转换为CSV"""
        def to_csv_string(data):
            output = io.StringIO()
            data_list = list(data)
            if not data_list:
                return ""
            
            if isinstance(data_list[0], dict):
                fieldnames = headers or data_list[0].keys()
                writer = csv.DictWriter(output, fieldnames=fieldnames)
                writer.writeheader()
                writer.writerows(data_list)
            else:
                writer = csv.writer(output)
                if headers:
                    writer.writerow(headers)
                for row in data_list:
                    writer.writerow(row if isinstance(row, (list, tuple)) else [row])
            
            return output.getvalue()
        
        return self.pipe(to_csv_string)

# 创建一些辅助函数
def parse_date(date_str: str) -> datetime:
    """解析日期字符串"""
    return datetime.strptime(date_str, "%Y-%m-%d")

def format_currency(amount: float) -> str:
    """格式化货币"""
    return f"${amount:,.2f}"

def calculate_age(birth_date: datetime) -> int:
    """计算年龄"""
    today = datetime.now()
    return today.year - birth_date.year - ((today.month, today.day) < (birth_date.month, birth_date.day))

# 示例数据
sales_data = [
    {"id": 1, "product": "Laptop", "category": "Electronics", "price": 1200.00, "quantity": 2, "date": "2024-01-15", "customer_age": 28},
    {"id": 2, "product": "Mouse", "category": "Electronics", "price": 25.00, "quantity": 10, "date": "2024-01-16", "customer_age": 34},
    {"id": 3, "product": "Keyboard", "category": "Electronics", "price": 80.00, "quantity": 5, "date": "2024-01-17", "customer_age": 25},
    {"id": 4, "product": "Monitor", "category": "Electronics", "price": 300.00, "quantity": 3, "date": "2024-01-18", "customer_age": 42},
    {"id": 5, "product": "Chair", "category": "Furniture", "price": 150.00, "quantity": 4, "date": "2024-01-19", "customer_age": 31},
    {"id": 6, "product": "Desk", "category": "Furniture", "price": 200.00, "quantity": 2, "date": "2024-01-20", "customer_age": 29},
    {"id": 7, "product": "Book", "category": "Education", "price": 15.00, "quantity": 20, "date": "2024-01-21", "customer_age": 22},
    {"id": 8, "product": "Pen", "category": "Education", "price": 2.00, "quantity": 50, "date": "2024-01-22", "customer_age": 19}
]

print("原始销售数据:")
for item in sales_data[:3]:
    print(f"  {item}")
print(f"  ... 共{len(sales_data)}条记录")

# 1. 基础数据处理
print("\n1. 基础数据处理:")

# 计算每个订单的总价值
order_values = (DataProcessor.from_list(sales_data)
               .map(lambda item: {**item, 'total_value': item['price'] * item['quantity']})
               .collect())

print("添加总价值字段:")
for item in order_values[:3]:
    print(f"  {item['product']}: {format_currency(item['total_value'])}")

# 过滤高价值订单（>500）
high_value_orders = (DataProcessor.from_list(order_values)
                    .filter(lambda item: item['total_value'] > 500)
                    .collect())

print(f"\n高价值订单（>$500）: {len(high_value_orders)}个")
for order in high_value_orders:
    print(f"  {order['product']}: {format_currency(order['total_value'])}")

# 2. 聚合分析
print("\n2. 聚合分析:")

# 按类别分组并计算总收入
category_revenue = (DataProcessor.from_list(order_values)
                   .group_by(lambda item: item['category'])
                   .execute())

print("按类别分组的收入:")
for category, items in category_revenue.items():
    total_revenue = sum(item['total_value'] for item in items)
    print(f"  {category}: {format_currency(total_revenue)}")

# 计算总收入
total_revenue = (DataProcessor.from_list(order_values)
                .map(lambda item: item['total_value'])
                .sum()
                .execute())

print(f"\n总收入: {format_currency(total_revenue)}")

# 平均订单价值
avg_order_value = (DataProcessor.from_list(order_values)
                  .map(lambda item: item['total_value'])
                  .avg()
                  .execute())

print(f"平均订单价值: {format_currency(avg_order_value)}")

# 3. 复杂数据转换
print("\n3. 复杂数据转换:")

# 创建销售报告
sales_report = (DataProcessor.from_list(order_values)
               .map(lambda item: {
                   'product': item['product'],
                   'category': item['category'],
                   'revenue': item['total_value'],
                   'date': item['date'],
                   'customer_segment': 'Young' if item['customer_age'] < 30 else 'Adult'
               })
               .sort(key=lambda item: item['revenue'], reverse=True)
               .collect())

print("销售报告（按收入排序）:")
for report in sales_report[:5]:
    print(f"  {report['product']}: {format_currency(report['revenue'])} ({report['customer_segment']})")

# 4. 数据导出
print("\n4. 数据导出:")

# 导出为JSON
json_report = (DataProcessor.from_list(sales_report)
              .take(3)
              .to_json(indent=2)
              .execute())

print("JSON格式报告（前3条）:")
print(json_report)

# 导出为CSV
csv_report = (DataProcessor.from_list(sales_report)
             .take(5)
             .to_csv()
             .execute())

print("\nCSV格式报告（前5条）:")
print(csv_report)

# 5. 高级分析
print("\n5. 高级分析:")

# 客户年龄段分析
age_analysis = (DataProcessor.from_list(order_values)
               .group_by(lambda item: 'Young' if item['customer_age'] < 30 else 'Adult')
               .execute())

print("客户年龄段分析:")
for segment, orders in age_analysis.items():
    total_orders = len(orders)
    total_revenue = sum(order['total_value'] for order in orders)
    avg_revenue = total_revenue / total_orders if total_orders > 0 else 0
    print(f"  {segment}: {total_orders}个订单, 总收入{format_currency(total_revenue)}, 平均{format_currency(avg_revenue)}")

# 产品性能分析
product_performance = (DataProcessor.from_list(order_values)
                      .group_by(lambda item: item['product'])
                      .pipe(lambda groups: {
                          product: {
                              'total_quantity': sum(order['quantity'] for order in orders),
                              'total_revenue': sum(order['total_value'] for order in orders),
                              'order_count': len(orders)
                          }
                          for product, orders in groups.items()
                      })
                      .execute())

print("\n产品性能分析:")
for product, metrics in sorted(product_performance.items(), key=lambda x: x[1]['total_revenue'], reverse=True):
    print(f"  {product}:")
    print(f"    销量: {metrics['total_quantity']}")
    print(f"    收入: {format_currency(metrics['total_revenue'])}")
    print(f"    订单数: {metrics['order_count']}")

# 6. 链式复杂操作
print("\n6. 链式复杂操作:")

# 找出每个类别中收入最高的产品
top_products_by_category = (DataProcessor.from_list(order_values)
                           .group_by(lambda item: item['category'])
                           .pipe(lambda groups: {
                               category: max(orders, key=lambda x: x['total_value'])
                               for category, orders in groups.items()
                           })
                           .execute())

print("每个类别收入最高的产品:")
for category, top_product in top_products_by_category.items():
    print(f"  {category}: {top_product['product']} - {format_currency(top_product['total_value'])}")

# 7. 性能测试
print("\n7. 性能测试:")

import timeit

# 生成大量测试数据
large_data = [
    {
        "id": i,
        "value": i * 2,
        "category": f"cat_{i % 10}",
        "active": i % 3 == 0
    }
    for i in range(10000)
]

# 函数式处理
def functional_processing():
    return (DataProcessor.from_list(large_data)
           .filter(lambda x: x['active'])
           .map(lambda x: x['value'] * 2)
           .sum()
           .execute())

# 传统处理
def traditional_processing():
    total = 0
    for item in large_data:
        if item['active']:
            total += item['value'] * 2
    return total

functional_time = timeit.timeit(functional_processing, number=100)
traditional_time = timeit.timeit(traditional_processing, number=100)

print(f"函数式处理时间: {functional_time:.4f}秒")
print(f"传统处理时间: {traditional_time:.4f}秒")
print(f"性能比: {functional_time / traditional_time:.2f}x")

# 验证结果一致性
functional_result = functional_processing()
traditional_result = traditional_processing()
print(f"\n结果一致性: {functional_result == traditional_result}")
print(f"函数式结果: {functional_result}")
print(f"传统结果: {traditional_result}")

练习2：函数式配置管理系统

创建一个基于函数式编程的配置管理系统，支持配置组合、验证和转换。

# 练习2：函数式配置管理系统
print("\n=== 练习2：函数式配置管理系统 ===")

from functools import reduce, partial
from typing import Dict, Any, Callable, Optional, Union, List
import os
import json
from pathlib import Path
from dataclasses import dataclass, field
from copy import deepcopy

# 配置验证器
class ConfigValidator:
    """配置验证器"""
    
    @staticmethod
    def required(key: str) -> Callable:
        """必填验证器"""
        def validator(config: Dict) -> Dict:
            if key not in config or config[key] is None:
                raise ValueError(f"配置项 '{key}' 是必填的")
            return config
        return validator
    
    @staticmethod
    def type_check(key: str, expected_type: type) -> Callable:
        """类型验证器"""
        def validator(config: Dict) -> Dict:
            if key in config and not isinstance(config[key], expected_type):
                raise TypeError(f"配置项 '{key}' 应该是 {expected_type.__name__} 类型")
            return config
        return validator
    
    @staticmethod
    def range_check(key: str, min_val: Any = None, max_val: Any = None) -> Callable:
        """范围验证器"""
        def validator(config: Dict) -> Dict:
            if key in config:
                value = config[key]
                if min_val is not None and value < min_val:
                    raise ValueError(f"配置项 '{key}' 不能小于 {min_val}")
                if max_val is not None and value > max_val:
                    raise ValueError(f"配置项 '{key}' 不能大于 {max_val}")
            return config
        return validator
    
    @staticmethod
    def choices(key: str, valid_choices: List[Any]) -> Callable:
        """选择验证器"""
        def validator(config: Dict) -> Dict:
            if key in config and config[key] not in valid_choices:
                raise ValueError(f"配置项 '{key}' 必须是以下值之一: {valid_choices}")
            return config
        return validator
    
    @staticmethod
    def custom(key: str, validator_func: Callable[[Any], bool], error_msg: str = None) -> Callable:
        """自定义验证器"""
        def validator(config: Dict) -> Dict:
            if key in config and not validator_func(config[key]):
                msg = error_msg or f"配置项 '{key}' 验证失败"
                raise ValueError(msg)
            return config
        return validator

# 配置转换器
class ConfigTransformer:
    """配置转换器"""
    
    @staticmethod
    def default(key: str, default_value: Any) -> Callable:
        """设置默认值"""
        def transformer(config: Dict) -> Dict:
            new_config = config.copy()
            if key not in new_config:
                new_config[key] = default_value
            return new_config
        return transformer
    
    @staticmethod
    def convert_type(key: str, target_type: type) -> Callable:
        """类型转换"""
        def transformer(config: Dict) -> Dict:
            new_config = config.copy()
            if key in new_config:
                try:
                    new_config[key] = target_type(new_config[key])
                except (ValueError, TypeError) as e:
                    raise ValueError(f"无法将配置项 '{key}' 转换为 {target_type.__name__}: {e}")
            return new_config
        return transformer
    
    @staticmethod
    def map_value(key: str, mapping: Dict[Any, Any]) -> Callable:
        """值映射转换"""
        def transformer(config: Dict) -> Dict:
            new_config = config.copy()
            if key in new_config and new_config[key] in mapping:
                new_config[key] = mapping[new_config[key]]
            return new_config
        return transformer
    
    @staticmethod
    def compute(key: str, compute_func: Callable[[Dict], Any]) -> Callable:
        """计算字段"""
        def transformer(config: Dict) -> Dict:
            new_config = config.copy()
            new_config[key] = compute_func(config)
            return new_config
        return transformer
    
    @staticmethod
    def rename(old_key: str, new_key: str) -> Callable:
        """重命名字段"""
        def transformer(config: Dict) -> Dict:
            new_config = config.copy()
            if old_key in new_config:
                new_config[new_key] = new_config.pop(old_key)
            return new_config
        return transformer
    
    @staticmethod
    def remove(key: str) -> Callable:
        """移除字段"""
        def transformer(config: Dict) -> Dict:
            new_config = config.copy()
            new_config.pop(key, None)
            return new_config
        return transformer

# 配置管理器
class FunctionalConfigManager:
    """函数式配置管理器"""
    
    def __init__(self, config: Dict[str, Any] = None):
        self.config = config or {}
        self.transformers = []
        self.validators = []
    
    def __repr__(self):
        return f"FunctionalConfigManager({self.config})"
    
    # 配置加载
    @classmethod
    def from_dict(cls, config_dict: Dict) -> 'FunctionalConfigManager':
        """从字典创建"""
        return cls(deepcopy(config_dict))
    
    @classmethod
    def from_json_file(cls, file_path: str) -> 'FunctionalConfigManager':
        """从JSON文件加载"""
        with open(file_path, 'r', encoding='utf-8') as f:
            config = json.load(f)
        return cls(config)
    
    @classmethod
    def from_env(cls, prefix: str = "") -> 'FunctionalConfigManager':
        """从环境变量加载"""
        config = {}
        for key, value in os.environ.items():
            if key.startswith(prefix):
                config_key = key[len(prefix):].lower()
                config[config_key] = value
        return cls(config)
    
    @classmethod
    def merge(cls, *managers: 'FunctionalConfigManager') -> 'FunctionalConfigManager':
        """合并多个配置管理器"""
        merged_config = {}
        for manager in managers:
            merged_config.update(manager.config)
        return cls(merged_config)
    
    # 函数式操作
    def transform(self, transformer: Callable[[Dict], Dict]) -> 'FunctionalConfigManager':
        """添加转换器"""
        new_manager = FunctionalConfigManager(self.config)
        new_manager.transformers = self.transformers + [transformer]
        new_manager.validators = self.validators.copy()
        return new_manager
    
    def validate(self, validator: Callable[[Dict], Dict]) -> 'FunctionalConfigManager':
        """添加验证器"""
        new_manager = FunctionalConfigManager(self.config)
        new_manager.transformers = self.transformers.copy()
        new_manager.validators = self.validators + [validator]
        return new_manager
    
    def pipe(self, operation: Callable[['FunctionalConfigManager'], 'FunctionalConfigManager']) -> 'FunctionalConfigManager':
        """管道操作"""
        return operation(self)
    
    def build(self) -> Dict[str, Any]:
        """构建最终配置"""
        # 应用所有转换器
        config = self.config
        for transformer in self.transformers:
            config = transformer(config)
        
        # 应用所有验证器
        for validator in self.validators:
            config = validator(config)
        
        return config
    
    def get(self, key: str, default: Any = None) -> Any:
        """获取配置值"""
        final_config = self.build()
        return final_config.get(key, default)
    
    def set(self, key: str, value: Any) -> 'FunctionalConfigManager':
        """设置配置值"""
        new_config = self.config.copy()
        new_config[key] = value
        new_manager = FunctionalConfigManager(new_config)
        new_manager.transformers = self.transformers.copy()
        new_manager.validators = self.validators.copy()
        return new_manager
    
    def update(self, updates: Dict[str, Any]) -> 'FunctionalConfigManager':
        """更新配置"""
        new_config = {**self.config, **updates}
        new_manager = FunctionalConfigManager(new_config)
        new_manager.transformers = self.transformers.copy()
        new_manager.validators = self.validators.copy()
        return new_manager

# 配置模板
class ConfigTemplate:
    """配置模板"""
    
    @staticmethod
    def database_config() -> Callable[[FunctionalConfigManager], FunctionalConfigManager]:
        """数据库配置模板"""
        def template(manager: FunctionalConfigManager) -> FunctionalConfigManager:
            return (manager
                   .transform(ConfigTransformer.default('db_host', 'localhost'))
                   .transform(ConfigTransformer.default('db_port', 5432))
                   .transform(ConfigTransformer.default('db_name', 'myapp'))
                   .transform(ConfigTransformer.default('db_timeout', 30))
                   .transform(ConfigTransformer.convert_type('db_port', int))
                   .transform(ConfigTransformer.convert_type('db_timeout', int))
                   .validate(ConfigValidator.required('db_host'))
                   .validate(ConfigValidator.required('db_name'))
                   .validate(ConfigValidator.type_check('db_port', int))
                   .validate(ConfigValidator.range_check('db_port', 1, 65535))
                   .validate(ConfigValidator.range_check('db_timeout', 1, 300)))
        return template
    
    @staticmethod
    def web_server_config() -> Callable[[FunctionalConfigManager], FunctionalConfigManager]:
        """Web服务器配置模板"""
        def template(manager: FunctionalConfigManager) -> FunctionalConfigManager:
            return (manager
                   .transform(ConfigTransformer.default('host', '0.0.0.0'))
                   .transform(ConfigTransformer.default('port', 8000))
                   .transform(ConfigTransformer.default('debug', False))
                   .transform(ConfigTransformer.default('workers', 4))
                   .transform(ConfigTransformer.convert_type('port', int))
                   .transform(ConfigTransformer.convert_type('debug', bool))
                   .transform(ConfigTransformer.convert_type('workers', int))
                   .validate(ConfigValidator.type_check('host', str))
                   .validate(ConfigValidator.range_check('port', 1, 65535))
                   .validate(ConfigValidator.range_check('workers', 1, 32))
                   .validate(ConfigValidator.choices('debug', [True, False])))
        return template
    
    @staticmethod
    def logging_config() -> Callable[[FunctionalConfigManager], FunctionalConfigManager]:
        """日志配置模板"""
        def template(manager: FunctionalConfigManager) -> FunctionalConfigManager:
            return (manager
                   .transform(ConfigTransformer.default('log_level', 'INFO'))
                   .transform(ConfigTransformer.default('log_format', '%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
                   .transform(ConfigTransformer.default('log_file', None))
                   .transform(ConfigTransformer.map_value('log_level', {
                       'debug': 'DEBUG',
                       'info': 'INFO',
                       'warning': 'WARNING',
                       'error': 'ERROR',
                       'critical': 'CRITICAL'
                   }))
                   .validate(ConfigValidator.choices('log_level', ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']))
                   .validate(ConfigValidator.type_check('log_format', str)))
        return template

# 示例使用
print("配置管理系统演示:")

# 1. 基础配置创建
print("\n1. 基础配置创建:")

base_config = {
    'app_name': 'MyApp',
    'version': '1.0.0',
    'db_host': 'localhost',
    'db_port': '5432',  # 字符串，需要转换
    'port': '8080',     # 字符串，需要转换
    'debug': 'true',    # 字符串，需要转换
    'log_level': 'info' # 小写，需要映射
}

config_manager = FunctionalConfigManager.from_dict(base_config)
print(f"原始配置: {config_manager.config}")

# 2. 应用配置模板
print("\n2. 应用配置模板:")

final_config = (config_manager
               .pipe(ConfigTemplate.database_config())
               .pipe(ConfigTemplate.web_server_config())
               .pipe(ConfigTemplate.logging_config())
               .build())

print("处理后的配置:")
for key, value in final_config.items():
    print(f"  {key}: {value} ({type(value).__name__})")

# 3. 配置验证
print("\n3. 配置验证:")

# 测试无效配置
invalid_config = {
    'db_port': 70000,  # 超出范围
    'debug': 'maybe',  # 无效值
    'workers': 0       # 超出范围
}

try:
    invalid_manager = (FunctionalConfigManager.from_dict(invalid_config)
                      .pipe(ConfigTemplate.database_config())
                      .pipe(ConfigTemplate.web_server_config())
                      .build())
except (ValueError, TypeError) as e:
    print(f"配置验证失败: {e}")

# 4. 环境特定配置
print("\n4. 环境特定配置:")

# 模拟不同环境的配置
development_config = {
    'debug': True,
    'log_level': 'DEBUG',
    'db_name': 'myapp_dev'
}

production_config = {
    'debug': False,
    'log_level': 'WARNING',
    'db_name': 'myapp_prod',
    'workers': 8
}

# 创建环境特定的配置管理器
def create_env_config(env: str) -> FunctionalConfigManager:
    """创建环境特定配置"""
    base = FunctionalConfigManager.from_dict(base_config)
    
    if env == 'development':
        env_config = FunctionalConfigManager.from_dict(development_config)
    elif env == 'production':
        env_config = FunctionalConfigManager.from_dict(production_config)
    else:
        env_config = FunctionalConfigManager()
    
    return (FunctionalConfigManager.merge(base, env_config)
           .pipe(ConfigTemplate.database_config())
           .pipe(ConfigTemplate.web_server_config())
           .pipe(ConfigTemplate.logging_config()))

# 测试不同环境
for env in ['development', 'production']:
    env_config = create_env_config(env).build()
    print(f"\n{env.capitalize()} 环境配置:")
    print(f"  Debug: {env_config['debug']}")
    print(f"  Log Level: {env_config['log_level']}")
    print(f"  Workers: {env_config['workers']}")
    print(f"  DB Name: {env_config['db_name']}")

# 5. 动态配置计算
print("\n5. 动态配置计算:")

# 添加计算字段
computed_config = (config_manager
                  .transform(ConfigTransformer.compute('db_url', 
                      lambda cfg: f"postgresql://{cfg.get('db_host', 'localhost')}:{cfg.get('db_port', 5432)}/{cfg.get('db_name', 'myapp')}"))
                  .transform(ConfigTransformer.compute('server_info',
                      lambda cfg: f"{cfg.get('app_name', 'App')} v{cfg.get('version', '1.0')} on {cfg.get('host', 'localhost')}:{cfg.get('port', 8000)}"))
                  .pipe(ConfigTemplate.database_config())
                  .pipe(ConfigTemplate.web_server_config())
                  .build())

print("计算字段:")
print(f"  DB URL: {computed_config['db_url']}")
print(f"  Server Info: {computed_config['server_info']}")

# 6. 配置链式操作
print("\n6. 配置链式操作:")

# 复杂的配置处理链
complex_config = (FunctionalConfigManager.from_dict({
                     'raw_timeout': '30s',
                     'raw_memory': '512MB',
                     'feature_flags': 'feature1,feature2,feature3'
                 })
                 .transform(ConfigTransformer.convert_type('raw_timeout', str))
                 .transform(ConfigTransformer.compute('timeout_seconds', 
                     lambda cfg: int(cfg['raw_timeout'].rstrip('s'))))
                 .transform(ConfigTransformer.compute('memory_mb',
                     lambda cfg: int(cfg['raw_memory'].rstrip('MB'))))
                 .transform(ConfigTransformer.compute('features',
                     lambda cfg: cfg['feature_flags'].split(',')))
                 .transform(ConfigTransformer.remove('raw_timeout'))
                 .transform(ConfigTransformer.remove('raw_memory'))
                 .transform(ConfigTransformer.remove('feature_flags'))
                 .validate(ConfigValidator.range_check('timeout_seconds', 1, 300))
                 .validate(ConfigValidator.range_check('memory_mb', 64, 2048))
                 .build())

print("复杂配置处理结果:")
for key, value in complex_config.items():
    print(f"  {key}: {value} ({type(value).__name__})")

# 7. 配置性能测试
print("\n7. 配置性能测试:")

import timeit

# 创建大量配置项
large_config = {f'key_{i}': f'value_{i}' for i in range(1000)}

def functional_config_processing():
    manager = FunctionalConfigManager.from_dict(large_config)
    for i in range(100):
        manager = manager.transform(ConfigTransformer.default(f'default_{i}', i))
    return manager.build()

def traditional_config_processing():
    config = large_config.copy()
    for i in range(100):
        if f'default_{i}' not in config:
            config[f'default_{i}'] = i
    return config

functional_time = timeit.timeit(functional_config_processing, number=10)
traditional_time = timeit.timeit(traditional_config_processing, number=10)

print(f"函数式配置处理时间: {functional_time:.4f}秒")
print(f"传统配置处理时间: {traditional_time:.4f}秒")
print(f"性能比: {functional_time / traditional_time:.2f}x")

print("\n函数式配置管理的优势:")
print("  - 不可变性保证配置安全")
print("  - 链式操作提高可读性")
print("  - 模块化验证和转换")
print("  - 易于测试和调试")
print("  - 支持配置组合和继承")

总结

本章节深入探讨了lambda表达式与函数式编程的核心概念和实际应用。

核心知识点

1. Lambda表达式基础

• 语法结构: lambda 参数: 表达式
• 特性: 匿名函数、单一表达式、返回值自动返回
• 应用场景: 简短函数、回调函数、函数式编程
• 限制: 只能包含表达式，不能包含语句

2. 函数式编程核心概念

• 纯函数: 无副作用、相同输入产生相同输出
• 不可变性: 数据不可修改，通过创建新数据实现变更
• 惰性求值: 延迟计算，提高性能和内存效率
• 函数组合: 将简单函数组合成复杂功能

3. 高阶函数应用

• map(): 映射转换，将函数应用到序列每个元素
• filter(): 过滤筛选，根据条件筛选元素
• reduce(): 归约聚合，将序列归约为单一值
• sorted(): 排序操作，支持自定义排序键

4. 函数组合与柯里化

• 函数组合: 将多个函数连接成处理管道
• 柯里化: 将多参数函数转换为单参数函数序列
• 偏函数: 固定部分参数，创建新的专用函数
• 管道操作: 数据流式处理，提高代码可读性

技能掌握

基础技能

• ✅ 编写和使用lambda表达式
• ✅ 理解纯函数和副作用概念
• ✅ 使用map、filter、reduce进行数据处理
• ✅ 掌握函数式编程基本思维

中级技能

• ✅ 实现函数组合和管道操作
• ✅ 使用柯里化和偏函数应用
• ✅ 设计不可变数据结构
• ✅ 利用惰性求值优化性能

高级技能

• ✅ 构建复杂的函数式数据处理系统
• ✅ 设计函数式配置管理系统
• ✅ 实现高阶函数和装饰器模式
• ✅ 优化函数式代码的性能

最佳实践

1. 设计原则

• 保持函数纯净: 避免副作用，确保函数可预测
• 优先不可变: 使用不可变数据结构，避免意外修改
• 函数单一职责: 每个函数只做一件事，便于组合
• 合理使用lambda: 简单逻辑用lambda，复杂逻辑用命名函数

2. 性能考虑

• 惰性求值: 利用生成器和迭代器延迟计算
• 避免过度抽象: 平衡函数式风格和性能需求
• 内存管理: 注意函数式操作的内存使用
• 缓存策略: 对纯函数结果进行缓存优化

3. 代码可读性

• 适度使用: 不要为了函数式而函数式
• 清晰命名: 给lambda表达式所在的变量起有意义的名字
• 文档说明: 为复杂的函数组合添加注释
• 类型提示: 使用类型注解提高代码可读性

4. 错误处理

• 异常传播: 设计合理的异常处理机制
• 输入验证: 在函数入口进行参数验证
• 容错设计: 提供默认值和降级策略
• 调试支持: 保留足够的调试信息

常见陷阱

1. Lambda表达式误用

# ❌ 错误：过于复杂的lambda
process = lambda x: x.strip().lower().replace(' ', '_') if x else 'default'

# ✅ 正确：使用命名函数
def normalize_string(text):
    """标准化字符串格式"""
    return text.strip().lower().replace(' ', '_') if text else 'default'

2. 副作用问题

# ❌ 错误：有副作用的函数
counter = 0
def impure_increment(x):
    global counter
    counter += 1  # 副作用
    return x + counter

# ✅ 正确：纯函数
def pure_increment(x, increment):
    return x + increment

3. 性能问题

# ❌ 错误：重复计算
result = list(map(expensive_function, 
                 filter(lambda x: expensive_function(x) > 0, data)))

# ✅ 正确：避免重复计算
processed = [(x, expensive_function(x)) for x in data]
result = [x for x, value in processed if value > 0]

4. 内存泄漏

# ❌ 错误：闭包引用大对象
def create_processor(large_data):
    return lambda x: process_with_data(x, large_data)

# ✅ 正确：只引用必要的数据
def create_processor(large_data):
    essential_data = extract_essential(large_data)
    return lambda x: process_with_data(x, essential_data)

性能考虑

1. 内存使用

• 生成器优先: 使用生成器表达式替代列表推导
• 惰性求值: 利用map、filter的惰性特性
• 及时释放: 避免闭包引用大对象
• 内存监控: 监控函数式操作的内存使用

2. 计算效率

• 算法复杂度: 选择合适的函数式算法
• 缓存机制: 对纯函数结果进行缓存
• 并行处理: 利用函数式编程的并行特性
• 编译优化: 了解Python解释器的优化机制

3. 优化策略

• 性能测试: 定期进行性能基准测试
• 瓶颈分析: 识别性能瓶颈并针对性优化
• 混合模式: 结合命令式和函数式编程
• 工具使用: 利用性能分析工具

下一步学习

1. 深入主题

• 函数式库: 学习toolz、funcy等函数式编程库
• 并发编程: 探索函数式并发和异步编程
• 类型系统: 学习类型驱动的函数式编程
• 设计模式: 掌握函数式设计模式

2. 实践项目

• 数据分析: 使用函数式方法进行数据分析
• Web开发: 在Web框架中应用函数式编程
• 算法实现: 用函数式方法实现经典算法
• 系统设计: 设计函数式架构的系统

3. 相关技术

• 响应式编程: 学习RxPY等响应式编程库
• 函数式语言: 了解Haskell、Clojure等纯函数式语言
• 数学基础: 学习范畴论、λ演算等理论基础
• 编译原理: 理解函数式语言的编译和优化

扩展阅读

1. 官方文档

• Python functools模块
• Python itertools模块
• Python operator模块

2. 推荐书籍

• 《Functional Python Programming》- Steven Lott
• 《函数式编程思维》- Neal Ford
• 《Python函数式编程》- 刘宇

3. 在线资源

• Real Python - Functional Programming
• Python Course - Functional Programming
• Awesome Functional Python

4. 实践平台

• LeetCode函数式编程题目
• HackerRank函数式编程
• Codewars函数式编程

---

本章节完成了lambda表达式与函数式编程的全面学习，掌握了函数式编程的核心概念、实践技巧和性能优化方法。下一章节将学习正则表达式详解，探索文本处理和模式匹配的强大功能。