在这种情况下，结果是2和12之间的数，但是为了简单起见，最好可能保留第一个索引。
因此test_data列表需要增加以存储12项，并且作为result，我们应该调用random.randint(1, 6) * 两次 *（而不是乘以2），并将这些项相加：

import random

test_data = [0] * 12
n = 1000
for i in range(n):
  # adding up two dices
  result = random.randint(1, 6) + random.randint(1, 6)
  test_data[result - 1] += 1

for i, x in enumerate(test_data, 1):
  print ("Number of ", i, "'s: ", x)

在这里写+= 1而不是= ... + 1也更优雅，因为这里我们避免了写test_data[result - 1]两次。此外，在Python中，通常直接枚举集合，而不是索引。可以使用enumerate(iterable, start_index)来生成2元组(i, n)的可迭代，其中i是索引。而x是与该索引相关的集合的元素。

这是两个不可区分的骰子的解决方案，意味着掷1和3与掷3和1被视为相同。在这种方法中，我们使用dict而不是list，因为对于两个（或更多!）不可区分的骰子，列表将有"洞"（像3、1这样的组合永远不会出现，因为我们将它们视为1、3）。

import random

counts = {}
for _ in range(1000):
    dice = tuple(sorted([random.randint(1, 6), random.randint(1, 6)]))
    counts[dice] = counts.get(dice, 0) + 1

dice现在是两个骰子，排序后3，1被视为1，3，并从一个列表转换为一个元组（基本上是一个不可变的列表），这样我们就可以用它作为字典（counts）的键，然后我们只需要增加骰子的特定组合的计数。
与列表不同的是，字典没有排序，但我们确实希望输出按dice显示的内容排序，所以我们按keys = dice排序：

for dice in sorted(counts.keys()):
    print("{} occurred {} times".format(dice, counts[dice]))

这将为您提供：

(1, 1) occurred 22 times
(1, 2) occurred 53 times
(1, 3) occurred 47 times
(1, 4) occurred 55 times
(1, 5) occurred 55 times
(1, 6) occurred 50 times
(2, 2) occurred 27 times
(2, 3) occurred 64 times
(2, 4) occurred 58 times
...

您可以使用numpy，这个解决方案允许您指定任意数量的骰子：

import numpy as np

no_of_dice = 2
sides_on_die = 6
rolls = 1000
dice = np.array([0]*rolls)

for i in range(no_of_dice):
    dice += np.random.randint(1,sides_on_die+1,rolls)
data = np.bincount(dice)

for i in range(no_of_dice,no_of_dice*sides_on_die+1):
    print ("Number of ", i, "'s: ", data[i])

产量：

Number of  2 's:  26
Number of  3 's:  55
Number of  4 's:  100
Number of  5 's:  106
Number of  6 's:  139
Number of  7 's:  152
Number of  8 's:  135
Number of  9 's:  104
Number of  10 's:  87
Number of  11 's:  64
Number of  12 's:  32

如果允许使用其他python模块，那么random可以使用collections. counter来计数，通过从random.randint()切换到random. choices，可以同时掷出两个骰子：

import random
from collections import Counter

def roll_n_dice_of_sides_x_times(n,x,sides=6):
    """Rolls 'n' dices with 'sides' sides 'x' times. Yields 'x' values that 
    hold the sum of the 'x' dice rolls.""" 
    r = range(1,sides+1)
    yield from (sum(random.choices(r,k=n)) for _ in range(x))

# this does allthe counting and dice throwingof 1000 2-6sided-dice-sums
c = Counter(roll_n_dice_of_sides_x_times(2,1000))

# print the sorten (key,value) tuples of the Counter-dictionary. Sort by 
# how much eyes thrown, then amount of occurences
for eyes,count in sorted(c.items()):
    print(f"Number of {eyes:>3}'s : {count}")

输出：

Number of   2's : 24
Number of   3's : 51
Number of   4's : 66
Number of   5's : 115
Number of   6's : 149
Number of   7's : 182
Number of   8's : 153
Number of   9's : 116
Number of  10's : 68
Number of  11's : 58
Number of  12's : 18

独：

• collections.Counter
• 它是一个字典--你给它一个可迭代对象，int计算可迭代对象的每个元素出现的频率：

print(Counter( [1,2,2,3,3,3,4,4,4,4] ) )

        # Counter({4: 4, 3: 3, 2: 2, 1: 1})

• random.choices
• literal string interpolation (f-strings)
• 发电机

如果你想得到单个骰子的结果，你可以修改代码，在生成随机数的时候不计算骰子的和，而是传递元组，我对它们进行了排序，这样（5，4，5）和（4，5，5）的投掷次数是一样的：

import random
from collections import Counter

def roll_n_dice_of_sides_x_times_no_sum(n,x,sides=6):
    """Rolls 'n' dices with 'sides' sides 'x' times. Yields a sorted tuple 
    of the dice throwsof all  'x' dice rolls.""" 
    r = range(1,sides+1)

    # instead of summing, create a tuple (hashable, important for Counter)
    # and return that sorted, so that 4,4,5 == 5,4,4 == 4,5,4 throw:
    yield from ( tuple(sorted(random.choices(r,k=n))) for _ in range(x))

# throw 3 6-sided dice 1000 times and count:
c = Counter(roll_n_dice_of_sides_x_times_no_sum(3,1000))

# print the sorten (key,value) tuples of the Counter-dictionary. Sort by 
# how much eyes thrown, then amount of occurences
for dice,count in sorted(c.items()):
    print(f"{dice} occured {count} times")

输出（缩短）：

(1, 1, 1) occured 3 times
(1, 1, 2) occured 14 times
[...] 
(2, 3, 5) occured 32 times
(2, 3, 4) occured 21 times
[...]
(4, 6, 6) occured 10 times
(5, 5, 5) occured 3 times
(5, 5, 6) occured 20 times
(5, 6, 6) occured 9 times
(6, 6, 6) occured 4 times

1.编写一个模型类来表示一个骰子（也就是一个立方体，它的面编号为1到6）。这个类可能只有一个方法throw（），并且没有属性。（提示：使用Math.random编写throw。）然后，编写一个输出视图类，在掷出骰子后显示它。最后，编写一个控制器，让用户重复掷两个骰子。
1.利用上一个练习中的班级构建一个名为“画房子”的游戏。游戏的目标是反复掷骰子，并根据结果画出房子的各个部分。掷6次骰子可以画出建筑物，即一个正方形;掷五下可以拉上屋顶掷4让人拉上门;掷3可以画一个窗口。（有两个窗口。）完成的房子看起来像这样：/
/ \

|- -||x||x|

当然，建筑物必须在屋顶之前绘制，屋顶必须在门窗之前绘制。除了表示骰子的类之外，编写一个表示部分建成的房屋状态的模型类。然后，编写一个显示房屋的输出视图，并编写一个执行游戏规则的控制器。8.制作上一个项目中的游戏版本，让两个玩家竞争建造各自的房子。