numpy基础总结

1.Numpy的对象

Numpy中处理的对象类型为名为ndarray的n维数组类型，但和列表list不同，列表中的元素可以不为同一类型如[1,“name”:“xiaohei”]，但ndarray中的元素相同。

#数组
a=np.array([1,2,3,4,])
b=a
c=b
c[0]=2 #改变c时，a、b都会变 >>>a=[2,2,3,4] 

#列表操作
a1=[1,2,3]
b1=a1
c1=b1
c1.append(4)
print(a1)
print(b1)    #a1=[1,2,3,4]  a1 is b1 = True

在python中变量和数据的关系都同上例，上述操作，三个变量都指向同一个数据，当变一个标签指向的数据时，其他都会改变，要想其他标签指向的数据不变可以使用numpy的copy属性。

a=np.array([1,2,3,4,])
b=a.copy() #有self参数，要加（）
a[0]=2
print(a,id(a))
print(b,id(b))

[2 2 3 4] 1782376961008
[1 2 3 4] 1782376843264

数组和列表的不同

list_1=[1,2,3]
arr1=np.array([1,2,3])
arr2=np.array([[1,2,3],4])
list_1+=list_1
arr1+=arr1
arr2+=arr2
print(list_1)
print(arr1)
print(arr2)

[1, 2, 3, 1, 2, 3]
[2 4 6]
[list([1, 2, 3, 1, 2, 3]) 8]

[[a,b,c,d]]和[a,b,c,d]的区别——数型为（1，n）和（n,)的区别

import  numpy as np
arr1=np.array([1,2,3,4])
arr2=np.array([[1,2,3,4]])
print(arr1.shape,arr1.T,arr1[0])
print("----"*10)
print(arr2.shape,arr2.T,"\n",arr2[0],arr2[0,0])

总结一下就是(n,)数型的数组可看成一个列表，转置后不变，索引的用法和列表一样形式为[索引值]；但（1，n）可进行转置，且如果要用索引找出某个元素，需要使用数组的索引方法，具体看后面的索引部分。

2.数组的创建

array

np.array(x)
np.array(x, dtype) #指定数据类型

生成一个指定元素的数组，使用array（[]）生成一维数组时，默认数组的shape为（n，），若想要数组的shape为（1，n）应再加一个[]。(使用arange生成一维数组不用reshape指定时，数组的shape也为（n，)

import  numpy as np
a=np.array([1,2,3,4])
b=np.array(([1,2,3,4]))
c=np.array([[1,2,3,4]])
d=np.array([(1,2,3,4)])
e=np.array([[[1,2,3,4]]])
f=np.array([((1,2,3,4))])
print("a为",a,a.shape)
print("b为",b,b.shape)
print("c为",c,c.shape)
print("d为",d,d.shape)
print("e为",e,e.shape)
print("f为",f,f.shape)

a为 [1 2 3 4] (4,)
b为 [1 2 3 4] (4,)
c为 [[1 2 3 4]] (1, 4)
d为 [[1 2 3 4]] (1, 4)
e为 [[[1 2 3 4]]] (1, 1, 4)
f为 [[1 2 3 4]] (1, 4)

从上面可看出，在很多层时（）可能会造成与预期维数不同的结果，最好还是都选择用[ ]。以上创建的数组都为一维，要想创建多维的数组，需要在外面多加[]或者（），且要保证各行的元素个数一致。

array=np.array(([1,2,3],[1,2,3]))    #array和array_1输出为两行三列的矩阵
array_1=np.array([[1,2,3],[1,2,3]])
array_2=np.array([[1],[2],[3]])      #array_2为三行单列矩阵，与array([1,2,3])不同   
print(array)
print(array_1)
print(array_2)
print("数组维度",array.ndim)         #ndim表示数组维度的数量，不是行数
print("形状",array.shape)           #shape形状属性 
print("元素个数",array.size)        #数组中总元素个数   

empty

