Pandas

import pandas as pd
import numpy as np

s = pd.Series([10, 20, 30, 40, 50], index=list('abcde'), name='销量')
s.index                            # 输出: Index(['a', 'b', 'c', 'd', 'e'], dtype='str')
s.dtype, s.name, s.shape           # 输出: (dtype('int64'), '销量', (5,))
s['a'], s.iloc[0]                  # 输出: 10  10（按标签取值 / 按位置取值）
s * 2                              # 输出: a 20  b 40  c 60  d 80  e 100（运算按 index 对齐）
s.mean(), s.sum(), s.max()         # 输出: 30.0  150  50

df = pd.DataFrame({'姓名': ['张三', '李四', '王五'],
                   '年龄': [25, 30, 28],
                   '城市': ['北京', '上海', '深圳']})
df.shape, list(df.columns), list(df.index)   # 输出: ((3, 3), ['姓名', '年龄', '城市'], [0, 1, 2])
df.dtypes                          # 输出: 姓名 str / 年龄 int64 / 城市 str（3.x 字符串是 str，不是 object）
df['年龄']                         # 输出: 单列 → Series（dtype int64）
df[['姓名', '年龄']]                # 输出: 多列 → DataFrame（注意双层方括号）
df.loc[0]                          # 输出: 第一行 → Series，各列被向上提升为 object
df.loc[0, '年龄']                   # 输出: 25（标量）
df.loc[df['年龄'] > 26]             # 输出: 李四 30 / 王五 28（布尔掩码选行）

df = pd.DataFrame({'产品': ['手机', '电脑', '平板'],
                   '销量': [120, 80, 45],
                   '单价': [2999, 5999, 1999]})
df['销售额'] = df['销量'] * df['单价']   # 新增列：逐元素运算，不需要写循环
df['销售额'].sum()                       # 输出: 929755
df.head(2)                               # 输出: 前 2 行（tail(2) 看末尾）
df.info()                                # 输出: 行数、列数、每列 dtype 与非空计数
df.describe()                            # 输出: 数值列的 count/mean/std/min/四分位/max
df.sort_values('销售额', ascending=False) # 输出: 降序新对象，原 df 不变
df = df.reset_index(drop=True)           # 输出: 索引重排为 0..n-1，旧索引丢弃
df.to_csv('out.csv', index=False, encoding='utf-8-sig')   # 落盘，Excel 打开不乱码

df = pd.DataFrame({'姓名': ['张三', '李四', '张三', None],
                   '年龄': [25, np.nan, 25, 40],
                   '城市': ['北京', '', '北京', '深圳']})

df.isna().sum()                                        # 输出: 姓名 1 / 年龄 1 / 城市 0（'' 不算缺失）
df.isna().any()                                        # 输出: 每列是否含缺失（布尔 Series）
df.dropna(subset=['年龄'])                              # 输出: 只丢「年龄」为空的行
df['年龄'] = df['年龄'].fillna(df['年龄'].median())      # 用中位数补单列
df['城市'] = df['城市'].replace('', np.nan).ffill()      # 空串先变 NaN，再前向填充
df = df.drop_duplicates(subset=['姓名'], keep='last')    # 同名保留最后一次出现的行
df = df.reset_index(drop=True)                         # 删行后索引会断，重排成 0..n-1

pd.set_option('display.max_columns', 50)   # 宽表不再被折叠
pd.set_option('display.width', 120)        # 单行可容纳更多字符
pd.set_option('display.precision', 2)      # 浮点显示 2 位
pd.options.display.max_colwidth = 60       # 等价的属性式写法
pd.get_option('display.precision')         # 输出: 2（读回当前值）
pd.reset_option('display.precision')       # 恢复默认
pd.describe_option('display.max_rows')     # 输出: 该项的说明与默认值

with pd.option_context('display.max_rows', None, 'display.precision', 4):
    df                                     # 只在 with 内临时生效，退出自动还原

arr2 = np.arange(6).reshape(2, 3)
df2 = pd.DataFrame(arr2, columns=list('ABC'))  # ndarray → DataFrame，索引 0..1
df2.to_numpy()                                 # 输出: array([[0, 1, 2], [3, 4, 5]])
np.array(df2)                                  # 输出: 同上（等价路径）
df2['A'].to_numpy()                            # 输出: array([0, 3])（1D，索引被丢弃）

mix = pd.DataFrame({'年龄': [25, 30, 28], '城市': ['北京', '上海', '深圳']})
mix['年龄'].to_numpy()                         # 输出: array([25, 30, 28])（dtype 保留）
mix.to_numpy().dtype                           # 输出: dtype('O')（异构列被统一成 object）
mix.to_numpy(na_value=0)                       # np.array(mix) 做不到：还能把 NaN 换成 0
mix.select_dtypes('number').to_numpy(dtype='float64')   # 输出: 只取数值列的纯浮点数组

import pandas as pd
import numpy as np

pd.set_option('display.max_columns', 50)
pd.set_option('display.width', 120)
pd.set_option('display.precision', 2)

pd.__version__                          # 输出: '3.x.x'
pd.get_option('display.max_columns')    # 输出: 50
pd.get_option('display.precision')      # 输出: 2

wide = pd.DataFrame(np.arange(120).reshape(3, 40))   # 40 列的宽表
wide.shape                              # 输出: (3, 40)
wide.iloc[:, :6]                        # 输出: 前 6 列（40 列全开时仍会折叠，按需再调 max_columns）

df = pd.DataFrame({'姓名': ['张三', '李四', '王五'], '年龄': [25, 30, 28]})
df.dtypes                               # 输出: 姓名 str；年龄 int64（3.x 字符串是 str，不是 object）
df['姓名'].dtype == 'str'                # 输出: True
pd.reset_option('display.precision')    # 还原单项设置

import pandas as pd
import numpy as np

df = pd.DataFrame({
    '日期': pd.to_datetime(['2024-03-01', '2024-03-01', '2024-03-02', '2024-03-02', '2024-03-03']),
    '产品': ['手机', '电脑', '手机', '平板', '电脑'],
    '销量': [5, 3, np.nan, 4, 6],
    '单价': [3000, 5000, 3000, 2000, 5000],
    '城市': [None, '上海', '北京', '深圳', '上海'],
})

