Python - Numpy库的使用

Numpy简介

Numpy（Numerical Python的简称）是高性能科学计算和数据分析的基础包。

优点

1. Numpy底层使用C语言进行编写的，执行更快。
2. Numpy数组内部的数据类型必须是统一的，而Python列表list支持所有类型的内容填充，使得在使用列表时，每次调用元素都要查询元素类型。
3. Numpy数组的存储地址是连续的。
4. Python语言执行的时候有线程锁，无法实现真正的多线程，而C语言可以。

调用方法

import numpy as np

关于ndarray

数据类型

相对于python自带的list数组，ndarray数组的优点如下：

1. ndarray数组支持广播机制，不需要for循环就能进行矩阵运算。

# 矩阵运算1
a = np.array([1, 2, 3, 4, 5])
a = a + 1
# 无需使用for循环进行逐个增加，简化了矩阵的运算

# 矩阵运算2-广播机制
a = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
b = np.array([1, 2, 3, 4, 5])
c = a + b
# c = ([[2, 4, 6, 8, 10], [7, 9, 11, 13, 15]])

# 矩阵运算3-标量和矩阵
# 使用标量对矩阵进行加减乘除，都相对于使用标量对数组内每一个元素进行加减乘除操作

# 矩阵运算4-矩阵间运算（区别于2）
# 使用矩阵加减乘除矩阵，都相当于对应位置元素各自的加减乘除。 

2. 内部数据类型相同，地址空间连续，运行速度更快。

创建函数

函数	作用
np.array(object, dtype=)	接受一切序列型（常用list）的对象,然后产生一个新的含有传入数据的numpy数组，可设置类型dtype。
np.arange(m,n,x)	创建元素从m到n依次递增x的数组。
np.zeros()	创建指定长度或者形状（例如二位矩阵）的全0数组。
np.ones()	创建指定长度或者形状的全1数组。
np.full((), n)	创建指定长度或者形状的指定内容为n的数组。
np.eye(n)	创建n*n的单位矩阵。
np.linspace(0, 1, 5)	创建从0-1，长度为5的等差数列。
np.logspace(0,9,10)	创建一个长度为10，形成1-10^9的等比数列。

属性

属性(a=变量名)	作用
a.shape	数组的形状，1维数组（N, ），二维数组（M, N），三维数组（M, N, K）。
a.dtype	数组内的数据类型。
a.size	包含的元素个数，指单个元素。
a.ndim	数组的维度大小，如一维二维三维

操作函数

属性 (a=变量名)	作用
a = a.astype(type)	改变数组数据类型 。
a = a.reshape(shape)	改变数组形状, 返回视图，(-1,1)表示列数为1，行数自适应。
a = a.flatten() /a.reshape(-1)	展开数组，返回副本，无法修改。
a = a.ravel()	展开数组，返回视图，修改会保存到原数组。

属性 (a=变量名)	作用
np.median(x)	求x的中位数
a.mean()	计算算术平均数，零长度数组的mean为NaN
a.std() / a.var()	计算标准差/方差，自由度可调（默认为n）
a.sum()	对数组中全部或某轴向的元素求和，零长度数组的sum为0。
a.sum()	对数组中全部或某轴向的元素求积
a.max() / a.min()	返回最大值/最小值。
a.argmin() / a.argmax()	返回最大值/最小值的索引。
a.cumprod()	计算所有元素累积。
a.cumsum()	计算所有元素累加。

属性 (a=变量名)	作用
np.r_[a,b] / np.vstack([a, b])	两矩阵上下相加，要求列数相等
np.c_[a,b] / np.hstack([a, b])	两矩阵左右相加，要求行数相等
np.split(X, n)	将X进行分裂，返回n个等分数组
np.split(X, [n,m])	将X进行分裂，返回3个数组，从n和m为下标的元素进行左切割
np.hsplit(X, n / [n,m])	对X进行垂直切割，按列数或等分
np.vsplit(X, n / [n,m])	对X进行水平切割，按行数或等分

关于np.random

创建随机数组

建立随机数组之前一般先设置随机数种子，用以保证多次运行时能够建立相同的随机数组

np.random.seed(42)

生成随机数组的方式：

1. 均匀分布：[0,1)

a = np.random.rand(3, 3)
a = np.random.random((3, 3))

2. 正态分布：

a = np.random.randn(3, 3) # 标准正态
a = np.random.normal(loc = 1.0, scale = 1.0, size = (3,3))  # loc为均值，scale为方差