numpy.empty(shape, dtype = float, order = 'C') 
# dtype 数据类型默认为浮点型
#有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

作用：生成随机元素的数组

arr1=np.empty((2,3))
print(arr1)

生成一个两行三列的随机数组，如下：

[[5.11798223e-307 1.37961370e-306 1.37960012e-306]
 [4.22802739e-307 1.24611470e-306 8.34423493e-308]]

zeros

numpy.zeros(shape, dtype = float, order = 'C')

arr1 = np.zeros((2,3))
arr1 = np.zeros((2,3),dtype=np.int16)
print(arr1)

[[0. 0. 0.]
 [0. 0. 0.]]
[[0 0 0]
 [0 0 0]]

ones

numpy.ones(shape, dtype = None, order = 'C')

arr1 = 10*np.ones((2,3))
print(arr1)

[[10. 10. 10.]
 [10. 10. 10.]]

arange

numpy.arange(start, stop, step, dtype)

使用arange创建，arange有四个参数，arange(start=None, stop=None, step=None, dtype=None)：

• Start指定了起始位置；
• stop指定了结束位置（不包含该值）；
• step指定步长，默认为1；
• dtype指定数据类型；

arr1=np.arange(0,10)
arr2=np.arange(0,10).reshape((2,5))
print(arr1)
print(arr2)

[0 1 2 3 4 5 6 7 8 9]  
#shape 为(10,) ,若输出为[[ 0  1  2  3  4  5  6  7  8  9]]则shape才为（1，10）
[[0 1 2 3 4]
 [5 6 7 8 9]]

注意创建范围为左闭右开，相同的range,字符串、列表的切片、numpy.random.randint等

linspace

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

使用linespace创建数组

• start和stop：指定了起始和结束位置
• num：指定了数组中元素的数量,不指定时默认为50；
• endpoint：指定是否包含结束位置的值，默认包含；
• retstep：为True时，返回数组以及数组之间的步长；

import  numpy as np
arr1=np.linspace(0,9)
arr2=np.linspace(0,9,10)
print(len(arr1))
print(arr2)

50
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

logspace

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

多使用logspace创建等比数列。

• start和stop：指定了启示和结束位置，但与linspace的直接指定不同，指定的为base（默认为10）的幂次；
• num：数组中元素的数量；
• endpoint：指定是否包含结束位置的值，默认包含；
• base:以什么数为底，默认为10；

import  numpy as np
arr1=np.logspace(1,2,2)
arr2=np.logspace(1,2,3)
arr3=np.logspace(1,3,3,base=2)
print(arr1)
print(arr2)
print(arr3)

常用的numpy.random函数

详细见https://blog.csdn.net/kancy110/article/details/69665164.

3.数组的数形

shape

shape返回数组的维度元组，也可用于调整数组的维度，用法为shape，后面不跟参数，没有shape()。

import numpy as np
arr1 = np.array([[1,2,3,4,5,6],[1,2,3,4,5,6]])
print(arr1)
print(arr1.shape)
arr1.shape = (6,2)
print(arr1)

[[1 2 3 4 5 6]
 [1 2 3 4 5 6]]
(2, 6)
[[1 2]
 [3 4]
 [5 6]
 [1 2]
 [3 4]
 [5 6]]

import numpy as np
a = np.arange(24)
b = a.reshape(2,4,3)  # b 现在拥有三个维度
c=a.reshape(3,8)
print(b)
print(c)
print (b.ndim)
print(c.ndim)

[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]
  [ 9 10 11]]

 [[12 13 14]
  [15 16 17]
  [18 19 20]
  [21 22 23]]]
[[ 0  1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14 15]
 [16 17 18 19 20 21 22 23]]
3
2

注：对于一行多列的数组要特别注意，创建的一行n列数组的shape可能为（1，n）或为（n,)，列如直接用array和arange定义且不用reshape时为（n,）；但用zeros，ones（（1，n））时指令中规定了shape为（1，n）。实际情况如下：

