numpy ------Good

 come from : https://blog.csdn.net/jayloncheng/article/category/7643404

numpy数组的创建

一、用python列表创建数组
import numpy as np
np.array([1,2,3,4])#用列表创建一维数组
np.array([1,2,3,4],dtype='float')#在创建时用关键字dtype明确地设置数组的数据类型
二、用Numpy内置方法创建数组

import numpy as np
#np.zeros(shape, dtype=None, order='C')
#创建shape是3x5的全1(默认浮点型)数组
np.zeros((3,5))
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])
 
#np.ones(shape, dtype=None, order='C')
#创建shape是3x5的全1(默认浮点型)数组
np.ones((3,5))
array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])
 
#np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
#创建一个形状为 N x N 的单位矩阵（二维数组）
np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
 
#empty(shape, dtype=float, order='C')
#创建一个形状为shape的未初始化数组，值为随机值
np.empty(3)
array([1., 1., 1.])
 
#np.full(shape, fill_value, dtype=None, order='C')
#创建shape是3x5的(默认浮点型)数组，值fill_value都是3.14
np.full((3,5),3.14)
array([[3.14, 3.14, 3.14, 3.14, 3.14],
       [3.14, 3.14, 3.14, 3.14, 3.14],
       [3.14, 3.14, 3.14, 3.14, 3.14]])
 
#与python内置range()函数内置
#arange([start,] stop[, step,], dtype=None)
np.arange(5)
array([0, 1, 2, 3, 4])
 
#np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
#产生一个5个元素的数组，这5个数均匀地分配到0~10
np.linspace(0,10,num=5)
array([ 0. ,  2.5,  5. ,  7.5, 10. ])

numpy数组属性：ndim,shape,size,dtype,itemsize,nbytes

import numpy as np
#numpy数组属性：ndim,shape,size,dtype,itemsize,nbytes
x = np.eye(5)
x
Out[2]:
 
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])
 
x.ndim#数组的维度
Out[3]:
 
2
x.shape#数组的形状
Out[4]:
 
(5, 5)
 
x.size#数组的元素个数
Out[5]:
 
25
 
x.dtype#数组的数据类型
Out[6]:
 
dtype('float64')
 
x.itemsize#数组的每个元素占用的内存大小，以字节为单位
Out[7]:
 
8
 
x.nbytes#数组占用的总内存大小，以字节为单位
Out[8]:
 
200


一、索引的作用

  获取、修改数组单个元素的值

 
二、获取单个元素的值
1，在一维数组中：
import numpy as np 
x = np.array([5,3,6,9,8]) 
 
x[0] #索引为非负值，获取第i个值，从0开始计数
Out[8]:5 
 
x[-1] #索引为负值，从末尾开始索引，倒数第一个索引为-1 
Out[9]:8
2，在多维数组中：

import numpy as np 
x = np.eye(3)
 
x 
Out[10]:
array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])
 
x[0,1] #用逗号分隔的索引元组获取元素 
Out[11]:0.0
三、修改单个元素的值
上接前面的例子：
x[0,1]=5 #通过索引修改数组单个元素的值  
 
x  
Out[13]:  
array([[1., 5., 0.],  
       [0., 1., 0.],  
       [0., 0., 1.]]) 



切片语法：
x[ start : stop : step ]

一、一维数组的切片

import numpy as np
x = np.arange(5,13)
x
Out[4]:array([ 5, 6, 7, 8, 9, 10, 11, 12])
x[:3]#前3个元素，即索引0~2所代表的元素
Out[6]:array([5, 6, 7])
x[3:]#索引3及往后的所有元素
Out[7]:array([ 8, 9, 10, 11, 12])
x[::2]#每隔一个元素
Out[8]:array([ 5, 7, 9, 11])
x[::-1]#数组元素逆序
Out[9]:array([12, 11, 10, 9, 8, 7, 6, 5])

二、多维数组的切片
      以二维为例：
import numpy as np
x=np.random.randint(0,11,(3,4))
 
