用于轮询字典的Pythonic方法 - 一旦存在，就使用密钥的值

Question

我有一个解决这个问题的工作方案，它只是感觉不是非常pythonic。 我在Python 2.7中工作，因此不能使用Python 3解决方案。

我有一本定期更新的字典。 最后一个键，让我们称之为“foo”，一个值将出现在字典中。 我想继续轮询该对象并获取该字典，直到键“foo”出现，此时我想获得与该键相关联的值并使用它。

这是一些现在正在运行的伪代码：

polled_dict = my_object.get_dict()
while('foo' not in polled_dict.keys()):
    polled_dict = my_object.get_dict()
fooValue = polled_dict['foo']

让我强调一下，代码现在正在做什么。 感觉很糟糕但是很有效。 我想出的一个潜在的解决方案是：

fooValue = None
While fooValue is None:
    polled_dict = my_object.get_dict()
    fooValue = polled_dict.get('foo')

这也有效，但它似乎只是更好一点。 一旦它出现在dict中（在while循环期间访问密钥并且在退出while循环时再次访问），我们只调用一次，而不是一次调用polled_dict.get（'foo'）。 但是，老实说，它似乎并没有好转，收益微乎其微。

当我查看我已实现的其他解决方案时，我发现它们只是上述两个示例的不同逻辑排列（不是在不同的地方或其他地方），但没有任何感觉pythonic。 我似乎会有一种简单，清洁的方式来做到这一点。 有什么建议？ 如果没有，上述任何一个都比另一个好吗？

编辑很多答案都建议我覆盖或以其他方式更改代码轮询的字典。 我同意这通常是一个很好的解决方案，但引用我的一些评论如下：

“有问题的代码需要与更新字典的API分开存在。这段代码必须是通用的，并且可以访问大量不同类型对象的字典。添加触发器最终需要完全重新处理所有这些对象（并且不会像这个函数那样通用了）这显然已经大大简化了，但是，最终，我需要检查这个dict中的值，直到它出现而不是触发对象中的某些东西。我不相信这样做一个广泛的，可能具有破坏性的变化是pythonic解决方案（尽管API应该从头开始重写，这肯定是解决方案，对于不需要分离/可以访问API的东西，这绝对是pythonic解决方案。 ）”

Answer 1

如果您的对象正在修改字典，那么您只需要获取一次。 然后你和你的对象有一个指向同一个字典对象的指针。 如果你需要坚持轮询，那么这可能是最干净的解决方案：

polled_dict = my_object.get_dict()
while 'foo' not in polled_dict:
    pass # optionally sleep
fooValue = polled_dict['foo']

这样做的最佳总体方法是以某种方式通过管道/套接字/线程锁推送某种类型的事件。

Answer 2

你总是可以做类似子类dict事情。

这是完全未经测试的，但有一些影响：

class NoisyDict(dict):
    def __init__(self, *args, **kwargs):
        self.handlers = {}
        #Python 3 style
        super().__init__(*args, **kwargs)

    def add_handler(self, key, callback):
        self.handlers[key] = self.handlers.get(key, [])
        self.handlers[key].append(callback)

    def __getitem__(self, key):
        for handler in self.handlers.get(key, []):
            handler('get', key, super().__getitem__(key))
        return super().__getitem__(key)

    def __setitem__(self, key, value):
        for handler in self.handlers.get(key, []):
            handler('set', key, value)
        return super().__setitem(value)

然后你可以做到

d = NoisyDict()

d.add_handler('spam', print)

d['bar'] = 3
d['spam'] = 'spam spam spam'

Answer 3

发电机的乐趣：

from itertools import repeat
gen_dict = (o.get_dict() for o in repeat(my_object))
foo_value = next(d['foo'] for d in gen_dict if 'foo' in d)

Answer 4

是不是可以做这样的事情？ （显然不是线程安全的）唯一的问题是下面的方法没有通过构造捕获字典初始化。 也就是说，在创建字典时不会捕获添加的键; 例如MyDict（watcher = MyWatcher（），a = 1，b = 2） - a和b键不会被添加。 我不确定如何实现它。

class Watcher(object):
    """Watches entries added to a MyDict (dictionary).  key_found() is called
    when an item is added whose key matches one of elements in keys.
    """
    def __init__(self, *keys):
        self.keys = keys

    def key_found(self, key, value):
        print key, value


class MyDict(dict):

    def __init__(self, *args, **kwargs):
        self.watcher = kwargs.pop('watcher')
        super(MyDict, self).__init__(*args, **kwargs)

    def __setitem__(self, key, value):
        super(MyDict, self).__setitem__(key, value)
        if key in self.watcher.keys:
              self.watcher.key_found(key, value)


watcher = Watcher('k1', 'k2', 'k3')
d = MyDict(watcher=watcher)
d['a'] = 1
d['b'] = 2
d['k1'] = 'k1 value'

Answer 5

也许Try / Except会被认为更“Pythonic”？

while循环中的sleep语句也会停止消耗所有资源。

polled_dict = my_object.get_dict()
while True:
    time.sleep(0.1)
    try: 
        fooValue = polled_dict['foo']
        return (foovalue) # ...or break
    except KeyError:
        polled_dict = my_object.get_dict()

Answer 6

我认为默认情况对于这种工作很有用。

from collections import defaultdict

mydeafultdict = defaultdict(lambda : None)
r = None

while r is None:
    r = mydeafultdict['foo']

defaultdict就像普通字典一样工作，除非一个键不存在，它调用在构造函数中提供给它的函数来返回一个值。 在这种情况下，我给它一个只返回None的lambda。 有了这个，你可以继续尝试获取foo ，当有一个与之关联的值时，它将被返回。