Generieren Sie zufällige Ganzzahlen zwischen 0 und 9

Wie kann ich in Python zufällige Ganzzahlen zwischen 0 und 9 (einschließlich) generieren?

Zum Beispiel 0, 1, 2, 3, 4, 5, 6, 7, 8,9

Versuchen:

from random import randrange
print(randrange(10))

Weitere Informationen: http://docs.python.org/library/random.html#random.randrange

import random
print(random.randint(0,9))

random.randint(a, b)

Gibt eine zufällige ganze Zahl N zurück, so dass a <= N <= b.

Dokumente: https://docs.python.org/3.1/library/random.html#random.randint

Versuche dies:

from random import randrange, uniform

# randrange gives you an integral value
irand = randrange(0, 10)

# uniform gives you a floating-point value
frand = uniform(0, 10)

from random import randint

x = [randint(0, 9) for p in range(0, 10)]

Dies erzeugt 10 Pseudozufallszahlen im Bereich von 0 bis einschließlich 9.

Das secretsModul ist neu in Python 3.6. Das ist besser als dasrandom Modul für Kryptografie- oder Sicherheitszwecke.

So drucken Sie zufällig eine Ganzzahl im Inklusivbereich 0-9:

from secrets import randbelow
print(randbelow(10))

Einzelheiten finden Sie in PEP 506 .

Wählen Sie die Größe des Arrays (in diesem Beispiel habe ich die Größe 20 gewählt). Verwenden Sie dann Folgendes:

import numpy as np   
np.random.randint(10, size=(1, 20))

Sie können erwarten, dass eine Ausgabe der folgenden Form angezeigt wird (jedes Mal, wenn Sie sie ausführen, werden unterschiedliche zufällige Ganzzahlen zurückgegeben; daher können Sie erwarten, dass sich die Ganzzahlen im Ausgabearray von dem unten angegebenen Beispiel unterscheiden ).

array([[1, 6, 1, 2, 8, 6, 3, 3, 2, 5, 6, 5, 0, 9, 5, 6, 4, 5, 9, 3]])

Versuchen Sie dies durch random.shuffle

>>> import random
>>> nums = range(10)
>>> random.shuffle(nums)
>>> nums
[6, 3, 5, 4, 0, 1, 2, 9, 8, 7]

Ich würde eines der folgenden versuchen:

1.> numpy.random.randint

import numpy as np
X1 = np.random.randint(low=0, high=10, size=(15,))

print (X1)
>>> array([3, 0, 9, 0, 5, 7, 6, 9, 6, 7, 9, 6, 6, 9, 8])

2.> numpy.random.uniform

import numpy as np
X2 = np.random.uniform(low=0, high=10, size=(15,)).astype(int)

print (X2)
>>> array([8, 3, 6, 9, 1, 0, 3, 6, 3, 3, 1, 2, 4, 0, 4])

3.> random.randrange

from random import randrange
X3 = [randrange(10) for i in range(15)]

print (X3)
>>> [2, 1, 4, 1, 2, 8, 8, 6, 4, 1, 0, 5, 8, 3, 5]

4.> random.randint

from random import randint
X4 = [randint(0, 9) for i in range(0, 15)]

print (X4)
>>> [6, 2, 6, 9, 5, 3, 2, 3, 3, 4, 4, 7, 4, 9, 6]

Geschwindigkeit:

► np.random.randint ist der schnellste , gefolgt von np.random.uniform und random.randrange . random.randint ist am langsamsten .

► Sowohl np.random.randint als auch np.random.uniform sind viel schneller (~ 8 - 12 mal schneller) als random.randrange und random.randint .

%timeit np.random.randint(low=0, high=10, size=(15,))
>> 1.64 µs ± 7.83 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit np.random.uniform(low=0, high=10, size=(15,)).astype(int)
>> 2.15 µs ± 38.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [randrange(10) for i in range(15)]
>> 12.9 µs ± 60.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [randint(0, 9) for i in range(0, 15)]
>> 20 µs ± 386 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Anmerkungen:

1.> np.random.randint generiert zufällige Ganzzahlen über das halboffene Intervall [niedrig, hoch].

2.> np.random.uniform erzeugt gleichmäßig verteilte Zahlen über das halboffene Intervall [niedrig, hoch].

3.> random.randrange (stop) generiert eine Zufallszahl aus dem Bereich (start, stop, step).

4.> random.randint (a, b) gibt eine zufällige ganze Zahl N zurück, so dass a <= N <= b.

5.> astype (int) wandelt das numpy-Array in den Datentyp int um.

