【基础】NumPy库基础：多维数组与数组操作

# 2.1 多维数组的创建和操作

NumPy中的数组可以是多维的，即具有多个维度。维度数称为数组的秩。创建一个多维数组时，需要指定每个维度的长度。

### 2.1.1 数组的创建

创建多维数组可以使用`numpy.array()`函数，并指定一个嵌套列表作为参数。例如，创建一个三维数组：

import numpy as np

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr)

输出：

[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]

### 2.1.2 数组的索引和切片

与一维数组类似，多维数组也可以使用索引和切片进行访问。索引和切片操作分别使用`[]`和`[:]`。例如，获取三维数组中的一个元素：

print(arr[0, 1, 2])  # 输出：6

切片操作可以获取数组的一部分。例如，获取三维数组中的一个子数组：

print(arr[0, :, :])  # 输出：[[1 2 3]
                     #        [4 5 6]]

# 2. NumPy数组基础

NumPy数组是NumPy库的核心数据结构，它提供了高效地存储和操作多维数据的机制。本节将深入探讨NumPy数组的基础知识，包括创建、操作、数据类型和类型转换。

### 2.1 多维数组的创建和操作

#### 2.1.1 数组的创建

NumPy提供了多种创建数组的方法：

- **np.array()：**将Python列表、元组或其他可迭代对象转换为NumPy数组。
- **np.zeros()：**创建一个指定形状和数据类型的全零数组。
- **np.ones()：**创建一个指定形状和数据类型的全一数组。
- **np.full()：**创建一个指定形状和数据类型的数组，其中所有元素都填充为给定的值。
- **np.arange()：**创建一个指定范围内的等差数列数组。
- **np.linspace()：**创建一个指定范围内的等距数列数组。

#### 2.1.2 数组的索引和切片

NumPy数组可以通过下标和切片进行索引和切片：

- **下标：**使用方括号访问数组中的单个元素或子数组。
- **切片：**使用方括号和冒号访问数组中的一组连续元素。

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 访问单个元素
print(arr[0, 1])  # 输出：2

# 访问子数组
print(arr[0, :])  # 输出：[1 2 3]

# 访问切片
print(arr[:, 1:])  # 输出：[[2 3] [5 6]]

#### 2.1.3 数组的广播和形状转换

**广播：**当两个形状不同的数组进行算术运算时，NumPy会自动将较小的数组广播到较大数组的形状，从而实现逐元素运算。

**形状转换：**使用reshape()方法可以改变数组的形状。

# 广播示例
arr1 = np.array([1, 2, 3])
arr2 = np.array([[4], [5], [6]])

print(arr1 + arr2)  # 输出：[[5 6 7] [6 7 8] [7 8 9]]

# 形状转换示例
arr = np.array([1, 2, 3, 4, 5, 6])
print(arr.reshape((2, 3)))  # 输出：[[1 2 3] [4 5 6]]

### 2.2 数据类型和类型转换

#### 2.2.1 常见的NumPy数据类型

NumPy提供了多种数据类型，包括：

- 整数类型：int8、int16、int32、int64
- 浮点数类型：float16、float32、float64
- 复数类型：complex64、complex128
- 布尔类型：bool
- 字符串类型：str
- 对象类型：object

#### 2.2.2 数据类型转换和类型检查

可以使用astype()方法转换数组的数据类型。可以使用dtype属性检查数组的数据类型。

# 数据类型转换示例
arr = np.array([1, 2, 3], dtype=np.int32)
print(arr.astype(np.float32))  # 输出：[1. 2. 3.]

# 数据类型检查示例
print(arr.dtype)  # 输出：int32

# 3.1 基本数学运算

NumPy库提供了丰富的数学运算函数，可以对数组中的元素进行各种数学运算，包括算术运算、比较运算和逻辑运算。

#### 3.1.1 算术运算

NumPy支持常见的算术运算，包括加法（+）、减法（-）、乘法（*）、除法（/）、取余（%）和幂运算（**）。这些运算符可以对数组中的元素逐个进行操作，也可以对数组和标量进行操作。

import numpy as np

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])

# 加法
print(arr + 2)  # 输出：[3 4 5 6 7]

# 减法
print(arr - 1)  # 输出：[0 1 2 3 4]

# 乘法
print(arr * 2)  # 输出：[2 4 6 8 10]

# 除法
print(arr / 2)  # 输出：[0.5 1.  1.5 2.  2.5]

# 取余
print(arr % 3)  # 输出：[1 2 0 1 2]

# 幂运算
print(arr ** 2)  # 输出：[1 4 9 16 25]

#### 3.1.2 比较运算

NumPy支持比较运算，包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。这些运算符可以对数组中的元素逐个进行比较，返回一个布尔数组，其中True表示比较结果为真，False表示比较结果为假。

import numpy as np

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])

