1、使用适当的数据类型

优化数据类型可以减少内存使用。对于数值数据，可以选择使用内存占用更小的数值类型，如int8或float32，而非默认的int64或float64。同样，对于值重复率高的字符串列，将其转换为category类型可以显著降低内存使用。日期和时间数据最好使用专门的datetime类型。

import pandas as pd

# 示例DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': ['C', 'JAVA', 'Python'],
    'C': pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-03'])
})

# 优化数据类型
df['A'] = df['A'].astype('int8')  # 更小的整数类型
df['B'] = df['B'].astype('category')  # 分类类型
print(df)

2、避免循环

尽量使用 Pandas 的内置向量化操作而非循环。向量化操作通常更高效。Pandas 提供了大量的向量化操作，可以提高数据操作的效率。如 sum()、mean()、max() 等函数可以直接作用于整个 DataFrame 或 Series，而不需要使用循环。可以显著提高数据处理的速度和效率，特别是在处理大型数据集时。它们利用了 Pandas 和 NumPy 库的内部优化，使得操作更加高效，避免了相对开销较大的 Python 循环。

import pandas as pd
import numpy as np

# 创建示例 DataFrame
df = pd.DataFrame({
    'column1': [1, 2, -3, 4, -5],
    'column2': [5, 6, 7, -8, -9]
})

# 向量化操作
df['sum'] = df['column1'] + df['column2']

# 使用 apply() 方法
df['transformed_column1'] = df.apply(lambda x: x['column1'] * 2 if x['column2'] > 0 else x['column1'], axis=1)

# 使用 map() 和 applymap()
df['mapped_column1'] = df['column1'].map(lambda x: x * 2)
df = df.applymap(lambda x: x * 2 if isinstance(x, int) else x)

# 使用 groupby() 进行分组操作
grouped_sum = df.groupby('mapped_column1').sum()

# 使用 Pandas 的内置函数
total_column1 = df['column1'].sum()

# 使用条件表达式
df['new_column'] = np.where(df['column2'] > 0, 'positive', 'non-positive')

# 显示结果
print("DataFrame with Applied Operations:\n", df)
print("\nGrouped Sum:\n", grouped_sum)
print("\nTotal of 'column1':", total_column1)

3、有效使用索引

为 DataFrame 设置适当的索引可以提高数据检索的效率。高效地使用索引也是提升数据操作性能的关键之一。为了优化数据操作，首先应选择合适的索引。常见做法包括将频繁查询的列设置为索引，利用 set_index 方法，以及在复杂数据集上使用多级索引。访问数据时，应通过 loc 和 iloc 索引器高效地访问数据，特别是在使用索引列进行条件查询时，这比全表扫描更有效。同时，需要注意索引的内存消耗，过多索引会增加内存负担，因此在内存有限的情况下要平衡索引数量和性能提升。去除不再需要的索引可以使用 reset_index 方法。在索引操作上，应避免在循环中频繁修改 DataFrame 索引，这是一种低效的操作。

import pandas as pd
import numpy as np

# 构建一个示例股票数据集
np.random.seed(0)
dates = pd.date_range('20240101', periods=6)
stocks = ['AAPL', 'MSFT', 'GOOG']
data = pd.DataFrame(np.random.randn(6, 3), index=dates, columns=stocks)

# 将日期和股票代码作为多级索引
data = data.stack().reset_index()
data.columns = ['日期', '股票代码', '价格']
data.set_index(['日期', '股票代码'], inplace=True)

# 按索引排序
data.sort_index(inplace=True)

# 查询特定日期的所有股票数据
data_on_specific_date = data.loc['2024-01-01']

# 查询特定股票代码的数据
data_for_specific_stock = data.xs('AAPL', level='股票代码')

# 显示查询结果
print(data_on_specific_date, data_for_specific_stock)

4、使用内置函数

Pandas 库中，使用内置函数进行数据操作是提高效率和性能的关键之一。Pandas 提供了大量内置函数，这些函数经过优化，通常比手动编写的循环或自定义函数要高效得多。

5、避免链式赋值

