在特定键值处启动字典 for 循环

Question

代码如下：

编辑**** 请不要再“使用无序的字典回复是不可能的”。我几乎已经知道了。我发表这篇文章是因为它可能是可能的，或者有人有一个可行的想法。

#position equals some set of two dimensional coords
for name in self.regions["regions"]:  # I want to start the iteration with 'last_region'
    # I don't want to run these next two lines over every dictionary key each time since the likelihood is that the new
    # position is still within the last region that was matched.
    rect = (self.regions["regions"][name]["pos1"], self.regions["regions"][name]["pos2"])
    if all(self.point_inside(rect, position)):
        # record the name of this region in variable- 'last_region' so I can start with it on the next search...
        # other code I want to run when I get a match
        return
return # if code gets here, the points were not inside any of the named regions

希望代码中的 cmets 能很好地解释我的情况。假设我最后在区域“delta”内（即，键名是 delta，值将是定义其边界的坐标集）并且我还有 500 个区域。我第一次发现自己在区域 delta 中时，代码可能直到（假设）第 389 次迭代才发现这一点……所以它在发现之前进行了 388 次all(self.point_inside(rect, position)) 计算。由于下次运行时我可能仍处于 delta 中（但每次代码运行时我都必须验证），如果键“delta”是第一个被 for 循环检查的键，将会很有帮助。

这个特定的代码每秒可以为许多不同的用户运行多次。所以速度至关重要。设计是这样的，用户不会在一个区域中，并且所有 500 条记录可能需要循环通过并且将在没有匹配项的情况下退出循环，但我想通过加速整个程序来加速它那些目前在其中一个地区的人。

我不希望以任何特定顺序对字典进行排序等额外开销。我只希望它从成功匹配的最后一个开始查找all(self.point_inside(rect, position))

也许这会有所帮助。以下是我正在使用的字典（仅显示第一条记录），因此您可以看到我在上面编码的结构...是的，尽管名称为“rect”代码，它实际上检查立方体区域中的点。

