import pandas as pd

df = pd.read_csv('your_data.csv')

# まずここから始める
df.info()

# さらに詳しく、カラム別のメモリ使用量
memory = df.memory_usage(deep=True)
print(memory.sort_values(ascending=False))
print(f"\n合計メモリ使用量: {memory.sum() / 1024**2:.2f} MB")

import timeit
import time

# %timeit の代替（100回実行して平均を計測）
elapsed = timeit.timeit(lambda: df['price'].apply(lambda x: x * 1.1), number=100)
print(f"timeit: {elapsed / 100 * 1000:.2f} ms per loop (mean of 100 runs)")

# %time の代替（1回だけ計測）
start = time.time()
result = df.groupby('category')['sales'].sum()
end = time.time()
print(f"time: {end - start:.4f} s")

import pandas as pd
import numpy as np

# ダウンキャストの基本
df['user_id'] = pd.to_numeric(df['user_id'], downcast='integer')  # int64 → int32 or smaller
df['score'] = pd.to_numeric(df['score'], downcast='float')        # float64 → float32

# 変換前後の比較
before = df.memory_usage(deep=True).sum() / 1024**2
print(f"変換前: {before:.2f} MB")

# int8: -128〜127  → フラグ・スコアなど
# int16: -32768〜32767 → IDが小さい場合
# int32: 〜21億     → 一般的なID
# float32: 精度が少し落ちる → 機械学習特徴量などOK

# 変換前のメモリ確認
print(f"変換前: {df['region'].memory_usage(deep=True) / 1024**2:.2f} MB")

# Categorical型に変換
df['region'] = df['region'].astype('category')
df['product_category'] = df['product_category'].astype('category')

# 変換後を確認
print(f"変換後: {df['region'].memory_usage(deep=True) / 1024**2:.2f} MB")

def optimize_dtypes(df: pd.DataFrame) -> pd.DataFrame:
    """DataFrameのdtypeを自動最適化する関数"""
    df = df.copy()
    
    for col in df.columns:
        col_type = df[col].dtype
        
        # 整数型のダウンキャスト
        if col_type in ['int64', 'int32', 'int16']:
            df[col] = pd.to_numeric(df[col], downcast='integer')
        
        # 浮動小数点型のダウンキャスト
        elif col_type in ['float64', 'float32']:
            df[col] = pd.to_numeric(df[col], downcast='float')
        
        # 文字列型で低カーディナリティならCategorical
        elif col_type == 'object':
            num_unique = df[col].nunique()
            num_total = len(df[col])
            if num_unique / num_total < 0.5:  # ユニーク率50%未満
                df[col] = df[col].astype('category')
    
    return df

# 使い方はカンタン
df_optimized = optimize_dtypes(df)

import pandas as pd
import numpy as np

df = pd.DataFrame({'value': range(1_000_000)})

# forループ（遅い）
result = []
for val in df['value']:
    result.append(val * 2 + 1)

# apply（forよりはマシ）
df['result'] = df['value'].apply(lambda x: x * 2 + 1)

# ベクトル化演算（コレが正義）
df['result'] = df['value'] * 2 + 1

# 文字列操作は .str アクセサを使う
df['name_upper'] = df['name'].str.upper()
df['name_clean'] = df['name'].str.strip().str.lower()

from numba import jit
import numpy as np

@jit(nopython=True)
def complex_calculation(values):
    """numbaでコンパイルされた高速関数"""
    result = np.empty(len(values))
    for i in range(len(values)):
        result[i] = values[i] ** 2 + values[i] * 0.5
    return result

# numpy配列で渡す
df['result'] = complex_calculation(df['value'].values)

import pandas as pd

results = []

for chunk in pd.read_csv('large_file.csv', chunksize=1_000_000):
    # チャンクごとに処理してメモリを節約する
    filtered = chunk[chunk['value'] > 100]
    aggregated = filtered.groupby('category')['value'].sum()
    results.append(aggregated)

# 全チャンクの結果を結合
final = pd.concat(results).groupby(level=0).sum()
print(final)

import psutil
import pandas as pd

def get_optimal_chunksize(file_path: str, memory_fraction: float = 0.1) -> int:
    """利用可能メモリからチャンクサイズを動的に計算"""
    available_memory = psutil.virtual_memory().available
    target_memory = available_memory * memory_fraction  # 利用可能メモリの10%を使用
    
    # ファイルの最初の1000行でサイズを推定
    sample = pd.read_csv(file_path, nrows=1000)
    row_size = sample.memory_usage(deep=True).sum() / len(sample)
    
    optimal_chunksize = int(target_memory / row_size)
    return max(10_000, min(optimal_chunksize, 1_000_000))  # 上下限を設定

chunksize = get_optimal_chunksize('large_file.csv')
print(f"最適チャンクサイズ: {chunksize:,} 行")

import pandas as pd

# CSVよりずっと速く保存・読み込みできる
df.to_parquet('data.parquet', engine='pyarrow', compression='snappy')

# 必要なカラムだけ読み込む（カラム射影）
df_loaded = pd.read_parquet(
    'data.parquet',
    engine='pyarrow',
    columns=['id', 'value', 'category']
)

# import pandas as pd  ← コメントアウトして
import modin.pandas as pd  # これだけで並列処理になる

# あとは全部同じコードでOK
df = pd.read_csv('your_data.csv')

import polars as pl

# Polarsの書き方（メソッドチェーンが気持ちいい）
df_pl = pl.read_csv('data.csv')
result = (
    df_pl
    .filter(pl.col('value') > 100)
    .group_by('category')
    .agg(pl.col('value').sum().alias('total_value'))
    .sort('total_value', descending=True)
)
print(result)