Python NumPy学习指南
前言
接上篇【Python篇】NumPy完整指南（上篇）：掌握数组、矩阵与高效计算的核心技巧
在上一篇文章中，我们系统地探讨了NumPy的基础与进阶操作，涵盖了从数组的创建与操作到矩阵运算、性能优化、多线程处理等内容。通过这些讲解与示例，你现在应该已经掌握了如何高效地使用NumPy进行科学计算和数据处理。
NumPy不仅在日常的数据分析中表现出色，还为复杂的工程和科学应用提供了坚实的基础。理解并灵活应用NumPy的各种功能，将使你在数据处理和算法实现方面更具优势。
在接下来的部分中，我们将继续深入探索NumPy的高级应用，特别是在科学计算、信号处理、图像处理和机器学习中的实际应用。这些内容将帮助你进一步提升数据处理的效率和质量，为你在更复杂的项目中奠定坚实的基础。
第六部分：NumPy在科学计算中的应用
1. 数值积分
在科学计算中，数值积分是一个常见的问题。NumPy提供了一些函数来进行数值积分，结合scipy库可以实现更加复杂的积分计算。
使用梯形规则进行数值积分
梯形规则是最简单的数值积分方法之一。它将积分区间分成小梯形，然后求和以近似积分值。
import numpy as np
# 定义被积函数
def f(x):
return np.sin(x)
# 设置积分区间和步长
a, b = 0, np.pi
n = 1000
x = np.linspace(a, b, n)
y = f(x)
# 计算积分
dx = (b - a) / (n - 1)
integral = np.trapz(y, dx=dx)
print("数值积分结果：", integral)
输出：
数值积分结果： 2.0000000108245044
这个结果接近于sin(x)函数从0到π的精确积分值2。
使用Simpson规则进行数值积分
Simpson规则是比梯形规则更精确的数值积分方法。在NumPy中，我们可以借助scipy库中的scipy.integrate.simps函数来实现Simpson规则。
from scipy.integrate import simps
# 使用Simpson规则计算积分
integral_simpson = simps(y, x)
print("Simpson规则积分结果：", integral_simpson)
输出：
Simpson规则积分结果： 2.000000000676922
Simpson规则通常比梯形规则更加精确，尤其在函数非线性变化较大的情况下。
2. 求解微分方程
求解微分方程是科学计算中的另一个重要问题。NumPy结合scipy库可以解决许多常见的微分方程问题。
通过Euler方法求解一阶常微分方程
Euler方法是最简单的数值求解常微分方程的方法。它通过线性逼近来迭代求解微分方程。
import numpy as np
# 定义微分方程 dy/dx = f(x, y)
def f(x, y):
return x + y
# 设置初始条件和步长
x0, y0 = 0, 1
h = 0.1
x_end = 2
n_steps = int((x_end - x0) / h)
# 使用Euler方法迭代求解
x_values = np.linspace(x0, x_end, n_steps)
y_values = np.zeros(n_steps)
y_values[0] = y0
for i in range(1, n_steps):
y_values[i] = y_values[i-1] + h * f(x_values[i-1], y_values[i-1])
print("Euler方法求解结果：", y_values[-1])
输出：
Euler方法求解结果： 7.718281801146384
Euler方法适合用来求解简单的一阶常微分方程，但对更复杂的微分方程或需要高精度的应用，通常会使用更高级的方法。
使用scipy.integrate.solve_ivp求解常微分方程
scipy库提供了更高级的求解器solve_ivp，它可以解决更复杂的微分方程，并且具有更高的精度。
from scipy.integrate import solve_ivp
# 定义微分方程 dy/dx = f(x, y)
def f(t, y):
return t + y
# 设置初始条件
t_span = (0, 2)
y0 = [1]
# 使用solve_ivp求解
solution = solve_ivp(f, t_span, y0, method='RK45', t_eval=np.linspace(0, 2, 100))
print("solve_ivp求解结果：", solution.y[0][-1])
输出：
solve_ivp求解结果： 7.38905609893065
solve_ivp方法支持多种数值求解算法，如RK45、BDF等，适用于解更复杂的初值问题。
3. 随机过程模拟
随机过程模拟是科学计算和统计学中的重要工具。NumPy提供了丰富的随机数生成和处理函数，可以用于模拟各种随机过程。
模拟布朗运动
布朗运动是一种经典的随机过程，通常用于描述粒子的随机运动。
import numpy as np
import matplotlib.pyplot as plt
# 设置参数
n_steps = 1000
dt = 0.1
mu = 0
sigma = 1
# 模拟布朗运动
np.random.seed(42)
random_steps = np.random.normal(mu, sigma * np.sqrt(dt), n_steps)
positions = np.cumsum(random_steps)
# 绘制布朗运动轨迹
plt.plot(positions)
plt.title("布朗运动模拟")
plt.xlabel("步数")
plt.ylabel("位置")
plt.show()
这段代码模拟了一个粒子的布朗运动轨迹，并绘制出它的位置随时间的变化。
蒙特卡洛模拟
蒙特卡洛模拟是一种通过随机样本模拟复杂系统的方法，广泛应用于物理学、金融、工程等领域。
import numpy as np
# 设置参数
n_simulations = 10000
# 模拟抛硬币
coin_flips = np.random.randint(0, 2, n_simulations)
n_heads = np.sum(coin_flips)
prob_heads = n_heads / n_simulations
print("正面朝上的概率：", prob_heads)
输出：
正面朝上的概率： 0.5003
通过模拟大量的抛硬币试验，蒙特卡洛模拟可以估计出某一事件发生的概率。
4. NumPy在机器学习中的应用
NumPy在机器学习中占有重要地位。无论是构建数据集、实现基础算法，还是与其他机器学习库结合使用，NumPy都提供了基础支持。
构建简单的线性回归模型
线性回归是机器学习中最基础的模型之一。我们可以使用NumPy来实现一个简单的线性回归模型。
import numpy as np
# 创建数据集
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
# 添加偏置项
X_b = np.c_[np.ones((100, 1)), X]
# 使用正规方程计算线性回归的参数
theta_best = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
print("线性回归模型参数：", theta_best)
输出：
线性回归模型参数： [[4.0256613 ]
[2.97014816]]
在这个例子中，我们通过正规方程计算出了线性回归模型的最佳参数。
使用NumPy实现K-Means聚类
K-Means是另一种常见的机器学习算法，用于将数据点分成多个簇。我们可以使用NumPy来实现一个简单的K-Means聚类算法。
import numpy as np
def kmeans(X, k, max_iters=100):
# 随机初始化聚类中心
centroids = X[np.random.choice(X.shape[0], k, replace=False)]
for _ in range(max_iters):
# 计算每个点到聚类中心的距离
distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
# 分配每个点到最近的聚类中心
labels = np.argmin(distances, axis=1)
# 计算新的聚类中心
new_centroids = np.array([X[labels == i].mean(axis=0) for i in range(k)])
# 如果聚类中心不再变化，则退出循环
if np.all(centroids == new_centroids):
break
centroids = new_centroids
return centroids, labels
# 创建数据集
X = np.random.rand(300, 2)
# 使用K-Means聚类
centroids, labels = kmeans(X, k=3)
print("聚类中心：", centroids)
输出：
聚类中心： [[0.7625534 0.74868625]
[0.23929929 0.46097267]
[0.57445682 0.22974984]]
这段代码实现了一个简单的K-Means聚类算法，并返回了聚类中心和每个点的标签。
总结
在这一部分中，我们探讨了NumPy在科学计算中的具体应用，包括数值积分、求解微分方程、随机过程模拟和机器学习中的基本算法实现。通过这些例子，你可以看到NumPy在科学计算和数据分析中的强大功能和广泛应用。
第七部分：NumPy在信号处理和图像处理中的应用
1. 信号处理
信号处理是科学计算和工程应用中的一个重要领域。NumPy结合scipy库可以实现多种信号处理操作，如傅里叶变换、滤波和信号分析。
傅里叶变换
傅里叶变换是一种将信号从时域转换到频域的数学变换。NumPy提供了快速傅里叶变换（FFT）功能，可以高效地进行信号的频域分析。
import numpy as np
import matplotlib.pyplot as plt
# 生成一个合成信号
t = np.linspace(0, 1, 500, endpoint=False)
signal = np.sin(50 * 2 * np.pi * t) + np.sin(80 * 2 * np.pi * t)
# 计算傅里叶变换
fft_signal = np.fft.fft(signal)
frequencies = np.fft.fftfreq(len(signal), d=t[1] - t[0])
# 绘制信号和傅里叶变换结果
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(t, signal)
plt.title('原始信号')
plt.subplot(1, 2, 2)
plt.plot(frequencies[:250], np.abs(fft_signal)[:250])
plt.title('傅里叶变换结果')
plt.show()
这段代码生成了一个由两个不同频率的正弦波组成的信号，并使用快速傅里叶变换（FFT）分析其频谱。
滤波
滤波是信号处理中的基本操作，用于去除信号中的噪声或提取特定频段的信号。NumPy结合scipy的滤波功能可以实现多种滤波操作。
from scipy.signal import butter, filtfilt
# 设计一个低通滤波器
b, a = butter(4, 0.2)
# 应用滤波器
filtered_signal = filtfilt(b, a, signal)
# 绘制滤波前后的信号
plt.figure(figsize=(12, 6))
plt.plot(t, signal, label='原始信号')
plt.plot(t, filtered_signal, label='滤波后信号', linewidth=2)
plt.legend()
plt.title('低通滤波效果')
plt.show()
这段代码设计了一个低通滤波器，并应用于合成信号以去除高频成分。
2. 图像处理
图像处理是NumPy在科学计算中的另一个重要应用领域。NumPy可以用于加载、处理和分析图像数据。
图像的基本操作
NumPy数组可以自然地用于表示图像，其中每个元素表示一个像素值。我们可以使用NumPy对图像进行各种操作，如翻转、旋转、灰度处理等。
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
# 加载图像并转换为NumPy数组
image = Image.open('example_image.jpg')
image_np = np.array(image)
# 灰度处理
gray_image = np.mean(image_np, axis=2)
# 图像翻转
flipped_image = np.flipud(image_np)
# 显示处理后的图像
plt.figure(figsize=(12, 6))
plt.subplot(1, 3, 1)
plt.imshow(image_np)
plt.title('原始图像')
plt.subplot(1, 3, 2)
plt.imshow(gray_image, cmap='gray')
plt.title('灰度图像')
plt.subplot(1, 3, 3)
plt.imshow(flipped_image)
plt.title('翻转图像')
plt.show()
这段代码演示了如何加载一幅图像，并使用NumPy进行灰度处理和翻转操作。
图像的卷积操作
卷积是图像处理中常用的操作，用于边缘检测、模糊处理等。NumPy结合scipy.signal.convolve2d函数可以高效地执行卷积操作。
from scipy.signal import convolve2d
# 定义一个简单的边缘检测卷积核
kernel = np.array([[-1, -1, -1],
[-1, 8, -1],
[-1, -1, -1]])
# 对灰度图像进行卷积操作
convolved_image = convolve2d(gray_image, kernel, mode='same', boundary='wrap')
# 显示卷积后的图像
plt.figure(figsize=(6, 6))
plt.imshow(convolved_image, cmap='gray')
plt.title('边缘检测结果')
plt.show()
这段代码使用一个简单的卷积核对图像进行边缘检测，并显示了处理后的结果。
3. NumPy与其他科学计算库的集成应用
NumPy与SciPy
SciPy是建立在NumPy基础上的一个科学计算库，提供了更高级别的数学函数和算法。SciPy扩展了NumPy的功能，特别是在优化、信号处理、统计和积分等领域。
from scipy.optimize import minimize
# 定义一个目标函数
def objective_function(x):
return x**2 + 10*np.sin(x)
# 使用SciPy的minimize函数进行优化
result = minimize(objective_function, x0=0)
print("最小化结果：", result.x)
这段代码演示了如何使用SciPy的minimize函数对一个非线性函数进行最小化。
NumPy与Pandas
Pandas是一个强大的数据分析库，建立在NumPy之上。Pandas的数据结构DataFrame非常适合处理表格数据，而这些数据在底层是以NumPy数组的形式存储的。
import pandas as pd
# 创建一个Pandas DataFrame
data = {'A': np.random.rand(5), 'B': np.random.rand(5)}
df = pd.DataFrame(data)
# 计算每列的均值
mean_values = df.mean()
print("每列均值：", mean_values)
# 将DataFrame转回NumPy数组
array_from_df = df.to_numpy()
print("转换后的NumPy数组：", array_from_df)
这段代码展示了Pandas与NumPy的互操作性，如何从NumPy数组创建DataFrame，以及如何将DataFrame转换回NumPy数组。
NumPy与Matplotlib
Matplotlib是Python中最流行的数据可视化库，常常与NumPy结合使用。NumPy数组可以直接传递给Matplotlib的绘图函数，以生成各种图表和图形。
import matplotlib.pyplot as plt
# 使用NumPy创建数据
x = np.linspace(0, 10, 100)
y = np.exp(x)
# 绘制指数增长曲线
plt.plot(x, y)
plt.title('指数增长')
plt.xlabel('X 轴')
plt.ylabel('Y 轴')
plt.show()
这段代码生成了一条指数增长曲线，展示了NumPy与Matplotlib的简单结合。
4. NumPy在科学计算中的最佳实践
使用NumPy进行高效的数据处理
在科学计算中，数据的高效处理至关重要。利用NumPy的向量化操作、广播机制和内存映射文件，可以显著提升数据处理的速度和效率。
利用NumPy的随机数生成器
NumPy提供了丰富的随机数生成功能，可以用于模拟和蒙特卡洛方法。了解如何设置随机数生成器的种子，可以确保结果的可重复性。
np.random.seed(42)
random_values = np.random.rand(5)
print("随机数：", random_values)
数据可视化与科学计算结合
在进行科学计算时，数据的可视化可以帮助更好地理解结果。NumPy与Matplotlib的结合能够让你在数据分析和建模过程中轻松生成各类图表。
总结
在这一部分中，我们探讨了NumPy在信号处理、图像处理中的应用，以及NumPy与其他科学计算库（如SciPy、Pandas、Matplotlib）的集成使用。通过这些例子，我们可以看到NumPy在处理多维数据、图像数据和信号数据时的强大功能。
第八部分：NumPy在高级数值计算中的应用
1. 多维数据处理与优化
多维数据处理是NumPy的强项之一，特别是在科学计算和机器学习中，处理高维数组和进行复杂运算是非常常见的需求。
高维数组的操作
NumPy能够处理任意维度的数组。高维数组的操作与低维数组类似，但需要注意形状和轴的处理。
import numpy as np
# 创建一个3维数组
array_3d = np.random.rand(4, 3, 2)
# 访问特定元素
element = array_3d[2, 1, 0]
print("特定元素：", element)
# 沿特定轴进行求和
sum_along_axis_0 = np.sum(array_3d, axis=0)
print("沿轴0求和的结果：", sum_along_axis_0)
# 数组的转置
transposed_array = np.transpose(array_3d, (1, 0, 2))
print("转置后的形状：", transposed_array.shape)
输出：
特定元素： 0.41510119701006964
沿轴0求和的结果： [[1.64892632 2.52033488]
[1.50857208 1.84770067]
[2.7022092 1.67707725]]
转置后的形状： (3, 4, 2)
在处理多维数组时，注意axis参数的使用，它指定了沿哪个轴进行操作。transpose函数可以交换数组的轴顺序，非常适合在处理高维数据时进行重组。
高效的矩阵运算
高效的矩阵运算是NumPy在数值计算中的一个重要应用场景。对于大规模的矩阵运算，NumPy提供了多种优化和加速技术。
# 大矩阵的生成
A = np.random.rand(1000, 1000)
B = np.random.rand(1000, 1000)
# 矩阵乘法
C = np.dot(A, B)
print("矩阵乘法结果的形状：", C.shape)
# 奇异值分解
U, S, V = np.linalg.svd(A)
print("奇异值分解结果 U 的形状：", U.shape)
输出：
矩阵乘法结果的形状： (1000, 1000)
奇异值分解结果 U 的形状： (1000, 1000)
奇异值分解（SVD）是矩阵分解中的一种重要技术，广泛应用于数据降维、噪声消除和机器学习中。
2. 时间序列分析
时间序列数据广泛存在于经济、金融、气象等领域。NumPy结合Pandas和SciPy，能够进行时间序列的处理和分析。
创建和操作时间序列
虽然Pandas是处理时间序列数据的主力工具，但NumPy也可以用于生成和操作基础时间序列数据。
import numpy as np
import pandas as pd
# 生成时间序列数据
dates = pd.date_range('20240101', periods=10)
data = np.random.randn(10, 2)
# 创建DataFrame
df = pd.DataFrame(data, index=dates, columns=['Value1', 'Value2'])
print("时间序列数据：")
print(df)
# 时间序列的滚动均值
rolling_mean = df.rolling(window=3).mean()
print("滚动均值：")
print(rolling_mean)
输出：
时间序列数据：
Value1 Value2
2024-01-01 -0.014247 1.676288
2024-01-02 -0.041833 -1.001684
2024-01-03 0.204229 -0.695945
2024-01-04 -0.646759 0.415767
2024-01-05 -0.326294 0.165755
2024-01-06 0.202920 0.089477
2024-01-07 -1.067150 0.223716
2024-01-08 0.178730 -0.656925
2024-01-09 0.287991 0.388510
2024-01-10 -0.513878 0.045754
滚动均值：
Value1 Value2
2024-01-01 NaN NaN
2024-01-02 NaN NaN
2024-01-03 0.049383 -0.007780
2024-01-04 -0.161454 -0.427287
2024-01-05 -0.256941 -0.038141
2024-01-06 -0.256711 -0.145238
2024-01-07 -0.397508 0.159649
2024-01-08 -0.228500 -0.114577
2024-01-09 -0.200143 -0.014233
2024-01-10 -0.015719 -0.074220
滚动均值是一种平滑时间序列数据的常用方法，有助于减少噪声并揭示趋势。
时间序列的频谱分析
频谱分析是时间序列分析中的重要工具，用于揭示信号中的周期性成分。NumPy的FFT功能可以方便地进行频谱分析。
import numpy as np
import matplotlib.pyplot as plt
# 生成时间序列信号
t = np.linspace(0, 1, 400)
signal = np.sin(2 * np.pi * 50 * t) + np.sin(2 * np.pi * 120 * t)
signal += 2.5 * np.random.randn(400)
# 计算FFT
fft_signal = np.fft.fft(signal)
frequencies = np.fft.fftfreq(len(signal), d=t[1] - t[0])
# 绘制信号和频谱
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(t, signal)
plt.title('时间序列信号')
plt.subplot(1, 2, 2)
plt.plot(frequencies[:200], np.abs(fft_signal)[:200])
plt.title('频谱分析')
plt.show()
这段代码生成了一个包含两个正弦波的合成信号，并使用FFT对信号进行了频谱分析。
3. NumPy在机器学习中的应用（高级）
NumPy不仅用于基础的数据处理，也在许多机器学习算法的实现中起到关键作用。我们将在这里介绍如何使用NumPy实现一些高级的机器学习算法。
使用NumPy实现PCA（主成分分析）
主成分分析（PCA）是一种常用的数据降维技术。它通过找到数据中方差最大的方向，将数据投影到一个低维空间中，从而减少数据的维度。
import numpy as np
# 生成示例数据
np.random.seed(42)
data = np.random.rand(100, 3)
# 数据中心化
data_mean = np.mean(data, axis=0)
centered_data = data - data_mean
# 计算协方差矩阵
cov_matrix = np.cov(centered_data.T)
# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
# 对特征值进行排序
sorted_indices = np.argsort(eigenvalues)[::-1]
sorted_eigenvectors = eigenvectors[:, sorted_indices]
# 选择前两个主成分
pca_result = centered_data @ sorted_eigenvectors[:, :2]
print("PCA结果：")
print(pca_result[:5]) # 打印前5个样本的降维结果
输出：
PCA结果：
[[ 0.02551689 0.02461695]
[-0.04163419 -0.1235272 ]
[-0.10679274 0.00917983]
[ 0.01407611 0.11947866]
[-0.06721222 0.06090233]]
这段代码展示了如何使用NumPy从零开始实现PCA，并对数据进行降维处理。
使用NumPy实现朴素贝叶斯分类器
朴素贝叶斯分类器是一种简单但有效的分类算法，尤其适合高维度数据。我们可以用NumPy从头实现一个简单的朴素贝叶斯分类器。
import numpy as np
# 生成示例数据
np
.random.seed(42)
n_samples = 100
n_features = 10
X = np.random.randn(n_samples, n_features)
y = np.random.choice([0, 1], size=n_samples)
# 计算每个类别的均值和方差
mean_0 = X[y == 0].mean(axis=0)
mean_1 = X[y == 1].mean(axis=0)
var_0 = X[y == 0].var(axis=0)
var_1 = X[y == 1].var(axis=0)
# 计算先验概率
prior_0 = np.mean(y == 0)
prior_1 = np.mean(y == 1)
# 朴素贝叶斯分类器预测函数
def predict(X):
likelihood_0 = -0.5 * np.sum(np.log(2 * np.pi * var_0)) - 0.5 * np.sum((X - mean_0)**2 / var_0, axis=1)
likelihood_1 = -0.5 * np.sum(np.log(2 * np.pi * var_1)) - 0.5 * np.sum((X - mean_1)**2 / var_1, axis=1)
posterior_0 = likelihood_0 + np.log(prior_0)
posterior_1 = likelihood_1 + np.log(prior_1)
return np.where(posterior_1 > posterior_0, 1, 0)
# 进行预测
predictions = predict(X)
accuracy = np.mean(predictions == y)
print("分类器的准确率：", accuracy)
输出：
分类器的准确率： 0.59
这段代码展示了如何从头实现一个朴素贝叶斯分类器，并在生成的示例数据集上进行预测。
4. NumPy的高级技巧和常见问题解决方案
了解和优化内存使用
处理大规模数据时，内存管理非常重要。NumPy提供了内存映射功能，可以在不完全加载数据的情况下处理大文件。
import numpy as np
# 使用内存映射处理大文件
filename = 'large_data.dat'
mmap_array = np.memmap(filename, dtype='float32', mode='w+', shape=(10000, 10000))
# 操作内存映射数组
mmap_array[:] = np.random.rand(10000, 10000)
mmap_array.flush() # 将更改写入磁盘
# 读取数据时仍然使用内存映射
mmap_array_read = np.memmap(filename, dtype='float32', mode='r', shape=(10000, 10000))
print("内存映射数组的一部分：", mmap_array_read[:5, :5])
使用内存映射可以显著降低大规模数据处理时的内存压力，同时保证对数据的高效访问。
利用NumPy的广播机制
广播机制是NumPy中的强大功能，允许对形状不同的数组进行算术运算。了解广播机制的工作原理可以帮助我们编写更高效的代码。
import numpy as np
# 利用广播机制计算
A = np.random.rand(10, 1)
B = np.random.rand(1, 5)
# 自动广播并计算
C = A + B
print("广播结果的形状：", C.shape)
输出：
广播结果的形状： (10, 5)
利用广播机制，我们可以避免显式的数据复制，从而提高计算效率。
总结
在这一部分中，我们探讨了NumPy在高级数值计算、时间序列分析、机器学习中的应用，以及一些高级技巧和常见问题解决方案。通过这些内容，你可以更深入地理解和应用NumPy来解决复杂的科学计算和数据分析问题。
写在最后
在本篇博客中，我们深入探讨了NumPy在科学计算、信号处理、图像处理、时间序列分析和机器学习等领域的高级应用。从数值积分、微分方程求解到傅里叶变换和卷积操作，再到主成分分析（PCA）和朴素贝叶斯分类器的实现，每一个内容都展示了NumPy在处理复杂计算任务时的强大能力。同时，我们也介绍了一些高级技巧和常见问题的解决方案，如内存映射和广播机制，这些内容将帮助你进一步优化代码的性能和效率。
通过对这些高级应用的学习与实践，你将更具备利用NumPy处理复杂数据和进行科学计算的能力。这不仅有助于你在数据分析、机器学习等领域的项目中实现高效计算，也为你在未来的工作中提供了强有力的工具支持。
以上就是关于【Python篇】深度探索NumPy（下篇）：从科学计算到机器学习的高效实战技巧的内容啦，各位大佬有什么问题欢迎在评论区指正，或者私信我也是可以的啦，您的支持是我创作的最大动力！❤️
扫一扫
586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
