NumPy: 掌握多维数组与高级数据操作的Python库

NumPy是Python中用于数值计算的核心库，它提供了强大的多维数据库对象和广泛的数学函数，为科学计算和数据分析提供了基础。本文将介绍NumPy的一些最常用的方法，并提供实际代码示例，帮助读者更好地理解和运用这个强大的工具。

1 numpy的简介

1.1 来自官网的简介

NumPy是一个开源 Python 库，几乎用于科学和工程的每个领域。它是在 Python 中处理数值数据的通用标准，也是科学 Python 和 PyData 生态系统的核心。NumPy 用户包括从初学者到从事最先进科学和工业研究与开发的经验丰富的研究人员的所有人。NumPy API 广泛用于 Pandas、SciPy、Matplotlib、scikit-learn、scikit-image 和大多数其他数据科学和科学 Python 包中。

NumPy 库包含多维数组和矩阵数据结构（您将在后面的部分中找到有关此的更多信息）。它提供了 ndarray，一个同构 n 维数组对象，以及对其进行有效操作的方法。NumPy 可用于对数组执行各种数学运算。它为 Python 添加了强大的数据结构，保证了数组和矩阵的高效计算，并且提供了一个庞大的高级数学函数库，可以对这些数组和矩阵进行操作。

1.2 python列表和numpy数组的异同

相同点：

1. 它们都是用于存储数据的数据结构。
2. 它们都可以存储不同类型的数据，例如整数、浮点数、字符串等。
3. 它们都可以通过索引访问数据。

不同点：

1. NumPy数组是一个固定数据类型的多维数组，而Python列表可以存储不同类型的数据。
2. NumPy数组提供了大量的数学和科学计算功能，而Python列表则需要额外的库或函数来实现这些功能。
3. NumPy数组在处理大数据集时通常比Python列表更高效，因为它使用C语言实现并优化了内存管理。
4. NumPy数组提供了广播（broadcasting）功能，即可以对数组的各个维度进行操作，而Python列表则不支持此功能。
5. NumPy数组提供了许多方便的函数和方法来处理数据，例如切片、重塑、统计、排序等，而Python列表则需要使用额外的函数或方法来实现这些功能。
6. NumPy数组还提供了许多用于数据处理的功能，例如线性代数运算（矩阵乘法、转置等）、随机数生成、文件读写等，而Python列表则需要使用额外的库或函数来实现这些功能。

2 numpy的使用

2.1 创建numpy数组

创建一维数组

import numpy as np

# 创建一维数组
arr1 = np.array([1,2,3])

创建多维数组

# 创建多维数组
arr2 = np.array([[1,2,3],[4,6,9]])

其余操作

# 用0填充
arr3 = np.zeros(3)
print(arr3) #   [0. 0. 0.]
# 用's填充
arr4 = np.ones(3)
print(arr4) #    [1. 1. 1.]
# 创建一个空数组,填充内容随机，初始为空
arr5 = np.empty(2)
print(arr5)# [-9.85604994e+250  6.34183291e-098]
# 创建一系列元素
arr6 = np.arange(5)
arr7 = np.arange(2,10,2)#(sart,stop,step)
print(arr6) #    [0 1 2 3 4]
print(arr7) #   [2 4 6 8]
# 指定间隔线性间隔的值创建数组
arr8 = np.linspace(2,10,num=5)#(start,stop,num:要创建几个元素)
print(arr8) #[ 2.  4.  6.  8. 10.]
# 指定数据类型
# 默认为float，通过关键字指定
arr9 = np.ones(3,dtype=int)
print(arr9) #[1,1,1]

2.2 数组常用操作

添加元素

# 创建一维数组
arr1 = np.array([1,2,3])
# 添加元素(末尾）
arr1 = np.append(arr1,4)
print(arr1)#[1 2 3 4]
# 添加元素，指定位置
arr1 = np.insert(arr1,2,5)#在第二个后面插入5
print(arr1)# [1 2 5 3 4]

排序

