Pandas チートシート

• filepath_or_buffer: ファイルパス、URL、またはファイルライクオブジェクト。
• sep: 区切り文字 (デフォルト: ‘,’)。タブ区切りなら '\t'。
• header: ヘッダー行の指定 (デフォルト: ‘infer’)。ヘッダーがない場合は None。
• index_col: インデックスとして使用する列番号または列名。
• usecols: 読み込む列を指定するリストまたは関数。
• encoding: ファイルのエンコーディング (例: ‘utf-8’, ‘shift-jis’)。
• dtype: 列のデータ型を指定する辞書。

import pandas as pd

# 基本的な読み込み
df_csv = pd.read_csv('data.csv')

# タブ区切り、ヘッダーなし、インデックス列指定
df_tsv = pd.read_csv('data.tsv', sep='\t', header=None, index_col=0)

# 列とエンコーディングを指定
df_partial = pd.read_csv('data_sjis.csv', usecols=['ID', '名前', 'スコア'], encoding='shift-jis')

# データ型を指定
df_typed = pd.read_csv('data.csv', dtype={'ID': str, 'スコア': float})

• io: ファイルパス、URL、またはファイルライクオブジェクト。
• sheet_name: 読み込むシート名またはシート番号 (0-indexed)。デフォルトは最初のシート。複数シートを読み込む場合はリストや None (全シート)。
• header: ヘッダー行の指定 (デフォルト: 0)。
• index_col: インデックスとして使用する列番号。
• usecols: 読み込む列を指定する範囲 (例: ‘A:C’, ‘A,C’) やリスト。
• skiprows: 先頭からスキップする行数。
• nrows: 読み込む行数。

# 特定のシートを読み込み
df_excel = pd.read_excel('data.xlsx', sheet_name='Sheet1')

# 2番目のシートを、特定の列のみ読み込み
df_sheet2 = pd.read_excel('data.xlsx', sheet_name=1, usecols='A,C:E')

# 全シートを辞書として読み込み
dict_of_dfs = pd.read_excel('data.xlsx', sheet_name=None)

• path_or_buf: JSONデータへのパスまたはJSON文字列。
• orient: JSON文字列の期待される形式 (‘split’, ‘records’, ‘index’, ‘columns’, ‘values’)。データ構造に合わせます。
• lines: 各行が個別のJSONオブジェクトであるか (デフォルト: False)。TrueにするとJSON Lines形式を読み込めます。
• dtype: 列のデータ型を指定。

# records 形式のJSON
json_str = '[{"col1": 1, "col2": "a"}, {"col1": 2, "col2": "b"}]'
df_json_records = pd.read_json(json_str, orient='records')

# JSON Lines ファイル
df_json_lines = pd.read_json('data.jsonl', lines=True)

• sql: 実行するSQLクエリ (read_sql_query) またはテーブル名 (read_sql_table)。read_sql はどちらも受け付けます。
• con: データベース接続オブジェクト (SQLAlchemy Engine や DBAPI2 connection)。
• index_col: インデックスとして使用する列名。
• params: SQLクエリに渡すパラメータ。

from sqlalchemy import create_engine

# SQLAlchemy エンジンを作成 (例: PostgreSQL)
# engine = create_engine('postgresql://user:password@host:port/database')
# ※ 上記はダミーです。実際の接続情報を使用してください。
engine = create_engine('sqlite:///mydatabase.db') # SQLiteの例

# SQLクエリで読み込み
query = "SELECT id, name, score FROM users WHERE score > ?"
df_sql = pd.read_sql_query(query, engine, params=[70])

# テーブル全体を読み込み
# df_table = pd.read_sql_table('products', engine, index_col='product_id') # SQLAlchemyが必要

• io: URL、ファイルパス、またはHTML文字列。
• match: 指定した正規表現にマッチするテキストを含むテーブルのみを抽出。
• header: ヘッダーとして使用する行。
• index_col: インデックス列の指定。
• attrs: テーブルタグの属性を指定してフィルタリング (例: {'id': 'table_id'})。

# URLからテーブルを読み込み (通常、複数のテーブルがリストで返る)
# url = 'https://example.com/data_table.html' # ダミーURL
# list_of_dfs = pd.read_html(url)
# df_html = list_of_dfs[0] # 最初のテーブルを取得

# 特定の属性を持つテーブルを抽出
# df_specific = pd.read_html(url, attrs={'class': 'data'})[0]

# クリップボードから読み込み (事前に表形式データをコピーしておく)
# df_clipboard = pd.read_clipboard(sep='\t') # タブ区切りの場合

• data: DataFrameの元となるデータ (辞書、リストのリスト、NumPy配列、Seriesなど)。
• index: 行ラベル。
• columns: 列ラベル。

# 辞書から作成 (キーが列名、値がデータリスト)
data_dict = {'col1': [1, 2, 3], 'col2': ['A', 'B', 'C']}
df_from_dict = pd.DataFrame(data_dict)

# リストのリストから作成 (columnsで列名を指定)
data_list = [[1, 'A'], [2, 'B'], [3, 'C']]
df_from_list = pd.DataFrame(data_list, columns=['col1', 'col2'])

# NumPy配列から作成
import numpy as np
arr = np.random.rand(3, 2)
df_from_numpy = pd.DataFrame(arr, columns=['val1', 'val2'])

# 単一列を選択 (Series)
series_col1 = df['col1']
series_col1_alt = df.col1 # 列名がPython変数名として有効な場合のみ

# 複数列を選択 (DataFrame)
df_subset = df[['col1', 'col3']]

# 最初の3行を選択
df_first3 = df[0:3]

# 2行目から4行目まで (5行目は含まない)
df_rows_2_to_4 = df[2:5]

# 行ラベル 'index_label' の行を選択 (Series)
row_data = df.loc['index_label']

# 複数の行ラベルで選択 (DataFrame)
rows_data = df.loc[['index_label1', 'index_label2']]

# 行ラベルと列ラベルで単一要素を選択
value = df.loc['index_label', 'col_label']

# 行ラベル範囲と列ラベル範囲で選択 (終点も含む)
subset = df.loc['start_label':'end_label', 'col1':'col3']

# 特定の行と複数列を選択
subset_cols = df.loc['index_label', ['col1', 'col3']]

# 条件式で行を選択 (boolean indexing)
condition = df['score'] > 80
high_scores = df.loc[condition]
high_scores_specific_cols = df.loc[condition, ['name', 'score']]