# 等于
print(arr == 2)  # 输出：[False  True False False False]

# 不等于
print(arr != 2)  # 输出：[ True False  True  True  True]

# 大于
print(arr > 2)  # 输出：[False False  True  True  True]

# 小于
print(arr < 2)  # 输出：[ True  True False False False]

# 大于等于
print(arr >= 2)  # 输出：[False  True  True  True  True]

# 小于等于
print(arr <= 2)  # 输出：[ True  True  True False False]

#### 3.1.3 逻辑运算

NumPy支持逻辑运算，包括与（&）、或（|）和非（~）。这些运算符可以对布尔数组中的元素逐个进行操作，返回一个布尔数组，其中True表示逻辑运算结果为真，False表示逻辑运算结果为假。

import numpy as np

# 创建一个布尔数组
arr = np.array([True, False, True, False, True])

# 与
print(arr & arr)  # 输出：[ True False  True False  True]

# 或
print(arr | arr)  # 输出：[ True  True  True  True  True]

# 非
print(~arr)  # 输出：[False  True False  True False]

# 4. NumPy数组处理

### 4.1 数组排序和筛选

#### 4.1.1 数组排序

NumPy提供了多种数组排序函数，包括：

- `sort()`: 对数组进行就地排序。
- `argsort()`: 返回数组元素排序后的索引。
- `partition()`: 将数组划分为两部分，一部分元素小于等于给定的基准值，另一部分元素大于给定的基准值。

**代码块：**

import numpy as np

# 创建一个随机数组
arr = np.random.randint(10, size=10)
print("原始数组：", arr)

# 使用sort()函数对数组进行就地排序
arr.sort()
print("排序后的数组：", arr)

# 使用argsort()函数返回排序后的索引
sorted_indices = np.argsort(arr)
print("排序后的索引：", sorted_indices)

**逻辑分析：**

* `np.random.randint(10, size=10)`：创建一个包含10个0到9之间的随机整数的数组。
* `arr.sort()`：对`arr`数组进行就地排序，将元素从小到大排列。
* `np.argsort(arr)`：返回`arr`数组元素排序后的索引。

#### 4.1.2 数组筛选

NumPy还提供了数组筛选函数，包括：

- `where()`: 返回满足给定条件的元素的索引。
- `nonzero()`: 返回满足给定条件的元素的非零索引。
- `extract()`: 返回满足给定条件的元素。

**代码块：**

# 使用where()函数筛选数组中大于5的元素
filtered_indices = np.where(arr > 5)
print("大于5的元素索引：", filtered_indices)

# 使用nonzero()函数筛选数组中非零元素
non_zero_indices = np.nonzero(arr)
print("非零元素索引：", non_zero_indices)

# 使用extract()函数筛选数组中大于5的元素
filtered_elements = arr[arr > 5]
print("大于5的元素：", filtered_elements)

**逻辑分析：**

* `np.where(arr > 5)`：返回`arr`数组中大于5的元素的索引。
* `np.nonzero(arr)`：返回`arr`数组中非零元素的索引。
* `arr[arr > 5]`：返回`arr`数组中大于5的元素。

### 4.2 数组拼接和分割

#### 4.2.1 数组拼接

NumPy提供了数组拼接函数，包括：

- `concatenate()`: 将多个数组沿着给定的轴连接起来。
- `vstack()`: 将多个数组垂直堆叠起来。
- `hstack()`: 将多个数组水平堆叠起来。

**代码块：**

# 创建两个数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# 使用concatenate()函数将两个数组连接起来
concatenated_arr = np.concatenate((arr1, arr2))
print("连接后的数组：", concatenated_arr)

# 使用vstack()函数将两个数组垂直堆叠起来
stacked_arr = np.vstack((arr1, arr2))
print("堆叠后的数组：", stacked_arr)

# 使用hstack()函数将两个数组水平堆叠起来
horizontal_stacked_arr = np.hstack((arr1, arr2))
print("水平堆叠后的数组：", horizontal_stacked_arr)

**逻辑分析：**

* `np.concatenate((arr1, arr2))`：将`arr1`和`arr2`数组沿着轴0连接起来，形成一个新的数组。
* `np.vstack((arr1, arr2))`：将`arr1`和`arr2`数组垂直堆叠起来，形成一个新的数组。
* `np.hstack((arr1, arr2))`：将`arr1`和`arr2`数组水平堆叠起来，形成一个新的数组。

#### 4.2.2 数组分割

NumPy提供了数组分割函数，包括：

- `split()`: 将数组分割成多个子数组。
- `array_split()`: 将数组分割成相等大小的子数组。
- `hsplit()`: 将数组水平分割成多个子数组。

**代码块：**

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5, 6])

# 使用split()函数将数组分割成三个子数组
split_arrays = np.split(arr, 3)
print("分割后的子数组：", split_arrays)