arr = np.array(['张','刘'])
arr = np.sort(arr)
print(arr)#['刘' '张']
# 多个数组排序
first_name = np.array(['消炎','丽丽','红','华'])
last_name = np.array(['王','李','刘','孙'])
print(np.sort(last_name))
index = np.lexsort((first_name,last_name)) #通过lexsort排序，返回一个索引，然后就可以根据这个获取对应数组
print(index) #[2 3 1 0]
arr_new = [last_name[i]+first_name[i] for i in index]
print(arr_new) #['刘红', '孙备', '李丽丽', '王消炎']
# argsort使用kind关键字指定的算法沿给定轴执行间接排序。
x = np.array([[0, 3], [3, 2]])
#它返回与沿给定轴按排序顺序索引数据形状相同的索引数组 。
ind = np.argsort(x,axis=0)#按照行排列
print(ind)#
# [[0 1]
#  [1 0]]
ind1 = np.argsort(x,axis=1)#按照列排序
print(ind1)
# [[0 1]
#  [1 0]]

删除

arr1 = np.array([3,2,5,4])
arr1 = np.delete(arr1,3)
print(arr1)# [3 2 5]

拼接

arr1 = np.array([3,2,5,4])
arr2 = np.arange(5)
new_arr = np.concatenate((arr1,arr2))
print(new_arr)#[3 2 5 4 0 1 2 3 4]

索引和切片

arr1 = np.array([3,2,5,4])
#打印索引1的元素
print(arr1[1])
# 打印指定范围元素
print(arr1[0:3])#[3 2 5]
print(arr1[1:])#[2 5 4]
print(arr1[:3])#[3 2 5]
# 打印指定间隔元素
print(arr1[1::2])#[2 4]
# 倒序
print(arr1[::-1])#[4 5 2 3]
# 高能：条件查询,打印大于2的元素
print(arr1[arr1>2])#[3 5 4]

查看数组形状和维度

# 一维数组
arr1 = np.array([1, 2, 3, 4, 5])

# 二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])

# 数组形状和维度
print("arr1 shape:", arr1.shape)#显示整个数组储存的元素数量  
# arr1 shape: (5,)
print("arr2 shape:", arr2.shape)#显示数组数量，和每个数组元素数量  
#arr2 shape: (2, 3)
print("arr1 dimensions:", arr1.ndim)  
# arr1 dimensions: 1
print("arr2 dimensions:", arr2.ndim)  
# arr2 dimensions: 2
print("arr2 size:",arr2.size)#shape的乘积，元素总数  
# arr2 size: 6

重塑数组

a = np.arange(6)
b = a.reshape(3,2)#注意总数一定要与原来的一样
print(b)
c = np.reshape(a, newshape=(1, 6), order='C')
"""
a是要重塑的数组。
newshape是你想要的新形状。您可以指定一个整数或整数元组。
如果指定一个整数，结果将是该长度的数组。形状应与原始形状兼容。
order: C表示使用类 C 索引顺序读/写元素， 
F表示使用类 Fortran 索引顺序读/写元素，
A 表示如果 a 在内存中是 Fortran 连续的，
则表示按类 Fortran 索引顺序读/写元素，
C -否则类似订单。（这是一个可选参数，不需要指定。）
"""
print(c)

添加新轴，一维变多维

# 使用np.newaxis一次后，数组的维度就会增加一维
a = np.array([1, 2, 3, 4, 5, 6])
a1 = a[np.newaxis,:]
print(a1.shape)#(1, 6)
a2 = a[:,np.newaxis]#对于列向量，可以沿第二维插入轴
print(a2.shape)# (6, 1)
# 使用expand_dims增加维度
a3 = np.expand_dims(a,axis= 0)
print(a3.shape)# (1, 6)

堆叠

a1 = np.array([[1, 1],
               [2, 2]])
a2 = np.array([[3, 3],
               [4, 4]])
# 垂直堆叠它们vstack
print(np.vstack((a1,a2)))
"""
[[1 1]
 [2 2]
 [3 3]
 [4 4]]
 """
