numpy

numpy

0、作用

使用numpy&pandas使得数据分析中计算非常快,比python自带的字典和列表快很多,因为这俩模块使用C语言编写的。应用到了矩阵的运算,使用C语言实现,更快。

1、安装

直接在终端使用命令

1
pip install numpy

安装完成即可

2、numpy基本属性

基本属性包括:将列表转换为numpy的array,查看array的维度、形状、总元素个数

1
2
3
4
5
6
7
8
9
10
import numpy as np #一般习惯重命名为np
# 将列表转换为numpy的矩阵
array = np.array([[1,2,3],[2,3,4]])
print(array)
# 维度
print('number of dimation: ',array.ndim)
# 形状
print('shape:',array.shape)
# 总共多少个元素在矩阵中
print('size:',array.size)

3、创建

创建的方法有:

  1. 直接传入列表
  2. 通过zeros()方法生成全为0的矩阵
  3. 通过ones()方法生成全为1的矩阵
  4. 通过empty()方法生成全为0的矩阵
  5. 通过arange()方法生成有序array
  6. 使用reshape指定形状,注意,元素个数可以变成指定的形状否则报错
  7. linspace分段
  8. 使用random模块,生成随机的。随机数位于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
import numpy as np
# 1,直接传入列表,使用的type指定数据类型,比如float32,几位数字需要根据精度需求来确定
# 位数越大,精度越高但同时占用空间越大
a = np.array([[2,3,4],[3,4,5]],dtype=np.float32)
# 打印出来,和列表的差别就是,没有逗号
print(a)
print(a.dtype)

# 2,直接生成全部为0的矩阵,需要在参数中传入形状(用一个括号包着)
# 如果不指定数据类型,zeros默认为float64
b = np.zeros((3,4))
print(b)
# 同理,生成全为1的,使用ones方法即可
b = np.ones((4,5),dtype=np.int16)
print(b)

# 3,empty,相当于生成全为0的
c = np.empty((3,4))
print(c)

# 4,生成有序,和python中的arange相同,指定区间(左闭右开),指定步长
# 步长为2,10到20之间
c = np.arange(10,21,2)
print(c)

# 5,使用reshape指定形状,注意,元素个数可以变成指定的形状否则报错
c = np.arange(12).reshape((3,4))
print(c)

# 6,linspace分段,在闭区间1到10中生成5个点,平均分成4段
a = np.linspace(0,10,5)
print(a)

# 7、使用random模块,生成随机的。随机数位于0到1之间
a = np.random.random((2,4))
print(a)

4、运算

  1. 加法、减法、指数运算、三角函数运算、布尔值运算。都是对每个元素都进行运算
  2. 矩阵乘法
    • 逐个元素相乘
    • 使用dot方法矩阵相乘(线性代数的知识)
  3. 求和,求最大值最小值,都是返回一个指定的元素
  4. 求指定维度的和、最大最小值,需要根据axis指定维度
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
import numpy as np
a = np.array([10,20,30,40])
b = np.arange(4)
print(a,b)
# 1、减法
print(a-b)
# 2、加法
print(a+b)
# 3、指数
print(a**2)
# 4、三角函数运算
# print(np.sin(a),np.cos(a),np.tan(a))
# 5、布尔值
print(b)
print(b<3)
print(b==3)

############矩阵###########
a = np.array([[10,20],[30,45]])
b = np.arange(4).reshape((2,2))
print(a)
print(b)
# 乘法,逐个相乘
print(a*b)
# 乘法,矩阵相乘,使用np.dot或者a.dot(b)
print(np.dot(a,b))
print(a.dot(b))

# 随机生成一个矩阵
a = np.random.random((2,4))
print(a)
# 求和,或者写成a.sum()
print(np.sum(a))
# 最大值
print(np.max(a))
# 最小值
print(np.min(a))
# 求指定维度的和,最大最小值
# axis为1,就是将维度为1的元素累加,该维度消失,只剩下维度为0的行
print(np.sum(a,axis=1))
print(np.max(a,axis=1))
print(np.min(a,axis=0))
# 另一种写法
print(a.min(axis=0))
# 总结,axis的值为求和的维度,运算之后该维度消失

5、运算2

  1. 求最小最大值索引
  2. 求平均值,指定维度求平均值
  3. 求中位数
  4. 累加,第n个元素为原矩阵前n个元素的和
  5. 累差,原矩阵相邻元素之间的差值,列数减一
  6. 找出非0的元素,返回的值是多个表示非零元素的维度数组,数组拼接即可得到非零元素的索引值
  7. 排序,按照最小的维度排序,对于矩阵就是对行内的列元素排序
  8. 转置矩阵
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
import numpy as np
A = np.arange(2,14).reshape((3,4))
print(A)
# 最小值索引,两种写法都可
print(np.argmin(A))
print(A.argmin())
# 最大值索引
print(A.argmax())
# 求平均值
print(A.mean())
# 也可以指定维度
print(np.mean(A,axis=0))
print(np.average(A))
# 不能这样使用average
# print(A.average())

