numpy数据的基本操作

在基本运算之前需要了解到numpy数据的一些基本概念

1. 广播特征

2. 轴

1. 基本运算

1.1数组和数

>>> t1 = np.arange(12).reshape(3,4)
>>> print(t1)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
>>> t1-1
array([[-1,  0,  1,  2],
       [ 3,  4,  5,  6],
       [ 7,  8,  9, 10]])
>>> t1+1
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> t1*2
array([[ 0,  2,  4,  6],
       [ 8, 10, 12, 14],
       [16, 18, 20, 22]])
>>> t1/2
array([[0. , 0.5, 1. , 1.5],
       [2. , 2.5, 3. , 3.5],
       [4. , 4.5, 5. , 5.5]])
>>> t1/0
array([[nan, inf, inf, inf],
       [inf, inf, inf, inf],
       [inf, inf, inf, inf]])

加减乘除是针对数组中每一个数都进行的操作，也就是数据的广播机制：

广播机制： 广播( Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。受限于某些限制，较小的阵列在较大的阵列上“广播”，以便它们具有兼容的形状。
广播原则： 如果两个数组的后缀维度（trailing demention 从末尾算起的维度）的轴长度相符或者其中一个长度为1，则认为他们是广播兼容的，广播会在确实或者长度为1的维度上进行
np.shape对应的数字个数

拆解动作： t1 + 5 == t1+ np.full((3,4), 5)
会将5转化为同等形状大小的数组，然后按照其相同的索引进行加减乘除运算

nan： 不是一个数 np.nan != np.nan (类型未知，不等式成立)
inf： 无穷大数
后面再说

轴： 前面所说的轴对应数组的维度即也是shape对应数字的个数，
一维数组只有0轴， 2维数组有0,1轴 依次类推
轴的方向， 参考维度坐标轴，0轴对应x轴， 1轴对应y轴， 2轴对应z轴

>>> t1 = np.arange(12).reshape(3,4)
>>> t2 = np.array([1,2,3]).reshape(3,1)
>>> t3 = np.array([1,2,3,4])
>>> t1
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> t2
array([[1],
       [2],
       [3]])
>>> t3
array([1, 2, 3, 4])
>>> t1+t2
array([[ 1,  2,  3,  4],
       [ 6,  7,  8,  9],
       [11, 12, 13, 14]])
>>> t1+t3
array([[ 1,  3,  5,  7],
       [ 5,  7,  9, 11],
       [ 9, 11, 13, 15]])

1.2数组和数组

基本操作如上述1.1章节所示，相同形状的大小的数组在各自相同坐标对应的数字进行运算，结果返回新的数组。

原地操作： *= +=

>>> b = np.full((3,4), 3)
>>> print(b)
[[3 3 3 3]
 [3 3 3 3]
 [3 3 3 3]]
>>> t1+=b
>>> t1
array([[ 3,  4,  5,  6],
       [ 7,  8,  9, 10],
       [11, 12, 13, 14]])
>>> t1*=b
>>> t1
array([[ 9, 12, 15, 18],
       [21, 24, 27, 30],
       [33, 36, 39, 42]])
>>>

1.3乘积

>>> c = np.arange(12).reshape(4,3)
>>> c
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
>>> t1 @ c
array([[ 288,  342,  396],
       [ 504,  606,  708],
       [ 720,  870, 1020]])
>>> t1.dot(c)
array([[ 288,  342,  396],
       [ 504,  606,  708],
       [ 720,  870, 1020]])

2. 其他的通函数

通函数：NumPy提供熟悉的数学函数，例如sin，cos和exp。在NumPy中，这些被称为通函数， 在NumPy中，这些函数在数组上按元素进行运算，产生一个数组作为输出。

>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> np.exp(a)
array([ 1.        ,  2.71828183,  7.3890561 , 20.08553692])
>>> np.sqrt(a)
array([0.        , 1.        , 1.41421356, 1.73205081])
>>> b = np.array([1.,3.,4.,5.])
>>> np.add(a,b)
array([1., 4., 6., 8.])

常见的其他的通用函数：
all， any， apply_along_axis， argmax， argmin， argsort， average， bincount， ceil， clip， conj， corrcoef， cov， cross， cumprod， cumsum， diff， dot， floor， inner， INV ， lexsort， max， maximum， mean， median， min， minimum， nonzero， outer， prod， re， round， sort， std， sum， trace， transpose， var， vdot， vectorize， where

3. 索引和切片

3.1索引

同python列表索引操作，一维的只有一个下标，二维的2个，一次类推

注意NumPy中特殊的是bool索引，下标出为条件语句，输出结果

>>> t1 = np.arange(12).reshape(3,4)
>>> t1[1]
array([4, 5, 6, 7])
>>> t1[1][2]
6
>>> t1[t1>2]
array([ 3,  4,  5,  6,  7,  8,  9, 10, 11])

如果想要访问某一列且看切片操作

3.2切片

同python列表切片操作，对于对位数据切片可使用[]方式，维度使用，隔开

>>> t1[:2] # 0-1行
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> t1[:,2]  #3列 
array([ 2,  6, 10])
>>> t1[1,2]  # 2行3列
6
>>> t1[1:,2] # 1行到末尾，3列  取交集
array([ 6, 10])
>>> t1[:1,2:] # 0-1行，2列到末尾 取交集
array([[2, 3]])

针对某一行或者某一列时操作同python-list， 当某个维度取所有时使用 : 代替，多维度连续取所有时使用...代替（一定要有开始或者结尾的维度，否则无意义）， 取不连续的多行多列使用[[1,2],[2,3]]方式

>>> t2 = np.arange(24).reshape(1,2,3,4)
>>> t2[...,1]
array([[[ 1,  5,  9],
        [13, 17, 21]]])
>>> t2[...,1,1]
array([[ 5, 17]])
>>> t2[:,:,1,1]  # 等同上面操作
array([[ 5, 17]])

>>> t1[[0,2],[1,3]] #  取（0,1） （2,3）
array([ 1, 11])

4. 形状操作

4.1改变形状

>>> t1 = np.arange(24).reshape((4,6))
>>> t1
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]])
>>> t1.reshape((2,12))  ##  == t1.reshape(2, -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]])
>>> t1.ravel()
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])
>>> t1.T    # 矩阵的转置
array([[ 0,  6, 12, 18],
       [ 1,  7, 13, 19],
       [ 2,  8, 14, 20],
       [ 3,  9, 15, 21],
       [ 4, 10, 16, 22],
       [ 5, 11, 17, 23]])

