import pandas as pd

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

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

內存占用(MB) ≈ 行數 × 列數 × 每個值的字節(jié)數 / 10242

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

results = []
for chunk in chunks:
    # 對每個數據塊進行處理
    chunk_processed = chunk[chunk['amount'] > 1000]
    results.append(chunk_processed)

# 合并結果（注意內存控制）
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)):
        # 數據清洗邏輯
        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']

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

# 原始讀?。ㄗ詣油茢囝愋?，可能不最優(yōu)）
df = pd.read_csv('data.csv')  # 內存占用：1.2GB

# 優(yōu)化后讀?。ㄖ付ň_類型）
dtypes = {
    'id': 'int32',
    'price': 'float32',
    'category': 'category',  # 分類數據專用類型
    'date': 'datetime64[ns]'
}
df_optimized = pd.read_csv('data.csv', dtype=dtypes)  # 內存占用：480MB

# 原始字符串列（占用大）
df['product_type'] = ['A','B','A','C'...]  # 每個值重復存儲

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

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

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

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

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

# 優(yōu)化方案3：直接刪除（當缺失比例高時）
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)

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

# 原始讀取（自動轉為datetime64[ns]）
df = pd.read_csv('transactions.csv', parse_dates=['date'])  # 8字節(jié)/值

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

# 優(yōu)化方案2：分離年月日（當不需要完整時間時）
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')

# 識別高內存對象列
def memory_usage(df):
    return df.memory_usage(deep=True).sort_values(ascending=False)

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

import pandas as pd
import numpy as np

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

# 分塊處理函數
def process_chunk(chunk):
    # 數據清洗
    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)計
    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))

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

預計內存占用(GB) = 行數 × 列數 × 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個CPU核心
        results = pool.map(parallel_process, chunks)
    
    final_result = pd.concat(results)