random — Generieren von Pseudozufallszahlen

Quellcode: Lib/random.py

Dieses Modul implementiert Pseudozufallszahlengeneratoren für verschiedene Verteilungen.

Für ganze Zahlen gibt es die gleichmäßige Auswahl aus einem Bereich. Für Sequenzen gibt es die gleichmäßige Auswahl eines zufälligen Elements, eine Funktion zur Generierung einer zufälligen Permutation einer Liste "in-place" und eine Funktion für die zufällige Stichprobe ohne Zurücklegen.

Auf der reellen Achse gibt es Funktionen zur Berechnung von gleichmäßigen, normalen (Gaußschen), logarithmisch-normalen, negativ exponentiellen, Gamma- und Beta-Verteilungen. Zur Erzeugung von Winkelverteilungen steht die von-Mises-Verteilung zur Verfügung.

Fast alle Modulfunktionen hängen von der Basis-Funktion random() ab, die eine zufällige Gleitkommazahl gleichmäßig im halboffenen Bereich 0.0 <= X < 1.0 generiert. Python verwendet den Mersenne Twister als Kern-Generator. Er erzeugt Gleitkommazahlen mit 53-Bit-Präzision und hat eine Periode von 2**19937-1. Die zugrundeliegende Implementierung in C ist sowohl schnell als auch threadsicher. Der Mersenne Twister ist einer der am besten getesteten Zufallszahlengeneratoren, die es gibt. Da er jedoch vollständig deterministisch ist, ist er nicht für alle Zwecke geeignet und für kryptografische Zwecke völlig ungeeignet.

Die von diesem Modul bereitgestellten Funktionen sind tatsächlich gebundene Methoden einer versteckten Instanz der Klasse random.Random. Sie können eigene Instanzen von Random instanziieren, um Generatoren zu erhalten, die keinen Zustand teilen.

Random kann auch unterklassifiziert werden, wenn Sie einen anderen Basisgenerator nach eigenem Entwurf verwenden möchten: siehe die Dokumentation zu dieser Klasse für weitere Details.

Das Modul random stellt auch die Klasse SystemRandom bereit, die die Systemfunktion os.urandom() verwendet, um Zufallszahlen aus vom Betriebssystem bereitgestellten Quellen zu generieren.

Warnung

Die von diesem Modul bereitgestellten Pseudozufallszahlengeneratoren sollten nicht für Sicherheitszwecke verwendet werden. Für Sicherheits- oder kryptografische Zwecke siehe das Modul secrets.

Siehe auch

M. Matsumoto und T. Nishimura, „Mersenne Twister: A 623-dimensionally equidistributed uniform pseudorandom number generator“, ACM Transactions on Modeling and Computer Simulation Vol. 8, No. 1, Januar S. 3–30 1998.

Complementary-Multiply-with-Carry Rezept für einen kompatiblen alternativen Zufallszahlengenerator mit langer Periode und vergleichsweise einfachen Aktualisierungsoperationen.

Hinweis

Der globale Zufallszahlengenerator und Instanzen von Random sind threadsicher. Im Free-Threaded-Build können gleichzeitige Aufrufe des globalen Generators oder derselben Instanz von Random jedoch zu Konflikten und schlechter Leistung führen. Erwägen Sie, stattdessen getrennte Instanzen von Random pro Thread zu verwenden.

Buchhaltungsfunktionen

random.seed(a=None, version=2)

Initialisiert den Zufallszahlengenerator.

Wenn a weggelassen wird oder None ist, wird die aktuelle Systemzeit verwendet. Wenn Zufallsquellen vom Betriebssystem bereitgestellt werden, werden diese anstelle der Systemzeit verwendet (siehe die Funktion os.urandom() für Details zur Verfügbarkeit).

Wenn a eine Ganzzahl ist, wird sie direkt verwendet.

Bei Version 2 (Standard) wird ein Objekt vom Typ str, bytes oder bytearray in eine int konvertiert und alle seine Bits werden verwendet.

Bei Version 1 (bereitgestellt zur Reproduktion von Zufallssequenzen aus älteren Python-Versionen) erzeugt der Algorithmus für str und bytes einen engeren Bereich von Seeds.

Geändert in Version 3.2: Umstellung auf das Versions-2-Schema, das alle Bits eines String-Seeds verwendet.

