发布于 由admin

Python的`Pandas`性能优化：如何通过`矢量化`、`数据类型`优化和`NumPy`操作提升Pandas性能。

Pandas 性能优化：矢量化、数据类型与 NumPy 操作

大家好，今天我们来深入探讨 Pandas 性能优化的一些关键技巧。 Pandas 作为一个强大的数据分析库，在数据处理领域应用广泛。然而，当处理大型数据集时，其性能瓶颈也会逐渐显现。本文将围绕三个核心主题：矢量化、数据类型优化以及利用 NumPy 操作，来帮助大家显著提升 Pandas 代码的执行效率。

1. 矢量化：告别循环，拥抱并行

1.1 为什么矢量化如此重要？

Pandas 的底层是基于 NumPy 构建的，NumPy 核心优势之一就是对数组操作的矢量化支持。 矢量化操作指的是一次性对整个数组或 Series 进行操作，而不是像传统循环那样逐个元素处理。 这种方式能够充分利用底层硬件的并行计算能力，极大地提升运算速度。

传统的 Python 循环效率低下，原因在于 Python 解释器需要在每次循环迭代中执行大量的额外操作，例如类型检查、函数调用等。 而矢量化操作则将这些操作委托给 NumPy 或 Pandas 的底层 C 代码来执行，避免了 Python 解释器的性能损耗。

1.2 案例分析：计算平均值

假设我们有一个包含 100 万个随机数的 Pandas Series，我们需要计算每个元素的平均值（假设每个元素都代表一个数组的长度，平均值就是这个长度的平均值）。 我们先用循环的方式实现：

import pandas as pd
import numpy as np
import time

# 创建一个包含 100 万个随机数的 Series
data = pd.Series(np.random.rand(1000000))

# 循环方式计算平均值
def calculate_average_loop(series):
    result = pd.Series(index=series.index, dtype='float64')
    for i in series.index:
        result[i] = np.mean(np.random.rand(int(series[i] * 100))) # 假设series[i]是0-1之间的小数，表示数组的长度比例
    return result

start_time = time.time()
result_loop = calculate_average_loop(data)
end_time = time.time()
print(f"循环方式耗时: {end_time - start_time:.4f} 秒")

现在，我们使用矢量化操作来实现相同的功能：

# 矢量化方式计算平均值
def calculate_average_vectorized(series):
    # 使用 apply 函数结合 lambda 表达式，实现矢量化操作
    result = series.apply(lambda x: np.mean(np.random.rand(int(x * 100))))
    return result

start_time = time.time()
result_vectorized = calculate_average_vectorized(data)
end_time = time.time()
print(f"矢量化方式耗时: {end_time - start_time:.4f} 秒")

通常情况下，矢量化操作的效率会比循环方式快几个数量级。 尽管 apply 本身也是一种迭代，但它将计算任务委托给了 NumPy 的 mean 函数，从而实现了矢量化。

1.3 避免使用 .iterrows() 和 .itertuples()

iterrows() 和 itertuples() 是 Pandas 中用于迭代 DataFrame 的方法，但它们通常效率很低，应该尽量避免使用。 它们实际上是 Python 循环的变种，无法充分利用矢量化操作的优势。

如果需要对 DataFrame 的每一行进行操作，可以考虑以下替代方案：

  • 使用 apply() 函数： 如上述例子所示，apply() 函数可以对 DataFrame 的行或列进行操作，并且可以结合 lambda 表达式或自定义函数来实现复杂的功能。

  • 使用 NumPy 操作： 如果操作可以转换为 NumPy 数组操作，则可以直接将 DataFrame 转换为 NumPy 数组，然后进行操作。

  • 使用 Pandas 内置函数： Pandas 提供了许多内置函数，例如 sum()、mean()、max() 等，可以直接对 DataFrame 或 Series 进行操作。

1.4 向量化的条件判断与赋值

对于条件判断和赋值操作，矢量化同样可以带来显著的性能提升。 避免使用循环来逐个元素进行判断和赋值，而是使用 Pandas 的布尔索引或 np.where() 函数。

例如，假设我们需要将 DataFrame 中所有大于 0.5 的元素设置为 1，否则设置为 0。 使用循环的方式如下：

df = pd.DataFrame(np.random.rand(1000, 5))