df.isna().sum()                              # 输出: 销量 1；城市 1
df['销量'] = df['销量'].fillna(df['销量'].median())   # 输出: 中位数 4.5 补进第 3 行
df['城市'] = df['城市'].ffill()               # 输出: 首行是 NaN，前向填不到 → 仍是 NaN
df.loc[df['城市'].isna(), '城市'] = '未知'     # 安全赋值：先算掩码，再 .loc 定位写入
df['销售额'] = df['销量'] * df['单价']         # 输出: 15000 15000 13500 8000 30000
df.loc[df['销售额'] > 15000, '等级'] = 'A'     # 条件赋值，未命中的行留 NaN
df['等级'] = df['等级'].fillna('B')           # 输出: 补成 B B B B A
df.groupby('产品')['销售额'].sum()            # 输出: 手机 28500 / 电脑 45000 / 平板 8000
df.loc[df['销售额'].idxmax(), ['日期', '产品', '销售额']]   # 输出: 2024-03-03 电脑 30000
df.select_dtypes('number').to_numpy()        # 输出: 数值列的纯 ndarray，无日期/无字符串
df.to_csv('orders.csv', index=False, encoding='utf-8-sig')   # 落盘，Excel 打开不乱码

import pandas as pd
import numpy as np

s = pd.Series([85, 92, 78, 95, 88],
              index=['张三', '李四', '王五', '赵六', '孙七'],
              name='成绩')
s.index.name = '学生'
s                 # 输出: 张三 85 / 李四 92 / 王五 78 / 赵六 95 / 孙七 88；Name: 成绩, dtype: int64

pd.Series([10, 20, 30])                                   # 输出: 0→10 1→20 2→30，dtype: int64
pd.Series({'a': 10, 'b': 20})                             # 输出: a→10 b→20
pd.Series({'a': 10, 'b': 20}, index=['b', 'a', 'z'])      # 输出: b→20.0 a→10.0 z→NaN（z 不存在 → 缺失，dtype 变 float64）
pd.Series(np.arange(3), index=['a', 'b', 'c'])            # 输出: a→0 b→1 c→2
pd.Series(9.9, index=['产品A', '产品B'])                   # 输出: 两行都是 9.9（标量广播）
pd.Series([1, 2, 3], dtype='float64')                     # 输出: dtype: float64
pd.Series([1, 2, None], dtype='Int64')                    # 输出: 1 2 <NA>（可空整型，缺失用 pd.NA）
pd.Series(['A', 'B']).dtype                               # 输出: str（3.x 默认字符串 dtype，不再是 object）
pd.Series([1, 2, 'x']).dtype                              # 输出: object（混合类型退回 object，应尽量避免）

g = pd.Series(['A', 'B', 'A', 'C', 'B', 'A'])

g.unique()                          # 输出: ['A' 'B' 'C']
g.nunique()                         # 输出: 3
g.value_counts()                    # 输出: A 3 / B 2 / C 1
g.value_counts(normalize=True)      # 输出: A 0.5 / B 0.333333 / C 0.166667
g.isin(['A', 'C'])                  # 输出: True False True True False True
g[~g.isin(['A'])]                   # 输出: B / C / B
g.sample(2, random_state=42)        # 输出: 随机 2 个（random_state 固定即可复现）

s.sort_values(ascending=False)      # 输出: 赵六 95 / 李四 92 / 孙七 88 / 张三 85 / 王五 78
s.sort_index()                      # 输出: 按姓名排序（索引需同类型，否则先统一 dtype）
s.rank(ascending=False, method='min')  # 输出: 赵六 1.0 / 李四 2.0 / 孙七 3.0 / 张三 4.0 / 王五 5.0
s.describe()                        # 输出: count 5 / mean 87.6 / std 6.58 / min 78 / 25% 85 / 50% 88 / 75% 92 / max 95
s.head(2), s.tail(2)                # 输出: 张三 85 / 李四 92 ；赵六 95 / 孙七 88

s.astype('float64')                 # 输出: 85.0 92.0 ...（dtype: float64）
s.drop(index=['张三'])              # 输出: 去掉张三的 4 行新 Series
s.rename(index={'张三': 'Zhang'})   # 输出: 索引标签被替换
s.rename('期末成绩')                # 输出: 只改 name（传标量 = 改名，传 dict = 改标签）
s.rename_axis('姓名')               # 输出: 索引名变为「姓名」
s.reset_index()                     # 输出: DataFrame，两列（姓名 / 成绩）
s.reset_index(drop=True)            # 输出: Series，索引重置为 0..n-1
s.set_axis(['a', 'b', 'c', 'd', 'e', 'f'])   # 输出: 索引整体替换（长度须一致）

a = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
b = pd.Series([1, 2, 4], index=['a', 'b', 'd'])

a + b                       # 输出: a 11.0 / b 22.0 / c NaN / d NaN（索引取并集，对不上的补 NaN）
a * 2, a - a.mean(), a ** 2  # 输出: [20 40 60]；[-10. 0. 10.]；[100 400 900]（标量运算保留索引）
(a / 3).round(2)            # 输出: a 3.33 / b 6.67 / c 10.0
np.sqrt(a)                  # 输出: a 3.162 / b 4.472 / c 5.477（NumPy 通用函数直接可用）
a > 15                      # 输出: a False / b True / c True
a.add(b, fill_value=0)      # 输出: a 11.0 / b 22.0 / c 30.0 / d 4.0（缺失侧当 0 再算）
a.sub(b, fill_value=0), a.mul(b, fill_value=1), a.div(b, fill_value=1)   # 同样支持 fill_value

