ToB企服应用市场:ToB评测及商务社交产业平台

标题: python3 numpy的一些小知识点 [打印本页]

---

作者: 千千梦丶琪    时间: 2024-9-24 11:41
标题: python3 numpy的一些小知识点
简介

一个用python实现的科学计算，包括：
1、一个强大的N维数组对象Array；
2、比较成熟的（广播）函数库；
3、用于整合C/C++和Fortran代码的工具包；
4、实用的线性代数、傅里叶变更和随机数生成函数。
numpy和稀疏矩阵运算包scipy配合利用更加方便。NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为许多大型金融公司利用，以及焦点的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来利用C++，Fortran或Matlab等所做的任务。
NumPy 的前身为 Numeric ，最早由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中联合了另一个同性质的步伐库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。
利用方法

NumPy 是一个强大的 Python 库，广泛用于科学计算和数据处理。以下是一些 NumPy 在数据处理时常用的主要函数，以及利用时的注意事项：
主要函数

• 数组创建
  
  
  
  • np.array(): 从列表或元组创建数组。
    
  • np.zeros(): 创建全零数组。
    
  • np.ones(): 创建全一数组。
    
  • np.arange(): 创建等间隔的数组。
    
  • np.linspace(): 创建指定数量的等间隔数组。
    
  
  
• 数组操作
  
  
  
  • np.reshape(): 改变数组的外形。
    
  • np.flatten(): 将多维数组展平为一维数组。
    
  • np.transpose(): 转置数组。
    
  • np.concatenate(): 连接多个数组。
    
  • np.split(): 分割数组。
    
  
  
• 数组运算
  
  
  
  • np.add(), np.subtract(), np.multiply(), np.divide(): 基本的算术运算。
    
  • np.dot(): 矩阵乘法。
    
  • np.sum(): 计算数组的和。
    
  • np.mean(): 计算数组的均值。
    
  • np.std(): 计算标准差。
    
  • np.min(), np.max(): 计算最小值和最大值。
    
  
  
• 索引和切片
  
  
  
  • 利用 [] 进行数组索引。
    
  • 利用 : 进行切片。
    
  • 布尔索引：通过条件生成布尔数组来筛选数据。
    
  
  
• 线性代数
  
  
  
  • np.linalg.inv(): 计算矩阵的逆。
    
  • np.linalg.det(): 计算矩阵的行列式。
    
  • np.linalg.eig(): 计算特征值和特征向量。
    
  
  
• 随机数生成
  
  
  
  • np.random.rand(): 生成均匀分布的随机数。
    
  • np.random.randn(): 生成标准正态分布的随机数。
    
  • np.random.randint(): 生成指定范围内的随机整数。
    
  
  

利用注意事项

• 数组维度：确保在进行运算时，数组的维度和外形是兼容的。利用 reshape() 和 expand_dims() 可以帮助调整数组的外形。
  
• 数据类型：NumPy 数组的元素类型是固定的，确保在创建数组时指定合适的数据类型（如 dtype），以避免不测的数据类型转换。
  
• 内存管理：NumPy 数组通常比 Python 列表占用更少的内存，但在处理非常大的数组时，仍需注意内存利用情况。利用 np.memmap() 可以处理超出内存限制的数组。
  
• 广播机制：NumPy 支持广播（broadcasting），这允许不同外形的数组进行运算。理解广播规则可以帮助你更有效地进行数据处理。
  
• 避免循环：只管避免利用 Python 的 for 循环来处理 NumPy 数组，利用向量化操作（如数组运算）可以显著提高性能。
  
• 随机数种子：在进行随机数生成时，如果需要可重复的结果，可以利用 np.random.seed() 设置随机数种子。
  
• 利用文档：NumPy 有丰富的文档和示例，遇到问题时可以参考官方文档（NumPy Documentation）。
  

知识点

NumPy 是 Python 数据科学和呆板学习范畴中的焦点库之一，因此它经常成为面试中的话题。以下是一些关于 NumPy 的高频面试标题以及相应的答案：
NumPy 中的 ndarray 是什么？

