08 章: 数据操作

import pandas as pd  # 导入 pandas 库，并将其简称为 pd
import numpy as np   # 导入 numpy 库，并将其简称为 np

#| echo: true
data = pd.Series(np.random.uniform(size=9),  # 创建一个包含 9 个均匀分布随机数的 Series
                 index=[["a", "a", "a", "b", "b", "c", "c", "d", "d"],  # 外层索引
                        [1, 2, 3, 1, 3, 1, 2, 2, 3]])  # 内层索引
data  # 显示 Series

data.index  # 显示 Series 的索引

data["b"]  # 选择索引为 "b" 的组

data["b":"c"]  # 选择从 "b" 到 "c" 的组（包括 "b" 和 "c"）

data.loc[["b", "d"]]  # 选择索引为 "b" 和 "d" 的组

data.loc[:, 2]  # 选择内层索引为 2 的所有数据

data.unstack()  # 将 Series 转换为 DataFrame，内层索引变为列

data.unstack().stack()  # 将 DataFrame 转换回 Series，列变回内层索引

frame = pd.DataFrame(np.arange(12).reshape((4, 3)),  # 创建一个 4x3 的 DataFrame，值为 0-11
                     index=[["a", "a", "b", "b"], [1, 2, 1, 2]],  # 行索引：两层
                     columns=[["Ohio", "Ohio", "Colorado"],  # 列索引：两层
                              ["Green", "Red", "Green"]])
frame  # 显示 DataFrame

frame.index.names = ["key1", "key2"]  # 设置行索引的名称
frame.columns.names = ["state", "color"]  # 设置列索引的名称
frame  # 显示 DataFrame

frame.index.nlevels #查看行索引的层数

frame["Ohio"]  # 选择列索引为 "Ohio" 的组

frame.swaplevel("key1", "key2")  # 交换行索引的 "key1" 和 "key2" 级别

frame.sort_index(level=1)  # 按行索引的第 1 级（key2）排序

frame.swaplevel(0, 1).sort_index(level=0)  # 先交换行索引的 0 和 1 级，然后按第 0 级排序

frame.groupby(level="key2").sum()  # 按行索引的 "key2" 级别分组，并计算每组的和

frame.groupby(level="color", axis="columns").sum()  # 按列索引的 "color" 级别分组，并计算每组的和

frame = pd.DataFrame({"a": range(7),  # 创建一个 DataFrame，列 "a" 的值为 0-6
                      "b": range(7, 0, -1),  # 列 "b" 的值为 7-1
                      "c": ["one", "one", "one", "two", "two",
                            "two", "two"],  # 列 "c" 的值为字符串
                      "d": [0, 1, 2, 0, 1, 2, 3]})  # 列 "d" 的值为 0-3
frame  # 显示 DataFrame

frame2 = frame.set_index(["c", "d"])  # 使用 "c" 和 "d" 列作为索引
frame2  # 显示新的 DataFrame

frame.set_index(["c", "d"], drop=False)  # 使用 "c" 和 "d" 列作为索引，并保留这些列

frame2.reset_index()  # 将分层索引移动到列中，并创建一个默认的整数索引

df1 = pd.DataFrame({"key": ["b", "b", "a", "c", "a", "a", "b"],  # DataFrame 1，包含 "key" 列
                    "data1": pd.Series(range(7), dtype="Int64")})  # 和 "data1" 列
df2 = pd.DataFrame({"key": ["a", "b", "d"],  # DataFrame 2，包含 "key" 列
                    "data2": pd.Series(range(3), dtype="Int64")})  # 和 "data2" 列

df1  # 显示 df1

df2  # 显示 df2

pd.merge(df1, df2)  # 合并 df1 和 df2，自动使用 "key" 列作为连接键
# 或者 pd.merge(df1, df2, on="key")  # 显式指定连接键为 "key"

df3 = pd.DataFrame({"lkey": ["b", "b", "a", "c", "a", "a", "b"],  # DataFrame 3，包含 "lkey" 列
                    "data1": pd.Series(range(7), dtype="Int64")})  # 和 "data1" 列
df4 = pd.DataFrame({"rkey": ["a", "b", "d"],  # DataFrame 4，包含 "rkey" 列
                    "data2": pd.Series(range(3), dtype="Int64")})  # 和 "data2" 列
pd.merge(df3, df4, left_on="lkey", right_on="rkey")  # 使用 "lkey" 和 "rkey" 作为连接键

pd.merge(df1, df2, how="outer")  # 执行外连接，包含所有键

df1 = pd.DataFrame({"key": ["b", "b", "a", "c", "a", "b"],  # DataFrame 1
                    "data1": pd.Series(range(6), dtype="Int64")})