# 0行目のデータを取得 (Series)
row_0 = df.iloc[0]

# 0行目、1列目の要素を取得
value_0_1 = df.iloc[0, 1]

# 最初の3行を取得 (DataFrame)
first_3_rows = df.iloc[0:3] # 3行目は含まない

# 0行目と2行目、0列目と1列目を選択
subset = df.iloc[[0, 2], [0, 1]]

# 最初の2行、最初の3列を選択
subset_slice = df.iloc[0:2, 0:3] # 行も列も終点は含まない

# 'score' 列が 80 より大きい行を選択
high_scores = df[df['score'] > 80]

# 複数の条件 (AND: & , OR: |) ※各条件は()で囲む
condition_and = (df['score'] > 80) & (df['category'] == 'A')
subset_and = df[condition_and]

condition_or = (df['age'] < 30) | (df['age'] > 60)
subset_or = df[condition_or]

# isin() を使った複数条件
target_categories = ['A', 'C']
subset_isin = df[df['category'].isin(target_categories)]

# loc と組み合わせる
high_scores_loc = df.loc[df['score'] > 80]

# ラベルで単一要素を取得
value_at = df.at['index_label', 'col_label']

# 整数位置で単一要素を取得
value_iat = df.iat[0, 1] # 0行目、1列目の要素

# 値を設定
df.at['index_label', 'col_label'] = new_value
df.iat[0, 1] = another_value

# 列名に 'id' を含む列を選択 (axis=1 が列)
id_cols = df.filter(like='id', axis=1)

# 列名が正規表現 '^[A-C]' にマッチする列を選択
abc_cols = df.filter(regex='^[A-C]', axis=1)

# インデックスラベルが 'index' で終わる行を選択 (axis=0 が行)
index_rows = df.filter(like='index', axis=0)

# 特定の列名のリストでフィルタリング (items 引数)
specific_cols = df.filter(items=['name', 'score'])

# 先頭 5 行を取得 (デフォルト)
df_head = df.head()

# 先頭 10 行を取得
df_head_10 = df.head(10)

# 末尾 5 行を取得 (デフォルト)
df_tail = df.tail()

# 末尾 3 行を取得
df_tail_3 = df.tail(3)

# 3行をランダムにサンプリング
random_rows = df.sample(n=3)

# 全体の10%をランダムにサンプリング
random_frac = df.sample(frac=0.1)

# 重複を許してサンプリング (replace=True)
random_replace = df.sample(n=5, replace=True)

# 乱数シードを指定して再現性を確保
random_seed = df.sample(n=3, random_state=42)

# DataFrame 全体で欠損値を確認
missing_values = df.isnull()

# 特定の列で欠損値を確認
missing_in_col = df['column_name'].isnull()

# 欠損値の合計数を列ごとに計算
missing_counts = df.isnull().sum()

# 欠損値を含む行を抽出
rows_with_nan = df[df.isnull().any(axis=1)]

# 欠損値でない要素を確認
non_missing = df.notnull()

# 欠損値を含まない行を抽出
rows_without_nan = df[df.notnull().all(axis=1)]

• axis: 削除する軸 (‘index’/’0′ で行、’columns’/’1’ で列。デフォルトは行)。
• how: ‘any’ (一つでも NaN があれば削除)、’all’ (すべて NaN なら削除)。デフォルトは ‘any’。
• thresh: NaN でない値がこの数以上ある行/列を残す。
• subset: 指定した列/行ラベルの範囲で NaN をチェックする。
• inplace: True の場合、元の DataFrame を直接変更する (デフォルト: False)。

# 欠損値を含む行を削除
df_dropped_rows = df.dropna() # how='any' がデフォルト

# 全ての要素が欠損値である行を削除
df_dropped_all_nan_rows = df.dropna(how='all')

# 欠損値を含む列を削除
df_dropped_cols = df.dropna(axis=1)

# 特定の列 ('col1', 'col2') に欠損値がある行を削除
df_dropped_subset = df.dropna(subset=['col1', 'col2'])

# 欠損値でない値が3つ以上ある行のみ残す
df_thresh = df.dropna(thresh=3)

# 元の DataFrame を直接変更
# df.dropna(inplace=True)

• value: 欠損値を置き換える値 (スカラー、辞書、Series、DataFrame)。
• method: 補完方法 (‘ffill’/’pad’: 前の値で補完, ‘bfill’/’backfill’: 後ろの値で補完)。
• axis: 補完を行う軸。
• limit: 連続する欠損値を補完する最大数 (method指定時)。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。

# 全ての欠損値を 0 で補完
df_filled_zero = df.fillna(0)

# 列ごとに異なる値で補完 (辞書を使用)
fill_values = {'col1': 0, 'col2': 'Unknown', 'col3': df['col3'].mean()}
df_filled_dict = df.fillna(value=fill_values)

# 前の値で補完 (Forward Fill)
df_ffill = df.fillna(method='ffill')

# 後の値で補完 (Backward Fill) 、最大2つまで
df_bfill_limit = df.fillna(method='bfill', limit=2)

# 特定の列だけを平均値で補完
df['col_numeric'] = df['col_numeric'].fillna(df['col_numeric'].mean())

# 元の DataFrame を直接変更
# df.fillna(0, inplace=True)

• subset: 重複をチェックする列名のリスト。指定しない場合は全列が対象。
• keep: ‘first’ (最初の出現以外を True), ‘last’ (最後の出現以外を True), False (全ての重複行を True)。デフォルトは ‘first’。

# 重複行を特定 (最初の出現以外が True)
duplicates = df.duplicated()

# 重複している行を表示
df_duplicates = df[df.duplicated()]

# 特定の列 ('key1', 'key2') で重複をチェック
key_duplicates = df.duplicated(subset=['key1', 'key2'])

# 最後の出現を残して重複を特定
last_duplicates = df.duplicated(keep='last')

# 全ての重複行を特定 (重複がない行は False)
all_duplicates = df.duplicated(keep=False)

• subset: 重複をチェックする列名のリスト。
• keep: ‘first’ (最初の出現を残す), ‘last’ (最後の出現を残す), False (全ての重複行を削除)。デフォルトは ‘first’。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。

# 重複行を削除 (最初の出現を残す)
df_deduplicated = df.drop_duplicates()

