1）Python模块：numpy

http://www.runoob.com/numpy/numpy-dtype.html

numpy是一种开源的数值计算扩展，可用来存储和处理大型矩阵。比Python自身的嵌套列表（nested list structure)结构要高效的多。专攻数字处理。底层使用C语言编写，内部解除了GIL（全局解释器锁），其对数组的操作速度不受Python解释器的限制，效率远高于纯Python代码。

numpy一共三块知识：ndarray ufunc   矩阵运算

NumPy提供了一个N维数组类型ndarray，它描述了相同类型的“items”的集合。

利用numpy创建的数组，类型都是ndarray。

img=cv2.imread('D:\\1.jpg')   获取的img类型是ndarray

Numpy库：

数据类型：np.

bool_ 
int_  intc  intp  int 8  int16  int32  int64  uint8  uint16  uint32  uint64
float_  float16  float32  float64  
complex_  complex64  complex128

数组创建

arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r, zeros, zeros_like

数组转换

ndarray.astype, atleast_1d, atleast_2d, atleast_3d, mat

操作

array_split, column_stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, ndarray.item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack

问题

all, any, nonzero, where

排列

argmax, argmin, argsort, max, min, ptp, searchsorted, sort

运算

choose, compress, cumprod, cumsum, inner, ndarray.fill, imag, prod, put, putmask, real, sum

基础统计

cov, mean, std, var

基本线性代数

cross, dot, outer, linalg.svd, vdot

 

add,sqrt

np.around 返回四舍五入后的值，可指定精度。
around(a, decimals=0, out=None)
a 输入数组
decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
np.floor  向下取整
np.ceil 向上取整
np.where(data > 0.5, data, 0)  满足条件返回data本身，不满足用0代替
np.hstack((a,b))实现数组横向堆叠， np.column_stack 有点区别
np.vstack((a,b))实现数组纵向堆叠。

np.split(a,3)   从左到右，从上到下顺序切3个ndarray
np.hsplit(a,4) 纵向切成4块
np.vsplit(a,3) 横向切成3块
a[:,newaxis]  增加维度

ndarray的属性：

ndarray.ndim

  ndarray.ndim表示数组的维度。

ndarray.shape

  ndarray.shape是一个整型tuple，用来表示数组中的每个维度的大小。例如，对于一个n行和m列的矩阵，其shape为(n,m)。

ndarray.size

  ndarray.size表示数组中元素的个数，其值等于shape中所有整数的乘积。

ndarray.dtype

  ndarray.dtype用来描述数组中元素的类型，ndarray中的所有元素都必须是同一种类型，如果在构造数组时，传入的参数不是同一类型的，不同的类型将进行统一转化。除了标准的Python类型外，NumPy额外提供了一些自有的类型，如numpy.int32、numpy.int16以及numpy.float64等。

ndarray.itemsize

  ndarray.itemsize用于表示数组中每个元素的字节大小。

 

ndarray.sum(axis=0\1 or none)  1 is row  ;0 is column

ndarray.min(axis=? or none)

ndarray.max(axis=? or none)

ndarray.cumsum(axis=? or none)

ndarray.reshape((m,n)) ；ndarray.reshape((m,-1)) 列自动匹配,这个很重要，一般创建阵列都需要reshape一下，确保格式(2,)表示1维

ndarray.resize()  区别于reshape，直接更改数组，无返回值

ndarray.T()

 

这些完全可以用np.X(ndarray)代替

数组创建：

创建数组方法1：

np.int8([[1,2],[3,4]])  8bits,去掉1bit符号位，7位最大127.  
还有np.int16() .int32() .int64()
np.float16()  .float32()  .float64()

np.complex64()  .complex128()

创建数组方法2：

a=np.array([[1,2,3],[2,4,3]],dtype=complex)# or int \ float \ np.int8等等
也可以不指定类型：a=np.array([1,2])
a=np.ndarray(tuple\list\set)和b=np.array(-)返回的都是ndarray。np.array()内部用[] {} ()都行，但是一般都是用[]

