Question

是否有一种方法只能在一个函数内执行一次代码块（例如，定义时），然后每次调用该函数时，解释器便会忽略它并直接使用结果？

例如：

import time as t
def foo():
    ### redundant code execution
    t0 = t.time()
    arr = ('Apples ' * 10000000).split()
    print(t.time() - t0)
    ###

    print(arr[0])

这将是一个很棒的功能，因为该变量仅在函数内部使用，并且我不希望从外部访问它。

谢谢

Answer 1

在这里，一个主意是记住它。本质上，如果一个函数是纯函数（总是为一组输入提供相同的输出），则可以在第一次计算输入时保存输入到输出的映射。

为此，您可以像Geeks 4 Geeks中的以下示例一样实现自己的备忘录。原始链接：https://www.geeksforgeeks.org/memoization-using-decorators-in-python/

def memoize_factorial(f): 
    memory = {} 
  
    # This inner function has access to memory 
    # and 'f' 
    def inner(num): 
        if num not in memory:          
            memory[num] = f(num) 
        return memory[num] 
  
    return inner 
      
@memoize_factorial
def facto(num): 
    if num == 1: 
        return 1
    else: 
        return num * facto(num-1) 
  
print(facto(5))

或者您可以使用现有装饰器库，例如下面链接中的库。

https://wiki.python.org/moin/PythonDecoratorLibrary#Memoize

Answer 2

是的。可以使用称为closure的东西来完成。

def foo():
    result = None
    def inner():
        nonlocal result
        if result is None:
            result = ...  # do your calculation here
        
        return result
    return inner
foo = foo()

根据问题中的代码再说几点。

time.perf_counter比time.time准确
('Apples ' * 10000000).split()与['Apples'] * 10000000

优化Python函数内部的冗余计算

2 个答案: