Pandas GroupBy 性能优化与高级用法 – wiki基地

作者： /

精通 Pandas GroupBy：性能优化与高级用法深度解析

Pandas 是 Python 数据科学生态系统中的基石库，提供了强大且灵活的数据结构和数据分析工具。其中，GroupBy 操作是数据聚合、转换和分析的核心，允许我们将数据根据某些标准分割成组，然后对每个组独立应用函数（聚合、转换、过滤等），最后将结果合并起来。虽然 GroupBy 功能强大，但在处理大型数据集时，性能往往成为瓶颈。同时，其丰富的特性也意味着存在许多基础用法之外的高级技巧。

本文旨在深入探讨 Pandas GroupBy 的性能优化策略和高级用法，帮助你更高效、更灵活地驾驭数据分组操作，提升数据处理能力。本文预计篇幅较长，将覆盖从基础回顾到深入优化和高级技巧的方方面面。

一、GroupBy 基础回顾：Split-Apply-Combine 范式

在我们深入探讨性能和高级用法之前，有必要快速回顾一下 GroupBy 的核心思想：Split-Apply-Combine（拆分-应用-合并）。

  1. Split（拆分）：根据指定的键（列名、索引级别、函数、数组等），将 DataFrame 或 Series 拆分成多个组。
  2. Apply（应用）：对每个独立的组应用一个或多个函数。这可以是：
    • 聚合（Aggregation）: 计算每个组的统计摘要（如 sum(), mean(), size(), std()）。结果的行数通常等于组的数量。
    • 转换（Transformation）: 对组内数据执行特定计算，返回与原始组形状相同的 Series 或 DataFrame（如组内标准化 (x - x.mean()) / x.std()）。
    • 过滤（Filtration）: 根据组级别的计算结果，丢弃某些组。
    • 通用应用 (apply): 应用任意自定义函数，可以返回标量、Series 或 DataFrame，提供了最大的灵活性。
  3. Combine（合并）：将应用阶段产生的结果整合到一个新的数据结构（通常是 Series 或 DataFrame）中。

一个基础的 GroupBy 操作如下所示：

“`python
import pandas as pd
import numpy as np

创建示例数据

data = {‘Category’: [‘A’, ‘B’, ‘A’, ‘B’, ‘A’, ‘C’, ‘C’, ‘A’, ‘B’],
‘Value1’: np.random.randn(9) * 10,
‘Value2’: np.random.randint(1, 10, 9),
‘Timestamp’: pd.to_datetime([‘2023-01-01’, ‘2023-01-01’, ‘2023-01-02’,
‘2023-01-02’, ‘2023-01-03’, ‘2023-01-03’,
‘2023-01-04’, ‘2023-01-04’, ‘2023-01-05’])}
df = pd.DataFrame(data)

按 ‘Category’ 分组，计算 Value1 的平均值和 Value2 的总和

grouped = df.groupby(‘Category’)
result = grouped.agg(
Avg_Value1=(‘Value1’, ‘mean’),
Sum_Value2=(‘Value2’, ‘sum’)
)
print(“基础 GroupBy 聚合结果:”)
print(result)
“`

二、GroupBy 性能优化策略

当数据集增大时，GroupBy 操作可能变得非常耗时。理解其内部机制并采用优化策略至关重要。

1. 优先使用内置聚合函数

Pandas 的许多内置聚合函数（如 sum, mean, median, std, var, count, size, min, max, first, last, nunique）都是用 Cython 实现的。这意味着它们在底层直接操作 NumPy 数组，避免了 Python 解释器的开销，速度远快于使用 Python 循环或自定义的 Python 函数。

反例（低效）:

“`python

使用 apply + lambda 实现 sum，效率较低

slow_sum = df.groupby(‘Category’)[‘Value1’].apply(lambda x: x.sum())
“`

推荐（高效）:

“`python

直接使用内置 sum 函数

fast_sum = df.groupby(‘Category’)[‘Value1’].sum()

或者通过 agg 使用

fast_agg_sum = df.groupby(‘Category’).agg(Sum_Value1=(‘Value1’, ‘sum’))
“`

核心原则：尽可能利用 Pandas 提供的、经过优化的内置函数进行聚合。

2. 理解 agg, transform, apply 的性能差异

这三个方法是 GroupBy 对象最常用的应用函数方法，但它们的性能特征和适用场景不同：

  • agg (aggregate): 用于聚合操作。它可以同时应用多个聚合函数，并且可以为不同的列指定不同的函数。它通常是最高效的，特别是当使用内置函数时。返回结果的索引是分组键。
  • transform: 用于组内转换。它要求传入的函数返回与输入组形状相同的 Series 或 DataFrame。结果的索引与原始 DataFrame 相同。transform 对于某些内置操作（如 mean, sum 等）也进行了优化。它常用于特征工程，如计算组内 Z-score。
  • apply: 最通用，但也通常最慢。它可以接受返回标量、Series 或 DataFrame 的任意函数。Pandas 无法对 apply 中的任意 Python 代码进行深度优化，有时它可能需要逐组迭代执行 Python 函数，导致性能下降。只有在 agg 和 transform 无法满足需求时才应考虑使用 apply。

性能排序（通常）：agg (内置函数) > transform (内置函数) > agg (自定义函数) > transform (自定义函数) > apply

示例:

“`python

高效：使用 agg 计算多个聚合

agg_result = df.groupby(‘Category’).agg({
‘Value1’: [‘mean’, ‘std’],
‘Value2’: ‘sum’
})

高效：使用 transform 计算组内均值并广播

df[‘Group_Mean_Value1’] = df.groupby(‘Category’)[‘Value1’].transform(‘mean’)

可能较慢：使用 apply 实现复杂逻辑（假设无法用 agg/transform 替代）

def custom_logic(group):
# 示例：计算 Value1 > 0 的比例
return (group[‘Value1’] > 0).sum() / len(group)

apply_result = df.groupby(‘Category’).apply(custom_logic)
“`

优化建议：
* 优先考虑 agg 和 transform。
* 如果必须使用 apply，确保传递给 apply 的函数尽可能高效。避免在函数内部进行不必要的计算或数据复制。
* 有时，一个复杂的 apply 操作可以分解为多个 agg 和 transform 操作的组合，这通常更快。

3. 使用 Categorical 数据类型

如果你的分组键是字符串类型，并且唯一值的数量（基数）相对于数据总量来说不是特别大，将其转换为 Categorical 类型可以显著提高 GroupBy 的性能。

Categorical 类型在内部使用整数编码来表示不同的类别，分组操作实际上是在这些整数上进行的，这比在字符串上进行分组要快得多。内存占用也会减少。

“`python

假设 ‘Category’ 列是字符串，并且类别不多

df[‘Category’] = df[‘Category’].astype(‘category’)

现在基于 Category 列的 GroupBy 操作会更快

categorical_grouped_result = df.groupby(‘Category’)[‘Value1’].mean()
“`

注意：如果分组键的基数非常高（接近行的数量），转换为 Categorical 可能不会带来性能提升，甚至可能因为维护映射表的开销而变慢。

4. 预先过滤数据

如果你的分析只需要数据的一个子集，那么在执行 GroupBy 之前先过滤掉不需要的行，可以减小参与分组的数据量，从而提高性能。

低效:

“`python

先分组，再在 apply 函数内部过滤 (非常低效)

def filter_logic(group):

if group[‘Timestamp’].min() > pd.to_datetime(‘2023-01-02’):

return group[‘Value1’].mean()

else:

return np.nan

result = df.groupby(‘Category’).apply(filter_logic)

稍好，但仍需处理所有组

result = df.groupby(‘Category’)[‘Value1’].mean()

假设之后再根据条件过滤结果 (这取决于具体逻辑)

“`

高效:

“`python

先过滤，再分组

filtered_df = df[df[‘Timestamp’] > pd.to_datetime(‘2023-01-02’)]
result = filtered_df.groupby(‘Category’)[‘Value1’].mean()
“`

5. 避免在 apply 中创建大型中间对象

在传递给 apply 的自定义函数中，尽量避免创建和返回非常大的 Pandas 对象（Series/DataFrame），尤其是当这些对象不是最终需要的结果时。这会增加内存消耗和计算时间。

6. 使用 as_index=False

在 groupby() 方法中设置 as_index=False，可以让分组键直接成为结果 DataFrame 的列，而不是索引。这在某些情况下可以略微提高性能（减少了构建索引的开销），并且常常使后续操作更方便。

“`python

分组键作为索引 (默认)

result_with_index = df.groupby(‘Category’).agg(Mean_Value1=(‘Value1’, ‘mean’))

分组键作为列

result_no_index = df.groupby(‘Category’, as_index=False).agg(Mean_Value1=(‘Value1’, ‘mean’))
print(“\nGroupBy with as_index=False:”)
print(result_no_index)
“`

7. 利用 Numba 或 Cython 加速自定义函数

如果你的瓶颈在于传递给 agg, transform, 或 apply 的自定义 Python 函数，并且该函数主要是数值计算，可以考虑使用 Numba 或 Cython 来加速它。

  • Numba: 通过 JIT（Just-In-Time）编译器将 Python 函数（尤其是包含 NumPy 操作和循环的）编译成快速的机器码。通常只需添加一个 @numba.jit 装饰器。
  • Cython: 一种语言，允许你编写 C 语言扩展。可以将 Python 代码（特别是性能关键部分）翻译成 C 代码，然后编译成 Python 扩展模块。这提供了更大的控制力，但学习曲线也更陡峭。

示例 (Numba):

“`python
import numba

假设有一个计算密集的自定义聚合函数

def complex_calculation(arr):
# (这里只是一个简单示例，实际中可能是更复杂的数值计算)
res = 0.0
for x in arr:
res += np.sqrt(np.abs(x))
return res / len(arr) if len(arr) > 0 else 0

使用 Numba 加速

@numba.jit(nopython=True) # nopython=True 要求函数完全在 Numba 可编译的子集内
def complex_calculation_numba(arr):
res = 0.0
# 注意：在 nopython 模式下，操作需要 Numba 支持
# 传递 NumPy 数组通常效果最好
n = len(arr)
if n == 0:
return 0.0
for i in range(n):
res += np.sqrt(np.abs(arr[i]))
return res / n

在 agg 中使用 (需要传递 NumPy 数组)

Numba 可能在首次调用时有编译开销

注意：直接将 numba 函数传递给 agg 可能需要 Pandas 版本支持，

或者通过 apply(lambda x: complex_calculation_numba(x.to_numpy()))

但 apply 本身有开销，最佳方式是确保你的操作可以通过 agg/transform 内置或高效传递

try:
# 尝试直接传递（较新 Pandas 版本可能支持得更好）
numba_agg_result = df.groupby(‘Category’)[‘Value1’].agg(complex_calculation_numba)
print(“\nNumba Aggregation Result (Direct):”)
print(numba_agg_result)
except Exception as e:
print(f”\nDirect Numba agg failed: {e}. Trying via apply…”)
# 回退到 apply (注意 apply 的性能影响)
numba_apply_result = df.groupby(‘Category’)[‘Value1’].apply(lambda x: complex_calculation_numba(x.to_numpy()))
print(“\nNumba Aggregation Result (via Apply):”)
print(numba_apply_result)

``
**注意**：将 Numba/Cython 函数与 PandasGroupBy集成可能需要一些技巧，例如确保传递的是 Numba/Cython 能高效处理的数据类型（通常是 NumPy 数组）。对于agg，如果自定义函数期望 NumPy 数组，可能需要通过lambda x: func(x.to_numpy())传递，但这会引入apply类似的开销。最佳情况是 Numba/Cython 能直接优化整个GroupBy` 操作的一部分，但这通常需要更底层的库支持或特定的使用模式。不过，加速函数本身总是有益的。

8. 考虑数据分块处理 (Dask, Vaex)

如果你的数据集非常大，以至于单机内存无法容纳，或者 GroupBy 操作极其耗时，那么标准的 Pandas 可能不是最佳工具。这时可以考虑使用：

  • Dask: 一个并行计算库，它提供了类似 Pandas DataFrame 的 API（Dask DataFrame），但可以在多个核心甚至多台机器上并行处理数据。Dask DataFrame 将大型数据集分割成多个小的 Pandas DataFrame（分区），然后并行地在这些分区上执行 GroupBy 等操作。
  • Vaex: 另一个用于处理大型表格数据集的库，它采用内存映射和延迟计算（lazy evaluation）策略，可以在不将所有数据加载到内存的情况下执行 GroupBy 等操作，特别擅长处理非常宽（列多）或非常长（行多）的数据。

这些库是 Pandas 的有力补充，适用于超出 Pandas 处理能力的场景。