# 水平堆叠它们hstack
print(np.hstack((a1,a2)))
"""
[[1 1 3 3]
 [2 2 4 4]]
"""
# hsplit,数组拆分为多个较小的数组
arr = np.array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12],
       [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]])
# 分成三个形状相同的数组
print(np.hsplit(arr, 3))
"""
[array([[ 1,  2,  3,  4],
       [13, 14, 15, 16]]), array([[ 5,  6,  7,  8],
       [17, 18, 19, 20]]), array([[ 9, 10, 11, 12],
       [21, 22, 23, 24]])]
"""
# 在第三列和第四列之后拆分数组
print(np.hsplit(arr, (3, 4)))
"""
[array([[ 1,  2,  3],
       [13, 14, 15]]), array([[ 4],
       [16]]), array([[ 5,  6,  7,  8,  9, 10, 11, 12],
       [17, 18, 19, 20, 21, 22, 23, 24]])]
"""

加减乘除

data = np.array([1, 2])
ones = np.ones(2, dtype=int)
print(data+ones)#[2 3]
print(data-ones)#[0 1]
print(data*data)#[1 4]
print(data/data)#[1. 1.]
print(data.sum())#3
b = np.array([[1, 1], [2, 2]])
# 行求和
print(b.sum(axis=0))#[3 3]
# 列求和
print(b.sum(axis=1))#[2 4]

聚合函数

a = np.array([[0.45053314, 0.17296777, 0.34376245, 0.5510652],
              [0.54627315, 0.05093587, 0.40067661, 0.55645993],
              [0.12697628, 0.82485143, 0.26590556, 0.56917101]])
# 最大值
print(a.max())#0.82485143
# 最小值
print(a.min())#0.05093587
# 求和
print(a.sum())#4.8595784
# 查找每列最小值
print(a.min(axis=0))#[0.12697628 0.05093587 0.26590556 0.5510652 ]

广播

在数组和单个数字之间或在两个不同大小的数组之间执行运算

a = np.array([1.0,2.0])
print(a*2.3)#[2.3 4.6]

矩阵

numpy中二维数组视为矩阵

# 创建矩阵
data = np.array([[1,2],[3,2],[2,6]])
# 索引切片
print(data[0,1])#2
print(data[1:3])#返回第2、3行组成数组
# 第一行和第二行的第一个元素组成的一维数组
print(data[0:2,0])
# 聚合
print(data.max())
# 相同矩阵的算术运算
another = np.array([[5,5],[3,4],[7,5]])
print(data+another)
# 广播
a = np.array([1,2])
print(data+a)

反转

arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8])
arr2 = np.array([[1, 2, 3], [4, 5, 6],[ 7, 8,0]])
print(np.flip(arr1))#[8 7 6 5 4 3 2 1]
print(np.flip(arr2))
"""[[0 8 7]
 [6 5 4]
 [3 2 1]]"""

重塑和展平多维数组

有flatten和ravel两种方法，但两者有区别

x = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
y = x.flatten()#不会改变原数组
y[0] = 99
print(x,y)
"""
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

 [99  2  3  4  5  6  7  8  9 10 11 12]
"""

z = x.ravel()#通过引用创建，会改变原数组
z[0]=99
print(x,z)
"""
[[99  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

 [99  2  3  4  5  6  7  8  9 10 11 12]
"""

数学公式的使用

均方误差公式（处理回归的监督机器学习模型中使用的中心公式）

对应numpy的实现

error = (1/n) * np.sum(np.square(predictions - 1abels)

numpy对象的保存和加载

numpy对象的保存有许多方法，

np.save()将对象保存为后缀名为.npy的二进制文件，np.savez将对象保存为后缀名为.npz的二进制文件

也可以使用np.savetxt将数组保存为.csv或者.txt文件，但是这些文件虽然容易分享，但是文件更大，读取更慢

加载np.save和np.savez对应np.load；np.savetxt对应np.loadtxt

a = np.array([1, 2, 3, 4, 5, 6])  
np.save('filename', a)#保存成filename.npy文件  
b = np.load('filename.npy')

到此分享结束，更多使用参考官方文档