python中numpy库的使用

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