18

有没有pythonic办法在不完全面向对象的情况下保持状态（例如，为了优化）？

为了更好地说明我的问题，这里有一个我在 JavaScript 中经常使用的模式示例：

var someFunc = (function () {
    var foo = some_expensive_initialization_operation();
    return someFunc (bar) {
        // do something with foo and bar
    }
}());

在外部，这只是一个与其他函数一样的函数，不需要初始化对象或类似的东西，但是闭包允许一次计算值，然后我基本上将其用作常量。

Python 中的一个例子是优化正则表达式时 - 使用re.compile和存储编译后的版本match和search操作很有用。

我知道在 Python 中执行此操作的唯一方法是在模块范围内设置一个变量：

compiled_regex = compile_my_regex()

def try_match(m): # In reality I wouldn't wrap it as pointlessly as this
    return compiled_regex.match(m)

或者通过创建一个类：

class MatcherContainer(object):
    def __init__(self):
        self.compiled_regex = compile_my_regex()
    def try_match(self, m):
        self.compiled_regex.match(m)

my_matcher = MatcherContainer()

前一种方法是临时的，函数和在它上面声明的变量是否相互关联并不是很清楚。它还稍微污染了模块的命名空间，我对此不太满意。

后一种方法看起来很冗长，并且在样板上有点沉重。

我能想到的解决这个问题的唯一另一种方法是将任何像这样的函数分解到单独的文件（模块）中，然后只导入函数，这样一切都很干净。

更有经验的 Pythoners 有什么关于如何处理这个问题的建议吗？还是您只是不担心并继续解决问题？

4

6 回答 6

15

您也可以使用默认参数完成此操作：

def try_match(m, re_match=re.compile(r'sldkjlsdjf').match):
    return re_match(m)

因为默认参数只在模块导入时评估一次。

或者更简单：

try_match = lambda m, re_match=re.compile(r'sldkjlsdjf').match: re_match(m)

或者最简单的：

try_match = re.compile(r'sldkjlsdjf').match

这不仅节省了重新编译时间（实际上它实际上是在 re 模块内部缓存的），而且还节省了 '.match' 方法的查找。在繁忙的功能或紧密的循环中，那些'.' 决议可以加起来。

于 2012-08-08T14:27:33.727 回答
14

你可以在 Python 中定义闭包，就像在 JavaScript 中定义闭包一样。

def get_matcher():
    compiled_regex = compile_my_regex()

    def try_match(m)
        return compiled_regex.match(m)

    return try_match

但是，在 Python 2.x 中，闭包是只读的（compiled_regex对于上面的示例，您不能重新分配给内部函数调用）。如果闭包变量是一个可变数据结构（例如list, dict, set），你可以在你的函数调用中修改它。

def get_matcher():
    compiled_regex = compile_my_regex()
    match_cache = {}

    def try_match(m):
        if m not in match_cache:
           match_cache[m] = compiled_regex.match(m)

        return match_cache[m]

    return try_match

在 Python 3.x 中，您可以使用nonlocal关键字在函数调用中重新分配给闭包变量。(PEP-3104)

另请参阅以下有关 Python 闭包的问题：

于 2012-08-08T14:27:35.190 回答
8

关于什么

def create_matcher(re):
    compiled_regex = compile_my_regex()
    def try_match(m):
        return compiled_regex.match(m)
    return try_match

matcher = create_matcher(r'(.*)-(.*)')
print matcher("1-2")

?

但在大多数情况下，类更好更干净。

于 2012-08-08T14:18:57.787 回答
5

您可以在任何函数中存储属性。由于函数名称是全局的，您可以在其他函数中检索它。例如：

def memorize(t):
    memorize.value = t

def get():
    return memorize.value

memorize(5)
print get()

输出：

5

您可以使用它将状态存储在单个函数中：

def memory(t = None):
    if t:
        memory.value = t
    return memory.value

print memory(5)
print memory()
print memory()
print memory(7)
print memory()
print memory()

输出：

5
5
5
7
7
7

当然它的用处是有限的。在这个问题中，我只在 SO 上使用过它。

于 2012-08-09T02:22:25.807 回答
2

一个常用的约定是在私有模块级全局变量之前加上下划线，以表明它们不是模块导出 API 的一部分：

# mymodule.py

_MATCHER = compile_my_regex()

def try_match(m):
    return _MATCHER.match(m)

你不应该气馁这样做——它比函数闭包中的隐藏变量更可取。

于 2012-08-08T14:43:26.127 回答
0

你可以使用 generator.send(); 它可能不适合这种特殊情况，但对于维护没有类的状态很有用。调用 '.send(x)' 在调用 yield 后设置值。如果调用 'next' 而不是 possible_vals 将是无。相关发送问题。

def try_match(regex = '', target = ''):
    cache = {}
    while True:
        if regex not in cache:
            cache[regex] = re.compile(regex).match
        possible_vals = (yield cache[regex](target))
        if possible_vals is not None:
            (regex, target) = possible_vals
        
m = try_match(r'(.*)-(.*)', '1-2')
print(next(m))
m.send((r'(.*)-(.*)', '3-4'))
print(next(m))

#Note that you have to call yield before you can send it more values
n = try_match()
n.send((r'(.*)-(.*)', '5-6'))
print(next(n))
于 2020-09-08T23:48:48.943 回答