0.什么是numpy

  • 一个在Python中做科学计算的基础库，重在数值计算，也是大部分PYTHON科学计算库的基础库，多用于在大型、多维数组上执行数值运算

    1. 快速
    2. 方便
    3. 科学计算的基础库

  • 安装numpy和scipy

    • 方式1:使用cmd中pip指令 cmd –>pip list查看已安装的所有库

    • 安装numpy: pip install numpy==版本 python3.7对应版本1.21.6 3.8 3.9 3.11 对应1.24

      卸载: pip uninstall scipy 提示输入y

      安装: 指定版本 pip install scipy == 版本号

      方式2: pycharm –>设置 –> 项目 :python interperter –>点击+号: 搜索scipy–>点击install按钮

1.多维数组创建

(1) 创建一维数组

1
2
import numpy as np
print(np.__version__)

  • 方式1: np.array([1,2,3,4,5,6],dtype=np.int64) – 结果[1 2 3 4 5 6] 数组a

  • 方式2: np.array(range(1,6)) – 结果[1 2 3 4 5]

  • 方式3: np.arange(1,6,1) – 结果[1 2 3 4 5]

  • 方式4: np.array(list) 将一个列表或序列转化为数组

  • 方式5: np.adarray(a,b,c) 序列表达式直接产生一个数组 从a到b，步长为c。
    np特有的，猜测是 b= np.array(range(a,b，c)的简写

(2)创建多维数组

  • 二维数组 单个维度的元素数量要保持一致,数组的元素类型要保持一致(不一致则自动被转换为一致的),否则报错
1
2
3
num_list2 = [[1,2,3,4,5],[6,7,8,9,10]]
num_list3 = [[1,2,3,4,"a"],[6,7,8,9,"b"]]
array = np.array(num_list3)
  • 三维数组(三维矩阵) : 列表维度和要创建的数组维度一致; 数据和维度如果是灵活的情况下创建复杂,
1
2
num_list4=[ [[1,2,3,4,"a"],[6,7,8,9,"b"]] ,  [[1,2,3,4,"a"],[6,7,8,9,"b"]] ]
array2 = np.array(num_list4)
  • PS:
    创建多维数组时可以
  • ​ 1、创建一个全0的数组: np.zeros((3,4))
  • ​ 2、创建一个全1的数组:np.ones((3,4))
  • ​ 3、创建一个对角线为1的正方形数组(方阵)：np.eye(3)
  • ​ 4、随机数创建数组，见下一部分 （6）numpy生成随机数

(3) 数组的属性

​ a.ndim #数组维度

​ a.shape) #数组形状

​ a.itemsize #数组每个元素大小

2.常用数据类型

1. NumPy支持的数值类型

符号 含义
bool True和Flase
inti 支持int的32或64位
int8 8位的整形(-128~127)
int16 -32768~32767
int32 -2 ** 31 ~ 2 ** 31 - 1
int64 -2 ** 63 ~ 2 ** 63 - 1
uint8 8位的整形(0~255)
uint16 -32768~32767
uint32 0 ~ 2 ** 32 - 1
uint64 0 ~ 2 ** 64 - 1
float16 1位符号位，5位指数位，10位
float32 1位符号位，8位指数位，23位
float64、float 1位符号位，11位指数位，52位

另一种描述数据的类型的方式是用一个字符来描述使用的NumPy的数值数据的类型，例如’i’字符代表有符号整形数据，’f’代表浮点型数据，可以通过sctypeDict.keys()查看NumPy里支持的所有数据类型。

2.查看多维数组的数据类型

​ arr1.dtype

​ 定义bool类型

​ bs = np.array([1, 1, 0, 1, 0], dtype=bool)

3.数据类型转换

​ 数组名.astype(numpy.数据类型),返回数组, 需要接收后才会改变

​ 方法1: arr1= arr1.astype(“i2”)

​ 方法2: arr1= arr1.astype(np.int8) 浮点和字符串需末尾加下滑线 (a = a.astype(dtype=np.float_)) 或 np.s _

​ 方法3: int8(34.5) 34.5转为8位整形，即1字节

​ bool(34.5) 34.5转为即为True或False

​ 小结: 对于每种类型都有同名的转换函数可以将数据转为某种数据类型的数据。

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
#查看多维数组的数据类型
arr1.dtype

