Comment implémenter des valeurs aléatoires en Python

Introduction

La capacité à générer des valeurs aléatoires est une compétence de programmation importante. Même si vous n'en avez pas besoin tous les jours, des valeurs aléatoires apparaissent toujours à un nombre surprenant d'endroits. Bien sûr, pour de nombreuses personnes, lorsqu’elles pensent aux valeurs aléatoires, les premières choses qui viennent à l’esprit sont les cas d’utilisation liés aux jeux comme le mélange de cartes, le craps et les machines à sous.

Cependant, il existe de nombreuses autres utilisations des valeurs aléatoires. Ceux-ci incluent :

• Générer un mot de passe sécurisé ou une URL de réinitialisation de mot de passe.

• Créez des exemples de données pour des cas de test ou des démonstrations de code.

• Nettoyez les données d'informations personnelles identifiables (PII) pour préparer les données à l'analyse.

Comme beaucoup d'autres tâches de programmation importantes, le langage de programmation Python dispose d'un support bien conçu et cohérent pour générer des valeurs aléatoires dans le cadre de la bibliothèque standard Python. Certains modules associés incluent le module random, le module secrets et le module uuid. Le module secrets fournit des nombres aléatoires cryptographiquement forts, tandis que le module random fournit des nombres moins sécurisés, qui peuvent être utilisés pour des jeux, des données de test, des simulations, etc. Les différences entre ces deux types de valeurs aléatoires sont discutées ci-dessous. random模块、secrets 模块和uuid模块。secrets模块提供加密性强的随机数，而random模块提供安全性较差的数字，可用于游戏、测试数据、模拟等。下面将讨论这两种类型的随机值之间的差异。

随机值与伪随机值

“真”随机数和伪随机数之间的主要区别：伪随机数生成器使用一种算法生成看似随机但具有确定性的数字序列。事实上，它们是如此确定，给定相同的种子值（或起始值），它们将可靠地生成相同的数字序列！另一方面，随机数生成器依赖物理过程来创建真正随机的数字。

虽然伪随机数生成器适用于许多用途，但它们不适用于需要真正随机性的应用，如密码学。这是因为知道算法的人可以预测序列中的下一个数字。因此，真正的随机数生成器对于安全关键应用至关重要。

随机和加密

正如我们在上一节中所讨论的，如果我们正在编写游戏或模拟数据，random模块是很好的。然而，如果我们处理授权令牌或其他安全数据，我们需要secrets模块。

随机模块

这两个模块之间还有其他区别。random模块是这两个模块中较老的一个，自Python版本1以来一直存在。它有一个大型函数接口，本质上是一个类的共享实例random.Random的包装器。然而，你始终可以构造自己的随机类并使用它。random.Random可以用已知种子实例化随机类，以给出可复制的随机数序列。如果缺失，将使用基于系统计时器的种子值。

此示例显示了选择种子对random.Random类的影响：

"""Creating random integers demo"""
from random import Random, randint

seed = 42
seeded_1 = Random(seed)
seeded_2 = Random(seed)
randomly_seeded = Random()

# Get a random number between 1 and 1000, inclusive
print(seeded_1.randint(1, 1000))
print(seeded_2.randint(1, 1000))
print(randomly_seeded.randint(1, 1000))

# Use the functional interface
print(randint(1,1000))

655
655
161
956

随机类的两个实例使用相同的种子实例化，生成了前两行输入。每次运行程序时，这些行打印655。（试试看！）。

最后两行是使用随机种子实例和函数接口（也是随机种子）创建的。代码随每次运行而变化，在这两行的情况下，数字排列的任何运行都是完全重合的。

加密模块

乍一看，在PEP 506中首次描述并首次出现在Python 3.6中的secrets模块看起来与Python随机模块非常不同。许多函数接口包装器都已经消失，因此，例如，你不能直接导入randint。此外，还有secrets.SystemRandom类将忽略你可能传递给它的任何种子值。

然而，如果我们在这些表面差异的下面进行描述，这两个类非常相似，实际上，从源代码来看：

• secrets.SystemRandom类实际上是random.SystemRandom类的别名。

