numpy

介绍

numpy用于处理大数组的数据,并进行数值运算

numpy是在一个连续的内存块中存储数据,独立于其他python内置对象。numpy的C语言编写的算法库可以操作内存,而不必进行类型检查或其它前期工作。比起python的内置序列,numpy数组使用的内存更更少。

numpy可以在整个数组上执行复杂的计算,而不需要python的for循环

基于numpy的算法比纯python快10-100倍,并且内存使用的更少

直接使用pip install numpy进行安装, 并且通常我们使用import numpy as np进行别名使用

ndarray多维数组对象

即n维数组对象

数组创建

随机二维数组和多维数组

几个参数就是几维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 二维数组
In [5]: a = np.random.randn(2,3)

In [6]: a
Out[6]:
array([[ 0.40782246, 1.01188141, -0.72254947],
[-0.33912128, -0.83395203, -0.62968705]])

In [8]: type(a)
Out[8]: numpy.ndarray

# 三维数组
In [10]: np.random.randn(2,3,2)
Out[10]:
array([[[ 0.06468234, 1.35577864],
[ 0.65733334, 0.76170521],
[ 1.14480233, -0.02904135]],

[[-0.32580275, -0.97027343],
[-1.09083706, 2.13423053],
[ 0.27216318, 1.01170855]]])

自定义多维数组

1
2
3
4
5
6
7
8
In [14]: data1 = [[1,2,3],[4,5,6]]

In [15]: array1 = np.array(data1)

In [16]: array1
Out[16]:
array([[1, 2, 3],
[4, 5, 6]])

相关属性

取维度大小和内容

1
2
3
4
5
6
# 维度大小
In [20]: array1.ndim
Out[20]: 2
# 维度内容
In [21]: array1.shape
Out[21]: (2, 3)

取数据类型

1
2
3
# 取数据类型
In [22]: array1.dtype
Out[22]: dtype('int32')

全1数组ones

根据指定的形状和dtype创建一个全1数组;

ones_like以一个数组为参数,创建一个形状和dtype相同全为1的数组

1
2
3
4
5
6
7
8
9
10
# 三维全1
In [25]: np.ones((2,3,2))
Out[25]:
array([[[1., 1.],
[1., 1.],
[1., 1.]],

[[1., 1.],
[1., 1.],
[1., 1.]]])

全0数组zeros

根据指定的形状和dtype创建一个全0数组;

ones_like以一个数组为参数,创建一个形状和dtype相同全为0的数组

1
2
3
4
5
# 二维全0
In [26]: np.zeros((2,3))
Out[26]:
array([[0., 0., 0.],
[0., 0., 0.]])

无具体值empty

创建新数组,只分配空间不填充任何值,一维参数为int,多维参数是一个元祖

对应empty_like方法,以另一个数组为参数,并根据它的形状和dtype创建创建一个数组

1
2
3
4
5
# np.empty 返回上得是没有初始化的垃圾值
In [28]: np.empty((2,3))
Out[28]:
array([[0., 0., 0.],
[0., 0., 0.]])

全x数组full

根据指定的形状和dtype,创建一个全为填充值x的数组

full_like参数为数组,如上

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

c = np.full_like(b, 2)
array([[2, 2, 2],
[2, 2, 2]])

指定类型dtype和类型转换astype

1
2
3
4
5
6
7
8
9
10
11
12
In [44]: a = np.array([1,2,3,4,5], dtype=np.int32)

In [45]: a
Out[45]: array([1, 2, 3, 4, 5])

In [46]: a.dtype
Out[46]: dtype('int32')

In [47]: a1 = a.astype(np.int64)

In [48]: a1.dtype
Out[48]: dtype('int64')

创建单位矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# N * N的单位矩阵(对角线为1 其余为0)
In [50]: a = np.eye(4)

In [51]: a
Out[51]:
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])

In [52]: b = np.identity(4)

In [53]: b
Out[53]:
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])

数组运算

大小相同的数组之间的任何算数运算会将运算进行的元素级上

大小相同数组与标量运算

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

In [54]: array1 = np.array([[1,2,3],[4,5,6]])

In [55]: array1
Out[55]:
array([[1, 2, 3],
[4, 5, 6]])
# 加
In [56]: array1 + array1
Out[56]:
array([[ 2, 4, 6],
[ 8, 10, 12]])
# 减
In [57]: array1 - array1
Out[57]:
array([[0, 0, 0],
[0, 0, 0]])
# 乘
In [58]: array1 * array1
Out[58]:
array([[ 1, 4, 9],
[16, 25, 36]])
# 除
In [59]: 1 / array1
Out[59]:
array([[1. , 0.5 , 0.33333333],
[0.25 , 0.2 , 0.16666667]])
# 乘方
In [60]: array1**2
Out[60]:
array([[ 1, 4, 9],
[16, 25, 36]], dtype=int32)
# 整除
In [61]: array1 // 2
Out[61]:
array([[0, 1, 1],
[2, 2, 3]], dtype=int32)
# 取余
In [62]: array1 % 2
Out[62]:
array([[1, 0, 1],
[0, 1, 0]], dtype=int32)
# 布尔
In [63]: array2 = [[1,5,2],[1,4,2]]