三、GroupBy 高级用法

除了基础的聚合，GroupBy 还提供了许多强大的高级功能。

1. 多键分组

你可以传入一个列名列表或 Series 列表来进行多级分组。

“`python

按 ‘Category’ 和 ‘Timestamp’ 的年份分组

grouped_multi = df.groupby([‘Category’, df[‘Timestamp’].dt.year])
result_multi = grouped_multi[‘Value1’].mean()
print(“\nMulti-key Grouping Result:”)
print(result_multi) # 结果会是一个 MultiIndex Series
“`

2. 按函数或 Series 分组

分组键不一定是列名，可以是任何长度与 DataFrame 行数相同的数组、Series，或者是作用于索引的函数。

“`python

按 Value2 的奇偶性分组

def parity(x):
return ‘Even’ if x % 2 == 0 else ‘Odd’

grouped_by_func_on_col = df.groupby(df[‘Value2’].apply(parity))
result_func_col = grouped_by_func_on_col[‘Value1’].count()
print(“\nGrouping by Function on Column (‘Value2’ parity):”)
print(result_func_col)

按索引的某个属性分组 (假设索引有意义，这里用默认 RangeIndex 举例)

假设我们想按索引模 3 分组

grouped_by_index_func = df.groupby(lambda idx: idx % 3)
result_index_func = grouped_by_index_func[‘Value2’].sum()
print(“\nGrouping by Function on Index (index % 3):”)
print(result_index_func)

按外部 Series 分组

external_key = pd.Series([‘GroupX’, ‘GroupY’] * (len(df) // 2) + [‘GroupX’] * (len(df) % 2), index=df.index)
grouped_by_series = df.groupby(external_key)
result_series_group = grouped_by_series[‘Value1’].median()
print(“\nGrouping by External Series:”)
print(result_series_group)
“`

3. 按索引级别分组 (MultiIndex)

如果你的 DataFrame 有 MultiIndex（多级索引），你可以通过 level 参数指定按哪个索引级别进行分组。

“`python

创建一个 MultiIndex DataFrame

arrays = [list(‘AAABBBCCC’), [1, 2, 3, 1, 2, 3, 1, 2, 3]]
index = pd.MultiIndex.from_arrays(arrays, names=(‘Outer’, ‘Inner’))
multi_df = pd.DataFrame({‘Data’: np.random.randn(9)}, index=index)
print(“\nMultiIndex DataFrame:”)
print(multi_df)

按外层索引 (‘Outer’) 分组

grouped_level0 = multi_df.groupby(level=’Outer’)
result_level0 = grouped_level0[‘Data’].sum()
print(“\nGrouping by Index Level ‘Outer’:”)
print(result_level0)

按内层索引 (‘Inner’) 分组

grouped_level1 = multi_df.groupby(level=’Inner’)
result_level1 = grouped_level1[‘Data’].mean()
print(“\nGrouping by Index Level ‘Inner’:”)
print(result_level1)
“`

4. 自定义聚合函数与 agg 的高级应用

agg 方法非常灵活：

  • 传递函数列表: 对同一列应用多个聚合函数。
    python
    agg_list = df.groupby('Category')['Value1'].agg(['sum', 'mean', 'std'])
    print("\nAgg with list of functions:")
    print(agg_list)
  • 传递字典: 对不同的列应用不同的聚合函数，或对同一列应用多个函数并重命名。
    python
    agg_dict = df.groupby('Category').agg(
    Total_Value1=('Value1', 'sum'),
    Average_Value1=('Value1', 'mean'),
    Max_Value2=('Value2', 'max'),
    Value1_Range=('Value1', lambda x: x.max() - x.min()) # 使用 lambda 自定义
    )
    print("\nAgg with dictionary for renaming and custom functions:")
    print(agg_dict)

  • 传递自定义函数: 可以传递你自己定义的函数。
    “`python
    def q75(x):
    return x.quantile(0.75)

    agg_custom_func = df.groupby(‘Category’)[‘Value1’].agg([‘mean’, q75])
    print(“\nAgg with custom function (q75):”)
    print(agg_custom_func)
    “`

5. 使用 transform 进行组内特征工程

transform 非常适合创建基于组统计量的新特征，因为它返回的结果与原始 DataFrame 具有相同的索引，可以直接赋值回新列。

