Question

如何从dict获得随机对？我正在做一个游戏，你需要猜测一个国家的首都，我需要随机出现问题。

dict看起来像{'VENEZUELA':'CARACAS'}

我该怎么做？

Answer 1

一种方式（在Python 2. *中）将是：

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

编辑：问题在原帖后几年发生了变化，现在要求一对，而不是一个项目。最后一行应该是：

country, capital = random.choice(list(d.items()))

Answer 2

我写这篇文章试图解决同样的问题：

https://github.com/robtandy/randomdict

它有O（1）随机访问键，值和项目。

Answer 3

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

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

自dict doesn't preserve order以来，通过使用popitem，您可以从中获取任意（但不是严格随机）的订单。

另请注意，popitem会从字典中删除键值对，如docs中所述。

popitem（）对破坏性地迭代字典很有用

Answer 4

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

通过字典keys（国家/地区）调用random.choice。

Answer 5

试试这个：

import random
a = dict(....) # a is some dictionary
random_key = random.sample(a, 1)[0]

这肯定有效。

Answer 6

如果您不想使用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'

Answer 7

因为这是作业：

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

Answer 8

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

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)那么输出将如下：

VENEZUELA? CARACAS
CANADA? TORONTO

您可以通过改变选项来进一步扩展这一点

Answer 9

由于原帖想要对：

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

（python 3 style）

Answer 10

这适用于Python 2和Python 3：

随机密钥：

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

一个随机值

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

随机键和值

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

Answer 11

试试这个（使用来自项目的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'

Answer 12

在现代版本的Python（自3起）中，方法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([hex_color for color_value in colors.values()]

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

参考：

Answer 13

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)

Answer 14

这是字典类的一些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))]

Answer 15

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

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

Answer 16

一种方法是：

async function yourLoop() {
  // each step could be synchronous or asynchronous
  for (const step of actions.step) {
    const result = window[step.functionName](step.functionParameter);
    if (result instanceof Promise) {
        // if step is asynchronous operation, wait for it to complete
        await result;
    }
  }
}

/////// usage ////////

yourLoop().then(() => {
  /* all steps completed */
}).catch(() => {
  /* some step(s) failed */
});

编辑：问题在原始帖子发布几年后发生了变化，现在要求一对，而不是单个项目。 最后一行现在应该是：

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

Answer 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]

如何在python字典中获取随机值

17 个答案: