Python Language
Module aléatoire

Syntaxe

• random.seed (a = None, version = 2) (la version est uniquement disponible pour python 3.x)
• random.getstate ()
• random.setstate (state)
• random.randint (a, b)
• random.randrange (stop)
• random.randrange (démarrer, arrêter, étape = 1)
• random.choice (seq)
• random.shuffle (x, random = random.random)
• random.sample (population, k)

Aléatoire et séquences: aléatoire, choix et échantillon

import random

mélanger ()

Vous pouvez utiliser random.shuffle() pour mélanger / randomiser les éléments dans une séquence mutable et indexable . Par exemple une list :

laughs = ["Hi", "Ho", "He"]

random.shuffle(laughs)     # Shuffles in-place! Don't do: laughs = random.shuffle(laughs)

print(laughs)
# Out: ["He", "Hi", "Ho"]  # Output may vary!

choix()

Prend un élément aléatoire d'une séquence arbitraire:

print(random.choice(laughs))
# Out: He                  # Output may vary!

échantillon()

Comme le choice il prend des éléments aléatoires d'une séquence arbitraire , mais vous pouvez spécifier combien:

#                   |--sequence--|--number--|
print(random.sample(    laughs   ,     1    ))  # Take one element
# Out: ['Ho']                    # Output may vary!

il ne faudra pas deux fois le même élément:

print(random.sample(laughs, 3))  # Take 3 random element from the sequence.
# Out: ['Ho', 'He', 'Hi']        # Output may vary!

print(random.sample(laughs, 4))  # Take 4 random element from the 3-item sequence.

ValueError: Échantillon plus grand que la population

Création d'entiers et de flottants aléatoires: randint, randrange, random et uniform

import random

randint ()

Retourne un entier aléatoire entre x et y (inclus):

random.randint(x, y)

Par exemple obtenir un nombre aléatoire entre 1 et 8 :

random.randint(1, 8) # Out: 8

randrange ()

random.randrange a la même syntaxe que range et contrairement à random.randint , la dernière valeur n'est pas inclusive:

random.randrange(100)       # Random integer between 0 and 99
random.randrange(20, 50)    # Random integer between 20 and 49
random.rangrange(10, 20, 3) # Random integer between 10 and 19 with step 3 (10, 13, 16 and 19)

au hasard

Renvoie un nombre aléatoire en virgule flottante compris entre 0 et 1:

random.random() # Out: 0.66486093215306317

uniforme

Renvoie un nombre aléatoire en virgule flottante compris entre x et y (inclus):

random.uniform(1, 8) # Out: 3.726062641730108

Nombres aléatoires reproductibles: Semences et état

Définir une graine spécifique créera une série de nombres aléatoires fixes:

random.seed(5)                 # Create a fixed state         
print(random.randrange(0, 10))  # Get a random integer between 0 and 9
# Out: 9
print(random.randrange(0, 10))
# Out: 4

Réinitialiser la graine créera à nouveau la même séquence "aléatoire":

random.seed(5)                 # Reset the random module to the same fixed state.
print(random.randrange(0, 10))
# Out: 9
print(random.randrange(0, 10))
# Out: 4

Comme la graine est fixée, ces résultats sont toujours 9 et 4 . Si des nombres spécifiques ne sont pas requis uniquement pour que les valeurs soient les mêmes, vous pouvez également utiliser getstate et setstate pour récupérer un état précédent:

save_state = random.getstate()  # Get the current state
print(random.randrange(0, 10))
# Out: 5
print(random.randrange(0, 10))
# Out: 8

random.setstate(save_state)     # Reset to saved state
print(random.randrange(0, 10))
# Out: 5
print(random.randrange(0, 10))
# Out: 8

Pour pseudo-randomiser la séquence à nouveau, vous seed avec None :

random.seed(None)

Ou appelez la méthode seed sans arguments:

random.seed()

Créer des nombres aléatoires sécurisés par cryptographie

Par défaut, le module aléatoire Python utilise le Mersenne Twister PRNG pour générer des nombres aléatoires qui, bien qu'adaptés à des domaines tels que les simulations, ne répondent pas aux exigences de sécurité dans des environnements plus exigeants.

Pour créer un nombre pseudo-aléatoire sécurisé sur le plan cryptographique, on peut utiliser SystemRandom qui, en utilisant os.urandom , peut agir en tant que générateur de nombres pseudo-aléatoires sécurisés par cryptographie, CPRNG .

La manière la plus simple de l'utiliser consiste simplement à initialiser la classe SystemRandom . Les méthodes fournies sont similaires à celles exportées par le module aléatoire.

from random import SystemRandom
secure_rand_gen = SystemRandom()

Pour créer une séquence aléatoire de 10 int s dans l'intervalle [0, 20] , on peut simplement appeler randrange() :

print([secure_rand_gen.randrange(10) for i in range(10)])
# [9, 6, 9, 2, 2, 3, 8, 0, 9, 9]

Pour créer un entier aléatoire dans une plage donnée, on peut utiliser randint :

print(secure_rand_gen.randint(0, 20))
# 5

et, en conséquence, pour toutes les autres méthodes. L'interface est exactement la même, le seul changement est le générateur de nombres sous-jacent.

Vous pouvez également utiliser os.urandom directement pour obtenir des octets aléatoires sécurisés par cryptographie.

Création d'un mot de passe utilisateur aléatoire

Afin de créer un mot de passe utilisateur aléatoire, nous pouvons utiliser les symboles fournis dans le module de string . Spécifiquement la punctuation pour les punctuation de ponctuation, les lettres ascii_letters pour les lettres et les digits pour les chiffres:

from string import punctuation, ascii_letters, digits

Nous pouvons alors combiner tous ces symboles dans un nom nommé symbols :

symbols = ascii_letters + digits + punctuation

Supprimez l'un de ces éléments pour créer un pool de symboles contenant moins d'éléments.

Après cela, nous pouvons utiliser random.SystemRandom pour générer un mot de passe. Pour un mot de passe de longueur 10:

secure_random = random.SystemRandom()
password = "".join(secure_random.choice(symbols) for i in range(10))
print(password)  # '^@g;J?]M6e'

Notez que les autres routines immédiatement disponibles par le module random - telles que random.choice , random.randint , etc. - ne conviennent pas à des fins de cryptographie.

Derrière les rideaux, ces routines utilisent le Mersenne Twister PRNG , qui ne répond pas aux exigences d'un CSPRNG . Ainsi, en particulier, vous ne devez en utiliser aucun pour générer des mots de passe que vous prévoyez d'utiliser. Utilisez toujours une instance de SystemRandom comme indiqué ci-dessus.

import string
alphabet = string.ascii_letters + string.digits
while True:
    password = ''.join(choice(alphabet) for i in range(10))
    if (any(c.islower() for c in password)
            and any(c.isupper() for c in password)
            and sum(c.isdigit() for c in password) >= 3):
        break

Décision binaire aléatoire

import random

probability = 0.3

if random.random() < probability:
    print("Decision with probability 0.3")
else:
    print("Decision with probability 0.7")