# 使用array_split()函数将数组分割成两个相等大小的子数组
array_split_arrays = np.array_split(arr, 2)
print("相等大小的子数组：", array_split_arrays)

# 使用hsplit()函数将数组水平分割成两个子数组
hsplit_arrays = np.hsplit(arr, 2)
print("水平分割后的子数组：", hsplit_arrays)

**逻辑分析：**

* `np.split(arr, 3)`：将`arr`数组分割成三个子数组，每个子数组包含两个元素。
* `np.array_split(arr, 2)`：将`arr`数组分割成两个相等大小的子数组，每个子数组包含三个元素。
* `np.hsplit(arr, 2)`：将`arr`数组水平分割成两个子数组，每个子数组包含三个元素。

# 5. NumPy数组高级应用

### 5.1 线性代数操作

NumPy库提供了丰富的线性代数操作函数，可以方便地进行矩阵运算、求解线性方程组等操作。

#### 5.1.1 矩阵乘法

矩阵乘法是线性代数中的一种基本运算，用于计算两个矩阵相乘得到的结果矩阵。NumPy中提供了`np.dot()`函数进行矩阵乘法运算。

import numpy as np

# 创建两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 计算矩阵乘法
C = np.dot(A, B)

print(C)

输出：

[[19 22]
 [43 50]]

#### 5.1.2 矩阵求逆

矩阵求逆是求解线性方程组的一种重要方法。NumPy中提供了`np.linalg.inv()`函数进行矩阵求逆运算。

# 创建一个矩阵
A = np.array([[1, 2], [3, 4]])

# 计算矩阵的逆矩阵
A_inv = np.linalg.inv(A)

print(A_inv)

输出：

[[-2.  1. ]
 [ 1.5 -0.5]]

### 5.2 傅里叶变换

傅里叶变换是一种数学变换，可以将时域信号转换为频域信号。NumPy中提供了`np.fft.fft()`和`np.fft.ifft()`函数进行傅里叶变换和逆傅里叶变换运算。

#### 5.2.1 傅里叶变换的原理

傅里叶变换将时域信号分解为一系列正弦波和余弦波，每个波的频率和幅度对应于时域信号中特定频率分量的强度。

#### 5.2.2 NumPy中的傅里叶变换函数

import numpy as np

# 创建一个时域信号
t = np.linspace(0, 1, 100)
x = np.sin(2 * np.pi * 10 * t) + np.cos(2 * np.pi * 20 * t)

# 进行傅里叶变换
X = np.fft.fft(x)

# 计算频率
freqs = np.fft.fftfreq(len(x))

# 绘制频谱图
import matplotlib.pyplot as plt
plt.plot(freqs, np.abs(X))
plt.xlabel('Frequency (Hz)')
plt.ylabel('Amplitude')
plt.show()

输出：

[频谱图](https://matplotlib.org/stable/tutorials/introductory/pyplot.html#sphx-glr-tutorials-introductory-pyplot-py)

图中显示了时域信号的频谱图，可以看出时域信号包含了频率为10Hz和20Hz的正弦波分量。

# 6. NumPy库实战应用

### 6.1 图像处理

NumPy在图像处理领域有着广泛的应用，它提供了丰富的数组操作和图像处理函数，可以高效地处理图像数据。

#### 6.1.1 图像读取和显示

import numpy as np
from PIL import Image

# 读取图像
image = Image.open('image.jpg')

# 转换为NumPy数组
image_array = np.array(image)

#### 6.1.2 图像处理操作

NumPy提供了各种图像处理操作，例如：

* **颜色空间转换：**将图像从一种颜色空间（如RGB）转换为另一种（如灰度）。
* **图像滤波：**使用卷积核对图像进行平滑、锐化或边缘检测。
* **图像分割：**将图像分割成不同的区域或对象。
* **图像几何变换：**旋转、缩放或裁剪图像。

# 灰度化图像
gray_image = np.mean(image_array, axis=2)

# 高斯滤波
blurred_image = cv2.GaussianBlur(image_array, (5, 5), 0)

# 边缘检测
edges_image = cv2.Canny(image_array, 100, 200)

### 6.2 数据分析

NumPy在数据分析中也扮演着重要的角色，它提供了高效的数据加载、预处理和分析工具。

#### 6.2.1 数据加载和预处理

# 加载CSV数据
data = np.loadtxt('data.csv', delimiter=',')

# 缺失值处理
data[np.isnan(data)] = 0

# 标准化数据
data = (data - np.min(data)) / (np.max(data) - np.min(data))

#### 6.2.2 数据分析和可视化

NumPy提供了统计函数和可视化工具，可以帮助分析和可视化数据。

# 计算均值和标准差
mean = np.mean(data, axis=0)
std = np.std(data, axis=0)

# 绘制散点图
plt.scatter(data[:, 0], data[:, 1])
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()