#numpy中的bool类型
bs = np.array([1, 1, 0, 1, 0], dtype=bool)

#修改数据类型 ,返回数组, 需要接收后才会改变
arr1= arr1.astype("i2")   或np.int8
 
#特别的，修改小数的位数
np.round(arr1,2) #保留两位小数   python中也是如：round(random.random(),2) 随机产生一个0-1之间的小数，保留两位

#numpy中的小数类型  
#生成10个随机小数 ,保留两位小数  random.random()0~1之间的小数
rs = np.array([random.random() for i in range(10)])
print(rs.dtype)
np_round = np.round(rs, 2)
print(np_round)

PS:
    type(数组)
 
    结果：
    numpy.ndarray
    type(数组) numpy中多维数组的对象类型是 numpy.ndarray 即numpy多维数组   
    数组.dtype 数据的数据类型

3.多维数组形状

  1. 查看数组的形状

    语法: a.shape

  2. 修改数组的形状

    方法1: a.reshape(5,2) – 5是行, 2是列

    方法2: a.resize (3，4) –表示将arr数组修改成3行4列数组，原数组a形状改变

  3. 输出 a.shape 问题: 为何修改后,仍然是原来的形状?使用b接收

  4. 把数组转为1维数组

    方法1:a.reshape(1,10)

    方法2:a.flatten()

    方法3:a.reshape(a.shape[0] * a.shape[1], )

    方法4: a.ravel()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
e = np.array([ [[1,2,3,4,5],[6,7,8,9,10]],[[1,2,3,4,5],[6,7,8,9,10]] ])
 
#查看多维数组形状
print(a.shape)
print(e.shape)
 
#改变多维数组形状
a.reshape(5,2)
 
结果：
 
(10,)      一维数组的shape 一个数
(2, 5)     二维数组的shape 二个数
(5, 2, 2)  三维数组的shape 三个数，2 块  5行2列的
                                 0轴（维）是5, 1轴（维）是2, 2轴（维）是2

注意：
d.reshape reshape操作是有返回值的，需要有一个对象去接收改变后的多维数组。一般有返回值的操作都不改变原对象d。

PS:多维数组的轴（维度）

在numpy中轴(axis)可以理解为方向,使用0,1,2…数字表示,

对于一个一维数组,只有一个0轴, 对于2维数组(shape(2,2)),有0轴和1轴, 对于三维数组(shape(2,2, 3)),有0,1,2轴

4.多维数组计算

​ 1. 数组与数字： 如 a+1,a-1,a*3,a/2， “广播” - 将标量”广播”运算到到各个元素 (a / 0不报错 nan 表示不是一个数字, inf无限的)

  1. 数组与数组（同形状）：对应位置运算
  2. 数组与数组（不同形状）：只要在某一维度，如行或列相同，就在该维度计算，否则不能计算

​ 例如二维数组: 2行5列 , 一维数组可以是5列 , 或者二维数组 : 2行1列

​ a1 =np.array([[1,2,3,4,5],[6,7,8,9,10]])

​ a2 = np.arange(5) 一维数组0,1,2,3,4一个维度一致

​ a1+a2就可以进行计算

​ a3 = np.arange(2).reshape(2, 1) a1+a3就可以进行计算

​ 这是一个numpy的广播机制造成的,在运算过程中,加减乘除的值被广播到所有的元素上.

5.广播原则

  1. 如果两个数组的后缘维度(trailing dimension ,即从末尾开始算起的维度) 的轴长度相符或其中一方的长度为1,则认为他们是广播兼容的.广播会在缺失和(或)长度为1的维度上进行.
  2. 原理: 可以把维度指shape所对应的数字个数.
  3. shape为(3,3,3)的数组是否能够和(3,2)的数组进行计算?
  4. shape为(3,3,2)的数组是否能够和(3,2)的数组进行计算?
  5. 广播优点: 例如每列的数据减去列的平均值的结果.

6.多维数组的轴（维度）

​ 在numpy中轴(axis)可以理解为方向,使用0,1,2…数字表示,

​ 对于一个一维数组,只有一个0轴, 对于2维数组(shape(2,2)),有0轴和1轴, 对于三维数组(shape(2,2, 3)),有0,1,2轴.

​ 二维数组 0轴横轴，1轴是纵轴.