{"regions": {"shop": {"flgs": {"breakprot": true, "placeprot": true}, "dim": 0, "placeplayers": {"4f953255-6775-4dc6- a612-fb4230588eff": "SurestTexas00"}, "breakplayers": {"4f953255-6775-4dc6-a612-fb4230588eff": "SurestTexas00"}, "protected": true, "banplayers": {}, "pos1": [ 5120025, 60, 5120208], "pos2": [5120062, 73, 5120257], "ownerUuid": "4f953255-6775-4dc6-a612-fb4230588eff", "accessplayers": {"4f953255-6774-2056-a612-b ": "SurestTexas00"}}，更多，更多，更多...}

Answer 1

您可以尝试在dict 的自定义子类中实现一些缓存机制。

您可以在__init__ 中设置self._cache = None，添加类似set_cache(self, key) 的方法来设置缓存，最后在调用默认__iter__ 之前将__iter__ 覆盖为yield self._cache。

但是，如果您考虑this stackoverflow answer 和this one，这可能有点麻烦。

对于您的问题中所写的内容，我会尝试在您的代码中实现此缓存逻辑。

def _match_region(self, name, position):
    rect = (self.regions["regions"][name]["pos1"], self.regions["regions"][name]["pos2"])
    return all(self.point_inside(rect, position))


if self.last_region and self._match_region(self.last_region, position):
    self.code_to_run_when_match(position)
    return

for name in self.regions["regions"]:
    if self._match_region(name, position):
        self.last_region = name
        self.code_to_run_when_match(position)
        return
return # if code gets here, the points were not inside any of the named regions

Answer 2

没错，字典是无序类型。因此，OrderedDict 对您想做的事情没有多大帮助。

您可以将最后一个区域存储到您的类中。然后，在下一次调用时，在检查整个字典之前检查最后一个区域是否仍然有效？

Answer 3

您可以直接使用迭代器来代替 for 循环。这是一个示例函数，它使用迭代器执行类似于您想要的操作：

def iterate(what, iterator):
    iterator = iterator or what.iteritems()
    try:
        while True:
            k,v = iterator.next()
            print "Trying k = ", k
            if v > 100:
                return iterator
    except StopIteration:
        return None

您将存储此函数的结果，而不是将区域名称存储在last_region 中，这就像一个指向您离开的地方的“指针”。然后，您可以像这样使用该函数（显示为在 Python 交互式解释器中运行，包括输出）：

>>> x = {'a':12, 'b': 42, 'c':182, 'd': 9, 'e':12}
>>> last_region = None
>>> last_region = iterate(x, last_region)
Trying k = a
Trying k = c
>>> last_region = iterate(x, last_region)
Trying k = b
Trying k = e
Trying k = d

因此，您可以轻松地从中断处继续，但还有一个需要注意的额外警告：

>>> last_region = iterate(x, last_region)
Trying k =  a
Trying k =  c
>>> x['z'] = 45
>>> last_region = iterate(x, last_region)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in iterate
RuntimeError: dictionary changed size during iteration

如您所见，如果您添加新密钥，它会引发错误。因此，如果您使用此方法，则需要确保在向字典中添加新区域时设置last_region = None。

Answer 4

TigerhawkT3 是对的。从某种意义上说，在给定字典中没有保证顺序或键的情况下，字典是无序的。如果你遍历同一个字典，你甚至可以有不同的键顺序。如果您想要订购，您需要使用OrderedDict 或只是简单的列表。您可以将您的 dict 转换为 list 并按照它表示您需要的顺序对其进行排序。

Answer 5

如果不知道您的对象是什么以及示例中的 self 是 user 实例还是 environment 实例，则很难提出解决方案。但是如果示例中的self 是环境，那么如果用户实例是可散列的，那么它的类可以有一个类属性，即所有当前用户及其最后已知位置的字典。

类似的东西

class Thing(object):
    __user_regions = {}
    def where_ami(self, user):
        try:
            region = self.__user_regions[user]
            print 'AHA!! I know where you are!!'
        except KeyError:
            # find region
            print 'Hmmmm. let me think about that'
            region = 'foo'
            self.__user_regions[user] = region

class User(object):
    def __init__(self, position):
        self.pos = position

thing = Thing()
thing2 = Thing()
u = User((1,2))
v = User((3,4))

现在您可以尝试从类属性中检索用户的区域。如果有多个Thing，它们将共享该类属性。

>>> 
>>> thing._Thing__user_regions
{}
>>> thing2._Thing__user_regions
{}
>>> 
>>> thing.where_ami(u)
Hmmmm. let me think about that
>>> 
>>> thing._Thing__user_regions
{<__main__.User object at 0x0433E2B0>: 'foo'}
>>> thing2._Thing__user_regions
{<__main__.User object at 0x0433E2B0>: 'foo'}
>>> 
>>> thing2.where_ami(v)
Hmmmm. let me think about that
>>> 
>>> thing._Thing__user_regions
{<__main__.User object at 0x0433EA90>: 'foo', <__main__.User object at 0x0433E2B0>: 'foo'}
>>> thing2._Thing__user_regions
{<__main__.User object at 0x0433EA90>: 'foo', <__main__.User object at 0x0433E2B0>: 'foo'}
>>> 
>>> thing.where_ami(u)
AHA!! I know where you are!!
>>> 

Answer 6

您说您“不希望以任何特定顺序对字典进行排序的额外开销”。 什么开销？大概OrderedDict 在内部使用了一些额外的数据结构来跟踪键的顺序。但除非您知道这会消耗您太多内存，否则OrderedDict 是您的解决方案。这意味着分析您的代码并确保 OrderedDict 是您的瓶颈的来源。

如果您想要最干净的代码，只需使用OrderedDict。它有一个move_to_back 方法，它接受一个键并将其放在字典的前面或末尾。例如：

from collections import OrderedDict

animals = OrderedDict([('cat', 1), ('dog', 2), ('turtle', 3), ('lizard', 4)])

def check_if_turtle(animals):
    for animal in animals:
        print('Checking %s...' % animal)
        if animal == 'turtle':
            animals.move_to_end('turtle', last=False)
            return True
    else:
        return False

我们的check_if_turtle 函数通过OrderedDict 查找turtle 键。如果没有找到，它会返回False。如果确实找到它，它会返回True，但不会在将turtle 键移到OrderedDict 的开头之后。

让我们试试吧。第一次运行：

>>> check_if_turtle(animals)
Checking cat...
Checking dog...
Checking turtle...
True

我们看到它检查了直到turtle 的所有键。现在，如果我们再次运行它：

>>> check_if_turtle(animals)
Checking turtle...
True

我们看到它首先检查了turtle 键。