链式赋值指的是在一个单独的表达式中连续对 DataFrame 进行多个操作。虽然这种写法看起来简洁，但可能会导致意外的行为和效率问题。链式赋值可能导致对 DataFrame 的修改无法确定是在原始数据上还是副本上进行，有时甚至可能导致警告或错误。此外，连续操作可能会导致不必要的数据复制，从而降低效率，并且过长的链式命令可能难以阅读和维护。为了避免这些问题，可以将操作分解为多个步骤，并对每个步骤显式地进行赋值。在对 DataFrame 的子集进行赋值时，使用 loc 或 iloc 进行索引。

import pandas as pd
import numpy as np

# 创建一个示例 DataFrame
np.random.seed(0)
df = pd.DataFrame(np.random.randn(10, 2), columns=['A', 'B'])

# 如我们需要修改列 B 的值，但只在列 A 的值大于 0 的情况下
# 不推荐的链式赋值
# df[df['A'] > 0]['B'] = 1  # 这样做可能导致 SettingWithCopyWarning

# 推荐的做法
df.loc[df['A'] > 0, 'B'] = 1

# 显示修改后的 DataFrame
print(df)

6、减少不必要的数据复制

数据复制不仅消耗内存，还可能导致代码运行缓慢，并增加出错的风险。减少不必要的数据复制是提高效率和性能的关键。在可能的情况下，为了提高效率，应优先考虑就地操作，如使用 inplace=True 参数，可以直接在原始 DataFrame 上修改数据而不创建副本。理解 Pandas 中视图和副本的区别也很重要，尽量操作视图以避免不必要的复制。如果确实需要副本，应使用 .copy() 方法来创建一个明确的副本，这有助于避免对原始数据的意外修改。

import pandas as pd
import numpy as np

# 创建一个示例 DataFrame
np.random.seed(0)
df = pd.DataFrame(np.random.randn(10, 2), columns=['A', 'B'])
df_copy = df.copy()  # 创建 df 的副本
print(df_copy)

# 准备一个新值数组，用于更新 DataFrame
new_values = np.random.rand(10)

# 错误的做法：创建不必要的副本（已注释）
# df_filtered = df[df['A'] > 0]
# df_filtered['B'] = new_values


# 正确的做法：避免不必要的副本
df.loc[df['A'] > 0, 'B'] = new_values[df['A'] > 0]

# 显示修改后的 DataFrame
print(df)

7、谨慎使用 apply 和 map

尽管 apply 和 map 很强大，但它们不总是最高效的选择。尽可能使用向量化方法。需要谨慎，以确保代码的效率和性能。虽然这些函数提供了很大的灵活性，但不当使用可能会导致性能问题。apply 函数虽然提供了处理每一行或列的强大灵活性，但在内部进行循环处理，可能会比 Pandas 的内置向量化函数运行得慢。对于 map 函数，它通常用于 Series 数据，将指定函数应用于每个元素，但在可能的情况下，应考虑使用 replace 或其他向量化方法，这些方法通常更为高效。如果需要对 DataFrame 的每个元素进行操作，可以使用 applymap。

import pandas as pd
import numpy as np

# 创建一个示例 DataFrame
df = pd.DataFrame({'column': np.random.randint(1, 10, size=5)})

# 定义一个复杂的计算函数
def complex_calculation(x):
    return x * x - x + 2

# 使用 apply 应用函数
df['apply_result'] = df['column'].apply(complex_calculation)

# 使用向量化操作
df['vectorized_result'] = df['column'] * df['column'] - df['column'] + 2

# 显示 DataFrame 结果
print(df)

8、分块处理大型数据集

对于大型数据集，考虑分块处理而不是一次性加载整个数据集。由于内存限制，直接加载整个数据集可能不可行或效率低下。这种情况下，分块处理大型数据集是一种有效的解决方案。可以通过分块读取并逐块计算某列的总和，最后将所有块的结果累加。这种分块处理方法使处理大型数据集变得可行，特别是在有限的内存资源下，能有效提高数据处理的效率和可行性。

import pandas as pd
import numpy as np

total_sum = 0
chunksize = 10  # 假设每块包含 10000 行

# 设置随机数据的参数
num_rows = 1000  # 数据行数
column_name = 'target_column'  # 列名

