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 在数据处理时常用的主要函数，以及使用时的注意事项：

主要函数

1. 数组创建

   • np.array(): 从列表或元组创建数组。
   • np.zeros(): 创建全零数组。
   • np.ones(): 创建全一数组。
   • np.arange(): 创建等间隔的数组。
   • np.linspace(): 创建指定数量的等间隔数组。

2. 数组操作

   • np.reshape(): 改变数组的形状。
   • np.flatten(): 将多维数组展平为一维数组。
   • np.transpose(): 转置数组。
   • np.concatenate(): 连接多个数组。
   • np.split(): 分割数组。

3. 数组运算

   • np.add(), np.subtract(), np.multiply(), np.divide(): 基本的算术运算。
   • np.dot(): 矩阵乘法。
   • np.sum(): 计算数组的和。
   • np.mean(): 计算数组的均值。
   • np.std(): 计算标准差。
   • np.min(), np.max(): 计算最小值和最大值。

4. 索引和切片

   • 使用 [] 进行数组索引。
   • 使用 : 进行切片。
   • 布尔索引：通过条件生成布尔数组来筛选数据。

5. 线性代数

   • np.linalg.inv(): 计算矩阵的逆。
   • np.linalg.det(): 计算矩阵的行列式。
   • np.linalg.eig(): 计算特征值和特征向量。

6. 随机数生成

   • np.random.rand(): 生成均匀分布的随机数。
   • np.random.randn(): 生成标准正态分布的随机数。
   • np.random.randint(): 生成指定范围内的随机整数。

使用注意事项

1. 数组维度：确保在进行运算时，数组的维度和形状是兼容的。使用 reshape() 和 expand_dims() 可以帮助调整数组的形状。

2. 数据类型：NumPy 数组的元素类型是固定的，确保在创建数组时指定合适的数据类型（如 dtype），以避免意外的数据类型转换。

3. 内存管理：NumPy 数组通常比 Python 列表占用更少的内存，但在处理非常大的数组时，仍需注意内存使用情况。使用 np.memmap() 可以处理超出内存限制的数组。

4. 广播机制：NumPy 支持广播（broadcasting），这允许不同形状的数组进行运算。理解广播规则可以帮助你更有效地进行数据处理。

5. 避免循环：尽量避免使用 Python 的 for 循环来处理 NumPy 数组，使用向量化操作（如数组运算）可以显著提高性能。

6. 随机数种子：在进行随机数生成时，如果需要可重复的结果，可以使用 np.random.seed() 设置随机数种子。

7. 使用文档：NumPy 有丰富的文档和示例，遇到问题时可以参考官方文档（NumPy Documentation）。

知识点

NumPy 是 Python 数据科学和机器学习领域中的核心库之一，因此它经常成为面试中的话题。以下是一些关于 NumPy 的高频面试题目以及相应的答案：

NumPy 中的 ndarray 是什么？

ndarray 是 NumPy 中的一个核心对象，用于存储同质类型的元素（如整数、浮点数等）。它是一个多维数组，可以进行高效的元素级操作。

如何创建一个形状为 (3, 4) 的 NumPy 数组，并且用 0 填充？

答案:

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

这将创建一个 3 行 4 列的数组，所有元素都是 0。

如何获取 NumPy 数组的形状？

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

shape 属性会返回一个元组，表示数组的形状。

如何改变 NumPy 数组的形状而不改变其数据？

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

这将把原数组改变为 3 行 2 列的形状。

如何将 Python 列表转换为 NumPy 数组？

使用 np.array() 函数可以将 Python 列表转换为 NumPy 数组。

如何计算 NumPy 数组的均值、标准差和方差？

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

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

np.mean() 函数可以计算数组的均值。

如何在 NumPy 数组中进行元素级别的操作？

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

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

这将返回一个新数组 [5, 7, 9]。

如何使用 NumPy 生成随机数？

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

