numpy使用

numpy提供了ndarray的基本对象（多维数组），便于进行数值运算

基础

创建：

np.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
a = np.array([1,2,3,4])

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

np.arange(0,1,0.1) # array([0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9])

arange指定起始值，终值，步长来创建一维数组（数组不包括终值）

np.linspace(0,1,10) # 步长为1/9

linspace指定起始值，终值，元素个数（可通过endpoint参数指定是否包括终值，缺省设置为True）

冒号的使用：

1. 默认全部选择

2. 指定范围

   X[:,0] # 取X的所有行第0列的元素
   X[:,m:n] # 取X的所有行中的的第m到n-1列数据

其他：

np.logspace(0,2,20) # 等比数列，20个元素，1-100
np.r_[0:2:0.5] # 快速创建行向量 [0.0.5,1,1.5]
np.c_[0:2:0.5] # 快速创建列向量 [[0],[0.5],[1],[1.5]]
a = np.zeros(3, dtype=np.float) # 只有一个参数默认为行向量，dtype默认值为np.float,可以不填
a = np.zeros((2, 3))
a = np.ones(3) # 与zeros类似
a = np.eyes(5) # 创建一个5*5的单位矩阵，等价于np.identity(5)

创建一个在 2，10，之间有 6 个元素的 ndarray，并将其形状改为(2,3)：

array = np.linspace(2, 10, 6)
array = array.reshape(2, -1)  # -1为占位，numpy可以推测后面的值

单个矩阵操作：

array = np.arange(2, 5, 0.5, dtype=np.float).reshape(3, -1)
print(array)
print(2 + array)
print(array - 2)
print(array/2)
print(2*array)
print(np.log(array))
print(np.power(array, 2))
print(np.sqrt(array))

矩阵转置：

array = np.arange(2, 5, 0.5, dtype=np.float).reshape(3, -1)
print(array.T)
print(np.transpose(array)) # 两种方式都可以

随机数据：

np.random.rand(3,2) # [0,1) 正态分布
np.random.randn(2,5) # 标准正态分布
np.random.standard_uniform(size) # size为shape，多维数组应为元组形式
np.random.normal(loc,scale,size) # loc为均值，scale为标准差
np.random.randint(low,high,size) # 随机整数，[low,high)
np.random.random_integers(low,high,size) # 随机整数，[low,high]
np.random.random(size) # 产生属于[0.0, 1.0)的size数量的连续均匀分布。size为list或者tuple时，产生相应维度的结果。
np.random.random_sample(size) # 同random
np.random.sample(size) # 同random

拼接：

np.vstack(a,b) #按垂直方向（行顺序）堆叠数组构成一个新的数组 堆叠的数组需要具有相同的维度
np.hstack(a,b) #按水平方向（列顺序）堆叠数组构成一个新的数组 堆叠的数组需要具有相同的维度

函数：

np.atleast_2d(3.0) # 将输入视为至少两个维度的数组
np.sum(a, axis=None) # a为要进行求和的矩阵，axis代表轴，对于n维数组，它有n个轴，例如，对于一个4行3列2纵的三维数组，这个三维数组可以说有三个轴，0轴，1轴，2轴，若axis为一个单独的数字，就代表在以上三个轴之一选择加和，若是一个数组，则表示先进行第一个数代表的轴，再执行……
np.sign(a) # sign(x)={ 1 (x>0), 0 (x=0), -1 (x<0)}
np.all(a, axis=None) # 判断a中所有元素是否都为true，默认考虑所有轴
np.any(a, axis=None) # 判断a中是否有元素为true，同上
a,s,p=np.unique(a, return_index=True, return_inverse=True) # 对于一维数组或者列表，unique函数去除其中重复的元素，并按元素由大到小返回一个新的无元素重复的元组或者列表,return_index=True表示返回新列表元素在旧列表中的位置，并以列表形式储存在s中,return_inverse=True 表示返回旧列表元素在新列表中的位置，并以列表形式储存在p中
a.max() # 获取整个矩阵最大值
a.max(axis=0) # 行方向最大值，获取每列最大值
a.max(axis=1) # 列方向最大值，获取每行最大值，实质是第一轴第二轴……
a.argmax() # 返回的是位置 min同max
a.mean() # 平均值，同样地，可以通过关键字axis参数指定沿哪个方向获取平均值
a.var() # 方差，同上
a.std() # 标准差，同上
np.median(a) # 中值，如果有偶数个数，则是排在中间两个数的平均值，默认axis=None，对所有数取中值

矩阵相乘：

np.matmul(a,b)

打印设置：

set_printoptions(precision=8, threshold=None, edgeitems=None, 
				 linewidth=None,suppress=None, nanstr=None, 
				 infstr=None, formatter=None, sign=None,
				 floatmode=None, **kwarg)

precision 浮点数组输出的精度位数，即小数点后位数。

threshold 元素门槛值。数组个数沒有超过设置的阈值，NumPy就会将Python将所有元素列印出來

edgeitems 当省略数组内元素内容时要显示的元素数量

linewidth 每一行要打印的元素个数

suppress 是否要打印显示小数位

nanstr 当数组元素值出现NaN时所要显示的字符串

infstr 数组元素值出現inf时所显示的字串

sign 控制正负号

linalg模块

创建矩阵：

A = np.mat("0 1 2;1 0 3;4 -3 8")

计算逆矩阵：

inv = np.linalg.inv(A)
# [[-4.5,7,-1.5]
#  [-2,4,-1]
#  [1.5,-2,0.5]]

求解线性方程组：

B = np.mat("1 -2 1;0 2 -8;-4 5 9")
b = np.array([0,8,-9])
x = np.linalg.solve(B,b)
# [29,16,3]

求解特征值和特征向量：

C = np.mat("3 -2;1 0")
c0 = np.linalg.eigvals(C)
# [2,1]
c1,c2 = np.linalg.eig(C)
# c1 = [2,1]
# c2 = [[0.89442719 0.70710678]
#	    [0.4472136 0.70710678]]

奇异值分解：

这里先讲一下奇异值分解的概念，对于一个高维矩阵A，通常情况下高维数据并非雨露均沾，集中分布在某些维度上于是，通过SVD(奇异值分解)，就可以利用降维后的数据近似地替代原始数据。所以，SVD(奇异值分解)其实就是在寻找数据分布的主要维度，将原始的高维数据映射到低维子空间中实现数据降维，A=u*sigma*v

其中sigma是对矩阵a的奇异值分解。sigma除了对角元素不为0，其他元素都为0，并且对角元素从大到小排列。sigma中有n个奇异值，一般排在后面的比较接近0，所以仅保留比较大的r个奇异值。

D = np.mat("4 11 14;8 7 -2")
U,Sigma,V = np.linalg.svd(D,full_matrices=False) # full_matrices = True 全SVD False 简化SVD

求广义逆矩阵：

E = np.mat("4 11 14;8 7 -2")
pseudoinv = np.linalg.pinv(E) # 注：inv函数只接受方阵作为输入矩阵，而pinv函数则没有这个限制

求行列式：

F = np.mat("3 4;5 6")
np.linalg.det(F)

范数：

np.linalg.norm(x, ord=2) # ord决定范数，默认为2