df2 = pd.DataFrame({"key": ["a", "b", "a", "b", "d"],  # DataFrame 2
                    "data2": pd.Series(range(5), dtype="Int64")})

pd.merge(df1, df2, on="key", how="left")  # 左连接

left = pd.DataFrame({"key1": ["foo", "foo", "bar"],  # 左侧 DataFrame
                     "key2": ["one", "two", "one"],
                     "lval": pd.Series([1, 2, 3], dtype='Int64')})
right = pd.DataFrame({"key1": ["foo", "foo", "bar", "bar"],  # 右侧 DataFrame
                      "key2": ["one", "one", "one", "two"],
                      "rval": pd.Series([4, 5, 6, 7], dtype='Int64')})
pd.merge(left, right, on=["key1", "key2"], how="outer")  # 使用 "key1" 和 "key2" 作为连接键，执行外连接

pd.merge(left, right, on="key1")  # 自动添加后缀 "_x" 和 "_y"

pd.merge(left, right, on="key1", suffixes=("_left", "_right"))  # 自定义后缀

left1 = pd.DataFrame({"key": ["a", "b", "a", "a", "b", "c"],  # 左侧 DataFrame
                      "value": pd.Series(range(6), dtype="Int64")})
right1 = pd.DataFrame({"group_val": [3.5, 7]}, index=["a", "b"])  # 右侧 DataFrame，使用索引

pd.merge(left1, right1, left_on="key", right_index=True)  # 将 left1 的 "key" 列与 right1 的索引合并

lefth = pd.DataFrame({"key1": ["Ohio", "Ohio", "Ohio",
                            "Nevada", "Nevada"],  # 左侧 DataFrame
                    "key2": [2000, 2001, 2002, 2001, 2002],
                    "data": pd.Series(range(5), dtype="Int64")})
righth_index = pd.MultiIndex.from_arrays([  # 右侧 DataFrame 的 MultiIndex
    ["Nevada", "Nevada", "Ohio", "Ohio", "Ohio", "Ohio"],
    [2001, 2000, 2000, 2000, 2001, 2002]
    ])
righth = pd.DataFrame({"event1": pd.Series([0, 2, 4, 6, 8, 10], dtype="Int64",
                                        index=righth_index),  # 使用 MultiIndex
                    "event2": pd.Series([1, 3, 5, 7, 9, 11], dtype="Int64",
                                        index=righth_index)})

pd.merge(lefth, righth, left_on=["key1", "key2"], right_index=True, how="outer")  # 基于多个列和索引合并

left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],
                     index=["a", "c", "e"],  # 左侧 DataFrame
                     columns=["Ohio", "Nevada"]).astype("Int64")
right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],
                      index=["b", "c", "d", "e"],  # 右侧 DataFrame
                      columns=["Missouri", "Alabama"]).astype("Int64")
left2.join(right2, how="outer")  # 基于索引连接

left1.join(right1, on="key")  # 将 left1 与 right1 基于 left1 的 "key" 列连接

arr = np.arange(12).reshape((3, 4))  # 创建一个 3x4 的数组
np.concatenate([arr, arr], axis=1)  # 沿着列连接

s1 = pd.Series([0, 1], index=["a", "b"], dtype="Int64")  # Series 1
s2 = pd.Series([2, 3, 4], index=["c", "d", "e"], dtype="Int64")  # Series 2
s3 = pd.Series([5, 6], index=["f", "g"], dtype="Int64")  # Series 3
pd.concat([s1, s2, s3])  # 沿着行连接 Series

pd.concat([s1, s2, s3], axis="columns")  # 沿着列连接 Series，生成 DataFrame

s4 = pd.concat([s1, s3])  # 连接 s1 和 s3
pd.concat([s1, s4], axis="columns", join="inner")  # 沿着列连接 s1 和 s4，执行内连接

result = pd.concat([s1, s1, s3], keys=["one", "two", "three"])  # 连接并创建分层索引
result  # 显示结果

result.unstack()  # 将结果转换为 DataFrame

df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=["a", "b", "c"],  # DataFrame 1
                   columns=["one", "two"])
df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=["a", "c"],  # DataFrame 2
                   columns=["three", "four"])
pd.concat([df1, df2], axis="columns", keys=["level1", "level2"])  # 沿着列连接，并使用 keys 作为列标题

a = pd.Series([np.nan, 2.5, 0.0, 3.5, 4.5, np.nan],  # Series a，包含 NaN 值
              index=["f", "e", "d", "c", "b", "a"])
b = pd.Series([0., np.nan, 2., np.nan, np.nan, 5.],  # Series b，包含 NaN 值
              index=["a", "b", "c", "d", "e", "f"])