a=np.zeros((1,5),dtype=int)
b=np.array([1,2,3,4])
c=np.array([1,2,3,4]).reshape(1,4)
d=np.array([[1,2],[3,4]])
print(a[0],"a的shape为",a.shape)
print(b[0],"b的shape为",b.shape)
print(c[0],"c的shape为",c.shape)
print(b.T,"b.T的shape为",b.T.shape)
print(c.T,"c.T的shape为",c.T.shape)

输出结果如下：

[0 0 0 0 0] a的shape为 (1, 5) #对于（1，n）型的数组要想列出单个元素，要用[i,j]而不能直接用[i]
1 b的shape为 (4,)             #对于（n,)型的数组索引可认为和列表相似
[1 2 3 4] c的shape为 (1, 4)
[1 2 3 4] b.T的shape为 (4,)
[[1]
 [2]
 [3]
 [4]] c.T的shape为 (4, 1)

reshape

reshape也可用来调整数组的维度，但该方法并不会改变原来数组的维度，只会返回一个改变维度后的数组。

a.reshape(2,3)等价于a.reshape((2,3))

注：其他指令如果不加（）如np.zeros(2,1)会导致出现错误；有的命令如np.random.rand(2,3)生成一个2X3的随机[0,1)的数组，如果用np.random.rand((2,3))则会报错。

import numpy as np
arr1 = np.array([[1,2,3,4,5,6],[1,2,3,4,5,6]])
print(arr1)
print(arr1.shape)
arr2 = arr1.reshape((6,2))
print(arr1)
print(arr2)

[[1 2 3 4 5 6]
 [1 2 3 4 5 6]]
(2, 6)
[[1 2 3 4 5 6]
 [1 2 3 4 5 6]]
[[1 2]
 [3 4]
 [5 6]
 [1 2]
 [3 4]
 [5 6]]

注：只写arr1.reshape而不给变量接受的话，不会对原数据进行改变。变量名相当于标签或者指针，数据保存在内存中一个位置。

arr1=np.array([1,2,3,4])
arr1.reshape(2,2)
print(arr1)            #输出结果仍为[1,2,3,4]   

当你想将形状（a，b，c，d）的矩阵X平铺成形状（b * c * d，a）的矩阵时，可以使用以下代码

arr=np.arange(24).reshape(4,3,2)
arr1=arr.reshape(arr.shape[0],-1)   #>>>转换为（4，6）
arr2=arr.reshape(arr.shape[1],-1)   #>>>转换为（3，8)
arr3=arr.reshape(arr.shape[0],-1).T #>>>转换为（6，4）
print(arr.shape)
print(arr1,arr1.shape)
print(arr2,arr2.shape)
print(arr3,arr3.shape)

输出结果：

(4, 3, 2)
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]] (4, 6)
[[ 0  1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14 15]
 [16 17 18 19 20 21 22 23]] (3, 8)
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]] (6, 4)

特殊的，如果不指定前面的shape，会默认平铺为一行，且shape为（n，）；可用reshape（1，-1）输出shape为(1,n)的数组

a=np.arange(12).reshape(2,3,2)
b=a.reshape(-1) #或者b=a.reshape((-1))
c=a.reshape(1,-1)
print(b,b.shape)
print(c,c.shape)

输出结果：[ 0 1 2 3 4 5 6 7 8 9 10 11] (12,)

​ [[ 0 1 2 3 4 5 6 7 8 9 10 11]] (1, 12)

reshape（-1，n）——“-1”放在前面

a=np.array([1,2,3,4,5,6]).reshape(-1,1)
b=np.array([1,2,3,4,5,6]).reshape(-1,2)
c=np.array([1,2,3,4,5,6]).reshape(-1)
print(a,a.shape)
print(b,b.shape)
print(c,c.shape)

输出结果如下：

[[1]
 [2]
 [3]
 [4]
 [5]
 [6]] (6, 1)
[[1 2]
 [3 4]
 [5 6]] (3, 2)
