4

我正在编写一个解析 HTML 的类，以便为网页上的配置文件提供接口。它看起来像这样：

class Profile(BeautifulSoup):
    def __init__(self, page_source):
        super().__init__(page_source)

    def username(self):
        return self.title.split(':')[0]

除了更复杂和耗时。因为我知道底层配置文件在Profile对象的生命周期内不会发生变化，所以我认为这将是一个缓存结果的好地方，以避免重新计算已知的值。我用装饰器实现了这个，结果如下所示：

def cached_resource(method_to_cache):
    def decorator(self, *args, **kwargs):
        method_name = method_to_cache.__name__

        try:
            return self._cache[method_name]
        except KeyError:
            self._cache[method_name] = method_to_cache(self, *args, **kwargs)
            return self._cache[method_name]

    return decorator


class Profile(BeautifulSoup):
    def __init__(self, page_source):
        super().__init__(page_source)
        self._cache = {}

    @cached_resource
    def username(self):
        return self.title.split(':')[0]

当我将此代码提供给 pylint 时，它抱怨cached_resource可以访问客户端类的受保护变量。

我意识到公共和私有之间的区别在 Python 中并不是什么大问题，但我仍然很好奇——我在这里做了什么坏事吗？让装饰器依赖与它们关联的类的实现细节是不是很糟糕？

编辑：我不清楚邓肯答案中的关闭是如何工作的，所以也许这有点混乱，但这会是一个更简单的解决方案吗？

def cached_resource(method_to_cache):
    def decorator(self, *args, **kwargs):
    method_name = method_to_cache.__name__

    try:
        return self._cache[method_name]
    except KeyError:
        self._cache[method_name] = method_to_cache(self, *args, **kwargs)
    except AttributeError:
        self._cache = {}
        self._cache[method_name] = method_to_cache(self, *args, **kwargs)
    finally:
        return self._cache[method_name]

return decorator
4

2 回答 2

3

有一点代码的味道，我想我会同意 pylint 的观点，尽管它是相当主观的。

您的装饰器看起来像是一个通用的装饰器，但它与类的内部实现细节相关联。如果您尝试从另一个类中使用它，则如果没有_cachein的初始化，它将无法工作__init__。我不喜欢的链接是类和装饰器之间共享一个名为“_cache”的属性的知识。

您可以将初始化_cache移出__init__和移入装饰器。我不知道这是否有助于安抚 pylint，它仍然需要班级了解并避免使用该属性。这里（我认为）更简洁的解决方案是将缓存属性的名称传递给装饰器。那应该干净地打破链接：

def cached_resource(cache_attribute):
  def decorator_factory(method_to_cache):
    def decorator(self, *args, **kwargs):
        method_name = method_to_cache.__name__
        cache = getattr(self, cache_attribute)
        try:
            return cache[method_name]
        except KeyError:
            result = cache[method_name] = method_to_cache(self, *args, **kwargs)
            return result

    return decorator
  return decorator_factory


class Profile(BeautifulSoup):
    def __init__(self, page_source):
        super().__init__(page_source)
        self._cache = {}

    @cached_resource('_cache')
    def username(self):
        return self.title.split(':')[0]

如果你不喜欢大量重复属性名称的装饰器调用，那么：

class Profile(BeautifulSoup):
    def __init__(self, page_source):
        super().__init__(page_source)
        self._cache = {}

    with_cache = cached_resource('_cache')

    @with_cache
    def username(self):
        return self.title.split(':')[0]

编辑： Martineau 认为这可能是矫枉过正。如果您实际上不需要单独访问_cache类内的属性（例如，拥有缓存重置方法），则可能是这样。在这种情况下，您可以完全在装饰器中管理缓存，但如果您要这样做，则根本不需要实例上的缓存字典，因为您可以将缓存存储在装饰器中并在Profile实例上存储键：

from weakref import WeakKeyDictionary

def cached_resource(method_to_cache):
    cache = WeakKeyDictionary()
    def decorator(self, *args, **kwargs):
        try:
            return cache[self]
        except KeyError:
            result = cache[self] = method_to_cache(self, *args, **kwargs)
        return result
    return decorator

class Profile(BeautifulSoup):
    def __init__(self, page_source):
        super().__init__(page_source)
        self._cache = {}

    @cached_resource
    def username(self):
        return self.title.split(':')[0]
于 2013-09-09T08:34:51.650 回答
2

你所做的在我看来很好。该错误可能是因为 pylint 无法弄清楚这cached_resource只是self._cache通过其内部函数“访问”，这最终是类的方法（由装饰器分配）。

为此，可能值得在pylint 跟踪器上提出问题。使用静态分析可能很难处理，但当前的行为似乎并不正确。

于 2013-09-09T06:59:55.770 回答