np.random.rand() 函数可以生成一个给定形状的数组，其元素是从 [0, 1) 区间内均匀分布的随机数。

如何检查一个 NumPy 数组是否包含任何 NaN 值？

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

np.isnan() 函数可以返回一个布尔数组，指示哪些位置是 NaN。

如何在 NumPy 数组中进行条件筛选？

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

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

解释 NumPy 中的 dtype。

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

dtype 的关键点

1. 同质性：NumPy 数组是同质的，这意味着数组中的所有元素都必须是相同的数据类型。dtype 确保了这一点。

2. 内存效率：通过指定 dtype，可以控制数组在内存中的存储方式，从而提高内存使用效率。

3. 操作优化：不同的数据类型可能会影响数组操作的性能。例如，整数和浮点数的操作速度可能不同。

4. 类型转换：如果创建数组时没有指定 dtype，NumPy 会根据数组元素的类型自动推断 dtype。但是，如果需要，也可以显式指定 dtype。

5. 类型安全：在执行数组操作时，确保所有元素的数据类型一致可以避免类型不匹配的错误。

常见的 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 数组：

import numpy as np

# 创建一个整数类型的数组
int_array = np.array([1, 2, 3], dtype=np.int32)
print(int_array.dtype)  # 输出：int32

# 创建一个浮点数类型的数组
float_array = np.array([1.0, 2.0, 3.0], dtype=np.float64)
print(float_array.dtype)  # 输出：float64

# 创建一个布尔类型的数组
bool_array = np.array([True, False, True], dtype=bool)
print(bool_array.dtype)  # 输出：bool

注意事项

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

dtype 是 NumPy 数组的一个重要属性，了解和正确使用 dtype 对于进行高效的数值计算至关重要。

为什么 NumPy 比 Python 原生列表更快？

1. 数据存储：

   • NumPy 数组在内存中以连续块的形式存储数据，这意味着数组中的元素是紧密排列的。这种连续存储方式使得 CPU 缓存能够更有效地工作，因为当访问数组中的一个元素时，相邻的元素也会被加载到缓存中。
   • Python 原生列表存储的是对象的引用，这些对象可能散布在内存的任何地方，这导致了更多的内存访问延迟。

2. 数据类型：

   • NumPy 数组中的元素都是同质的，这意味着它们具有相同的数据类型，这使得 NumPy 可以优化内存使用和计算操作。
   • Python 列表可以包含不同类型的元素，这增加了内存使用的复杂性。

3. 操作优化：

   • NumPy 是用 C 语言编写的，它的数组操作是用低级语言实现的，这使得操作非常快速和高效。
   • Python 列表的操作是用 Python 这门高级语言实现的，这通常涉及到更多的函数调用和解释器开销。

4. 向量化操作：

   • NumPy 支持向量化操作，这意味着可以一次性对数组的多个元素执行操作，而不需要使用循环。这些操作是用 C 语言编写的，可以被编译成机器代码，从而实现高性能。
   • Python 列表通常需要使用循环来迭代元素，这增加了额外的开销。

5. 广播机制：

   • NumPy 的广播机制允许不同形状的数组在算术操作中协同工作，而不需要显式地进行元素级别的循环。

6. 算法实现：

   • NumPy 的算法实现通常更加优化，因为它们是专门为数值计算设计的。

7. 并行处理：

   • 对于某些操作，NumPy 可以利用并行处理来进一步提高性能，尤其是在多核处理器上。

8. 内存管理：

   • NumPy 在创建数组时，会明确指定数据类型和大小，这有助于减少内存分配和回收的开销。

9. 缓存效率：

   • 由于 NumPy 数组的连续内存分配，现代 CPU 的缓存机制能够更有效地工作，因为数据访问模式更加局部化。

10. 避免Python解释器开销：

    • Python 列表的操作需要 Python 解释器的介入，而 NumPy 操作很多都是直接在底层执行，避免了解释器的开销。

如何优化 NumPy 代码的性能？

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

