Numpy库是python的一个开源数值计算库，提供了大量的专门应对一些大型额多维数组与矩阵的计算数学函数库，同时，Numpy库广泛应用于科学技术、数据分析、机器学习、数据可视化等领域。由于其高效性和易用性使它成为专业开发人员和研究人员的首选，那么今天就让我们来学习一下关于numpy库的相关内容吧。

首先让我们看一下Numpy在机器学习中的具体应用，主要体现在以下几个方面：

1. 数据加载与预处理：

    使用NumPy可以方便地加载数据，如从CSV文件中读取数据。在数据预处理阶段，NumPy可用于数据清洗，例如删除缺失值。 NumPy还支持数据标准化和归一化等操作，有助于提升模型训练的效率。

2. 特征工程：

    特征选择：利用NumPy可以计算特征之间的相关性或方差，从而挑选出对模型最有帮助的特征。

    特征构造：通过NumPy的数组运算，可以基于现有特征生成新的特征。  

3. 模型训练与优化：

    许多机器学习算法，如线性回归、逻辑回归、支持向量机等，都需要进行大量的矩阵运算。例如在机器模型优化过程中，NumPy可用于计算梯度、更新模型参数等。

4. 算法实现：

    NumPy可以直接用于实现一些基本的机器学习算法，如K-均值聚类算法等。通过NumPy，可以实现自定义的机器学习模型，以满足特定需求。

5. 与其他库的集成：

    NumPy与许多机器学习库（如scikit-learn、TensorFlow、PyTorch等）紧密集成，这些库在底层使用了NumPy进行数值计算。通过NumPy，可以方便地在这些库之间传递数据，共同构建复杂的机器学习系统。

下面是Numpy的一些常用操作，如有需要请点赞，收藏+转发，防止后面找不到。

1.创建数组（array）

   通过 np.array()，将 Python 列表（或其他序列对象）转换    为 NumPy 数组，或者从给定的数据直接创建数组。

具体操作：

import numpy as np
 
# 从列表创建一维数组
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
#输出[1, 2, 3, 4, 5]
 
# 从嵌套列表创建二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)
#输出[[1, 2, 3]
      [4, 5, 6]]
 
# 指定数据类型
arr3 = np.array([1.1, 2.2, 3.3], dtype=int)
print(arr3) 
# 输出：[1 2 3]

2、创建全零、全一数组

    可以使用 np.zeros()创建全0数组、np.ones()创建全1数组

具体操作：

import numpy as np
#创建全零数组
array4=np.zeros((2,3))
print("全零数组:\n",array4)
#输出：[[0,0,0]
       [0,0,0]]
 
# 创建全一数组
array5=np.ones((2,3))
print("全零数组:\n",array5)
#输出：[[1,1,1]
       [1,1,1]]