x
Out[12]:
array([[2, 7, 3, 0],
       [1, 1, 0, 1],
       [4, 3, 0, 6]])
 
x[:2,:3]#前两行，前三列
Out[13]:
array([[2, 7, 3],
       [1, 1, 0]])
 
x[::-1,::-1]#数组所有元素逆序
Out[15]:
array([[6, 0, 3, 4],
       [1, 0, 1, 1],
       [0, 3, 7, 2]])
 
#获取二维数组的单行和单列:索引+切片
x[:,1]#第2列
Out[16]:
array([7, 1, 3])
 
 
 
三、数组切片返回的不是数据的副本
    与python内置数据类型list相区别，list切片返回的是值的副本。而numpy数组切片返回的是数组数据的视图，不是数值数据的副本（摘自python数据科学手册），接下来从代码理解：
x
Out[19]:
array([[2, 7, 3, 0],
       [1, 1, 0, 1],
       [4, 3, 0, 6]])
 
x_sub = x[:2,:2]
x_sub
Out[22]:
array([[2, 7],
       [1, 1]])
 
x_sub[0,0]=5 #数组切片的值被修改后，原数组也被修改了
Out[23]:
array([[5, 7, 3, 0],
       [1, 1, 0, 1],
       [4, 3, 0, 6]])
四、创建numpy数组的副本
       用copy()方法。代码略.


常用的两种变形方法：reshape()函数、newaxis关键字
一、reshape()
使用条件：原始数组的大小（size）必须和变形后的一致。
注意：reshape()方法会用到原始数组的非副本视图

>>> grid = np.arange(1,10).reshape((3,3))
>>> grid
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
二、newaxis
newaxis将一个一维数组变成二维的行或列的矩阵
>>> x = np.array([1,2,3])

>>> y=x [ np.newaxis , : ]  #变成二维的行向量
>>> y
array([[1, 2, 3]])

>>> y=x[ : , np.newaxis ]  #变成二维的列向量
>>> y
array([[1],
       [2],
       [3]])


拼接方法：np.concatenate、np.vstack、np.hstack、np.dstack
分裂方法：np.split、np.vsplit、np.hsplit、np.dsplit
一、数组的拼接
1，np.concatenate
将数组列表（或元组）作为第一个参数，轴作为第二个参数（默认为axis=0）
#一维数组的拼接
>>> import numpy as np
>>> x = np.array([1,2,3])
>>> y = np.array([4,5,6])
>>> z = np.array([7,8,9])
>>> np.concatenate([x,y,z])
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
#二维数组的拼接
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0) #沿着第一个轴
array([[1, 2], [3, 4], [5, 6]])
>>> np.concatenate((a, b.T), axis=1) #沿着第二个轴
array([[1, 2, 5], [3, 4, 6]])
2，np.vstack（垂直栈）
将数组列表（或元组）作为唯一参数，沿着第一个轴（axis=0）拼接


>>> a = np.array([1, 2, 3])
>>> b = np.array([2, 3, 4])
>>> np.vstack((a,b))
array([[1, 2, 3],
       [2, 3, 4]])
 
>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[2], [3], [4]])
>>> np.vstack((a,b))
array([[1],
       [2],
       [3],
       [2],
       [3],
       [4]])
3，np.hstack(水平栈)
将数组列表（或元组）作为唯一参数，沿着第二个轴(axis=1)拼接
>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.hstack((a,b))
array([1, 2, 3, 2, 3, 4])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.hstack((a,b))
array([[1, 2],
       [2, 3],
       [3, 4]])
二、数组的分裂
1，np.split


第一个参数是被分裂的数组，第二个参数是记录分裂点位置的索引列表或者表示分成几份的一个整数,第三个参数是要沿哪个轴分裂（默认axis=0)

>>> x = np.arange(9.0)
>>> np.split(x, 3)
[array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.,  8.])]
 
>>> x = np.arange(8.0)
>>> np.split(x, [3, 5, 6, 10])
[array([ 0.,  1.,  2.]),
 array([ 3.,  4.]),
 array([ 5.]),
 array([ 6.,  7.]),
 array([], dtype=float64)]
