Effizientere Berechnung Wahrscheinlichkeiten

Question

Ich habe mit etwas Programmier-Unerfahrenheit zu kämpfen. Der Code, den ich unten geschrieben habe, ist extrem unbequem und unschön anzusehen.

Meine Frage an Sie lautet: Wie kann dies effizienter durchgeführt werden? Die Art, wie ich es gewählt habe, ist ziemlich ineffizient. Beachten Sie den Abschnitt def freq_2dice(n, N): des Codes sowie die print Anweisungen. Das sind die Bereiche, in denen ich mehr Effizienz und einfach nur schön aussehenden Code brauche.

Danke!

EDIT: Die Aufgabe ist es, eine Funktion zu erstellen, die jede der Wahrscheinlichkeiten des Erhaltens jeder der möglichen Summen aufzeichnet und speichert, wenn 2 Würfel geworfen werden, n mal.

Der Rest des Codes vergleicht diese Wahrscheinlichkeiten mit den genauen Wahrscheinlichkeiten.

EDIT2: Fehler im Code

from random import randint 
import sys 

def freq_2dice(n, N): 
    M, A, E, R, T, Y, U, I, O, P, D = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
    for reps in xrange(N): 
     s = 0 
     for dice in xrange(n): 
      outcome = randint(1, 6) 
      s += outcome 
     if s==2: 
      M += 1 
     if s==3: 
      A += 1 
     if s==4: 
      E += 1 
     if s==5: 
      R += 1 
     if s==6: 
      T += 1 
     if s==7: 
      Y += 1 
     if s==8: 
      U += 1 
     if s==9: 
      I += 1 
     if s==10: 
      O += 1 
     if s==11: 
      P += 1 
     if s==12: 
      D += 1 
    return N*(float(M)/N), N*(float(A)/N), N*(float(E)/N), N*(float(R)/N), N*(float(T)/N), N*(float(Y)/N), N*(float(U)/N), N*(float(I)/N), N*(float(O)/N), N*(float(P)/N), N*(float(D)/N) 

def chance_die(): 
    frequencies = {} 
    for s in range(2, 13): 
     frequency = 0 
     for die1 in range(1, 7): 
      for die2 in range(1, 7): 
       if die1 + die2 == s: 
        frequency += 1 
     frequencies[s] = frequency 
    return frequencies 


n = int(sys.argv[1]) 
N = int(sys.argv[2]) 

print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[0], freq_2dice(n, N)[0]/(N/100), chance_die()[2]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[1], freq_2dice(n, N)[0]/(N/100), chance_die()[3]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[2], freq_2dice(n, N)[0]/(N/100), chance_die()[4]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[3], freq_2dice(n, N)[0]/(N/100), chance_die()[5]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[4], freq_2dice(n, N)[0]/(N/100), chance_die()[6]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[5], freq_2dice(n, N)[0]/(N/100), chance_die()[7]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[6], freq_2dice(n, N)[0]/(N/100), chance_die()[8]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[7], freq_2dice(n, N)[0]/(N/100), chance_die()[9]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[8], freq_2dice(n, N)[0]/(N/100), chance_die()[10]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[9], freq_2dice(n, N)[0]/(N/100), chance_die()[11]/.36) 
print 'No. of twos: %d, probability: %.2f, expected: %.2f' % (freq_2dice(n, N)[10], freq_2dice(n, N)[0]/(N/100), chance_die()[12]/.36) 

''' 

MacBook-Air:python Leroy$ python freq_2dice.py 2 100000 
No. of twos: 2680, probability: 2.80, expected: 2.78 
No. of threes: 5612, probability: 5.51, expected: 5.56 
No. of fours: 8169, probability: 8.43, expected: 8.33 
No. of fives: 11099, probability: 10.96, expected: 11.11 
No. of sixes: 13827, probability: 13.91, expected: 13.89 
No. of sevens: 16610, probability: 16.51, expected: 16.67 
No. of eights: 13808, probability: 13.72, expected: 13.89 
No. of nines: 10947, probability: 11.22, expected: 11.11 
No. of tens: 8249, probability: 8.35, expected: 8.33 
No. of elevens: 5540, probability: 5.59, expected: 5.56 
No. of twelves: 2805, probability: 2.74, expected: 2.78 

''' 

Answer 1

Sie sind die falsche N in der zweiten Schleife verwenden, sieht es aus wie es n sein sollte, das heißt 100000 Läufe 2 Würfel zu werfen.
Sie brauchen wirklich nicht alle Variablen, Sie wollen nur die Punkte zählen, verwenden Sie eine dict mit der Punktzahl als Schlüssel.
Sie rufen freq_2dice() für jede print, was N*n Anrufe für jeden Druck bedeutet. Sie sollten es nur einmal nennen:

result = freq_2dice(n, N) 
print ... result[0] ... 
print ... result[1] ... 
... 

eine Anzahl von Bereichen gibt, die 2 Würfel geht davon aus, trotz der Anzahl der Würfel ein Argument zu sein.

Ein Beispiel eines dict halten {score: count} mit:

from random import randint 

def freq_ndice(n, N): 
    d = {} 
    for _ in range(N): 
     score = sum(randint(1, 6) for _ in range(n)) 
     d[score] = d.get(score, 0) + 1 
    return d 

Aber schließlich kann man Frequenzberechnung viel mit collections.Counter() zu vereinfachen, die eine Form von dict ist, dass das Auftreten der Dinge hochzählt:

from collection import Counter 

def freq_ndice(n, N): 
    return Counter(sum(random.randint(1, 6) for _ in range(n)) for _ in range(N)) 

>>> n, N = 2, 100000 
>>> for score, count in freq_ndice(n, N).items(): 
...  print('No. of {}s: {}, probability: {:.2f}%'.format(score, count, 100*count/N)) 
No. of 2s: 2870, probability: 2.87% 
No. of 3s: 5533, probability: 5.53% 
No. of 4s: 8386, probability: 8.39% 
No. of 5s: 11081, probability: 11.08% 
No. of 6s: 13947, probability: 13.95% 
No. of 7s: 16649, probability: 16.65% 
No. of 8s: 13850, probability: 13.85% 
No. of 9s: 11166, probability: 11.17% 
No. of 10s: 8166, probability: 8.17% 
No. of 11s: 5496, probability: 5.50% 
No. of 12s: 2856, probability: 2.86% 
1 loop, best of 3: 900 ms per loop 

Hinweis: Python3 ... verwenden Sie xrange, from __future__ import print_function und 100.0 in Python2