[1 2 3 4 5 6] (6,)

综上reshape(n,-1)和reshape(-1,n)的用法相似，前者是先确定数组的行数，后者先确定列数，之后根据元素个数进行分配。

numpy.squeeze()

在机器学习和深度学习中，通常算法的结果是可以表示向量的数组（即包含两对或以上的方括号形式[[]]），如果直接利用这个数组进行画图可能显示界面为空（链接文章中有例子）。我们可以利用squeeze（）函数将表示向量的数组转换为秩为1的数组，这样利用matplotlib库函数画图时，就可以正常的显示结果了。详细内容见https://blog.csdn.net/zenghaitao0128/article/details/78512715。

flatten 、ravel

ndarray.flatten(order='C')
ndarray.ravel(order='C')

ndarry.flatten()和ndarry.ravel() 展平数组的元素

order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

a = np.arange(6).reshape(2, 3)
b=a.flatten()
c=a.ravel()
print(b)
print(c)

[0 1 2 3 4 5]
[0 1 2 3 4 5]

翻转数组

ndarry.T   
ndarry.transpose()
np.transpose(ndarry)

a = np.arange(6).reshape(2, 3)
b=np.transpose(a)
print(a)
print(b)
print(a.transpose())
print(a.T) 

4.数组的切片和索引

切片

import numpy as np
arr1 = np.arange(0,10)
arr2 = slice(1,5,1)
print("arr1:",arr1)
print("arr2:",arr2)
print(arr1[arr2])
print(arr1[1:5:1])

arr1: [0 1 2 3 4 5 6 7 8 9]
arr2: slice(1, 5, 1)
[1 2 3 4]
[1 2 3 4]

以上为基本的切片形式，对于多行数组的切片的特殊情况如下：

import numpy as np
arr1 = np.arange(0,10).reshape((2,5))
print("arr1:",arr1)
print("第一行数据为：",arr1[0])   #0 表示索引        
print("第一列数据为：",arr1[:,0])
print("第一行第一列数据为",arr1[0,0])(应用的索引)
print("第一行第一,二列数据为",arr1[0,:2]) print("第一行第一,二列数据为",arr1[:1,:2])
print("第一,二行第一,二列数据为",arr1[:,:2])
print("第一,二行第一,二列数据为",arr1[0:2,0:2])
print("第一,二行所有列中偶数列数据为",arr1[0:2,::2])

arr1: [[0 1 2 3 4]
 [5 6 7 8 9]]
第一行数据为： [0 1 2 3 4]
第一列数据为： [0 5]
第一行第一列数据为 0
第一行第一,二列数据为 [0 1]
第一,二行第一,二列数据为 [[0 1]
 [5 6]]
第一,二行第一,二列数据为 [[0 1]
 [5 6]]
第一,二行所有列中偶数列数据为 [[0 2 4]
 [5 7 9]]

索引

import numpy as np
arr1 = np.arange(0,10).reshape((2,5))
print("arr1:",arr1)
print(arr1[[0,1],[2,3]])   
#[0,1]为行索引，[2,3]为列索引，对应的元素位置为(0,2),(1,3)，为下面的整数数组索引形式，指定选中元素的行列坐标。
print(arr1[0,2])  #相当于 arr1[0][2]
print(arr1[0][2])
print(arr1[[0],[2]])

输出结果：

arr1: [[0 1 2 3 4]
 [5 6 7 8 9]]
[2 8]
2
2
[2]

arr3= np.array([[1,2,3],[3,4,5],[4,5,6]])
print(arr3)
print(arr3[1:])

[[1 2 3]
 [3 4 5]
 [4 5 6]]
[[3 4 5]
 [4 5 6]]

整数数组索引

以下代码为获取数组中(0,0),(1,1),(2,0)位置处的元素

import  numpy as np
x = np.array([[1,  2],  [3,  4],  [5,  6]])
y = x[[0,1,2],  [0,1,0]]
print (y)

输出为：

[1 4 5]

