在 Python 3 中以恒定时间从字典中选择随机值？

Question

我知道您可以通过多种方式从字典中选择随机值。

在 Python 2 中：

random.choice(d.keys())

在 Python 3 中：

random.choice(list(d.keys()))

尽管如此，这两种方法都需要在随机选择之前将其转换为一个列表，即线性时间 O(n)。例如，我知道在 Python 3 中 d.keys() 返回一个迭代器，我猜测在 Python 3 中列表是从字典内部创建的。

是否可以在常数时间内从字典中选择一个值，即 O(1)？

编辑：到目前为止，对于 cmets，我认为这是不可能的，至少不是直接的方式。需要辅助结构。

编辑2：我认为字典可以在恒定时间内随机选择，因为它在内部是一个哈希表，即在内部它必须有一个数组或相似的东西。当然，这取决于内部实现，但理论上我认为是可能的。

Answer 1

next(islice(d.values(),np.random.randint(0, len(d)-1),None)) 是我发现从 dict d 中选择随机值的最佳执行方法Python 3。这在下面的讨论中进行了解释。

一些标准库随机方法比可比较的 numpy.random 方法花费更多的运行时间。例如：

import numpy as np

timeit random.randint(0, 10)
100000 loops, best of 3: 2.52 µs per loop

timeit np.random.randint(0, 10)
1000000 loops, best of 3: 453 ns per loop

使用 numpy.random.randint 可以提高选择 dict 随机值的方法的运行时间：

from itertools import islice
import random

d = {1:'a',2:'b',3:'c',4:'d',5:'e',6:'f',7:'g',8:'h',9:'i',10:'j'}

timeit next(islice(d.values(),random.randint(0, len(d)-1),None))
100000 loops, best of 3: 3.58 µs per loop

timeit next(islice(d.values(),np.random.randint(0, len(d)-1),None))
100000 loops, best of 3: 1.26 µs per loop

# d[5] access time is about 25X smaller than 1.26 µs
timeit d[5]
10000000 loops, best of 3: 51.3 ns per loop

def take_nth(sequence, n):
    i = iter(sequence)
    for _ in range(n):
        next(i)
    return next(i)

timeit d[take_nth(d.keys(), random.randint(0, len(d)-1))]
100000 loops, best of 3: 5.07 µs per loop

timeit d[take_nth(d.keys(), np.random.randint(0, len(d)-1))]
100000 loops, best of 3: 2.66 µs per loop

Answer 2

我认为，很明显，通过标准 dict 公共 API 这是不可能的。

但是，dict 有几个直接替代品，可按某种排序顺序提供对密钥的有效访问。然后可以对其进行索引以获得随机元素。尽管它们的理论渐近性与 dict 不同，但在实践中它们通常表现得一样好或更好。

Stutzbach Enterprises 的 blist 包提供了 blist.sorteddict，它经过专门测试与 dict 完全兼容。它提供了对其关键视图的索引，这是对数复杂度。它是用 B+Trees 实现的。

Grant Jenks 中的 SortedContainers 包提供了 sortedcontainers.SortedDict，它同样提供了对其关键视图的高效索引。

其他也可用，通常基于搜索树。

Answer 3

在这种情况下，我只能想象一种（次要）优化：不要创建列表，只需获取一个随机数 r 并迭代 d.keys() 直到你得到 r-th 项。

def take_nth(sequence, n):
    i = iter(sequence)
    for _ in range(n):
        next(i)

    return next(i)

import random
rand_key = d[take_nth(d.keys(), random.randint(0, len(d)-1))]

这会给您带来更好的性能，因为您不必每次都迭代整个列表，但这仍然是个坏主意。

如果您想在固定字典上重复进行随机选择，而不是将其键缓存到单独的列表中并使用随机索引值对其进行索引。

UPD：

总结 cmets 中的讨论，以下具有前向/后向缓存和重用已删除项目的类可能会有所帮助：

import random

class RandomSampleDict(object):

    def __init__(self):
        self.data     = {}
        self.cache_ik = {}
        self.cache_ki = {}
        self.track    = []

    def lookup(self, key):
        return self.data[key]

    def set(self, key, value):
        self.data[key] = value

    def add(self, key, value):
        self.data[key] = value
        if len(self.track) == 0:
            i = len(self.data) - 1
        else:
            i = self.track.pop()

        self.cache_ik[i] = key
        self.cache_ki[key] = i

    def delete(self, key):
        del self.data[key]
        i = self.cache_ik[i]
        del self.data_ik[i]
        del self.data_ki[key]

        self.track.append(i)

    def random_sample_key(self):
        key = None
        while key is None:
            i = random.randint(0, len(self.data))
            if i in self.cache_ik:
                return self.cache_ik[i]

Answer 4

假设仅使用 Python dict 无法做到这一点并且需要第二个数据结构，那么这里有一个廉价且高效的辅助数据结构，它只跟踪当前节点。

它只是将节点保存在列表中。为了支持删除，它只是清空该位置并保留另一个可用空间列表。

请注意，如果您只是随机删除节点，那么这很好。如果要删除通过其他方法选择的节点，则需要将序列号存储在节点中，以便找到要删除的节点。

除非您遇到随机采样变慢时节点列表大部分为空的情况，否则它运行良好。如果您需要处理这种情况，那么您需要在此时重新分配列表 - 这可以作为摊销成本，但会增加相当多的复杂性。例如，您需要添加一个从节点到序列号的字典，并在重新分配节点列表时更新它。

import random
RNG = random.Random()

class Tracker(object):

    def __init__(self):
        self.free = []
        self.nodes = []

    def add(self,node):
        if self.free:
            seq_num = self.free.pop()
            self.nodes[seq_num] = node
        else:
            seq_num = len(self.nodes)
            self.nodes.append(node)

    def random_node(self):
        seq_num = RNG.randint(0,len(self.nodes)-1)
        while self.nodes[seq_num] == None:
            seq_num = RNG.randint(0,len(self.nodes)-1)
        return self.nodes[seq_num],seq_num

    def delete(self,seq_num):
        self.nodes[seq_num] = None
        self.free.append(seq_num)

    def delete_random_node(self):
        node,seq_num = self.random_node()
        self.delete(seq_num)
        return node

这里可能有一些小的优化。用collections.deque 替换空闲列表可能会更快一些，因为如果它们的大小变化太频繁，列表会减慢一点。但这没什么大不了的。我认为您的节​​点列表将达到一个平衡大小，然后变得非常高效，但是您可以用 Nones 来填充它，以避免重复增长的启动成本。你可以做一些常见的子表达式消除。但所有这些都只会产生很小的影响。