前面操作所提到的np.reshape(# 数字个数代表维度数量， 数字大小代表维度大小)
操作原有的数组改变其维度。所有数字乘积为数组大小。

4.2列表堆叠

延不同的轴堆叠

>>> a = np.array([[1,3],[2,4]])
>>> b = np.array([[1,4],[3,5]])
>>> np.vstack((a,b))
array([[1, 3],
       [2, 4],
       [1, 4],
       [3, 5]])
>>> np.hstack((a,b))
array([[1, 3, 1, 4],
       [2, 4, 3, 5]])

column_stack 允许将1维的延列方向堆叠到2维中去

>>> a = np.array([4.,2.])
>>> b = np.array([3.,8.])
>>> np.column_stack((a,b))# returns a 2D array
array([[4.,3.],[2.,8.]])

c_, r_ 允许使用操作符: ,将数组堆叠

>>> np.r_[1:4,0,4]
array([1,2,3,0,4])

4.3数组的拆分

>>> a = np.arange(24).reshape((2,12))
>>> a
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]])
>>> np.hsplit(a, 3)
[array([[ 0,  1,  2,  3],
       [12, 13, 14, 15]]), array([[ 4,  5,  6,  7],
       [16, 17, 18, 19]]), array([[ 8,  9, 10, 11],
       [20, 21, 22, 23]])]
>>> np.hsplit(a,(3,4,6))
[array([[ 0,  1,  2],
       [12, 13, 14]]), array([[ 3],
       [15]]), array([[ 4,  5],
       [16, 17]]), array([[ 6,  7,  8,  9, 10, 11],
       [18, 19, 20, 21, 22, 23]])]

注意，hsplit第二个参数为单个数字是等分， 如果是元祖，则为一个升序的元祖，意为按照特定的航哥或者列切分，切分后的数量为元组长度+1, 也就是元组最后一个值大于等于其维度大小是，最后一个为空

>>> np.hsplit(a,(3,4,12))
[array([[ 0,  1,  2],
       [12, 13, 14]]), array([[ 3],
       [15]]), array([[ 4,  5,  6,  7,  8,  9, 10, 11],
       [16, 17, 18, 19, 20, 21, 22, 23]]), array([], shape=(2, 0), dtype=int64)]
>>> np.hsplit(a,(3,4,13))
[array([[ 0,  1,  2],
       [12, 13, 14]]), array([[ 3],
       [15]]), array([[ 4,  5,  6,  7,  8,  9, 10, 11],
       [16, 17, 18, 19, 20, 21, 22, 23]]), array([], shape=(2, 0), dtype=int64)]

vsplit（延垂直方向）同hsplit操作。