# 特定の列 ('key1', 'key2') で重複をチェックし、最後の出現を残す
df_dedup_last = df.drop_duplicates(subset=['key1', 'key2'], keep='last')

# 元の DataFrame を直接変更
# df.drop_duplicates(inplace=True)

• dtype: 変換後のデータ型 (例: int, float, str, 'category', 'datetime64[ns]')。辞書で列ごとに指定可能。
• errors: 変換エラー時の処理 (‘raise’: 例外発生, ‘ignore’: エラーを無視し元の値を保持)。デフォルトは ‘raise’。

# 'col1' を整数型に変換
df['col1'] = df['col1'].astype(int)

# 'col2' を文字列型に変換
df['col2'] = df['col2'].astype(str)

# 複数列の型を同時に変換
df = df.astype({'col1': float, 'col_cat': 'category'})

# 数値に変換できない値がある場合、エラーにせず NaN にする (pd.to_numeric を推奨)
# df['numeric_str'] = df['numeric_str'].astype(float, errors='ignore') # 非推奨の場合あり

# より安全な数値変換 (errors='coerce' で変換不能値を NaN に)
df['numeric_str'] = pd.to_numeric(df['numeric_str'], errors='coerce')

# 日付文字列を datetime 型に変換 (pd.to_datetime を推奨)
df['date_str'] = pd.to_datetime(df['date_str'], errors='coerce')

• to_replace: 置換対象の値 (スカラー、リスト、辞書、正規表現)。
• value: 置換後の値。to_replace が辞書の場合は不要。
• regex: to_replace を正規表現として扱うか (True/False)。
• method: .fillna() と同様の補完メソッド (‘pad’, ‘ffill’, ‘bfill’, ‘backfill’)。
• limit: method 使用時の連続置換上限。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。

# DataFrame 全体で特定の値 (例: -999) を NaN に置換
import numpy as np
df_replaced = df.replace(-999, np.nan)

# 特定の列で値を置換
df['category'] = df['category'].replace('Old', 'Legacy')

# 複数の値を単一の値に置換
df['status'] = df['status'].replace(['Pending', 'Processing'], 'InProgress')

# 辞書を使って複数の値を個別に置換
df_replaced_dict = df.replace({'col1': {0: 10, 1: 100}, 'col2': {'A': 'X', 'B': 'Y'}})

# 正規表現を使って置換 (例: 'Mr.' や 'Ms.' を削除)
df['name'] = df['name'].replace(r'(Mr\.|Ms\.)\s*', '', regex=True)

# 元の DataFrame を直接変更
# df.replace('N/A', np.nan, inplace=True)

• mapper / index / columns: 変更マッピングを指定する辞書または関数。index は行ラベル、columns は列名用。mapper は axis と組み合わせて使用。
• axis: マッピングを適用する軸 (‘index’/’0’ or ‘columns’/’1’)。mapper 使用時に必要。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。

# 列名を変更 ({旧名: 新名})
df_renamed_cols = df.rename(columns={'old_col1': 'new_col1', 'old_col2': 'new_col2'})

# 行ラベル (インデックス) を変更
df_renamed_index = df.rename(index={'old_idx1': 'new_idx1'})

# 関数を使って列名を変更 (例: 全て大文字に)
df_upper_cols = df.rename(columns=str.upper)

# mapper と axis を使用 (列名を小文字に)
df_lower_cols = df.rename(mapper=str.lower, axis='columns')

# 元の DataFrame を直接変更
# df.rename(columns={'ID': 'Identifier'}, inplace=True)

# 固定値で新しい列を追加
df['new_col_fixed'] = 100

# 既存の列から計算して新しい列を追加
df['col_sum'] = df['col1'] + df['col2']
df['col_product'] = df['col1'] * df['col_rate']

# 条件に基づいて値を設定 (np.whereを使用)
import numpy as np
df['category'] = np.where(df['score'] >= 60, 'Pass', 'Fail')

# .loc を使って特定の条件下で値を設定
df.loc[df['country'] == 'Japan', 'currency'] = 'JPY'

# del 文で削除 (元の DataFrame を変更)
# del df['obsolete_col']

# .pop() で削除 (削除した列を Series として返す, 元の DataFrame を変更)
# popped_series = df.pop('temp_col')

# .drop() で削除 (デフォルトでは新しい DataFrame を返す)
df_dropped = df.drop(columns=['col_to_drop1', 'col_to_drop2'])

# .drop() で元の DataFrame を変更
# df.drop(columns='another_col', inplace=True)

# .drop() で行を削除する場合 (axis=0 または index 引数)
df_dropped_rows = df.drop(index=['index_label1', 'index_label2'])

• func: 適用する関数。
• axis: 関数を適用する軸 (‘index’/’0’: 列ごとに関数適用, ‘columns’/’1’: 行ごとに関数適用)。デフォルトは 0。
• result_type: 結果の形式 (‘expand’, ‘reduce’, ‘broadcast’)。
• args, **kwargs: 関数に渡す追加の引数。

# 列 'col1' の各要素を2倍にする (Series.apply は要素ごと)
df['col1_doubled'] = df['col1'].apply(lambda x: x * 2)

# 各列の最大値を計算 (axis=0, 列ごとに関数適用)
max_values = df.apply(np.max, axis=0) # または df.max(axis=0)

# 各行の合計値を計算 (axis=1, 行ごとに関数適用)
row_sums = df[['col1', 'col2']].apply(np.sum, axis=1) # または df[['col1', 'col2']].sum(axis=1)

# 複雑な条件で行ごとに新しい列を作成
def calculate_category(row):
    if row['score'] > 80 and row['attendance'] > 0.9:
        return 'Excellent'
    elif row['score'] > 60:
        return 'Good'
    else:
        return 'Needs Improvement'

df['performance'] = df.apply(calculate_category, axis=1)

# 辞書を使ってカテゴリ名をマッピング
category_map = {1: 'Electronics', 2: 'Clothing', 3: 'Groceries'}
df['category_name'] = df['category_id'].map(category_map)

# マッピングにない値は NaN になる。fillnaでデフォルト値を設定可能
df['category_name'] = df['category_id'].map(category_map).fillna('Other')

# 関数を使ってマッピング (例: 数値を文字列フォーマットに)
df['formatted_price'] = df['price'].map(lambda x: f'${x:.2f}')