s[s >= 90]                          # 输出: 李四 92 / 赵六 95
s[(s >= 80) & (s < 95)]             # 输出: 张三 85 / 李四 92 / 孙七 88（且：&，每个条件必须加括号）
s[(s < 80) | (s > 92)]              # 输出: 王五 78 / 赵六 95（或：|）
s[s != 92]                          # 输出: 除李四外全部
s[~s.index.isin(['王五'])]           # 输出: 去掉王五（按标签排除）
s.where(s >= 85)                    # 输出: 张三 85 / 李四 92 / 王五 NaN / 赵六 95 / 孙七 88（不满足 → NaN）
s.where(s >= 85, 0)                 # 输出: 不满足的位置填 0
s.mask(s >= 85)                     # 输出: 满足条件的被置 NaN（与 where 相反）
s.mask(s >= 85, -1)                 # 输出: 满足条件的被置 -1
s.clip(lower=80, upper=90)          # 输出: 全部截断到 [80, 90]
s.loc[s >= 90] = 100                # 写入：用 .loc，别写 s[s >= 90][...] = 100

t = pd.Series([1, np.nan, np.nan, 4, np.nan, 6])

t.isna(), t.notna()         # 输出: 布尔 Series（isnull/notnull 是等价别名，建议统一用 isna/notna）
t.isna().sum(), t.hasnans   # 输出: 3  True
t.dropna()                  # 输出: 1.0 / 4.0 / 6.0（索引保留原标签）
t.fillna(0)                 # 输出: 1.0 0.0 0.0 4.0 0.0 6.0
t.fillna(t.mean())          # 输出: 缺的都填 3.666667（mean 已跳过 NaN）
t.ffill()                   # 输出: 1.0 1.0 1.0 4.0 4.0 6.0（用前一个有效值）
t.bfill()                   # 输出: 1.0 4.0 4.0 4.0 6.0 6.0（用后一个有效值）
t.ffill(limit=1)            # 输出: 1.0 1.0 NaN 4.0 4.0 6.0（最多连续填 1 个）
t.interpolate()             # 输出: 1.0 2.0 3.0 4.0 5.0 6.0（线性插值，按位置等距）
t.replace(-999, np.nan)     # 输出: 把哨兵值 -999 换成 NaN（先清洗再统计）

arr = s.to_numpy()                          # Series → ndarray（含扩展 dtype 时比 .values 稳）
pd.Series(arr, index=s.index)               # ndarray → Series

d = s.to_dict()                             # 输出: {'张三': 85, '李四': 92, ...}（Series → dict，标签须唯一）
pd.Series(d)                                # dict → Series（键变索引）

df = s.to_frame('成绩')                     # Series → DataFrame（列名即 name）
df['成绩']                                  # DataFrame 取一列 → Series（视图语义）
df['成绩'].copy()                           # 想独立修改就显式 copy
df.loc[:, '成绩'] = df['成绩'] * 2          # 写回必须走 .loc，不要 df['成绩'][0] = ...

s.to_list()                                 # 输出: [85, 92, 78, 95, 88]（转 Python list）
list(s.items())                             # 输出: [('张三', 85), ...]（(标签, 值) 对，可直接 for 遍历）
pd.concat([a, b])                           # 多个 Series 纵向拼接（索引不去重，可重复）

import pandas as pd

scores = pd.Series(
    {'张三': 85, '李四': 92, '王五': 78, '赵六': 95, '孙七': 88,
     '周八': 76, '吴九': 90, '郑十': 82, '钱一': 91, '孙二': 87},
    name='成绩')
scores.index.name = '学生'

scores.describe()                     # 输出: count 10 / mean 86.4 / std 6.17 / min 76 / 25% 82.75 / 50% 87.5 / 75% 90.75 / max 95
scores.mean(), scores.median()        # 输出: 86.4  87.5
(scores >= 60).mean() * 100           # 输出: 100.0（及格率：布尔当 0/1 求均值）
(scores >= 90).sum()                  # 输出: 3（优秀人数：布尔求和）
scores.nlargest(3)                    # 输出: 赵六 95 / 李四 92 / 钱一 91
scores.rank(ascending=False, method='min').astype('int64')   # 输出: 赵六 1 / 李四 2 / 钱一 3 / 吴九 4 / 孙七 5 / 孙二 6 / 张三 7 / 郑十 8 / 王五 9 / 周八 10
scores[scores > scores.mean()]        # 输出: 李四 92 赵六 95 孙七 88 吴九 90 钱一 91 孙二 87（共 6 人高于均分）

grades = pd.cut(scores, [0, 60, 70, 80, 90, 100], labels=['F', 'D', 'C', 'B', 'A'])   # 默认右闭区间，90 分落 B 档
grades.value_counts().sort_index()    # 输出: A 2 / B 5 / C 2 / D 0 / F 0
scores[grades == 'C']                 # 输出: 王五 78 / 周八 76（C 档名单）
scores.sort_values(ascending=False).head(3).to_dict()   # 输出: {'赵六': 95, '李四': 92, '钱一': 91}

import pandas as pd

qty = pd.Series({'苹果': 150, '香蕉': 200, '橙子': 120, '葡萄': 80}, name='销量(斤)')
price = pd.Series({'苹果': 5.5, '香蕉': 3.2, '葡萄': 8.9, '西瓜': 2.5}, name='单价(元/斤)')

qty.index.equals(price.index)          # 输出: False ← 运算前必须体检
qty.index.difference(price.index)      # 输出: Index(['橙子'])（有销量没单价）
price.index.difference(qty.index)      # 输出: Index(['西瓜'])（有单价没销量）

qty * price                            # 输出: 苹果 825.0 / 香蕉 640.0 / 橙子 NaN / 葡萄 712.0 / 西瓜 NaN（不对齐 → NaN，不报错）
qty.mul(price, fill_value=0)           # 输出: 橙子 0.0 / 西瓜 0.0（缺的一侧当 0 再乘）

full_price = price.reindex(qty.index.union(price.index))   # 输出: 苹果 5.5 / 香蕉 3.2 / 橙子 NaN / 葡萄 8.9 / 西瓜 2.5
full_price = full_price.fillna(full_price.mean())          # 输出: 橙子 5.025（缺单价用均价 5.025 兜底）

revenue = (qty * full_price).dropna().sort_values(ascending=False)   # 输出: 苹果 825.0 / 葡萄 712.0 / 香蕉 640.0 / 橙子 603.0
revenue.sum()                          # 输出: 2780.0
revenue.idxmax(), revenue.max()        # 输出: 苹果  825.0
(revenue / revenue.sum() * 100).round(1)   # 输出: 苹果 29.7 / 葡萄 25.6 / 香蕉 23.0 / 橙子 21.7
revenue.cumsum().round(1)              # 输出: 苹果 825.0 / 葡萄 1537.0 / 香蕉 2177.0 / 橙子 2780.0

