如何在Python中实现类似OCaml的可组合谓词逻辑？

你遇到的递归超限问题，本质是Python闭包的延迟绑定特性导致的：新定义的lambda里引用的fltr变量，指向的是最终赋值后的fltr自身，而非修改前的初始谓词，所以调用时会无限递归自己。下面是几种解决方法和推荐的谓词组合方案：

1. 用默认参数捕获当前谓词值 #

这是最直接的修复方式，通过lambda的默认参数在定义时就绑定当前的fltr值，避免后续变量覆盖带来的问题：

def example(v: int, opt_n=None):
    fltr = lambda i: i % 2 == 0
    if opt_n is not None:
        # 用默认参数f绑定修改前的fltr
        fltr = lambda i, f=fltr: f(i) and i % opt_n == 0
    return fltr(v)

print(example(10, 5))  # 输出True
print(example(9, 3))   # 输出False（9不是偶数）

2. 用类封装谓词（推荐复杂场景） #

如果你的实际场景需要大量谓词组合、扩展，比如支持逻辑与/或/非，用类封装是更清晰、可维护的方案。可以通过重载运算符让谓词组合像原生逻辑操作一样直观：

class Predicate:
    def __init__(self, func):
        self.func = func
    
    def __call__(self, value):
        return self.func(value)
    
    # 重载&运算符，实现逻辑与
    def __and__(self, other):
        return Predicate(lambda x: self(x) and other(x))
    
    # 重载|运算符，实现逻辑或
    def __or__(self, other):
        return Predicate(lambda x: self(x) or other(x))
    
    # 重载~运算符，实现逻辑非
    def __invert__(self):
        return Predicate(lambda x: not self(x))

def example(v: int, opt_n=None):
    # 初始谓词：检查是否为偶数
    fltr = Predicate(lambda i: i % 2 == 0)
    if opt_n is not None:
        # 组合新谓词：同时满足原条件 + 能被opt_n整除
        fltr = fltr & Predicate(lambda i: i % opt_n == 0)
    return fltr(v)

print(example(10, 5))  # True
print(example(12, 3))  # True
print(example(7, 7))   # False（7不是偶数）

这种方式可以轻松扩展更多操作，比如添加__xor__实现异或，或者自定义matches_any等方法，完全适配大量可选条件的场景。

3. 用列表收集谓词（简洁灵活） #

如果你的谓词都是独立的检查项，不需要嵌套组合，直接把所有需要满足的谓词收集到列表里，最后统一判断是否全部满足，这种方式最简洁：

def example(v: int, opt_n=None):
    predicates = [lambda i: i % 2 == 0]
    if opt_n is not None:
        predicates.append(lambda i: i % opt_n == 0)
    # 检查所有谓词是否都成立
    return all(p(v) for p in predicates)

print(example(10, 5))  # True
print(example(8, 3))   # False（8不能被3整除）

后续要添加更多条件，比如检查是否大于10，直接predicates.append(lambda i: i > 10)即可，非常直观。

内容的提问来源于stack exchange，提问作者Denis