# DataFrame 全体の数値を絶対値に変換 (数値列のみに適用するのが一般的)
numeric_cols = df.select_dtypes(include=np.number).columns
# df[numeric_cols] = df[numeric_cols].applymap(abs) # applymapの使用例

# 代替: DataFrame.map (Pandas 2.1.0以降)
# df[numeric_cols] = df[numeric_cols].map(abs)

# 代替: apply と Series.map
# df[numeric_cols] = df[numeric_cols].apply(lambda x: x.map(abs))

• by: ソート基準となる列名または列名のリスト。
• axis: ソートする軸 (0: 行, 1: 列)。デフォルトは 0。
• ascending: 昇順 (True) か降順 (False) か。リストで列ごとに指定可能。デフォルトは True。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。
• na_position: NaN の位置 (‘first’ または ‘last’)。デフォルトは ‘last’。

# 'score' 列で昇順ソート
df_sorted_score = df.sort_values(by='score')

# 'category' で昇順、'score' で降順ソート
df_multi_sorted = df.sort_values(by=['category', 'score'], ascending=[True, False])

# インデックスでソートする場合は .sort_index() を使用
df_sorted_index = df.sort_index(ascending=False)

# 元の DataFrame を直接ソート
# df.sort_values(by='date', inplace=True)

• axis: ソートする軸 (0: インデックス, 1: 列名)。デフォルトは 0。
• ascending: 昇順 (True) か降順 (False) か。デフォルトは True。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。
• na_position: NaN の位置 (‘first’ または ‘last’)。デフォルトは ‘last’。

# インデックスで昇順ソート
df_sorted_idx = df.sort_index()

# インデックスで降順ソート
df_sorted_idx_desc = df.sort_index(ascending=False)

# 列名でアルファベット順ソート (axis=1)
df_sorted_cols = df.sort_index(axis=1)

# 元の DataFrame を直接ソート
# df.sort_index(inplace=True)

• level: マルチインデックスの場合、リセットするレベルを指定。
• drop: True の場合、元のインデックスを列として追加せずに削除する (デフォルト: False)。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。

# インデックスをリセットし、元のインデックスを 'index' 列として追加
df_reset = df.reset_index()

# インデックスをリセットし、元のインデックスを削除
df_reset_drop = df.reset_index(drop=True)

# 元の DataFrame を直接変更
# df.reset_index(inplace=True)

• keys: インデックスにする列名または列名のリスト (マルチインデックス用)。
• drop: True の場合、インデックスに設定した列を元の列から削除する (デフォルト: True)。
• append: True の場合、既存のインデックスに追加する形で新しいインデックスを設定する (デフォルト: False)。
• inplace: True の場合、元の DataFrame を直接変更 (デフォルト: False)。

# 'id' 列を新しいインデックスに設定
df_set_idx = df.set_index('id')

# 複数列 ('category', 'id') をマルチインデックスに設定
df_multi_idx = df.set_index(['category', 'id'])

# インデックスに設定後も元の列を残す (drop=False)
df_set_idx_keep = df.set_index('id', drop=False)

# 元の DataFrame を直接変更
# df.set_index('timestamp', inplace=True)

# 文字列を小文字に変換
df['name_lower'] = df['name'].str.lower()

# 文字列が含まれているか確認 (boolean Series)
has_keyword = df['description'].str.contains('important', case=False, na=False)

# 文字列を置換
df['product_code'] = df['product_code'].str.replace('-', '')

# 文字列を指定文字で分割してリストにする
split_names = df['full_name'].str.split(' ')

# 分割したリストの最初の要素を取得
df['first_name'] = df['full_name'].str.split(' ').str[0]

# 正規表現で文字列を抽出
df['zip_code'] = df['address'].str.extract(r'(\d{5})')

# 文字列の長さを取得
df['name_length'] = df['name'].str.len()

# 事前に datetime 型に変換しておく
df['timestamp'] = pd.to_datetime(df['timestamp'])

# 年、月、日を抽出
df['year'] = df['timestamp'].dt.year
df['month'] = df['timestamp'].dt.month
df['day'] = df['timestamp'].dt.day

# 曜日を取得 (0=月曜日, 6=日曜日)
df['weekday'] = df['timestamp'].dt.weekday
df['weekday_name'] = df['timestamp'].dt.day_name() # 曜日の名前

# 時、分、秒を抽出
df['hour'] = df['timestamp'].dt.hour

# 日付を指定フォーマットの文字列に変換
df['date_str'] = df['timestamp'].dt.strftime('%Y-%m-%d')

# 日付のみ、時間のみを抽出
df['date_only'] = df['timestamp'].dt.date
df['time_only'] = df['timestamp'].dt.time

# 時間帯を考慮した操作 (タイムゾーン設定が必要な場合)
# df['timestamp_tz'] = df['timestamp'].dt.tz_localize('UTC').dt.tz_convert('Asia/Tokyo')

• x: 分割するデータ (Series や配列)。
• bins: 区間の境界値のリスト、または区間の数 (int)。
• labels: 各区間に付けるラベルのリスト。指定しない場合は区間表記になる。
• right: True の場合、区間は右側を含む (例: (10, 20])。False なら左側を含む [10, 20)。デフォルトは True。
• include_lowest: True の場合、最初の区間に最小値を含む。

# 年齢を年代に分割
age_bins = [0, 18, 30, 50, 100]
age_labels = ['Teen', '20s', '30-40s', '50+']
df['age_group'] = pd.cut(df['age'], bins=age_bins, labels=age_labels, right=False)

# スコアを 4 つの等間隔な区間に分割 (ラベルなし)
df['score_quantile'] = pd.cut(df['score'], bins=4)

# スコアを 4 つの等量な区間に分割 (pd.qcut を使用)
df['score_qcut'] = pd.qcut(df['score'], q=4, labels=['Q1', 'Q2', 'Q3', 'Q4'])

• data: 変換する DataFrame または Series。
• prefix: 生成される新しい列名のプレフィックス。辞書で列ごとに指定可能。
• columns: ダミー変数化する列名のリスト。指定しない場合、データ型が object または category の列が対象になることが多い。
• drop_first: True の場合、各カテゴリの最初のレベルを削除して k-1 個のダミー変数を作成 (多重共線性を避けるため)。
• dtype: 生成されるダミー変数用のデータ型 (デフォルトは bool または int)。

# 'category' 列をダミー変数化
dummies = pd.get_dummies(df['category'], prefix='cat')

