Numpy 学习笔记

《Numpy & Pandas》视频链接

Numpy 介绍

• Numpy是Python的一种开源的数值计算扩展，是一些针对矩阵进行运算的模块

Numpy学习笔记

1. 导包

import numpy as np   # 导入包

2. 创建一个矩阵

为了使用numpy中的方法，在输入input后，得把它转化为Numpy可识别的矩阵。

比如说我要创建下面这个矩阵并打印相关信息，正常的输入应该是array = [[1,2,3],[4,5,6]]，但是为了使用Numpy的方法，得先把二维数组转换为numpy可识别的矩阵，即array = np.array([[1,2,3],[4,5,6]])。

array = np.array([[1,2,3],[4,5,6]])  # 将这个列表变为numpy可识别的矩阵

print(array)  # 打印矩阵
print('number of dim:', array.ndim)   # 几维数组？
print('shape',array.shape)   # 打印出几行几列
print('size：',array.size)   # 打印出几个元素

给定矩阵的元素，那怎么定义元素的数据类型呢？可以用dtype函数，但是注意在定义数据类型时得使用numpy内置的数据类型，比如要定义成浮点型，不可以直接使用dtype = float，而是得dtype = np.float

a = np.array([2,23,4],dtype=np.float)  
print(a)   # 变成矩阵逗号就不见了
print(a.dtype)  # 打印矩阵的数据类型

如何定义一个矩阵所有的元素都为0呢？可以试试np.zeros()，或者np.empty()也可以，注意如果这个矩阵只含有一个元素，就是np.zero()

a = np.zeros((3,4))   # 其中(3,4)表示定义三行四列，记住 行列 得用括号括起来
a = np.empty((3,4))  # 这种写法也行
print(a)  

如何定义一个矩阵所有的元素都为1呢？可以试试np.ones()，注意如果这个矩阵只含有一个元素，就是np.one()

a = np.ones((3,4))   # 3. 打印全部为1的三行四列矩阵
print(a)   

将一个范围的数字放入矩阵中，比如将10-20的数字放入矩阵中，要求每个数字之间相差2

a = np.arange(10,20,2)  # arange(初始值，结尾值，步长)，左闭右开
print(a)   

# 范围从0到11的矩阵
a1 = np.arange(12).reshape((3,4))  # reshape函数重新定义矩阵的形状，这里为三行四列 
print(a1)   

# linspace函数也可以生成一个数字范围。具体使用方法为linspace(初始值，结尾值，个数)
a2 = np.linspace(1,10,5)  # 会生成5个从1到10的数字，且数字差相等
print(a2)   

3. 矩阵的基本运算

假设有两个矩阵：

a = np.array([[1,1],[0,1]])
b = np.arange(4).reshape(2,2)
print(a)
print(b)
print('------------------')

对a和b进行相加

c = a+b   #  对a和b里面的数据逐个相加（+）、相减（-）、乘方（**）等等操作
print(c)

a+sin(b)

c1 = a+np.sin(b)  # sin /cos 函数 等等
print(c1)

a*b，有两种乘法，一种就是普通的乘法

c21 = a*b  # 普通的乘法
print(c21)

还有一种是矩阵的乘法

c22 = np.dot(a,b)  # np.dot为矩阵的乘法，也可以写成a.dot(b)
print(c22)

4. 求矩阵的最值，和，平均值

给一个2行4列的随机矩阵

d = np.random.random((2,4))  # 随机生成的2行4列
print(d)

求和

print(np.sum(d))   # 求和

求最小值，不仅可以求出整个矩阵的最小值，还可以求出每一列的最小值（加参数axis =0），每一行的最小值（加参数axis=1）。

print(np.min(d))   # 求出全部数值的最小值
print(np.min(d,axis = 0))  # 参数axis = 0 代表求出每列的最小值，所以有几列就有几个最小值
print(np.min(d,axis = 1))  # 参数axis = 1 求出每行的最小值，有几行就有几个最小值

求最大值，均值，中位数

print(np.max(d))   # 求最大值
print(np.mean(d))  # 平均值  也可以写成np.average(d)或者d.mean()
print(np.median(d))  # 中位数

5. 矩阵的累和，累差，排序，转置

假设我有一个下图的矩阵

A = np.arange(2,14).reshape((3,4))

求索引的最小值与索引的最大值

print(np.argmin(A))  # 求索引中的最小值，一般都为0
print(np.argmax(A))  # 求索引中的最大值

求矩阵的累和，即它会输出矩阵，矩阵元素与A一致，并且其中第n项为矩阵A前n项累加之和