创建方法3：

a = np.zeros((3,4))   两维
b = np.zeros((2,2,2))  三维
c = np.ones((3,3))   d = np.ones((3,3), dtype = np.int16)
e = np.arange(15)   [0,14]  ；f = np.arange(15).reshape(3,5)  ；g = np.arange(0,15,3)  [0,14]步幅为3
            h = np.arange(0,3,0.3)   ；np.arange(9).reshape(3,3)
h = np.linspace( 0, 2, 9 )  [0,2]之间，平均步幅取9个数   np.linspace( 0, 2*np.pi, 100 )
a=np.random.randint(min,max,size [] or () or none,dtype=np.int32)   ；b=np.random.random((3,2)) #3X2 [0,1]

等维数组可进行的运算:  + -  *   /  **     *= +=  -=  /=  ;或者比较：<  > ....a<3 ;a<b

以上是数值对应相做算法。矩阵乘法:A.dot(B)

当操作不同类型的数组时，最终的结果数组的类型取决于精度最宽的数组的类型。（即所谓的向上造型）

 

处理数组：（数组的索引、切片和迭代）

一维：

取值兼赋值：

单值：a[1]=N

区间值：a[1:2]=N    [1,2)

跨区间值：a[0:6:2]=N    [0,5]之间元素，步长为2     a[::-1]   颠倒顺序   （0可以省略）

二、三...维：

b[1:3:1,3:4:1]=0  中间用,隔开，每一块格式与1维相同。

b[-1]  倒数第一行

b[1, :]  第二行

数组遍历：

for row in b:
    print(row)
for element in b.flat:其中flat属性是array中的每个元素的迭代器。
    print(element)

 

NumPy中，数组的复制有三种方式：

1. Python通用的地址复制：通过 b = a 复制 a 的值，b 与 a 指向同一地址，改变 b 同时也改变 a。
2. 通过视图ndarray.view()仅复制值，当对 c 值进行改变会改变 a 的对应的值，而改变 c 的 shape 不改变 a 的 shape。
3. ndarray.copy() 进行的完整的拷贝，产生一份完全相同的独立的复制。

 

np.hstack

cv2.imshow("Histogram Equalization", np.hstack([image, eq]))  # np.hstack：两个图合并一个图，并排显示

 

 

ufunc

https://blog.csdn.net/unixtch/article/details/78531585

ufunc是universal function的缩写，意思是这些函数能够作用于narray对象的每一个元素上，而不是针对narray对象操作，numpy提供了大量的ufunc的函数。这些函数在对narray进行运算的速度比使用循环或者列表推导式要快很多，但请注意，在对单个数值进行运算时，python提供的运算要比numpy效率高。

逻辑运算and、or、not、xor等由于python提供，np.logical_or(a == b, a > b)

以bitwise_开头的函数时用于位运算，如(bitwise_and、bitwise_or)等，也可以使用&、|、~和^来进行运算。 

除了numpy提供的内置ufunc函数，用户也可以编写自定义的ufunc函数

## 基本形式

u_func = np.frompyfunc(func,nin,nout)

ret = u_func(narray_obj,param1,param2..)

numpy.vectorize()也实现了和numpy.frompyfunc()一样的功能

#a
array([[ 0],
       [10],
       [20],
       [30],
       [40],
       [50]])
#b
array([0, 1, 2, 3, 4])
# a+b
array([[ 0,  1,  2,  3,  4],
       [10, 11, 12, 13, 14],
       [20, 21, 22, 23, 24],
       [30, 31, 32, 33, 34],
       [40, 41, 42, 43, 44],
       [50, 51, 52, 53, 54]])

numpy提供了ogrid和mgrid来创建广播计算的数组，前者返回的是两个向量，后者返回的是进行广播运算的数组。