3.创建指定范围的数组

    使用np.linspace(）和np.arange(）生成固定长度的数组。

    （1）np.linspace(start, stop, num, endpoint)，endpoint表示序列中是否包含stop值，默认是True。表示从start到stop中生成num个整形数据。

    （2）np.arange(start, stop, step, dtype)，step表示步长，默认为1，不包含stop值。

具体操作：

#import numpy as np
 
#数组
arange_array = np.arange(2, 10, 2)  # 步长为2的数组，包含1，不包含10
print("arange创建的固定范围数组:", arange_array)
 
# 创建等间隔的数组
linspace_array = np.linspace(2, 8, 4)  # 从1到10，共5个数，等间隔
print("linspace创建的数组:", linspace_array)

4.创建随机数组

① np.random.random()：生成指定形状的0-1之间的随机数；

② np.random.rand()：生成指定形状的0-1之间的随机数；

③ np.random.randint()：生成指定数值范围内的随机整数；

④ np.random.normal()：生成指定均值和标准差的正态分布随机数；

⑤ np.random.uniform()：生成均匀分布随机数；

具体操作:

import numpy as np
 
# 生成指定形状的0-1之间的随机数
random_array_1 = np.random.random((3, 2))  # 生成一个3x2的数组
print("输出结果为:\n", random_array_1)
 
# 生成指定形状的0-1之间的随机数
# 实际上，np.random.rand() 和 np.random.random() 是等价的
random_array_2 = np.random.rand((3, 2))  # 生成一个3x2的数组
print("输出结果为:\n", random_array_2)
 
# 生成指定数值范围内的随机整数
# 例如，生成一个3x2的数组，元素范围在1到10之间（包括1但不包括10）
random_array_3 = np.random.randint(1, 10, (3, 2))
print("输出结果为:\n", random_array_3)
 
# 生成指定均值和标准差的正态分布随机数
# 例如，生成一个3x2的数组，均值为0，标准差为1
normal = np.random.normal(0, 1, (3, 2))
print("输出结果为:\n", normal)
 
# 生成均匀分布随机数
# 例如，生成一个3x2的数组，元素范围在0到1之间（包括0和1）
uniform = np.random.uniform(0, 1, (3, 2))
print("输出结果为:\n", uniform)

5.数组大小(size)

使用 np.size查看数组的总数。

使用方式：

import numpy as np
 
#创建二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
 
print("数组大小为：",arr2.size)
#输出：数组大小为：6

6.数组的形状(shape)

使用np.shape函数返回数组的形状，使用np.reshape()改变数组的维度.

具体操作:

import numpy as np
 
# 创建服从均匀分布的随机数组
array5 = np.random.random((3,4))
print("数组的形状为：",array5.shape)
#输出： (3, 4)
 
#改变数组的形状
reshape_array6=np.reshape(array5,(2,6))
print("形状改变后：",reshape_array6)
#输出： [[0.66461584 0.678915   0.56349308 0.36924412 0.57592957 0.75054765]
       [0.8582146  0.68932762 0.26228381 0.50113356 0.15225465 0.11699577]]

7.数组类型(dtype)

通过调用dtype属性，获取数组中的数据类型；通过type()函数查看数组对象的类型（不是数据）。

具体操作：

import numpy as np
 
# 创建二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print("查看数组的类型：",arr2.dtype)
print("查看数组的类型：",type(arr2))
#输出： int32
#输出： <class 'numpy.ndarray'>

8.类型转换（astype）

使用astype()函数，将数组转换为自定义数组。

具体操作：

import numpy as np
 
arr=np.array([1,2,3,4])
arr_float=arr.astype(float)
print("类型转化为float:",arr_float)
#输出：[1. 2. 3. 4.]
 
arr_str=arr.astype(str)
print("类型转化为fstr:",arr_str)
#输出： ['1' '2' '3' '4']

9.数组维度（ndim）

使用ndim属性获取数组的维度数。

具体操作：

import numpy as np
 
# 创建一个一维数组
arr1d = np.array([1, 2, 3])
print("一维数组的维度数:", arr1d.ndim)  # 输出: 1
 
# 创建一个二维数组
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print("二维数组的维度数:", arr2d.ndim)  # 输出: 2
 
# 创建一个三维数组
arr3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("三维数组的维度数:", arr3d.ndim)  # 输出: 3

10.数组索引

通过位置（位置索引）和标签（标签索引）。

具体操作：

#位置索引
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[0])  # 输出第一个元素
print(arr[1:4])  # 输出从第二个到第四个元素
 
#标签索引 
import pandas as pd
df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
print(df.loc[0])  # 输出第一行的数据
 
#布尔索引
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[arr > 2])  # 输出大于2的元素
 
#花括号索引
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr[[0, 2], [1, 2]])  # 输出第1行第2个元素和第3行第3个元素

11.数组切片

使用切片获取数组中指定的数据元素。

具体操作：

#一维数组切片
import numpy as np
 
arr = np.array([1, 2, 3, 4, 5])
 
# 选择从索引1到索引3的元素（不包括索引3）
slice_arr = arr[1:3]
print(slice_arr)  # 输出: [2 3]
 