3. 随机整数

a = np.random.randint(0,10,(3,3))# 生成[0, 10)之间的整数数组

打乱数组顺序

1. 打乱一维数组顺序，二维数组行序。

np.random.shuffle(a) 		

2. 产生随机索引，打乱本来数据相互对应的多个数组顺序。

shuffle_index = np.random.permutation(len(X))
X, y = X[shuffle_index], y[shuffle_index]

3. 产生新的被打乱的数组，原数组不发生变化

y = np.random.permutation(x)

抽取随机元素

x = np.random.choice(X, size=)
# 返回指定形状的随机采样

关于np.linalg

Numpy提供了线性代数中矩阵相关的运算函数。

函数	作用
X.T	返回矩阵X的转置矩阵
a.dot(b) / np.dot(a,b)	矩阵乘法a*b。
a.trace() / np.trace(a)	矩阵a的对角线之和
np.diag(a)	返回矩阵对角线内容或将一维数组转换为方阵（非对角线元素为0）。
np.linalg.det(a)	计算矩阵行列式。
np.linalg.eig(a)	计算方阵的特征值和特征向量。
np.linalg.inv(a)	计算方阵的逆。

关于npy

numpy提供了文件处理函数save()和load()

函数	作用
np.save(‘filename.npy’ , a)	存储矩阵a。
np.load(‘filename.npy’ )	读取矩阵a。

关于np.sort

函数	作用
np.sort(x)	返回将元素从小到大排列的数组 ，原数组不改变
x.sort()	将原数组按从小到大重新排列
np.argsort(x)	返回排序索引
np.argmax(x)	返回最大值的索引
np.argmin(x)	返回最小值的索引

其他函数

函数	作用
np.sin(theta)	三角函数，其他及反三角函数同样求法
np.exp(x)	e^x
np.log(x)	以e为底的对数函数
np.log2(x)	以2为底的对数函数
np.unique()	去除数组中的重复数字，并进行排序之后输出。

知识点：

1. 数组切片产生的新数组，还是指向原来的内存区域，数据不会被复制，任何修改都会直接反映到源数组上。但是可以通过X.copy()函数创建不同内存空间。

y = x[:2, 3:].copy()

2. 比较运算：

>>> a
array([[ 2, 19,  0, 12,  8],
       [ 0, 15, 13,  0, 19],
       [14, 19, 15, 15, 12],
       [ 6, 15, 12,  4,  8]])
>>> a>10
array([[False,  True, False,  True, False],
       [False,  True,  True, False,  True],
       [ True,  True,  True,  True,  True],
       [False,  True,  True, False, False]])
>>> np.sum(a>10)	# True的个数
12
>>> np.all(a>0)
False
>>> np.any(a==0)
True
>>> np.all(a>0, axis=1)	# 按行进行判断
array([False, False,  True,  True])
>>> b = a[a>2]	# 掩码操作
>>> b
array([19, 12,  8, 15, 13, 19, 14, 19, 15, 15, 12,  6, 15, 12,  4,  8])

3. 花哨的索引

# 一维数组的索引
>>> b
array([19, 12,  8, 15, 13, 19, 14, 19, 15, 15, 12,  6, 15, 12,  4,  8])
>>> index = [0,4,7]	
>>> c =b[index]
>>> c
array([19, 13, 19])
>>> index = np.array([[1,0],[2,3]])
>>> c = b[index]
>>> c	# 由于索引是二元数组，但是原数组是一维数组，所以按照索引产生一个二维数组，索引中的元素为一维数组的下标
array([[12, 19],
       [ 8, 15]])

# 多维数组的索引
>>> a
array([[ 2, 19,  0, 12,  8],
       [ 0, 15, 13,  0, 19],
       [14, 19, 15, 15, 12],
       [ 6, 15, 12,  4,  8]])
>>> row = np.array([0,1,2])
>>> col = np.array([1,2,3])
>>> b = a[row,col]
>>> b		# a[0,1],a[1,2],a[2,3]
array([19, 13, 15])
>>> row.reshape(-1,1)
array([[0],
       [1],
       [2]])
>>> b = a[row.reshape(-1,1),col]	# 这里使用了广播机制，所以索引其实是一个3*3的二维数组
>>> b
array([[19,  0, 12],
       [15, 13,  0],
       [19, 15, 15]])