• random.SystemRandom是random.Random的子类。因此，一般来说，一个系统中可用的功能在另一个系统也可用。（两个例外是getstate和setstate，它们没有在SystemRandom中实现）。

内部最显著的区别是SystemRandom中的核心“随机化”行为是根据os.urandom实现的。反过来，urandom

Valeurs aléatoires et pseudo-aléatoires

La principale différence entre les "vrais" nombres aléatoires et les pseudo -nombres aléatoires La différence : un générateur de nombres pseudo-aléatoires utilise un algorithme pour générer une séquence de nombres apparemment aléatoire mais déterministe. En fait, ils sont si certains qu’avec la même valeur de départ (ou valeur de départ), ils généreront de manière fiable la même séquence de nombres ! Les générateurs de nombres aléatoires, quant à eux, s'appuient sur des processus physiques pour créer des nombres véritablement aléatoires. 🎜

Bien que les générateurs de nombres pseudo-aléatoires conviennent à de nombreuses fins, ils ne conviennent pas aux applications qui nécessitent un véritable caractère aléatoire, comme la cryptographie. En effet, quelqu'un qui connaît l'algorithme peut prédire le prochain numéro de la séquence. Par conséquent, les véritables générateurs de nombres aléatoires sont essentiels pour les applications critiques en matière de sécurité. 🎜

Aléatoire et crypté 🎜

Comme nous l'avons vu dans la section précédente, si nous écrivons un jeu ou simulons données, le module random est génial. Cependant, si nous traitons de jetons d'autorisation ou d'autres données sécurisées, nous avons besoin du module secrets. 🎜

Module aléatoire

Il existe d'autres différences entre ces deux modules. Le module random est le plus ancien des deux modules et existe depuis la version 1 de Python. Il possède une grande interface fonctionnelle qui est essentiellement un wrapper autour d'une instance partagée d'une classe random.Random. Cependant, vous pouvez toujours créer votre propre classe aléatoire et l’utiliser. random.RandomLa classe aléatoire peut être instanciée avec une graine connue pour donner une séquence reproductible de nombres aléatoires. En cas d'absence, une valeur de départ basée sur la minuterie du système sera utilisée. 🎜

Cet exemple montre l'effet du choix d'une graine sur la classe random.Random : 🎜

from secrets import SystemRandom
rand = SystemRandom()

# Integers betewen 1 and 5, inclusive
print(rand.randint(1,5))   

# Integers between 1 and 5, but not including 5
print(rand.randrange(1,5))

"""IQ distribution"""
from secrets import SystemRandom
rand = SystemRandom()
population = [round(rand.gauss(100, 15)) for _ in range(0,20)]
print(population)

Classe aléatoire Deux instances de sont instanciées en utilisant la même graine, générant les deux premières lignes d'entrée. Chaque fois que j'exécute le programme, ces lignes s'impriment 655. (Essayez-le !). 🎜

Les deux dernières lignes sont créées à l'aide d'une instance de graine aléatoire et d'une interface de fonction (également une graine aléatoire). Le code change à chaque exécution, et dans le cas de ces deux lignes, toute exécution de l'arrangement numérique coïncide complètement. 🎜

Module Crypto

Décrit pour la première fois dans PEP 506 et vu pour la première fois dans Le module secrets en Python 3.6 est très différent du module aléatoire Python. De nombreux wrappers d'interface fonctionnels ont disparu, donc, par exemple, vous ne pouvez pas importer directement randint. De plus, il existe la classe secrets.SystemRandom qui ignorera toute valeur de départ que vous pourriez lui transmettre. 🎜

Cependant, si l'on décrit ci-dessous ces différences superficielles, les deux classes sont très similaires, en fait, en regardant le code source : 🎜

🎜🎜 La classe secrets.SystemRandom est en fait un alias de la classe random.SystemRandom. 🎜🎜🎜🎜random.SystemRandom est une sous-classe de random.Random. Par conséquent, d’une manière générale, les fonctionnalités disponibles dans un système sont également disponibles dans un autre système. (Deux exceptions sont getstate et setstate, qui ne sont pas implémentées dans SystemRandom). 🎜🎜🎜

