import pandas as pd

# 錯(cuò)誤示范1：直接讀取整個(gè)文件
df = pd.read_csv('large_file.csv')  # 內(nèi)存占用飆升至9.2GB，程序崩潰

# 錯(cuò)誤示范2：未指定數(shù)據(jù)類型
df = pd.read_csv('large_file.csv', dtype=object)  # 內(nèi)存占用翻倍

內(nèi)存占用(MB) ≈ 行數(shù) × 列數(shù) × 每個(gè)值的字節(jié)數(shù) / 10242

# 分塊讀取示例：每次處理10萬行
chunk_size = 100000
chunks = pd.read_csv('sales_data.csv', chunksize=chunk_size)

results = []
for chunk in chunks:
    # 對(duì)每個(gè)數(shù)據(jù)塊進(jìn)行處理
    chunk_processed = chunk[chunk['amount'] > 1000]
    results.append(chunk_processed)

# 合并結(jié)果（注意內(nèi)存控制）
final_df = pd.concat(results, ignore_index=True)

with pd.HDFStore('output.h5', mode='w') as store:
    for i, chunk in enumerate(pd.read_csv('big_data.csv', chunksize=50000)):
        # 數(shù)據(jù)清洗邏輯
        cleaned = chunk.dropna(subset=['price'])
        store.append(f'chunk_{i}', cleaned, index=False)

import pandas as pd
from collections import defaultdict

user_stats = defaultdict(lambda: {'count':0, 'duration':0})

for chunk in pd.read_csv('access_logs.csv', chunksize=100000):
    for _, row in chunk.iterrows():
        user = row['user_id']
        user_stats[user]['count'] += 1
        user_stats[user]['duration'] += row['duration']

# 轉(zhuǎn)換為DataFrame
result_df = pd.DataFrame.from_dict(user_stats, orient='index')

# 原始讀?。ㄗ詣?dòng)推斷類型，可能不最優(yōu)）
df = pd.read_csv('data.csv')  # 內(nèi)存占用：1.2GB

# 優(yōu)化后讀取（指定精確類型）
dtypes = {
    'id': 'int32',
    'price': 'float32',
    'category': 'category',  # 分類數(shù)據(jù)專用類型
    'date': 'datetime64[ns]'
}
df_optimized = pd.read_csv('data.csv', dtype=dtypes)  # 內(nèi)存占用：480MB

# 原始字符串列（占用大）
df['product_type'] = ['A','B','A','C'...]  # 每個(gè)值重復(fù)存儲(chǔ)

# 轉(zhuǎn)換為分類類型（節(jié)省內(nèi)存）
df['product_type'] = df['product_type'].astype('category')

# 進(jìn)一步優(yōu)化：使用數(shù)值編碼
df['product_code'] = df['product_type'].cat.codes

# 原始缺失值（NaN占用空間）
df = pd.DataFrame({'A': [1, None, 3], 'B': [None, 'x', None]})

# 優(yōu)化方案1：用特定值填充（適合數(shù)值列）
df['A'].fillna(0, inplace=True)

# 優(yōu)化方案2：用更緊湊的類型存儲(chǔ)（適合字符串列）
df['B'] = df['B'].astype('category')

# 優(yōu)化方案3：直接刪除（當(dāng)缺失比例高時(shí)）
df.dropna(subset=['important_column'], inplace=True)

# 創(chuàng)建稀疏DataFrame（大部分值為0或空）
import numpy as np
import pandas as pd

data = np.random.choice([0, 1], size=(1000000, 100), p=[0.99, 0.01])
df = pd.DataFrame(data)

# 轉(zhuǎn)換為稀疏格式（節(jié)省95%內(nèi)存）
sparse_df = df.astype(pd.SparseDtype("int8", 0))

# 原始讀?。ㄗ詣?dòng)轉(zhuǎn)為datetime64[ns]）
df = pd.read_csv('transactions.csv', parse_dates=['date'])  # 8字節(jié)/值

# 優(yōu)化方案1：使用整數(shù)時(shí)間戳
df['timestamp'] = pd.to_datetime(df['date']).astype(np.int64) // 10**9  # 4字節(jié)/值

# 優(yōu)化方案2：分離年月日（當(dāng)不需要完整時(shí)間時(shí)）
df['year'] = pd.to_datetime(df['date']).dt.year  # int16
df['month'] = pd.to_datetime(df['date']).dt.month  # int8

# 保存為Parquet格式（壓縮比高）
df.to_parquet('data.parquet', compression='snappy')

# 讀取Parquet文件
df_parquet = pd.read_parquet('data.parquet')

# 識(shí)別高內(nèi)存對(duì)象列
def memory_usage(df):
    return df.memory_usage(deep=True).sort_values(ascending=False)

# 對(duì)象列優(yōu)化方案
for col in df.select_dtypes(include=['object']):
    # 嘗試轉(zhuǎn)換為category
    if df[col].nunique() / len(df) < 0.5:
        df[col] = df[col].astype('category')
    # 嘗試轉(zhuǎn)換為更緊湊的字符串表示
    elif df[col].str.len().max() < 50:
        pass  # 保持現(xiàn)狀或考慮數(shù)值編碼
    else:
        # 分割字符串或提取關(guān)鍵信息
        df[['part1','part2']] = df[col].str.split('|', expand=True)

import pandas as pd
import numpy as np

# 定義數(shù)據(jù)類型
dtypes = {
    'order_id': 'int64',
    'user_id': 'int32',
    'product_id': 'int32',
    'quantity': 'int16',
    'price': 'float32',
    'order_time': 'datetime64[ns]'
}

# 分塊處理函數(shù)
def process_chunk(chunk):
    # 數(shù)據(jù)清洗
    chunk = chunk[chunk['price'] > 0]
    chunk = chunk[chunk['quantity'] > 0]
    
    # 特征工程
    chunk['total_amount'] = chunk['price'] * chunk['quantity']
    chunk['day_of_week'] = chunk['order_time'].dt.dayofweek
    
    # 按用戶分組統(tǒng)計(jì)
    user_stats = chunk.groupby('user_id').agg({
        'total_amount': 'sum',
        'quantity': 'sum',
        'order_id': 'count'
    }).rename(columns={'order_id': 'order_count'})
    
    return user_stats

# 主處理流程
chunk_size = 500000
results = []

for i, chunk in enumerate(pd.read_csv(
    'orders_2020-2023.csv',
    dtype=dtypes,
    parse_dates=['order_time'],
    chunksize=chunk_size
)):
    print(f"Processing chunk {i+1}")
    results.append(process_chunk(chunk))

# 合并結(jié)果
final_result = pd.concat(results).groupby('user_id').sum()
final_result.to_parquet('user_stats.parquet')

預(yù)計(jì)內(nèi)存占用(GB) = 行數(shù) × 列數(shù) × 8字節(jié) / 10243

from multiprocessing import Pool

def parallel_process(chunk):
    # 處理邏輯同前
    return process_chunk(chunk)

if __name__ == '__main__':
    chunks = pd.read_csv('big_data.csv', chunksize=100000)
    
    with Pool(processes=4) as pool:  # 使用4個(gè)CPU核心
        results = pool.map(parallel_process, chunks)
    
    final_result = pd.concat(results)