#二维数组切片
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
# 选择第二行和第三行的所有列
slice_arr = arr[1:3, :]
print(slice_arr) 
# 输出:[[4 5 6]
       [7 8 9]]
 
# 选择第一列和第二列的所有行
slice_arr = arr[:, 0:2]
print(slice_arr)  
# 输出:[[1 2]
       [4 5]
      [7 8]]

12.数组去重（unique）

np.unique() 函数用于去重并返回数组中的唯一元素.

具体操作：

import numpy as np
 
# 创建一个数组
arr = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
 
# 使用 numpy.unique 去重
unique_arr = np.unique(arr)
print(unique_arr) #输出：[1 2 3 4]

13.数组最大最小值（max、argmax）

使用np.max()/np.min()函数获取数组的最大、最小值；使用np.argmax()/np.argmin()函数获取数组最大值、最小值的索引。

具体操作：

import numpy as np
 
arr = np.array([1, 3, 2, 5, 4])
 
#获取最大值
max_value = np.max(arr)
print("最大值:", max_value)#输出：5
 
#获取最小值
min_value = np.min(arr)
print("最小值:", min_value)#输出：1
 
#获取最大值索引
max_index = np.argmax(arr)
print("最大值的索引:", max_index)#输出：3
 
#获取最小值索引
min_index = np.argmin(arr)
print("最小值的索引:", min_index)#输出0

14.求绝对值（abs）

使用内置的np.abs()函数来获取一个数的绝对值。

具体操作：

import numpy as np
 
arr = np.array([-1, -2, 3, -4, 5])
#求绝对值
abs_arr = np.abs(arr)
print(abs_arr)  # 输出: [1 2 3 4 5]

15.数组元素的加、减、乘、除4种操作

加法操作：使用+操作符或np.add()函数

减法操作：使用-操作符或np.subtract()函数

乘法操作：使用*操作符或np.multiply()函数

除法操作：使用/操作符或np.divide()函数。

具体操作：

import numpy as np
 
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
 
# 使用 + 操作符
c = a + b
print(c)  # 输出: [5 7 9]
 
# 使用 numpy.add 函数
c = np.add(a, b)
print(c)  # 输出: [5 7 9]
 
# 使用 - 操作符
c = a - b
print(c)  # 输出: [-3 -3 -3]
 
# 使用 numpy.subtract 函数
c = np.subtract(a, b)
print(c)  # 输出: [-3 -3 -3]
 
# 使用 * 操作符
c = a * b
print(c)  # 输出: [ 4 10 18]
 
# 使用 numpy.multiply 函数
c = np.multiply(a, b)
print(c)  # 输出: [ 4 10 18]
 
# 使用 / 操作符（浮点除法）
c = a / b
print(c)  # 输出: [0.25 0.4  0.5 ]
 
# 使用 numpy.divide 函数（浮点除法）
c = np.divide(a, b)
print(c)  # 输出: [0.25 0.4  0.5 ]

16.数组求和、平均值、中值、标准差、方差

求和 (np.sum(arr)): 计算数组中所有元素的总和。

平均值 (np.mean(arr)): 计算数组中所有元素的平均值。中值 (np.median(arr)): 计算数组中所有元素的中位数，即中间位置的数。

标准差 (np.std(arr)): 计算数组中所有元素的标准差，表示数据分布的离散程度。

方差 (np.var(arr)): 计算数组中所有元素的方差。

具体操作：

import numpy as np
 
# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])
 
# 求和
sum_of_elements = np.sum(arr)
print("求和:", sum_of_elements)#输出：15
 
# 平均值
mean_of_elements = np.mean(arr)
print("平均值:", mean_of_elements)#输出：3.0
 
# 中值
median_of_elements = np.median(arr)
print("中值:", median_of_elements)#输出：3.0
 
# 标准差
std_deviation = np.std(arr)
print("标准差:", std_deviation)#输出：1.4142135623730951
 
# 方差
variance = np.var(arr)
print("方差:", variance)#输出：2.0