ndarray 是 NumPy 中的一个焦点对象，用于存储同质类型的元素（如整数、浮点数等）。它是一个多维数组，可以进行高效的元素级操作。
如何创建一个外形为 (3, 4) 的 NumPy 数组，并且用 0 填充？

答案:

1. import numpy as np
2. array = np.zeros((3, 4))

复制代码

这将创建一个 3 行 4 列的数组，所有元素都是 0。
如何获取 NumPy 数组的外形？

1. import numpy as np
2. array = np.array([[1, 2, 3], [4, 5, 6]])
3. shape = array.shape

复制代码

shape 属性会返回一个元组，表示数组的外形。
如何改变 NumPy 数组的外形而不改变其数据？

1. import numpy as np
2. array = np.array([[1, 2, 3], [4, 5, 6]])
3. reshaped_array = array.reshape(3, 2)

复制代码

这将把原数组改变为 3 行 2 列的外形。
如何将 Python 列表转换为 NumPy 数组？

利用 np.array() 函数可以将 Python 列表转换为 NumPy 数组。
如何计算 NumPy 数组的均值、标准差和方差？

分别利用 np.mean()、np.std() 和 np.var() 函数。例如均值计算如下：

1. import numpy as np
2. array = np.array([1, 2, 3, 4, 5])
3. mean_value = np.mean(array)

复制代码

np.mean() 函数可以计算数组的均值。
如何在 NumPy 数组中进行元素级别的操作？

NumPy 支持元素级别的操作，这意味着你可以对数组中的每个元素应用算术运算或其他函数。例如：

1. import numpy as np
2. array1 = np.array([1, 2, 3])
3. array2 = np.array([4, 5, 6])
4. added_array = array1 + array2

复制代码

这将返回一个新数组 [5, 7, 9]。
如何利用 NumPy 生成随机数？

1. import numpy as np
2. random_array = np.random.rand(3, 4)

复制代码

np.random.rand() 函数可以生成一个给定外形的数组，其元素是从 [0, 1) 区间内均匀分布的随机数。
如何检查一个 NumPy 数组是否包含任何 NaN 值？

1. import numpy as np
2. array = np.array([1, 2, np.nan, 4])
3. contains_nan = np.isnan(array)

复制代码

np.isnan() 函数可以返回一个布尔数组，指示哪些位置是 NaN。
如何在 NumPy 数组中进行条件筛选？

1. import numpy as np
2. array = np.array([1, 2, 3, 4, 5])
3. filtered_array = array[array > 2]

复制代码

这将返回一个新数组 [3, 4, 5]，包含所有大于 2 的元素。
解释 NumPy 中的 dtype。

在 NumPy 中，dtype 是一个非常重要的概念，它代表数据类型（Data Type）。每个 NumPy 数组都有一个与之相干的 dtype，它指定了数组中每个元素的数据类型。这有助于 NumPy 在内存中有效地存储和处理数据。
dtype 的关键点

• 同质性：NumPy 数组是同质的，这意味着数组中的所有元素都必须是相同的数据类型。dtype 确保了这一点。
  
• 内存效率：通过指定 dtype，可以控制数组在内存中的存储方式，从而提高内存利用效率。
  
• 操作优化：不同的数据类型可能会影响数组操作的性能。例如，整数和浮点数的操作速度可能不同。
  
• 类型转换：如果创建数组时没有指定 dtype，NumPy 会根据数组元素的类型自动推断 dtype。但是，如果需要，也可以显式指定 dtype。
  
• 类型安全：在执行数组操作时，确保所有元素的数据类型一致可以避免类型不匹配的错误。
  

常见的 NumPy 数据类型：

• np.int32：32位整数
  
• np.int64：64位整数
  
• np.float32：32位浮点数
  
• np.float64：64位浮点数（双精度）
  
• np.bool_：布尔类型（True 或 False）
  
• np.complex64：复数，实部和虚部各占32位
  
• np.complex128：复数，实部和虚部各占64位
  
• np.object：Python 对象
  
