版权声明：著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 https://blog.csdn.net/MicroWisdom/article/details/83217205
Numpy通用函数
一、数组形状— —.T/.reshape()和.resize()**
1、numpy.T ：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变
# 数组形状：.T
import numpy as np
ar1 = np.arange(1,11)
ar2 = np.zeros((2,5))
print(ar1)
print(ar2)
print('----------上面是原数组--------------')
# 注意：一维数组在转置后没有任何变化。
print(ar1.T)
# 二维数组原来是(2,5)也就是2行5列，转置后变成5行2列。
print(ar2.T)
运行结果如下：
[ 1 2 3 4 5 6 7 8 9 10]
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
----------上面是原数组--------------
[ 1 2 3 4 5 6 7 8 9 10]
[[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]]
2、numpy.reshape()：为数组提供新形状，而不更改其数据，所以元素数量需要一致！
ar3 = np.ones((3,4))
# 注意：在数组进行形状变化时，元素的个数一定要保持一致，
# 原数组为一维的有10个元素，现在变成了(2,5)即2行5列，也是10个元素
print(ar1)
print(ar1.reshape(2,5))
print('---------------------------------')
# 原来的数组元素是(3,4)也就是3行4列共12个元素，变形后为(6,2)即6行2列共12个元素。
print(ar3)
print(ar3.reshape(6,2))
print('---------------------------------')
# 可直接在数组生成的时候改变形状
print(np.zeros((5,10)).reshape(2,25))
print('---------------------------------')
# 可直接在方法内容写上形状并生成新的数组
# 注意：1、参数之间括号不要丢失。2、元素个数要相同。
print(np.reshape(np.arange(16),(4,4)))
运行结果如下：
[ 1 2 3 4 5 6 7 8 9 10]
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
---------------------------------
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 1.]
[1. 1.]
[1. 1.]
[1. 1.]
[1. 1.]
[1. 1.]]
---------------------------------
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
0.]]
---------------------------------
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
3、numpy.resize(a, new_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
# 生成的数组只有5个元素，但是resize要12个元素，所以进行了重复填充
ar4 = np.resize(np.arange(5),(3,4))
print(ar4)
print('----------------')
# 生成的数组有15个元素，但是resize要12个元素，所以将多余的元素删除了。
ar5 = np.resize(np.arange(15),(3,4))
print(ar5)
运行结果如下：
[[0 1 2 3]
[4 0 1 2]
[3 4 0 1]]
----------------
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
关于resize的特别说明
s = np.arange(10)
print('这是原数组：-->','\n',s)
# 如果对数组s直接用.resize()的话，是不生成数组的。
#print('这里没有生成任何数组：-->',s.resize(3,4))
# 如果通过np.resize()对s进行操作的话，不仅生成新数组，而且还修改了原数组“s”。
print('这里不仅生成了新的数组，而且还改变了原数组',np.resize(s,(3,4)))
# 关于上面这两句的说明：由于一个是传址一个传值，所以放在一个代码块里直接运行会报错，故将其中一句注释掉。
print('-----------------------------')
print('这里原数组"s"已经被改变了：-->','\n',s)
运行结果如下：
这是原数组：-->
[0 1 2 3 4 5 6 7 8 9]
这里不仅生成了新的数组，而且还改变了原数组 [[0 1 2 3]
[4 5 6 7]
[8 9 0 1]]
-----------------------------
这里原数组"s"已经被改变了：-->
[0 1 2 3 4 5 6 7 8 9]
二、数组复制— —直接赋值和copy()
ar6 = np.arange(10)
ar7 = ar6
print(ar7 is ar6)
# 指向内存中生成的一个值 → 这里ar6和ar7指向同一个值，所以ar7改变，ar6一起改变
ar6[2] = 666
print(ar6)
print(ar7)
print('------------------------')
# copy方法生成数组及其数据的完整拷贝
ar8 = ar6.copy()
print(ar8 is ar6)
ar6[3] = 777
print(ar6,ar8)
# 关于是传值还是传址的一些说明
a = np.arange(8)
print('数组a是这样的:','\n',a)
# 生成了新的数组。
print(np.resize(a, (2,5)), type(np.resize(a, (2,5))))
# 没有生成新的数组,结果是一个None
print(a.resize(2,4))
运行结果如下：
True
[ 0 1 666 3 4 5 6 7 8 9]
[ 0 1 666 3 4 5 6 7 8 9]
------------------------
False
[ 0 1 666 777 4 5 6 7 8 9] [ 0 1 666 3 4 5 6 7 8 9]
数组a是这样的:
[0 1 2 3 4 5 6 7]
[[0 1 2 3 4]
[5 6 7 0 1]] <class 'numpy.ndarray'>
None
三、数组堆叠— —hstack()、vstack()和stack()
1、hstack()和vstack()
# 数组堆叠 hstack()：水平（按列顺序）堆叠数组
# a为一维数组，5个元素
a = np.arange(5)
# b为一维数组,4个元素
b = np.arange(5,9)
# 对数组a和b进行水平（按列顺序）堆叠数组
# 注意:((a,b))，这里形状可以不一样
ar1 = np.hstack((a,b))
print('数组a:', a, a.shape)
print('数组b:', b, b.shape)
print('数组ar1：', ar1, ar1.shape)
# a为二维数组，3行1列
a = np.array([[1],[2],[3]])
# b为二维数组，3行1列
b = np.array([['a'],['b'],['c']])
# 二维数组的堆叠
ar2 = np.hstack((a,b))
print('二维数组a:','\n', a, a.shape)
print('二维数组b:','\n', b, b.shape)
print('二维数组ar2:','\n', ar2 ,ar2.shape)
print('----------------------------')
# 数组堆叠 vstack()：垂直（按列顺序）堆叠数组
a = np.arange(5)
b = np.arange(5,10)
# 对数组a和b进行垂直（按列顺序）堆叠数组
ar1 = np.vstack((a,b))
print('数组a:', a, a.shape)
print('数组b:', b, b.shape)
print('数组ar1：', ar1, ar1.shape)
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c'],['d']])
ar2 = np.vstack((a,b)) # 这里形状可以不一样
print('数组a:','\n', a, a.shape)
print('数组b:','\n', b, b.shape)
print('数组ar2:','\n', ar2 ,ar2.shape)
print('----------------------------')
运行结果如下：
数组a: [0 1 2 3 4] (5,)
数组b: [5 6 7 8] (4,)
数组ar1： [0 1 2 3 4 5 6 7 8] (9,)
二维数组a:
[[1]
[2]
[3]] (3, 1)
二维数组b:
[['a']
['b']
['c']] (3, 1)
二维数组ar2:
[['1' 'a']
['2' 'b']
['3' 'c']] (3, 2)
----------------------------
数组a: [0 1 2 3 4] (5,)
数组b: [5 6 7 8 9] (5,)
数组ar1： [[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
数组a:
[[1]
[2]
[3]] (3, 1)
数组b:
[['a']
['b']
['c']
['d']] (4, 1)
数组ar2:
[['1']
['2']
['3']
['a']
['b']
['c']
['d']] (7, 1)
----------------------------
2、stack()
# a b c分别是3个1维数组，每个数组都有5个元素
a = np.arange(1, 7)
b = np.arange(11, 17)
c = np.arange(101, 107)
# 查看数组，数组类型和维度
print(a, '\n', type(a), a.ndim)
print(b, '\n', type(b), b.ndim)
print(c, '\n', type(c), c.ndim)
# 将数组a、b、c进行堆叠，并增加一个维度。堆叠方式是行。
# 这里需要注意，axis的参数不是随便写的。与数组中元素的维度有关系，如果元素的维度是1，那么axis就只能是0和1。
# 当axis=0的时候堆叠方式是以行的形式来进行。即现把数组a当作第一行，数组b当作第二行，数组c当作第三行。
x = np.stack((a,b,c),axis = 0)
print(x,type(x),'\n',x.ndim)
print('_________________________')
# 当axis=1的时候堆叠方式是以列的形式来进行。即现把数组a当作第一列，数组b当作第二列，数组c当作第三列。
y = np.stack((a,b,c),axis = 1)
print(y,type(y),'\n',y.ndim)
print('_________________________')
运行结果如下：
[1 2 3 4 5 6]
<class 'numpy.ndarray'> 1
[11 12 13 14 15 16]
<class 'numpy.ndarray'> 1
[101 102 103 104 105 106]
<class 'numpy.ndarray'> 1
[[ 1 2 3 4 5 6]
[ 11 12 13 14 15 16]
[101 102 103 104 105 106]] <class 'numpy.ndarray'>
2
_________________________
[[ 1 11 101]
[ 2 12 102]
[ 3 13 103]
[ 4 14 104]
[ 5 15 105]
[ 6 16 106]] <class 'numpy.ndarray'>
2
# d e f分别是3个2维数组，每个数组都有2个元素，数组的形状是2行3列。
d = np.arange(3, 9).reshape((2, 3))
e = np.arange(13, 19).reshape((2, 3))
f = np.arange(103, 109).reshape((2, 3))
# 查看数组，数组类型和维度
print(d, '\n', type(d), d.ndim)
print(e, '\n', type(e), e.ndim)
print(f, '\n', type(f), f.ndim)
# 这里需要注意，axis的参数不是随便写的。与数组中元素的维度有关系，如果元素的维度是2，那么axis就只能是0、1、2。
# 当axis=0的时候堆叠方式是以行的形式来进行。即现把数组a当作第一行，数组b当作第二行，数组c当作第三行。
# 注意：下面print语句中的中文说明里，所写到的行和列，仅仅是对打印出的图形而言，不是真正的数组在空间中的表现。
x = np.stack((d,e,f),axis = 0)
print('当axis=0的时候堆叠方式是以行的形式来进行。即现把数组d当作第一行，数组e当作第二行，数组f当作第三行。')
print(x,type(x),'\n', x.ndim, x.shape)
print('_________________________')
print('当axis=1的时候堆叠方式是以行的方式先拆分元素，然后在按行进行堆叠。可以看出第一个3*3的数组是由是d,e,f中每个数组的第一行堆叠而成')
y = np.stack((d,e,f),axis = 1)
print(y,type(y),'\n',y.ndim, y.shape)
print('_________________________')
print('当axis=2的时候堆叠方式是以列的方式先拆分元素，然后在按列进行堆叠。可以看到第一个3*3的数组是由d,e,f中的第一列向量组合而成')
z = np.stack((d,e,f),axis = 2)
print(z,type(z),'\n',z.ndim, z.shape)
运行结果如下：
[[3 4 5]
[6 7 8]]
<class 'numpy.ndarray'> 2
[[13 14 15]
[16 17 18]]
<class 'numpy.ndarray'> 2
[[103 104 105]
[106 107 108]]
<class 'numpy.ndarray'> 2
当axis=0的时候堆叠方式是以行的形式来进行。即现把数组d当作第一行，数组e当作第二行，数组f当作第三行。
[[[ 3 4 5]
[ 6 7 8]]
[[ 13 14 15]
[ 16 17 18]]
[[103 104 105]
[106 107 108]]] <class 'numpy.ndarray'>
3 (3, 2, 3)
_________________________
当axis=1的时候堆叠方式是以行的方式先拆分元素，然后在按行进行堆叠。可以看出第一个3*3的数组是由是d,e,f中每个数组的第一行堆叠而成
[[[ 3 4 5]
[ 13 14 15]
[103 104 105]]
[[ 6 7 8]
[ 16 17 18]
[106 107 108]]] <class 'numpy.ndarray'>
3 (2, 3, 3)
_________________________
当axis=2的时候堆叠方式是以列的方式先拆分元素，然后在按列进行堆叠。可以看到第一个3*3的数组是由d,e,f中的第一列向量组合而成
[[[ 3 13 103]
[ 4 14 104]
[ 5 15 105]]
[[ 6 16 106]
[ 7 17 107]
[ 8 18 108]]] <class 'numpy.ndarray'>
3 (2, 3, 3)
四、数组拆分— —hsplit()和vsplit()
# numpy.hsplit()：将数组水平（逐列）拆分为多个子数组 → 按列拆分
# 再次强调reshape()的参数一定要和前面生成数组的个数保持一致。
ar = np.arange(9).reshape(3,3)
# 将数组ar差分成3个数组
# ar1的输出结果为列表
ar1 = np.hsplit(ar,3)
print('数组ar1：','\n',ar1, '\n', '元素的类型：', type(ar1))
print('数组ar： ', ar)
# 列表中元素为数组
ar2 = np.hsplit(ar,3)[2]
print('数组ar中下标为2的元素：','\n',ar2, '\n', '元素的类型：', type(ar2))
print('---------------------------------')
# numpy.vsplit():将数组垂直（行方向）拆分为多个子数组 → 按行拆
ar2 = np.vsplit(ar,3)
print(ar2,type(ar2))
运行结果如下：
数组ar1：
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
元素的类型： <class 'list'>
数组ar： [[0 1 2]
[3 4 5]
[6 7 8]]
数组ar中下标为2的元素：
[[2]
[5]
[8]]
元素的类型： <class 'numpy.ndarray'>
---------------------------------
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])] <class 'list'>
五、数组简单运算
ar = np.arange(6).reshape(2,3)
# 加法
print(ar + 10)
# 乘法
print(ar * 2)
# 除法
print(1 / (ar+1))
# 幂
print(ar ** 0.5)
# 常用函数
# 求平均值
print(ar.mean())
# 求最大值
print(ar.max())
# 求最小值
print(ar.min())
# 求标准差
print(ar.std())
# 求方差
print(ar.var())
# 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
print(ar.sum(), np.sum(ar,axis = 0))
# 排序
print(np.sort(np.array([1,4,3,2,5,6])))
运行结果如下：
[[10 11 12]
[13 14 15]]
[[ 0 2 4]
[ 6 8 10]]
[[1. 0.5 0.33333333]
[0.25 0.2 0.16666667]]
[[0. 1. 1.41421356]
[1.73205081 2. 2.23606798]]
2.5
5
0
1.707825127659933
2.9166666666666665
15 [3 5 7]
[1 2 3 4 5 6]