def modify_dataframe_loop(df):
    for i in range(len(df)):
        for j in range(len(df.columns)):
            if df.iloc[i, j] > 0.5:
                df.iloc[i, j] = 1
            else:
                df.iloc[i, j] = 0
    return df

start_time = time.time()
modified_df_loop = modify_dataframe_loop(df.copy()) # 使用copy()防止修改原始数据
end_time = time.time()
print(f"循环方式耗时: {end_time - start_time:.4f} 秒")

使用矢量化方式：

def modify_dataframe_vectorized(df):
    df[df > 0.5] = 1
    df[df <= 0.5] = 0
    return df

start_time = time.time()
modified_df_vectorized = modify_dataframe_vectorized(df.copy())
end_time = time.time()
print(f"矢量化方式耗时: {end_time - start_time:.4f} 秒")

# 或者使用 np.where
def modify_dataframe_npwhere(df):
    df = pd.DataFrame(np.where(df > 0.5, 1, 0), index=df.index, columns=df.columns)
    return df

start_time = time.time()
modified_df_npwhere = modify_dataframe_npwhere(df.copy())
end_time = time.time()
print(f"np.where 方式耗时: {end_time - start_time:.4f} 秒")

使用布尔索引或 np.where() 函数可以避免循环，实现高效的条件判断和赋值。

2. 数据类型优化：选择合适的存储方式

2.1 数据类型的重要性

Pandas 提供了多种数据类型，例如 int、float、object、category 等。 选择合适的数据类型可以有效地减少内存占用，并提升计算速度。 错误的数据类型选择会导致内存浪费和性能下降。

例如，如果一个列只包含整数，但数据类型被错误地设置为 object，则 Pandas 会将每个整数存储为 Python 对象，而不是使用更紧凑的整数类型。 这会显著增加内存占用，并降低计算速度。

2.2 常用数据类型优化技巧

  • 使用更小的整数类型： 如果一个列只包含较小的整数，例如 0 到 100，则可以使用 int8 或 int16 类型，而不是默认的 int64 类型。 可以使用 pd.to_numeric() 函数将列转换为更小的整数类型。
# 假设 data['age'] 的值在 0-100之间
data = pd.DataFrame({'age': np.random.randint(0, 100, size=1000)})

# 检查当前数据类型
print(data['age'].dtype)  # 输出：int64

# 转换为 int8 类型
data['age'] = pd.to_numeric(data['age'], downcast='integer')

# 再次检查数据类型
print(data['age'].dtype)  # 输出：int8
  • 使用 category 类型： 如果一个列包含有限数量的重复值（例如，性别、城市等），则可以使用 category 类型。 category 类型会将每个唯一值存储为整数，并将原始值存储在一个单独的查找表中。 这可以显著减少内存占用，并提升分组和排序等操作的速度。
# 假设 data['city'] 包含有限数量的城市名称
data = pd.DataFrame({'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Beijing', 'Shanghai'] * 200})

# 检查当前数据类型
print(data['city'].dtype)  # 输出：object

# 转换为 category 类型
data['city'] = data['city'].astype('category')

# 再次检查数据类型
print(data['city'].dtype)  # 输出：category
  • 避免使用 object 类型存储数值数据： object 类型通常用于存储字符串或其他混合类型的数据。 如果一个列包含数值数据，但数据类型被错误地设置为 object，则需要将其转换为合适的数值类型，例如 int 或 float。
# 假设 data['price'] 的数据类型为 object，但实际包含的是数值数据
data = pd.DataFrame({'price': ['10.5', '20.3', '30.1']})

# 检查当前数据类型
print(data['price'].dtype)  # 输出：object

# 转换为 float 类型
data['price'] = pd.to_numeric(data['price'])

# 再次检查数据类型
print(data['price'].dtype)  # 输出：float64
  • 合理选择 float 类型： 类似于整数，float也有 float16, float32, float64 之分。根据数据的精度需求选择合适的浮点数类型。 如果精度要求不高，使用 float32 可以减少内存占用。

2.3 使用 memory_usage() 函数检查内存占用

可以使用 memory_usage() 函数来检查 DataFrame 或 Series 的内存占用情况。 这可以帮助你识别哪些列占用了大量的内存，并进行相应的优化。