# 创建包含随机数据的 DataFrame
# 数据是随机的浮点数，可以根据需要调整数据类型和生成逻辑
df = pd.DataFrame({column_name: np.random.rand(num_rows)})

# 写入 CSV 文件
csv_file = 'large_dataset.csv'
df.to_csv(csv_file, index=False)


# 分块读取
for chunk in pd.read_csv('large_dataset.csv', chunksize=chunksize):
    total_sum += chunk['target_column'].sum()

print(total_sum)

9、使用并行处理

对于大型操作，考虑使用并行处理来加速。使用并行处理是一个有效的优化技巧。尽管 Pandas 本身不是为并行处理而设计的，但可以通过一些方法来利用多核处理器的能力，从而加速数据处理任务。Dask 提供了一个与 Pandas 类似的大型并行 DataFrame，适用于处理大数据集；Joblib 可以高效运行多个 Python 进程，适合简单的并行化任务；而 Python 的 multiprocessing 模块允许手动创建并行任务，通过将大型 DataFrame 分割成多个小块，在每个处理器核心上并行处理这些块。

import pandas as pd
import numpy as np
from multiprocessing import Pool

# 示例函数，对数据进行某种复杂计算
def my_complex_function(data_chunk):
    return data_chunk.apply(np.sin)

# 创建一个大型 DataFrame
df = pd.DataFrame(np.random.rand(1000000, 4), columns=['A', 'B', 'C', 'D'])

# 将 DataFrame 分割成多个小块
data_chunks = np.array_split(df, 4)

# 创建一个进程池并并行处理每个数据块
with Pool(4) as pool:
    results = pool.map(my_complex_function, data_chunks)

# 合并结果
final_result = pd.concat(results)
print(final_result)

10、优化内存使用

优化内存使用是提高效率和性能的一个重要方面。尤其在处理大型数据集时，有效管理内存是至关重要的。通过 df.memory_usage(deep=True) 可以检查 DataFrame 的每列占用的内存量。

import pandas as pd
import numpy as np

# 创建一个示例 DataFrame
np.random.seed(0)
data = {
    'float_col': np.random.rand(10000),
    'int_col': np.random.randint(0, 100, size=10000),
    'category_col': np.random.choice(['A', 'B', 'C', 'D'], size=10000)
}
df = pd.DataFrame(data)

# 检查每列的内存使用情况
memory_usage_before = df.memory_usage(deep=True)

# 节省内存的数据类型转换
df['float_col'] = df['float_col'].astype('float32')
df['int_col'] = df['int_col'].astype('int16')

# 类别数据类型转换
df['category_col'] = df['category_col'].astype('category')

# 检查优化后的内存使用
memory_usage_after = df.memory_usage(deep=True)

# 输出内存使用情况
print(memory_usage_before, memory_usage_after)

11、避免使用全局变量

避免使用全局变量是一个重要的最佳实践。全局变量在大型项目中可能导致代码难以维护、理解和调试。特别是在大型项目中。为了提高代码的清晰度和可维护性，可以使用函数参数来传递 DataFrame 或其他必要数据，而不是在函数内部直接引用全局变量。在处理数据时，函数应该返回修改后的 DataFrame，而不是直接在全局变量上进行就地修改。另外，可以考虑使用面向对象的方法，通过类封装数据和相关操作，这样可以更好地组织代码，并限制全局变量的作用域。

import pandas as pd

# 示例数据
data = {
    'A': [1, 2, 3, None, 5],
    'B': [5, None, 2, 4, 3]
}

# 创建 DataFrame
df = pd.DataFrame(data)

# 不推荐的做法：使用全局变量
def clean_data_global():
    global df
    df.dropna(inplace=True)

# 推荐的做法：使用函数参数和返回值
def clean_data(dataframe):
    return dataframe.dropna()

# 使用不推荐的方法处理数据
clean_data_global()

# 输出结果
print("使用不推荐的方法：")
print(df)

# 恢复原始数据
df = pd.DataFrame(data)

# 使用推荐的方法处理数据
df_cleaned = clean_data(df)

# 输出结果
print("\n使用推荐的方法：")
print(df_cleaned)