Geändert in Version 3.11: Der seed muss einer der folgenden Typen sein: None, int, float, str, bytes oder bytearray.

random.getstate()

Gibt ein Objekt zurück, das den aktuellen internen Zustand des Generators erfasst. Dieses Objekt kann an setstate() übergeben werden, um den Zustand wiederherzustellen.

random.setstate(state)

state sollte von einem vorherigen Aufruf von getstate() stammen, und setstate() stellt den internen Zustand des Generators auf den Zustand wieder her, den er zum Zeitpunkt des Aufrufs von getstate() hatte.

Funktionen für Bytes

random.randbytes(n)

Generiert n zufällige Bytes.

Diese Methode sollte nicht zur Generierung von Sicherheitstokens verwendet werden. Verwenden Sie stattdessen secrets.token_bytes().

Hinzugefügt in Version 3.9.

Funktionen für Ganzzahlen

random.randrange(stop)
random.randrange(start, stop[, step])

Gibt ein zufällig ausgewähltes Element aus range(start, stop, step) zurück.

Dies ist ungefähr äquivalent zu choice(range(start, stop, step)), unterstützt aber beliebig große Bereiche und ist für gängige Fälle optimiert.

Das Muster der positionsgebundenen Argumente entspricht der Funktion range().

Schlüsselwortargumente sollten nicht verwendet werden, da sie unerwartet interpretiert werden können. Zum Beispiel wird randrange(start=100) als randrange(0, 100, 1) interpretiert.

Geändert in Version 3.2: randrange() ist ausgefeilter bei der Erzeugung gleichmäßig verteilter Werte. Früher wurde ein Stil wie int(random()*n) verwendet, der leicht ungleichmäßige Verteilungen erzeugen konnte.

Geändert in Version 3.12: Die automatische Konvertierung von Nicht-Ganzzahl-Typen wird nicht mehr unterstützt. Aufrufe wie randrange(10.0) und randrange(Fraction(10, 1)) lösen nun einen TypeError aus.

random.randint(a, b)

Gibt eine zufällige Ganzzahl N zurück, so dass a <= N <= b. Alias für randrange(a, b+1).

random.getrandbits(k)

Gibt eine nicht-negative Python-Ganzzahl mit k zufälligen Bits zurück. Diese Methode wird mit dem Mersenne-Twister-Generator geliefert, und einige andere Generatoren stellen sie möglicherweise ebenfalls als optionalen Teil der API bereit. Wenn verfügbar, ermöglicht getrandbits() randrange() die Handhabung beliebig großer Bereiche.

Geändert in Version 3.9: Diese Methode akzeptiert nun Null für k.

Funktionen für Sequenzen

random.choice(seq)

Gibt ein zufälliges Element aus der nicht-leeren Sequenz seq zurück. Wenn seq leer ist, wird ein IndexError ausgelöst.

random.choices(population, weights=None, *, cum_weights=None, k=1)

Gibt eine Liste der Größe k zurück, die mit Zurücklegen aus der population ausgewählt wurden. Wenn die population leer ist, wird ein IndexError ausgelöst.

Wenn eine weights-Sequenz angegeben ist, werden die Auswahlen entsprechend den relativen Gewichten vorgenommen. Alternativ, wenn eine cum_weights-Sequenz angegeben ist, werden die Auswahlen entsprechend den kumulativen Gewichten vorgenommen (vielleicht mit itertools.accumulate() berechnet). Zum Beispiel sind die relativen Gewichte [10, 5, 30, 5] äquivalent zu den kumulativen Gewichten [10, 15, 45, 50]. Intern werden die relativen Gewichte vor der Auswahl in kumulative Gewichte umgewandelt, sodass die Angabe der kumulativen Gewichte Arbeit spart.

Wenn weder weights noch cum_weights angegeben sind, werden die Auswahlen mit gleicher Wahrscheinlichkeit vorgenommen. Wenn eine Gewichtssequenz angegeben ist, muss sie die gleiche Länge wie die population-Sequenz haben. Es ist ein TypeError, sowohl weights als auch cum_weights anzugeben.