import pandas as pd
import numpy as np

temp = pd.Series([22.5, np.nan, np.nan, 25.5, np.nan, 27.0, 26.8],
                 index=['周一', '周二', '周三', '周四', '周五', '周六', '周日'],
                 name='气温(℃)')

temp.hasnans, temp.isna().sum()        # 输出: True  3（先量缺口）
temp.ffill()                           # 输出: 22.5 22.5 22.5 25.5 25.5 27.0 26.8（用前一天顶）
temp.bfill()                           # 输出: 22.5 25.5 25.5 25.5 27.0 27.0 26.8（用后一天顶）
temp.ffill(limit=1)                    # 输出: 22.5 22.5 NaN 25.5 25.5 27.0 26.8（最多连续顶 1 天）
t = temp.interpolate()                 # 输出: 22.5 23.5 24.5 25.5 26.25 27.0 26.8（线性插值，最贴合连续量）

t.mean().round(2), t.std().round(2)    # 输出: 25.15  1.66（均温 / 标准差）
t.idxmax(), t.max(), t.idxmin(), t.min()   # 输出: 周六  27.0  周一  22.5
(t - t.mean()).round(2)                # 输出: -2.65 -1.65 -0.65 0.35 1.10 1.85 1.65（距平）
t.diff().round(2)                      # 输出: NaN 1.0 1.0 1.0 0.75 0.75 -0.20（日环比，首日为 NaN）
t.rolling(3).mean().round(2)           # 输出: NaN NaN 23.5 24.5 25.42 26.25 26.68（3 日滑动平均）
t.where(t >= t.mean())                 # 输出: 低于均温的日子置 NaN（周四 25.5 周五 26.25 周六 27.0 周日 26.8 保留）
t[t > t.mean()].index.to_list()        # 输出: ['周四', '周五', '周六', '周日']（偏热日）
t.describe().round(2)                  # 输出: count 7 / mean 25.15 / std 1.66 / min 22.5 / 25% 23.5 / 50% 25.5 / 75% 26.53 / max 27.0

import pandas as pd
import numpy as np

df = pd.DataFrame({'姓名': ['张三', '李四', '王五'],
                   '年龄': [25, 30, 28],
                   '工资': [8000, 12000, 10000]})
df                                        # 输出: 3 行 × 3 列的表，行索引为 RangeIndex(0, 3)
type(df)                                  # 输出: <class 'pandas.core.frame.DataFrame'>

d = {'姓名': ['张三', '李四'], '年龄': [25, 30], '城市': ['北京', '上海']}
pd.DataFrame(d, index=['a', 'b'])                     # 输出: 行标签变 a / b
pd.DataFrame(d, columns=['城市', '姓名'])              # 输出: 只留 2 列且顺序被改为 城市、姓名
pd.DataFrame(d, columns=['城市', '工号'])              # 输出: '工号' 不存在 → 整列 NaN

pd.DataFrame([[1, 'x'], [2, 'y']], columns=['a', 'b'])
pd.DataFrame(np.arange(6).reshape(3, 2), columns=['a', 'b'], dtype='float32')   # dtype 全局指定
pd.DataFrame(d).dtypes                                # 输出: 姓名 str / 年龄 int64 / 城市 str

s_name = pd.Series(['张三', '李四'], index=['a', 'b'])
s_age  = pd.Series([25], index=['a'])
pd.DataFrame({'姓名': s_name, '年龄': s_age})          # 输出: b 行年龄为 NaN（按索引对齐）

pd.DataFrame()                                        # 输出: 完全空表，columns=[] index=[]
pd.DataFrame(columns=['a', 'b'])                      # 输出: 有列名无数据行
pd.DataFrame(index=range(3), columns=['a', 'b'])      # 输出: 3×2 全 NaN 的占位表

df.shape, df.size, df.ndim, df.empty        # 输出: ((3, 3), 9, 2, False)
df.shape[0], df.shape[1]                    # 输出: (3, 3)  行数、列数
df.index.tolist()                           # 输出: [0, 1, 2]
df.columns.tolist()                         # 输出: ['姓名', '年龄', '工资']
df.axes                                     # 输出: [RangeIndex(0,3), Index(['姓名','年龄','工资'])]
df.values.shape                             # 输出: (3, 3)
df.T.index.tolist()                         # 输出: ['姓名', '年龄', '工资']（转置后原列名变行标签）
df.dtypes                                   # 输出: 姓名 str / 年龄 int64 / 工资 int64
df['姓名'].dtype                            # 输出: str（Pandas 3 默认，非 object）
df.dtypes.value_counts()                    # 输出: int64 2 / str 1

df.head(2), df.tail(1)                      # 输出: 前 2 行 / 最后 1 行
df.sample(2, random_state=0)                # 输出: 随机抽 2 行，结果可复现
df.info(memory_usage='deep')                # 输出: 3 entries, 3 columns，各列 non-null 计数与 dtype
df.describe()                               # 输出: 数值列的 count mean std min 25% 50% 75% max
df.describe(include='all')                  # 输出: 追加 unique / top / freq 三行
df.nunique()                                # 输出: 姓名 3 / 年龄 3 / 工资 3
df['年龄'].unique()                         # 输出: [25 30 28]（单列取值数组）
df.memory_usage(deep=True).sum()            # 输出: 各列真实字节数之和（不加 deep 会低估文本列）
df.isna().sum()                             # 输出: 每列缺失值个数

df['姓名'], df[['姓名']]                    # 输出: Series / DataFrame（双层方括号保二维）
df[['姓名', '工资']]                        # 输出: 选多列，同时也是调整列顺序