• np.string_：字符串类型
  
• np.datetime64：日期时间类型
  

示例

创建一个具有特定 dtype 的 NumPy 数组：

1. import numpy as np
3. # 创建一个整数类型的数组
4. int_array = np.array([1, 2, 3], dtype=np.int32)
5. print(int_array.dtype)  # 输出：int32
7. # 创建一个浮点数类型的数组
8. float_array = np.array([1.0, 2.0, 3.0], dtype=np.float64)
9. print(float_array.dtype)  # 输出：float64
11. # 创建一个布尔类型的数组
12. bool_array = np.array([True, False, True], dtype=bool)
13. print(bool_array.dtype)  # 输出：bool

复制代码

注意事项

• 当执行数组操作时，如果涉及不同 dtype 的数组，NumPy 通常会执行类型提升（type casting），以确保结果数组的数据类型可以或许容纳所有可能的值。
  
• 显式指定 dtype 可以帮助避免不必要的类型转换，从而提高代码的性能和可读性。
  
• 在处理大数据集时，合理选择 dtype 可以显著减少内存利用，提高处理速度。
  

dtype 是 NumPy 数组的一个重要属性，了解和精确利用 dtype 对于进行高效的数值计算至关重要。
为什么 NumPy 比 Python 原生列表更快？

• 数据存储：
  
  
  
  • NumPy 数组在内存中以一连块的情势存储数据，这意味着数组中的元素是精密排列的。这种一连存储方式使得 CPU 缓存可以或许更有效地工作，因为当访问数组中的一个元素时，相邻的元素也会被加载到缓存中。
    
  • Python 原生列表存储的是对象的引用，这些对象可能散布在内存的任何地方，这导致了更多的内存访问延迟。
    
  
  
• 数据类型：
  
  
  
  • NumPy 数组中的元素都是同质的，这意味着它们具有相同的数据类型，这使得 NumPy 可以优化内存利用和计算操作。
    
  • Python 列表可以包含不同类型的元素，这增加了内存利用的复杂性。
    
  
  
• 操作优化：
  
  
  
  • NumPy 是用 C 语言编写的，它的数组操作是用低级语言实现的，这使得操作非常快速和高效。
    
  • Python 列表的操作是用 Python 这门高级语言实现的，这通常涉及到更多的函数调用和解释器开销。
    
  
  
• 向量化操作：
  
  
  
  • NumPy 支持向量化操作，这意味着可以一次性对数组的多个元素执行操作，而不需要利用循环。这些操作是用 C 语言编写的，可以被编译成呆板代码，从而实现高性能。
    
  • Python 列表通常需要利用循环来迭代元素，这增加了额外的开销。
    
  
  
• 广播机制：
  
  
  
  • NumPy 的广播机制允许不同外形的数组在算术操作中协同工作，而不需要显式地进行元素级别的循环。
    
  
  
• 算法实现：
  
  
  
  • NumPy 的算法实现通常更加优化，因为它们是专门为数值计算计划的。
    
  
  
• 并行处理：
  
  
  
  • 对于某些操作，NumPy 可以利用并行处理来进一步提高性能，尤其是在多核处理器上。
    
  
  
• 内存管理：
  
  
  
  • NumPy 在创建数组时，会明白指定数据类型和大小，这有助于减少内存分配和接纳的开销。
    
  
  
• 缓存效率：
  
  
  
  • 由于 NumPy 数组的一连内存分配，现代 CPU 的缓存机制可以或许更有效地工作，因为数据访问模式更加局部化。
    
  
  
• 避免Python解释器开销：
  
  
  
  • Python 列表的操作需要 Python 解释器的介入，而 NumPy 操作许多都是直接在底层执行，避免了解释器的开销。
    
  
  

如何优化 NumPy 代码的性能？

答案：利用向量化操作而不是循环，避免不必要地复制数据，利用得当的数据类型，以及并行处理（如利用 np.dot 替代 for 循环计算点积）。
解释 NumPy 中的广播机制。

