numpy知识点汇总
文章目录
- numpy数组
- 数组的创建
- 1.arange函数
- 2.array函数
- 3.zeros函数
- 4.ones函数
- 5.empty()函数（注意）
- 数组的维度
- 1.shape函数
- 2.reshape函数
- 3.resize函数
- 4.ravel函数与flatten函数
- 数组的组合方法
- 1.vstack函数
- 2.hstack函数
- 3.dstack函数
- 4.stack函数
- 5.concatenate函数
- 数组的分割方法
- 1.hsplit函数
- 2.vsplit函数
- 3.dsplit函数
- 其他属性
- 1.transpose()
- 2.flat
- 3.tolist()
- 4.astype()
numpy数组
数组的创建
1.arange函数
辅助reshape函数可以创建任意维度的数组
print(np.arange(5)) # 创建一维数组
print(np.arange(9).reshape(3, 3)) # 创建二维及更高数组以此类推
print(np.arange(10, step=2)) # 指定步长
输出
[0 1 2 3 4]
[[0 1 2]
[3 4 5]
[6 7 8]]
[0 2 4 6 8]
2.array函数
可以自定义创建数组
print(np.array([1, 2, 3, 4]))
print(np.array([[1, 2], [3, 4]]))
print(np.array([1, 2, 3, 4], dtype = 'str'))
输出
[1 2 3 4]
[[1 2]
[3 4]]
['1' '2' '3' '4']
3.zeros函数
创建元素全为0的一维及更高数组
print(np.zeros(5))
print(np.zeros((3, 3)))
输出
[0. 0. 0. 0. 0.]
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
4.ones函数
与zeros函数差不多，ones函数创建元素全为1的一维及更高数组
print(np.ones(5))
print(np.ones((3, 3)))
输出
[1. 1. 1. 1. 1.]
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
5.empty()函数（注意）
empty函数是创建一个空的数组，但是要注意的是，它创建的数组里面的元素是不为空的，使用时需要将它里面的元素全部替换，否则可能影响使用结果
print(np.empty(11))
print(np.empty((2, 4)))
输出
[6.23042070e-307 7.56587584e-307 1.37961302e-306 6.23053614e-307
6.23053954e-307 1.78020169e-306 1.78021527e-306 1.69118787e-306
2.22522596e-306 2.41910790e-312 0.00000000e+000]
[[0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 4.52564132e-321 1.78021527e-306 6.95358498e-308]]
数组的维度
1.shape函数
shape函数可以检查数组的形状，同时也可以改变数组的形状，而且会对数组本身造成影响（改变形状会直接改变原数组）。
使用方法
a = np.arange(12)
print(a.shape) # 返回数组形状
a.shape = (2,3,2) # 修改数组形状
print(a.shape)
输出
(12,)
(2, 3, 2)
2.reshape函数
reshape函数可以设置数组的形状，但是不会影响到原来的数组
a = np.arange(12)
print(a.shape)
b = a.reshape(2,3,2)
print(a.shape)
print(b.shape)
输出
(12,)
(12,)
(2, 3, 2)
3.resize函数
resize函数也是修改数组的形状，但是会直接改变原来的数组
a = np.arange(12)
print(a.shape)
a.resize(2,3,2)
print(a.shape)
输出
(12,)
(2, 3, 2)
4.ravel函数与flatten函数
这两个函数的功能是展平数组，将一个多维的数组有序的展开成为一个一维数组，但是ravel只是返回数组的视图，而flatten会请求分配内存来保存结果
ravel函数：
a = np.arange(12).reshape(2,3,2)
print(a.shape)
a = a.ravel()
print(a.shape)
输出
(2, 3, 2)
(12,)
flatten函数：
a = np.arange(12).reshape(2,3,2)
print(a.shape)
a = a.flatten()
print(a.shape)
输出
(2, 3, 2)
(12,)
效果一样，并且都不会直接改变原数组
数组的组合方法
1.vstack函数
将多个数组垂直组合成为一个新的数组，新数组的行数会发生变化，但是组合的数组列数必须相同
a = np.arange(6).reshape(2,3)
b = np.arange(6).reshape(2,3)
c = np.arange(6).reshape(2,3)
print(a)
print(b)
print(c)
print('--')
d = np.vstack((a,b,c))
print(d)
输出
[[0 1 2]
[3 4 5]]
[[0 1 2]
[3 4 5]]
[[0 1 2]
[3 4 5]]
--
[[0 1 2]
[3 4 5]
[0 1 2]
[3 4 5]
[0 1 2]
[3 4 5]]
2.hstack函数
将多个数组水平组合成为一个新的数组，新数组的列数数会发生变化，但是组合的数组行数必须相同
a = np.arange(6).reshape(2,3)
b = np.arange(6).reshape(2,3)
c = np.arange(6).reshape(2,3)
print(a)
print(b)
print(c)
print('--')
d = np.hstack((a,b,c))
print(d)
输出
[[0 1 2]
[3 4 5]]
[[0 1 2]
[3 4 5]]
[[0 1 2]
[3 4 5]]
--
[[0 1 2 0 1 2 0 1 2]
[3 4 5 3 4 5 3 4 5]]
3.dstack函数
dstack函数针对的是axis=2也就是第三个维度（shape函数显示的第三个维度）进行组合，不能用行列的关系来解释了。
对2个低于三维的数组进行拼接
a = np.arange(6).reshape(2,3)
b = np.arange(6).reshape(2,3)
print(a)
print(b)
print('--')
d = np.dstack((a,b))
print(d)
print(d.shape)
输出
[[0 1 2]
[3 4 5]]
[[0 1 2]
[3 4 5]]
--
[[[0 0]
[1 1]
[2 2]]
[[3 3]
[4 4]
[5 5]]]
(2, 3, 2)
对2个三维数组进行拼接
a = np.arange(6).reshape(2,3,1)
b = np.arange(6).reshape(2,3,1)
print(a)
print(b)
print('--')
d = np.dstack((a,b))
print(d)
print(d.shape)
输出
[[[0]
[1]
[2]]
[[3]
[4]
[5]]]
[[[0]
[1]
[2]]
[[3]
[4]
[5]]]
--
[[[0 0]
[1 1]
[2 2]]
[[3 3]
[4 4]
[5 5]]]
(2, 3, 2)
4.stack函数
用stack函数组合后数组的维度会+1，它有一个axis参数，代表数组沿着某个轴堆叠
当axis=0时，stack函数会直接将两个数组上下堆叠起来，相当于直接在两个数组外面套上一对[]，结果就像是array(数组1，数组2)
axis=0时
a = np.array([1, 2, 3])
b = np.array([2, 3, 4])
c = np.stack((a, b), axis=0)
print(c)
print(c.shape)
输出
[[1 2 3]
[2 3 4]]
(2, 3)
5.concatenate函数
concatenate函数有axis参数，当axis=0时，效果与vstack函数相同，当axis=1时，效果与hstack相同，当axis=2时，效果与dstack相同，但是不能完全代替，concatenate函数对于组合数组形状的要求更加严格
a = np.arange(4).reshape(2,2,1)
b = np.arange(4).reshape(2,2,1)
c = np.dstack((a, b))
print(c)
print('-----')
d = np.concatenate((a,b), axis=2)
print(d)
输出
[[[0 0]
[1 1]]
[[2 2]
[3 3]]]
-----
[[[0 0]
[1 1]]
[[2 2]
[3 3]]]
上面这种情况正常运行
将b的形状改变一下
b = np.arange(4).reshape(2,2)
输出
[[[0 0]
[1 1]]
[[2 2]
[3 3]]]
-----
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
in
6 print(c)
7 print('-----')
----> 8 d = np.concatenate((a,b), axis=2)
9 print(d)
ValueError: all the input arrays must have same number of dimensions
报错了，因为concatenate函数组合的两个数组除了指定的轴以外的形状必须相同
数组的分割方法
要将数组分割n份，那么分割的数组必须能等分成n份，且分割后的数组放在一个列表中
1.hsplit函数
行分割
a = np.arange(9).reshape(3,3)
d1 = np.hsplit(a, 3)
print(d1)
输出
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
2.vsplit函数
列分割
a = np.arange(9).reshape(3,3)
d1 = np.vsplit(a, 3)
print(d1)
输出
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
3.dsplit函数
a = np.arange(12).reshape(2, 2, 3)
l = np.dsplit(a, 3)
print(l[0].shape)
print(l[1].shape)
print(l[2].shape)
print(l)
输出
(2, 2, 1)
(2, 2, 1)
(2, 2, 1)
[array([[[0],
[3]],
[[6],
[9]]]), array([[[ 1],
[ 4]],
[[ 7],
[10]]]), array([[[ 2],
[ 5]],
[[ 8],
[11]]])]
其他属性
1.transpose()
转置数组效果与T一样
a = np.arange(9).reshape(3,3)
print(a)
print(a.T)
print(a.transpose())
输出
[[0 1 2]
[3 4 5]
[6 7 8]]
[[0 3 6]
[1 4 7]
[2 5 8]]
[[0 3 6]
[1 4 7]
[2 5 8]]
2.flat
flat 属性将返回一个可迭代对象，可以让我们像遍历一维数组一样去遍历任意的多维数组
a = np.arange(9).reshape(3,3)
f = a.flat
for i in f:
print(i, end=',')
输出
0,1,2,3,4,5,6,7,8,
3.tolist()
tolist函数numpy数组转换成python列表
a = np.arange(9).reshape(3,3)
b = a.tolist()
print(b)
输出
[[0, 1, 2], [3, 4, 5], [6, 7, 8]]
4.astype()
astype函数可以将数组转换成指定数据类型
a = np.arange(9).reshape(3,3)
b = a.astype(str)
print(b)
输出
[['0' '1' '2']
['3' '4' '5']
['6' '7' '8']]