6.> Ich habe Größe = (15,) gewählt. Dies gibt Ihnen ein numpy Array mit einer Länge von = 15.

Im Fall von fortlaufenden Zahlen randintoder randrangewahrscheinlich die beste Wahl, aber wenn Sie mehrere unterschiedliche Werte in einer Sequenz haben (dh a list), können Sie auch Folgendes verwenden choice:

>>> import random
>>> values = list(range(10))
>>> random.choice(values)
5

choice funktioniert auch für einen Artikel aus einer nicht kontinuierlichen Stichprobe:

>>> values = [1, 2, 3, 5, 7, 10]
>>> random.choice(values)
7

Wenn Sie es "kryptografisch stark" benötigen, gibt es auch eine secrets.choicein Python 3.6 und neuer:

>>> import secrets
>>> values = list(range(10))
>>> secrets.choice(values)
2

Während viele Beiträge zeigen , wie man eine Zufallszahl, fragt die ursprüngliche Frage , wie Zufallszahl erzeugen s (Plural):

Wie kann ich in Python zufällige Ganzzahlen zwischen 0 und 9 (einschließlich) generieren?

Zur Verdeutlichung zeigen wir hier, wie mehrere zufällige Ganzzahlen erhalten werden.

Gegeben

>>> import random


lo = 0
hi = 10
size = 5

Code

Mehrere zufällige Ganzzahlen

# A
>>> [lo + int(random.random() * (hi - lo)) for _ in range(size)]
[5, 6, 1, 3, 0]

# B
>>> [random.randint(lo, hi) for _ in range(size)]
[9, 7, 0, 7, 3]

# C
>>> [random.randrange(lo, hi) for _ in range(size)]
[8, 3, 6, 8, 7]

# D
>>> lst = list(range(lo, hi))
>>> random.shuffle(lst)
>>> [lst[i] for i in range(size)]
[6, 8, 2, 5, 1]

# E
>>> [random.choice(range(lo, hi)) for _ in range(size)]
[2, 1, 6, 9, 5]

Beispiel für zufällige Ganzzahlen

# F
>>> random.choices(range(lo, hi), k=size)
[3, 2, 0, 8, 2]

# G
>>> random.sample(range(lo, hi), k=size)
[4, 5, 1, 2, 3]

Einzelheiten

Einige Beiträge zeigen, wie mehrere zufällige Ganzzahlen nativ generiert werden . ¹ Hier sind einige Optionen, die die implizite Frage beantworten:

• A : random.randomGibt einen zufälligen Float im Bereich zurück[0.0, 1.0)
• B : random.randintGibt eine zufällige Ganzzahl zurück, Nso dassa <= N <= b
• C : random.randrangeAlias ​​zurandint(a, b+1)
• D : random.shufflemischt eine Sequenz an Ort und Stelle
• E :random.choice Gibt ein zufälliges Element aus der nicht leeren Sequenz zurück
• F : random.choicesRückkehr kAuswahlen aus einer Population (mit Ersatz, Python 3.6 oder höher)
• G : random.sampleGibt keindeutige Auswahlen aus einer Population zurück (ohne Ersatz): ²

Siehe auch R. Hettingers Vortrag über Chunking und Aliasing anhand von Beispielen aus dem randomModul.

Hier ist ein Vergleich einiger zufälliger Funktionen in der Standard Library und Numpy:

| | random                | numpy.random                     |
|-|-----------------------|----------------------------------|
|A| random()              | random()                         |
|B| randint(low, high)    | randint(low, high)               |
|C| randrange(low, high)  | randint(low, high)               |
|D| shuffle(seq)          | shuffle(seq)                     |
|E| choice(seq)           | choice(seq)                      |
|F| choices(seq, k)       | choice(seq, size)                |
|G| sample(seq, k)        | choice(seq, size, replace=False) |

Sie können auch schnell eine von vielen Verteilungen in Numpy in eine Stichprobe zufälliger Ganzzahlen konvertieren . ³

Beispiele

>>> np.random.normal(loc=5, scale=10, size=size).astype(int)
array([17, 10,  3,  1, 16])

>>> np.random.poisson(lam=1, size=size).astype(int)
array([1, 3, 0, 2, 0])

>>> np.random.lognormal(mean=0.0, sigma=1.0, size=size).astype(int)
array([1, 3, 1, 5, 1])

_{¹ Nämlich @ John Lawrence Aspden, @ ST Mohammed, @ SiddTheKid, @ user14372, @ zangw, et al. ² @prashanth erwähnt dieses Modul mit einer ganzen Zahl. ³ Demonstriert von @Siddharth Satpathy}