​ shape=(2, 2, 5), 即：0轴=2； 1轴=2； 2轴=5 ；即2块，2行，2列的多维数组 (见ppt的图)

7.数组的索引和切片

(1) 一维数组的索引与切片

​ 1.获取指定元素 语法:数组名[索引（下标）] a[3]

​ 2.数组的切片 语法:数组名[start : end : step] a[2:10:2]

(2) 二维数组的索引与切片

​ 1. 获取指定元素 语法:数组名[行索引,列索引] a[1 , 1]

​ 2. 数组的切片 语法:数组名[rows_start:rows_end:rows_step，cols_start:cols_end:cols_step]

​ a[1 : 2 , 0: 1]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
取一行  a[1]
取多行  a[1:3]
取连续多行  a[2:]
取不连续多行 a[[0,2]]

取一列  a[:,2] 第3列
取多列 a[:, 1:3]
	print(a[1,:]) #第2行所有列
	print(a[1: , :]) #第2至结尾行所有列
	print(a[[0,2],:]) #第1和3行所有列
	print(a[: , 0]) #所有行的第1列
取连续的多列 a[: , 1:]
取不连续的多列 a[: , [0,2]]
取多行多列 第1到2,  第1-2列   print(a[0:2, 0:2])

列使用冒号?   a[[1:3],:]  超出范围,则最多取到最后一列  a[:, 1:6]
取多个不相邻的点 (选择的点是(1,1)  (2,2))
a[[1,2] , [1,2]]

(3) numpy中数值的修改

1
2
3
#数值的修改
a2[:, 0:2] = 0
print(a2)

如果希望将小于10的数字替换为0?

(4)numpy中布尔索引

1
2
3
4
5
6
7
8
9
10
#小于10的替换为0
a3 = np.array([[1,2,3,4,5,6],[7,8,9,10,11,12]])
print(a3<10)
a3[a3<10] = 0
print(a3)
#小于10的替换为0, 大于10的换成10
a4 = np.array([[1,2,3,4,5,6],[7,8,9,10,11,12]])
print(np.where(a4<10,0,10)) #三元运算符
#特殊情况, nan类型,判断结果不相等
print(np.nan == np.nan)

8.numpy 转置和轴对换：

​ 1.转置是一种变换,对于numpy中的数组来说,就是在对角线方向交换数据.目的也是未了更方便的去处理数据.

​ 2.方法1: a.transpose() 行和列互换 ,原来的数组从2行3列,变为3行2列.

​ 3.方法2: a.swapaxes(1,0) 交换轴

​ 4.方法3: a.T

​ 5.方法4: np rollaxis(arr,axis,start )函数 arr表示数组，axis表示要向后滚动的轴，其它轴的相对位置不会改变，start表示滚动到特定位置，默认为零，表示完整的滚动

​ 转换和交换轴的效果一样.

1
2
3
4
5
6
7
8
9
 a 是二维数组

         a.transpose()

         a.swapaxes(1,0)  # 交换轴，也能实现转置

         a.T

以上三种方法都能实现转置

9.numpy常用方法

(1)数组的连接

1.concatenate连接NumPy数组

​ 连接意味着将两个或多个数组的内容放在单个数组中。

​ 在SQL中，我们基于键联接表，而在NumPy中，我们按轴联接数组。

​ 我们传递了一系列要与轴一起加入concatenate()函数的数组。 如果未显式传递轴，则将其视为0。

​ 例如：

​ 连接两个数组

1
2
3
4
5
6
7
8
9
import numpy as np

arr1 = np.array([4, 2, 3])

arr2 = np.array([4, 7, 6])

arr = np.concatenate((arr1, arr2))

print(arr)

上面代码运行的成果：[4 2 3 4 7 6]

例如：

沿行（axis=1）联接两个二维数组：

1
2
3
4
5
6
7
arr1 = np.array([[1, 7], [3, 4]])

arr2 = np.array([[5, 9], [2, 8]])

arr = np.concatenate((arr1, arr2), axis=1)

print(arr)

上面代码运行的成果：

1
2
[[1 7 5 9]
 [3 4 2 8]]

2.使用stack()函数连接数组

stack()与concatenate()相同，唯一的不同是stack()是沿着新轴完成的。

我们可以沿着第二个轴连接两个一维数组，这将导致它们一个放在另一个之上。

