将一个骰子转换为两个骰子

Question

I am a new learner with python and right now my code stimulates rolling one dice 1,000 times, however I just need some improvement to make it stimulate rolling two dice 1,000 times.

Here is what I have so far which is working perfectly just need some improvement:

import random
test_data = [0, 0, 0, 0, 0, 0]
n = 1000
for i in range(n):
  result = random.randint(1, 6)
  test_data[result - 1] = test_data[result - 1] + 1

for i in range(0, 6):
  print ("Number of ", i+1, "'s: ", test_data[i])

Any suggestions on how to get two dice rolling and get the similar output as what my code is doing right now which is this:

Number of  1 's:  180

Number of  2 's:  161

Number of  3 's:  179

Number of  4 's:  159

Number of  5 's:  146

Number of  6 's:  175

Answer 1

In that case the outcome are numbers between 2 and 12 . For simplicity it is better however to probably maintain the first index.

The test_data list thus needs to be increased to store 12 items, and as result we should call random.randint(1, 6) twice (not times two), and add these together:

import random

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

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

It is also more elegant to write += 1 here, instead of = ... + 1 , since here we avoid writing test_data[result - 1] twice. Furthermore in Python one typically enumerates over the collection directly, not over the indices. One can use enumerate(iterable, start_index) to generate an iterable of 2-tuples (i, n) with i the index, and x the element of the collection that is related to that index.

Answer 2

This is a solution for two indistinguishable dice, meaning that throwing a 1 and a 3 is treated identical to a 3 and a 1. In this approach we use a dict instead of a list , because for two (or more!) indistinguishable dice the list would have "holes" (combinations like 3, 1 that can never occur because we treat them like 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 is now both dice, sorted so that 3, 1 is treated as 1, 3, and converted from a list into a tuple (basically an immutable list) so we can use it as key for a dictionary ( counts ). Then we just increase the count for that particular combination of dice.

Unlike the list, the dictionary is not sorted, but we do want a nice output sorted by what the dice showed, so we sort by the keys = dice:

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

This gives you:

(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
...

Answer 3

You could use numpy , and this solution allows you to specify any number of dice:

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

Yields:

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

Answer 4

If you are allowed to use other python modules then random you can leverage collections.Counter to do your counting. By switching from random.randint() to random.choices you can throw both dices at once:

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}")

Output:

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

Doku:

• collections.Counter
  • its a dictionary - you feed it an iterable and int counts how often each element of the iterable occurs:

        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)
• generators

---

If instead you wanted the single dice results, you can modify the code to not sum dices but instead deliver the tuples when generating the random numbers. I sorted them, so that (5,4,5) is the same throw as (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")

Output (shortened):

(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

Answer 5

6. Write a model class that represents a die (that is, a cube whose sides are numbered 1 to 6). The class will likely have just one method, throw(), and no attributes. (Hint: use Math.random to write throw.) Then, write an output-view class that displays a die after it has been thrown. Finally, write a controller that lets a user throw two dice repeatedly.
7. Use the class from the previous exercise to build a game called “draw the house.” The objective is to throw a die repeatedly, and based on the outcome, draw parts of a house. A throw of 6 lets one draw the building, a square; a throw of 5 lets one draw the roof; a throw of 4 lets one draw the door; and a throw of 3 lets one draw a window. (There are two windows.) The finished house looks something like this: /
   / \

---

| _ | |x| |x|

Of course, the building must be drawn before the roof, and the roof must be drawn before the doors and windows. In addition to the class that represents the die, write a model class that represents the state of a partially built house. Then, write an output view that displays the house, and write a controller that enforces the rules of the game. 8. Make a version of the game in the previous Project that lets two players compete at building their respective houses.