# 求中位数,也是只能np.median
print(np.median(A))
# 累加,第n个元素为原矩阵前n个元素的和
print(np.cumsum(A))
# 累差,原矩阵相邻元素之间的差值,列数减一了,因为n个元素有n-1个差值
print(np.diff(A))
# 找出非零元素,返回维度的数组
print(np.nonzero(A))

# 排序,最小的那个维度的数进行排序。如果是矩阵,就是行内的每列元素进行排序
B = np.arange(14,2,-1).reshape((3,4))
print(B)
# 不会改变原矩阵的值
print(np.sort(B))

# 矩阵的转置,行变成列,列变成行
print(np.transpose(B))
print(B.T)
print((B.T).dot(B))

# clip,所有大于9的数都变成9,小于5的数都变成5,5到9之间的数不变
print(B)
print(np.clip(B,5,9))

6、索引

  1. 对于多维的索引,索引号都放在一个中括号中,用逗号分割开
  2. 切片
  3. for迭代,默认迭代矩阵的行
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
import numpy as np

A = np.arange(3,15).reshape((3,4))
print(A)
print(A[2])
print(A[2][1])
# 多维索引都放在一个中括号中,用逗号分割
print(A[2,1])

# 切片
# 第一维度所有元素,就是原矩阵
print(A[:])
# 第一维度不限定,第二维度索引为1
print(A[:,1])
# 切片限定第二维度(列)
print(A[1,1:3])
print("********************")

# for迭代,默认迭代矩阵的行。就是第一维度
for row in A:
print(row)
# 迭代矩阵的列,可以通过迭代转置矩阵的列
for col in A.T:
print(col)
# 迭代每一个元素,flat之后是一个一维的列表
for item in A.flat:
print(item,end=',')

7、array合并

  1. 使用vstack实现多个array上下合并
  2. 使用hstack实现多个array水平合并
  3. 把一个横向的数列变成纵向的数列
  4. 使用concatenate多个array的合并指定合并的维度
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
import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])

# 上下合并
C = np.vstack((A,B))
print(C)
print(A.shape,C.shape)

# 左右合并(水平合并) horizontal stack
D = np.hstack((A,B))
print(D)
print(A.shape,D.shape)

print("*********************")
# 如何把一个横向的数列变成纵向的数列
A = A[:,np.newaxis]
B = B[:,np.newaxis]
print(A.shape,B.shape)
# 左右合并,hstack和vstack都可以进行多个array的合并
D = np.hstack((A,B,B))
print(D)

# 多个array的合并指定合并的维度,和上面两个不同的就是可以指定合并的维度
# 比如,在第一维度合并,即合并行
C = np.concatenate((A,B,B,A),axis=0)
print(C)
# 合并列
print(np.concatenate((A,B,B,A),axis=1))

8、分割

  1. 使用split均等分割
  2. 使用array_split不均等分割
  3. 使用vsplit和hsplit进行均等分割
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np

A = np.arange(12).reshape((3,4))
print(A)
# 均等分割,使用split均等分割
print(np.split(A,2,axis=1))
print(np.split(A,3,axis=0))

# 不均等分割,使用array_split
# 这里将四列分为三部分,第一部分为2列,2,3部分为1列
print(np.array_split(A,3,axis=1))
# 使用vsplit和hsplit进行分割
print(np.vsplit(A,3))
print(np.hsplit(A,2))

9、copy和deep copy

  1. 通过 = 赋值的变量都指向同一个数据
  2. 使用copy方法使复制后两个变量不相关联
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
a = np.arange(4)
print(a)
b = a
c = a
d = b
# 目前为止,abcd都是一样
# 这里更改a的值,观察其他变量的改变
a[0]=11
print(a,b,c,d)
print(b is a,c is a,d is a)
# 可以看到,改变了a,bcd都会改变,哪怕是通过b赋值的d
# 同理,改变了bcd任何一个元素,a的值也会改变
# 所以,通过=赋值的变量都是指向同一个数据,是浅拷贝

# 如果想让赋值后的两个变量不相关联,使用copy()方法
e = a.copy()
print(e is a)
a[1]=22
print(a,e)

numpy
https://zhaoyunlai.github.io/posts/927a0c3d4668/
作者
赵运来
发布于
2022年3月7日
许可协议