# 元の DataFrame と結合
df = pd.concat([df, dummies], axis=1)

# DataFrame 内の複数の列を一度にダミー変数化
df_with_dummies = pd.get_dummies(df, columns=['category', 'region'], drop_first=True)

• objs: 連結する DataFrame/Series のリスト。
• axis: 連結する軸 (0: 行方向 (縦積み), 1: 列方向 (横並び))。デフォルトは 0。
• join: 列方向 (axis=1) での連結時に、インデックスの処理方法 (‘outer’: 和集合, ‘inner’: 積集合)。デフォルトは ‘outer’。
• ignore_index: True の場合、元のインデックスを無視して新しい連番インデックスを振る (デフォルト: False)。
• keys: 連結元の DataFrame を識別するための階層的インデックスを追加。

# df1 と df2 を行方向に連結 (縦に積む)
df_concat_rows = pd.concat([df1, df2])

# インデックスをリセットして連結
df_concat_ignore = pd.concat([df1, df2], ignore_index=True)

# df1 と df3 を列方向に連結 (横に並べる) ※インデックスが揃っている必要がある場合が多い
df_concat_cols = pd.concat([df1, df3], axis=1)

# 列方向で、共通のインデックスのみ残して連結 (inner join)
df_concat_cols_inner = pd.concat([df1, df3], axis=1, join='inner')

# 連結元を識別するキーを追加
df_concat_keys = pd.concat([df1, df2], keys=['source1', 'source2'])

• left, right: 結合する左側と右側の DataFrame。df_left.merge(df_right, ...) の形でも使える。
• how: 結合方法 (‘inner’, ‘outer’, ‘left’, ‘right’)。SQL の JOIN に対応。デフォルトは ‘inner’。
• on: 結合キーとする列名 (両方の DataFrame に存在する)。
• left_on, right_on: 左右の DataFrame で結合キーの列名が異なる場合にそれぞれ指定。
• left_index, right_index: True の場合、インデックスを結合キーとして使用する。
• suffixes: 結合後に重複する列名がある場合に付与する接尾辞 (例: ('_left', '_right'))。
• indicator: True の場合、結合結果に ‘_merge’ 列を追加し、各行がどの結合タイプに対応するかを示す (‘left_only’, ‘right_only’, ‘both’)。

# 'key' 列を基準に内部結合 (共通のキーを持つ行のみ)
df_inner = pd.merge(df_left, df_right, on='key', how='inner')
# または df_left.merge(df_right, on='key', how='inner')

# 'key' 列を基準に左外部結合 (左 DataFrame の全行を残す)
df_left_join = pd.merge(df_left, df_right, on='key', how='left')

# 異なる列名をキーとして結合 ('left_key' と 'right_key')
df_diff_keys = pd.merge(df_left, df_right, left_on='left_key', right_on='right_key', how='inner')

# 左 DataFrame のインデックスと右 DataFrame の 'key' 列で結合
df_merge_index = pd.merge(df_left, df_right, left_index=True, right_on='key', how='left')

# 重複列名にサフィックスを付与
df_suffixes = pd.merge(df_orders, df_customers, on='customer_id', suffixes=('_order', '_cust'))

# 結合ソースを示すインジケータを追加
df_indicator = pd.merge(df1, df2, on='id', how='outer', indicator=True)

• other: 結合する相手の DataFrame または DataFrame のリスト。
• on: 呼び出し元 DataFrame で結合キーとして使用する列名 (インデックスではなく)。
• how: 結合方法 (‘left’, ‘right’, ‘outer’, ‘inner’)。デフォルトは ‘left’。
• lsuffix, rsuffix: 重複する列名がある場合に付与する左/右の接尾辞。

# df_left のインデックスと df_right のインデックスで左結合 (デフォルト)
df_join_index = df_left.join(df_right, lsuffix='_left', rsuffix='_right')

# df_left の 'key' 列と df_right のインデックスで左結合
df_join_on_key = df_left.join(df_right, on='key', lsuffix='_left', rsuffix='_right')

# 複数の DataFrame をインデックスで結合
df_join_multiple = df_left.join([df_other1, df_other2], how='outer')

Note: merge はより柔軟性が高く、列と列、列とインデックス、インデックスとインデックスの結合を明示的に指定できます。join はインデックスベースの結合を簡潔に書くのに便利です。

• by: グループ化のキーとなる列名、列名のリスト、関数、またはインデックスレベル。
• axis: グループ化する軸 (0: 行, 1: 列)。デフォルトは 0。
• level: インデックスが MultiIndex の場合、グループ化に使うレベル。
• as_index: True の場合、グループ化キーを結果のインデックスにする (デフォルト: True)。False にすると通常の列になる。
• sort: True の場合、グループキーでソートする (デフォルト: True)。
• group_keys: apply と共に使用する場合、グループ化キーを結果に含めるか。
• observed: カテゴリ型でグループ化する場合、観測されたカテゴリのみを対象とするか (デフォルト: False、将来 True に変更予定)。

# 'category' 列でグループ化
grouped = df.groupby('category')

# グループ化オブジェクトの確認 (この時点では計算されない)
# print(grouped)

# グループごとに 'score' 列の平均値を計算
mean_scores = grouped['score'].mean()
# または df.groupby('category')['score'].mean()

# 複数列でグループ化し、複数列の合計を計算
grouped_multi = df.groupby(['category', 'region'])
sum_values = grouped_multi[['sales', 'quantity']].sum()

# グループ化キーをインデックスにしない場合
mean_scores_no_index = df.groupby('category', as_index=False)['score'].mean()

# グループごとにサイズ (行数) を計算
group_sizes = grouped.size()

# カテゴリごとの合計売上
total_sales = df.groupby('category')['sales'].sum()

# 地域ごとの平均スコア
avg_scores = df.groupby('region')['score'].mean()

# カテゴリごとのレコード数 (NaN を含まない)
counts = df.groupby('category')['id'].count()

# カテゴリごとのレコード数 (NaN を含む)
sizes = df.groupby('category').size()

# 地域ごとの最大価格
max_prices = df.groupby('region')['price'].max()

# カテゴリごとのユニークな商品数
unique_products = df.groupby('category')['product_id'].nunique()

# グループごとに複数の集計 (平均と合計)
agg_results = df.groupby('category')['score'].agg(['mean', 'sum'])