# 创建一个示例 DataFrame
data = pd.DataFrame({
    'int_col': np.random.randint(0, 1000, size=100000),
    'float_col': np.random.rand(100000),
    'category_col': ['A', 'B', 'C', 'A', 'B'] * 20000
})

# 检查 DataFrame 的内存占用情况
print(data.memory_usage(deep=True))

通过分析 memory_usage() 函数的输出，你可以了解每个列的内存占用情况，并采取相应的优化措施。

3. 利用 NumPy 操作：充分发挥底层优势

3.1 Pandas 与 NumPy 的关系

Pandas 的底层是基于 NumPy 构建的，这意味着 Pandas 可以直接利用 NumPy 的强大功能。 在某些情况下，使用 NumPy 操作可以比 Pandas 操作更有效率。

3.2 常用 NumPy 操作技巧

  • 将 DataFrame 转换为 NumPy 数组： 可以使用 values 属性将 DataFrame 转换为 NumPy 数组。 这可以让你直接使用 NumPy 的各种函数和操作，而无需通过 Pandas 的 API。
# 创建一个示例 DataFrame
df = pd.DataFrame(np.random.rand(1000, 5))

# 转换为 NumPy 数组
numpy_array = df.values

# 使用 NumPy 函数计算平均值
mean_values = np.mean(numpy_array, axis=0)

print(mean_values)
  • 使用 NumPy 的广播机制： NumPy 的广播机制允许对不同形状的数组进行操作。 这可以简化代码，并提高效率。
# 创建一个示例 DataFrame
df = pd.DataFrame(np.random.rand(1000, 5))

# 创建一个包含 5 个元素的 NumPy 数组
array = np.array([1, 2, 3, 4, 5])

# 使用广播机制将 DataFrame 的每一列乘以对应的数组元素
df = df * array

print(df.head())
  • 使用 NumPy 的矢量化函数： NumPy 提供了许多矢量化函数，可以直接对 NumPy 数组进行操作。 这些函数通常比 Pandas 的等效函数更有效率。
# 创建一个示例 DataFrame
df = pd.DataFrame(np.random.rand(1000, 5))

# 使用 NumPy 的矢量化函数计算每个元素的平方根
df = np.sqrt(df)

print(df.head())

3.3 案例分析：计算距离

假设我们有两个包含坐标的 DataFrame，我们需要计算它们之间的欧几里得距离。

df1 = pd.DataFrame(np.random.rand(1000, 2), columns=['x', 'y'])
df2 = pd.DataFrame(np.random.rand(1000, 2), columns=['x', 'y'])

# 循环方式计算距离
def calculate_distance_loop(df1, df2):
    distances = []
    for i in range(len(df1)):
        x1, y1 = df1.iloc[i]['x'], df1.iloc[i]['y']
        x2, y2 = df2.iloc[i]['x'], df2.iloc[i]['y']
        distance = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
        distances.append(distance)
    return pd.Series(distances)

start_time = time.time()
distances_loop = calculate_distance_loop(df1, df2)
end_time = time.time()
print(f"循环方式耗时: {end_time - start_time:.4f} 秒")

# 使用 NumPy 操作计算距离
def calculate_distance_numpy(df1, df2):
    x1 = df1['x'].values
    y1 = df1['y'].values
    x2 = df2['x'].values
    y2 = df2['y'].values
    distances = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
    return pd.Series(distances)

start_time = time.time()
distances_numpy = calculate_distance_numpy(df1, df2)
end_time = time.time()
print(f"NumPy 方式耗时: {end_time - start_time:.4f} 秒")

在这个例子中，将 DataFrame 转换为 NumPy 数组，并使用 NumPy 的矢量化操作可以显著提升计算速度。

4. 总结：优化策略回顾与应用

综上所述，Pandas 性能优化涉及多个方面。 矢量化操作是提升性能的关键，避免循环，尽可能使用 Pandas 内置函数和 NumPy 操作。 数据类型优化可以减少内存占用，并提升计算速度，根据实际情况选择合适的数据类型。 充分利用 NumPy 的强大功能，可以进一步提升 Pandas 代码的执行效率。 实践中，需要根据具体情况灵活运用这些技巧，才能达到最佳的优化效果。

发表回复

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