@Akolon: Noch ein paar Anmerkungen zum Quelltext:
Namen sollten dem Leser klar vermitteln was der Wert dahinter im Programm bedeutet. Deswegen sind kryptische Abkürzungen oder einbuchstabige Namen schlecht. `x` wäre okay wenn es sich um eine `x`-Koordinate handelt, weil man diesen Namen dafür gewohnt ist, aber für eine Gesamtsumme ist das kein guter Name. Ähnlich gilt das für `zliste` und `zanzahl`, bei denen nicht direkt klar ist warum das jetzt gerade `z` ist (weil es nicht für eine `z`-Koordinate steht). Ebenfalls problematisch ist das kodieren von konkreten Grunddatentypen in Namen, denn man verändert öfter mal während der Programmentwicklung den Datentyp, zum Beispiel weil an anderer Sequenzdatentyp als `list` oder gar ein selbst geschriebener Datentyp mehr Sinn macht. Und dann muss man entweder überall die Namen anpassen, oder man hat falsche und irreführende Namen im Programm. Üblicherweise wählt man für einfache Containerdatentypen die Mehrzahl von der Bezeichnung die für ein einzelnes Element passend wäre. Also statt `zliste` beispielsweise `zahlen`.
Anstelle einer Liste bei `zanzahl` würde ein Wörterbuch etwas selbsterklärender sein, weil die Abbildung nicht bei 0 anfängt und man diese Verschiebung um 1 sonst immer im Kopf haben muss wenn man mit dieser Datenstruktur arbeitet. An der Stelle ist auch der willkürliche Unterschied zwischen den beiden letzten ``while``-Schleifen was den Test und die Position der Erhöhung von `zaehler` angeht verwirrend.
Diese ``while``-Schleifen sollten sowieso allesamt ``for``-Schleifen sein. ``while``-Schleifen verwendet man, wenn man vor eintritt der Schleife nicht ermitteln kann, nach wie vielen Schleifendurchläufen abgebrochen werden muss. Bei allen Schleifen in diesem Programm weiss man aber genau wie oft die durchlaufen werden. Damit entfällt jeweils die Initialisierung von `zaehler` vor der Schleife, sowie das manuelle hochzählen des Wertes innerhalb der Schleife. Und der Fehler den Du in der ersten Schleife gemacht hast, ist unwahrscheinlicher wenn man diese Sachen nicht selber von Hand erledigt.
Namen sollte man nach möglichkeit erst dort definieren, wo sie auch tatsächlich benutzt werden. Also nicht irgendwo am Anfang alle möglichen Namen an Werte binden, die erst viel später in der Funktion tatsächlich verwendet werden. Das macht den Quelltext unübersichtlicher und schwerer wartbar, weil es zum Beispiel unnötig aufwändiger wird eine zu lange Funktion in kleinere Teilfunktionen zu zerlegen.
Der Fehler der durch die erste Schleife passiert ist, könnte dadurch ausgeglichen werden, dass man weniger ”magische” Zahlen verwendet. Statt also am Ende für die Wahrscheinlichkeit eine feste Gesamtzahl der Ziehungen zu verwenden, könnte man die tatsächliche Anzahl der vorliegenden Werte ausrechnen und verwenden.
Auf jeden Fall sollte man ”magische” Zahlen nicht mehrfach im Quelltext stehen haben. Das macht das anpassen des Programms aufwändiger und fehleranfällger, wenn man sich beispielsweise andere Anzahlen von Ziehungen oder andere Wertebereiche für die Zufallszahlen ansehen möchte. In so einem Fall sollte man die jeweilige Zahl nur an *einer* Stelle im Quelltext ändern müssen.
Code und Daten sollten sich nicht wiederholen. Die Berechnung der Wahrscheinlichkeit für eine Zahl führst Du zwei mal durch.
Anweisungen der Form ``x = x + y`` lassen sich kürzer als ``x += y`` schreiben.
Ich lande dann ungefähr bei so etwas:
Code: Alles auswählen
from random import randrange
def main():
gesamtanzahl = 100000
untergrenze = 1 # Inklusive.
obergrenze = 10 # Exklusive.
assert untergrenze < obergrenze
zahlen = list()
for _ in range(gesamtanzahl):
zahlen.append(randrange(untergrenze, obergrenze))
zahl_zu_anzahl = dict()
for zahl in range(untergrenze, obergrenze):
zahl_zu_anzahl[zahl] = zahlen.count(zahl)
assert sum(zahl_zu_anzahl.values()) == gesamtanzahl
gesamtwahrscheinlichkeit = 0
for zahl, anzahl in sorted(zahl_zu_anzahl.items()):
wahrscheinlichkeit = anzahl / gesamtanzahl
print(zahl, wahrscheinlichkeit)
gesamtwahrscheinlichkeit += wahrscheinlichkeit
print('Gesamt: ', gesamtwahrscheinlichkeit)
if __name__ == '__main__':
main()
Aus der ersten Schleife könnte man jetzt noch eine „list comprehension“ machen.
Der Algorithmus zum zählen mit `count()` ist ineffizient, denn statt die `zahlen` *einmal* komplett durchzugehen, werden sie für jede der neun Zahlen komplett durchgegangen. Die Standardbibliothek enthält mit `collections.Counter` ausserdem einen Datentyp, der genau für dieses Szenario passt, so dass man das zählen gar nicht selber implementieren muss.