# 列ごとに異なる集計関数を適用 (辞書を使用)
agg_dict = {
    'sales': ['sum', 'mean'],
    'quantity': 'sum',
    'score': 'mean'
}
agg_custom = df.groupby('category').agg(agg_dict)

# 集計結果の列名をカスタマイズ (タプルを使用: (列名, 関数))
agg_named = df.groupby('category').agg(
    total_sales=('sales', 'sum'),
    avg_score=('score', 'mean'),
    max_quantity=('quantity', 'max')
)

# カスタム集計関数を適用 (lambda や定義済み関数)
def range_fn(x):
    return x.max() - x.min()

agg_lambda = df.groupby('category')['price'].agg(['sum', lambda x: x.max() - x.min()])
agg_custom_fn = df.groupby('category').agg(
    sales_sum=('sales', 'sum'),
    price_range=('price', range_fn)
)

# 各カテゴリの平均スコアを元の DataFrame に追加
df['avg_score_by_category'] = df.groupby('category')['score'].transform('mean')

# 各カテゴリ内でスコアを標準化 (平均 0, 標準偏差 1)
df['score_zscore_by_category'] = df.groupby('category')['score'].transform(lambda x: (x - x.mean()) / x.std())

# 各カテゴリの中央値で欠損値を補完
df['filled_price'] = df.groupby('category')['price'].transform(lambda x: x.fillna(x.median()))

# グループ内の行数が 10 より大きいグループのみを抽出
filtered_df = df.groupby('category').filter(lambda x: len(x) > 10)

# グループ内の平均スコアが 70 より大きいグループのみを抽出
filtered_high_score = df.groupby('category').filter(lambda x: x['score'].mean() > 70)

# グループ内に特定の条件を満たす行が含まれるグループのみを抽出
# (例: 'status' 列に 'Error' が含まれる category の全データを抽出)
filtered_error = df.groupby('category').filter(lambda x: (x['status'] == 'Error').any())

• data: ピボットテーブルを作成する DataFrame。
• values: 集計する値が含まれる列名。
• index: ピボットテーブルの行インデックスにする列名。
• columns: ピボットテーブルの列にする列名。
• aggfunc: 集計関数 (デフォルト: ‘mean’)。リストや辞書も可。
• fill_value: 結果の NaN を置き換える値。
• margins: True の場合、行と列の合計 (All) を追加する。

# カテゴリを行、地域を列とし、売上の合計を集計
pivot_sales = pd.pivot_table(df, values='sales', index='category', columns='region', aggfunc='sum')

# 複数列を集計 (平均スコアと最大数量)
pivot_multi = pd.pivot_table(df, index='category', columns='region',
                             aggfunc={'score': 'mean', 'quantity': 'max'})

# NaN を 0 で埋め、合計行・列を追加
pivot_filled_margins = pd.pivot_table(df, values='sales', index='category', columns='region',
                                      aggfunc='sum', fill_value=0, margins=True)

• index: クロス集計表の行に配置する値（Series、配列、またはリスト）。
• columns: クロス集計表の列に配置する値。
• values: これらの要因に基づいて集計する値の配列（オプション）。
• aggfunc: `values` が指定された場合に適用する集計関数（オプション）。
• margins: True の場合、行/列の小計を追加（デフォルト: False）。
• normalize: True または (‘index’, ‘columns’, ‘all’) で、頻度を正規化（割合を計算）。

# 'category' と 'region' の頻度クロス集計表
cross_freq = pd.crosstab(df['category'], df['region'])

# 合計行・列を追加
cross_margins = pd.crosstab(df['category'], df['region'], margins=True)

# 行ごとに正規化（各カテゴリ内での地域の割合）
cross_norm_index = pd.crosstab(df['category'], df['region'], normalize='index')

# 'sales' の合計値をクロス集計
cross_sales_sum = pd.crosstab(df['category'], df['region'], values=df['sales'], aggfunc='sum')

# 文字列の列を datetime 型に変換
df['date_col'] = pd.to_datetime(df['date_str_col'])

# フォーマットを指定して変換
df['custom_format_date'] = pd.to_datetime(df['custom_str'], format='%Y/%m/%d %H:%M')

# 変換できない値を NaT (Not a Time) にする
df['date_coerce'] = pd.to_datetime(df['mixed_date_str'], errors='coerce')

# Unix タイムスタンプ (秒) から変換
df['datetime_from_unix'] = pd.to_datetime(df['unix_timestamp'], unit='s')

# 'date_col' をインデックスに設定
df = df.set_index('date_col') # 事前に to_datetime で変換しておく

# 特定の日付で選択
data_on_date = df.loc['2023-10-26']

# 月で選択
data_in_month = df.loc['2023-10']

# 年で選択
data_in_year = df.loc['2023']

# 日付範囲でスライス
data_range = df.loc['2023-10-01':'2023-10-15']

# 特定の時刻まで選択
data_until_time = df.loc[:'2023-10-26 12:00:00']

• rule: リサンプリングする頻度を示すオフセットエイリアス (例: ‘D’: 日次, ‘W’: 週次, ‘M’: 月末, ‘MS’: 月初, ‘Q’: 四半期末, ‘A’: 年末, ‘H’: 時間, ‘T’/’min’: 分)。
• on: DatetimeIndex 以外に、時系列データを持つ列名を指定する場合。
• 集計メソッド (.sum(), .mean(), .ohlc() など) を続けて呼び出す。

# df のインデックスが DatetimeIndex である前提

# 日次データを月次合計にダウンサンプリング
monthly_sum = df['value'].resample('M').sum()

# 日次データを週次平均にダウンサンプリング (週は日曜始まり)
weekly_mean = df['value'].resample('W').mean()
# 週次平均 (月曜始まり)
# weekly_mean_mon = df['value'].resample('W-MON').mean()

# OHLC (始値, 高値, 安値, 終値) を計算
monthly_ohlc = df['price'].resample('M').ohlc()

# 月次データを日次データにアップサンプリング (欠損値が発生)
daily_upsampled = df['value'].resample('D').asfreq() # 値をそのまま持ってくる
daily_ffill = df['value'].resample('D').ffill() # 前の値で補完
daily_interpolated = df['value'].resample('D').interpolate() # 線形補間