df2 = df.copy()
df2['国家'] = '中国'                        # 标量广播给所有行
df2['年薪'] = df2['工资'] * 12              # 向量化计算
df2['等级'] = pd.cut(df2['工资'], [0, 10000, np.inf], labels=['中', '高'])
df2.insert(1, '性别', ['男', '女', '男'])   # 插到第 1 个位置（原地修改）
df2.assign(奖金=lambda x: x['工资'] * 0.1, 总收入=lambda x: x['工资'] * 1.1)   # 返回新 DF，df2 不变
df2.rename(columns={'工 资': '工资'}, errors='raise')   # 输出: 键对不上直接报错，防止静默漏改
df2.rename(columns=str.upper).columns.tolist()          # 输出: 全大写列名列表

df2.drop(columns=['国家'])                  # 输出: 新表，原 df2 仍在
df2.pop('年薪')                             # 输出: 被弹出的 Series，同时 df2 少一列
# del df2['等级']                          # 原地删，无返回值

df2.set_index('姓名')                       # 输出: '姓名' 变行索引，并从列中移除
df2.set_index('姓名').reset_index()         # 输出: 索引退回普通列
df2.set_index('姓名').reset_index(drop=True)   # 输出: 丢弃旧标签，重排 RangeIndex

sub = df.head(3).set_index('姓名')
sub.loc['李四'], sub.loc[['李四']]           # 输出: Series / DataFrame
sub.loc['李四':'王五']                      # 输出: 标签切片，右端点包含
sub.iloc[0], sub.iloc[0:2]                  # 输出: Series / DataFrame；位置切片右端点不包含
sub.iloc[[0, 2]], sub.iloc[:, :2]           # 输出: 第 1、3 行 / 所有行的前两列

sub.drop(index=['李四'])                    # 输出: 按标签删行
sub.drop(sub.index[0])                      # 输出: 按位置删行（先换算成标签）
df[df['工资'] > 9000]                       # 输出: 布尔筛选，条件间用 & | ~ 且各自加括号
df.query('工资 > 9000 and 年龄 < 30')       # 输出: 字符串表达式筛选
df.drop_duplicates(subset=['姓名'])         # 输出: 按列去重，保留首次出现

idx = pd.Index(['a', 'b', 'a'], name='key')
idx.name, idx.dtype, idx.is_unique          # 输出: ('key', dtype('str'), False)
idx.set_names(['K']).name                   # 输出: 'K'
idx.unique(), idx.value_counts()            # 输出: Index(['a','b']) / a 2, b 1
pd.Index(['a', 'b', 'c']).get_loc('b')      # 输出: 1（唯一索引返回标量位置）
idx.get_loc('a')                            # 输出: array([0, 2])（重复标签返回位置数组）
pd.RangeIndex(0, 1000).memory_usage()       # 输出: 远小于等效 Index

m = df.assign(部门=['技术', '销售', '技术']).set_index(['部门', '姓名'])
m.index.nlevels, m.index.names              # 输出: (2, FrozenList(['部门', '姓名']))
m.loc['技术']                               # 输出: 取外层标签，内层索引保留

df.to_numpy()                               # 输出: object 二维数组（str 与 int 混在一起被向上提升）
df[['年龄', '工资']].to_numpy()             # 输出: int64 二维数组（同类型才保住 dtype）
df[['年龄', '工资']].to_numpy(dtype='float64')   # 显式指定目标 dtype
df2 = df.assign(分数=[90.5, 88.0, np.nan])
df2[['分数']].to_numpy(na_value=-1)         # 输出: NaN 换成 -1（.values 做不到）

df.to_dict(orient='list')                   # 输出: {'姓名': [...], '年龄': [...], ...}
df.to_dict(orient='records')                # 输出: [{'姓名': '张三', ...}, ...]（喂给 API 常用）
pd.DataFrame(df.to_dict(orient='records'))  # 输出: records → 表，往返一致
df.columns.tolist(), df.index.tolist()      # 输出: 两个 Python list
df.values.tolist()                          # 输出: 嵌套 list（每行一个子列表）

a = df[['年龄']]                            # Pandas 3 CoW：惰性副本，改它不污染 df
b = df[['年龄']].copy()                     # 深拷贝：独立新内存，可安全改
c = df[['年龄']].copy(deep=False)           # 浅拷贝：共享底层 buffer

df.drop(columns=['工资'])                   # ✅ 返回新表，原表不变
df = df.drop(columns=['工资'])              # ✅ 用赋值替代 inplace
# df.drop(columns=['工资'], inplace=True)   # ❌ 不再有性能收益，且会在 CoW 下徒增心智负担

people = pd.DataFrame(
    {'姓名': ['张三', '李四', '王五', '赵六'], '部门': ['技术', '销售', '技术', '销售'],
     '入职年份': [2019, 2021, 2018, 2023], '基本工资': [18000, 12000, 22000, 9000]},
    columns=['姓名', '部门', '入职年份', '基本工资'], index=['E01', 'E02', 'E03', 'E04'],
)
people.insert(2, '性别', ['男', '女', '男', '女'])      # 指定位置插列
people = people.assign(工作年限=2026 - people['入职年份'], 年收入=lambda x: x['基本工资'] * 12)
people = people.rename(columns={'年收入': '年薪'}).set_index('姓名')   # 唯一标识上索引

people.shape, people.columns.tolist()      # 输出: (4, 6)  ['部门','性别','入职年份','基本工资','工作年限','年薪']
people.dtypes.value_counts()               # 输出: int64 4 / str 2
people.info(memory_usage='deep')           # 输出: 4 entries, 6 columns, 各列 non-null 4
people.describe()                          # 输出: 数值列的 count/mean/std/min/四分位/max
people.memory_usage(deep=True).sum()       # 输出: 含文本列真实开销的字节总数
people = people.astype({'基本工资': 'int32', '性别': 'category'})
people.memory_usage(deep=True).sum()       # 输出: 比上一行小（降整型精度 + 转 category）

records = [
    {'empId': 'E01', 'empName': '张三', 'dept': '技术', 'salary': 18000},
    {'empId': 'E02', 'empName': '李四', 'salary': 12000},              # 缺 dept
    {'empId': 'E03', 'empName': '王五', 'dept': '技术', 'salary': 22000},
]

