在Python中，数据处理的高效技巧可以显著提升代码性能和开发效率。以下是经过实战验证的最佳数据处理技巧，涵盖从基础到高级的多种场景：

一、核心数据结构技巧

1.字典的妙用

• 快速去重计数：

from collections import defaultdict
data = ['apple', 'banana', 'apple']
counter = defaultdict(int)
for item in data:
    counter[item] += 1  # 比手动循环快2倍

字典推导式：

names = ['Alice', 'Bob']
name_dict = {name: len(name) for name in names}  # {'Alice': 5, 'Bob': 3}

2.集合的高效操作

a = {1, 2, 3}
b = {3, 4, 5}
print(a - b)  # 差集: {1, 2}
print(a & b)  # 交集: {3}
print(a | b)  # 并集: {1, 2, 3, 4, 5}

二、Pandas高效技巧

3.向量化操作（比循环快100倍）

import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df['C'] = df['A'] * df['B']  # 避免apply循环

4.避免逐行处理

# 错误做法（慢）：
df['new'] = df['A'].apply(lambda x: x*2 if x>1 else None)

# 正确做法（快10倍）：
df['new'] = np.where(df['A'] > 1, df['A']*2, None)

5.分块处理大文件

chunk_size = 10_000
for chunk in pd.read_csv('10GB.csv', chunksize=chunk_size):
    process(chunk)  # 内存友好

三、NumPy黑科技

6.广播机制

import numpy as np
arr = np.array([[1], [2], [3]])  # 3x1
result = arr * np.array([10, 20])  # 自动广播为3x2

7.布尔索引

arr = np.random.randint(0, 100, 1000)
filtered = arr[(arr > 50) & (arr < 80)]  # 比循环快100倍

8.原地操作节省内存

arr = np.ones(1_000_000)
arr *= 2  # 不创建新数组

四、高效IO技巧

9.Pickle协议5（Python 3.8+）

import pickle
# 序列化大对象（比JSON快3倍）
with open('data.pkl', 'wb') as f:
    pickle.dump(obj, f, protocol=5)

10.Parquet格式（列式存储）

df.to_parquet('data.parquet') # 比CSV小10倍，读取快5倍 
pd.read_parquet('data.parquet')

五、并发处理

11.多进程处理CPU密集型任务

from multiprocessing import Pool
def process_data(x):
    return x * 2

with Pool(4) as p:  # 4核并行
    results = p.map(process_data, range(1000))

12.Dask处理超大数据

import dask.dataframe as dd
ddf = dd.read_csv('100GB_*.csv')  # 分布式处理
result = ddf.groupby('column').mean().compute()

六、内存优化技巧

13.内存视图（memoryview）

data = bytearray(b'123456789')
view = memoryview(data)
slice = view[2:5]  # 不复制数据

14.类型指定节省内存

arr = np.array([1, 2, 3], dtype=np.int8)  # 比默认int64小8倍

七、实用工具库

性能对比示例

# 传统循环 (慢)
result = []
for x in range(1_000_000):
    result.append(x * 2)

# 列表推导式 (快2倍)
result = [x * 2 for x in range(1_000_000)]

# NumPy向量化 (快100倍)
result = np.arange(1_000_000) * 2

黄金法则

1. 避免循环：优先用向量化操作
2. 选择合适的数据结构：字典 > 列表查找
3. 批处理优于单条处理：减少IO次数
4. 类型一致性：避免隐式类型转换
5. 惰性计算：用生成器处理流式数据

掌握这些技巧后，你的Python数据处理速度可提升10~100倍，特别是在处理GB级以上数据时效果显著。