随机数生成算法基本原理,计算机编程中的取随机数函数是怎么实现的？说一下大致原理就行

随机数生成算法基本原理,计算机编程中的取随机数函数是怎么实现的？说一下大致原理就行详细介绍

本文目录一览： 随机算法原理

展开专栏
登录
企鹅号小编
5.7K 篇文章
?关注
详解各种随机算法
2018-02-06阅读 1.4K0
转自：JarvisChu
之前将的算法都是确定的，即对于相同的输入总对应着相同的输出。但实际中也常常用到不确定的算法，比如随机数生成算法，算法的结果是不确定的，我们称这种算法为（随机）概率算法，分为如下四类：
1、数值概率算法
用于数值问题的求解，通常是近似解
2、蒙特卡洛算法Monte Carlo
能得到问题的一个解，但不一定是正确解，正确的概率依赖于算法运行的时间，算法所用的时间越多，正确的概率也越高。求问题的准确解；
3、拉斯维加斯算法 Las Vegas
不断调用随机算法求解，直到求得正确解或调用次数达到某个阈值。所以，如果能得到解，一定是正确解。
4、舍伍德算法 Sherwood
利用随机算法改造已有算法，使得算法的性能尽量与输入数据无关，即平滑算法的性能。它总能求得问题的一个解，且求得的解总是正确的。
随机数
概述
计算机产生的随机数都是伪随机数，通过线性同余法得到。
方法：产生随机序列
?
d称为种子；m取值越大越好；m，b互质，常取b为质数；

合成法生成随机数原理

