random
— Generera pseudoslumpmässiga tal¶
Källkod: Lib/random.py
Denna modul implementerar pseudoslumpmässiga nummergeneratorer för olika distributioner.
För heltal finns ett enhetligt urval från ett intervall. För sekvenser finns det ett enhetligt urval av ett slumpmässigt element, en funktion för att generera en slumpmässig permutation av en lista på plats och en funktion för slumpmässigt urval utan ersättning.
På den reella linjen finns det funktioner för att beräkna uniforma, normala (gaussiska), lognormala, negativa exponentiella, gamma- och betafördelningar. För att generera fördelningar av vinklar finns von Mises-fördelningen tillgänglig.
Nästan alla modulfunktioner är beroende av den grundläggande funktionen random()
, som genererar en slumpmässig flottör enhetligt i det halvöppna intervallet 0,0 <= X < 1,0
. Python använder Mersenne Twister som kärngenerator. Den producerar flyttal med 53-bitars precision och har en period på 2**19937-1. Den underliggande implementationen i C är både snabb och trådsäker. Mersenne Twister är en av de mest omfattande slumptalsgeneratorer som finns. Eftersom den är helt deterministisk är den dock inte lämplig för alla ändamål, och den är helt olämplig för kryptografiska ändamål.
De funktioner som tillhandahålls av denna modul är faktiskt bundna metoder för en dold instans av klassen random.Random
. Du kan instansiera dina egna instanser av Random
för att få generatorer som inte delar tillstånd.
Klassen Random
kan också underklassificeras om du vill använda en annan grundläggande generator som du själv har skapat: se dokumentationen för den klassen för mer information.
Modulen random
innehåller även klassen SystemRandom
som använder systemfunktionen os.urandom()
för att generera slumptal från källor som tillhandahålls av operativsystemet.
Varning
Pseudoslumpgeneratorerna i denna modul bör inte användas för säkerhetsändamål. För säkerhet eller kryptografisk användning, se modulen secrets
.
Se även
M. Matsumoto och T. Nishimura, ”Mersenne Twister: A 623-dimensionally equidistributed uniform pseudorandom number generator”, ACM Transactions on Modeling and Computer Simulation Vol. 8, No. 1, January pp.3–30 1998.
Complementary-Multiply-with-Carry recipe för en kompatibel alternativ slumptalsgenerator med lång period och jämförelsevis enkla uppdateringsoperationer.
Anteckning
Den globala slumptalsgeneratorn och instanser av Random
är trådsäkra. I den frittrådade versionen kan dock samtidiga anrop till den globala generatorn eller till samma instans av Random
leda till konflikter och dålig prestanda. Överväg att använda separata instanser av Random
per tråd istället.
Bokföringsfunktioner¶
- random.seed(a=None, version=2)¶
Initialisera slumptalsgeneratorn.
Om a utelämnas eller
None
, används den aktuella systemtiden. Om slumpmässiga källor tillhandahålls av operativsystemet används de i stället för systemtiden (se funktionenos.urandom()
för information om tillgänglighet).Om a är en int används den direkt.
Med version 2 (standard) konverteras ett
str
-,bytes
- ellerbytearray
-objekt till ettint
-objekt och alla dess bitar används.Med version 1 (som tillhandahålls för att återskapa slumpmässiga sekvenser från äldre versioner av Python) genererar algoritmen för
str
ochbytes
ett smalare urval av frön.Ändrad i version 3.2: Flyttat till version 2-schemat som använder alla bitar i en strängfrö.
- random.getstate()¶
Returnerar ett objekt som fångar generatorns nuvarande interna tillstånd. Detta objekt kan skickas till
setstate()
för att återställa tillståndet.
- random.setstate(state)¶
state bör ha erhållits från ett tidigare anrop till
getstate()
, ochsetstate()
återställer generatorns interna tillstånd till vad det var närgetstate()
anropades.
Funktioner för bytes¶
- random.randbytes(n)¶
Generera n slumpmässiga byte.
Denna metod bör inte användas för att generera säkerhetstoken. Använd
secrets.token_bytes()
istället.Tillagd i version 3.9.
Funktioner för heltal¶
- random.randrange(stop)¶
- random.randrange(start, stop[, step])
Returnerar ett slumpmässigt valt element från
range(start, stop, step)
.Detta motsvarar i stort sett
choice(range(start, stop, step))
men stöder godtyckligt stora intervall och är optimerat för vanliga fall.Det positionella argumentmönstret matchar funktionen
range()
.Nyckelord som argument bör inte användas eftersom de kan tolkas på oväntade sätt. Till exempel tolkas
randrange(start=100)
somrandrange(0, 100, 1)
.Ändrad i version 3.2:
randrange()
är mer sofistikerad när det gäller att producera jämnt fördelade värden. Tidigare användes en stil somint(random()*n)
som kunde ge något ojämna fördelningar.Ändrad i version 3.12: Automatisk konvertering av typer som inte är heltal stöds inte längre. Anrop som
randrange(10.0)
ochrandrange(Fraction(10, 1))
ger nu upphov till ettTypeError
.
- random.randint(a, b)¶
Returnerar ett slumpmässigt heltal N så att
a <= N <= b
. Alias förrandrange(a, b+1)
.
- random.getrandbits(k)¶
Returnerar ett icke-negativt Python-heltal med k slumpmässiga bitar. Denna metod levereras med Mersenne Twister-generatorn och vissa andra generatorer kan också tillhandahålla den som en valfri del av API:et. När den är tillgänglig gör
getrandbits()
det möjligt förrandrange()
att hantera godtyckligt stora intervall.Ändrad i version 3.9: Denna metod accepterar nu noll för k.
Funktioner för sekvenser¶
- random.choice(seq)¶
Returnerar ett slumpmässigt element från den icke-tomma sekvensen seq. Om seq är tom, uppstår
IndexError
.
- random.choices(population, weights=None, *, cum_weights=None, k=1)¶
Returnerar en k stor lista med element som valts från populationen med ersättning. Om populationen är tom, uppstår
IndexError
.Om en weights-sekvens anges görs urvalen enligt de relativa vikterna. Alternativt, om en cum_weights-sekvens anges, görs urvalen enligt de kumulativa vikterna (kanske beräknade med
itertools.accumulate()
). Till exempel är de relativa vikterna[10, 5, 30, 5]
likvärdiga med de kumulativa vikterna[10, 15, 45, 50]
. Internt konverteras de relativa vikterna till kumulativa vikter innan urval görs, så det sparar arbete att ange de kumulativa vikterna.Om varken weights eller cum_weights anges görs urvalen med lika stor sannolikhet. Om en sekvens med vikter anges måste den vara lika lång som sekvensen population. Det är ett
TypeError
att ange både weights och cum_weights.I weights eller cum_weights kan du använda vilken numerisk typ som helst som fungerar med
float
-värdena som returneras avrandom()
(vilket inkluderar heltal, flyttal och fraktioner men inte decimaler). Vikter antas vara icke-negativa och ändliga. EttValueError
uppstår om alla vikter är noll.För ett visst frö ger funktionen
choices()
med lika viktning vanligtvis en annan sekvens än upprepade anrop tillchoice()
. Algoritmen som används avchoices()
använder flyttalsaritmetik för intern konsistens och snabbhet. Algoritmen som används avchoice()
använder som standard heltalsaritmetik med upprepade val för att undvika små förskjutningar från avrundningsfel.Tillagd i version 3.6.
Ändrad i version 3.9: Utlöser ett
ValueError
om alla vikter är noll.
- random.shuffle(x)¶
Blanda sekvensen x på plats.
Om du vill blanda en oföränderlig sekvens och returnera en ny blandad lista använder du
sample(x, k=len(x))
istället.Observera att även för små
len(x)
kan det totala antalet permutationer av x snabbt bli större än perioden för de flesta slumptalsgeneratorer. Detta innebär att de flesta permutationer av en lång sekvens aldrig kan genereras. Till exempel är en sekvens med längden 2080 den största som kan rymmas inom perioden för slumptalsgeneratorn Mersenne Twister.Ändrad i version 3.11: Den valfria parametern random har tagits bort.
- random.sample(population, k, *, counts=None)¶
Returnerar en k lång lista med unika element som valts från populationssekvensen. Används för slumpmässig provtagning utan ersättning.
Returnerar en ny lista som innehåller element från populationen medan den ursprungliga populationen lämnas oförändrad. Den resulterande listan är i urvalsordning så att alla delskivor också kommer att vara giltiga slumpmässiga urval. Detta gör det möjligt att dela upp lotterivinnare (urvalet) i vinnare av förstapriset och andraplatsen (underskivorna).
Medlemmarna i populationen behöver inte vara hashable eller unika. Om populationen innehåller upprepningar är varje förekomst ett möjligt urval i urvalet.
Upprepade element kan anges ett i taget eller med den valfria parametern counts som endast innehåller nyckelord. Exempelvis är
sample(['red', 'blue'], counts=[4, 2], k=5)
likvärdigt medsample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
.Om du vill välja ett urval från ett intervall av heltal använder du ett
range()
-objekt som argument. Detta är särskilt snabbt och utrymmeseffektivt för provtagning från en stor population:sample(range(10000000), k=60)
.Om urvalsstorleken är större än populationsstorleken uppstår ett
ValueError
.Ändrad i version 3.9: Lagt till parametern counts.
Ändrad i version 3.11: Population måste vara en sekvens. Automatisk konvertering av sets till listor stöds inte längre.
Diskreta fördelningar¶
Följande funktion genererar en diskret fördelning.
- random.binomialvariate(n=1, p=0.5)¶
Binomialfördelning. Returnera antalet lyckade försök för n oberoende försök där sannolikheten för att lyckas i varje försök är p:
Matematiskt likvärdig med:
sum(random() < p för i i intervallet(n))
Antalet försök n ska vara ett icke-negativt heltal. Sannolikheten för framgång p ska ligga mellan
0,0 <= p <= 1,0
. Resultatet är ett heltal i intervallet0 <= X <= n
.Tillagd i version 3.12.
Realvärdesdistributioner¶
Följande funktioner genererar specifika realvärdesfördelningar. Funktionsparametrarna är namngivna efter motsvarande variabler i fördelningens ekvation, som används i vanlig matematisk praxis; de flesta av dessa ekvationer kan hittas i vilken statistiktext som helst.
- random.random()¶
Returnerar nästa slumpmässiga flyttal i intervallet
0,0 <= X < 1,0
- random.uniform(a, b)¶
Returnerar ett slumpmässigt flyttal N så att
a <= N <= b
föra <= b
ochb <= N <= a
förb < a
.Slutpunktsvärdet
b
kan ingå eller inte ingå i intervallet beroende på avrundningen av flyttal i uttrycketa + (b-a) * random()
.
- random.triangular(low, high, mode)¶
Returnerar ett slumpmässigt flyttal N så att
låg <= N <= hög
och med det angivna läget mellan dessa gränser. Gränserna low och high är som standard noll och ett. Argumentet mode är som standard mittpunkten mellan gränserna, vilket ger en symmetrisk fördelning.
- random.betavariate(alpha, beta)¶
Betafördelning. Villkoren för parametrarna är
alpha > 0
ochbeta > 0
. Returnerade värden varierar mellan 0 och 1.
- random.expovariate(lambd=1.0)¶
Exponentiell fördelning. lambd är 1,0 dividerat med önskat medelvärde. Det bör vara ett värde som inte är noll. (Parametern skulle kallas ”lambda”, men det är ett reserverat ord i Python) Returnerade värden sträcker sig från 0 till positiv oändlighet om lambd är positiv, och från negativ oändlighet till 0 om lambd är negativ.
Ändrad i version 3.12: Lagt till standardvärde för
lambd
.
- random.gammavariate(alpha, beta)¶
Gammafördelning. (Inte gammafunktionen!) Parametrarna för form och skala, alpha och beta, måste ha positiva värden. (Benämningskonventionerna varierar och vissa källor definierar ”beta” som skalans invers).
Sannolikhetsfördelningsfunktionen är:
x ** (alfa - 1) * math.exp(-x / beta) pdf(x) = -------------------------------------- math.gamma(alfa) * beta ** alfa
- random.gauss(mu=0.0, sigma=1.0)¶
Normalfördelning, även kallad gaussisk fördelning. mu är medelvärdet och sigma är standardavvikelsen. Detta är något snabbare än funktionen
normalvariate()
som definieras nedan.Notering om multithreading: När två trådar anropar denna funktion samtidigt är det möjligt att de får samma returvärde. Detta kan undvikas på tre sätt. 1) Låt varje tråd använda en annan instans av slumptalsgeneratorn. 2) Sätt lås runt alla anrop. 3) Använd den långsammare men trådsäkra funktionen
normalvariate()
istället.Ändrad i version 3.11: mu och sigma har nu standardargument.
- random.lognormvariate(mu, sigma)¶
Logaritmisk normalfördelning. Om du tar den naturliga logaritmen av den här fördelningen får du en normalfördelning med medelvärde mu och standardavvikelse sigma. mu kan ha vilket värde som helst och sigma måste vara större än noll.
- random.normalvariate(mu=0.0, sigma=1.0)¶
Normalfördelning. mu är medelvärdet och sigma är standardavvikelsen.
Ändrad i version 3.11: mu och sigma har nu standardargument.
- random.vonmisesvariate(mu, kappa)¶
mu är medelvinkeln, uttryckt i radianer mellan 0 och 2*pi, och kappa är koncentrationsparametern, som måste vara större än eller lika med noll. Om kappa är lika med noll reduceras denna fördelning till en enhetlig slumpmässig vinkel över intervallet 0 till 2*pi.
- random.paretovariate(alpha)¶
Pareto-fördelning. alpha är formparametern.
- random.weibullvariate(alpha, beta)¶
Weibullfördelning. alpha är skalparametern och beta är formparametern.
Alternativ generator¶
- class random.Random([seed])¶
Klass som implementerar standardgeneratorn för pseudoslumptal som används av modulen
random
.Ändrad i version 3.11: Tidigare kunde seed vara vilket hashbart objekt som helst. Nu är det begränsat till:
None
,int
,float
,str
,bytes
, ellerbytearray
.Subklasser av
Random
bör åsidosätta följande metoder om de vill använda en annan grundläggande generator:- seed(a=None, version=2)¶
Åsidosätt denna metod i underklasser för att anpassa
seed()
-beteendet förRandom
-instanser.
- getstate()¶
Åsidosätt denna metod i underklasser för att anpassa
getstate()
-beteendet förRandom
-instanser.
- setstate(state)¶
Åsidosätt denna metod i underklasser för att anpassa
setstate()
-beteendet förRandom
-instanser.
- random()¶
Åsidosätt denna metod i underklasser för att anpassa
random()
-beteendet förRandom
-instanser.
Alternativt kan en underklass till en anpassad generator också tillhandahålla följande metod:
- getrandbits(k)¶
Åsidosätt denna metod i underklasser för att anpassa
getrandbits()
-beteendet förRandom
-instanser.
- randbytes(n)¶
Åsidosätt denna metod i underklasser för att anpassa
randbytes()
-beteendet hosRandom
-instanser.
- class random.SystemRandom([seed])¶
Klass som använder funktionen
os.urandom()
för att generera slumptal från källor som tillhandahålls av operativsystemet. Finns inte tillgänglig på alla system. Förlitar sig inte på programvarutillstånd och sekvenser är inte reproducerbara. Följaktligen har metodenseed()
ingen effekt och ignoreras. Metodernagetstate()
ochsetstate()
ger upphov tillNotImplementedError
om de anropas.
Anteckningar om reproducerbarhet¶
Ibland är det bra att kunna reproducera de sekvenser som ges av en pseudoslumpmässig nummergenerator. Genom att återanvända ett seed-värde bör samma sekvens kunna reproduceras från körning till körning så länge inte flera trådar körs.
De flesta av slumpmodulens algoritmer och såddfunktioner kan ändras i olika Python-versioner, men två aspekter kommer garanterat inte att ändras:
Om en ny såningsmetod läggs till kommer en bakåtkompatibel såmaskin att erbjudas.
Generatorns metod
random()
kommer att fortsätta att producera samma sekvens när den kompatibla såningsmaskinen får samma frö.
Exempel¶
Grundläggande exempel:
>>> 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]
Simuleringar:
>>> # 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
Exempel på statistisk bootstrapping där man använder omsampling med ersättning för att skatta ett konfidensintervall för medelvärdet i ett urval:
# 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}')
Exempel på ett resampling permutationstest för att fastställa den statistiska signifikansen eller p-värdet för en observerad skillnad mellan effekterna av ett läkemedel och placebo:
# 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.')
Simulering av ankomsttider och serviceleveranser för en multiserver-kö:
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)])
Se även
Statistics for Hackers en videohandledning av Jake Vanderplas om statistisk analys med hjälp av några få grundläggande begrepp, bland annat simulering, provtagning, blandning och korsvalidering.
Economics Simulation en simulering av en marknadsplats av Peter Norvig som visar effektiv användning av många av de verktyg och fördelningar som tillhandahålls av denna modul (gauss, uniform, sample, betavariate, choice, triangular och randrange).
A Concrete Introduction to Probability (using Python) en handledning av Peter Norvig som täcker grunderna i sannolikhetsteori, hur man skriver simuleringar och hur man utför dataanalys med Python.
Recept¶
Dessa recept visar hur man på ett effektivt sätt gör slumpmässiga urval från de kombinatoriska iteratorerna i modulen itertools
:
def random_product(*args, repeat=1):
"Slumpmässigt urval från itertools.product(*args, **kwds)"
pooler = [tuple(pool) for pool in args] * repeat
return tuple(map(slumpmässigt.val, pooler))
def random_permutation(iterabel, r=None):
"Slumpmässigt urval från itertools.permutations(iterable, r)"
pool = tupel(iterabel)
r = len(pool) if r is None else r
return tuple(slumpmässigt.urval(pool, r))
def slumpmässig_kombination(iterabel, r):
"Slumpmässigt urval från itertools.combinations(iterable, r)"
pool = tupel(iterabel)
n = len(pool)
index = sorterad(slumpmässigt.urval(intervall(n), r))
return tuple(pool[i] for i in index)
def random_combination_with_replacement(iterable, r):
"Välj r element med ersättning. Ordna resultatet så att det matchar iterabeln."
# Resultatet kommer att finnas i set(itertools.combinations_with_replacement(iterable, r)).
pool = tupel(iterabel)
n = len(pool)
index = sorterad(random.choices(range(n), k=r))
return tuple(pool[i] for i in index)
Standardvärdet random()
returnerar multiplar av 2-⁵³ i intervallet 0,0 ≤ x < 1,0. Alla sådana tal är jämnt fördelade och är exakt representerbara som Python-flottor. Många andra representativa flyttal i det intervallet är dock inte möjliga val. Till exempel är 0,05954861408025609
inte en heltalsmultipel av 2-⁵³.
I följande recept används ett annat tillvägagångssätt. Alla flyttal i intervallet är möjliga val. Mantissan kommer från en enhetlig fördelning av heltal i intervallet 2⁵² ≤ mantissa < 2⁵³. Exponenten kommer från en geometrisk fördelning där exponenter som är mindre än -53 förekommer hälften så ofta som den nästa större exponenten.
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)
Alla realvärdesdistributioner i klassen kommer att använda den nya metoden:
>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544
Receptet är konceptuellt likvärdigt med en algoritm som väljer bland alla multiplar av 2-¹⁰⁷⁴ i intervallet 0,0 ≤ x < 1,0. Alla sådana tal är jämnt fördelade, men de flesta måste avrundas nedåt till närmaste representativa Python-flat. (Värdet 2-¹⁰⁷⁴ är den minsta positiva onormaliserade flottören och är lika med math.ulp(0.0)
.)
Se även
Generating Pseudo-random Floating-Point Values en artikel av Allen B. Downey som beskriver sätt att generera mer finkorniga flyttal än vad som normalt genereras av random()
.
Användning av kommandoraden¶
Tillagd i version 3.13.
Modulen random
kan köras från kommandoraden.
python -m random [-h] [-c CHOICE [CHOICE ...] | -i N | -f N] [inmatning ...]
Följande alternativ accepteras:
- -h, --help¶
Visa hjälpmeddelandet och avsluta.
- -c CHOICE [CHOICE ...]¶
- --choice CHOICE [CHOICE ...]¶
Skriv ut ett slumpmässigt val med hjälp av
choice()
.
- -f <N>¶
- --float <N>¶
Skriv ut ett slumpmässigt flyttal mellan 0 och N inklusive, med hjälp av
uniform()
.
Om inga alternativ anges beror utdata på indata:
Exempel på kommandorad¶
Här följer några exempel på kommandoradsgränssnittet random
:
$ # Välj en slumpmässigt
$ python -m slumpmässigt ägg bacon korv spam "Hummer Thermidor aux crevettes med en Mornay-sås"
Hummer Thermidor aux crevettes med Mornay-sås
$ # Slumpmässigt heltal
$ python -m slumpmässigt 6
6
$ # Slumpmässigt flyttal
$ python -m slumpmässigt 1,8
1.7080016272295635
$ # Med uttryckliga argument
$ python -m random --choice ägg bacon korv spam "Hummer Thermidor aux crevettes med en Mornay-sås"
ägg
$ python -m slumpmässig --integer 6
3
$ python -m slumpmässig -flata 1,8
1.5666339105010318
$ python -m slumpmässig --integer 6
5
$ python -m slumpmässig -flata 6
3.1942323316565915