• window: 窓のサイズ (整数: 期間数、オフセット文字列: 時間)。
• min_periods: 計算に必要な最小観測数。満たない場合は NaN。
• center: True の場合、窓の中心にラベルを配置する (デフォルト: False、窓の右端に配置)。
• on: 計算対象の列名 (DatetimeIndex 以外の場合)。
• 集計メソッド (.mean(), .sum(), .std() など) を続けて呼び出す。

# 3期間の移動平均
rolling_mean_3 = df['value'].rolling(window=3).mean()

# 7日間の移動合計 (インデックスが DatetimeIndex の場合)
rolling_sum_7d = df['value'].rolling(window='7D').sum()

# 窓サイズ5、最低3期間で計算
rolling_std_min3 = df['value'].rolling(window=5, min_periods=3).std()

# 窓の中心に値を配置
rolling_mean_center = df['value'].rolling(window=3, center=True).mean()

• min_periods: 計算に必要な最小観測数 (デフォルト: 1)。
• 集計メソッド (.mean(), .sum(), .max() など) を続けて呼び出す。

# 累積合計
expanding_sum = df['value'].expanding().sum()

# 累積平均
expanding_mean = df['value'].expanding().mean()

# 累積最大値 (最低2期間必要)
expanding_max_min2 = df['value'].expanding(min_periods=2).max()

• periods: シフトする期間数 (正: 未来へシフト (ラグ), 負: 過去へシフト (リード))。デフォルトは 1。
• freq: 時間ベースでシフトする場合のオフセットエイリアス (例: ‘D’, ‘M’)。DatetimeIndex が必要。
• axis: シフトする軸 (0: 行, 1: 列)。デフォルトは 0。
• fill_value: シフトによって生じる欠損値を埋める値。

# 1期間前の値 (ラグ1)
df['value_lag1'] = df['value'].shift(1)

# 1期間後の値 (リード1)
df['value_lead1'] = df['value'].shift(-1)

# 前日比を計算
df['daily_change'] = df['price'] - df['price'].shift(1)

# 1ヶ月前の値 (インデックスが DatetimeIndex の場合)
df['value_1M_ago'] = df['value'].shift(freq='M')

# シフトで生じた NaN を 0 で埋める
df['value_lag1_filled'] = df['value'].shift(1, fill_value=0)

• .dt.tz_localize(): naive な datetime にタイムゾーン情報を付与する。
• .dt.tz_convert(): aware な datetime を別のタイムゾーンに変換する。

# df['timestamp'] は naive な datetime とする

# UTC タイムゾーンを付与
df['timestamp_utc'] = df['timestamp'].dt.tz_localize('UTC')

# 東京タイムゾーンを付与 (注意: ローカルタイムが不明確な時期あり)
df['timestamp_tokyo_naive'] = df['timestamp'].dt.tz_localize('Asia/Tokyo', ambiguous='infer')

# UTC から東京タイムゾーンに変換
# df_utc = df.set_index('timestamp_utc') # aware な DatetimeIndex が必要
# df_tokyo = df_utc.tz_convert('Asia/Tokyo')

# タイムゾーン情報を削除して naive に戻す
# df['timestamp_naive_again'] = df_tokyo.index.tz_localize(None)

• start: 開始日時。
• end: 終了日時。
• periods: 生成する期間の数。start, end, freq のうち2つを指定。
• freq: 頻度 (例: ‘D’, ‘H’, ‘M’, ‘MS’)。デフォルトは ‘D’。
• tz: タイムゾーン。
• normalize: True の場合、開始/終了日時を午前0時に丸める。

# 2023年の日次インデックスを生成
date_idx_daily = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')

# 開始日から10日間を生成
date_idx_periods = pd.date_range(start='2023-10-01', periods=10, freq='D')

# 2023年の月初めのインデックスを生成
date_idx_monthly_start = pd.date_range(start='2023-01-01', end='2023-12-31', freq='MS')

# 特定のタイムゾーンで生成
date_idx_tz = pd.date_range(start='2023-10-01', periods=5, freq='H', tz='Asia/Tokyo')

• kind: グラフの種類 (‘line’, ‘bar’, ‘barh’, ‘hist’, ‘box’, ‘kde’, ‘density’, ‘area’, ‘pie’, ‘scatter’, ‘hexbin’)。
• x, y: DataFrame でプロットする列を指定。
• figsize: グラフのサイズ (タプル)。
• title: グラフタイトル。
• grid: グリッド表示の有無 (True/False)。
• legend: 凡例表示の有無 (True/False)。
• その他、Matplotlib の plot 関数に渡される引数。

import matplotlib.pyplot as plt

# Series の折れ線グラフ
# series.plot()

# DataFrame の全数値列を折れ線グラフに
# df.plot(figsize=(10, 5), title='Time Series Plot', grid=True)

# 棒グラフ
# df['counts'].plot(kind='bar', title='Counts per Category')

# 水平棒グラフ
# df.plot(kind='barh', x='category', y='value')

# ヒストグラム
# df['scores'].plot(kind='hist', bins=20, title='Score Distribution')

# 箱ひげ図
# df[['score1', 'score2']].plot(kind='box')

# カーネル密度推定
# df['values'].plot(kind='kde', title='Value Density')

# 散布図 (DataFrame のみ)
# df.plot(kind='scatter', x='feature1', y='feature2', title='Scatter Plot')

# グラフを表示 (Jupyter Notebook などでは不要な場合あり)
# plt.show()

Note: .plot() を呼び出す前に import matplotlib.pyplot as plt を実行しておくことが推奨されます。グラフの細かいカスタマイズには Matplotlib の機能を使います。

# 折れ線グラフ
# df['value'].plot.line()

# 棒グラフ
# df.plot.bar(x='category', y='count')

# ヒストグラム
# df['data'].plot.hist(bins=15)

# 散布図
# df.plot.scatter(x='col_a', y='col_b')

# plt.show()

• path_or_buf: 出力ファイルパスまたはファイルライクオブジェクト。
• sep: 区切り文字 (デフォルト: ‘,’)。
• index: True の場合、インデックスをファイルに出力する (デフォルト: True)。False で出力しない。
• header: True の場合、列名をヘッダーとして出力する (デフォルト: True)。False またはリストで指定。
• encoding: 出力ファイルのエンコーディング (例: ‘utf-8’, ‘shift_jis’)。
• float_format: 浮動小数点数のフォーマット文字列。
• mode: 書き込みモード (‘w’: 上書き, ‘a’: 追記)。