以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。

int (x)
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
z=x[[0,0,3,3],[[0,2,0,2]]]
print (y)
print(z)

输出结果为：

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
[[ 0  2  9 11]]
[[ 0  2]
 [ 9 11]]

索引加切片

arr[[1,3],[:2]]——表示第一三行中前两列的数据。

布尔索引及赋值应用

如果想把t中小于十的数替换为0，否则替换为10,用numpy的三元计算符：

利用切片和索引进行行列的交换：

用 与“&” , 或“|”来选择满足多个布尔条件 ：

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

5.数组的合并分割

合并

np.concatenate((a1, a2, ...), axis)  #axis默认为0
np.vstack((a,b))
np.hstack((a,b))

a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
#列合并
print (np.concatenate((a,b)))   
print(np.vstack((a,b)))   
#行合并
print (np.concatenate((a,b),axis = 1))
print (np.hstack((a,b)))

分割

np.split(arr, indices_or_sectionsindices_or_sections, axis)
np.vsplit(arr,indices_or_sections)
np.hsplit(arr,indices_or_sections)

6.数组的添加和删除

append

numpy.append 函数在数组的末尾添加值。

np.append(arr, values, axis=None)

• arr：输入数组
• values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
• axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print('向数组添加元素：')
print(np.append(a, [7, 8, 9]))
print('沿轴 0 添加元素：')
print(np.append(a, [[7, 8, 9]], axis=0))
print('沿轴 1 添加元素：')
print(np.append(a, [[5, 5, 5], [7, 8, 9]], axis=1))

[[1 2 3]
 [4 5 6]]
向数组添加元素：
[1 2 3 4 5 6 7 8 9]
沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]
沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

insert

numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值， 插入函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。

np.insert(arr, obj, values, axis)

参数说明：

• arr：输入数组
• obj：在其之前插入值的索引
• values：要插入的值
• axis：沿着它插入的轴，如果未提供，则输入数组会被展开

a = np.array([[1, 2], [3, 4], [5, 6]])
print('第一个数组：')
print(a)
print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.insert(a, 3, [11, 12]))
print('传递了 Axis 参数。 会广播值数组来配输入数组。')
print('沿轴0广播：')
print(np.insert(a, 1, 11, axis=0))
print('沿轴0添加：')
print(np.insert(a, 2, [11,12], axis=0))
print('沿轴1广播：')
print(np.insert(a, 1, 11, axis=1))
print('沿轴1添加：')
print(np.insert(a,1,[1,2,3],axis=1))

第一个数组：
[[1 2]
 [3 4]
 [5 6]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]
传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴0广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]
沿轴0添加：
[[ 1  2]
 [ 3  4]
 [11 12]
 [ 5  6]]
沿轴1广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]
沿轴1添加：
[[1 1 2]
 [3 2 4]
 [5 3 6]]

delete

numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

np.delete(arr, obj, axis)

• arr：输入数组
• obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
• axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

a = np.arange(12).reshape(3, 4)
print('第一个数组：')
print(a)
print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.delete(a, 5))
print('删除第二列：')
print(np.delete(a, 1, axis=1))

第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]
删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]

7.迭代数组

numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式，对数组中每个元素都进行处理，还可以使用flat属性，该属性是一个数组元素迭代器

a = np.arange(6).reshape(2, 3)
print('原始数组是：')
print(a)
print('迭代输出元素：')
for x in np.nditer(a):
    print(x, end=", ")
print("\n")
for y in a.flat:
    print(y,end=", ")

输出结果：

原始数组是：
[[0 1 2]
 [3 4 5]]
迭代输出元素：
0, 1, 2, 3, 4, 5, 

0, 1, 2, 3, 4, 5, 

对于转置矩阵元素输出顺序详情见：https://www.runoob.com/numpy/numpy-terating-over-array.html

如果要遍历整个矩阵，for循环是非常合适的选择。

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
for row in a:
    print(row) # >>> [1 2 3]
               # >>> [4 5 6]
               # >>> [7 8 9]
