graph LR
    A[数据] --> B(按键拆分)
    B --> C1[组 1]
    B --> C2[组 2]
    B --> C3[组 3]
    C1 --> D1(应用函数)
    C2 --> D2(应用函数)
    C3 --> D3(应用函数)
    D1 --> E[合并结果]
    D2 --> E
    D3 --> E

grouped = df["data1"].groupby(df["key1"])  # 按 key1 分组 data1
grouped.mean()  # 计算每个组的平均值

grouped = df.groupby(["key1", "key2"])  # 按 key1 和 key2 分组
grouped.agg({
    "data1": ["mean", "std"],  # 对 data1 计算平均值和标准差
    "data2": ["mean", "std"]   # 对 data2 计算平均值和标准差
})

means = df.groupby(["key1", "key2"])["data1"].mean()  # 按 key1 和 key2 分组，计算 data1 的平均值
means.unstack()  # 将结果展开，使 key2 成为列

states = np.array(["OH", "CA", "CA", "OH", "OH", "CA", "OH"])  # 外部数组 states
years = np.array([2005, 2005, 2006, 2005, 2006, 2005, 2006])  # 外部数组 years

# 创建新的 df 以匹配 states 和 years 的长度
df_ext = pd.DataFrame({
    "key1": ["a", "a", "b", "b", "a", "b", "a"],
    "key2": [1, 2, 1, 2, 1, 2, 1],
    "data1": np.random.randn(7),
    "data2": np.random.randn(7)
})

result = df_ext["data1"].groupby([states, years]).mean()  # 使用外部数组分组
print("\n分组结果:")
print(result)

print("\n展开结果:")
print(result.unstack())

df.groupby("key1").mean()  # 按 key1 分组，计算所有数值列的平均值

df.groupby(["key1", "key2"]).mean()  # 按 key1 和 key2 分组，计算所有数值列的平均值

df.groupby(["key1", "key2"]).size()  # 按 key1 和 key2 分组，计算每个组的大小

df.groupby("key1", dropna=False).size()  # 按 key1 分组，包括缺失值（如果有）

for name, group in df.groupby("key1"):  # 按 key1 迭代组
    print(f"组名: {name}")  # 打印组名
    print(group)  # 打印组数据

for (k1, k2), group in df.groupby(["key1", "key2"]):  # 按 key1 和 key2 迭代组
    print(f"组键: {(k1, k2)}")  # 打印组键
    print(group)  # 打印组数据

pieces = dict(list(df.groupby("key1")))  # 将按 key1 分组的结果转换为字典
pieces["b"]  # 获取 key1 为 "b" 的组

df.groupby(["key1", "key2"])["data2"].mean()  # 按 key1 和 key2 分组，计算 data2 的平均值

df.groupby(["key1", "key2"])[["data2"]].mean()  # 按 key1 和 key2 分组，计算 data2 的平均值

def peak_to_peak(arr):  # 定义一个函数，计算数组的极差（最大值 - 最小值）
    return arr.max() - arr.min()

grouped = df.groupby("key1")  # 按 key1 分组
grouped.agg(peak_to_peak)  # 应用自定义函数

grouped.describe()  # 获取每个组的描述性统计信息

tips = pd.read_csv("examples/tips.csv")  # 从 CSV 文件加载数据(需确保 examples 文件夹及 tips.csv 文件存在)
tips["tip_pct"] = tips["tip"] / tips["total_bill"]  # 添加一个小费百分比列

grouped = tips.groupby(["day", "smoker"])  # 按 day 和 smoker 分组
grouped_pct = grouped["tip_pct"]  # 选择 tip_pct 列
grouped_pct.agg(["mean", "std", peak_to_peak])  # 应用多个聚合函数

grouped_pct.agg([("average", "mean"), ("stdev", np.std)])  # 使用自定义列名

functions = ["count", "mean", "max"]  # 定义一个函数列表
result = grouped[["tip_pct", "total_bill"]].agg(functions)  # 对 tip_pct 和 total_bill 应用函数列表
result

grouped.agg({"tip" : np.max, "size" : "sum"})  # 对 tip 列应用 max 函数，对 size 列应用 sum 函数

grouped.agg({
    "tip_pct": ["min", "max", "mean", "std"],  # 对 tip_pct 应用多个函数
    "size": "sum"  # 对 size 应用 sum 函数
})

def top(df, n=5, column="tip_pct"):  # 定义一个函数，按指定列选择前 n 行
    return df.sort_values(column, ascending=False)[:n]

tips.groupby("smoker").apply(top)  # 按 smoker 分组，应用 top 函数

tips.groupby(["smoker", "day"]).apply(top, n=1, column="total_bill")  # 向 apply 传递额外的参数

tips.groupby("smoker", group_keys=False).apply(top)  # 抑制组键

frame = pd.DataFrame({
    "data1": np.random.standard_normal(1000),  # 创建一个包含 1000 个随机数的 DataFrame
    "data2": np.random.standard_normal(1000)
})
quartiles = pd.cut(frame["data1"], 4)  # 将 data1 列分为 4 个桶

def get_stats(group):  # 定义一个函数，计算组的统计信息
    return pd.DataFrame(
        {"min": group.min(), "max": group.max(),
        "count": group.count(), "mean": group.mean()}
    )

grouped = frame.groupby(quartiles)  # 按分位数分组
grouped.apply(get_stats)  # 应用 get_stats 函数

grouped.agg(["min", "max", "count", "mean"])