raw = pd.DataFrame(records)                 # 缺字段的行自动补 NaN
clean = (raw.rename(columns={'empId': '工号', 'empName': '姓名', 'dept': '部门', 'salary': '薪资'})
            .reindex(columns=['工号', '姓名', '部门', '薪资'])   # 输出: 定列序；多余列丢弃，缺失补 NaN
            .set_index('工号'))
clean['部门'] = clean['部门'].ffill()       # 输出: Pandas 3 的前向填充；定值填用 fillna(value=...)
clean = clean.reset_index()                 # 索引退回普通列，便于导出

clean.columns.tolist()                      # 输出: ['工号', '姓名', '部门', '薪资']
clean.isna().sum()                          # 输出: 各部门缺失 0，其余同
clean.to_dict(orient='records')             # 输出: 清洗后的 records，可直接回传给调用方
clean.to_numpy()                            # 输出: object 二维数组（str 与 int 混合被提升）

rows = []
for city, sales in [('北京', 320), ('上海', 415), ('广州', 288)]:
    rows.append({'城市': city, '销售额': sales, '达成': sales >= 300})   # 只攒数据，不碰 DataFrame

perf = pd.DataFrame(rows).set_index('城市') # 输出: 一次性建表，O(n)
perf.loc['深圳'] = [260, False]             # 单行追加，值须覆盖全部列
perf = perf.assign(达成率=lambda x: (x['销售额'] / 300).round(2))

bottom = perf.drop(index=perf['销售额'].idxmin())   # 删掉销售额最低的城市
bottom.loc[:, '销售额']                     # 输出: Series（loc[:, '列'] 仍是 Series）
bottom.loc[:, ['销售额']]                   # 输出: DataFrame（双层方括号）
bottom.to_dict(orient='index')              # 输出: 索引作外层键，如 {'北京': {...}}

c = perf.copy()
c.loc[c['达成'], '销售额'] = c['销售额'] * 1.05     # ✅ 布尔掩码 + 单一 loc
# perf['销售额'][perf['达成']] = 0                  # ❌ 链式赋值

import pandas as pd
import numpy as np

df = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '赵六', '钱七', '孙八', '周九', '吴十'],
    '性别': ['男', '女', '男', '女', '男', '女', '男', '女'],
    '年龄': [18, 19, 18, 20, 19, 18, 20, 19],
    '班级': ['一班', '一班', '二班', '二班', '一班', '二班', '一班', '二班'],
    '数学': [85, 92, 78, 88, 95, 73, 90, 82],
    '英语': [90, 88, 85, 92, 87, 78, 93, 95],
    '物理': [78, 85, 92, 80, 88, 85, 82, 90],
})
df.shape                                 # 输出: (8, 7)

s = df.set_index('姓名')                 # 之后行标签为姓名
s.loc['张三', '数学']                    # 输出: 85（标量）
s.loc['张三']                            # 输出: Series（index 是列名，name='张三'）
s.loc[:, ['数学', '英语']]               # 输出: DataFrame（所有行，两列）
s.loc[['张三', '李四'], ['数学', '英语']] # 输出: 2×2
s.loc['张三':'王五']                     # 输出: 张三、李四、王五 3 行（**闭区间**）
s.loc[:, '数学':'英语']                  # 输出: 数学、英语 两列（同样闭区间）
s.loc[lambda d: d['数学'] > 90]          # 输出: 李四、钱七（callable 收到整个 DataFrame）
s.loc[s['数学'] > 90, '班级']            # 输出: 李四 一班 / 钱七 一班

df.iloc[0, 4]                            # 输出: 85（第 0 行第 4 列 = 张三的数学）
df.iloc[[0, 2]]                          # 输出: 第 0、2 行
df.iloc[[0, 0, 1]]                       # 输出: 位置可重复（第 0 行取两遍）
df.iloc[0:3, 4:6]                        # 输出: 3 行 × 2 列（半开区间）
df.iloc[-1, -1]                          # 输出: 90（最后一行最后一列）
df.iloc[:, 4:7].columns.tolist()         # 输出: ['数学', '英语', '物理']
rng = np.random.default_rng(0)
df.iloc[rng.choice(len(df), 3, replace=False)]      # 输出: 随机 3 行（比 sample 更可控）

mask = df['数学'] > 85                   # 输出: [F,T,F,T,T,F,T,F] 的 bool Series
df[mask]                                 # 输出: 李四、赵六、钱七、周九 4 行
df.loc[mask, ['姓名', '数学']]            # 输出: 同上但只留两列
df.loc[~mask, '数学']                    # 输出: 张三85 王五78 孙八73 吴十82
df[(df['数学'] > 85) & (df['英语'] > 90)]                    # 输出: 赵六、周九
df[(df['数学'] > 90) | (df['英语'] > 90)]                    # 输出: 李四、赵六、钱七、周九、吴十
df[~((df['数学'] > 85) & (df['英语'] > 90))]                 # 输出: 其余 6 行
df[(df['数学'] > 85) & (df['英语'] > 85) & (df['物理'] > 85)] # 输出: 钱七
df[df['姓名'].isin(['张三', '李四', '王五'])]                 # 输出: 3 行
df[~df['姓名'].isin(['张三', '李四'])]                        # 输出: 其余 6 行（isin 反向筛选）
df[df['数学'].between(80, 90)]                                # 输出: 张三、赵六、周九、吴十
df[df['数学'].between(80, 90, inclusive='neither')]           # 输出: 张三、赵六、吴十（80<x<90）
df[df['姓名'].str.startswith('张')]                           # 输出: 张三

th, names = 85, ['张三', '李四', '王五']
df.query('数学 > @th')                              # 输出: 李四、赵六、钱七、周九
df.query('数学 > @th and 英语 > 90')                 # 输出: 赵六、周九
df.query('(数学 > 90 or 英语 > 90) and 性别 == "女"') # 输出: 李四、赵六、吴十
df.query('姓名 in @names')                          # 输出: 张三、李四、王五
df.query('班级 == "一班" and 数学 > @th')            # 输出: 李四、钱七、周九
df.query('数学 > 85')[['姓名', '数学']]              # query 返回新表，可继续取列
df.rename(columns={'数学': '数学 成绩'}).query('`数学 成绩` > 90')   # 输出: 李四、钱七（列名带空格用反引号）

