numpy基础教程-常用（莫烦python笔记）

numpy基础教程

优势

比原生的Python速度快，因为是由c语言编写的。

创建

import numpy as np  # 引入模块
A = np.array([[1,2,3],
	 		  [4,5,6]],dtype = np.int64)
# 0维度：行。 1维度：列。  [每一个维度都由方括号括起来],维度高的包含维度低的,同一维度之间有逗号！
# 需要通过np.array函数将列表转换为np的array类型，否则只是一个多维列表，可以理解为np.array的一个参数：1个列表(1个！)
# dtype = np.int可以省略，其他创建方法中也可以使用，还有很多类型np.int32,np.in64,np.float等等。

# 线性数据转换为矩阵
B1 = np.arange(0,12).reshape((3,4))
B2 = np.linspace(1,10,6).reshape((2,3))
# arrange的使用方法同python自带的range,左闭右开。arrange(12)==arrange(0,12)
# arrange(start,stop,sep)
# linspace(start,stop,nums) 左闭右闭
# reshape的1个（1个！）参数是矩阵大小，所以要将(2,3)这个元组作为参数。

# 特殊矩阵创建
C = np.zeros((2,3))
D = np.ones((2,3))
E = np.empty((2,3))  # 就是一个所有元素接近0的矩阵
# 同理,1个(1个!)参数是矩阵大小，所以要将(2,3)这个元组作为参数。

# 随机矩阵
R = np.random.random((2,3))import numpy as np  # 引入模块

基本运算

import numpy as np
A = np.array([10,20,30,40])
B = np.arange(4)
# 元素之间的运算(+，—，*，/,判断)
C1 = A-B
C2 = A+B
C3 = A*B
C4 = A**2
D1 = A>20 # 对每个元素判断，返回True或False
D1 = (A==20)
# 元素之间的计算（函数计算）
E1 = np.sin(A)
E2 = np.cos(A)
E3 = np.tan(A)
# 矩阵之间的运算
C_dot1 = np.dot(A,B)  # 向量的点积是常数，会自动转换维度。向量的转置也还是原来的向量
C_dot2 = A.dot(B)

矩阵的属性

import numpy as np
R = np.random.random((2, 3))  # 0~1的随机数
V = np.array([1, 2, 3])
shape_R = R.shape  # 矩阵的形状
shape_V = V.shape  # 向量的形状，只有(3,),逗号是因为元组的定义，只有3表示的向量有三个元素，不同于（1，3）的矩阵，向量的转置还是向量

sum_all = np.sum(R)
sum_col = np.sum(R, axis=0)  # 0维：列    列的维度上求和，即每一列分别求和

min_all = np.min(R)
min_index = np.argmin(R)  # 求最小值索引
min_column = np.min(R, axis=1)  # 1维：行   行的维度上求最小值，即求每一行的最小值

max_all = np.max(R)
max_index = np.argmax(R)  # 求最小值索引
max_column = np.max(R, axis=1)  # 1维：行   行的维度上求最大值，即求每一行的最大值

mean_all = np.mean(R) # 平均数，R.mean()也可以
median_all = np.median(R) # 中位数，一个数

矩阵变换（矩阵–>新矩阵）

import numpy as np
A = np.array([[1,2,3,4,5],[10,9,8,7,6]])
my_cumsum = np.cumsum(A) # 累加
my_diff = np.diff(A) # 相邻元素求差，会少一些元素
my_nonzero = np.nonzero(A)  # 非0元素的所有行坐标，所有列坐标。。。感觉不是很好用
my_sort_line = np.sort(A)  # 行内排序，从小到大排序
A_zhuan_zhi1 = A.T  # 矩阵的转置，向量的转置还是向量
A_zhuan_zhi2 = np.transpose(A)  # 矩阵的转置
A_limit = np.clip(A,5,7)  # 限定大小5~7，超过的元素定为5或7
A_flat = A.flatten()  # 将多维矩阵转为一维。A.flat返回的是一个迭代器
'''这几个函数，都有一个参数axis指定运算的维度，在对应的维度内部使用该函数
0维度：列。 1维度：行。A.shape输出的是(4维数目，3维数目，2维数目，1维数目，0维数目)，如果没有5维数目，表示该矩阵不存在第五维，只有五个维度。
该维数目=0和=1的意义是不同的！这个和matlab不太一样，matlab向量就是一行的矩阵，且以1为起始点！
对于向量，只有一个维度，也就不说行列了。一行五列也是两个维度！
比如axis=0，就是对列的维度内部，即列内部使用该函数，不同的列将得到不同的结果。
0维度：列。 1维度：行！ 0维度：列。 1维度：行！ 0维度：列。 1维度：行！
'''

索引遍历

import numpy as np
A = np.arange(3, 15).reshape((3, 4))
# 索引
print(A[2])  # 一个一维列表，数据内容为第三行，因为以0为起始
print(A[2][1])  # 一个数，第三行的第二个数
print(A[2,1])  # 等效于[2][1]
print(A[2,:])  # 第三行的所有，返回的是一个一维列表
print(A[:,2])  # 第三列的所有，返回的是一个一维列表
print(A[1,0:2])  # 也是左闭右开
# 遍历
for row in A:
	print(row)  # 遍历每一行，输出的是一维的
for col in A.T:
	print(col)  # 遍历每一列
for item in A.flat:
	print(item)  # 遍历每一项，输出的是一个元素
	

合并

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

v_AB = np.vstack((A,B))  # 垂直堆叠,对向量使用，变为矩阵
print(v_AB)
print(v_AB.shape)

h_AB = np.hstack((A,B))  # 水平堆叠，对向量使用，还是向量
print(h_AB)
print(h_AB.shape)

A_mat1 = A[np.newaxis, :]
A_mat1_r = A.reshape(1,3)
A_mat2 = A[:,np.newaxis]
A_mat2_r = A.reshape(3,1)

B_mat1 = B[np.newaxis, :]
C = np.concatenate((A_mat1,B_mat1,B_mat1,A_mat1),axis=0)  # 0维：列 上下合并
D = np.concatenate((A_mat1,B_mat1,B_mat1,A_mat1),axis=1)  # 1维：行 左右合并

分割

import numpy as np
A = np.arange(40).reshape((5,8))
print(A)
# 分割的结果是一个列表，列表的每一个元素是一个numpy矩阵，也就是分割的一块儿
B = np.split(A,2,axis=1)  # 1维：行  行内分，分成几列
C = np.split(A,5,axis=0)  # 0维：列  列内分，分成几行
# 注意split，vsplit,hsplit这几个函数只能均分，对于无法均分的情况会报错,而np.array_split可以
np.array_split(A,3,axis=1)  # 尽可能均分， 1维：行  行内分，分成几列
np.vsplit(A,5)  # 纵向分割为5块儿
np.hsplit(A,2)  # 横向分割为两块儿

拷贝

import numpy as np
a = np.arange(4)

b = a  # 浅拷贝，将a盒子再贴一个标签b
a[2] = 10
print(b)   # 0 1 10 3
print(b is a)  # True

c = a.copy()  # 深拷贝，新创建一个盒子，贴上标签c
a[2] = 100
print(c)  # 0 1 10 3

其他常用

import numpy as np
A = np.array([1,2,3,0,0],[0,3,4,5,0])
np.count_nonzero(A)  # 非0元素的个数
A_repeat = np.tile(A, (3,2)) # 将矩阵A横向复制为3个，纵向复制为2个