print(np.cumsum(A))  # 累和

矩阵的累差，注意：由于新生成的矩阵的每一项是原矩阵相邻两项之差，所以新生成的矩阵元素会变少

print(np.diff(A))   # 累差，

矩阵非0数的位置，结果会输出两个数组，其中第一个数组保存的是每一个位置行数，第二个数组保存的是列数

print(np.nonzero(A))  

矩阵的排序，但这个排序并不是整个矩阵元素进行排序，而是对每一行单独排序，排序顺序：从小到大

print(np.sort(A))  # 排序

矩阵的转置

print(np.transpose(A))  # 也可以写成 (A,T)

下面的代码会使得 在A中所有小于5的数都重置为5，所有大于9的数都重置为9

print(np.clip(A,5,9))   

6. 矩阵的索引

重新给一个矩阵

A= np.arange(3,15).reshape((3,4))

输出矩阵的某一行

# 注意：如果A为一维数组，那么就打印第三个值；如果A为二维数组，那么就输出第3行
print(A[2]) 
print(A[2,:])  # : 代表所有，放在后面代表所有列，放在前面代表所有行；所以是打印第3行的所有数据 

# 打印 A 第2行第2列
print(A[1][1])  # 也可以写为print(A[1,1])

迭代打印矩阵A的每一行

for row in A:
    print(row)

输出矩阵的某一列

print(A[:,2])  

如何迭代每一列？先转置再迭代，注意如果是单行不能用转置函数来将行变为列，得使用 A[:,np.newaxis]

那如果是多行多列的矩阵，如何迭代每一个元素？使用A.flat将A变为一行后再循环

for item in A.flat:
    print(item)

7. 矩阵的合并

假设我们有两个矩阵

A= np.array([1,1,1])
B = np.array([2,2,2])

我们对这两个矩阵进行合并，有两种方式

合并方式一：

C = np.vstack((A,B))   #  vstack 就是将B矩阵整体放在A矩阵整体的下边

合并方式二：

D = np.hstack((A,B))  #   hstack 就是将B矩阵整体放在A矩阵整体的右边

为了更好的理解 vstack与hstack的区别，可以在上面的代码的基础上自己跑一下下面的代码

A= A[:,np.newaxis]  # 将单行变为单列
B = B[:,np.newaxis]

C = np.vstack((A,B))   
print(C)
print('---------------------') 
D= np.hstack((A,B))  
print(D)

输出结果：

上面是两个矩阵的合并，如果是多个矩阵合并，则要用到concatenate函数，concatenate的参数：第一参数表示要合并的数组，第一个参数外记得加括号；第二个参数为维度，其中axis = 0相当于vstack，axis=1相当于hstack

E = np.concatenate((A,B,B),axis = 0)    

8. 数组的分割

我们这个数组

A= np.arange(12).reshape((3,4))

将上面的数组进行纵向分割，平均的分割成两块

B = np.split(A,2,axis=1)  # split(array,分成几块，怎么样分割)； 其中axis=1表示纵向分割，即竖着切。注意：spilt不能进行不相等的分割，会报错array split does not result in an equal division
G = np.hsplit(A,2)  # 也可以这样写，hsplit 纵向分割，分为两块

将上面的数组进行横向分割，平均的分割成三块

C = np.split(A,3,axis=0) # axis=0表示横向分割
F = np.vsplit(A,3)  # 也可以这样写，vsplit 横向分割，分为三块

上面都是平均的分割，如何进行不平均的分割？用array_split

E = np.array_split(A,3,axis=1)
print(E)

9. 矩阵的copy问题

假设我有一个矩阵a，我用a copy一个矩阵b，一个矩阵c，再用矩阵b copy一个矩阵d，此时如果我改变某个矩阵中的某一个值，其他矩阵的值会不会对应的的改变呢？

a = np.array([0,1,2,3])
b = a
c = a
d = b
a[0] = 4  # 改变a里面的值，其他的都会变
print(a)
print(b)
print(c)
print(d)
print( b is a)  # b是a吗？结果为TRUE
print(d is  a)  # True
d[3] = 0  # 因为a就是b，就是c,就是d,所以不管改变谁，所有的都会变
print(a)
print(b)
print(c)
print(d)

答案是，改变一个全部都会改变的，因为实际上这几个矩阵在底层都是指向同一个矩阵的，也就是C++上面的浅copy，那么问题来了：如果我想用a拷贝一个矩阵e，但是又不想两个矩阵关联，如何处理？用copy函数

a = np.array([0,1,2,3])
e = a.copy()  # deep copy 深拷贝
e[0] = 5
print(e)
print(a)