Die weights oder cum_weights können jeden numerischen Typ verwenden, der mit den von random() zurückgegebenen float-Werten interoperiert (dazu gehören Ganzzahlen, Gleitkommazahlen und Brüche, aber keine Dezimalzahlen). Gewichte werden als nicht-negativ und endlich angenommen. Ein ValueError wird ausgelöst, wenn alle Gewichte Null sind.

Bei einem gegebenen Seed erzeugt die Funktion choices() mit gleicher Gewichtung typischerweise eine andere Sequenz als wiederholte Aufrufe von choice(). Der von choices() verwendete Algorithmus verwendet Gleitkomma-Arithmetik für interne Konsistenz und Geschwindigkeit. Der von choice() verwendete Algorithmus verwendet standardmäßig Ganzzahl-Arithmetik mit wiederholten Auswahlen, um kleine Verzerrungen durch Rundungsfehler zu vermeiden.

Hinzugefügt in Version 3.6.

Geändert in Version 3.9: Löst einen ValueError aus, wenn alle Gewichte Null sind.

random.shuffle(x)

Mischt die Sequenz x "in-place".

Um eine unveränderliche Sequenz zu mischen und eine neue gemischte Liste zurückzugeben, verwenden Sie stattdessen sample(x, k=len(x)).

Beachten Sie, dass selbst für kleine len(x) die Gesamtzahl der Permutationen von x schnell größer werden kann als die Periode der meisten Zufallszahlengeneratoren. Dies impliziert, dass die meisten Permutationen einer langen Sequenz nie generiert werden können. Zum Beispiel ist eine Sequenz der Länge 2080 die größte, die in die Periode des Mersenne-Twister-Zufallszahlengenerators passt.

Geändert in Version 3.11: Der optionale Parameter random wurde entfernt.

random.sample(population, k, *, counts=None)

Gibt eine Liste der Länge k mit eindeutigen Elementen zurück, die aus der population-Sequenz ausgewählt wurden. Wird für die zufällige Stichprobe ohne Zurücklegen verwendet.

Gibt eine neue Liste mit Elementen aus der Population zurück, während die ursprüngliche Population unverändert bleibt. Die resultierende Liste ist in Auswahlsortierung, sodass alle Teilschnitte ebenfalls gültige Zufallsstichproben sind. Dies ermöglicht es Gewinnspiel-Gewinnern (die Stichprobe), in Hauptpreis- und Zweitplatzierte (die Teilschnitte) aufgeteilt zu werden.

Mitglieder der Population müssen nicht hashable oder eindeutig sein. Wenn die Population Wiederholungen enthält, ist jede Wiederholung eine mögliche Auswahl in der Stichprobe.

Wiederholte Elemente können einzeln oder mit dem optionalen Keyword-only-Parameter counts angegeben werden. Zum Beispiel ist sample(['red', 'blue'], counts=[4, 2], k=5) äquivalent zu sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5).

Um eine Stichprobe aus einem Bereich von Ganzzahlen auszuwählen, verwenden Sie ein range()-Objekt als Argument. Dies ist besonders schnell und speichereffizient für die Stichprobe aus einer großen Population: sample(range(10000000), k=60).

Wenn die Stichprobengröße größer ist als die Populationsgröße, wird ein ValueError ausgelöst.

Geändert in Version 3.9: Der Parameter counts wurde hinzugefügt.

Geändert in Version 3.11: Die population muss eine Sequenz sein. Die automatische Konvertierung von Sets in Listen wird nicht mehr unterstützt.

Diskrete Verteilungen

Die folgende Funktion erzeugt eine diskrete Verteilung.

random.binomialvariate(n=1, p=0.5)

Binomialverteilung. Gibt die Anzahl der Erfolge für n unabhängige Versuche mit der Erfolgswahrscheinlichkeit p in jedem Versuch zurück.

Mathematisch äquivalent zu

sum(random() < p for i in range(n))

Die Anzahl der Versuche n sollte eine nicht-negative Ganzzahl sein. Die Erfolgswahrscheinlichkeit p sollte zwischen 0.0 <= p <= 1.0 liegen. Das Ergebnis ist eine Ganzzahl im Bereich 0 <= X <= n.

Hinzugefügt in Version 3.12.

Reellwertige Verteilungen

Die folgenden Funktionen generieren spezifische reellwertige Verteilungen. Die Funktionsparameter sind nach den entsprechenden Variablen in der Gleichung der Verteilung benannt, wie sie in der gängigen mathematischen Praxis verwendet werden; die meisten dieser Gleichungen sind in jedem Statistiktext zu finden.

