Python 惰性求值器

Question

是否有一种 Pythonic 方法来封装惰性函数调用，即在第一次使用函数 f() 时，它调用先前绑定的函数 g(Z) 并在连续调用 f() 返回缓存值？

请注意，记忆可能并不完美。

我有：

f = g(Z)
if x:
     return 5
elif y:
     return f
elif z:
     return h(f)

该代码可以工作，但我想对其进行重组，以便仅在使用该值时才调用 g(Z) 。我不想更改 g(...) 的定义，而且 Z 有点大，无法缓存。

编辑：我认为 f 必须是一个函数，但情况可能并非如此。

Answer 1

我有点困惑你是否寻求缓存或惰性评估。对于后者，请查看 Alberto Bertogli 的 lazy.py 模块。

Answer 2

尝试使用这个装饰器：（

class Memoize:
    def __init__ (self, f):
        self.f = f
        self.mem = {}
    def __call__ (self, *args, **kwargs):
        if (args, str(kwargs)) in self.mem:
            return self.mem[args, str(kwargs)]
        else:
            tmp = self.f(*args, **kwargs)
            self.mem[args, str(kwargs)] = tmp
            return tmp

从死链接中提取：http://snippets.dzone.com/posts /show/4840 / https://web.archive.org/web/20081026130601/http://snippets.dzone.com/posts/show/4840）
（在这里找到：是否有一个装饰器来简单地缓存函数返回值？作者：Alex Martelli）

编辑：这是另一个属性形式的（使用__get__）http://code.activestate.com/recipes/363602/

Answer 3

好奇为什么在这种情况下不直接使用 lambda ？

f = lambda: g(z)
if x:
    return 5
if y:
    return f()
if z:
    return h(f())

Answer 4

您可以使用缓存装饰器，让我们看一个示例

from functools import wraps

class FuncCache(object):
    def __init__(self):
        self.cache = {}

    def __call__(self, func):
        @wraps(func)
        def callee(*args, **kwargs):
            key = (args, str(kwargs))
            # see is there already result in cache
            if key in self.cache:
                result = self.cache.get(key)
            else:
                result = func(*args, **kwargs)
                self.cache[key] = result
            return result
        return callee

使用缓存装饰器，在这里您可以编写

my_cache = FuncCache()

@my_cache
def foo(n):
    """Expensive calculation

    """
    sum = 0
    for i in xrange(n):
        sum += i
    print 'called foo with result', sum
    return sum

print foo(10000)
print foo(10000)
print foo(1234)

正如您从输出中看到的那样，

called foo with result 49995000
49995000
49995000

foo 将仅被调用一次。您不必更改函数 foo 的任何行。这就是装饰器的力量。

Answer 5

有很多用于记忆的装饰器：

http://wiki.python.org/moin/ PythonDecoratorLibrary#Memoize
http://code.activestate.com/recipes/498110-memoize-decorator-with-o1-length-limited-lru-cache/
http://code.activestate.com/ Recipes/496879-memoize-decorator-function-with-cache-size-limit/

提出一个完全通用的解决方案比您想象的要困难。例如，您需要注意不可散列的函数参数，并且需要确保缓存不会变得太大。

如果您确实正在寻找惰性函数调用（仅在需要值时才实际评估函数的调用），您可能可以使用生成器。

编辑：所以我想你真正想要的是惰性评估。这可能就是您正在寻找的库：

http://pypi.python.org/pypi /lazypy/0.5

Answer 6

这里是一个非常简短的惰性装饰器，尽管它缺少使用 @functools.wraps （实际上返回一个 Lazy 实例以及其他一些潜在的陷阱）：

class Lazy(object):
    def __init__(self, calculate_function):
        self._calculate = calculate_function

    def __get__(self, obj, _=None):
        if obj is None:
            return self
        value = self._calculate(obj)
        setattr(obj, self._calculate.func_name, value)
        return value


# Sample use:

class SomeClass(object):

    @Lazy
    def someprop(self):
        print 'Actually calculating value'
        return 13


o = SomeClass()
o.someprop
o.someprop

Answer 7

即使经过您的编辑和一系列详细的评论，我仍然不太明白。在第一句话中，您说对 f() 的第一次调用应该调用 g()，但随后返回缓存的值。但随后在您的评论中，您说“无论如何，g() 都不会被调用”（强调我的）。我不确定你在否定什么：你是说 g() 不应该被调用（没有多大意义；为什么 g() 存在？）；或者 g()可能被调用，但也可能不会（好吧，这仍然与第一次调用 f() 时调用 g() 相矛盾）。然后，您给出一个根本不涉及 g() 的片段，并且实际上与您的问题的第一句话或与 detly 的评论线程无关。

如果您再次编辑它，这是我回复的片段：

我有：

<前><代码>a = f(Z)
如果x：
返回5
埃莉芙：
返回一个
埃利夫·Z：
返回 h(a)

代码有效，但我想要
重构它，使 f(Z) 仅是
如果使用该值则调用。我不
想要改变的定义
f(...)，Z 有点大，无法缓存。

如果这确实是您的问题，那么答案很简单，

if x:
    return 5
elif y:
    return f(Z)
elif z:
    return h(f(Z))

那就是如何实现“仅在使用该值时才调用 f(Z)”。

我不完全理解“Z 有点大而无法缓存”。如果您的意思是在程序执行过程中会有太多不同的 Z 值而记忆是无用的，那么也许您必须诉诸于预先计算 f(Z) 的所有值并在运行时查找它们。如果你不能做到这一点（因为你无法知道你的程序将遇到的 Z 值），那么你又回到了记忆。如果这仍然太慢，那么您唯一真正的选择是使用比 Python 更快的东西（尝试 Psyco、Cython、ShedSkin 或手动编码的 C 模块）。

Answer 8

为了完整起见，这里是我的惰性评估器装饰器食谱的链接：

https:/ /bitbucket.org/jsbueno/metapython/src/f48d6bd388fd/lazy_decorator.py