numpy支持的数据类型： bool_ 布尔型数据类型（True 或者 False） int_ 默认的整数类型（类似于 C 语言中的 long，int32 或 int64） intc 与 C 的 int 类型一样，一般是 int32 或 int 64 intp 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64） int8 字节（-128 to 127） int16 整数（-32768 to 32767） int32 整数（-2147483648 to 2147483647） int64 整数（-9223372036854775808 to 9223372036854775807） uint8 无符号整数（0 to 255） uint16 无符号整数（0 to 65535） uint32 无符号整数（0 to 4294967295） uint64 无符号整数（0 to 18446744073709551615） float_ float64 类型的简写 float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位 float32 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位 float64 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位 complex_ complex128 类型的简写，即 128 位复数 complex64 复数，表示双 32 位浮点数（实数部分和虚数部分） complex128 复数，表示双 64 位浮点数（实数部分和虚数部分） 使用np.dtype表示数据类型 int8, int16, int32, int64 四种数据类型可以使用字符串 ‘i1’, ‘i2’,‘i4’,‘i8’ 代替 结构化数据类型 dt = np.dtype([(‘age’,np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a) 输出为 [(10,) (20,) (30,)] 类型字段名可以用于存取实际的 age 列 import numpy as np dt = np.dtype([(‘age’,np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a[‘age’]) 则可以取出a这个数组的age列 student = np.dtype([(‘name’,‘S20’), (‘age’, ‘i1’), (‘marks’, ‘f4’)]) print(student) [(‘name’, ‘S20’), (‘age’, ‘i1’), (‘marks’, ‘f4’)] import numpy as np student = np.dtype([(‘name’,‘S20’), (‘age’, ‘i1’), (‘marks’, ‘f4’)]) a = np.array([(‘abc’, 21, 50),(‘xyz’, 18, 75)], dtype = student) print(a) [(‘abc’, 21, 50.0), (‘xyz’, 18, 75.0)] 每个内建类型都有一个唯一对应的字符代码，如下： b 布尔型 i (有符号) 整型 u 无符号整型 integer f 浮点型 c 复数浮点型 m timedelta（时间间隔） M datetime（日期时间） O (Python) 对象 S, a (byte-)字符串 U Unicode V 原始数据 (void) axis为numpy中的维度和轴，axis=0为对每一列进行操作，axis为对每一行操作。 属性 说明 ndarray.ndim 秩，即轴的数量或维度的数量 ndarray.shape 数组的维度，对于矩阵，n 行 m 列 ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值 ndarray.dtype ndarray 对象的元素类型 ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位 ndarray.flags ndarray 对象的内存信息 ndarray.real ndarray元素的实部 ndarray.imag ndarray 元素的虚部 ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 a = np.arange(24) print (a.ndim) # a 现只有一个维度 b = a.reshape(2,4,3) # b 现在拥有三个维度 a为0到23的数字依次递增1 改变形状后为 array([[[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11]], [[12, 13, 14], [15, 16, 17], [18, 19, 20], [21, 22, 23]]]) 先分为2个再分为3个，一维数组中有3个元素 shape表示此数组的维度 b.shape = （2，4，3） 且利用shape和reshape可以改变数组大小和形状。 b.shape= (4,6) b array([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]]) 或者b.reshape(3,8) b.reshape(3,8) array([[ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20, 21, 22, 23]]) b.itemsize返回每个元素的值的大小 b.flags返回该数组的内存信息，包含一下属性： C_CONTIGUOUS © 数据是在一个单一的C风格的连续段中 F_CONTIGUOUS (F) 数据是在一个单一的Fortran风格的连续段中 OWNDATA (O) 数组拥有它所使用的内存或从另一个对象中借用它 WRITEABLE (W) 数据区域可以被写入，将该值设置为 False，则数据为只读 ALIGNED (A) 数据和所有元素都适当地对齐到硬件上 UPDATEIFCOPY (U) 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新 b = np.empty（[size],dtype=…） 同理可创建全为1的数组或全为1的数组 //默认为浮点数，但是可以设置元素种类，比如 np.int或者自定义类型 dtype=[(‘x’,‘i4’),(‘y’,‘i4’)] numpy从已有数组创建数组 numpy.asarray(a, dtype = None, order = None) a 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 dtype 数据类型，可选 order 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 numpy.fromiter可以在可迭代对象中创建ndarray对象，返回一维数组 numpy.fromiter(iterable,dtype,count=-1) iterable 可迭代对象 dtype 返回数组的数据类型 count 读取的数据数量，默认为-1，读取所有数据
list=range(5)
>>> it=iter(list)
>>> it
<range_iterator object at 0x000001CAE9215DD0>
>>> x=np.fromiter(it,float)
>>> x
array([0., 1., 2., 3., 4.])
numpy.arange(start,stop,step,dtype) numpy.linspace创建一个一维数组，且为等差数列构成的 np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) start 序列的起始值 stop 序列的终止值，如果endpoint为true，该值包含于数列中 num 要生成的等步长的样本数量，默认为50 endpoint 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 retstep 如果为 True 时，生成的数组中会显示间距，反之不显示。 dtype ndarray 的数据类型
>>>a = np.linspace(1,3,23,True,True)
>>> a
(array([1. , 1.09090909, 1.18181818, 1.27272727, 1.36363636,
1.45454545, 1.54545455, 1.63636364, 1.72727273, 1.81818182,
1.90909091, 2. , 2.09090909, 2.18181818, 2.27272727,
2.36363636, 2.45454545, 2.54545455, 2.63636364, 2.72727273,
2.81818182, 2.90909091, 3. ]), 0.09090909090909091)
>>>
可以看出此为等差数列，最后一项为步长 numpy.logspace 函数用于创建一个于等比数列。格式如下： np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
>>> a = np.logspace(1,2,10)
>>> a
array([ 10. , 12.91549665, 16.68100537, 21.5443469 ,
27.82559402, 35.93813664, 46.41588834, 59.94842503,
77.42636827, 100. ])
>>> a = np.logspace(0,5,10,base = 2)
>>> a
array([ 1. , 1.46973449, 2.16011948, 3.1748021 , 4.66611616,
6.85795186, 10.0793684 , 14.8139954 , 21.77264 , 32. ])
>>>
numpy切片和索引 切片可以利用内置的slice函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
>>> a = np.arange(10)
>>> s=slice(2,8,3)
>>> a[s]
array([2, 5])
>>> b = a[2:8:3]
>>> b
array([2, 5])
还有下面几种索引方式：
>>> a = np.array([[1,2,3],[2,2,2],[1,8,9]])
>>> print(a[...,1])
[2 2 8]
>>> print(a[1,...])
[2 2 2]
>>> print(a[1:,...])
[[2 2 2]
[1 8 9]]
>>> print(a[...,1:])
[[2 3]
[2 2]
[8 9]]
根据矩阵可以很明显看出这几种索引的不同。 整数数组索引：
>>> x=np.array([[1,2],[3,4],[5,6]])
>>> y = x[[0,1,2],[0,1,1]]
>>> y
array([1, 4, 6])
这个分为行索引和列索引，表示找到(0,0)(1,1)(2,1)处的元素 布尔索引：
>>> x=np.array([[1,2],[3,4],[5,6]])
>>>> print(x[x>3])
[4 5 6]
或可以使用~来表示非，例如：
>>> a = np.array([np.nan,1,2,np.nan,3,4,5])
>>> print(~np.isnan(a))
[False True True False True True True]
>>> print(a[~np.isnan(a)])
[1. 2. 3. 4. 5.]
还可以过滤复数：
>>> a = np.array([1, 2+1j ,3,9j])
>>> print(a[np.iscomplex(a)])
[2.+1.j 0.+9.j]
花式索引 指的是利用整数数组进行索引，例如：
>>> x
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31]])
>>> print(x[[4,2,1,7]])
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
传入倒序索引数组，例如：
>>> print(x[[-4,-2,-1,-7]])
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
传入多个索引数组（要使用np.ix_），例如：
>>> print(x[np.ix_([1,5,7,2],[0,3,1,2])])
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
ix_产生笛卡尔积，得到（1,0）,(1,3),(1,1)…以此类推。 numpy广播是numpy对不同形状的数组进行数值计算的方式。例如：
>>> a = np.array([1,2,3,4])
>>> b = np.array([10,20,30,40])
>>> c =a * b
>>> c
array([ 10, 40, 90, 160])
当两个数组形状不同时，numpy将自动触发广播机制。例如：
>>> a = np.array([[ 0, 0, 0],
... [10,10,10],
... [20,20,20],
... [30,30,30]])
>>> b = np.array([1,2,3])
>>> a+b
array([[ 1, 2, 3],
[11, 12, 13],
[21, 22, 23],
[31, 32, 33]])
当两者不能进行正常相加减的时候就会触发广播机制，这与下面的效果是等价的，例如：
>>> bb=np.tile(b,(4,1))
>>> a+bb
array([[ 1, 2, 3],
[11, 12, 13],
[21, 22, 23],
[31, 32, 33]])
tile函数是将原矩阵横向纵向的复制。 tile(mat,(1,4)) 将列复制为原来的四倍
>>> np.tile(b,4)
array([1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])
>>> np.tile(b,(1,4))
array([[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]])
numpy迭代数组 可以使用numpy.nditer()来创建一个迭代器，例如下面的：
>>> for x in np.nditer(bb):
... print(x)
output = 1 2 3 1 2 3 1 2 3 1 2 3
a和a的转置遍历顺序相同，他们在内存中的存储数据也是一样的。 因此迭代顺序二者相同。但是a.T.copy(order = ‘C’)它默认是按行访问，它与前两种存储方式不同。 或者加入order='C/F’表示按行访问或者按列访问。 修改数组中的值 有个可选参数op_flags。默认情况下是只读对象，可以将其设置为read-write或者write-only. 使用外部循环，nditer类的构造器有多个flags参数，可以接受以下的值： c_index 可以跟踪 C 顺序的索引 f_index 可以跟踪 Fortran 顺序的索引 multi-index 每次迭代可以跟踪一种索引类型 external_loop 给出的值是具有多个值的一维数组，而不是零维数组 例如下面的例子：
>>> for i in np.nditer(a, flags= ['external_loop'],order = 'F'):
... print(i,end =',')
...
[0 9],[ 3 12],[ 6 15],
广播迭代： nditer可以同时迭代两个不同的数组，例如下面的式子：
>>> a = np.arange(0,60,5)
>>> a = a.reshape(3,4)
>>> a
array([[ 0, 5, 10, 15],
[20, 25, 30, 35],
[40, 45, 50, 55]])
>>> b = np.array([1,2,3,4],int)
>>> for x,y in np.nditer([a,b]):
... print("%d:%d" % (x,y),end=",")
...
0:1,5:2,10:3,15:4,20:1,25:2,30:3,35:4,40:1,45:2,50:3,55:4,
numpy数组操作： reshape 不改变数据的条件下修改形状 flat 数组元素迭代器 flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 ravel 返回展开数组
>>> a = np.arange(0,60,5)
>>> a
array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55])
>>> a = a.reshape(3,4)
>>> a
array([[ 0, 5, 10, 15],
[20, 25, 30, 35],
[40, 45, 50, 55]])
>>> for i in a:
... print(i)
...
[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]
>>> for element in a.flat:
... print(element)
...
0
5
10
15
20
25
30
35
40
45
50
55
>>> np.ravel(a,'C')
array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55])
翻转数组： transpose 对换数组的维度 ndarray.T 和 self.transpose() 相同 rollaxis 向后滚动指定的轴 swapaxes 对换数组的两个轴
>>> np.transpose(a)
array([[ 0, 20, 40],
[ 5, 25, 45],
[10, 30, 50],
[15, 35, 55]])
>>> a.T
array([[ 0, 20, 40],
[ 5, 25, 45],
[10, 30, 50],
[15, 35, 55]])
np.swapaxes(0,2)，即轴0和轴1交换。比如第一个元素arr[0,0,0]，交换后仍是arr[0,0,0]；第二个元素arr[0,0,1]，交换后则为arr[1,0,0]；…；最后一个元素arr[1,1,2]，交换后为arr[2,1,1]。
>>> a
array([[[0, 1],
[2, 3]],
[[4, 5],
[6, 7]]])
>>> np.swapaxes(a,2,0)
array([[[0, 4],
[2, 6]],
[[1, 5],
[3, 7]]])
numpy数学函数： 提供了标准的三角函数，sin（），cos（），tan（）。 并且可以通过np.pi/180来转化角度。例如：
>>> a = np.array([0,30,45,60,90])
>>> print(np.sin(a*np.pi/180))
[0. 0.5 0.70710678 0.8660254 1. ]
>>> inv = np.arcsin(0.5)
>>> np.degrees(inv)
30.000000000000004
舍入函数： numpy.around() 函数返回指定数字的四舍五入值。 numpy.around(a,decimals)例如：
>>> a = np.array([17.8, 11, 0, 5.55, 0.567, 25.532])
>>> np.around(a,1)
array([17.8, 11. , 0. , 5.6, 0.6, 25.5])
>>> np.around(a,0)
array([18., 11., 0., 6., 1., 26.])
>>> np.around(a,-1)
array([20., 10., 0., 10., 0., 30.])
向下取整，向上取整： numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。例如：
>>> np.floor(a)
array([-2., 1., -1., 0., 10.])
>>> np.ceil(a)
array([-1., 2., -0., 1., 10.])
numpy算术函数： NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。
需要注意的是数组必须具有相同的形状或符合数组广播规则。 例如：
>>> a = np.arange(9, dtype=np.float_).reshape(3,3)
>>> a
array([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]])
>>> b = np.array([10,10,10])
>>> np.add(a,b)
array([[10., 11., 12.],
[13., 14., 15.],
[16., 17., 18.]])
>>> np.subtract(a,b)
array([[-10., -9., -8.],
[ -7., -6., -5.],
[ -4., -3., -2.]])
>>> np.subtract(b,a)
array([[10., 9., 8.],
[ 7., 6., 5.],
[ 4., 3., 2.]])
>>> np.multiply(a,b)
array([[ 0., 10., 20.],
[30., 40., 50.],
[60., 70., 80.]])
>>> np.divide(a,b)
array([[0. , 0.1, 0.2],
[0.3, 0.4, 0.5],
[0.6, 0.7, 0.8]])
numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。
>>> np.reciprocal([0.25,1.33])
array([4. , 0.7518797])
numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。例如：
>>> a = np.array([10,4,5])
>>> b = np.array([1,2,3])
>>> np.power(a,b)
array([ 10, 16, 125], dtype=int32)
但是它必须符号广播的条件，否则就会出错。
>>> np.power(a,[1,2])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,) (2,)
numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。例如：
>>> a = np.array([10,4,5])
>>> b = np.array([10,10,10])
>>> np.mod(a,b)
array([0, 4, 5], dtype=int32)
>>> np.mod(b,a)
array([0, 2, 0], dtype=int32)
numpy统计函数： numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。 例如：
>>> a
array([[3, 7, 5],
[8, 4, 3],
[2, 4, 9]])
>>> np.amin(a,1)
array([3, 3, 2])
>>> np.amin(a,0)
array([2, 4, 3])
>>> np.amax(a,0)
array([8, 7, 9])
>>> np.amax(a,1)
array([7, 8, 9])
numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
>>> a
array([[3, 7, 5],
[8, 4, 3],
[2, 4, 9]])
>>> np.ptp(a)
7
>>> np.ptp(a,1)
array([4, 5, 7])
>>> np.ptp(a,0)
array([6, 3, 6])
标准差： np.std([1,2,3,4])
>>> np.std([1,2,3,4])
1.118033988749895
方差：np.var([1,2,3,4])
>>> np.var([1,2,3,4])
1.25
numpy排序 种类 速度 最坏情况 工作空间 稳定性 ‘quicksort’（快速排序） 1 O(n^2) 0 否 ‘mergesort’（归并排序） 2 O(nlog(n)) ~n/2 是 ‘heapsort’（堆排序） 3 O(nlog(n)) 0 否 numpy.sort() 函数返回输入数组的排序副本。函数格式如下： numpy.sort(a, axis, kind, order) numpy.argsort() 函数返回的是数组值从小到大的索引值。 numpy线性代数： dot 两个数组的点积，即元素对应相乘。 vdot 两个向量的点积 inner 两个数组的内积 matmul 两个数组的矩阵积 determinant 数组的行列式 solve 求解线性矩阵方程 inv 计算矩阵的乘法逆矩阵 矩阵的内积为对应位置的乘积加起来维度不变。例如：
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[11,12],[13,14]])
>>> np.dot(a,b)
array([[37, 40],
[85, 92]])
计算式为：
[[111+213, 112+214],[311+413, 312+414]] numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。 例如：
>>> np.vdot(a,b)
130
计算式为： 111 + 212 + 313 + 414 = 130 numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。例如： numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。
对于二维数组，它就是矩阵乘法：
>>> a = [[1,0],[0,1]]
>>> b = [[2,3],[1,4]]
>>> np.matmul(a,b)
array([[2, 3],
[1, 4]])
numpy.linalg.det() 函数计算输入矩阵的行列式。例如：
>>> np.linalg.det(a)
1.0
numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。例如：
>>> a = [[1,0],[0,1]]
>>> np.linalg.inv(a)
array([[1., 0.],
[0., 1.]])
Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。 例如下面的使用：
>>> from matplotlib import pyplot as plt
>>> x = np.arange(1,11)
>>> y = x * 2 +5
>>> plt.title("Demo")
Text(0.5,1,'Demo')
>>> plt.xlabel("x axis caption")
Text(0.5,0,'x axis caption')
>>> plt.ylabel("y axis caption")
Text(0,0.5,'y axis caption')
>>> plt.plot(x,y)
[<matplotlib.lines.Line2D object at 0x000001FB5EFB7FD0>]
>>> plt.show()
显示为： 具体python的数据可视化需要下来自己补充学习，这里就不赘述了。 参考地址：https://www.runoob.com/numpy/numpy-tutorial.html