解释 NumPy 中的广播机制。

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

1. 维度对齐：从左到右比较两个数组的维度，确保它们的维度是对齐的。这意味着较短数组的前面会填充1（例如，(3,) 被视为 (1, 3)）。

2. 维度扩展：如果两个数组在某个维度的大小不一致，那么较小数组的形状会在该维度上被扩展以匹配较大数组。这是通过复制较小数组的维度值来实现的。

3. 形状比较：从尾部维度（最右边的维度）开始，逐个维度比较两个数组的形状。如果两个维度相等，或其中一个维度为1，则认为它们是兼容的。

4. 复制扩展：如果一个数组的维度大小为1，而另一个数组的维度大小大于1，则将维度大小为1的数组复制扩展到与另一个数组相同的维度大小。

5. 广播结果：如果两个数组在所有维度上都兼容，那么它们就可以进行广播，从而形成一个新的数组形状，用于计算。

例如：

import numpy as np

# 创建两个数组
a = np.array([1, 2, 3])  # 形状为 (3,)
b = np.array([[1], [2], [3]])  # 形状为 (3, 1)

# 广播相加
c = a + b  # 结果是一个形状为 (3, 3) 的数组
print(c)
# 输出：
# [[2 2 2]
#  [3 3 3]
#  [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]。这种方法对于保持数据中的特征比例很有用。

import numpy as np

# 假设 X 是一个形状为 (n_samples, n_features) 的数据数组
X = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

# 计算每个特征的最小值和最大值
X_min = X.min(axis=0)
X_max = X.max(axis=0)

# 执行最小-最大归一化
X_scaled = (X - X_min) / (X_max - X_min)
print(X_scaled)

标准化（Standardization）

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

# 假设 X 是一个形状为 (n_samples, n_features) 的数据数组
X = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

# 计算每个特征的均值和标准差
X_mean = X.mean(axis=0)
X_std = X.std(axis=0)

# 执行标准化
X_standardized = (X - X_mean) / X_std
print(X_standardized)

注意事项

1. 避免数据泄露：在训练集上计算用于缩放的参数（如最小值、最大值、均值和标准差）时，应确保不要使用测试集或验证集的数据，这被称为数据泄露。

2. 保存缩放参数：在训练集上训练模型后，应该保存用于特征缩放的参数（最小值、最大值、均值和标准差），以便在测试集或生产环境中对新数据进行相同的缩放。

3. 选择缩放方法：不同的模型可能对特征缩放的敏感度不同。例如，距离基模型（如 K-最近邻和 SVM）通常会从缩放中受益，而树基模型（如决策树和随机森林）通常不需要特征缩放。

4. 处理缺失值：在进行特征缩放之前，应该处理数据中的缺失值，因为它们可能会影响均值和标准差的计算。

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

如何使用 NumPy 进行主成分分析（PCA）？

步骤 1: 准备数据

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

import numpy as np

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

步骤 2: 数据标准化

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

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

步骤 3: 计算协方差矩阵

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

cov_matrix = np.cov(X_normalized.T)

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

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

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

步骤 5: 选择主成分

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

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

其中 n_components 是你想要保留的成分数量。

步骤 6: 转换数据

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

X_pca = np.dot(X_normalized, principal_components)

使用 X_pca 可以得到降维后的数据。

NumPy PCA 示例代码

import numpy as np

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

# 标准化数据
X_centered = X - np.mean(X, axis=0)
X_std = np.std(X_centered, axis=0)
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 实现非常简单：

from sklearn.decomposition import PCA

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

# 初始化 PCA，n_components 为需要保留的成分数量
pca = PCA(n_components=2)

# 对数据进行拟合和转换
X_pca = pca.fit_transform(X)

print(X_pca)

这种方法更加简洁，且 scikit-learn 会自动处理数据标准化和奇异值分解（SVD）。

如果有错误的地方欢迎大佬批评指正，谢谢