我们传递一个要连接到stack()方法的数组序列和axis。如果axis没有显式传递，则将其视为0。

例如：

1
2
3
4
5
6
7
8
9
import numpy as np

arr1 = np.array([1, 7, 3])

arr2 = np.array([4, 8, 6])

arr = np.stack((arr1, arr2), axis=1)

print(arr)

上面代码运行的成果：

1
2
3
[[1 4]
 [7 8]
 [3 6]]

3、使用hstack()通过行

NumPy提供了一个辅助函数：hstack()沿行堆叠。

例如：

1
2
3
4
5
6
7
8
9
import numpy as np

arr1 = np.array([1, 77, 31])

arr2 = np.array([4, 88, 61])

arr = np.hstack((arr1, arr2))

print(arr)

上面代码运行的成果：

1
[ 1 77 31  4 88 61]

4、使用vstack()通过列

NumPy提供了一个辅助函数：vstack()沿列堆叠。

例如：

1
2
3
4
5
6
7
8
9
import numpy as np

arr1 = np.array([11, 12, 3])

arr2 = np.array([41, 5, 16])

arr = np.vstack((arr1, arr2))

print(arr)

上面代码运行的成果：

1
2
[[11 12  3]
 [41  5 16]]

5、使用dstack()通过Height (depth)

NumPy提供了一个辅助函数：dstack()沿高度进行堆叠，该高度与深度相同。

例如：

1
2
3
4
5
6
7
8
9
import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.dstack((arr1, arr2))

print(arr)

上面代码运行的成果：

1
2
3
[[[1 4]
  [2 5]
  [3 6]]]

(2)数组的分割

1. split()函数

​ 沿特定的轴将数组分割为子数组

​ 语法: numpy.split(arr,indices_or_sections,axis)

​ indices_or_sections表示将arr数组创建为大小相同的子数组的数量

1
2
3
4
5
6
7
8
#对1维数组分割 按指定位置分割,2,5位置
sp1 = np.array([  1,2,3,4,5,6])
# print(np.split(sp1,[2,5]))
sp2 = np.array([  [1,2,3] , [4,5,6]])
#将数组分割为2个大小相同的子数组
print(np.split(sp2, 2))
#3个2维数组  结果: [[1],[4]]    [[2],[5]]   [[3],[6]]
print(np.split(sp2, 3 , 1 ))

2.hsplit()函数

​ 将数组沿着水平方向分割

​ 语法:numpy.hsplit(arr,indices_or_sections)

3.vsplit()函数

​ 将数组沿着竖直方向分割

​ 语法: numpy.vsplit(arr,indices_or_sections)

1
2
3
4
5
#hsplit()函数  沿着水平方向分割 结果3个数组 [[1],[4]]    [[2],[5]]   [[3],[6]]
print(sp2)
print(np.hsplit(sp2,3)) 
#vsplit()函数  沿着垂直方向分割 结果2个数组 [[1, 2, 3]]   [[4, 5, 6]]
print(np.vsplit(sp2,2))

(3)数组转换

​ 数组名.tolist() 将数组转换成列表

(4)添加删除数组元素

1. append()函数

​ 数组的末尾添加元素，该函数会返回一个新数组，而原数组不变。

​ 方法：numpy.append(arr,values,axis)

1
2
3
4
5
6
7
8
9
10
#一维数组追加
a = np.array([  1,2,3,4,5,6])
# a = np.append(a,[0,0,0])
a1 = np.array([[1,2,3],[4,5,6]])
#二维数组追加二维数组
a1 = np.append(a1,[[7,8],[9,10]])
#沿0轴添加  [[ 1  2  3]  [ 4  5  6]  [ 7  8  9] [10 11 12]]
print(np.append(a1,[[7,8,9],[10,11,12]],axis=0))
#沿1轴添加  [[ 1  2  3  7  8  9]   [ 4  5  6 10 11 12]]
print(np.append(a1,[[7,8,9],[10,11,12]],axis=1))
1
2
3
4
5
6
7
8
#沿0轴添加运行结果
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
 #沿1轴添加运行结果
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

2.insert()函数

​ 沿给定轴在输入数组中插入值,该函数会返回一个新数组，原数组不变。

​ 方法：numpy.insert(arr,obj,values,axis)