s = df['数学']
s.where(s >= 85, 0)                      # 输出: 85 92 0 88 95 0 90 0（不满足 → 替换值）
s.where(s >= 85)                         # 输出: 85 92 NaN 88 95 NaN 90 NaN（省略第二参数）
s.mask(s >= 85, -1)                      # 输出: -1 -1 78 -1 -1 73 -1 82（满足条件 → 替换）
df.where(df[['数学', '英语']] >= 85)      # 输出: 形状不变，不满足的格子变 NaN
np.where(df['数学'] >= 85, '达标', '补考') # 输出: 长度 8 的 ndarray
avg = df[['数学', '英语', '物理']].mean(axis=1)
df['等级'] = np.select([avg >= 88, avg >= 85, avg >= 75],
                       ['优秀', '良好', '及格'], default='待提高')

df.filter(items=['姓名', '数学'])         # 输出: 2 列（不存在的列名静默跳过）
df.filter(like='数')                     # 输出: 数学 列
df.get('化学', default=None)             # 输出: None（不抛 KeyError）
df.take([0, 3, -1])                      # 输出: 第 0、3、末 三行
df.take([4, 5], axis=1)                  # 输出: 数学、英语 两列
df.sample(3, random_state=42)            # 输出: 随机 3 行（可复现）
df.sample(frac=0.5, random_state=0)      # 输出: 随机 50%
mi = df.set_index(['班级', '姓名'])
mi.loc[('一班', '张三'), '数学']          # 输出: 85（多级索引用元组）
mi.xs('张三', level='姓名')               # 输出: 跨班级取张三那一行

df.loc[0, '数学'] = 100                                    # ✅ 单格
df.loc[:, '总分'] = df[['数学', '英语', '物理']].sum(axis=1)  # ✅ 新增列
df.loc[df['数学'] > 85, '英语'] = 95                        # ✅ 条件改单列
df.loc[df['数学'] > 85, ['英语', '物理']] = 0                # ✅ 条件改多列
df.loc[len(df)] = ['新同学', '男', 18, '一班', 80, 80, 80]   # ✅ loc 扩容追加一行
m = df['数学'] > 85
df.loc[m, '等级'] = 'A'                                    # ✅ 先存掩码，再一次赋值
# df[df['数学'] > 85]['英语'] = 0                           # ❌ 链式赋值
# df['数学'][0] = 100                                       # ❌ 同样是链式
sub = df[df['班级'] == '一班'].copy()                       # ✅ 要独立改就显式 copy
sub['英语'] = 0                                            # 不影响 df

dup = pd.DataFrame({'数学': [80, 90, 85]}, index=['张三', '张三', '李四'])
dup.index.is_unique                                  # 输出: False
dup.loc['张三']                                       # 输出: 2 行的 DataFrame（不是 Series！）
dup.loc['张三', '数学']                                # 输出: Series（两行）
# dup.reindex(['张三', '李四'])                        # ❌ ValueError：索引有重复标签
dup[~dup.index.duplicated(keep='first')]             # 输出: 保留首次出现的行
d = df.set_index('姓名').sort_index()
d.index.is_monotonic_increasing                      # 输出: True（切片前提）
d.loc['张三':'王五']                                  # 输出: 张三、李四、王五
d.reindex(['张三', '钱七', '不存在'])                  # 输出: '不存在' 整行 NaN
d.reindex(columns=['数学', '物理', '化学'])            # 输出: 化学 列全 NaN
d.index.get_indexer(['张三', '不存在'])                # 输出: array([3, -1])（-1 = 缺失）

df['数学'].idxmax(), df['数学'].max()                 # 输出: (4, 95) → 钱七
df.loc[df['数学'].idxmax(), '姓名']                    # 输出: '钱七'
df['数学'].idxmin()                                   # 输出: 5（孙八 73）
df.nlargest(3, '数学')[['姓名', '数学']]               # 输出: 钱七95 李四92 周九90
df[~df['姓名'].duplicated(keep='first')]              # 输出: 按姓名去重（保留首次）
df.loc[df.duplicated(subset=['班级', '性别']), ['姓名', '班级', '性别']]   # 输出: 重复组合
df.loc[:, '数学'] = df['数学'].mask(df['数学'] < 0)     # 输出: 非法负值 → NaN
df['档位'] = np.where(df['数学'] >= 90, 'A', np.where(df['数学'] >= 80, 'B', 'C'))

score = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '赵六', '钱七', '孙八', '周九', '吴十'],
    '班级': ['一班', '一班', '二班', '二班', '一班', '二班', '一班', '二班'],
    '数学': [85, 92, 78, 88, 95, 73, 90, 82],
    '英语': [90, 88, 85, 92, 87, 78, 93, 95],
    '物理': [78, 85, 92, 80, 88, 85, 82, 90],
}).set_index('姓名')

subj = ['数学', '英语', '物理']
avg = score[subj].mean(axis=1)                       # 输出: 张三 84.33 … 钱七 90.00
score['平均分'] = avg.round(2)
score['等级'] = np.select([avg >= 88, avg >= 85, avg >= 75],
                          ['优秀', '良好', '及格'], default='待提高')
top = score['平均分'].idxmax()                        # 输出: '钱七'
score.loc[top, ['平均分', '等级']]                    # 输出: 90.0 / 优秀
score.nlargest(3, '平均分')[['班级', '平均分', '等级']] # 输出: 钱七90、吴十89、李四/周九88.33

spread = score[subj].max(axis=1) - score[subj].min(axis=1)
score['偏科'] = False
score.loc[spread > 12, '偏科'] = True                # ✅ 王五(14)、吴十(13) 置 True
help_idx = score.index[(score[subj] < 80).any(axis=1)]  # 输出: Index(['张三','王五','孙八'])
score.loc[help_idx, '等级'] = '需辅导'                # ✅ 用标签索引一次性回写
score.loc[score['班级'] == '一班', '平均分'].mean()    # 输出: 87.75

