python常用函数积累（二）

1、scipy矩阵操作
七种矩阵类型
csc_matrix: Compressed Sparse Column format
csr_matrix: Compressed Sparse Row format
bsr_matrix: Block Sparse Row format
lil_matrix: List of Lists format
dok_matrix: Dictionary of Keys format
coo_matrix: COOrdinate format (aka IJV, triplet format)
dia_matrix: DIAgonal format

在用python进行科学运算时，常常需要把一个稀疏的np.array压缩，这时候就用到scipy库中的sparse.csr_matrix(csr:Compressed Sparse Row marix) 和sparse.csc_matric(csc:Compressed Sparse Column marix)

使用lil_matrix和dok_matrix来高效的构建矩阵。lil_matrix支持与numpy类似的基本的切片和索引等操作，coo_matrix也可以用来有效构建矩阵。
为了进行一些操作，比如：乘法、加法、转置等，首先需要将数组转为csc或者csr形式。lil_matrix形式是基于row的，因此能够很高效的转为csr，但是转为csc效率相对较低。

最常用的函数：
tocsc()：Return a copy of this matrix in Compressed Sparse Column format 压缩稀疏列格式
tocsr()：Return a copy of this matrix in Compressed Sparse Row format 压缩稀疏行格式
todense([order, out])：Return a dense matrix representation of this matrix 矩阵的稠密矩阵表示

2、array.sum(axis=?)
(1) sum()：将array中每个元素相加的结果
(2) axis对应的是维度的相加。

(1) axis=0时，是第一个维度元素的相加，
[[0,1,2,3],[4,5,6,7]]和[[1,2,3,4],[5,6,7,8]]对应元素相加[[0+1,1+2,2+3,3+4],[4+5,5+6,7+7,7+8]]=[[1,3,5,7],[9,11,14,16]]
(2) axis=1时, 对应的是第二个维度元素相加，这时候保留第一个维度的结构(第一个维度元素的个数)，第一个维度元素的个数为2。
分别是[[0,1,2,3],[4,5,6,7]]和[[1,2,3,4],[5,6,7,8]]
结构不变，继续向下拆分，可得
1）[0,1,2,3]和[4,5,6,7], 对应元素相加, 合并到一个数组中, [4,6,8,10]
2）[1,2,3,4]和[5,6,7,8], 对应元素相加, 合并到一个数组中, [6,8,10,12]
(3) 当axis=2时, 因为元素一共是三维，这就到了最后一个维度，将最小单位的数组元素相加即可。
[0+1+2+3,4+5+6+7],[[1+2+3+4],[5+6+7+8]]=[[6,22],[10,26]]

3、numpy.power()数组元素求n次方
numpy.power(x1, x2)
数组的元素分别求n次方。x2可以是数字，也可以是数组，但是x1和x2的列数要相同。

>>> x1 = range(6)
>>> x1
[0, 1, 2, 3, 4, 5]
>>> np.power(x1, 3)
array([  0,   1,   8,  27,  64, 125])
>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
>>> np.power(x1, x2)
array([  0.,   1.,   8.,  27.,  16.,   5.])

4、numpy中矩阵名.A
python中一个matrix矩阵名.A 代表将 矩阵转化为array数组类型

5、range()、xrange()和np.arange()区别
range多用作循环，range（0,10）返回一个range对象，如想返回一个list，前面加上list转换；

arange是numpy模块中的函数，使用前需要先导入此模块，arange(3):返回array类型对象。
【注：range()中的步长不能为小数，但是np.arange()中的步长可以为小数】

xrange()也是用作循环，只是xrang(0,10)不返回list，返回xrange对象。每次调用返回其中的一个值。
返回很大的数的时候或者频繁的需要break时候，xrange性能更好。
【注意：python3.x中把xrange()取消了】

6、矩阵乘法 np.dot, np.multiply, *
同线性代数中矩阵乘法的定义： np.dot()
np.dot(A, B)：对于二维矩阵，计算真正意义上的矩阵乘积，同线性代数中矩阵乘法的定义。对于一维矩阵，计算两者的内积。
对应元素相乘 element-wise product: np.multiply(), 或 *
在Python中，实现对应元素相乘，有2种方式，一个是np.multiply()，另外一个是*。

7、Numpy 中clip函数的使用
numpy.clip(a, a_min, a_max, out=None)[source]
其中a是一个数组，后面两个参数分别表示最小和最大值：

import numpy as np
x=np.array([1,2,3,5,6,7,8,9])
np.clip(x,3,8)
Out[88]:
array([3, 3, 3, 5, 6, 7, 8, 8])

clip函数将数组中的元素限制在a_min, a_max之间，大于a_max的就使它等于 a_max，小于a_min就使它等于a_min。

8、scipy.sparse.linalg.factorized(A)
Return a fuction for solving a sparse linear system, with A pre-factorized.
Parameters: A : (N, N) array_like Input.
Returns: solve : callable To solve the linear system of equations given in A, the solve callable should be passed an ndarray of shape (N,).
就是A是线性方程组的参数矩阵，给出线性方程组的右侧结果矩阵值，计算线性方程组的解。

>>> from scipy.sparse.linalg import factorized
>>> A = np.array([[ 3. ,  2. , -1. ],
...               [ 2. , -2. ,  4. ],
...               [-1. ,  0.5, -1. ]])
>>> solve = factorized(A) # Makes LU decomposition.
>>> rhs1 = np.array([1, -2, 0])
>>> solve(rhs1) # Uses the LU factors.
array([ 1., -2., -2.])

9、*和**
**两个乘号就是乘方，比如2**4,结果就是2的4次方，结果是16
一个乘号*，如果操作数是两个数字，就是这两个数字相乘，如2*4,结果为8

*如果是字符串、列表、元组与一个整数N相乘，返回一个其所有元素重复N次的同类型对象，比如”str”*3将返回字符串”strstrstr”

函数定义中参数前的*表示的是将调用时的多个参数放入元组中,
**则表示将调用函数时的关键字参数放入一个字典中
如：定义以下函数

def func(*args):print(args)

当用func(1,2,3)调用函数时,参数args就是元组(1,2,3)
如：定义以下函数

def func(**args):print(args)

当用func(a=1,b=2)调用函数时,参数args将会是字典{‘a’:1,’b’:2}

如果是在函数调用中,*args表示将可迭代对象扩展为函数的参数列表

args=(1,2,3) 
func=(*args)

等价于函数调用func(1,2,3)；
函数调用的**表示将字典扩展为关键字参数

args={'a':1,'b':2}
func(**args)

等价于函数调用 func(a=1,b=2)

10、mean()函数功能：求取均值
经常操作的参数为axis，以m * n矩阵举例：
axis 不设置值，对 m*n 个数求均值，返回一个实数
axis = 0：压缩行，对各列求均值，返回 1* n 矩阵
axis =1 ：压缩列，对各行求均值，返回 m *1 矩阵

>>> a = np.array([[1, 2], [3, 4]])  
>>> np.mean(a) # 将上面二维矩阵的每个元素相加除以元素个数（求平均数）  
2.5  
>>> np.mean(a, axis=0) # axis=0，计算每一列的均值  
array([ 2.,  3.])  
>>> np.mean(a, axis=1) # 计算每一行的均值  
array([ 1.5,  3.5])  

11、np.linalg
np.linalg.inv()：矩阵求逆，
np.linalg.det()：矩阵求行列式（标量），
np.linalg.norm：则表示范数，范数是对向量（或者矩阵）的度量，是一个标量（scalar）。