random.random()

Gibt die nächste zufällige Gleitkommazahl im Bereich 0.0 <= X < 1.0 zurück.

random.uniform(a, b)

Gibt eine zufällige Gleitkommazahl N zurück, so dass a <= N <= b für a <= b und b <= N <= a für b < a.

Der Endpunktwert b kann je nach Gleitkomma-Rundung im Ausdruck a + (b-a) * random() im Bereich enthalten sein oder nicht.

random.triangular(low, high, mode)

Gibt eine zufällige Gleitkommazahl N zurück, so dass low <= N <= high und mit dem angegebenen mode zwischen diesen Grenzen. Die Grenzen low und high haben standardmäßig Null und Eins. Das Argument mode hat standardmäßig den Mittelpunkt zwischen den Grenzen, was eine symmetrische Verteilung ergibt.

random.betavariate(alpha, beta)

Beta-Verteilung. Bedingungen für die Parameter sind alpha > 0 und beta > 0. Zurückgegebene Werte reichen zwischen 0 und 1.

random.expovariate(lambd=1.0)

Exponentielle Verteilung. lambd ist 1.0 geteilt durch den gewünschten Mittelwert. Er sollte ungleich Null sein. (Der Parameter wäre „lambda“ genannt, aber das ist ein reserviertes Wort in Python.) Zurückgegebene Werte reichen von 0 bis positiv unendlich, wenn lambd positiv ist, und von negativ unendlich bis 0, wenn lambd negativ ist.

Geändert in Version 3.12: Standardwert für lambd hinzugefügt.

random.gammavariate(alpha, beta)

Gamma-Verteilung. (Nicht die Gamma-Funktion!) Die Form- und Skalierungsparameter alpha und beta müssen positive Werte haben. (Aufrufkonventionen variieren, und einige Quellen definieren „beta“ als das Inverse der Skalierung).

Die Wahrscheinlichkeitsdichtefunktion ist

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
random.gauss(mu=0.0, sigma=1.0)

Normalverteilung, auch Gaußsche Verteilung genannt. mu ist der Mittelwert und sigma ist die Standardabweichung. Dies ist etwas schneller als die unten definierte Funktion normalvariate().

Hinweis zur Multithreading: Wenn zwei Threads diese Funktion gleichzeitig aufrufen, ist es möglich, dass sie denselben Rückgabewert erhalten. Dies kann auf drei Arten vermieden werden: 1) Jeder Thread verwendet eine andere Instanz des Zufallszahlengenerators. 2) Legen Sie Sperren um alle Aufrufe. 3) Verwenden Sie stattdessen die langsamere, aber threadsichere Funktion normalvariate().

Geändert in Version 3.11: mu und sigma haben nun Standardargumente.

random.lognormvariate(mu, sigma)

Log-Normalverteilung. Wenn Sie den natürlichen Logarithmus dieser Verteilung nehmen, erhalten Sie eine Normalverteilung mit dem Mittelwert mu und der Standardabweichung sigma. mu kann jeden Wert haben, und sigma muss größer als Null sein.

random.normalvariate(mu=0.0, sigma=1.0)

Normalverteilung. mu ist der Mittelwert und sigma ist die Standardabweichung.

Geändert in Version 3.11: mu und sigma haben nun Standardargumente.

random.vonmisesvariate(mu, kappa)

mu ist der mittlere Winkel, ausgedrückt in Radiant zwischen 0 und 2*pi, und kappa ist der Konzentrationsparameter, der größer oder gleich Null sein muss. Wenn kappa gleich Null ist, reduziert sich diese Verteilung auf einen gleichmäßigen Zufallswinkel im Bereich von 0 bis 2*pi.

random.paretovariate(alpha)

Paretosche Verteilung. alpha ist der Shape-Parameter.

random.weibullvariate(alpha, beta)

Weibull-Verteilung. alpha ist der Skalenparameter und beta ist der Shape-Parameter.

Alternativer Generator

class random.Random([seed])

Klasse, die den Standard-Pseudozufallszahlengenerator implementiert, der vom Modul random verwendet wird.

