24

假设我在 python 中有这个字典，在模块级别（mysettings.py）定义：

settings = {
    'expensive1' : expensive_to_compute(1),
    'expensive2' : expensive_to_compute(2),
    ...
}

我希望在访问键时计算这些值：

from mysettings import settings # settings is only "prepared"

print settings['expensive1'] # Now the value is really computed.

这可能吗？如何？

4

8 回答 8

11

不要继承内置字典。即使您覆盖dict.__getitem__()方法，dict.get()也不会按预期工作。

正确的方法是继承abc.Mapping自collections.

from collections.abc import Mapping

class LazyDict(Mapping):
    def __init__(self, *args, **kw):
        self._raw_dict = dict(*args, **kw)

    def __getitem__(self, key):
        func, arg = self._raw_dict.__getitem__(key)
        return func(arg)

    def __iter__(self):
        return iter(self._raw_dict)

    def __len__(self):
        return len(self._raw_dict)

然后你可以这样做：

settings = LazyDict({
    'expensive1': (expensive_to_compute, 1),
    'expensive2': (expensive_to_compute, 2),
})

我还在这里列出了示例代码和示例：https ://gist.github.com/gyli/9b50bb8537069b4e154fec41a4b5995a

于 2017-11-09T22:36:03.663 回答
6

如果您不将参数与可调用对象分开，我认为这是不可能的。但是，这应该有效：

class MySettingsDict(dict):

    def __getitem__(self, item):
        function, arg = dict.__getitem__(self, item)
        return function(arg)


def expensive_to_compute(arg):
    return arg * 3

现在：

>>> settings = MySettingsDict({
'expensive1': (expensive_to_compute, 1),
'expensive2': (expensive_to_compute, 2),
})
>>> settings['expensive1']
3
>>> settings['expensive2']
6

编辑：

expensive_to_compute如果要多次访问的结果，您可能还想缓存它们。像这样的东西

class MySettingsDict(dict):

    def __getitem__(self, item):
        value = dict.__getitem__(self, item)
        if not isinstance(value, int):
            function, arg = value
            value = function(arg)
            dict.__setitem__(self, item, value)
        return value

现在：

>>> settings.values()
dict_values([(<function expensive_to_compute at 0x9b0a62c>, 2),
(<function expensive_to_compute at 0x9b0a62c>, 1)])
>>> settings['expensive1']
3
>>> settings.values()
dict_values([(<function expensive_to_compute at 0x9b0a62c>, 2), 3])

您可能还想dict根据您要如何使用 dict 来覆盖其他方法。

于 2013-05-21T12:05:29.497 回答
4

将函数的引用存储为键的值，即：

def A():
    return "that took ages"
def B():
    return "that took for-ever"
settings = {
    "A": A,
    "B": B,
}

print(settings["A"]())

这样，您只需在访问和调用它时评估与键关联的函数。可以处理具有非惰性值的合适类是：

import types
class LazyDict(dict):
    def __getitem__(self,key):
        item = dict.__getitem__(self,key)
        if isinstance(item,types.FunctionType):
            return item()
        else:
            return item

用法：

settings = LazyDict([("A",A),("B",B)])
print(settings["A"])
>>> 
that took ages
于 2013-05-21T12:04:54.870 回答
3

您可以制作expensive_to_compute生成器功能：

settings = {
    'expensive1' : expensive_to_compute(1),
    'expensive2' : expensive_to_compute(2),
}

然后尝试：

from mysettings import settings

print next(settings['expensive1'])
于 2013-05-21T12:00:39.493 回答
3

我最近需要类似的东西。将李光阳和迈克尔迈耶的两种策略混合在一起，我是这样做的：

class LazyDict(MutableMapping):
  """Lazily evaluated dictionary."""

  function = None

  def __init__(self, *args, **kargs):
    self._dict = dict(*args, **kargs)

  def __getitem__(self, key):
      """Evaluate value."""
      value = self._dict[key]
      if not isinstance(value, ccData):
          value = self.function(value)
      self._dict[key] = value
      return value

  def __setitem__(self, key, value):
      """Store value lazily."""
      self._dict[key] = value

  def __delitem__(self, key):
      """Delete value."""
      return self._dict[key]

  def __iter__(self):
      """Iterate over dictionary."""
      return iter(self._dict)

  def __len__(self):
      """Evaluate size of dictionary."""
      return len(self._dict)

让我们懒惰地评估以下函数：

def expensive_to_compute(arg):
  return arg * 3

优点是该函数尚未在对象中定义，并且参数是实际存储的参数（这是我需要的）：

>>> settings = LazyDict({'expensive1': 1, 'expensive2': 2})
>>> settings.function = expensive_to_compute # function unknown until now!
>>> settings['expensive1']
3
>>> settings['expensive2']
6

此方法仅适用于单个函数。

我可以指出以下优点：

  • 实现完整的MutableMappingAPI
  • 如果您的函数是不确定的，您可以重置一个值以重新评估
于 2020-04-10T16:04:41.857 回答
3

我会用可调用对象填充字典值，并在阅读时将它们更改为结果。

class LazyDict(dict):
    def __getitem__(self, k):
        v = super().__getitem__(k)
        if callable(v):
            v = v()
            super().__setitem__(k, v)
        return v

    def get(self, k, default=None):
        if k in self:
            return self.__getitem__(k)
        return default

然后与

def expensive_to_compute(arg):
    print('Doing heavy stuff')
    return arg * 3

你可以做：

>>> settings = LazyDict({
    'expensive1': lambda: expensive_to_compute(1),
    'expensive2': lambda: expensive_to_compute(2),
})

>>> settings.__repr__()
"{'expensive1': <function <lambda> at 0x000001A0BA2B8EA0>, 'expensive2': <function <lambda> at 0x000001A0BA2B8F28>}"

>>> settings['expensive1']
Doing heavy stuff
3

>>> settings.get('expensive2')
Doing heavy stuff
6

>>> settings.__repr__()
"{'expensive1': 3, 'expensive2': 6}"
于 2020-04-15T08:10:17.413 回答
1

传入一个函数以生成第一个属性 get 的值：

class LazyDict(dict):
  """ Fill in the values of a dict at first access """
  def __init__(self, fn, *args, **kwargs):
    self._fn = fn
    self._fn_args = args or []
    self._fn_kwargs = kwargs or {}
    return super(LazyDict, self).__init__()
  def _fn_populate(self):
    if self._fn:
      self._fn(self, *self._fn_args, **self._fn_kwargs)
      self._fn = self._fn_args = self._fn_kwargs = None
  def __getattribute__(self, name):
    if not name.startswith('_fn'):
      self._fn_populate()
    return super(LazyDict, self).__getattribute__(name)
  def __getitem__(self, item):
    self._fn_populate()
    return super(LazyDict, self).__getitem__(item)



>>> def _fn(self, val):
...   print 'lazy loading'
...   self['foo'] = val
... 
>>> d = LazyDict(_fn, 'bar')
>>> d
{}
>>> d['foo']
lazy loading
'bar'
>>>
于 2020-07-24T20:46:01.410 回答
1

或者，可以使用创建线程安全惰性字典的 LazyDictionary 包。

安装：

pip install lazydict

用法：

from lazydict import LazyDictionary
import tempfile
lazy = LazyDictionary()
lazy['temp'] = lambda: tempfile.mkdtemp()
于 2021-04-15T08:09:12.130 回答