Maîtriser Python en 100 jours (Les bases) - Jour 30 : Bibliothèque standard aléatoire

avant-propos

• À propos de l' auteur : créateurs et ingénieurs de développement de données de grande qualité dans le domaine de Python
• Inspirant de devenir un ingénieur Python full-stack, suivez-moi pour trouver plus excitant ~
• Cet article a été inclus dans la série Python full stack : 100 jours pour maîtriser Python de l'entrée à l'emploi
• Bienvenue pour vous abonner, après vous être abonné à la colonne, vous pouvez discuter en privé dans le groupe de communication Python full-stack de 100 personnes (enseignement main à main, réponse aux questions); vous pouvez également recevoir 80GPython full-stack tutorial + 300 livres informatiques : bases, web, crawler, analyse de données, visualisation, machine learning, deep learning, intelligence artificielle, algorithmes, questions d'entretien, etc.
• Rejoignez-moi pour apprendre et progresser ensemble, une personne peut aller vite, un groupe de personnes peut aller plus loin !

---

1. Introduction à la bibliothèque aléatoire

伪随机数Le module random implémente des générateurs pour diverses distributions . Pourquoi est-il appelé nombre pseudo-aléatoire : c'est-à-dire que les humains utilisent des algorithmes et d'autres méthodes pour construire une série de nombres basés sur une référence (également appelée graine, la plus couramment utilisée est un horodatage), et les caractéristiques de ces nombres sont conformes à ce que les gens comprennent comme des nombres aléatoires. Cependant, comme il est obtenu via un algorithme, une fois que l'algorithme et la graine sont déterminés, la séquence de nombres aléatoires générés est également déterminée, on l'appelle donc un nombre pseudo-aléatoire.

import random

2. Fonctions communes

random.seed(a)

Définir la graine aléatoire initiale, qui peut produire la même séquence de nombres aléatoires ; a est un entier ou un nombre à virgule flottante, s'il n'est pas défini, l'heure système est utilisée comme graine par défaut

import random

print("没有设定种子时")
for i in range(5):
    ret = random.randint(1, 10)
    print(ret, end=" ")
print()

print("设定种子时")
random.seed(1)
for i in range(5):
    ret = random.randint(1, 10)
    print(ret, end=" ")

Résultat de sortie :

comme le montre la figure ci-dessus : lorsque la graine n'est pas explicitement définie, la sortie de nombre aléatoire à chaque fois est différente ; lorsque la graine est explicitement définie, la sortie de nombre aléatoire à chaque fois est la même

random.random()

Utilisé pour générer un nombre à virgule flottante aléatoire de 0,0 à 1,0

>>> import random
>>> random.random()
0.9279749775408933
>>> random.random()
0.12720379394341363
>>> random.random()
0.9391670189485866

aléatoire.uniforme(a,b)

Générer un [a,b]nombre décimal aléatoire entre a et b ; entier ou flottant

>>> import random
>>> random.uniform(10.0, 20.0)
10.839441969258752
>>> random.uniform(10.0, 20.0)
12.233491150445115
>>> random.uniform(10, 20)
11.290566243261305

random.randint(a,b)

générer un [a,b]entier aléatoire entre

>>> import random
>>> random.randint(10,100)
100
>>> random.randint(10,100)
83
>>> random.randint(10,100)
66

random.randrange (démarrer, arrêter, [pas])

Génère un [start,stop)entier aléatoire avec step comme nombre de pas ; start, stop, step sont des entiers et la valeur par défaut est 1 lorsque step n'est pas défini

Générez aléatoirement des entiers de 1 à 100 :

>>> import random
>>> random.randrange(1,100)
54
>>> random.randrange(1,100)
21
>>> random.randrange(1,100)
71

Générez aléatoirement des nombres impairs de 1 à 100 :

>>> import random
>>> random.randrange(1,100,2)
37
>>> random.randrange(1,100,2)
63
>>> random.randrange(1,100,2)
29

Générez aléatoirement des nombres pairs de 1 à 100 :

>>> import random
>>> random.randrange(2,100,2)
62
>>> random.randrange(2,100,2)
6
>>> random.randrange(2,100,2)
46

random.getrandbits(k)

Génère un 占内存k位entier aléatoire à l'intérieur de un ; k prend une valeur entière de longueur

>>> import random
>>> random.getrandbits(10)
29
>>> random.getrandbits(10)
540
>>> random.getrandbits(10)
227

choix aléatoire (suite)

Renvoie un élément au hasard à partir du type de séquence seq ; seq prend le type de séquence : tel que chaîne, liste, tuple

