random

 np.random

random()	生成一个[0, 1.)之间的随机浮点数
random([3, 2])	生成形状为3×2的[0, 1.)之间的随机浮点数
rand(3, 2)	和random([3, 2])相同
randint(a ,b, size)	生成[a,b)之间的随机整数
uniform(a, b, size)	生成形状为size的[a,b)之间的浮点数
normal(m, d, size)	生成的随机数符合均值为m,标准差为d的正态分布
randn(2, 3)	生成形状为2×3的随机浮点数,符合标准正态分布
choice(l, size)	随机返回形状为size的元素,l必须是1维的
shuffle(arr)	将ndarray中元素随机打乱,直接改变原来的变量,无返回值

1.np.random.random(size)：生成[0, 1.0)之间的随机浮点数。

import numpy as np
'''
np.random.random(size)
Args:
    size:默认为None，表示生成随机数的形状，不传参数时，只返回一个随机数
'''
r = np.random.random()
print(r)
'''
0.051330718987810275
'''
 
r = np.random.random([3,2])
print(r)
'''
[[0.56485029 0.26826023]
 [0.283601   0.06587369]
 [0.53037703 0.09549962]]
'''

2.np.random.rand(d0, d1, ..., dn)： 生成一个[0,1)之间的随机浮点数或N维浮点数组。

3.np.random.randint(low, high, size):生成[low, high)之间的随机整数。

import numpy as np
'''
np.random.randint(low, high, size)
    生成[low,high)之间的整数
Args:
    low:最小值(能取到)
    high:最大值(取不到)
    size:默认为None，表示生成随机数的形状，不传参数时，只返回一个随机数
'''
r = np.random.randint(1, 6)
print(r)
'''
5
'''
 
r = np.random.randint(1, 7, [3, 2])
print(r)
'''
[[1 3]
 [1 6]
 [2 2]]
'''

4.np.random.uniform(low, high, size):生成[low,high)之间的随机浮点数，随机的概率是均匀的。

import numpy as np
'''
np.random.uniform(low, high, size)
    生成[low,high)之间的随机浮点数，随机的概率是均匀的
Args:
    low:最小值(能取到)
    high:最大值(取不到)
    size:默认为None，表示生成随机数的形状，不传参数时，只返回一个随机数
'''
r = np.random.uniform(1, 6)
print(r)
'''
4.012983373039803
'''
 
r = np.random.uniform(1, 6, [3, 2])
print(r)
'''
[[3.15760289 1.680493  ]
 [5.99482432 3.50459819]
 [3.60929118 1.36948006]]
'''

5.np.random.normal(mean, stddev, size):生成形状为size的随机浮点数，随机的概率符合均值为mean，标准差为stddev的正态分布。

import numpy as np
'''
np.random.normal(mean, stddev, size)
    生成形状为size的随机浮点数，随机的概率符合均值为mean，标准差为stddev的正态分布
Args:
    mean:均值，默认为0
    stddev:标准差，默认为1
    size:默认为None，表示生成随机数的形状，不传参数时，只返回一个随机数
'''
r = np.random.normal(5, 1)
print(r)
'''
4.881012596562961
'''
 
r = np.random.normal(5, 1, [3, 2])
print(r)
'''
[[5.28539653 6.53396064]
 [5.59970247 5.066448  ]
 [5.72564169 4.78830441]]
'''

6.np.random.randn(d0, d1, ..., dn)： 生成一个浮点数或N维浮点数组，取数范围：正态分布的随机样本数。

7.np.random.choice(a, size=None, replace=True, p=None)：从a序列中随机取出形状为size的元素。

import numpy as np
'''
np.random.choice(a, size=None, replace=True, p=None)
    从a序列中随机取出形状为size的元素
Args:
    a:一个列表，必须是一维的！
    size:默认为None，表示生成随机数的形状，不传参数时，只返回一个随机数
    replace:能否重复
    p=None
'''
r = np.random.choice([1, 2, 3, 4, 5, 6])
print(r)
'''
3
'''
 
r = np.random.choice([1, 2, 3, 4, 5, 6], [2, 3])
print(r)
'''
[[4 4 6]
 [2 2 2]]
'''
 
r = np.random.choice([1, 2, 3, 4, 5, 6], [2, 3], replace=False)  # 不重复
print(r)
'''
[[3 1 2]
 [5 4 6]]
'''
 
r = np.random.choice([1, 2, 3, 4, 5, 6], [2, 3], p=[0.8, 0.05, 0.05, 0.04, 0.04, 0.02])  # 指定概率
print(r)
'''
[[6 1 1]
 [3 1 1]]
'''

8.np.random.shuffle(x)：洗牌，对x进行顺序打乱，对多维数组进行打乱排列时，只对第一个维度也就是列维度进行随机打乱。

import numpy as np
'''
np.random.shuffle(x)
    洗牌，对x进行顺序打乱
    对多维数组进行打乱排列时，只对第一个维度也就是列维度进行随机打乱
Args:
    x：如果是1维的，则全部打乱，如果是多维的,只对第一维打乱
'''
r = np.random.randint(1, 7, 6)  # 一维的
print(r)
'''
[4 5 2 5 1 2]
'''
 
np.random.shuffle(r)  # 打乱
print(r)
'''
[2 1 4 5 2 5]
'''
 
r = np.random.randint(1, 7, [5, 2])  # 多维的
print(r)
'''
[[2 1]
 [4 6]
 [3 2]
 [4 1]
 [1 4]]
'''
 
np.random.shuffle(r)  # 打乱
print(r)
'''
[[4 1]
 [2 1]
 [4 6]
 [3 2]
 [1 4]]
'''

9.np.random.choice(a, size=None, replace=True, p=None)： 从序列中获取元素，若a为整数，元素取值为np.range(a)中随机数；若a为数组，取值为a数组元素中随机元素。

10.np.random.permutation(x)： 与numpy.random.shuffle(x)函数功能相同，两者区别：peumutation(x)不会修改X的顺序。

torch随机函数

1.torch.rand(*sizes) ，size可以是列表、元组或直接写数字

Returns a tensor filled with random numbers from a uniform distribution on the interval [0, 1)

2.torch.randn(*sizes) ，size可以是列表、元组或直接写数字

Returns a tensor filled with random numbers from a normal distribution with mean `0` and variance `1`

3.torch.randint(low, high, size)，size是元组形式

Returns a tensor filled with random integers generated uniformly on the interval [low, high)

4.torch.randperm()：返回一个0到n-1的数组。

5.random_()：

返回的是恰好为整数的浮点型数字，例如：