Wenn Sie numpy verwenden möchten, verwenden Sie Folgendes:

import numpy as np
print(np.random.randint(0,10))

>>> import random
>>> random.randrange(10)
3
>>> random.randrange(10)
1

So erhalten Sie eine Liste mit zehn Beispielen:

>>> [random.randrange(10) for x in range(10)]
[9, 0, 4, 0, 5, 7, 4, 3, 6, 8]

Zufällige Ganzzahlen zwischen 0 und 9 erzeugen.

import numpy
X = numpy.random.randint(0, 10, size=10)
print(X)

Ausgabe:

[4 8 0 4 9 6 9 9 0 7]

random.sample ist eine andere, die verwendet werden kann

import random
n = 1 # specify the no. of numbers
num = random.sample(range(10),  n)
num[0] # is the required number

Am besten verwenden Sie die Import-Zufallsfunktion

import random
print(random.sample(range(10), 10))

oder ohne Bibliotheksimport:

n={} 
for i in range(10):
    n[i]=i

for p in range(10):
    print(n.popitem()[1])

Hier entfernen die Popitems einen beliebigen Wert und geben ihn aus dem Wörterbuch zurück n.

Dies ist eher ein mathematischer Ansatz, funktioniert aber zu 100%:

Angenommen, Sie möchten die random.random()Funktion verwenden, um eine Zahl zwischen aund zu generieren b. Um dies zu erreichen, gehen Sie einfach wie folgt vor:

num = (b-a)*random.random() + a;

Natürlich können Sie mehr Zahlen generieren.

Von der Dokumentationsseite für das Zufallsmodul :

Warnung: Die Pseudozufallsgeneratoren dieses Moduls sollten nicht aus Sicherheitsgründen verwendet werden. Verwenden Sie os.urandom () oder SystemRandom, wenn Sie einen kryptografisch sicheren Pseudozufallszahlengenerator benötigen.

random.SystemRandom , das in Python 2.4 eingeführt wurde, gilt als kryptografisch sicher . Es ist weiterhin in Python 3.7.1 verfügbar, das zum Zeitpunkt des Schreibens aktuell ist.

>>> import string
>>> string.digits
'0123456789'
>>> import random
>>> random.SystemRandom().choice(string.digits)
'8'
>>> random.SystemRandom().choice(string.digits)
'1'
>>> random.SystemRandom().choice(string.digits)
'8'
>>> random.SystemRandom().choice(string.digits)
'5'

Statt string.digits, rangekönnte zusammen vielleicht mit einem Verständnis für einige der anderen Antworten verwendet werden. Mix and Match nach Ihren Bedürfnissen.

Mit OpenTURNS können Sie nicht nur die zufälligen Ganzzahlen simulieren, sondern auch die der UserDefineddefinierten Klasse zugeordnete Verteilung definieren.

Im Folgenden werden 12 Ergebnisse der Verteilung simuliert.

import openturns as ot
points = [[i] for i in range(10)]
distribution = ot.UserDefined(points) # By default, with equal weights.
for i in range(12):
    x = distribution.getRealization()
    print(i,x)

Dies druckt:

0 [8]
1 [7]
2 [4]
3 [7]
4 [3]
5 [3]
6 [2]
7 [9]
8 [0]
9 [5]
10 [9]
11 [6]

Die Klammern sind da , weil xeine ist Pointin 1-Dimension. Es wäre einfacher, die 12 Ergebnisse in einem einzigen Aufruf zu generieren getSample:

sample = distribution.getSample(12)

würde produzieren:

>>> print(sample)
     [ v0 ]
 0 : [ 3  ]
 1 : [ 9  ]
 2 : [ 6  ]
 3 : [ 3  ]
 4 : [ 2  ]
 5 : [ 6  ]
 6 : [ 9  ]
 7 : [ 5  ]
 8 : [ 9  ]
 9 : [ 5  ]
10 : [ 3  ]
11 : [ 2  ]

Weitere Details zu diesem Thema finden Sie hier: http://openturns.github.io/openturns/master/user_manual/_generated/openturns.UserDefined.html

Ich hatte besseres Glück damit für Python 3.6

str_Key = ""                                                                                                
str_RandomKey = ""                                                                                          
for int_I in range(128):                                                                                    
      str_Key = random.choice('0123456789')
      str_RandomKey = str_RandomKey + str_Key 

Fügen Sie einfach Zeichen wie 'ABCD' und 'abcd' oder '^! ~ = -> <' hinzu, um den zu ziehenden Zeichenpool zu ändern, und ändern Sie den Bereich, um die Anzahl der generierten Zeichen zu ändern.