La différence interne la plus significative est que le comportement de "randomisation" de base dans SystemRandom est implémenté sur la base de os.urandom. À son tour, la fonction urandom reçoit un entier et renvoie un nombre d'octets aléatoires à l'aide d'un générateur de valeurs aléatoires cryptographiquement fortes, dépendant de la plate-forme. 🎜

我们现在知道我们可以使用这两个类中的任何一个，它们基本上是可互换的，但secrets.SystemRandom将更真实地随机，因此在更安全的环境中使用。

考虑到这一点，接下来让我们看一些用例。

生成随机数

Randint和Randrange

我们已经了解了如何使用randint在特定范围内生成随机数。randrange函数非常相似，只是它不包括上限，而randint的上限是包含的。如果你足够频繁地运行这段代码，第一行输出会出现5，但第二行不会。

from secrets import SystemRandom
rand = SystemRandom()

# Integers betewen 1 and 5, inclusive
print(rand.randint(1,5))   

# Integers between 1 and 5, but not including 5
print(rand.randrange(1,5))

生成随机分布

Random和SystemRandom共享了几种方法，允许你根据各种分布生成随机值。这些包括均匀分布（获得两个端点之间的浮点值，类似于randint提供的）、高斯（正态）分布等。

例如，我们可以创建一个包含20个虚拟IQ值的列表，这些值沿着与真实人群相同的正态曲线随机分布。根据定义，智商的平均值为100，标准差为15。（顺便说一句，为了本示例的目的，我们希望对这种分布建模，即使我们忽略了对这个想法和我们如何测试它提出的合理批评。）

以下是随机创建 20 个 IQ 的“群体”的代码：

"""IQ distribution"""
from secrets import SystemRandom
rand = SystemRandom()
population = [round(rand.gauss(100, 15)) for _ in range(0,20)]
print(population)

当然，输出会有所不同。这是一个有代表性的运行：

[102, 90, 88, 82, 102, 93, 127, 121, 94, 107, 103, 80, 106, 106, 84, 107, 108, 88, 123, 121]

在Python中进行随机选择

在其他语言中，从列表或其他序列中进行选择通常需要两个步骤。首先，你得到一个从0到列表上界（长度减1）的随机数。然后将该索引应用于列表以选择元素。在Python中，choice和chchoicesices这两种方法使你能够同时执行这两个步骤。这使得从任何类型的序列中选择所需大小的随机样本非常容易。

例如，给定上面的代码，假设我们想要获取IQ的总体，并从中选择一个或多个值。下面是我们可以快速完成的方法：

# Select one IQ at random
print(rand.choice(population))

# Select four IQs at random
print(rand.choices(population, k=4))

输出（示例）：

102
[107,102,88,103]

如何使用 Python 生成随机字符串

因为在Python中使用随机方法很容易从序列中选择随机选项。通过Random.choice或者Random.choices函数，在Python中创建随机字符串也很简单。此外，secrets模块定义了一些特殊的函数，根据你的需要，也可以使用这些函数。

让我们首先看看一种通用方法，你可以使用它生成多种类型的字符串。字符串模块包括几个基本上是硬编码字符序列的字符串，例如ascii_lowercase(a-z)、ascii_uppercase(A-Z)、ascii_letters、punctuation和digits。Random.choices或者SystemRandom.choices可以调用其中任何一个来创建所需长度的数组，然后可以使用str类的join方法将数组转换为新字符串。

我们在以下示例中结合了这些步骤：

from string import ascii_letters, digits, punctuation, ascii_lowercase, ascii_uppercase
from secrets import SystemRandom
rand = SystemRandom()

four_digits = "".join(rand.choices(digits, k=4))
ten_mixed_case = "".join(rand.choices(ascii_letters, k=10))
assorted = ascii_letters + punctuation
twenty_assorted = "".join(rand.choices(assorted, k=20))

print(four_digits)
print(ten_mixed_case)
print(twenty_assorted)

代码输出：

