代码收藏家 【python】标准库之random模块
目录
一、介绍random模块
1.1、random模块简介
二、random模块的基本功能
2.1、整数用函数
2.1.1、random.randrange()
2.1.2、random.randint()
2.1.3、random.getrandbits()
2.2、序列用函数
2.2.1、random.choice()
2.2.2、random.choices()
2.2.3、random.shuffle()
2.2.4、random.sample()
2.3、离散分布
2.3.1、random.binomialvariate()
2.4、实值分布
2.4.1、random.random()
2.4.2、random.uniform(a, b)
2.4.2.1、保留小数点后n位的方法
2.4.2.1.1、使用round()函数
2.4.2.1.2、使用format()函数
2.4.2.1.3、使用decimal模块进行精确控制
2.4.2.1.4、使用f-string（Python 3.6+）
三、与random相关的模块
3.1、secrets模块
3.1.1、secrets.choice()
3.1.2、secrets.randbelow()
3.1.3、secrets.randbits()
3.1.4、secrets.token_bytes()
3.1.5、secrets.token_hex()
3.1.6、secrets.token_urlsafe()
3.1.7、secrets.compare_digest()
一、介绍random模块
1.1、random模块简介
random模块是Python标准库中用于生成伪随机数的模块，伪随机数是通过算法生成的数列，在一定范围内表现出随机性，虽然这些数列在一定程度上是可预测的，但对于大多数应用来说已经足够。
二、random模块的基本功能
2.1、整数用函数
2.1.1、random.randrange()
random.randrange(start, stop[, step])
返回从 range(start, stop, step) 随机选择的一个元素。
支持设置步长，可以生成按固定间隔的随机数，这对于需要特定模式或间隔的随机数生成非常有用。注意：不包括右边界
# 返回 0 <= N < 100 范围内的随机整数
print(random.randrange(100))
# 返回 100 <= N < 200 范围内的随机整数
print(random.randrange(100, 200))
# 返回 100 <= N < 200 范围内的随机整数，步长为5
print(random.randrange(100, 200, 5))2.1.2、random.randint()
random.randint(a, b)
返回随机整数 N 满足 a <= N <= b。相当于 randrange(a, b+1)。
不支持设置步长，只能生成指定范围内的任意整数。注意：包括左边界和右边界
# 返回 100 <= N <= 200 范围内的随机整数
print(random.randint(100, 200))2.1.3、random.getrandbits()
random.getrandbits(k)
返回随机整数 N 满足 0 <= N <= 2^k-1，例如，getrandbits(16)将生成一个0到65535之间的随机整数。这个函数特别适用于需要生成大范围随机数的情况。
# 返回 0 <= N <= 65535（2的16次方再减去1） 范围内的随机整数
print(random.getrandbits(16))2.2、序列用函数
2.2.1、random.choice()
random.choice(seq)
从非空序列 seq 返回一个随机元素。 如果 seq 为空，则引发 IndexError。
a = ['alice', 'bob', 'helen', 'jack', 'sue']
b = ('alice', 'bob', 'helen', 'jack', 'sue')
c = {'alice', 'bob', 'helen', 'jack', 'sue'}
d = {'alice': 16, 'bob': 18, 'helen': 19, 'jack': 20, 'sue': 22}
e = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# 从列表中随机选取一个元素
print(random.choice(a))
# 从元组中随机选取一个元素
print(random.choice(b))
# 不支持从集合中随机选取，会报错
# print(random.choice(c))
# 不支持从字典中随机选取，会报错，但可以使用 random.choice(list(d.items())) 的方法来实现
# print(random.choice(d))
# 从字符串中随机选取一个元素
print(random.choice(e))2.2.2、random.choices()
random.choices(population, weights=None, *, cum_weights=None, k=1)
population：必需参数，指定要进行选择的序列（可以是列表、元组、字符串等）。 weights：可选参数，指定每个元素的权重（概率）。如果不指定，则默认每个元素的权重相等。 cum_weights：可选参数，指定累计权重。如果指定了cum_weights，则必需省略weights参数。 k：可选参数，指定要选择的元素个数。默认为1，即只选择一个元素。 从序列中有放回地随机抽取k个元素，并返回对应的数组，weights参数代表每个元素被选到的相对权重，而cum_weights代表的是累积权重，它们的长度需和待抽取序列population长度一致。若无设置权重，则每个元素被抽到的权重是一样的。
注意：权重不能为负值，否则会报错。
import random
fruits = ['apple', 'banana', 'orange', 'grape', 'watermelon']
weights = [0.1, 0.2, 0.3, 0.2, 0.2]
cum_weights = [0.1, 0.4, 0.7, 0.9, 1.0]
# 从列表中随机选择一个元素
chosen_fruit = random.choices(fruits)
# 选择多个元素
chosen_fruits = random.choices(fruits, k=3)
# 按照概率从列表中随机选择一个元素
chosen_fruit = random.choices(fruits, weights=weights)
# 利用cum_weights参数选择元素
chosen_fruit = random.choices(fruits, cum_weights=cum_weights)选择多个元素并计算选择的次数
import random
fruits = ['apple', 'banana', 'orange', 'grape', 'watermelon']
chosen_fruits = random.choices(fruits, k=1000)
fruit_counts = {}
for fruit in chosen_fruits:
if fruit in fruit_counts:
fruit_counts[fruit] += 1
else:
fruit_counts[fruit] = 1
print(fruit_counts)
2.2.3、random.shuffle()
random.shuffle(x)
就地将序列 x 随机打乱位置。
import random
fruits = ['apple', 'banana', 'orange', 'grape', 'watermelon']
random.shuffle(fruits) # 注意：改变的是原列表
print(fruits) # ['orange', 'watermelon', 'grape', 'banana', 'apple']2.2.4、random.sample()
random.sample(population, k, *, counts=None)
从序列中无放回地随机抽取k个元素。用于无重复的随机抽样。
import random
fruits = ['apple', 'banana', 'orange', 'grape', 'watermelon']
# 返回一个新的随机打乱序列, 注意：原列表是没有改变的
print(random.sample(fruits,len(fruits))) # ['orange', 'watermelon', 'apple', 'banana', 'grape']
print(fruits) # ['apple', 'banana', 'orange', 'grape', 'watermelon']重复的元素可以一个个地直接列出，或使用可选的仅限关键字形参 counts 来指定。 例如，sample(['red', 'blue'], counts=[4, 2], k=5) 等价于 sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)。
要从一系列整数中选择样本，请使用 range() 对象作为参数。 对于从大量人群中采样，这种方法特别快速且节省空间：sample(range(10000000), k=60) 。
2.3、离散分布
2.3.1、random.binomialvariate()
random.binomialvariate(n=1, p=0.5)
二项式分布。 返回 n 次独立试验在每次试验的成功率为 p 时的成功次数
2.4、实值分布
2.4.1、random.random()
random.random()
返回 0.0 <= X < 1.0 范围内的随机浮点数
2.4.2、random.uniform(a, b)
random.uniform(a, b)
返回一个随机浮点数 N ，当 a <= b 时 a <= N <= b ，当 b < a 时 b <= N <= a 。
import random
print(random.uniform(60, 100))2.4.2.1、保留小数点后n位的方法
2.4.2.1.1、使用round()函数
num = 3.14159
# 这种方式是进行的四舍五入
rounded_num = round(num, 2) # 输出: 3.142.4.2.1.2、使用format()函数
num = 3.14159
# 这种方式是进行的四舍五入，注意：得到的是字符串形式的浮点数
formatted_num = "{:.2f}".format(num) # 输出: '3.14'2.4.2.1.3、使用decimal模块进行精确控制
from decimal import Decimal, ROUND_HALF_UP
num = Decimal('3.14159')
context = Decimal(1) / Decimal(10) ** 2
# 这种方式是进行的四舍五入
rounded_num = num.quantize(context, rounding=ROUND_HALF_UP) # 输出: Decimal('3.14')2.4.2.1.4、使用f-string（Python 3.6+）
num = 3.14159
formatted_num = f"{num:.2f}" # 输出: '3.14'三、与random相关的模块
3.1、secrets模块
secrets 模块用于生成高度加密的随机数，适于管理密码、账户验证、安全凭据及机密数据。
3.1.1、secrets.choice()
secrets.choice(seq)
返回一个从非空序列中随机选取的元素。
import secrets
# 假设我们有一个元素列表
fruits = ['apple', 'banana', 'orange', 'grape', 'watermelon']
# 使用 secrets.choice 来安全地选择列表中的一个随机元素
secure_random_element = secrets.choice(fruits)
print(secure_random_element)3.1.2、secrets.randbelow()
secrets.randbelow(exclusive_upper_bound)
返回 [0, exclusive_upper_bound) 范围内的随机整数。
import secrets
# 生成一个安全的随机整数，范围在 0 <= N < 10之间
secure_int = secrets.randbelow(10)
print(f"安全随机整数：{secure_int}")3.1.3、secrets.randbits()
secrets.randbits(k)
返回一个具有k个随机位的非负整数。如 secrets.randbits(3)，表示取值为 0 <= N < 2^3，也就是 [0, 8) 之间的随机整数。
3.1.4、secrets.token_bytes()
secrets.token_bytes([nbytes=None])
如果指定了 nbytes， secrets.token_bytes(nbytes) 会返回一个包含 nbytes 个随机字节的 bytes 对象。 如果未提供 nbytes 参数，它会返回一个合适用于安全令牌的默认长度的随机字节序列（通常为 32 个字节）。
import secrets
# 生成默认长度（通常为32个字节）的随机字节序列
random_token = secrets.token_bytes()
print(len(random_token)) # 输出：32
print(random_token) # 输出随机字节序列：b'<\xa1\xc2\xb9k\xf4\x9e$\xd9\x03\xd5H\xb8\x1e\xe2d\xe0\x82x\xe9)\x11\xe9\x04l\xda\x95\xe3\xf0C\x88\xba'
# 生成指定长度的随机字节序列
specified_length_token = secrets.token_bytes(16)
print(specified_length_token) # 输出随机字节序列：b'\xa2C\x98H\xb2\xca5\n\xb69h{\xfa\xb3n\xc5'3.1.5、secrets.token_hex()
secrets.token_hex([nbytes=None])
如果提供了 nbytes 参数，则会生成长度为 nbytes*2 的十六进制字符串（每个字节转换为两个十六进制字符）。 如果未提供 nbytes 参数，则会生成一个适用于安全令牌的默认长度的十六进制字符串（通常是 32 个字符）。
import secrets
# 生成默认长度（通常为32个字符）的随机十六进制字符串
random_hex_token = secrets.token_hex()
print(random_hex_token) # 53063bd5d38f7f032e146d769567254748dcbc34de37f716043a21d4b9ef0575
# 生成指定长度的随机十六进制字符串
specified_length_hex_token = secrets.token_hex(16)
print(specified_length_hex_token) # bcce543dee60747639895e2fcffcfaf83.1.6、secrets.token_urlsafe()
secrets.token_urlsafe([nbytes=None])
返回安全的 URL 随机文本字符串，包含 nbytes 个随机字节。文本用 Base64 编码，平均来说，每个字节对应 1.3 个结果字符。 未提供 nbytes 或为 None 时，它会生成一个适合于安全令牌的默认长度随机 URL 安全字符串。 这个函数生成的返回值是一个只包含 URL 安全字符（字母、数字、下划线和短横线）的字符串。
import secrets
# 生成默认长度的随机 URL 安全字符串
random_urlsafe_token = secrets.token_urlsafe()
print(len(random_urlsafe_token)) # 输出：43
print(random_urlsafe_token) # 输出：t6GrND8P32pL763R36VQIaB70jf8r_uruvSa0wgQYrY
# 生成指定长度的随机 URL 安全字符串
specified_length_urlsafe_token = secrets.token_urlsafe(16)
print(specified_length_urlsafe_token) # 输出：dUA2mPJbbWtB6rLj8hoC1g3.1.7、secrets.compare_digest()
secrets.compare_digest(a, b)
用于比较两个字符串 a 和 b，并且在字符串匹配时具有防止时间侧信道攻击的特性。在密码学和安全相关的场景中，比较两个敏感字符串时，使用 secrets.compare_digest 要优于简单的 == 操作符。 该函数返回一个布尔值，如果 a 和 b 匹配，返回 True，否则返回 False。这种比较在比较时间上更加均匀，不易受到时间侧信道攻击的影响。在比较敏感数据时，尤其是在密码验证或令牌比对时使用这个函数，可以提高系统的安全性。
生成系统密码示例
import string
import random
import secrets
def generate_password(min_length, max_repeat, max_class_repeat, *char_credits):
characters = [string.digits, string.ascii_uppercase, '!@#$%^&*(){}<>,?`~+-=[]', string.ascii_lowercase]
all_characters = ''.join(characters)
while True:
# 生成每个字符类别的字符
password = [secrets.choice(char) for char, count in zip(characters, char_credits) for _ in range(count)]
# 添加字符以满足最小密码长度要求
remaining_len = min_length - sum(char_credits)
password += [secrets.choice(all_characters) for _ in range(remaining_len)]
random.shuffle(password)
if is_valid_password(min_length, password, characters, max_repeat, max_class_repeat):
return ''.join(password)
def is_valid_password(min_length, password, characters, max_repeat, max_class_repeat):
# 判断是否以=开头
if ''.join(password).startswith("="):
return False
# 检查字符和类别是否连续重复超过了规定次数
repeat_count = max(password.count(char) for char in set(password))
if repeat_count > min_length // 4:
return False
for char_class in characters:
char_class_positions = [idx for idx, char in enumerate(password) if char in char_class]
for idx in char_class_positions:
if idx < len(password) - max_class_repeat:
if all(password[idx + i] in char_class for i in range(0, max_class_repeat + 1)):
return False
# 判定同一个字符的索引
char_repeat = [char for char in set(password) if password.count(char) > max_repeat]
char_repeat_positions = {}
for idx, char in enumerate(password):
if char in char_repeat:
if char not in char_repeat_positions:
char_repeat_positions[char] = [idx]
else:
char_repeat_positions[char].append(idx)
# 判定相同字符是否连续
for _, index in char_repeat_positions.items():
for idx in index:
if idx < len(password) - max_repeat:
if all(password[idx + i] == password[idx] for i in range(0, max_repeat + 1)):
return False
return True
if __name__ == '__main__':
# 设置密码生成的参数
min_length = 16
char_credits = (3, 3, 3, 3) # 数字、大写字母、特殊字符、小写字母
# 同一个字符不能连续重复的数量
max_repeat = 2
# 同一类字符不能连续重复的数量
max_class_repeat = 3
# 生成和打印密码
for _ in range(100):
generated_password = generate_password(min_length, max_repeat, max_class_repeat, *char_credits)
print(generated_password)生成密码重置URL示例
import secrets
import string
# 生成安全令牌，用于密码恢复应用程序
security_token = ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(16))
# 构建临时密保URL
temp_url = f"https://example.com/password-recovery?token={security_token}"
print("生成的临时密保URL:", temp_url) # 输出：生成的临时密保URL: https://example.com/password-recovery?token=90HOEUVFroaJIO5D部分内容参考：https://www.cnblogs.com/wangguishe/p/18110157
作者：至尊宝呜呜