17.数组元素间比较

np.equal()：逐元素相等比较。

np.not_equal()：逐元素不相等比较。

np.less()：逐元素小于比较。

np.less_equal()：逐元素小于等于比较。

np.greater()：逐元素大于比较。

np.greater_equal()：逐元素大于等于比较。

具体操作：

import numpy as np
 
# 定义两个数组
array1 = np.array([1, 2, 3, 4, 5])
array2 = np.array([1, 3, 3, 7, 5])
 
# 逐元素相等比较
equal_result = np.equal(array1, array2)
print("相等比较:", equal_result)
 
# 逐元素不相等比较
not_equal_result = np.not_equal(array1, array2)
print("不相等比较:", not_equal_result)
 
# 逐元素小于比较
less_result = np.less(array1, array2)
print("小于比较:", less_result)
 
# 逐元素小于等于比较
less_equal_result = np.less_equal(array1, array2)
print("小于等于比较:", less_equal_result)
 
# 逐元素大于比较
greater_result = np.greater(array1, array2)
print("大于比较:", greater_result)
 
# 逐元素大于等于比较
greater_equal_result = np.greater_equal(array1, array2)
print("大于等于比较:", greater_equal_result)

18.数组四舍五入

np.round(array)：对数组中的每个元素进行四舍五入到最接近的整数。

np.floor(array)：对数组中的每个元素进行向下取整，即取不大于该元素的最大整数。

np.ceil(array)：对数组中的每个元素进行向上取整，即取不小于该元素的最小整数。

np.trunc(array)：对数组中的每个元素进行截断，即去掉小数部分，只保留整数部分。

具体操作：

import numpy as np
 
# 定义一个包含浮点数的数组
array = np.array([1.2, 2.5, 3.7, 4.4, -1.5, -2.3])
 
# 对数组元素进行舍入操作
round_result = np.round(array)
print("np.round(array):", round_result)
 
# 对数组元素进行向下取整操作
floor_result = np.floor(array)
print("np.floor(array):", floor_result)
 
# 对数组元素进行向上取整操作
ceil_result = np.ceil(array)
print("np.ceil(array):", ceil_result)
 
# 对数组元素进行截断操作
trunc_result = np.trunc(array)
print("np.trunc(array):", trunc_result)
 
代码运行后输出：
np.round(array): [ 1.  2.  4.  4. -2. -2.]
np.floor(array): [ 1.  2.  3.  4. -2. -3.]
np.ceil(array): [ 2.  3.  4.  5. -1. -2.]
np.trunc(array): [ 1.  2.  3.  4. -1. -2.]

19.数组插入（insert、append）

使用np.insert() 和 np.append() 函数对数组进行插入和追加操作。

具体操作：

import numpy as np
 
# 定义一个数组
array = np.array([1, 2, 4, 5])
 
# 在索引2的位置插入值3
insert_result = np.insert(array, 2, 3)
print("insert操作:", insert_result)
# 输出: [1 2 3 4 5]
 
# 在数组的末尾追加数组[7, 8, 9]
append_array_result = np.append(array, [7, 8, 9])
print("append操作:", append_array_result)
# 输出: [1 2 4 5 7 8 9]

20.数组元素删除（delete）

使用np.delete() 函数对数组中元素进行删除。

具体操作：

import numpy as np
 
# 定义一个数组
array = np.array([1, 2, 3, 4, 5])
 
# 删除索引为2的元素（即值3）
delete_result = np.delete(array, 2)
print("删除索引为2的元素后的数组:",delete_result)
# 输出: [1 2 4 5]
 
# 删除索引为0和3的元素（即值1和4）
delete_multiple_indices_result = np.delete(array, [0, 3])
print("\n删除索引为0和3的元素后的数组:")
print(delete_multiple_indices_result)
# 输出: [2 3 5]

如果大家对机器学习或者深度学习等相关知识感兴趣可以关注我的微信公众号：青藤之智，里面会分享一些知识干货。