2，np.vsplit
沿着axis=0方向分裂。第一个参数是被分裂的数组，第二个参数是记录分裂点位置的索引列表或者表示分成几份的一个整数
>>> x = np.arange(16.0).reshape(4, 4)
>>> x
array([[  0.,   1.,   2.,   3.],
       [  4.,   5.,   6.,   7.],
       [  8.,   9.,  10.,  11.],
       [ 12.,  13.,  14.,  15.]])
>>> np.vsplit(x, 2)
[array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.]]),
 array([[  8.,   9.,  10.,  11.],
       [ 12.,  13.,  14.,  15.]])]
>>> np.vsplit(x, np.array([3, 6]))
[array([[  0.,   1.,   2.,   3.],
       [  4.,   5.,   6.,   7.],
       [  8.,   9.,  10.,  11.]]),
 array([[ 12.,  13.,  14.,  15.]]),
 array([], dtype=float64)]
3,np.hsplit
沿着axis=1方向分裂。第一个参数是被分裂的数组，第二个参数是记录分裂点位置的索引列表或者表示分成几份的一个整数

>>> x = np.arange(16.0).reshape(4, 4)
>>> x
array([[  0.,   1.,   2.,   3.],
       [  4.,   5.,   6.,   7.],
       [  8.,   9.,  10.,  11.],
       [ 12.,  13.,  14.,  15.]])
>>> np.hsplit(x, 2)
[array([[  0.,   1.],
       [  4.,   5.],
       [  8.,   9.],
       [ 12.,  13.]]),
 array([[  2.,   3.],
       [  6.,   7.],
       [ 10.,  11.],
       [ 14.,  15.]])]
>>> np.hsplit(x, np.array([3, 6]))
[array([[  0.,   1.,   2.],
       [  4.,   5.,   6.],
       [  8.,   9.,  10.],
       [ 12.,  13.,  14.]]),
 array([[  3.],
       [  7.],
       [ 11.],
       [ 15.]]),
 array([], dtype=float64)]
注意：np.dstack用于沿着第三个维度拼接，类似，np.dsplit用于沿着第三个维度分裂。因为一般我们接触到最多的是两个维度的数据，就不对这两个函数作深入研究了


numpy的通用函数可以对数组进行向量化操作，可以提高数组元素的重复计算的效率。


一、算数运算符
numpy的算数运算符都是对python内置运算符的封装。
>>> import numpy as np
>>> x = np.arange(4)
>>> x
array([0, 1, 2, 3])
>>> x+2
array([2, 3, 4, 5])
>>> np.add(x,2)#加法
array([2, 3, 4, 5])
>>> x-2
array([-2, -1,  0,  1])
>>> np.subtract(x,2)#减法
array([-2, -1,  0,  1])
>>> x*2
array([0, 2, 4, 6])
>>> np.multiply(x,2)#乘法
array([0, 2, 4, 6])
>>> x/2
array([0. , 0.5, 1. , 1.5])
>>> np.divide(x,2)#除法
array([0. , 0.5, 1. , 1.5])
>>> x**2
array([0, 1, 4, 9], dtype=int32)
>>> np.power(x,2)#乘方
array([0, 1, 4, 9], dtype=int32)
>>> x//2
array([0, 0, 1, 1], dtype=int32)
>>> np.floor_divide(x,2)#地板除法
array([0, 0, 1, 1], dtype=int32)
>>> x%2
array([0, 1, 0, 1], dtype=int32)
>>> np.mod(x,2)#取余
array([0, 1, 0, 1], dtype=int32)

二、绝对值
>>> x=np.array([-1,-3,-5])
>>> np.abs(x)#取绝对值
array([1, 3, 5])


三、三角函数及反三角函数

>>> theta=np.linspace(0,np.pi,3)#180°均分成3份
>>> theta
array([0.        , 1.57079633, 3.14159265])
 
>>> np.sin(theta)#正弦函数
array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])
 
>>> np.cos(theta)#余弦函数
array([ 1.000000e+00,  6.123234e-17, -1.000000e+00])
 