1
2
3
4
5
6
7
8
#一维数组插入
# print(np.insert(a,2,[111,222]))
#二维数组插入 会被展开后插入
print(np.insert(a1,2,[111,222]))
#加入axis=0, 则会以广播数组来匹配输入数组  插入值[0,0,0]
print(np.insert(a1,2,[0],axis=0))
#加入axis=1, 则会以广播数组来匹配输入数组  插入值[[0],[0]]
print(np.insert(a1,2,[0],axis=1))
1
2
3
4
5
6
7
8
9
#二维数组插入 会被展开后插入运行结果
[  1   2 111 222   3   4   5   6]
#加入axis=0运行结果
[[1 2 3]
 [4 5 6]
 [0 0 0]]
#加入axis=1运行结果
[[1 2 0 3]
 [4 5 0 6]]

3.delete()函数

​ 从输入数组中删除指定子数组的新数组，原数组不变。

​ 方法：numpy.delete(arr,obj,axis)

1
2
3
4
5
6
7
8
9
delete()函数  删除前会被展开,删除指定索引的元素
a2 = np.array([[1,2,3],[4,5,6]])
print(np.delete(a2,[2,4]))
#删除第3列 结果 [[1 2]  [4 5]]
print(np.delete(a2,2,axis=1))
#删除第1行  结果[[4 5 6]]
print(np.delete(a2,0,axis=0))
#删除切片范围  展开后切片  结果[4 5 6]
print(np.delete(a2, np.s_[0:3]))

10.通用函数

(1)常见的一元函数

函数 说明
abs、fabs 计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs
sqrt 计算各元素的平方根，相当于arr ** 0.5
square 计算个元素的平方，
exp 计算各元素的指数
log、log10、log2、log1p 分别计算自然对数（底数为e）、底数为10的对数、底数为2的对数、底数为1+x的对数
sign 计算各元素的正负号：1（整数）、0（零）、-1（负数）
ceil 计算各元素的ceiling值，即大于等于该值的最小整数
floor 计算各元素的floor值，即小于等于该值的最大整数
rint 将各元素的值四舍五入到最接近的整数，保留dtype
modf 将数组各元素的小数和整数部分以两个独立的数组的形式返回
isnan 返回一个表示“哪些值是NaN（Not a Number）”的布尔型数组
isfinite、isinf 分别返回一个表示“哪些元素是有穷的”或“哪些元素是无穷的”的布尔型数组
cos、cosh、sin、sinh、tan、tanh 普通型和双曲型三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh 普通型和双曲型反三角函数
logical_not 计算各元素not x的真值 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#通用函数
#常用一元函数
arr = np.arange(10)
# print(arr)
#arr数组的平方根
arr1 = np.sqrt(arr)
print(arr1)
#每个数字+2
# print(np.add(arr,2))
#分解数组的浮点数为整数和小数部分
# print(np.modf(arr1))
#比较两个数组大小  结果[3 4 5]
arr2 = np.arange(3)
arr3 = np.arange(3,6)
print(np.maximum(arr2,arr3))
#计算矢量积和数量积
arr4 = np.arange(6).reshape(2,3)
arr5 = np.arange(3)
arr6 = np.arange(3)
print(arr4)
print(arr5)
print("矢量积",np.dot(arr6,arr5))#dot数组中对应元素相除
print("数量积",arr4*arr5)

(2)常见的二元函数

函数 说明
add 将数组中对应的元素相加
subtract 第一个数组减去第二个数组
multiply 数组元素相乘
divide、floor_divide 除法、向下整除法（丢弃余数）
power 对第一个数组中的元素A，根据第二个数组中的元素B，计算
maximum、fmax 元素级的最大值计算，fmax将忽略NaN
minimum、fmin 元素级的最小值计算，fmin将忽略NaN
mod 元素级的取模计算
copysign 将第二个数组各元素值的符号复制给第一个数组中各元素
greater、greater_equal、less、less_equal、equal、not_equal 执行元素级的比较运算，最终产生布尔型数组
logical_and、logical_or、logical_xor 执行元素级真值逻辑运算

11. NumPy矩阵创建、计算及操作

1. 矩阵的创建

​ 使用mat()、matrix()以及bmat()函数创建矩阵

(1) 使用字符串创建矩阵

​ 字符串以空格分隔列

