我们在python工程和数据分析中经常用到随机的操作，比如随机生成某个值，对一串数据进行随机排序等等。random是python一个很强的第三方库，可以实现常用的随机算法。

安装：pip install random

一：生成随机的数字

0~1之间的随机小数（float）：random.random()

a~b之间的随机小数（float）：random.uniform(a, b)

[a, b)之间的随机整数（int）：random.randint(a, b)

import random print(f''' random.random():0~1之间抽取随机小数： {random.random()} ''') print(f''' random.uniform():a~b之间抽取随机小数： {random.uniform(1,10)} ''') print(f''' random.randint():[a, b)之间抽取随机整数： {random.randint(3,8)} ''') # 运行结果： random.random():0~1之间抽取随机小数： 0.75106286590147 random.uniform():a~b之间抽取随机小数： 1.1154946513637323 random.randint():[a, b)之间抽取随机整数： 6

二：对非空序列（元组、列表、字符串）操作随机拿取

随机地取一个值（等权）：random.choice(lis)

这个很简单，从对象中随机取出一个值，每个值取到的概率相同。

import random lis = (1,2,3,4,5,'cat') print(random.choice(lis)) # 运行结果： 4

随机地取k个值（可分配权重）：random.choices(lis, weights=[], cum_weights=[], k=n)

这里重点讲一下几个参数：

• 参数1：population=lis，即样本集。
• 参数2：设置权重weights或cum_weights，传入一个权重列表，为每个样本元素分别设置权重（权重列表个数要与样本列表个数一致）。
  weights（相对权重）和cum_weights（累加权重）都是权重参数，设置方式不同而已，使用时选择其一。
• 参数3：k=n，即从样本中取几个元素。

重点来了：
要了解weights（相对权重）和cum_weghts（累加权重），我们看两个例子：
weights相对权重：把每个权重要素加一起，其总和为总权重。每个权重要素占总权重的比例，即为对应样本的概率。

import random lis = (1,2,3,4,5,'cat') print(random.choices(population=lis, weights=[1,2,1,1,3,4], k=3)) ''' weights=[1,2,1,1,3,4]，权重总和为：1+2+1+1+3+4 =12 即： 第一个元素1抽到的概率为：1/12，约8.3% 第二个元素2抽到的概率为：2/12，约16.7% ... 第五个元素5抽到的概率为：3/12，25% 第六个元素‘cat’抽到的概率为：4/12，约33.3% ''' # 运行结果： [2, 'cat', 5]

cum_weights累加权重：网上的教程对累加权重解释的都很模糊，我在这里详细说一下。

• 累加权重是“分蛋糕”的概念，样本按照所设权重的总份数（总蛋糕），从第一个开始依次分。分完即止，后面没分到权重的概率为0。
• 列表的最后一项为权重的总份数（共有多少份蛋糕）。
• 列表的每一项代表截至到此，累计拿了几份权重（拿走了多少份蛋糕）。

下面看几个例子。为了便于直观看到概率是多少，我们写个函数test_cumweights()，专门统计样本出现的概率。

def test_cumweights(lis, cw, m, n): ''' 【输入】lis:样本集，cw:累加权重，m:抽多少次，n:每次抽几个 【输出】每个样本出现的概率 ''' result = {} # 用于记录样本出现的次数，{样本：次数} for i in lis: result[i] = 0 # 初始化，出现次数均为0 num = 0 while num < m: # 抽 m 次 res = random.choices(population=lis, cum_weights=cw, k=n) # 抽n个的结果res for i in res: result[i] += 1 # 将本次的结果保存到字典 num += 1 times = num * n # 一共抽了多少次 for k,v in result.items(): # 打印结果 print(f'共抽了{times}次，其中【{k}】出现了{v}次，概率约为：{round((v/times),3)}')

例一：cum_weights=[1,2,2,3,7]，总权重为7份。

第一个元素：累计拿了一份，即1/7为14.3%；
第二个元素：累计拿了两份，即第二个元素拿了一份权重，1/7为14.3%；
第三个元素：累计拿了两份，说明第三个元素并未拿权重，即0%；
第四个元素：累计拿了三份，即第四个元素也拿了一份权重，1/7为14.3%；
第五个元素：到此累计拿了七份，即第五个元素拿了四份权重，4/7为57.1%。

lis = ['张飞','马超','荀彧','颜良文丑','毒苹果'] cw = [1,2,2,3,7] m = 10000 n = 3 test_cumweights(lis=lis,cw=cw, m=m, n=n) # 运行结果： 共抽了30000次，其中【张飞】出现了4284次，概率约为：0.143 共抽了30000次，其中【马超】出现了4366次，概率约为：0.146 共抽了30000次，其中【荀彧】出现了0次，概率约为：0.0 共抽了30000次，其中【颜良文丑】出现了4322次，概率约为：0.144 共抽了30000次，其中【毒苹果】出现了17028次，概率约为：0.568

是不是很好理解？别急，下面还有难的：

例二：cum_weights=[2,3,1,2,7]，总权重为7份。

第一个元素：累计拿了两份，即2/7为28.6%；
第二个元素：累计拿了三份，即第二个元素拿了一份权重，即1/7为14.3%；
第三个元素：累计拿了一份，权重分配到此，说明又收回了两份，只分了一份出去。谁拿了呢？显然是第一个，因为第一个是2，是最先分配的（如果是0呢？）。所以第一个元素变成了1/7为14.3%，第二个元素没分到为0%，第三个元素也没拿，为0%；
第四个元素：累计拿了两份，即第四个元素拿了一份权重，1/7为14.3%；
第五个元素：到此累计拿了七份，即第五个元素拿了五份权重，5/7为71.4%。

lis = ['张飞','马超','荀彧','颜良文丑','毒苹果'] cw = [2,3,1,2,7] m = 10000 n = 3 test_cumweights(lis=lis,cw=cw, m=m, n=n) # 运行结果： 共抽了30000次，其中【张飞】出现了4281次，概率约为：0.143 共抽了30000次，其中【马超】出现了0次，概率约为：0.0 共抽了30000次，其中【荀彧】出现了0次，概率约为：0.0 共抽了30000次，其中【颜良文丑】出现了4425次，概率约为：0.147 共抽了30000次，其中【毒苹果】出现了21294次，概率约为：0.71

例二中，如果cw第一个是0呢？显然，第一个就没要份额，后面重新分配时就会把权重分给第二个，即cw=[0, 3, 1, 2, 7]：
元素一：0%
元素二：14.3%
元素三：0%
元素四：14.3%
元素五：71.4%

lis = ['张飞','马超','荀彧','颜良文丑','毒苹果'] cw = [0,3,1,2,7] m = 10000 n = 3 test_cumweights(lis=lis,cw=cw, m=m, n=n) # 运行结果： 共抽了30000次，其中【张飞】出现了0次，概率约为：0.0 共抽了30000次，其中【马超】出现了4281次，概率约为：0.143 共抽了30000次，其中【荀彧】出现了0次，概率约为：0.0 共抽了30000次，其中【颜良文丑】出现了4292次，概率约为：0.143 共抽了30000次，其中【毒苹果】出现了21427次，概率约为：0.714

累加权重cum_weights支持整数和小数分配，逻辑是一样的。

累加权重的概念到此讲完，着实很抽象。

要知道，random.choices()的运算逻辑就是把相对权重weights先转为累加权重cum_weights，再执行随机算法。因此使用cum_weights参数的运算效率要高一些。

如果不是追求极致的算法，使用weights就能满足日常需要。但我还是建议你掌握cum_weights的逻辑，以便日后装杯用。

三、随机打乱一个可迭代对象

random.shuffle(lis)

该用法是对lis的原数据执行打乱操作，本身无返回值，lis将被随机打散，原数据再也回不来了。

lis = ['张飞','马超','荀彧','颜良文丑','毒苹果'] random.shuffle(lis) print(random.shuffle(lis)) print(lis) # 运行结果： None ['颜良文丑', '荀彧', '毒苹果', '张飞', '马超']

因此shuffle()使用起来会有诸多不便。我们可以构建一个自定义的shuffle函数，结合在numpy系列里讲的copy用法，实现对传入对象的打散，且不改变原对象的数据。

import random import copy def my_shuffle(lis): copy_lis = copy.deepcopy(lis) # 深拷贝一个副本对象 try: random.shuffle(copy_lis) # 对副本对象操作打散 except: return None return copy_lis lis = ['张飞','马超','荀彧','颜良文丑','毒苹果'] result = my_shuffle(lis=lis) print(f'执行打散后的数据：{result}') print(f'原数据：{lis}') # 运行结果： 执行打散后的数据：['马超', '颜良文丑', '毒苹果', '荀彧', '张飞'] 原数据：['张飞', '马超', '荀彧', '颜良文丑', '毒苹果']

四、固定某个随机结果

使用random.seed(n)可以将接下来的随机操作结果固定下来，如果后面的代码调用该seed，将复现本次的随机操作，使两次随机结果相同。
参数n可以为整型、浮点型、甚至为字符串。其本身没有任何意义，只作区分本次标记用。
因此要注意，每个seed值对应的随机结果是唯一的。

我们看个抽牌的小游戏，随机从一叠牌中抽取一张，如果抽到了JOKER，则使用seed模仿赌神，再抽一次JOKER出来。

res = ['10', 'J', 'Q', 'K', 'A', 'JOKER'] # 定义几张牌 num = 0 while num < 10: # 抽10次 set_seed = random.random() # 定义一个随机seed, 用于标记本次随机的记录 random.seed(set_seed) get_it = random.choice(res) # 抽牌 print(f'本次抽到了{get_it}。') if get_it == 'JOKER': random.seed(set_seed) # 如果为JOKER, 则使用本次标记的seed再抽一张JOKER出来 get_again = random.choice(res) # 执行第二次抽取 print(f'触发第二次，本次抽到了{get_again}') else: pass num += 1 print('- ' * 20) # 运行结果： 本次抽到了A。 - - - - - - - - - - - - - - - - - - - - 本次抽到了Q。 - - - - - - - - - - - - - - - - - - - - 本次抽到了K。 - - - - - - - - - - - - - - - - - - - - 本次抽到了Q。 - - - - - - - - - - - - - - - - - - - - 本次抽到了JOKER。 触发第二次，本次抽到了JOKER - - - - - - - - - - - - - - - - - - - - 本次抽到了Q。 - - - - - - - - - - - - - - - - - - - - 本次抽到了JOKER。 触发第二次，本次抽到了JOKER - - - - - - - - - - - - - - - - - - - - 本次抽到了Q。 - - - - - - - - - - - - - - - - - - - - 本次抽到了A。 - - - - - - - - - - - - - - - - - - - - 本次抽到了A。 - - - - - - - - - - - - - - - - - - - -

五、生成固定bit大小的随机整数：

random.getrandbits(s)

关于比特位bit和字节Byte的知识：

• 比特位bit指二进制的机器码（0和1），1011 代表4 bit；
• 1 Byte = 8 bit。

用最后一个例子结束random的讲解。生成一个随机bit位的随机数，执行十次看看结果如何：

num = 0 while num < 10: # 试验十次 size = random.randint(1,20) # 定义一个随机大小的bit位（1-19之间） result = random.getrandbits(size) # 生成size大小的随机整数 result_b = bin(result) # 转成二进制用做验证 print(f''' 第{num+1}次试验： 生成结果为：{result}，其二进制为：{result_b} 该数字大小为{size}bit，{round(size/8,2)}byte ''') num += 1 print('- ' * 20) # 运行结果： 第1次试验： 生成结果为：3，其二进制为：0b11 该数字大小为4bit，0.5byte - - - - - - - - - - - - - - - - - - - - 第2次试验： 生成结果为：211，其二进制为：0b11010011 该数字大小为8bit，1.0byte - - - - - - - - - - - - - - - - - - - - 第3次试验： 生成结果为：435，其二进制为：0b110110011 该数字大小为9bit，1.12byte - - - - - - - - - - - - - - - - - - - - 第4次试验： 生成结果为：784，其二进制为：0b1100010000 该数字大小为14bit，1.75byte - - - - - - - - - - - - - - - - - - - - 第5次试验： 生成结果为：33159，其二进制为：0b1000000110000111 该数字大小为19bit，2.38byte - - - - - - - - - - - - - - - - - - - - 第6次试验： 生成结果为：3，其二进制为：0b11 该数字大小为4bit，0.5byte - - - - - - - - - - - - - - - - - - - - 第7次试验： 生成结果为：56，其二进制为：0b111000 该数字大小为7bit，0.88byte - - - - - - - - - - - - - - - - - - - - 第8次试验： 生成结果为：0，其二进制为：0b0 该数字大小为4bit，0.5byte - - - - - - - - - - - - - - - - - - - - 第9次试验： 生成结果为：1，其二进制为：0b1 该数字大小为2bit，0.25byte - - - - - - - - - - - - - - - - - - - - 第10次试验： 生成结果为：26，其二进制为：0b11010 该数字大小为5bit，0.62byte - - - - - - - - - - - - - - - - - - - -

值得注意的是，我们以2举例，其二进制既可以为10，也可以为0010或00010。

其对应的值相同，只是占的bit大小不同（2bit、4bit、5bit）。