Generar enteros aleatorios entre 0 y 9

¿Cómo puedo generar enteros aleatorios entre 0 y 9 (inclusive) en Python?

Por ejemplo, 0, 1, 2, 3, 4, 5, 6, 7, 8,9

Tratar:

from random import randrange
print(randrange(10))

Más información: http://docs.python.org/library/random.html#random.randrange

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

random.randint(a, b)

Devuelve un entero aleatorio N tal que a <= N <= b.

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

Prueba esto:

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)]

Esto genera 10 enteros pseudoaleatorios en el rango de 0 a 9 inclusive.

El secretsmódulo es nuevo en Python 3.6. Esto es mejor que el randommódulo para criptografía o usos de seguridad.

Para imprimir aleatoriamente un número entero en el rango inclusivo 0-9:

from secrets import randbelow
print(randbelow(10))

Para más detalles, ver PEP 506 .

Elija el tamaño de la matriz (en este ejemplo, he elegido que el tamaño sea 20). Y luego, usa lo siguiente:

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

Puede esperar ver una salida de la siguiente forma ( se devolverán enteros aleatorios diferentes cada vez que lo ejecute; por lo tanto, puede esperar que los enteros en la matriz de salida difieran del ejemplo que se muestra a continuación ).

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

Prueba esto a través de random.shuffle

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

Intentaría uno de los siguientes:

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]

Velocidad:

► np.random.randint es el más rápido , seguido de np.random.uniform y random.randrange . random.randint es el más lento .

► Tanto np.random.randint como np.random.uniform son mucho más rápidos (~ 8 - 12 veces más rápidos) que random.randrange y 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)

Notas:

1.> np.random.randint genera enteros aleatorios durante el intervalo medio abierto [bajo, alto].

2.> np.random.uniform genera números distribuidos uniformemente en el intervalo medio abierto [bajo, alto].

3.> random.randrange (stop) genera un número aleatorio a partir del rango (inicio, parada, paso).

4.> random.randint (a, b) devuelve un entero aleatorio N tal que a <= N <= b.

5.> astype (int) convierte la matriz numpy en el tipo de datos int.

6.> He elegido size = (15,). Esto le dará una matriz numpy de longitud = 15.

En el caso de números continuos randinto randrangeson probablemente las mejores opciones, pero si tiene varios valores distintos en una secuencia (es decir, a list) también podría usar choice:

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

choice También funciona para un elemento de una muestra no continua:

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

Si lo necesita "criptográficamente fuerte" también hay un secrets.choicepython 3.6 y más reciente:

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

Mientras que muchos puestos demuestran cómo conseguir un número entero aleatorio, la pregunta original se pregunta cómo generar entero aleatorio s (plural):

¿Cómo puedo generar enteros aleatorios entre 0 y 9 (inclusive) en Python?

Para mayor claridad, aquí demostramos cómo obtener múltiples enteros aleatorios.

Dado

>>> import random


lo = 0
hi = 10
size = 5

Código

Múltiples enteros aleatorios

# 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]

Muestra de enteros aleatorios

# 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]

Detalles

Algunas publicaciones demuestran cómo generar nativamente múltiples enteros aleatorios. ¹ Aquí hay algunas opciones que abordan la pregunta implícita:

• A : random.randomdevuelve un flotante aleatorio en el rango[0.0, 1.0)
• B : random.randintdevuelve un entero aleatorio Ntal quea <= N <= b
• C : random.randrangealias arandint(a, b+1)
• D : random.shufflebaraja una secuencia en su lugar
• E : random.choicedevuelve un elemento aleatorio de la secuencia no vacía
• F : random.choicesdevuelve kselecciones de una población (con reemplazo, Python 3.6+)
• G : random.sampledevuelve kselecciones únicas de una población (sin reemplazo): ²

Vea también la charla de R. Hettinger sobre Chunking and Aliasing usando ejemplos del randommódulo.

Aquí hay una comparación de algunas funciones aleatorias en la Biblioteca estándar y 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) |

También puede convertir rápidamente una de las muchas distribuciones en Numpy en una muestra de enteros aleatorios. ³

Ejemplos

>>> 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])

_{¹ A saber, @John Lawrence Aspden, @ST Mohammed, @SiddTheKid, @ user14372, @zangw, et al. ² @prashanth menciona que este módulo muestra un número entero. ³ Demostrado por @Siddharth Satpathy}

si quieres usar numpy, usa lo siguiente:

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

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

Para obtener una lista de diez muestras:

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

Generando enteros aleatorios entre 0 y 9.

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

Salida:

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

random.sample es otro que se puede usar

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

La mejor manera es usar la función Importar al azar

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

o sin ninguna importación de biblioteca:

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

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

aquí los popitems eliminan y devuelven un valor arbitrario del diccionario n.

Este es más un enfoque matemático, pero funciona el 100% del tiempo:

Digamos que desea utilizar la random.random()función para generar un número entre ay b. Para lograr esto, solo haga lo siguiente:

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

Por supuesto, puedes generar más números.

Desde la página de documentación para el módulo aleatorio :

Advertencia: los generadores pseudoaleatorios de este módulo no deben utilizarse con fines de seguridad. Use os.urandom () o SystemRandom si necesita un generador de números pseudoaleatorio criptográficamente seguro.

random.SystemRandom , que se introdujo en Python 2.4, se considera criptográficamente seguro . Todavía está disponible en Python 3.7.1, que es actual en el momento de la escritura.

>>> 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'

En lugar de string.digits, rangepodría usarse según algunas de las otras respuestas, tal vez con una comprensión. Mezcla y combina de acuerdo a tus necesidades.

OpenTURNS permite no solo simular los enteros aleatorios sino también definir la distribución asociada con la UserDefinedclase definida.

Lo siguiente simula 12 resultados de la distribución.

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)

Esto imprime:

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

Los corchetes están ahí porque xes un Pointen 1 dimensión. Sería más fácil generar los 12 resultados en una sola llamada a getSample:

sample = distribution.getSample(12)

produciría:

>>> 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  ]

Más detalles sobre este tema están aquí: http://openturns.github.io/openturns/master/user_manual/_generated/openturns.UserDefined.html

Tuve mejor suerte con esto para Python 3.6

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

Simplemente agregue caracteres como 'ABCD' y 'abcd' o '^! ~ = -> <' para alterar el conjunto de caracteres para extraer, cambie el rango para alterar el número de caracteres generados.