Geändert in Version 3.11: Früher konnte seed jedes hashbare Objekt sein. Jetzt ist es beschränkt auf: None, int, float, str, bytes oder bytearray.

Unterklassen von Random sollten die folgenden Methoden überschreiben, wenn sie einen anderen Basisgenerator verwenden möchten

seed(a=None, version=2)

Überschreiben Sie diese Methode in Unterklassen, um das Verhalten von seed() von Random-Instanzen anzupassen.

getstate()

Überschreiben Sie diese Methode in Unterklassen, um das Verhalten von getstate() von Random-Instanzen anzupassen.

setstate(state)

Überschreiben Sie diese Methode in Unterklassen, um das Verhalten von setstate() von Random-Instanzen anzupassen.

random()

Überschreiben Sie diese Methode in Unterklassen, um das Verhalten von random() von Random-Instanzen anzupassen.

Optional kann eine benutzerdefinierte Generator-Unterklasse auch die folgende Methode bereitstellen

getrandbits(k)

Überschreiben Sie diese Methode in Unterklassen, um das Verhalten von getrandbits() von Random-Instanzen anzupassen.

randbytes(n)

Überschreiben Sie diese Methode in Unterklassen, um das Verhalten von randbytes() von Random-Instanzen anzupassen.

class random.SystemRandom([seed])

Klasse, die die Funktion os.urandom() zum Generieren von Zufallszahlen aus vom Betriebssystem bereitgestellten Quellen verwendet. Nicht auf allen Systemen verfügbar. Basiert nicht auf Softwarezustand, und Sequenzen sind nicht reproduzierbar. Dementsprechend hat die Methode seed() keine Wirkung und wird ignoriert. Die Methoden getstate() und setstate() lösen NotImplementedError aus, wenn sie aufgerufen werden.

Hinweise zur Reproduzierbarkeit

Manchmal ist es nützlich, die von einem Pseudozufallszahlengenerator gelieferten Sequenzen reproduzieren zu können. Durch Wiederverwendung eines Seed-Wertes sollte dieselbe Sequenz von Lauf zu Lauf reproduzierbar sein, solange keine mehreren Threads laufen.

Die meisten Algorithmen und Seeding-Funktionen des Zufallsmoduls können sich zwischen Python-Versionen ändern, aber zwei Aspekte werden garantiert nicht geändert

  • Wenn eine neue Seeding-Methode hinzugefügt wird, wird ein abwärtskompatibler Seeder angeboten.

  • Die Methode random() des Generators wird weiterhin dieselbe Sequenz erzeugen, wenn dem kompatiblen Seeder derselbe Seed gegeben wird.

Beispiele

Grundlegende Beispiele

>>> random()                          # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                     # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)              # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])   # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                     # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4) # Four samples without replacement
[40, 10, 50, 30]

Simulationen

>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value:  ten, jack, queen, or king.
>>> deal = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> deal.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> sum(binomialvariate(n=7, p=0.6) >= 5 for i in range(10_000)) / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
...     return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958

Beispiel für statistisches Bootstrapping mit Resampling mit Zurücklegen zur Schätzung eines Konfidenzintervalls für den Mittelwert einer Stichprobe

# https://www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted(mean(choices(data, k=len(data))) for i in range(100))
print(f'The sample mean of {mean(data):.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}')

Beispiel für einen Permutationstest mit Resampling zur Bestimmung der statistischen Signifikanz oder des p-Wertes einer beobachteten Differenz zwischen den Wirkungen eines Medikaments und eines Placebos

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

Simulation von Ankunftszeiten und Bedienlieferungen für eine Mehrserver-Warteschlange

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

Siehe auch

Statistiken für Hacker ein Video-Tutorial von Jake Vanderplas über statistische Analyse mit nur wenigen grundlegenden Konzepten, einschließlich Simulation, Stichprobenziehung, Mischen und Kreuzvalidierung.

Wirtschaftssimulation eine Simulation eines Marktplatzes von Peter Norvig, die die effektive Nutzung vieler der vom Modul bereitgestellten Werkzeuge und Verteilungen zeigt (gauss, uniform, sample, betavariate, choice, triangular und randrange).

Eine konkrete Einführung in die Wahrscheinlichkeit (mit Python) ein Tutorial von Peter Norvig, das die Grundlagen der Wahrscheinlichkeitstheorie, die Erstellung von Simulationen und die Datenanalyse mit Python behandelt.