随机数产生原理 原创
2017-06-30 18:15:46
? 8点赞
?
大作家佚名 ?
码龄13年
关注
引言
利用数学的方法产生随机数的优点具有速度快、可对模拟问题进行复算检查、具有较好的统计特性。通过检验符合均匀性、随机性、独立性就可以当作真正的随机数。
随机数
经典的随机数产生方法为是线性同余法，即Linear Congruence Generator (LCG)，由Lehmer于1951年提出。
同余：对于两个整数A、BA、B，如果它们同时除以一个自然数M的余数相同，就说A、BA、B对于模M同余，A≡BmodMA≡BmodM。
线性同余法
线性同余发生器是用不连续分段线性方程计算产生伪随机数序列的算法。LCG背后的理论比较容易理解，易于实现。由于计算机产生的随机数都是伪随机数，后面就直接用随机数代替伪随机数的叫法。
LCG定义如下：
Xn+1=(aXn+c)modm
Xn+1=(aXn+c)modm
其中，
XX是随机数序列
m,0
<mm,0<m，模
a,0
<a<ma,0<a<m，乘子
c,0≤c
<mc,0≤c<m，增量，也叫做偏移量
X0,0≤X0
<mx0,0≤x0<m，开始值，通常叫做“种子”seed
生成器不断往复运行，将会产生一序列
a,c,ma,c,m取值合适，序列最大周期将达到 mm。这种情况下，序列中所有可能的整数都在某点固定出现。当c=0c=0时候，LCG就变换成了乘法同余发生器，multiplicative congruential generator (MCG)， c≠0c≠0时叫做混合同余发生器，mixed congruential generator，MCG。
这里就用Wiki中的列子说明LCG是如何工作的：
?
当m=9,a=2,c=0,seed=1m=9,a=2,c=0,seed=1时，得：
X0=seed=1X0=seed=1
X2=(a?X1+c)modm=(2×1+0)%9=2X2=(a?X1+c)modm=(2×1+0)%9=2
X3=(a?X2+c)modm=(2×2+0)%9=4X3=(a?X2+c)modm=(2×2+0)%9=4
X4=(a?X3+c)modm=(2×4+0)%9=8X4=(a?X3+c)modm=(2×4+0)%9=8
X5=(a?X4+c)modm=(2×8+0)%9=7X5=(a?X4+c)modm=(2×8+0)%9=7
X6=(a?X5+c)modm=(2×7+0)%9=5X6=(a?X5+c)modm=(2×7+0)%9=5
X7=(a?X6+c)modm=(2×5+0)%9=1X7=(a?X6+c)modm=(2×5+0)%9=1
一个周期结束，如果再继续的话，随机序列将会以周期6重复出现。改变a,c,ma,c,m的值，LCG的周期性也发生了变换。
混合同余发生器 (MCG) 周期长度
通常MCG最大周期位mm，往往由于a,c，ma,c，m的选择使得周期无法达到mm。若想获得最大周期的随机数序列，需要同时满足下述条件：
m和c互质m和c互质。互质整数:公约数只有1的两个整数，如：7，5
a?1可以被ma?1可以被m的所有素因子整除
如果m被4整除，a?1也被4整除如果m被4整除，a?1也被4整除
这三个条件被称为Hull-Dobell定理，虽然LCG能够产生可以通过随机性的正式测试的伪随机数，但对参数c，m和ac，m和a的选择非常敏感。
使用LCG可能出现的问题
历史上，糟糕的因子选择导致了LCG的实施效率低下。在连续调用时，也无法避免序列的相关性。如果我们要自己设计LCG，选择不合适的a,c,ma,c,m往往带来糟糕的结果，却不自知。
历史上有这样的例子RANDU，其中，a=65539,m=231a=65539,m=231，在IBM大型机上使用了许多年，并被广泛应用在其他系统上，现在出现了很多问题，由于使用了糟糕的因子。
ANSI C库中的LCG
ANSI C库中的LCG实现具有一定的缺陷，其中一定数量的实施方法不能很好的工作，这个责任应该由ANSI C委员会及其实施者承担。——“Numerical Recipes”。该评判有明确出处，非笔者臆断！
由ANSI C标准规定rand()返回一个整数值，RAND_MAX通常不是很大。ANSI C标准要求RAND_MAX最大32767。
打开头文件stdlib.h，可以看到定义的十六进制RAND_MAX，使用博客的方法转换为十进制为32767。
/* Maximum value that can be returned by the rand function. */
#define RAND_MAX 0x7fff
1
2
3
1
2
3
ANSI C定义的LCG
打开rand.h头文件查看随机数生成器代码，产生随机数的过程即线性同余法，代码简单、结构清楚清楚。
/***
*rand.c - random number generator
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
* defines rand(), srand() - random number generator
*
*******************************************************************************/
#include
#include
#include
#include
/***
*void srand(seed) - seed the random number generator
*
*Purpose:
* Seeds the random number generator with the int given. Adapted from the
* BASIC random number generator.
*
*Entry:
* unsigned seed - seed to seed rand # generator with
*
*Exit:
* None.
*
*Exceptions:
*
*******************************************************************************/
void __cdecl srand (
unsigned int seed
)
{
_getptd()->_holdrand = (unsigned long)seed;
}
/***
*int rand() - returns a random number
*
*Purpose:
* returns a pseudo-random number 0 through 32767.
*
*Entry:
* None.
*
*Exit:
* Returns a pseudo-random number 0 through 32767.
*
*Exceptions:
*
*******************************************************************************/
int __cdecl rand (
void
)
{
_ptiddata ptd = _getptd();
return( ((ptd->_holdrand = ptd->_holdrand * 214013L
+ 2531011L) >> 16) & 0x7fff );
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
调用方式：
#include
#include
#include
using namespace std;
void main(){
//srand((unsigned)time(NULL));
srand(11);
for (int i = 0; i < 10; i++)
cout << rand() << '\t';
cout << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
均匀分布随机数
均匀分布随机数即等概率随机数，如：扔骰子、掷硬币。使用《数值方法》中的LCG生成服从[0,1][0,1]分布的均匀分布。
#include
#define IA 16807
#define IM 2147483647
#define AM (1.0/IM)
#define IQ 127773
#define IR 2836
#define NTAB 32
#define NDIV (1+(IM-1)/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)
float ran1(long *idum)
{
int j;
long k;
static long iy = 0;
static long iv[NTAB];
float temp;
if (*idum <= 0 || !iy) {
if (-(*idum) < 1)
*idum = 1;
else
*idum = -(*idum);
for (j = NTAB + 7; j >= 0; j--) {
k = (*idum) / IQ;
*idum = IA*(*idum - k*IQ) - IR*k;
if (*idum < 0)
*idum += IM;
if (j < NTAB)
iv[j] = *idum;
}
iy = iv[0];
}
k = (*idum) / IQ;
*idum = IA*(*idum - k*IQ) - IR*k;
if(*idum < 0)
*idum += IM;
j = iy / NDIV;
iy = iv[j];
iv[j] = *idum;
if ((temp = AM*iy) > RNMX)
return RNMX;
else
return temp;
}
void main()
{
float ran1(long *idum);
long seed = 10;
for (int i = 0; i < 10;++i)
{
std::cout << ran1(&seed) << std::endl;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
标准正态分布随机数
现实生活中更多的随机现象是服从正态分布的，如：20岁的成年人体重分布。正太分布随机数可以通过Box-Muller方法从均匀分布随机数转换为标准正态分布随机数。下面代码是《数值方法》中完整代码。
#include
#include
#define IA 16807
#define IM 2147483647
#define AM (1.0/IM)
#define IQ 127773
#define IR 2836
#define NTAB 32
#define NDIV (1+(IM-1)/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)
float ran1(long *idum)
{
int j;
long k;
static long iy = 0;
static long iv[NTAB];
float temp;
if (*idum <= 0 || !iy) {
if (-(*idum) < 1)
*idum = 1;
else
*idum = -(*idum);
for (j = NTAB + 7; j >= 0; j--) {
k = (*idum) / IQ;
*idum = IA*(*idum - k*IQ) - IR*k;
if (*idum < 0)
*idum += IM;
if (j < NTAB)
iv[j] = *idum;
}
iy = iv[0];
}
k = (*idum) / IQ;
*idum = IA*(*idum - k*IQ) - IR*k;
if(*idum < 0)
*idum += IM;
j = iy / NDIV;
iy = iv[j];
iv[j] = *idum;
if ((temp = AM*iy) > RNMX)
return RNMX;
else
return temp;
}
float gasdev(long *idum){
float ran1(long *idum);
static int iset = 0;
static float gset;
float fac, rsq, v1, v2;
if (*idum < 0)
iset = 0;
if (iset == 0) {
do {
v1 = 2.0*ran1(idum) - 1.0;
v2 = 2.0*ran1(idum) - 1.0;
rsq = v1*v1 + v2*v2;
} while (rsq >= 1.0 || rsq == 0.0);
fac = sqrt(-2.0*log(rsq) / rsq);
gset = v1*fac;
iset = 1;
return v2*fac;
}
else {
iset = 0;
return gset;
}
}
void main()
{
float ran1(long *idum);
long seed = 10;
for (int i = 0; i < 10;++i)
{
std::cout << gasdev(&seed) << std::endl;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
总结
这里详细叙述了LCG生成均匀分布随机数的方法，分析了获得最大周期的条件。随机序列具体服从的分布，可以通过卡方检验得到。由于ANSI C中的LCG随机数的缺陷，vs下编程不建议使用系统自带的随机数生成器。如果只是单独的使用LCG产生随机数，也不建议自己实现LCG（即使实现过程很简单）。最后建议使用《数值方法》中的LCG随机数生成器。
参考
https://en.wikipedia.org/wiki/Linear_congruential_generator
https://en.wikipedia.org/wiki/RANDU
http://baike.baidu.com/link?url=0_DsXFh4U0_s5s9mUrrEAwuW_y1ol3a473KOb8eGxNwUH7C5g_97Pc825aX2bOFqUjDYl-rM_Su-rdiDncwG_dwRyxmjjENIvlmEpyXEZJm
Press, W. H. (2007). Numerical recipes 3rd edition: The art of scientific computing. Cambridge university press.
https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
http://www.cnblogs.com/zztt/p/4025207.html
http://www.cnblogs.com/afarmer/archive/2011/05/01/2033715.html

电脑如何产生随机数？">电脑如何产生随机数？

电脑产生的随机数称为伪随机数，是通过算法模拟的，看上去和随机数一样，实际上能算出来的数就是可以预见的数（对用户来说不可预见，对电脑则是可预见），不是真正的随机数。
从一个大数“种子”开始重复某种迭代计算，通常是加减乘除加求余，种子可以取系统时间，因为用户不可能精确到微秒控制程序运行，就基本保证了每次生成数值的顺序不同
一般来说如果用数字电路产生的都是伪随机数，但由于循环时间太长可视为随机数。而现在有用模拟电路产生的随机数，主要原理是将热噪声放大，然后编码。
扩展资料
随机数的作用
随机数的使用历史已经有数千年。无论是抛硬币还是摇色子，目的是让随机概率决定结果。电脑中的随机数生成器的目的也是如此——生成随机不可预测的结果。
加密法要求数字不能被攻击者猜到，不能多次使用同样的数字。所以需要一种机制产生攻击者无法预测的数字，这些随机数对加密法至关重要，无论你是加密文件还是访问https协议网站，都需要用到随机数。
根据随机数的生成原理，我们把电脑随机数分为两类：“真”随机数和伪随机数。
要生成一个“真”随机数，电脑会检测电脑外部发生的某种物理现象。比如说，电脑可以测量某个原子的放射性衰变。根据量子理论，原子衰变是随机而不可测的，所以这就是宇宙中的“纯粹”随机性。攻击者永远无法预测原子衰变的发生时间，也就不可能猜出随机值。
参考资料来源：
百度百科——随机数

电脑取随机数是什么原理，是真正的随机数吗？

电脑所产生的随机数大部分为伪随机数，通过算法或者编一段程序实现，但是计算机本身就是一种确定的或固定的设备，编程时写的代码也是固定的，用的算法也是固定的，通过这些固定的东西生成真随机显然不太可能，但是我们可以引入系统意外的变量，通过计算机内的时钟，io请求响应时间，键盘的敲击速度，鼠标移动的位置，磁盘写入速度等信号，通过以上方法将其信号专为数据，是之成为参数带入某个函数内，是可以达到统计意义上的真随机。

电脑取随机数原bai理实质是伪随du机数。

大部分程序和语言中的随机数zhi（比如 C 中的，MATLAB 中的），确dao实都只是伪随机。是由可确定的函数（常用线性同余），通过一个种子（常用计算机内部的时钟），产生的伪随机数。

真正意义上的随机数（或者随机事件）在某次产生过程中是按照实验过程中表现的分布概率随机产生的，其结果是不可预测的，是不可见的。而计算机中的随机函数是按照一定算法模拟产生的，其结果是确定的，是可见的。我们可以这样认为这个可预见的结果其出现的概率是100%。所以用计算机随机函数所产生的“随机数”并不随机，是伪随机数。

steam随机数

Steam随机数是指在Steam平台上生成的随机数。这些随机数常用于游戏中的随机事件、掉落物品、抽奖活动等方面。Steam使用随机数生成器（Random Number Generator，简称RNG）来产生这些随机数。RNG是一种算法，通过使用特定的种子值，可以在特定的范围内生成看似随机的数字。
使用随机数的原因是为了增加游戏的变化性和挑战性。通过引入随机数，游戏中的事件和结果变得不可预测，使得游戏更具有趣味性和挑战性。例如，在一款角色扮演游戏中，怪物的掉落物品可能是随机的，玩家需要不断探索、战斗并希望能够获得稀有的装备或道具。这种随机性能够增加游戏的可玩性和重复性。
然而，需要注意的是，随机数并不意味着完全随机。因为随机数实际上是由算法生成的，所以在理论上是可预测的。此外，不同的随机数生成算法可能会有不同的随机性质和结果分布。对于游戏开发者来说，选择合适的随机数生成算法以及适当的种子值是很重要的，以确保游戏中的随机性符合设计意图，并且公平合理。
总结来说，Steam随机数的使用可以增加游戏的趣味性和挑战性，提供一种变化和不可预测性。然而，随机数实际上是由算法生成的，需要游戏开发者慎重选择和使用，以确保随机性的公平和合理性。
Steam随机数是指在Steam平台上生成的随机数。Steam是一个数字发行平台，用于购买和下载电子游戏、软件和其他相关内容。在游戏开发和游戏运行过程中，随机数的使用非常常见。
生成随机数的原因是为了增加游戏的可变性和重复性，使游戏具有更高的娱乐性和挑战性。随机数可以用于生成随机地图、敌人的行为模式、掉落物品的概率等等。通过使用随机数，游戏可以在每次玩的时候都呈现出不同的情况，让玩家体验到更多的乐趣和刺激。
同时，随机数也可以被用于游戏的平衡性和公平性。例如，在多人游戏中，通过随机数来决定玩家的出牌顺序或者随机匹配对手，可以避免不公平的情况发生，增加游戏的公正性。
在游戏开发中，生成高质量的随机数是非常重要的。因为低质量的随机数可能会导致游戏的不可预测性降低，出现重复的情况或者模式，影响游戏的乐趣和挑战性。因此，游戏开发者会使用各种算法和技术来生成高质量的随机数，以确保游戏的可玩性和变化性。
总之，Steam随机数的使用在游戏中起到了重要的作用，增加了游戏的可变性和挑战性，同时也保证了游戏的公平性和平衡性。
Steam随机数是指在Steam游戏平台中生成的随机数。这些随机数通常用于游戏中的随机事件、掉落物品、随机匹配等方面。Steam使用随机数的目的是为了增加游戏的可变性和挑战性，使游戏体验更具趣味性和多样性。
随机数的生成通常基于计算机的伪随机数生成算法，根据一定的种子值，通过一系列的计算和变换来生成随机数。这些算法保证了生成的随机数具有一定的不可预测性和均匀性。
使用随机数可以增加游戏的难度和挑战性，因为玩家无法预知下一个随机事件或者得到的随机物品是什么。这使得游戏更具策略性和刺激性，玩家需要根据随机事件的结果来做出相应的决策。
同时，随机数也增加了游戏的可重复性和乐趣性。每次游戏过程中随机生成的事件和物品都不同，使得每次游戏体验都有所不同，玩家可以不断尝试不同的策略和方案，增加游戏的重玩价值。
综上所述，Steam使用随机数是为了增加游戏的可变性、挑战性和乐趣性。通过随机数的引入，游戏变得更加有趣，玩家需要在不可预知的情况下做出决策，增加了游戏的策略性和重玩价值。
Steam随机数是指在Steam平台上生成的随机数。Steam是一个数字发行平台，用于购买和下载电子游戏、软件和其他数字内容。当需要进行随机选择或生成随机数时，Steam平台提供了一种方便的机制。
Steam随机数的生成原理是基于计算机的伪随机数算法。计算机使用一种称为"种子"的初始值，通过特定的算法生成随机数序列。这个种子值可以是由系统时间、用户输入或其他随机事件生成的。每次使用相同的种子值，都会生成相同的随机数序列。这个机制确保了在相同条件下，每次生成的随机数都是可重现的。
拓展内容：随机数在计算机科学和应用中具有广泛的应用。在游戏开发中，随机数被用于生成随机地图、敌人的行为模式、掉落物品等。在密码学中，随机数被用于生成加密密钥、生成随机的初始化向量等。此外，随机数还被用于模拟实验、进行统计分析等领域。保证随机数的质量和安全性是非常重要的，因此在实际应用中需要选择合适的随机数生成算法，并保证种子值的安全性和随机性。
Steam随机数是指在Steam平台上生成的随机数。这些随机数通常用于游戏中的随机事件、物品掉落、抽奖活动等。Steam平台为了保证公平性和随机性，采用了特定的算法来生成随机数。
生成随机数的算法通常会使用一个种子值作为起点，然后通过一系列计算来产生一个看似随机的结果。种子值可以是时间戳、用户ID等。由于算法是确定性的，所以相同的种子值会产生相同的随机数序列，这就意味着在相同的条件下，每次生成的随机数是固定的。
为了避免重复和可预测性，Steam通常会使用当前时间戳作为种子值，这样每次生成的随机数序列都会有所不同。此外，为了防止玩家通过破解算法或者恶意操作得到不公平的优势，Steam还会对生成的随机数进行进一步加密和保护。
需要注意的是，虽然随机数生成算法是设计为随机的，但实际上它们是伪随机的。也就是说，随机数的生成过程是可预测的，只是在实际应用中表现出了一种近似于真随机的特性。这是因为计算机是基于确定性的操作，无法真正实现绝对的随机性。
总结起来，Steam随机数生成过程涉及种子值、算法和加密保护等因素，以确保公平性和随机性。然而，由于计算机的本质限制，生成的随机数实际上是伪随机的。这样的设计可以确保游戏体验的多样性和趣味性，同时也保护了游戏平衡和公平性。

计算机编程中的取随机数函数是怎么实现的？说一下大致原理就行

用时间为种子生成的伪随机数，但并不是真正的随机，因为时间是确定的，我以前就试验过，?了个程序取成千上万的随机数，然后把这些随机数以图象形式呈现出来，能发现明显的规律。更随机的方法其实也有，比如用很精确的传感器，去测量主机里的温度，风扇的转速，电路里的电压等，由于这些值会受到无数来自内外部变量的影响，难以确定值的大小，并且总是在不断变化，因此只要传感器够灵敏，用这些值做种子得到的随机数会更随机

计算器如何产生随机数？

一般计算机的随机数都是伪随机数，以一个真随机数（种子）作为初始条件，然后用一定的算法不停迭代产生随机数，下面介绍两种方法：
一般种子可以以当前的系统时间，这是完全随机的
。
算法1：平方取中法。
1）将种子设为X0，并mod 10000得到4位数
2)将它平方得到一个8位数（不足8位时前面补0）
3）取中间的4位数可得到下一个4位随机数X1
4）重复1-3步，即可产生多个随机数
这个算法的一个主要缺点是最终它会退化成0，不能继续产生随机数。
算法2：线性同余法
1）将种子设为X0，
2）用一个算法X(n+1)=(a*X(n)+b) mod c产生X(n+1)
一般将c取得很大，可产生0到c-1之间的伪随机数
该算法的一个缺点是会出现循环。

线性同余法产生随机数原理

什么是伪随机数？ 1.伪随机数是看似随机实质是固定的周期性序列,也就是有规则的随机。

2.只要这个随机数是由确定算法生成的,那就是伪随机,只能通过不断算法优化,使你的随机数更接近随机。 (随机这个属性和算法本身就是矛盾的) 3.通过真实随机事件取得的随机数才是真随机数。 Java随机数产生原理： Java的随机数产生是通过线性同余公式产生的,也就是说通过一个复杂的算法生成的。

详解随机数的生成

随机数参与的应用场景大家一定不会陌生，比如密码加盐时会在原密码上关联一串随机数，蒙特卡洛算法会通过随机数采样等等。Python内置的random模块提供了生成随机数的方法，使用这些方法时需要导入random模块。

下面介绍下Python内置的random模块的几种生成随机数的方法。

1、random.random()随机生成 0 到 1 之间的浮点数[0.0, 1.0)。注意的是返回的随机数可能会是 0 但不可能为 1，即左闭右开的区间。

2、random.randint(a , b)随机生成 a 与 b 之间的整数[a, b]，a<=n<=b，随机整数不包含 b 时[a, b)可以使用 random.randrange() 方法。

3、random.randrange(start,stop,step)按步长step随机在上下限范围内取一个随机数，start<=n<stop。

4、random.uniform(a, b)随机生成 a 与 b 之间的浮点数[a, b]，a<=n<=b。

5、random.choice()从列表中随机取出一个元素，比如列表、元祖、字符串等。注意的是，该方法需要参数非空，否则会抛出 IndexError 的错误。

6、random.shuffle(items) 把列表 items 中的元素随机打乱。注意的是，如果不想修改原来的列表，可以使用 copy 模块先拷贝一份原来的列表。

7、random.sample(items, n)从列表 items 中随机取出 n 个元素。

Python 的random模块产生的随机数其实是伪随机数，依赖于特殊算法和指定不确定因素(种子seed)来实现。如randint方法生成一定范围内的随机数，会先指定一个特定的seed，将seed通过特定的随机数产生算法，得到一定范围内随机分布的随机数。因此对于同一个seed值的输入产生的随机数会相同，省略参数则意味着使用当前系统时间秒数作为种子值，达到每次运行产生的随机数都不一样。

numpy库也提供了random模块，用于生成多维度数组形式的随机数。使用时需要导入numpy库。

下面介绍下numpy库的random模块的几种生成随机数的方法。

1、numpy.random.rand(d0,d1,…,dn)

2、numpy.random.randn(d0,d1,…,dn)

3、numpy.random.randint(low, high=None, size=None, dtype=’l’)

4、numpy.random.seed()