如何从字典中获取随机键值对？

问题描述：

在 Python 中，给定一个字典，例如

{
    'VENEZUELA': 'CARACAS',
    'CANADA': 'OTTAWA'
}

我如何选择一个随机项目（键值对）？

如果我只需要键或只需要值怎么办？可以优化吗？

解决方案 1：

列出字典中的条目，然后以通常的方式从中随机选择：

import random
d = {'VENEZUELA':'CARACAS', 'CANADA':'OTTAWA'}
country, capital = random.choice(list(d.items()))

类似地，如果只需要一个值，则直接从值中选择：

capital = random.choice(list(d.values()))

解决方案 2：

在字典（国家）的键上调用random.choice 。

在 2.x 中，keys可以直接选择：

>>> import random
>>> d = dict(Venezuela = 1, Spain = 2, USA = 3, Italy = 4)
>>> random.choice(d.keys())
'Venezuela'
>>> random.choice(d.keys())
'USA'

在3.x中，首先创建一个列表，例如random.choice(list(d.keys()))。

解决方案 3：

给出一本字典a，使用：

import random
random_key = random.sample(a.keys(), 1)[0]

解决方案 4：

（这有许多注意事项，最主要的是这实际上并不是随机的......详情请参阅评论）

如果您不想使用该random模块，您也可以尝试popitem()：

>> d = {'a': 1, 'b': 5, 'c': 7}
>>> d.popitem()
('a', 1)
>>> d
{'c': 7, 'b': 5}
>>> d.popitem()
('c', 7)

由于dict 不保留顺序，通过使用，popitem您可以以任意（但不是严格随机）的顺序从中获取项目。

还请记住popitem从字典中删除键值对，如文档中所述。

popitem() 对于破坏性地迭代字典很有用

解决方案 5：

这在 Python 2 和 Python 3 中有效：

随机密钥：

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

随机值

random.choice(list(d.values()))

随机键和值

random.choice(list(d.items()))

解决方案 6：

由于原始帖子想要该对：

import random
d = {'VENEZUELA':'CARACAS', 'CANADA':'TORONTO'}
country, capital = random.choice(list(d.items()))

（python 3 风格）

解决方案 7：

要获取随机键，请使用random.choice()，并传递字典键，如下所示：

import random
keys = list(my_dict)
country = random.choice(keys)

解决方案 8：

以下是获取键、值或项目的单独函数：

import random

def pick_random_key_from_dict(d: dict):
    """Grab a random key from a dictionary."""
    keys = list(d.keys())
    random_key = random.choice(keys)
    return random_key

def pick_random_item_from_dict(d: dict):
    """Grab a random item from a dictionary."""
    random_key = pick_random_key_from_dict(d)
    random_item = random_key, d[random_key]
    return random_item

def pick_random_value_from_dict(d: dict):
    """Grab a random value from a dictionary."""
    _, random_value = pick_random_item_from_dict(d)
    return random_value

它们可以这样使用：

d = {...}
random_item = pick_random_item_from_dict(d)

这些方法仅复制字典的键，从而减少了使用时复制数据的需要random.choice。一旦我们有了键，我们就可以得到相应的值，从而得到一个项目。

解决方案 9：

如果您不想使用 random.choice() 您可以尝试以下方法：

>>> list(myDictionary)[i]
'VENEZUELA'
>>> myDictionary = {'VENEZUELA':'CARACAS', 'IRAN' : 'TEHRAN'}
>>> import random
>>> i = random.randint(0, len(myDictionary) - 1)
>>> myDictionary[list(myDictionary)[i]]
'TEHRAN'
>>> list(myDictionary)[i]
'IRAN'

解决方案 10：

因为这是家庭作业：

查看random.sample()哪个将从列表中选择并返回随机元素。您可以使用获取字典键列表dict.keys()，使用获取字典值列表dict.values()。

解决方案 11：

这是我的示例答案

import random

data = {f"key{n}" : n for n in range(100)}
print(random.choice(list(data.values())))

解决方案 12：

