Question

给定函数a, b = f(x)，是否有任何（pythonic）方法来确定实际使用哪些返回参数？作为一个伪示例，请考虑

def f(x):
    c = common_helper_function(x)
    a = a_complex_function(x,c)
    b = another_complex_function(x,c)
    return a, b

每个函数调用需要一段时间。如果f被调用，例如作为_, b = f(x)，有没有办法检测a f内部a_complex_function(x,c)的不相关性，因此b(x)不需要调用？果然我可以写另一个省略该调用的函数{{1}}，但是有另一种方法可以实现这一点，类似于例如MATLAB的nargout机制？

Answer 1

我认为如果python是lazy language，那么它可能是可能的，但你的代码应该像

一样改变

def f(x):
    c = common_helper_function(x)
    return a_complex_function(x,c), another_complex_function(x,c)

在python中，这不是真的

def test1():
    print '     simple function'
    return 1

print 'Calling simple function:'
_ = (lambda : test1())()
print 'Calling simple function again:'
_ = (lambda : test1())()

output:
Calling simple function:
    simple function # evaluated once
Calling simple function again:
    simple function # evaluated twice

为了提高性能，我建议你看两个概念：

Memoization - 您可以在字典中保留函数的结果，并且一旦计算就不会重新计算它。对于memoization，在python 3的lru_cache模块中有functools装饰器（forpython 2.7你可以下载functools32）。这是一个例子

from functools32 import lru_cache

@lru_cache(maxsize=10)
def test2():
    print '     cashed function'
    return 1

print 'Calling cashed function:'
_ = (lambda : test2())()
print 'Calling cashed function again:'
_ = (lambda : test2())()

output:
Calling cashed function:
    cashed function # evaluated once
Calling cashed function again:
                    # not evaluated twice

Lazy evaluation。在尝试获取函数结果然后存储时，函数的每个结果都会计算一次。因此，在您使用存储函数调用结果的变量时，不会对其进行求值。对于python 2.7，您可以使用lazy.py by Alberto Bertogli：

import lazy

@lazy.lazy
def test3():
    print '     lazy function'
    return 1

print 'Calling lazy function:'
b = (lambda : test3())()
print 'Calling cashed function again:'
b = (lambda : test3())()
print 'Trying to get results:'
print b

output:
Calling lazy function:
Calling cashed function again:
Trying to get results:
    lazy function  # evaluated
1

如何计算函数调用实际使用的返回值？

1 个答案: