python学习——random用法汇总（random,numpy,pytorch）

1.Python的random方法

• 引入random库

import random

• random.random()，用于生成一个0到1的随机符点数: 0 <= n < 1.0

[IN]:random.random()
[OUT]:0.8196438901221934

• random.uniform(a, b) 用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限

[IN]:random.uniform(1,2),random.uniform(2,1)
[OUT]:(1.324058649211128, 1.9116383670870984)

• random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限

[IN]:random.randint(1,3)
[OUT]:3

• random.randrange(strat,end,step)， start 到 end 每隔 step 取一个数组成一个数组，再随机从数组中取一个数，与random.choice(range(0,10,2))等价

[IN]:random.randrange(0,10,2)
[OUT]:6

• random.choice(sequence)，从序列中获取一个随机元素。参数sequence表示一个有序类型如list。

[IN]:random.choice(range(0,10))
[OUT]:6

• random.shuffle(list)，用于将一个列表中的元素打乱,无返回值，直接修改list

[IN]:lst = [1,2,3,4,5,6]
	 random.shuffle(lst)
	 print(lst)
[OUT]:[1, 5, 3, 4, 6, 2]

• random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列

[IN]:random.sample([1,2,3,4,5,6],4)
[OUT]:[4, 3, 1, 5]

2.numpy.random

• 导入库

import numpy as np

• np.random.uniform(low=0.0, high=1.0, size=None)
• 生出size个符合均分布的浮点数，取值范围为[low, high)，默认取值范围为[0, 1.0)

[IN]:np.random.uniform(low=0.0, high=1.0, size=10)
[OUT]:array([0.4269445 , 0.80133273, 0.77539793, 0.10455105, 0.20466959,0.20814754, 0.79143848, 0.40440469, 0.89503746, 0.67803687])

• np.random.rand(d0, d1, …, dn)
• 生成一个(d0, d1, …, dn)维的数组，数组的元素取自[0, 1)上的均分布，若没有参数输入，则生成一个数

[IN]:np.random.rand(1,32,32,3).shape,np.random.rand(1,32,32,3).max(),np.random.rand(1,32,32,3).min(),np.random.rand()
[OUT]:((1, 32, 32, 3), 0.9999076420260613, 0.0009399845766099313, 0.9674108430593686)

• np.random.randint(low, high=None, size=None, dtype=‘I’)
• 生成size个整数，取值区间为[low, high)，若没有输入参数high则取值区间为[0, low)

[IN]:np.random.randint(0,10,(32,32)).shape,np.random.randint(10)
[OUT]:((32, 32), 5)

• np.random.random(size=None)
• 产生[0.0, 1.0)之间的浮点数

[IN]:np.random.random((32,32)).shape
[OUT]:(32, 32)

• np.random.choice(a, size=None, replace=True, p=None)
• 从a（数组）中选取size（维度）大小的随机数，replace=True表示可重复抽取，p是a中每个数出现的概率
• 若a是整数，则a代表的数组是range(a)
• 若replace为False时，a中含有的数据要大于size的总数据，否则会报错

[IN]:np.random.choice(range(10),(3,3),replace=False)
[OUT]:array([[2, 9, 8],
             [0, 7, 4],
             [1, 5, 3]])

• np.random.permutation(x)
• 随机打乱x中的元素。若x是整数，则打乱range(x)
• 若x是一个数组，则将copy(x)的第一位索引打乱，意思是先复制x，对副本进行打乱处理，打乱只针对数组的第一维
• 注意与np.shuffle()的区别，permutation返回打乱的数据，shuffle不返回数组，在原数组中作修改。

[IN]:np.random.permutation(range(10))
[OUT]:array([7, 1, 6, 2, 9, 4, 3, 8, 5, 0])

• np.random.shuffle(x)
• 与permutation类似，随机打乱x中的元素。若x是整数，则打乱range(x). 但是shuffle会对x进行修改

[IN]:lst = [1,2,3,4,5,6,7,8,9]
     np.random.shuffle(lst)
     lst
[OUT]:[4, 1, 3, 8, 9, 2, 6, 5, 7]

• np.random.seed(seed=None)
• 设置随机生成算法的初始值 seed完后的第一次random操作的序列保持seed的序列不变

[IN1]:np.random.seed(1)
	 np.random.randint(0,10,(3,3))
[OUT1]:array([[5, 8, 9],
             [5, 0, 0],
             [1, 7, 6]])
# 再次运行：
[IN2]:np.random.seed(1)
	 np.random.randint(0,10,(3,3))
[OUT2]:array([[5, 8, 9],
             [5, 0, 0],
             [1, 7, 6]])

3.Pytorch-random

• 导入torch库

import torch

• 均匀分布: torch.rand(sizes,out=None)
• 返回一个张量，是从区间 [0, 1) 的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。

[IN]:torch.rand(2,3)
[OUT]:tensor([[0.1770, 0.4165, 0.7052],
        	  [0.8050, 0.8219, 0.0924]])

• 标准正态分布:torch.randn(sizes,out=None)
• 返回一个张量，是从标准正态分布（均值为0，方差为1）中抽取的一组随机数。张量的形状由参数sizes定义。

[IN]:torch.randn(2,3)
[OUT]:tensor([[ 0.1424,  0.8710, -0.7570],
        	  [ 0.4319,  0.3762, -0.5394]])

• 离散正态分布:torch.normal(means,std,out=None)
• 返回一个张量，是从指定均值means和标准差std的离散正态分布中抽取的一组随机数。
• 标准差std是一个张量，包含每个输出元素相关的正态分布标准差。

[IN]:torch.normal(mean = 1,std = torch.arange(1.0,6.0).float())
[OUT]:tensor([0.4434, 1.2379, 0.9425, 0.4852, 7.2445])

• torch.manual_seed(int) 用法与np.random.seed(int)等价

[IN1]:torch.manual_seed(1)
	  torch.rand(2,3)
[OUT1]:tensor([[0.7576, 0.2793, 0.4031],
        	   [0.7347, 0.0293, 0.7999]])
# 再次输出
[IN1]:torch.manual_seed(1)
	  torch.rand(2,3)
[OUT1]:tensor([[0.7576, 0.2793, 0.4031],
        	   [0.7347, 0.0293, 0.7999]])

• torch.randint(low=0, high, size, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
• 与np.randint类似 device可选’cpu’和’cuda’，require_grad=True时表示可导

[IN]:torch.randint(0,10,(3,3),device='cpu')
[OUT]:tensor([[0, 2, 1],
        	  [2, 6, 0],
        	  [3, 6, 4]])

• torch.rand_like(input, dtype=None, layout=None, device=None, requires_grad=False)
• 生成和input维度相同的随机[0,1]范围内的张量

[IN]:torch.rand_like(torch.Tensor(3,3),dtype=torch.float32)
[OUT]:tensor([[0.3398, 0.5239, 0.7981],
        	  [0.7718, 0.0112, 0.8100],
       		  [0.6397, 0.9743, 0.8300]])

• torch.randperm(n, out=None,dtype=torch.int64, layout=torch.strided,device=None,requires_grad=False) → LongTensor
• n为int表示上限，生成0-n-1的随机序列的整数

[IN]:torch.randperm(10)
[OUT]:tensor([5, 6, 9, 4, 3, 2, 7, 8, 1, 0])