“`python

计算每个 Category 内 Value1 的 Z-score

Z = (x – group_mean) / group_std

mean_val1 = df.groupby(‘Category’)[‘Value1’].transform(‘mean’)
std_val1 = df.groupby(‘Category’)[‘Value1’].transform(‘std’)

防止除以零 (如果组内只有一个元素，标准差为 NaN 或 0)

std_val1 = std_val1.replace(0, np.nan) # 或者用 fillna(1) 如果你想避免 NaN

df[‘Value1_ZScore’] = (df[‘Value1’] – mean_val1) / std_val1
print(“\nDataFrame with Group Z-Score (Transform):”)
print(df[[‘Category’, ‘Value1’, ‘Value1_ZScore’]])

组内排名

df[‘Value2_GroupRank’] = df.groupby(‘Category’)[‘Value2′].transform(lambda x: x.rank(method=’dense’, ascending=False))
print(“\nDataFrame with Group Rank (Transform):”)
print(df[[‘Category’, ‘Value2’, ‘Value2_GroupRank’]].sort_values([‘Category’, ‘Value2_GroupRank’]))
“`

6. 使用 filter 筛选组

filter 方法允许你根据对每个组计算得到的布尔值来保留或丢弃整个组。

“`python

只保留那些至少有 3 个成员的 Category 组

filtered_groups = df.groupby(‘Category’).filter(lambda x: len(x) >= 3)
print(“\nFiltering groups (keep groups with size >= 3):”)
print(filtered_groups)

只保留那些 Value1 平均值大于 0 的 Category 组

filtered_groups_mean = df.groupby(‘Category’).filter(lambda x: x[‘Value1’].mean() > 0)
print(“\nFiltering groups (keep groups with Value1 mean > 0):”)
print(filtered_groups_mean)
``filter` 返回的是原始 DataFrame 的一个子集，保留了通过条件的那些组的所有行。

7. 迭代 GroupBy 对象

虽然通常为了性能应避免迭代，但在某些需要对每个组执行复杂、无法向量化的操作（如图表绘制、模型训练等）的情况下，迭代 GroupBy 对象是必要的。

“`python
grouped_obj = df.groupby(‘Category’)

print(“\nIterating over groups:”)
for name, group_df in grouped_obj:
print(f”\nProcessing Group: {name}”)
print(f”Number of rows: {len(group_df)}”)
print(f”Value1 Mean: {group_df[‘Value1′].mean()}”)
# 这里可以进行更复杂的操作，比如为每个组绘制图表
# import matplotlib.pyplot as plt
# group_df.plot(x=’Timestamp’, y=’Value1′, title=f’Category {name}’)
# plt.show()
``
**性能警告**：迭代通常比向量化的agg,transform,filter` 慢得多，应仅在必要时使用。

8. pipe 方法与 GroupBy 结合

pipe 方法允许将 DataFrame 或 GroupBy 对象传递给一个函数，实现链式调用，提高代码可读性。这对于封装复杂的 GroupBy 相关操作特别有用。

“`python
def calculate_group_stats(grp, value_col=’Value1′, stats=[‘mean’, ‘std’]):
“””计算分组后的统计量”””
return grp[value_col].agg(stats)

def add_normalized_column(grp_df, value_col=’Value1′, new_col_name=’Normalized_Value’):
“””在分组对象上应用 transform 添加归一化列”””
mean = grp_df[value_col].transform(‘mean’)
std = grp_df[value_col].transform(‘std’).replace(0, 1) # 避免除零
# pipe 作用于 GroupBy 对象时，需要返回 GroupBy 对象或最终结果
# 这里我们直接计算 Series 并返回，pipe 会自动处理
# 注意：pipe 通常作用于 DataFrame/Series，作用于 GroupBy 对象相对少见
# 但可以将 GroupBy 后的操作封装
# 更常见的用法是 pipe 作用于 DataFrame
pass # pipe 在 GroupBy 上用法特殊，通常 pipe 用于链式调用 DataFrame 方法

pipe 更常用于 DataFrame 链式调用，封装 GroupBy 步骤

def process_data(df_in):
return (df_in
.assign(Year=df_in[‘Timestamp’].dt.year) # 添加年份列
.groupby([‘Category’, ‘Year’]) # 分组
.agg(Mean_Value1=(‘Value1’, ‘mean’), # 聚合
Count=(‘Value1’, ‘size’))
.reset_index() # 重置索引
)

processed_df = df.pipe(process_data)
print(“\nUsing pipe for chained operations including GroupBy:”)
print(processed_df)

也可以将 pipe 用于 GroupBy 对象，传递接受 GroupBy 对象的函数

def custom_groupby_analysis(gb_obj, col=’Value1′):
“””一个接收 GroupBy 对象的函数示例”””
result = gb_obj[col].agg([‘mean’, ‘median’])
# 可以做更多处理…
return result

analysis_result = df.groupby(‘Category’).pipe(custom_groupby_analysis, col=’Value2′)
print(“\nUsing pipe with GroupBy object:”)
print(analysis_result)
“`

