Python避免使用lambda作为需要两个可调用对象的键（函数组合）

Question

我正在研究项目欧拉问题14，并且第一次尝试提出了这种蛮力解决方案：

def collatz(n, memo={1: [1]}):
    if n not in memo:
        memo[n] = [n] + collatz(3 * n + 1 if n % 2 else n // 2)
    return memo[n]

def p014():
    return max(xrange(1, 10**6), key=lambda n: len(collatz(n)))

我的问题是关于那个lambda的，我通常不愿意使用它们，但是在这种情况下，我不知道有什么优雅的方法来避免使用它。是否存在functools将两个可调用对象链接起来的东西或其他东西，或者我缺少的其他任何巧妙的选择？

Answer 1

如果有一个compose功能的话-
也许在里面会很可爱functools。没有，我也不指望会有，唉。用Raymond
Hettinger的话来说，

先前已在其他论坛中进行了讨论和拒绝。问题之一是通常的数学顺序是不直观的，并且不能自我证明-即compose(f,g)
与f(g(x))或g(f(x))？相同。此外，它已经是污垢容易创建自己构建功能，或者直接做组成： h = lambda x: f(g(x))。

这里有两个简单的实现方式的compose一个可调用的类，可能对你有用，但：

# Scott Daniels, http://code.activestate.com/recipes/52902-function-composition/
# Lightly edited for style.
class Compose(object):
    '''Compose functions. compose(f,g,x...)(y...) = f(g(y...),x...))'''
    def __init__(self, f, g, *args, **kwargs):
        self.f = f
        self.g = g
        self.pending = args[:]
        self.kwargs = kwargs.copy()

    def __call__(self, *args, **kwargs):
        return self.f(self.g(*args, **kwargs), *self.pending, **self.kwargs)


class Starcompose:
    '''Compose functions. Starcompose(f,g,x...)(y...) = f(*g(y...),x...))'''
    TupleType = type(())

    def __init__(self, f, g, *args, **kwargs):
        self.f = f
        self.g = g
        self.pending = args[:]
        self.kwargs = kwargs.copy()

    def __call__(self, *args, **kwargs):
        mid = self.g(*args, **kwargs)
        if isinstance(mid, self.TupleType):
            return self.f(*(mid + self.pending), **self.kwargs)
        return self.f(mid, *self.pending, **self.kwargs)

另外，请参阅该functional软件包，它启发compose_many了我的这个非常简单的功能：

def compose(f1, f2):
    def composition(*args, **kwargs):
        return f1(f2(*args, **kwargs))
    return composition

def compose_many(*funcs):
    return reduce(compose, funcs)