>>> np.tan(theta)#正切函数
array([ 0.00000000e+00,  1.63312394e+16, -1.22464680e-16])
>>> 
注：由于计算机的截断，舍入误差，有些为零的地方没有精确到零，但非常小。
>>> x=np.array([-1,0,1])
 
>>> np.arcsin(x)
array([-1.57079633,  0.        ,  1.57079633])
 
>>> np.arccos(x)
array([3.14159265, 1.57079633, 0.        ])
 
>>> np.arctan(x)
array([-0.78539816,  0.        ,  0.78539816])
>>> 

四、指数及对数运算

>>> x=np.array([1,2,3])
 
>>> np.exp(x)
array([ 2.71828183,  7.3890561 , 20.08553692])
 
>>> np.power(3,x)
array([ 3,  9, 27], dtype=int32)
>>> x=np.array([1,8,64,100])
 
>>> np.log(x) #自然对数ln(x)
array([0.        , 2.07944154, 4.15888308, 4.60517019])
 
>>> np.log2(x)
array([0.        , 3.        , 6.        , 6.64385619])
 
>>> np.log10(x)
array([0.        , 0.90308999, 1.80617997, 2.        ])
>>> 
注意：log(x)表示的是自然对数ln(x)


一、常用函数
1、np.max()
作用：找出最大值
>>> import numpy as np
>>> x = np.array([[-1,3,0],[5,2,7]])
>>> x
array([[-1,  3,  0],
       [ 5,  2,  7]])
 
>>> np.max(x)
7
2、np.min()
作用：找出最小值
>>> np.min(x)
-1

3、np.sum()
作用：计算所有元素之和
>>> np.sum(x)
16

4、np.prod()
作用：计算数组中所有元素之积
>>> np.prod(x)
0

5、np.std()
作用：计算元素的标准差
>>> np.std(x)
2.748737083745107

6、np.var()
作用：计算元素的方差
>>> np.var(x)
7.555555555555556

7、np.mean()
作用：计算元素的平均值
>>> np.mean(x)
2.6666666666666665

 8、np.median()
作用：计算元素的中位数
>>> np.median(x)
2.5

9、np.any()
作用：判断是否存在为真的元素。
>>> np.any(x) #即判断是否存在不为零的元素。
True


10、np.all()
作用：判断是否所有元素为真
>>> np.all(x) #即判断是否所有的元素不为零。
 
False

二、高级用法
1、沿某个维度进行统计
默认情况下，每一个numpy的统计函数都是对数组中所有元素进行操作的。我们可以用关键字参数axis指定沿着哪个轴进行统计。

>>> import numpy as np
>>> x = np.array([[-1,3,0],[5,2,7]])
>>> x
array([[-1,  3,  0],
       [ 5,  2,  7]])
 
>>> np.min(x,axis=0)#找到每一列的最小值
array([-1,  2,  0])
 
>>> np.min(x,axis = 1)#找到每一行的最小值
array([-1,  2])
2、选取满足所给条件的值
这里涉及到布尔操作，仅作简单介绍。


2.1 布尔操作
布尔运算符：&(与) 、| (或) 、^(异或) 、 ~(非)，它们是按位运算的，对二进制的比特位进行逻辑操作。
>>> bin(10) #bin()得到二进制形式
'0b1010'
>>> bin(6)
'0b110'
>>> 10 & 6
2
>>> bin(10 & 6)
'0b10'
2.2 比较操作
比较运算符：>,<,<=,>=,!=,==，对数组的每一个元素进行比较操作。
比较操作得到的是布尔数组。

>>> x
array([[-1,  3,  0],
       [ 5,  2,  7]])
>>> x>0
array([[False,  True, False],
       [ True,  True,  True]])
2.3 用布尔数组作为筛选条件选取符合条件的元素

>>> x
array([[-1,  3,  0],
       [ 5,  2,  7]])
>>> x[ (x>0)&(x<6)] #选取大于0且小于6的元素
array([3, 5, 2])