8782
PLZYOxFLoQ
!mNsKsF;([I#F(c<jcg><h3 id="h20" data-id="h590b8bf-SL4CIZsY">使用Secrets模块加密随机字符串</h3>
<p data-id="p838747a-IPEgWEdV">除了如上所示轻松创建随机字符串外，secrets模块还提供了几个函数，可用于生成各种格式的随机字节序列。在最低级别，我们可以使用<code>token_bytes</code>函数生成各种长度的原始“字节”数组。</p>
<pre class="brush:php;toolbar:false">from secrets import token_bytes
b = token_bytes(10)
print(type(b))
print(b)

代码输出：

<class>
b'!\x05P\xc6a\x87\xf9~(\xa9'</class>

原始字节作为加密算法或类似算法的输入可能很有用，但请记住，它们不会包含有效的UTF-8代码点，因此不应使用此函数生成字符串。要获取字符串，可以使用上一节中的技术或下面两个函数中的一个。

我们可以返回一个字符串，它不是以原始格式获取字节，而是以十六进制格式再次由随机字节组成。这为每个字节提供了两个十六进制输出字符：

from secrets import token_hex
token = token_hex(10)
print(f"Returned a {type(token)} of length: {len(token)}:")
print(token)

代码输出：

Returned a <class> of length: 20:</class>

同一系列中的第三个功能——在某些方面可能是最有用的——是token_urlsafe。此函数允许我们将随机字节字符串转换为稍微修改的base64编码字符串。在这里，每个字节平均产生1.3个字符，结果可以安全地用作URL-例如，表示缩短的URL或用作密码重置令牌。另一个好处是字符串来自比16位token_hex更大的潜在随机字符集。

from secrets import token_urlsafe
token = token_urlsafe(15)
print(token)

代码输出：

gfN2nGjO7izMPyXs5tvU

使用UUID：在Python中生成随机且唯一的值

虽然我们在本文中的重点是随机值，但我们现在想花一些时间讨论对于所有实际目的来说都是随机和唯一的值。解决这个问题的一种非常普遍的方法是通用唯一标识符（UUID）的概念。UUID是一个128位的数字，不能100%保证是唯一的，但在统计上很可能是唯一的，以至于发生冲突的机会非常小。

除了大数字之外，UUID还共享一种通用的表示格式。128位的数字可以表示为32个十六进制数字，而UUID添加四个连字符以形成一个36个字符的字符串，以8-4-4-6-12的模式排列。例如：

'967909e3-7231-4040-aae4-8b6b2fb96a0b'

Python模块uuid有几个不同的函数，对应于许多公认的算法，用于创建此类标识符，但建议使用两种最常见的类型之一，uuid1和uuid4。

uuid1值是通过将网络节点id（通常意味着网卡的mac地址）与有关UUID版本和变体的少量信息以及表示高分辨率时间戳的许多位相结合来创建的。

相反，uuid4值通常包含用于存储版本和变体信息的6位，以及122位纯随机数据。因此，根据维基百科，尽管原则上可能存在两个uuid4值的冲突，但在实践中，“在103万亿个版本4 UUIDs中找到重复的概率是十亿分之一。”。

你可以使用Python uuid模块轻松创建uuid1和uuid4值。正如我们将看到的，字符串表示看起来是相同的，尽管描述uuid1字段中的位更有意义。

from uuid import uuid1, uuid4

print(uuid1())
print(uuid4())

代码输出：

bfc89f3e-e6ab-11ec-abfc-4a9b744d17b8
025586c2-50ed-41a6-ae31-bf96b9d79df2

与本文中的大多数内容一样，当我们说“示例输出”时，实际上只是他代码运行其中一次的结果。当然，至少在uuid4的情况下，如果你运行这段代码103万亿次，你有十亿分之一的机会得到与我相同的结果。

在结束对UUID的讨论之前，我们在这里提到它们，因为它们是一个被广泛接受的标准，但正如我们所看到的，uuid4的实现与系统模块中的许多实用函数之间有很多重叠。例如，我经常看到uuid4函数用于在数据库中生成主键，特别是在NoSQL上下文中，其中可能不支持自动递增字段。原则上，人们也可以使用secrets.token_hex用于同样的任务，但uuid4可能会使代码的意图更加清晰。

附上产生随机数分布的图以及代码实现：

import random
import matplotlib.pyplot as plt

x = [random.randint(1, 100) for n in range(100)]
y = [random.randint(1, 100) for n in range(100)]
plt.figure(figsize=(8,6), dpi=80)
plt.scatter(x, y)
plt.show()

结果：

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!