NumPy 中的广播（Broadcasting）机制是一种强大的功能，它允许不同外形的数组在数学运算中协同工作，而不需要显式地匹配它们的外形。广播机制遵循以下规则：

• 维度对齐：从左到右比较两个数组的维度，确保它们的维度是对齐的。这意味着较短数组的前面会填充1（例如，(3,) 被视为 (1, 3)）。
  
• 维度扩展：如果两个数组在某个维度的大小不一致，那么较小数组的外形会在该维度上被扩展以匹配较大数组。这是通过复制较小数组的维度值来实现的。
  
• 外形比较：从尾部维度（最右边的维度）开始，逐个维度比较两个数组的外形。如果两个维度相等，或其中一个维度为1，则以为它们是兼容的。
  
• 复制扩展：如果一个数组的维度大小为1，而另一个数组的维度大小大于1，则将维度大小为1的数组复制扩展到与另一个数组相同的维度大小。
  
• 广播结果：如果两个数组在所有维度上都兼容，那么它们就可以进行广播，从而形成一个新的数组外形，用于计算。
  

例如：

1. import numpy as np
3. # 创建两个数组
4. a = np.array([1, 2, 3])  # 形状为 (3,)
5. b = np.array([[1], [2], [3]])  # 形状为 (3, 1)
7. # 广播相加
8. c = a + b  # 结果是一个形状为 (3, 3) 的数组
9. print(c)
10. # 输出：
11. # [[2 2 2]
12. #  [3 3 3]
13. #  [4 4 4]]

复制代码

在这个例子中，a 的外形是 (3,)，b 的外形是 (3, 1)。根据广播规则，a 被扩展到 (3, 3)，b 也被扩展到 (3, 3)，然后进行逐元素相加。
广播机制使得 NumPy 在执行元素级操作时非常高效，因为它避免了不必要的数组复制和循环。然而，它也有潜在的缺点，好比偶然可能会导致不测的结果，特别是在数组外形复杂或操作不明白时。因此，理解广播机制对于编写清晰、高效的 NumPy 代码至关重要。
在呆板学习中，如何利用 NumPy 进行特征缩放？

在呆板学习中，特征缩放是一种重要的预处理步骤，它有助于改善模型的性能和收敛速度。特征缩放包括多种技能，其中最常见的是最小-最大归一化（Min-Max Scaling）和标准化（Standardization）。以下是如何利用 NumPy 进行这两种特征缩放的方法：
最小-最大归一化（Min-Max Scaling）

最小-最大归一化将特征缩放到一个指定的范围，通常是 [0, 1]。这种方法对于保持数据中的特征比例很有效。

1. import numpy as np
3. # 假设 X 是一个形状为 (n_samples, n_features) 的数据数组
4. X = np.array([[1, 2, 3],
5.               [4, 5, 6],
6.               [7, 8, 9]])
8. # 计算每个特征的最小值和最大值
9. X_min = X.min(axis=0)
10. X_max = X.max(axis=0)
12. # 执行最小-最大归一化
13. X_scaled = (X - X_min) / (X_max - X_min)
14. print(X_scaled)

复制代码

标准化（Standardization）

标准化（也称为 Z-score 归一化）将特征缩放，使得它们的均值为 0，标准差为 1。这有助于确保不同特征的尺度不会影响模型的优化过程。

1. # 假设 X 是一个形状为 (n_samples, n_features) 的数据数组
2. X = np.array([[1, 2, 3],
3.               [4, 5, 6],
4.               [7, 8, 9]])
6. # 计算每个特征的均值和标准差
7. X_mean = X.mean(axis=0)
8. X_std = X.std(axis=0)
10. # 执行标准化
11. X_standardized = (X - X_mean) / X_std
12. print(X_standardized)

复制代码

注意事项

• 避免数据泄露：在练习集上计算用于缩放的参数（如最小值、最大值、均值和标准差）时，应确保不要利用测试集或验证集的数据，这被称为数据泄露。
  
• 保存缩放参数：在练习集上练习模型后，应该保存用于特征缩放的参数（最小值、最大值、均值和标准差），以便在测试集或生产环境中对新数据进行相同的缩放。
  