# CSV ファイルに出力 (インデックスあり、ヘッダーあり)
# df.to_csv('output.csv')

# インデックスなし、タブ区切りで出力
# df.to_csv('output.tsv', sep='\t', index=False)

# Shift_JIS で出力 (ヘッダーなし)
# df.to_csv('output_sjis.csv', index=False, header=False, encoding='shift_jis')

# 追記モードで出力
# df_new.to_csv('existing_data.csv', mode='a', header=False, index=False)

• excel_writer: 出力ファイルパスまたは ExcelWriter オブジェクト。
• sheet_name: 出力するシート名 (デフォルト: ‘Sheet1’)。
• index: インデックスを出力するか (デフォルト: True)。
• header: ヘッダーを出力するか (デフォルト: True)。
• startrow, startcol: シート内の書き込み開始位置 (0-indexed)。
• engine: 使用する書き込みエンジン (‘openpyxl’, ‘xlsxwriter’)。

# Excel ファイルに出力 (単一シート)
# df.to_excel('output.xlsx', sheet_name='DataSheet', index=False)

# 複数の DataFrame を別々のシートに出力
# with pd.ExcelWriter('output_multiple.xlsx') as writer:
#     df1.to_excel(writer, sheet_name='Sheet1', index=False)
#     df2.to_excel(writer, sheet_name='Sheet2', index=False)

• path_or_buf: 出力ファイルパスまたは None (文字列として返す)。
• orient: 出力する JSON の形式 (‘split’, ‘records’, ‘index’, ‘columns’, ‘values’, ‘table’)。
• lines: True の場合、各行を個別の JSON オブジェクトとして出力 (JSON Lines 形式)。
• date_format: 日付のフォーマット (‘epoch’, ‘iso’)。
• indent: JSON を整形する場合のインデント数。

# JSON ファイルに出力 (records 形式)
# df.to_json('output.json', orient='records', indent=4)

# JSON Lines 形式で出力
# df.to_json('output.jsonl', orient='records', lines=True)

# JSON 文字列として取得 (split 形式)
# json_string = df.to_json(orient='split')

• name: 書き込む SQL テーブル名。
• con: データベース接続オブジェクト (SQLAlchemy Engine や DBAPI2 connection)。
• schema: 書き込むスキーマ名 (オプション)。
• if_exists: テーブルが既に存在する場合の動作 (‘fail’: エラー, ‘replace’: 削除して再作成, ‘append’: 追記)。デフォルトは ‘fail’。
• index: True の場合、DataFrame のインデックスをテーブルの列として書き込む (デフォルト: True)。
• index_label: インデックス列の列名。
• chunksize: 一度に書き込む行数 (メモリ効率のため)。
• method: 挿入方法 (‘multi’: 高速な multi-value INSERT, None: 標準的な INSERT)。

from sqlalchemy import create_engine

# engine = create_engine('sqlite:///mydatabase.db') # 例

# テーブル 'my_table' に書き込み (存在する場合は追記)
# df.to_sql('my_table', engine, if_exists='append', index=False)

# テーブル 'new_table' を作成して書き込み (存在する場合は置き換え)
# df.to_sql('new_table', engine, if_exists='replace', index=True, index_label='id')

# チャンクサイズを指定して書き込み
# df.to_sql('large_table', engine, if_exists='append', index=False, chunksize=1000)

• buf: 出力ファイルパスまたはファイルライクオブジェクト。None なら文字列を返す。
• index: インデックスを出力するか (デフォルト: True)。
• header: ヘッダーを出力するか (デフォルト: True)。
• classes: HTML の <table> タグに追加する CSS クラス名 (文字列またはリスト)。
• border: テーブルの罫線属性。
• escape: True の場合、HTML の特殊文字をエスケープする (デフォルト: True)。

# HTML ファイルに出力 (インデックスなし)
# df.to_html('output.html', index=False, classes='table is-striped') # Bulma クラスの例

# HTML 文字列として取得
# html_string = df.to_html(index=False, border=0)

• sep: クリップボードにコピーする際の区切り文字 (デフォルト: ‘\t’ タブ)。
• index: インデックスをコピーするか (デフォルト: True)。
• header: ヘッダーをコピーするか (デフォルト: True)。

# クリップボードにコピー (タブ区切り、インデックスなし)
# df.to_clipboard(sep='\t', index=False)

• path: 出力ファイルパス。
• engine: 使用するエンジン (‘pyarrow’, ‘fastparquet’)。’auto’ で自動選択。
• compression: 圧縮形式 (‘snappy’, ‘gzip’, ‘brotli’, None)。
• index: インデックスをファイルに含めるか (デフォルト: None、エンジン依存)。
• partition_cols: 指定した列の値に基づいてデータをパーティション分割して出力。

# Parquet ファイルに出力 (pyarrow 使用、snappy 圧縮)
# df.to_parquet('output.parquet', engine='pyarrow', compression='snappy', index=False)

# 'year' と 'month' 列でパーティション分割して出力
# df.to_parquet('partitioned_data/', engine='pyarrow', partition_cols=['year', 'month'])

# 表示する最大行数を設定
pd.set_option('display.max_rows', 100)

# 表示する最大列数を設定 (None ですべて表示)
pd.set_option('display.max_columns', None)

# 各列の最大表示幅を設定
pd.set_option('display.max_colwidth', 50)

# 浮動小数点数の表示桁数を設定
pd.set_option('display.precision', 3)

# 浮動小数点数を特定のフォーマットで表示
pd.set_option('display.float_format', '{:.2f}'.format) # 小数点以下2桁

# 設定を確認
# print(pd.get_option('display.max_rows'))

# 設定をリセット
# pd.reset_option('display.max_rows')
# pd.reset_option('all') # 全ての設定をリセット (注意が必要)

よく使われるオプション:

• display.max_rows / display.min_rows: 表示行数
• display.max_columns: 表示列数
• display.max_colwidth: 列の表示幅
• display.precision: 浮動小数点数の表示精度
• display.float_format: 浮動小数点数のフォーマット関数
• mode.chained_assignment: chained assignment (連鎖代入) の警告 (‘warn’, ‘raise’, None)

# 一時的に全ての行と列を表示する
# with pd.option_context('display.max_rows', None, 'display.max_columns', None):
#     print(df_large)

# ブロックを抜けると元の設定に戻る
# print("Outside the context block:")
# print(df_large.head())