深度学习中用到的numpy数组格式转换命令汇总

numpy格式转换相关命令

1.1 np.squeeze()——从数组的形状中删除单维度条目，即把shape中为1的维度去掉

格式：np.squeeze(a,axis=None)

​ 1.a表示输入的数组;

​ 2.axis用于指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错;

​ 3.axis的取值可为None 或 int 或 tuple of ints, 可选。若axis为空，则删除所有单维度的条目;

​ 4.返回值：数组；

​ 5.不会修改原数组；

import numpy as np

e = np.arange(10).reshape(1, 2, 5)
print("e=\n", e, "\ne.shape=", e.shape)
a = np.squeeze(e)
print("a=\n", a, "\na.shape=", a.shape)

结果：

e=	a=
[[[0 1 2 3 4] [5 6 7 8 9]]]	[[0 1 2 3 4] [5 6 7 8 9]]
e.shape= (1, 2, 5)	a.shape= (2, 5)

---

1.2 np.zeros_like(a)——即产生一个维度和a一样大小的全0数组

格式：np.zeros_like(a,dtype=None,order="K",subok=True,shape=None)

1. a表示输入的数组;

2. dtype指定输出数组中数字的类型，默认情况下与数组a中的类型一致；

3. 返回值：数组

4. 不会修改原数组；

import numpy as np

a = np.arange(10).reshape(2, 5)
print("e=\n", a, "\na.shape=", a.shape)

z=np.zeros_like(a)
print("z=\n", z, "\nz.shape=", z.shape)

结果：

a=	z=
[[0 1 2 3 4] [5 6 7 8 9]]	[[0 0 0 0 0] [0 0 0 0 0]]
a.shape= (2, 5)	z.shape= (2, 5)

---

1.3 np.copy()——深拷贝,拷贝前的地址和拷贝后的地址不一样，拷贝成一个新数组

格式：np.copy(a,order="K"，subok=False)

import numpy as np

x = np.array([1, 2, 3])
y = x	#浅拷贝x，y也指向x所指的内存空间
z = np.copy(x)	#深度拷贝x，讲x中的元素取出，放在新的内存空间中，z指向该空间

print("id(x)", id(x))
print("id(y)", id(y))
print("id(z)", id(z))

x[1] = 10
print("x=", x, "\ny=", y, "\nz=", z)

结果：

id(x)= 1870442628800 id(y)= 1870442628800 id(z)= 1870442629040
x= [ 1 10 3] y= [ 1 10 3] z= [1 2 3]

---

1.4 np.concatenate() —— 连接 NumPy 数组，并返回一个新数组

格式：np.concatenate((a1,a2,.....),axis=0,out=None)

作用：连接意味着将两个或多个数组的内容放在单个数组中，在 NumPy 中，我们按轴连接数组，我们传递了一系列要与轴一起连接到 concatenate() 函数的数组。如果未显式传递轴，则将其视为 0(默认axis=0,可以不写)

axis=0时 行后面加行

axis=1时 列后面加列

import numpy as np

arr1 = np.arange(1, 7).reshape(2, 3)
arr2 = np.arange(7, 13).reshape(2, 3)

print("arr1=\n", arr1)
print("arr2=\n", arr2)

arr = np.concatenate((arr1, arr2), axis=0)	#两个数组上下拼接，保证两个数组有相同的列
print("arr(axis=0)=\n", arr)
arr = np.concatenate((arr1, arr2), axis=1)	#俩个数组左右拼接，保证两个数组有相同的行
print("arr(axis=1)=\n", arr)

结果：

arr1=	arr2=
[[1 2 3] [4 5 6]]	[[ 7 8 9] [10 11 12]]

axis=0 时：arr=——上下拼接 （要求列相同）	axis=1 时，arr=——左右拼接（要求行相同）
[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]	[[ 1 2 3 7 8 9] [ 4 5 6 10 11 12]]

axis=None 时：arr=
[ 1 2 3 4 5 6 7 8 9 10 11 12]

---

1.5 np.reshape()——在不改变数据内容的情况下，改变一个数组的格式

格式：np.reshape(a,newshape,order="C")

1. a:需要处理的数组

2. newshape:指定要变成的格式，整数或整数数组，如（2，3）表示2行3列。新的形状应该与原来的形状兼容，即行数和列数相乘后等于a中的元素数量，整数数组时，其中一个数据可以为-1,这个数据的值python会自动计算出来

3. order 可选范围{“C”,“F”,"A”}，使用索引苏洵读取数组a中的元素，并按照索引顺序讲元素放到变换后的数组中，如果不进行order参数的设置，默认参数为C.

   (1). "C"指用类C索引顺序读/写的元素，最后一个维度变化最快，第一个维度最慢。以二维数组为例，简单来说就是横着读，横着写，优先读/写一行。

   (2). "F"指用FORTRAN类索引顺序读/写的元素，最后一个维度最慢，第一个维度最快。同样的以二维数组为例，就是竖着读，竖着写，优先读/写一列。"C"和"F"不考虑底层数组的内存布局，只引用索引的顺序。

   (3). "A"所生成的数组效果与原数组a的数据存储方式相同，a按照FORTRAN存储，则生成效果与"F"相同，否则则与“C"相同。

   注：FORTRAN和C是两个语言，他们存储数组的方式不同，FORTRSAN为列有限，而C为行优先。在python中默认数组生成的时候是按照C的方式进行存储

   4. 返回一个新数组

   import numpy as np
   
   a = np.arange(1, 13).reshape(4, 3)
   
   r1 = np.reshape(a, (3, 4), order='A')
   r2 = np.reshape(a, (3, 4), order='F')
   
   print("a=\n", a)
   print("r1=\n", r1)
   print("r2=\n", r2)
   

   结果：

   a=	r1=	r2=
   [[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]	[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]]	[[ 1 10 8 6] [ 4 2 11 9] [ 7 5 3 12]]

   *部分类容借用：

   ---