orders = pd.DataFrame({
    '日期': pd.to_datetime(['2024-01-03', '2024-01-08', '2024-01-12',
                            '2024-01-20', '2024-02-02', '2024-02-15']),
    '地区': ['北京', '上海', '广州', '北京', '上海', '广州'],
    '销售额': [3200, 1800, 4500, 2900, 5100, 2400],
    '销量': [30, 12, 45, 28, 52, 20],
})
lo, hi = pd.Timestamp('2024-01-01'), pd.Timestamp('2024-01-31')
orders[orders['日期'].between(lo, hi)]               # 输出: 前 4 行（1 月订单）
big = orders.query('销售额 > 2500 and 销量 > 25')     # 输出: 北京3200、广州4500、上海5100

orders['重点'] = False
orders.loc[big.index, '重点'] = True                 # ✅ query 结果经 .index 接回 loc
best = orders['销售额'].idxmax()                     # 输出: 4（上海 5100）
orders.loc[best, ['地区', '销售额']]                 # 输出: 上海 / 5100
orders.nlargest(2, '销售额')[['地区', '销售额']]      # 输出: 上海5100、广州4500

oi = orders.set_index('日期').sort_index()           # 时间索引必须先排序
oi.loc['2024-01']                                    # 输出: 1 月 4 行（loc 部分字符串匹配）
oi.loc['2024-01-05':'2024-02-05']                    # 输出: 闭区间，含两端
oi.index.is_monotonic_increasing                     # 输出: True（切片前提）

raw = pd.DataFrame({
    '工号': ['E01', 'E02', 'E02', 'E03', 'E04'],
    '姓名': ['张三', '李四', '李四', '王五', '赵六'],
    '城市': ['北京', '上海', '上海', '广州', '  '],
    '薪资': [8000, 12000, 12000, -1, 9500],
})
raw[raw.duplicated(keep=False)]                      # 输出: E02 两行（重复记录全标出）
clean = raw[~raw.duplicated()].copy()                # ✅ 显式 copy，后续修改不污染 raw

clean.loc[:, '城市'] = clean['城市'].str.strip()      # 输出: 首尾空格被去掉
clean.loc[clean['城市'] == '', '城市'] = '未知'       # 输出: 赵六 → 未知
clean.loc[:, '薪资'] = clean['薪资'].mask(clean['薪资'] < 0)   # 输出: 王五薪资 → NaN
clean['薪资'] = clean['薪资'].fillna(clean['薪资'].median())   # 输出: 王五 → 9500

clean = clean.set_index('工号')                      # 先去重再设索引
clean.index.is_unique                                # 输出: True
clean.loc['E02', '薪资']                             # 输出: 12000（标量，不是 Series）
clean.reindex(['E04', 'E01', 'E09'])                 # 输出: E09 整行 NaN，其余按序重排
clean.index.get_indexer(['E01', 'E09'])              # 输出: array([0, -1])（-1 = 工号不存在）

raised = pd.Series({'E01': 8500, 'E04': 10000})
clean.loc[raised.index, '薪资'] = raised             # ✅ 按索引对齐回写，无需循环
clean.loc[:, '薪资']                                 # 输出: E01 8500 / E02 12000 / E03 9500 / E04 10000

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'A': [1, 2, np.nan, 4, 5],
    'B': [np.nan, 2, 3, 4, 5],
    'C': [1, 2, 3, np.nan, 5],
    'D': [1, 2, 3, 4, 5],
})

df.isna().sum()               # 输出: A 1  B 1  C 1  D 0
df.isna().sum().sum()         # 输出: 3（全表缺失总数）
df.isna().mean().round(2)     # 输出: A 0.2  B 0.2  C 0.2  D 0.0
df.loc[df['B'].isna()]        # 输出: 第 0 行整行（挑出 B 缺失的记录）

df.dropna().shape             # 输出: (2, 4)（只剩 index 1、4）
df.dropna(axis=1).shape       # 输出: (5, 1)（只剩 D 列）
df.dropna(subset=['B']).shape # 输出: (4, 4)
df.dropna(thresh=4).shape     # 输出: (2, 4)（要求 4 列全非空）
df.dropna(how='all').shape    # 输出: (5, 4)（无全空行时原样返回）

df['A'].ffill()                                  # 输出: [1.0, 2.0, 2.0, 4.0, 5.0]
df['B'].bfill()                                  # 输出: [2.0, 2.0, 3.0, 4.0, 5.0]
df.fillna({'A': 0, 'B': 1, 'C': 2})['C'].tolist()# 输出: [1, 2, 3, 2, 5]
df.mean(numeric_only=True)                       # 输出: A 3.0  B 3.5  C 2.75  D 3.0
df.fillna(df.mean(numeric_only=True))['A'].tolist()  # 输出: [1.0, 2.0, 3.0, 4.0, 5.0]

s = pd.Series([1, np.nan, np.nan, 4, 5])
s.interpolate()                                  # 输出: [1.0, 2.0, 3.0, 4.0, 5.0]
s.interpolate(limit=1)                           # 输出: [1.0, 2.0, NaN, 4.0, 5.0]（最多连填 1 个）
ts = pd.Series([1, np.nan, np.nan, 4, 5],
               index=pd.date_range('2024-01-01', periods=5))
ts.interpolate(method='time')                    # 输出: 等距日期下与线性插值一致

dup = pd.DataFrame({
    'A': [1, 2, 2, 3, 3, 3],
    'B': [10, 20, 20, 30, 30, 30],
    'C': [100, 200, 200, 300, 300, 400],
})

dup.duplicated().tolist()            # 输出: [False, False, True, False, True, False]
dup.duplicated(subset=['A']).tolist()# 输出: [False, False, True, False, True, True]
dup.duplicated(subset=['A']).sum()   # 输出: 3（按业务主键看的重复数）

dup.drop_duplicates().shape              # 输出: (4, 3)（整行完全相同才删）
dup.drop_duplicates(subset=['A','B']).shape  # 输出: (3, 3)
dup.drop_duplicates(subset=['A'], keep='last').shape   # 输出: (3, 3)（留 idx 0、2、5）
dup.drop_duplicates(subset=['A'], keep=False).shape    # 输出: (1, 3)（只留 A=1）
dup.sort_values('C', ascending=False).drop_duplicates(subset=['A'])  # 先排序再去重 = 取每键最优行