>>> import random
>>> list = ['a', 'b', 'c', 'd', 'f', 'g']
>>> random.choice(list)
'b'
>>> random.choice(list)
'f'
>>> random.choice(list)
'g'

random.shuffle(seq)

Trier aléatoirement les éléments dans le type de séquence, renvoyer la séquence brouillée, seq est modifié ( 改变原列表), shuffle signifie shuffle ; seq prend le type de séquence : tel que chaîne, liste, tuple

>>> import random
>>> list = ['a', 'b', 'c', 'd', 'f', 'g']
>>> random.shuffle(list)
>>> list
['c', 'a', 'f', 'd', 'g', 'b']
>>> random.shuffle(list)
>>> list
['f', 'a', 'b', 'c', 'g', 'd']
>>> random.shuffle(list)
>>> list
['a', 'd', 'g', 'c', 'b', 'f']

échantillon aléatoire (pop, k)

Sélectionnez k éléments de pop et renvoyez-le sous la forme d'un type de liste (不改变原列表 ); pop est un type de séquence et k est un entier : il représente le nombre d'éléments sélectionnés

>>> import random
>>> list = ['a', 'b', 'c', 'd', 'f', 'g']
>>> random.sample(list, 4)
['b', 'f', 'c', 'a']
>>> random.sample(list, 4)
['g', 'f', 'b', 'd']
>>> random.sample(list, 4)
['g', 'f', 'c', 'b']

3. Fonctions inhabituelles

random.getstate()

Un objet qui capture et renvoie l'état interne actuel du générateur, qui peut être passé à la fonction setstate() pour restaurer l'état interne du générateur à l'état dans lequel il se trouvait avant l'appel de la fonction getstate(). Équivalent à la sauvegarde.

random.setstate(état)

state doit être le résultat de la fonction getstate(), qui est utilisée pour restaurer l'état interne actuel du générateur à state.

random.betavariate(alpha, beta)

Distribution bêta : les paramètres sont conditionnés sur alpha > 0 et bêta > 0, et la valeur renvoyée est comprise entre 0 et 1.

random.expovariate(lambd)

répartition de l'indice

random.gammavariate(alpha, beta)

Distribution gamma : les paramètres sont conditionnels à alpha > 0 et beta > 0

random.gauss(mu, sigma)

Distribution gaussienne : mu est la moyenne et sigma est l'écart type.

random.normalvariate(mu, sigma)

Distribution normale : mu est la moyenne et sigma est l'écart type.

random.paretovariate(alpha)

Distribution de Pareto : alpha est le paramètre de forme.

random.weibullvariate(alpha,beta)

Distribution de Weibull : alpha est le paramètre d'échelle et bêta est le paramètre de forme.

4. Cas réels

chaîne de mot de passe aléatoire

La chaîne comprend des chiffres et des lettres, et le nombre de chiffres dans le mot de passe peut être spécifié

import random
import string


def get_random_string(length):
    # 随机生成字母和数字的位数
    num_count = random.randint(1, length - 1)
    letter_count = length - num_count

    # 随机抽样生成数字序列
    num_list = [random.choice(string.digits) for _ in range(num_count)]

    # 随机抽样生成字母序列
    letter_list = [random.choice(string.ascii_letters) for _ in range(letter_count)]

    # 合并字母和数字
    all_list = num_list + letter_list

    # 乱序
    random.shuffle(all_list)

    result = "".join([i for i in all_list])
    return result


# 生成10位的密码
password1 = get_random_string(10)
print(password1)
# 生成15位的密码
password2 = get_random_string(15)
print(password2)
# 生成20位的密码
password3 = get_random_string(20)
print(password3)

Résultat de sortie :

41eD76F3e1
915087432k8443z
002L5292840A07284755

Calculer pi

1) Formule approximative pour calculer pi :

pi = 0
N = 100
for k in range(N):
    pi += 1 / pow(16, k) * (4 / (8 * k + 1) - 2 / (8 * k + 4) - 1 / (8 * k + 5) - 1 / (8 * k + 6))
print("圆周率值是：%s" % pi)

Résultat de sortie :

圆周率值是: 3.141592653589793

2) Algorithme de Monte Carlo :

import random

DARTS = 1000 * 1000 * 10
hits = 0.0

for i in range(1, DARTS + 1):
    x, y = random.random(), random.random()
    dist = pow(x ** 2 + y ** 2, 0.5)
    if dist <= 1.0:
        hits = hits + 1
pi = 4 * (hits / DARTS)
print("圆周率值是：%s" % pi)

Résultat de sortie :

圆周率值是：3.14205