另一个答案，可能更快:)

distribution = [(1, 0.2), (2, 0.3), (3, 0.5)]  
# init distribution  
dlist = []  
sumchance = 0  
for value, chance in distribution:  
    sumchance += chance  
    dlist.append((value, sumchance))  
assert sumchance == 1.0 # not good assert because of float equality  

# get random value  
r = random.random()  
# for small distributions use lineair search  
if len(distribution) < 64: # don't know exact speed limit  
    for value, sumchance in dlist:  
        if r < sumchance:  
            return value  
else:  
    # else (not implemented) binary search algorithm  

你可能想看看NumPy随机抽样分布

从Python 3.6开始，Python的标准库中就有了一个解决方案，即random.choices。

示例用法:让我们建立一个与OP问题中匹配的总体和权重:

>>> from random import choices
>>> population = [1, 2, 3, 4, 5, 6]
>>> weights = [0.1, 0.05, 0.05, 0.2, 0.4, 0.2]

现在choices(population, weights)生成一个样本，包含在一个长度为1的列表中:

>>> choices(population, weights)
[4]

可选的仅关键字参数k允许一次请求多个示例。这很有价值，因为有些准备工作是随机的。在生成样本之前，每次调用choice函数都要做的事情;通过一次生成多个样本，我们只需要做一次准备工作。这里我们生成一百万个样本，并使用集合。计数器来检查我们得到的分布是否与我们给出的权重大致匹配。

>>> million_samples = choices(population, weights, k=10**6)
>>> from collections import Counter
>>> Counter(million_samples)
Counter({5: 399616, 6: 200387, 4: 200117, 1: 99636, 3: 50219, 2: 50025})

也许有点晚了。但是你可以使用numpy.random.choice()，传递p参数:

val = numpy.random.choice(numpy.arange(1, 7), p=[0.1, 0.05, 0.05, 0.2, 0.4, 0.2])

这里有一个更有效的方法:

只需使用'weights'数组调用以下函数(假设索引为相应的项)和no。所需样品的数量。可以很容易地修改此函数以处理有序对。

使用它们各自的概率返回采样/选择(带有替换)的索引(或项):

def resample(weights, n):
    beta = 0

    # Caveat: Assign max weight to max*2 for best results
    max_w = max(weights)*2

    # Pick an item uniformly at random, to start with
    current_item = random.randint(0,n-1)
    result = []

    for i in range(n):
        beta += random.uniform(0,max_w)

        while weights[current_item] < beta:
            beta -= weights[current_item]
            current_item = (current_item + 1) % n   # cyclic
        else:
            result.append(current_item)
    return result

关于while循环中使用的概念的简短说明。 我们从累积beta(均匀随机构造的累积值)中减少当前项的权重，并增加当前索引以找到与beta值匹配的项。

这些答案都不是特别明确或简单的。

这里有一个明确、简单、保证有效的方法。

accumulate_normalize_probability接受一个字典p，将符号映射到概率或频率。它输出可用的元组列表，从中进行选择。

def accumulate_normalize_values(p):
        pi = p.items() if isinstance(p,dict) else p
        accum_pi = []
        accum = 0
        for i in pi:
                accum_pi.append((i[0],i[1]+accum))
                accum += i[1]
        if accum == 0:
                raise Exception( "You are about to explode the universe. Continue ? Y/N " )
        normed_a = []
        for a in accum_pi:
                normed_a.append((a[0],a[1]*1.0/accum))
        return normed_a

收益率:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

为什么它有效

累积步骤将每个符号转换为它自身与前一个符号的概率或频率之间的间隔(或第一个符号的情况为0)。这些间隔可以通过简单地遍历列表，直到间隔0.0 -> 1.0(前面准备的)中的随机数小于或等于当前符号的间隔终点来进行选择(从而对所提供的分布进行抽样)。

规范化使我们不再需要确保所有内容的总和为某个值。归一化后，概率的“向量”总和为1.0。

从分布中选择和生成任意长样本的其余代码如下:

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

用法:

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time