In [64]: array1 > array2
Out[64]:
array([[False, False, True],
[ True, True, True]])

索引与切片

切片规则与列表相同

shape的看法: 从左到右,维数减少;数值的多少表示该维度下有几个元素(数组)

切片的使用也可以对应shape

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
In [65]: array1 = np.array([1,2,3,4,5,6])

In [67]: array1[1:5]
Out[67]: array([2, 3, 4, 5])
# 切片会给数组的对应的索引位置全部赋值
In [68]: array1[2:5] = 100

In [69]: array1
Out[69]: array([ 1, 2, 100, 100, 100, 6]
# 对多维数组
In [70]: array2 = np.array([[1,2,3],[4,5,6],[7,8,9]])

In [71]: array2[:2]
Out[71]:
array([[1, 2, 3],
[4, 5, 6]])
# 两种方式一样
In [72]: array2[1,2]
Out[72]: 6

In [73]: array2[1][2]
Out[73]: 6
# 进行多个切片
In [74]: array2[:2,:2]
Out[74]:
array([[1, 2],
[4, 5]])
# 只有'冒号'时, 选取整个轴
In [75]: array2[:,1]
Out[75]: array([2, 5, 8])

布尔型索引

分别使用 & | ~ 表示与或非得关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = np.array([ False,  True,  True,  False])
b = np.random.randn(4,5)
array([[-0.99938879, -0.0535668 , -0.16032889, 1.08049267, 0.35588453],
[-0.28420901, 1.05329939, -1.35097747, 0.41424505, 0.42079163],
[ 0.24882717, -1.14601162, 0.51924268, -1.26684902, 1.54417874],
[ 0.34665976, 0.28197566, -1.10021705, -0.39085565, -0.25763008]])
# 注意两组数组中的行数应该相同
b[a==True]
array([[-0.28420901, 1.05329939, -1.35097747, 0.41424505, 0.42079163],
[ 0.24882717, -1.14601162, 0.51924268, -1.26684902, 1.54417874]])

# 使用非关系
b[~a==True]
array([[ 2.10217141, 1.8107804 , 0.1177351 , -0.7263583 , -0.74179261],
[-1.3267273 , -0.05289648, 0.42071815, -0.29748229, -1.39459566]])

花式索引

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
# fancy indexing 指利用整数数组进行索引
# 指定一个由32位整数组成的二维8行4列的数组
In [23]: array1 = np.arange(32).reshape(8,4)

In [24]: array1
Out[24]:
array([[ 0, 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]])
# 花式索引
In [25]: array1[[1,4,6]]
Out[25]:
array([[ 4, 5, 6, 7],
[16, 17, 18, 19],
[24, 25, 26, 27]])

# 重新指定数组的形状
In [26]: array1.reshape(4,8)
Out[26]:
array([[ 0, 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]])
# 也可以使用负数索引
In [27]: array1[[-1,-4,-6]]
Out[27]:
array([[28, 29, 30, 31],
[16, 17, 18, 19],
[ 8, 9, 10, 11]])
# 取指定位置的元素
# 选择出的是(1,1), (4,3), (6,2)位置的元素
# 注意使用花式索引选用具体的值时, 两边索引个数必须相等,此处都是3个索引
In [41]: array1[[1,4,6],[1,3,2]]
Out[41]: array([ 5, 19, 26])
# 取索引后 也可以再次取索引
In [45]: array1[[1,4,6]][[0,1,2],[1,3,2]]
Out[45]: array([ 5, 19, 26])

转置矩阵

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
# 行变列 列变行
In [49]: array1 = np.arange(12).reshape(4,3)

In [50]: array1
Out[50]:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
# 转置方法1 T方法 适用于一维和二维
In [51]: array1.T
Out[51]:
array([[ 0, 3, 6, 9],
[ 1, 4, 7, 10],
[ 2, 5, 8, 11]])
# 矩阵内积
# 矩阵a和它的转置矩阵aT 索引轴上所有数据对应乘所得到的
# 如 (0,0) 0*0+1*1+2*2=5 (2,3) 6*9+7*10+8*11=212
In [52]: np.dot(array1, array1.T)
Out[52]:
array([[ 5, 14, 23, 32],
[ 14, 50, 86, 122],
[ 23, 86, 149, 212],
[ 32, 122, 212, 302]])

# 转置方法2 transpose方法
# 注意tranpose方法 与shape相关 如array2.shape -> (2,2,4) -- (0,1,2)
# 如整数6 其索引是(0,1,2) 若transpose(1,0,2) 整数6通过变化位置的索引就变成(1,0,2) 也就是转置后的位置
In [60]: array2 = np.arange(16).reshape(2,2,4)

In [61]: array2.shape
Out[61]: (2, 2, 4)

In [62]: array2
Out[62]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],

[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])

In [63]: array2.transpose(1,0,2)
Out[63]:
array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],