12、numpy.eye() 与np.identity()
numpy.eye() 生成对角矩阵
numpy.eye(N,M=None, k=0, dtype=

>>> np.eye(2, dtype=int)  
array([[1, 0],  
       [0, 1]])  
>>> np.eye(3, k=1)  
array([[ 0.,  1.,  0.],  
       [ 0.,  0.,  1.],  
       [ 0.,  0.,  0.]]) 

np.identity(n, dtype=None)
np.identity只能创建方形矩阵，而np.eye可以创建矩形矩阵，且k值可以调节。

13、np.repeat 与 np.tile
二者执行的是均是复制操作；
np.repeat：复制的是多维数组的每一个元素；
np.tile：复制的是多维数组本身；

numpy.tile()：把数组沿各个方向复制
比如 a = np.array([0,1,2]), np.tile(a,(2,1))就是把a先沿x轴复制1倍，即没有复制，仍然是 [0,1,2]。
再把结果沿y方向复制2倍，即最终得到
array([[0,1,2],
[0,1,2]])
同理：

>>> b = np.array([[1, 2], [3, 4]])
>>> np.tile(b, 2) #沿X轴复制2倍
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
>>> np.tile(b, (2, 1))#沿X轴复制1倍（相当于没有复制），再沿Y轴复制2倍
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])

14、numpy.ravel() 与 numpy.flatten()
两者所要实现的功能是一致的（将多维数组降位一维），两者的区别在于返回拷贝（copy）还是返回视图（view），numpy.flatten()返回一份拷贝，对拷贝所做的修改不会影响（reflects）原始矩阵，而numpy.ravel()返回的是视图（view，也颇有几分C/C++引用reference的意味），会影响（reflects）原始矩阵。
两者的功能

>>> x = np.array([[1, 2], [3, 4]])
>>> x
array([[1, 2],
       [3, 4]])
>>> x.flatten()
array([1, 2, 3, 4])
>>> x.ravel()
array([1, 2, 3, 4])
                    两者默认均是行序优先
>>> x.flatten('F')
array([1, 3, 2, 4])
>>> x.ravel('F')
array([1, 3, 2, 4])

>>> x.reshape(-1)
array([1, 2, 3, 4])
>>> x.T.reshape(-1)
array([1, 3, 2, 4])

两者的区别

>>> x = np.array([[1, 2], [3, 4]])
>>> x.flatten()[1] = 100
>>> x
array([[1, 2],
       [3, 4]])            # flatten：返回的是拷贝
>>> x.ravel()[1] = 100
>>> x
array([[  1, 100],
       [  3,   4]])

15、numpy.unique()
a = np.unique(A)
对于一维数组或者列表，unique函数去除其中重复的元素，并按元素由大到小返回一个新的无元素重复的元组或者列表

>>> a=np.random.randint(0,5,8) 
>>> a 
array([2, 3, 3, 0, 1, 4, 2, 4]) 
>>> np.unique(a) 
array([0, 1, 2, 3, 4]) 

c,s=np.unique(b,return_index=True)
return_index=True表示返回新列表元素在旧列表中的位置，并以列表形式储存在s中。

>>> c,s=np.unique(b,return_index=True) 
>>> c 
array([0, 1, 2, 3, 4]) 
>>> s 
array([3, 4, 0, 1, 5])#元素出现的起始位置

a, s,p = np.unique(A, return_index=True, return_inverse=True)
return_inverse=True 表示返回旧列表元素在新列表中的位置，并以列表形式储存在p中

16、np.where
函数是三元表达式 x if condition else y的矢量化版本
result = np.where(cond,xarr,yarr)
当符合条件时是x，不符合是y，常用于根据一个数组产生另一个新的数组。

如：假设有一个随机数生成的矩阵，希望将所有正值替换为2，负值替换为-2

arr = np.random.randn(4,4)
arr
Out[51]: 
array([[ 0.04150406,  1.27790573, -0.25917274, -1.25604622],
       [ 0.8797799 ,  1.84828821, -1.21709272, -0.41767649],
       [-0.71758894, -0.70595454,  1.72330333,  0.18559916],
       [-2.19529605,  2.11615947, -0.13563148, -1.41532576]])

np.where(arr>0,2,-2)
Out[52]: 
array([[ 2,  2, -2, -2],
       [ 2,  2, -2, -2],
       [-2, -2,  2,  2],
       [-2,  2, -2, -2]])