Rezepte

Diese Rezepte zeigen, wie man effizient zufällige Auswahlen aus den kombinatorischen Iteratoren im Modul itertools trifft

def random_product(*args, repeat=1):
    "Random selection from itertools.product(*args, **kwds)"
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(map(random.choice, pools))

def random_permutation(iterable, r=None):
    "Random selection from itertools.permutations(iterable, r)"
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(random.sample(pool, r))

def random_combination(iterable, r):
    "Random selection from itertools.combinations(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.sample(range(n), r))
    return tuple(pool[i] for i in indices)

def random_combination_with_replacement(iterable, r):
    "Choose r elements with replacement.  Order the result to match the iterable."
    # Result will be in set(itertools.combinations_with_replacement(iterable, r)).
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.choices(range(n), k=r))
    return tuple(pool[i] for i in indices)

Das Standard-random() gibt Vielfache von 2⁻⁵³ im Bereich 0.0 ≤ x < 1.0 zurück. Alle diese Zahlen sind gleichmäßig verteilt und können als Python-Floats exakt dargestellt werden. Viele andere darstellbare Floats in diesem Intervall sind jedoch keine möglichen Auswahlen. Zum Beispiel ist 0.05954861408025609 kein ganzzahliges Vielfaches von 2⁻⁵³.

Das folgende Rezept verfolgt einen anderen Ansatz. Alle Floats im Intervall sind mögliche Auswahlen. Die Mantisse stammt aus einer gleichmäßigen Verteilung von ganzen Zahlen im Bereich 2⁵² ≤ mantissa < 2⁵³. Der Exponent stammt aus einer geometrischen Verteilung, bei der Exponenten kleiner als -53 halb so oft auftreten wie der nächstgrößere Exponent.

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

Alle reellwertigen Verteilungen in der Klasse verwenden die neue Methode

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

Das Rezept ist konzeptionell äquivalent zu einem Algorithmus, der aus allen Vielfachen von 2⁻¹⁰⁷⁴ im Bereich 0.0 ≤ x < 1.0 wählt. Alle diese Zahlen sind gleichmäßig verteilt, aber die meisten müssen auf den nächstliegenden darstellbaren Python-Float abgerundet werden. (Der Wert 2⁻¹⁰⁷⁴ ist der kleinste positive unnormalisierte Float und entspricht math.ulp(0.0).)

Siehe auch

Generierung von Pseudo-Zufalls-Gleitkommawerten ein Papier von Allen B. Downey, das Wege zur Generierung feinkörnigerer Floats als die normalerweise von random() generierten beschreibt.

Verwendung über die Kommandozeile

Hinzugefügt in Version 3.13.

Das Modul random kann von der Kommandozeile ausgeführt werden.

python -m random [-h] [-c CHOICE [CHOICE ...] | -i N | -f N] [input ...]

Die folgenden Optionen werden akzeptiert:

-h, --help

Zeigt die Hilfemeldung an und beendet das Programm.

-c WAHL [WAHL ...]
--choice WAHL [WAHL ...]

Gibt eine zufällige Auswahl aus, mit choice().

-i <N>
--integer <N>

Gibt eine zufällige ganze Zahl zwischen 1 und N (einschließlich) aus, mit randint().

-f <N>
--float <N>

Gibt eine zufällige Gleitkommazahl zwischen 0 und N (einschließlich) aus, mit uniform().

Wenn keine Optionen angegeben werden, hängt die Ausgabe von der Eingabe ab

Beispiel für die Kommandozeile

Hier sind einige Beispiele für die Kommandozeilenschnittstelle von random

$ # Choose one at random
$ python -m random egg bacon sausage spam "Lobster Thermidor aux crevettes with a Mornay sauce"
Lobster Thermidor aux crevettes with a Mornay sauce

$ # Random integer
$ python -m random 6
6

$ # Random floating-point number
$ python -m random 1.8
1.7080016272295635

$ # With explicit arguments
$ python  -m random --choice egg bacon sausage spam "Lobster Thermidor aux crevettes with a Mornay sauce"
egg

$ python -m random --integer 6
3

$ python -m random --float 1.8
1.5666339105010318

$ python -m random --integer 6
5

$ python -m random --float 6
3.1942323316565915