[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])
# 转置方法3 swapaxes方法
# swapaxes使用的轴的变化 与shape有关 array2.shape -> (2,2,4) -->shape标号(0,1,2)
# 如下swapaxes(1,0) 就将shape中0代表的轴和1代表轴交换位置
# 举例: 整数6(0,1,2) 交换0轴1轴 即(1,0,2)
# 同时 swapaxes的参数是两个整数, 并且位置无关(1,0)和(0,1)作用一样
In [73]: array2.swapaxes(1,0)
Out[73]:
array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],

[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])

通用函数

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

In [76]: array1 = np.arange(10)

In [77]: array1
Out[77]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 开根(0.5次方)
In [78]: np.sqrt(array1)
Out[78]:
array([0. , 1. , 1.41421356, 1.73205081, 2. ,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])
# 以e为底的指数函数
In [79]: np.exp(array1)
Out[79]:
array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,
5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,
2.98095799e+03, 8.10308393e+03])

In [80]: arr1 = np.random.randint(5)

In [81]: arr1
Out[81]: 1

In [82]: arr1 = np.random.randn(5)

In [83]: arr1
Out[83]: array([-0.44545786, -1.97082844, 0.5864768 , -0.58903824, 0.69115051]
)

In [84]: arr2 = np.random.randn(5)

In [85]: arr2
Out[85]: array([-1.13874562, -0.30752957, -0.80933734, 0.37003582, 0.54560881]
)
# maxinum将两个ndarray进行找最大值操作
In [86]: np.maximum(arr1, arr2)
Out[86]: array([-0.44545786, -0.30752957, 0.5864768 , 0.37003582, 0.69115051]
)
# 返回浮点数数组中的小数 整数部分
In [92]: decimal, integer = np.modf(arr1)

In [93]: decimal
Out[93]: array([-0.44545786, -0.97082844, 0.5864768 , -0.58903824, 0.69115051]
)

In [94]: integer
Out[94]: array([-0., -1., 0., -0., 0.])

逻辑判断where

1
2
3
4
5
6
7
8
9
10
# where 将数组arr1中大于0变成True, 否则变成False
In [108]: arr1
Out[108]: array([-0.44545786, -1.97082844, 0.5864768 , -0.58903824, 0.69115051
])

In [109]: np.where(arr1>0, True, False)
Out[109]: array([False, False, True, False, True])
# where 将数组arr1中大于0变成True, 否则保持arr1中值不变(True变成了1)
In [110]: np.where(arr1>0, True, arr1)
Out[110]: array([-0.44545786, -1.97082844, 1. , -0.58903824, 1.]

数学运算和统计

mean sum std cumsum

cumprod any all unique

in1d intersect1d setdiff1d union1d

axis为0求列,axis为1求行

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
In [112]: array2
Out[112]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],

[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
# 求整个数组平均值
# mean(1) 即mean(axis=1)计算每行的平均值
In [113]: array2.mean()
Out[113]: 7.5
# 求整个数组和
# sum(0) 即sum(axis=0)计算每列的和
In [114]: array2.sum()
Out[114]: 120
# 求方差-各数据与平均值的差的平方和的平均数(数值越大波动越大,越不稳定) std
# 求累计和-当前元素与前面所有元素的和 cumsum()
a = np.arange(9)
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
a.cumsum()
array([ 0, 1, 3, 6, 10, 15, 21, 28, 36], dtype=int32)
# 求累积积-当前元素与前面所有元素的和 cumprod()
a[1:].cumprod()
array([ 1, 2, 6, 24, 120, 720, 5040, 40320],
dtype=int32)
# 判断存在True any()
# 判断全部为True all()
# 排序函数-默认是快速排序 sort()
# 去重 unique()
c = np.full_like(a, 5)
array([5, 5, 5], dtype=object)
np.unique(c)
array([5], dtype=object)
# 测试一个数组的元素在另一个数组的是否出现 in1d()
d = np.array([1,2,3,2,5,1])
np.in1d(d, [1,3])
array([ True, False, True, False, False, True])
# 求交集 intersect1d()
# 求并集 union1d()
# 求差集 setdiff1d(x, y) 元素在x中不在y中

随机函数

np.random.x

rand 生成均匀分布的伪随机数(分布在[0,1)之间)

rand(2,3) –> 生成分布在[0,1)之间的两行三列的随机数

uniform 生成均匀分布的伪随机数(在[0,1)之间)

uniform(2,3) –> 生成在[2,3)之间的伪随机数

randn 生成标准正态分布的伪随机数(均值为0,方差为1)

randint 给定范围内取随机整数

shuffle 对一个序列进行随机排列操作

permutation 返回一个序列的随机排列

normal产生正态分布的样本值

关键词

1
2
3
4
5
6
array	random	ones	ones_like	zeros	zeros_like	
empty empty_like full full_like dtype astype
shape reshape T dot transpose swapaxes
maximum modf where mean sum std
cumsum cumprod any all unique in1d
intersect1d setdiff1d union1d
-------------end-------------
0%