9. 处理分组键中的 NaN 值

默认情况下，groupby 会忽略分组键中的 NaN 值。可以通过设置 dropna=False 来将 NaN 视为一个独立的组。

“`python

添加一个包含 NaN 的行

df_with_nan = pd.concat([df, pd.DataFrame({‘Category’: [np.nan], ‘Value1’: [0], ‘Value2’: [0], ‘Timestamp’: [pd.NaT]})], ignore_index=True)

默认忽略 NaN 键

print(“\nGroupBy with NaN key (default, dropna=True):”)
print(df_with_nan.groupby(‘Category’)[‘Value1’].count())

将 NaN 视为一个组

print(“\nGroupBy with NaN key (dropna=False):”)
print(df_with_nan.groupby(‘Category’, dropna=False)[‘Value1’].count())
“`

10. GroupBy 与时间序列 (Resampling)

GroupBy 常与时间序列的 resample 方法结合使用，实现按类别分组后再按时间窗口聚合。

“`python

确保 Timestamp 是索引

df_ts = df.set_index(‘Timestamp’)

按 Category 分组，然后按 2 天重采样，计算 Value1 的平均值

resampled_grouped = df_ts.groupby(‘Category’).resample(‘2D’)[‘Value1’].mean()
print(“\nGroupBy + Resample:”)
print(resampled_grouped)

注意：结果索引是 MultiIndex (Category, Timestamp)

“`

四、总结与最佳实践

Pandas GroupBy 是一个极其强大的工具，但也需要明智地使用以获得最佳性能和效果。

性能优化关键点:

  1. 优先内置函数: 利用 Cython 优化的内置聚合函数 (sum, mean, std 等)。
  2. 明智选择 agg, transform, apply: 理解它们的区别和性能影响，优先 agg 和 transform。
  3. 使用 Categorical: 对低基数分组键使用 Categorical 类型。
  4. 预过滤: 在 GroupBy 前尽可能缩小数据范围。
  5. as_index=False: 可能略微提升性能并简化输出。
  6. Numba/Cython: 加速计算密集的自定义 Python 函数。
  7. 考虑 Dask/Vaex: 处理超出单机内存或计算能力的大型数据集。

高级用法要点:

  1. 灵活分组: 使用多键、函数、数组、索引级别进行分组。
  2. 强大 agg: 利用字典实现多列、多函数、自定义聚合和重命名。
  3. transform 特征工程: 创建与原始数据对齐的组内计算特征。
  4. filter 组筛选: 基于组属性保留或丢弃整个组。
  5. 迭代与 pipe: 处理复杂组逻辑或改善代码流。
  6. NaN 控制: 通过 dropna 参数决定如何处理 NaN 键。
  7. 时间序列整合: 结合 resample 进行分组时间聚合。

最佳实践:

  • 理解数据: 了解你的数据分布、基数和大小，这有助于选择合适的优化策略。
  • 代码清晰: 优先编写可读性好的代码。只有在性能成为瓶颈时，才进行深度优化。
  • 测试与验证: 对应用了 GroupBy 操作的结果进行检查，确保逻辑正确。
  • 性能分析: 使用 %timeit 或 cProfile 等工具来识别 GroupBy 操作中的性能瓶颈。
  • 持续学习: Pandas 库不断发展，关注新版本带来的性能改进和新特性。

掌握 Pandas GroupBy 的性能优化技巧和高级用法，将使你能够更从容地应对日益增长的数据规模和复杂的数据分析任务，是成为一名高效数据分析师或科学家的重要一步。不断实践和探索这些技术，将它们内化为你的数据处理武器库的一部分。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部