我假设你正在制作一个测验类的应用程序。对于这种应用程序，我编写了一个函数，如下所示：

def shuffle(q):
"""
The input of the function will 
be the dictionary of the question
and answers. The output will
be a random question with answer
"""
selected_keys = []
i = 0
while i < len(q):
    current_selection = random.choice(q.keys())
    if current_selection not in selected_keys:
        selected_keys.append(current_selection)
        i = i+1
        print(current_selection+'? '+str(q[current_selection]))

如果我给出输入questions = {'VENEZUELA':'CARACAS', 'CANADA':'TORONTO'}并调用该函数，shuffle(questions)则输出将如下所示：

委内瑞拉？加拉加斯
加拿大？多伦多

您还可以通过随机排列选项来进一步扩展此功能

解决方案 13：

从字典集中选择 50 个随机键值dict_data：

sample = random.sample(set(dict_data.keys()), 50)

解决方案 14：

我需要遍历 a 中的键范围，dict 而无需每次都对其进行排序，然后找到了Sorted Containers库。我发现这个库可以通过索引随机访问字典项，这可以直观地解决这个问题，而无需每次都遍历整个字典dict：

>>> import sortedcontainers
>>> import random
>>> d = sortedcontainers.SortedDict({1: 'a', 2: 'b', 3: 'c'})
>>> random.choice(d.items())
(1, 'a')
>>> random.sample(d.keys(), k=2)
[1, 3]

解决方案 15：

在Python 3.x中，方法返回的对象dict.keys()和是视图对象，不能直接使用。dict.values()`dict.items()`random.choice

一种选择是传递random.choice列表推导来提取可供选择的候选值：

import random

colors = {
    'purple': '#7A4198',
    'turquoise': '#9ACBC9',
    'orange': '#EF5C35',
    'blue': '#19457D',
    'green': '#5AF9B5',
    'red': ' #E04160',
    'yellow': '#F9F985'
}

color = random.choice([color_value for color_value in colors.values()]

print(f'The new color is: {color}')

解决方案 16：

试试这个（使用来自项目的 random.choice）

import random

a={ "str" : "sda" , "number" : 123, 55 : "num"}
random.choice(list(a.items()))
#  ('str', 'sda')
random.choice(list(a.items()))[1] # getting a value
#  'num'

解决方案 17：

我在寻找一个相当类似的解决方案时找到了这篇文章。要从字典中挑选多个元素，可以使用以下方法：

idx_picks = np.random.choice(len(d), num_of_picks, replace=False) #(Don't pick the same element twice)
result = dict ()
c_keys = [d.keys()] #not so efficient - unfortunately .keys() returns a non-indexable object because dicts are unordered
for i in idx_picks:
    result[c_keys[i]] = d[i]

解决方案 18：

b = { 'video':0, 'music':23,"picture":12 } 
random.choice(tuple(b.items())) ('music', 23) 
random.choice(tuple(b.items())) ('music', 23) 
random.choice(tuple(b.items())) ('picture', 12) 
random.choice(tuple(b.items())) ('video', 0) 

解决方案 19：

下面是一个字典类的 Python 代码，它可以在 O(1) 时间内返回随机键。（为了便于阅读，我在此代码中包含了 MyPy 类型）：

from typing import TypeVar, Generic, Dict, List
import random

K = TypeVar('K')
V = TypeVar('V')
class IndexableDict(Generic[K, V]):
    def __init__(self) -> None:
        self.keys: List[K] = []
        self.vals: List[V] = []
        self.dict: Dict[K, int] = {}

    def __getitem__(self, key: K) -> V:
        return self.vals[self.dict[key]]

    def __setitem__(self, key: K, val: V) -> None:
        if key in self.dict:
            index = self.dict[key]
            self.vals[index] = val
        else:
            self.dict[key] = len(self.keys)
            self.keys.append(key)
            self.vals.append(val)

    def __contains__(self, key: K) -> bool:
        return key in self.dict

    def __len__(self) -> int:
        return len(self.keys)

    def random_key(self) -> K:
        return self.keys[random.randrange(len(self.keys))]