np.where(pd.isna(a), b, a)  # 如果 a 中有 NaN，则使用 b 中的值，否则使用 a 中的值

a.combine_first(b)  # 使用 b 中的值填充 a 中的 NaN 值，按索引对齐

df1 = pd.DataFrame({"a": [1., np.nan, 5., np.nan],  # DataFrame 1，包含 NaN 值
                    "b": [np.nan, 2., np.nan, 6.],
                    "c": range(2, 18, 4)})
df2 = pd.DataFrame({"a": [5., 4., np.nan, 3., 7.],  # DataFrame 2，包含 NaN 值
                    "b": [np.nan, 3., 4., 6., 8.]})
df1.combine_first(df2)  # 使用 df2 中的值填充 df1 中的 NaN 值，逐列进行

data = pd.DataFrame(np.arange(6).reshape((2, 3)),  # 创建一个 2x3 的 DataFrame
                    index=pd.Index(["Ohio", "Colorado"], name="state"),  # 行索引，名为 "state"
                    columns=pd.Index(["one", "two", "three"],
                    name="number"))  # 列索引，名为 "number"
data  # 显示 DataFrame

result = data.stack()  # 将 DataFrame 转换为 Series，列索引变为内层行索引
result  # 显示 Series

result.unstack()  # 将 Series 转换回 DataFrame，内层行索引变为列索引

result.unstack(level=0)  # 将外层行索引（"state"）unstack 到列
# 或 result.unstack("state")  # 使用名称指定要 unstack 的级别

s1 = pd.Series([0, 1, 2, 3], index=["a", "b", "c", "d"], dtype="Int64")  # Series 1
s2 = pd.Series([4, 5, 6], index=["c", "d", "e"], dtype="Int64")  # Series 2
data2 = pd.concat([s1, s2], keys=["one", "two"])  # 连接 s1 和 s2，并创建分层索引
data2.unstack().stack(dropna=False)  # 先 unstack，再 stack，并保留 NaN 值

df = pd.DataFrame({"left": result, "right": result + 5},  # 创建一个 DataFrame
                  columns=pd.Index(["left", "right"], name="side"))  # 列索引，名为 "side"
df  # 显示 DataFrame

df.unstack(level="state").stack(level="side")  # 先按 "state" 级别 unstack，再按 "side" 级别 stack

data = pd.read_csv("examples/macrodata.csv")  # 从 CSV 文件读取数据
data = data.loc[:, ["year", "quarter", "realgdp", "infl", "unemp"]]  # 选择特定的列
periods = pd.PeriodIndex(year=data.pop("year"),  # 创建一个 PeriodIndex
                        quarter=data.pop("quarter"),
                        name="date")
data.index = periods.to_timestamp("D")  # 将 PeriodIndex 转换为 Timestamp，并设置为索引
data = data.reindex(columns=["realgdp", "infl", "unemp"])  # 重新设置列的顺序
data.columns.name = "item"  # 设置列索引的名称
long_data = (data.stack()  # 将 DataFrame 转换为 Series
                .reset_index()  # 重置索引
                .rename(columns={0: "value"}))  # 重命名列
long_data[:10]  # 显示前 10 行

pivoted = long_data.pivot(index="date", columns="item",
                          values="value")  # 将长格式数据透视为宽格式
pivoted.head()  # 显示前几行

long_data["value2"] = np.random.standard_normal(len(long_data))  # 添加一个新的值列
pivoted = long_data.pivot(index="date", columns="item")  # 透视，不指定 values 参数
pivoted.head()  # 显示前几行，现在有分层列

unstacked = long_data.set_index(["date", "item"]).unstack(level="item")  # 先设置索引，再 unstack
unstacked.head()  # 显示前几行

df = pd.DataFrame({"key": ["foo", "bar", "baz"],  # 创建一个 DataFrame
                   "A": [1, 2, 3],
                   "B": [4, 5, 6],
                   "C": [7, 8, 9]})
melted = pd.melt(df, id_vars="key")  # 将 DataFrame 从宽格式转换为长格式
melted  # 显示结果

pd.melt(df, id_vars="key", value_vars=["A", "B"])  # 指定要取消透视的列

pd.melt(df, value_vars=["A", "B", "C"])  # 不指定组指示器列

pd.melt(df, value_vars=["key", "A", "B"])  # `value_vars` 也可以包含组标识符

reshaped = melted.pivot(index="key", columns="variable",
                        values="value")  # 使用 pivot 将数据恢复到类似原始布局
reshaped  # 显示结果

reshaped.reset_index()  # 将索引移回列中