for col in a.T:
    print(row) # >>> [1 2 3]
               # >>> [4 5 6]
               # >>> [7 8 9]

8.数组运算

dot

arr1=np.array([[1,2],[0,1]])
arr2=np.arange(4).reshape((2,2))
result_1=arr1*arr2
result_2=np.dot(arr1,arr2)
result_3=arr1.dot(arr2)
print(result_1)
print(result_2)
print(result_3)

*为对应元素相乘，调用dot为矩阵的乘法。

最值与求和

注：numpy中的轴axis

arr1=np.arange(4).reshape((2,2))
a=np.max(arr1,axis=0)
b=np.sum(arr1)
a=np.argmax(arr1,axis=0)

axis=0表示对列进行操纵，axis=1表示对行，（axis=0表示二维数组的行方向，在求和求最大值等操作时，axis=0表示行方向的个数不变（即列数不变），对列进行操作）不说明表示为整个数组。argmax ，argmin表示最值的索引值。

a=np.array([[1,2,3],[4,5,6]])
sum_0=np.sum(a)
sum_1=np.sum(a,axis=0)
sum_2=np.sum(a,axis=1)
max_0=np.max(a)
max_1=np.max(a,axis=0)
max_2=np.max(a,axis=1)
print(sum_0,sum_1,sum_2)
print(max_0,max_1,max_2)
>>>
21 [5 7 9] [ 6 15]
6 [4 5 6] [3 6]

注numpy中的keepdims=True，在深度学习中常用

import numpy as np
a = np.array([[1,2],[3,4]])
#按行相加，并且保持其二维特性
print(np.sum(a, axis=1, keepdims=True),np.sum(a, axis=1, keepdims=True).shape)
#按行相加，不保持其二维特性
print(np.sum(a, axis=1),np.sum(a, axis=1).shape)

输出结果：

[[3]
 [7]] (2, 1)
[3 7] (2,)

我们使用（keepdims = True）来确保 A.shape 是（n,1）而不是（n，），它使我们的代码更加严格,容易减少深度学习中代码bug 。

a=np.array([1,2,4,5]).reshape(1,4)
# 在定义一行的数组时最好reshape一下，不然（n,)型容易出错，如果不reshape，以下定义axis=1就会#出错
b=np.sum(a,axis = 1)
c=np.sum(a,axis = 1, keepdims = True)
print(b.shape)
print(c.shape)

输出结果：

(1,)
(1, 1)

np.pad

https://blog.csdn.net/zenghaitao0128/article/details/78713663

A=np.arange(95,99).reshape(2,2)
pad_0=np.pad(A,((3,2),(2,3)),'constant',constant_values = (0,0))
pad_1=np.pad(A,((3,2),(2,3)),'constant',constant_values = ((0,0),(1,2)))
print(pad_0)
print(pad_1)
[[ 0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0]
 [ 0  0 95 96  0  0  0]
 [ 0  0 97 98  0  0  0]
 [ 0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0]]

[[ 1  1  0  0  2  2  2]
 [ 1  1  0  0  2  2  2]
 [ 1  1  0  0  2  2  2]
 [ 1  1 95 96  2  2  2]
 [ 1  1 97 98  2  2  2]
 [ 1  1  0  0  2  2  2]
 [ 1  1  0  0  2  2  2]]

其中constant填充时轴axis的用法和以上求和等axis的用法一样。如以上pad_0中（3，2）表示在axis=0的轴前边缘填充3个0在轴的后边缘填充2个0，因为此情况为两维数组axis=0表示按行方向，和以上求和等axis的方法一样，列数不变添加行数；同理 （2，3）表示在axis=1的情况下即行数不变增加填充列数。

9.广播

lhttps://www.runoob.com/numpy/numpy-broadcast.html.

参考
https://www.runoob.com/python/python-tutorial.html
https://blog.csdn.net/u011587322/article/details/80746639