​ 语法:numpy.mat(‘1 2 3;4 5 6;7 8 9’)

(2) 使用嵌套序列创建矩阵

​ 语法:numpy.mat([[2,4,6,8],[1.0,3,5,7.0]]) 浮点数

(3) 使用一个数组创建矩阵

​ 语法:numpy.mat(numpy.arange(9).reshape(3,3))

(4) 使用matrix()函数创建矩阵

​ matrix()函数可以将字符串、嵌套序列、数组和matrix转换成矩阵。

​ 语法:matrix(data,dtype=None,copy=True)

(5) 使用bmat()函数创建矩阵

​ 小矩阵组合成大矩阵使用bmat分块

​ 语法:： bmat(obj,ldict=None,gdict=None) obj为matrix。参数ldict和gdict为None

​ 

1
2
3
4
5
6
7
8
9
#NumPy矩阵创建
# （1） 使用字符串创建矩阵 numpy.mat(‘1 2 3;4 5 6;7 8 9’)
m = np.mat('1 2;3 4;5 6')
m1 = np.mat([[2, 4, 6, 8], [1.0, 3, 5, 7.0]]) #使用嵌套序列创建矩阵
m2 = np.mat(np.arange(9).reshape(3, 3))#使用一个数组创建矩阵
m3 = np.matrix('1 2;3 4;5 6', dtype=np.int8,copy=True) #使用matrix()函数创建矩阵
m4 = np.mat('1 1 1;2 2 2')
m5 = np.mat('3 3 3;4 4 4')
print(np.bmat('m4 m5;m5 m4')) #使用bmat()函数创建矩阵

2. 矩阵的计算及操作

​ 针对整个矩阵中的每个元素进行的，不需要使用for循环，而且运算效率更高

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#矩阵计算
m7 = np.mat([[2, 4, 6, 8], [1.0, 3, 5, 7.0]])
m8 = np.mat(np.arange(8).reshape(2, 4))
m9 = np.mat(np.arange(9).reshape(3, 3))
#不同形状会报错
# print(m7+m8)#相同形状可以运算:+ - /
#矩阵相乘 矢量积操作
print(m7,m8.T)
print("矢量积",m7*m8.T)
#使用函数 multiply  计算数量积
print("数量积",np.multiply(m7,m8))
#矩阵操作  取矩阵的行数
print(m7.shape[1])
#排序
m7.sort()
print(m7)
#列表转np矩阵
list = [1,2,3]
np.mat(list)

12. 随机数生成

1.使用rand()函数

​ [0, 1)内均匀分布的随机数(不包括1) 若没有参数输入，则生成一个数

​ 语法:numpy.random.rand(d0, d1, …, dn) 

1
2
3
4
# 1.   使用rand()函数numpy.random.rand(d0, d1, ..., dn)
r = np.random.rand() #一个数 0~1之间
r1 = np.random.rand(1) #一行一列数组
r2 = np.random.rand(2,3) #2行3列数组

2.randn()函数

​ 生成一个(d0, d1, …, dn)维的数组，数组的元素是标准正太分布随机数

​ 语法:numpy.random.randn(d0, d1, …, dn)

1
2
3
4
#2.   randn()函数  numpy.random.randn(d0, d1, ..., dn)
rn1 = np.random.randn()#一个数 0~1之间
rn2 = np.random.randn(1)#一行一列数组
rn3 = np.random.randn(2,3)#2行3列数组

3. randint()函数

​ 生成指定范围的随机数，随机数取值区间为[low, high)，若没有输入参数high则取值区间为[0, low)

​ 语法:numpy.random.randint(low [, high, size, dtype])

1
2
3
4
5
#3. randint()函数  numpy.random.randint(low [, high, size, dtype])
rt1 = np.random.randint(3) #0~2的整数
rt2 = np.random.randint(3,size=1) #0~2的整数, 大小为1行一列的数组
rt3 = np.random.randint(3,size=(2,3),dtype='int64') #0~2的整数, 大小为2行3列的数组
# print(rt3)

4.random()函数

​ 产生[0.0, 1.0)之间的浮点数，但数组的元素不包括1

​ 语法:numpy.random.random(size=None)

1
2
3
4
#4.用random()生成随机数
random = np.random.random()  #1个随机数
random1 = np.random.random(5)  #5个随机数数组
# print(random)