• 选择缩放方法：不同的模型可能对特征缩放的敏感度不同。例如，间隔基模型（如 K-近来邻和 SVM）通常会从缩放中受益，而树基模型（如决策树和随机森林）通常不需要特征缩放。
  
• 处理缺失值：在进行特征缩放之前，应该处理数据中的缺失值，因为它们可能会影响均值和标准差的计算。
  

利用 NumPy 进行特征缩放是直接且高效的，但请注意，NumPy 不提供内置的函数来自动应用这些缩放技能。在实践中，scikit-learn 库提供了更高级的特征缩放方法，如 MinMaxScaler 和 StandardScaler，它们可以更方便地处理这些问题。
如何利用 NumPy 进行主成分分析（PCA）？

步骤 1: 准备数据

首先，你需要一个外形为 (n_samples, n_features) 的数据数组。

1. import numpy as np
3. # 示例数据
4. X = np.array([[1, 2, 3],
5.               [4, 5, 6],
6.               [7, 8, 9]])

复制代码

步骤 2: 数据标准化

PCA 对数据的尺度非常敏感，因此通常需要先标准化数据。

1. X_centered = X - np.mean(X, axis=0)
2. X_std = np.std(X_centered, axis=0)
3. X_normalized = X_centered / X_std

复制代码

步骤 3: 计算协方差矩阵

协方差矩阵用于找到数据的主成分。

1. cov_matrix = np.cov(X_normalized.T)

复制代码

步骤 4: 计算特征值和特征向量

特征值和特征向量表示了数据的主成分方向。

1. eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)

复制代码

步骤 5: 选择主成分

选择最大的几个特征值对应的特征向量作为主成分。

1. # 按特征值大小降序排序特征向量
2. sorted_index = np.argsort(eigenvalues)[::-1]
3. principal_components = eigenvectors[:, sorted_index[:n_components]]

复制代码

其中 n_components 是你想要保存的成分数量。
步骤 6: 转换数据

将原始数据投影到选定的主成分上。

1. X_pca = np.dot(X_normalized, principal_components)

复制代码

利用 X_pca 可以得到降维后的数据。
NumPy PCA 示例代码

1. import numpy as np
3. # 示例数据
4. X = np.array([[1, 2, 3],
5.               [4, 5, 6],
6.               [7, 8, 9]])# 标准化数据X_centered = X - np.mean(X, axis=0)
7. X_std = np.std(X_centered, axis=0)
8. X_normalized = X_centered / X_std# 计算协方差矩阵cov_matrix = np.cov(X_normalized.T)# 计算特征值和特征向量eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)# 按特征值大小降序排序特征向量sorted_index = np.argsort(eigenvalues)[::-1]n_components = 2  # 选择前两个主成分principal_components = eigenvectors[:, sorted_index[:n_components]]# 转换数据X_pca = np.dot(X_normalized, principal_components)print(X_pca)

复制代码

注意事项

• 数据标准化是 PCA 的重要步骤，确保每个特征具有单位方差。
  
• 在实践中，通常利用 scikit-learn 的 PCA 实现，因为它更高效、更方便，并且包含了更多的功能，如自动选择组件数量等。
  
• NumPy 的 PCA 实现没有考虑奇特值分解（SVD），这在处理具有更多特征的数据时可能更有效。
  

利用 scikit-learn 的 PCA 实现非常简单：

1. from sklearn.decomposition import PCA
3. # 示例数据
4. X = np.array([[1, 2, 3],
5.               [4, 5, 6],
6.               [7, 8, 9]])
8. # 初始化 PCA，n_components 为需要保留的成分数量
9. pca = PCA(n_components=2)
11. # 对数据进行拟合和转换
12. X_pca = pca.fit_transform(X)
14. print(X_pca)

复制代码

这种方法更加简洁，且 scikit-learn 会自动处理数据标准化和奇特值分解（SVD）。
如果有错误的地方欢迎大佬品评指正，谢谢


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4