quartiles_samp = pd.qcut(frame["data1"], 4, labels=False)  # 将 data1 列分为 4 个相等大小的桶，返回标签
grouped = frame.groupby(quartiles_samp)  # 按分位数标签分组
grouped.apply(get_stats)  # 应用 get_stats 函数

s = pd.Series(np.random.standard_normal(6))  # 创建一个包含 6 个随机数的 Series
s[::2] = np.nan  # 将一些值设置为 NaN
s.fillna(s.mean())  # 使用 Series 的平均值填充 NaN

states = ["Ohio", "New York", "Vermont", "Florida",  # 创建一个州列表
          "Oregon", "Nevada", "California", "Idaho"]
group_key = ["East"] * 4 + ["West"] * 4  # 创建一个分组键列表
data = pd.Series(np.random.standard_normal(8), index=states)  # 创建一个 Series，索引为州
data[["Vermont", "Nevada", "Idaho"]] = np.nan  # 将一些值设置为 NaN

def fill_mean(group):  # 定义一个函数，使用组的平均值填充 NaN
    return group.fillna(group.mean())

data.groupby(group_key).apply(fill_mean)  # 按组键分组，应用 fill_mean 函数

fill_values = {"East": 0.5, "West": -1}  # 创建一个填充值字典
def fill_func(group):  # 定义一个函数，使用预定义值填充 NaN
    return group.fillna(fill_values[group.name])

data.groupby(group_key).apply(fill_func)  # 按组键分组，应用 fill_func 函数

suits = ["H", "S", "C", "D"]  # 花色
card_val = (list(range(1, 11)) + [10] * 3) * 4  # 牌值
base_names = ["A"] + list(range(2, 11)) + ["J", "K", "Q"]  # 牌名
cards = []
for suit in suits:
    cards.extend(str(num) + suit for num in base_names)

deck = pd.Series(card_val, index=cards)  # 创建一副牌

def draw(deck, n=5):  # 定义一个函数，从一副牌中抽取 n 张牌
    return deck.sample(n)

draw(deck)  # 抽取 5 张牌

def get_suit(card):  # 定义一个函数，获取牌的花色
    return card[-1]

deck.groupby(get_suit).apply(draw, n=2)  # 按花色分组，从每个花色中抽取 2 张牌

df = pd.DataFrame({
    "category": ["a", "a", "a", "a",  # 创建一个 DataFrame
                 "b", "b", "b", "b"],
    "data": np.random.standard_normal(8),
    "weights": np.random.uniform(size=8)
})

grouped = df.groupby("category")  # 按 category 分组

def get_wavg(group):  # 定义一个函数，计算组的加权平均值
    return np.average(group["data"], weights=group["weights"])

grouped.apply(get_wavg)  # 应用 get_wavg 函数

# 假设 examples 文件夹存在且包含 stock_px.csv 文件
close_px = pd.read_csv("examples/stock_px.csv", parse_dates=True, index_col=0)  # 从 CSV 文件加载数据

rets = close_px.pct_change().dropna()  # 计算收益率并删除缺失值

def get_year(x):  # 定义一个函数，获取年份
    return x.year

by_year = rets.groupby(get_year)  # 按年份分组

def spx_corr(group):  # 定义一个函数，计算与 SPX 的相关性
    return group.corrwith(group["SPX"])

by_year.apply(spx_corr)  # 应用 spx_corr 函数

def corr_aapl_msft(group):  # 定义一个函数，计算 Apple 和 Microsoft 之间的相关性
    return group["AAPL"].corr(group["MSFT"])

by_year.apply(corr_aapl_msft)  # 应用 corr_aapl_msft 函数

df = pd.DataFrame({'key': ['a', 'b', 'c'] * 4,
                   'value': np.arange(12.)})
g = df.groupby('key')['value']

def get_mean(group):  #定义一个函数求平均值
    return group.mean()
g.transform(get_mean)

g.transform('mean')

def times_two(group):
      return group * 2
g.transform(times_two)

def get_ranks(group):
    return group.rank(ascending=False)
g.transform(get_ranks)

def normalize(x):  # 定义一个函数，进行标准化
    return (x - x.mean()) / x.std()

g.transform(normalize)  # 使用 transform 进行标准化

g.apply(normalize)  # 使用 apply 进行标准化

normalized = (df['value'] - g.transform('mean')) / g.transform('std')  # 展开的分组操作
normalized

tips.pivot_table(
    values=['total_bill', 'tip'],  # 要聚合的列
    index=['day', 'smoker'],  # 行索引
    aggfunc='mean'  # 聚合函数
)

tips.pivot_table(index=["time", "day"], columns="smoker",  # 行和列
                 values=["tip_pct", "size"])  # 要聚合的列

tips.pivot_table(index=["time", "day"], columns="smoker",
                 values=["tip_pct", "size"], margins=True)  # 添加边距

tips.pivot_table(index=["time", "smoker"], columns="day",
                 values="tip_pct", aggfunc=len, margins=True)  # 使用 len 作为聚合函数

from io import StringIO

data = pd.read_table(StringIO("""Sample Nationality Handedness
1 USA Right-handed
2 Japan Left-handed
3 USA Right-handed
4 Japan Right-handed
5 Japan Left-handed
6 Japan Right-handed
7 USA Right-handed
8 USA Left-handed
9 Japan Right-handed
10 USA Right-handed"""), sep="\s+")

pd.crosstab(data["Nationality"], data["Handedness"], margins=True)  # 创建交叉表

pd.crosstab([tips["time"], tips["day"]], tips["smoker"], margins=True)  # 创建交叉表