为什么使用可调用对象处理数列？

• 代码重用：避免重复编写相似的处理逻辑
• 可读性：将复杂操作封装成有意义的函数名
• 灵活性：可以轻松组合和替换不同的处理逻辑
• 函数式编程：支持map、filter等高阶函数

示例1：基本数列处理函数

# 计算数列平均值
def calculate_average(sequence):
    return sum(sequence) / len(sequence) if sequence else 0

# 过滤出偶数
def filter_even(numbers):
    return [x for x in numbers if x % 2 == 0]

# 应用函数
data = [1, 2, 3, 4, 5, 6]
print("平均值:", calculate_average(data))
print("偶数:", filter_even(data))

示例2：数列转换函数

# 应用平方转换
def square_elements(sequence):
    return [x**2 for x in sequence]

# 应用自定义转换
def transform_sequence(sequence, transformation):
    return [transformation(x) for x in sequence]

# 使用示例
numbers = [1, 2, 3, 4]
print("平方:", square_elements(numbers))

# 传递函数作为参数
def double(x): 
    return x * 2

print("加倍:", transform_sequence(numbers, double))

基本Lambda用法

# 使用lambda立即执行
result = (lambda x, y: x + y)(3, 4)
print("3 + 4 =", result)

# 将lambda赋值给变量
square = lambda x: x ** 2
print("5的平方:", square(5))

在数列处理中使用Lambda

# 使用lambda进行数列转换
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print("平方:", squared)

# 使用lambda过滤数列
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print("偶数:", even_numbers)

# 使用lambda排序
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
sorted_pairs = sorted(pairs, key=lambda pair: pair[1])
print("按字母排序:", sorted_pairs)

Lambda表达式最佳实践

• 只用于简单的单行操作
• 避免复杂的逻辑（这时应该使用普通函数）
• 确保表达式清晰易读
• 与高阶函数（map、filter、sorted）结合使用

组合高阶函数

# 处理数列：过滤偶数 -> 平方 -> 求和
from functools import reduce

numbers = range(1, 11)  # [1, 2, ..., 10]

result = reduce(
    lambda x, y: x + y,
    map(
        lambda x: x**2,
        filter(lambda x: x % 2 == 0, numbers)
    )
)

print("偶数的平方和:", result)  # 2² + 4² + 6² + 8² + 10² = 220

基本可调用类

class SequenceProcessor:
    def __init__(self, operation):
        self.operation = operation
        
    def __call__(self, sequence):
        return [self.operation(x) for x in sequence]

# 创建处理器实例
square_processor = SequenceProcessor(lambda x: x**2)
cube_processor = SequenceProcessor(lambda x: x**3)

# 像函数一样调用
numbers = [1, 2, 3, 4]
print("平方:", square_processor(numbers))
print("立方:", cube_processor(numbers))

带状态的可调用处理器

class AdvancedSequenceTransformer:
    def __init__(self, multiplier=1, exponent=1):
        self.multiplier = multiplier
        self.exponent = exponent
        
    def __call__(self, sequence):
        return [self.multiplier * (x ** self.exponent) for x in sequence]
        
    def set_multiplier(self, value):
        self.multiplier = value
        
    def set_exponent(self, value):
        self.exponent = value

# 使用示例
transformer = AdvancedSequenceTransformer(multiplier=2, exponent=3)
numbers = [1, 2, 3, 4]
print("2 * x^3:", transformer(numbers))  # [2, 16, 54, 128]

# 更新参数
transformer.set_multiplier(3)
print("3 * x^3:", transformer(numbers))  # [3, 24, 81, 192]

生成器表达式与惰性求值

# 使用生成器处理大型数列
def large_sequence_processor(sequence, transformation):
    return (transformation(x) for x in sequence)  # 返回生成器而非列表

# 处理大型数据集
big_data = range(1, 1000000)  # 一百万个元素

# 使用生成器处理（惰性求值）
processed = large_sequence_processor(big_data, lambda x: x**2)

# 只计算前10个结果
for i, value in enumerate(processed):
    if i >= 10:
        break
    print(value)

使用functools.partial创建专用函数

from functools import partial

def power(base, exponent):
    return base ** exponent

# 创建专用函数
square = partial(power, exponent=2)
cube = partial(power, exponent=3)

# 使用专用函数处理数列
numbers = [1, 2, 3, 4, 5]
squares = list(map(square, numbers))
cubes = list(map(cube, numbers))

print("平方:", squares)
print("立方:", cubes)

性能优化建议

• 对于大型数据集，使用生成器而非列表推导
• 在需要多次调用时缓存可调用对象
• 使用内置函数（如sum、max）替代reduce
• 考虑使用NumPy进行数值计算密集型操作
• 使用lru_cache记忆化重复计算