ogrid[]参数是有两种形式（1）：[start：end：step]即起点、终点和步长；（2）：[start：end：len]即起点、终点和数组长度，这里的长度为了和步长区分，在传入时时以虚数方式传入的，例如[1，5，4j]将产生[1,2,3,4]这样的数组。 
另外广播支持特殊的下标None，意义时在对应位置上产生1的新轴，例如a[None,:]等效于a.reshape((1,-1))，a[:,None]等效于a.reshape((-1,1))，另外，np.ix_()能将一维数组转换为能进行广播的二维数组：
np.ix_()支持多个参数，从而支持n维空间的广播计算。

.reduce()

.accumulate()

.reduceat()

 

矩阵运算

from numpy import *  #这样不用写np了
b=matrix([1,2,3])  #1X3
a1=array([1,2,3])
a1=mat(a1)
data1=mat(zeros((3,3))) #创建一个3*3的零矩阵，矩阵这里zeros函数的参数是一个tuple类型(3,3)
data2=mat(ones((2,4))) #创建一个2*4的1矩阵，默认是浮点型的数据，如果需要时int类型，可以使用dtype=int
data3=mat(random.rand(2,2)) #这里的random模块使用的是numpy中的random模块，random.rand(2,2)创建的是一个二维数组，需要将其转换成#matrix
data4=mat(random.randint(10,size=(3,3))) #生成一个3*3的0-10之间的随机整数矩阵，如果需要指定下界则可以多加一个参数
data5=mat(random.randint(2,8,size=(2,5))) #产生一个2-8之间的随机整数矩阵
data6=mat(eye(2,2,dtype=int)) #产生一个2*2的对角矩阵
a1=[1,2,3]
a2=mat(diag(a1)) #生成一个对角线为1、2、3的对角矩阵


a3=a1*a2 #1*2的矩阵乘以2*1的矩阵，得到1*1的矩阵
a3=multiply(a1,a2)  点乘
a2=a1*2  点乘
a2=a1.I  求逆
a2=a1.T  转置
a1.sum(axis=0) #列和，这里得到的是1*2的矩阵
a1.sum(axis=1) #行和，这里得到的是3*1的矩阵
a4=sum(a1[1,:])  #计算第一行所有列的和，这里得到的是一个数值

a1.max()   #计算a1矩阵中所有元素的最大值,这里得到的结果是一个数值
a2=max(a1[:,1]) #计算第二列的最大值，这里得到的是一个1*1的矩阵
a1[1,:].max()  #计算第二行的最大值，这里得到的是一个一个数值
np.max(a1,0)  #计算所有列的最大值，这里使用的是numpy中的max函数
np.max(a1,1)  #计算所有行的最大值，这里得到是一个矩阵
np.argmax(a1,0) #计算所有列的最大值对应在该列中的索引
np.argmax(a1[1,:])  #计算第二行中最大值对应在该行的索引
b=a[1:,1:]  #分割出第二行以后的行和第二列以后的列的所有元素
c=vstack((a,b))  #按列合并，即增加行数
d=hstack((a,b))  #按行合并，即行数不变，扩展列数
a.ndim
m,n=a.shape
number=a.size #元素总个数
str=a.dtype #元素的类型
a1=[[1,2],[3,2],[5,2]]  #列表
a2=array(a1)  #将列表转换成二维数组
a3=mat(a1)  #将列表转化成矩阵
a4=array(a3)  #将矩阵转换成数组
a41=a3.getA()  #将矩阵转换成数组
a5=a3.tolist()  #将矩阵转换成列表
a6=a2.tolist()  #将数组转换成列表
当列表是一维的时候，将它转换成数组和矩阵后，再通过tolist()转换成列表是不相同的[1, 2, 3]，[[1, 2, 3]]
a7=(a4 is a5[0])
dataMat=mat([1])
val=dataMat[0,0]  #这个时候获取的就是矩阵的元素的数值，而不再是矩阵的类型