别着急，坐和放宽
Pandas作为Python数据分析的利器，其索引系统是数据处理效率的核心支撑。在DataFrame结构中，索引机制可以比作图书馆的检索系统——就像通过书号快速定位书籍，Pandas通过标签（label）和位置（position）的双重索引机制实现数据的精准定位。
1. loc方法
基于标签的索引，适用于已知行列标签的场景：
2. iloc方法
基于位置的索引，适用于按绝对位置选择的场景：
输出结果：
关键特性：
1:3对应索引1和2通过NumPy的连续内存切片实现高效访问：
内存访问模式示意图：
连续切片只需计算起始地址和步长，实现O(1)时间复杂度。
输出结果：
关键特性：
采用NumPy的高级索引（fancy indexing）：
内存访问模式示意图：
需要多次随机访问，时间复杂度为O(n)。
| 特征 | 聚合选择 | 离散选择 |
|---|---|---|
| 连续性要求 | 必须连续 | 可非连续 |
| 顺序控制 | 自然顺序 | 自定义顺序 |
| 语法示例 | 1:3 | [1,3] |
| 时间复杂度 | O(1) | O(n) |
| 内存访问方式 | 连续访问 | 随机访问 |
| 返回维度 | 保持原维度 | 保持原维度 |
| 适用场景 | 批量连续数据处理 | 精确选取特定数据 |
典型输出结果：
错误案例：
df.iloc[start:end]而非df.iloc[start:end,]列表索引格式化：对于复杂选择，先定义索引列表
防御性检查：
1. 跨维度选择：
2. 配合numpy使用：
3. 动态索引构建：
随着Pandas的持续发展，索引机制也在不断优化。建议关注：
import pandas as pd
# 示例数据
data = {
'学号': [1, 2, 3, 4],
'姓名': ['张三', '李四', '王五', '赵六'],
'成绩': [90, 85, 92, 78]
}
df = pd.DataFrame(data).set_index('学号')
# 选取学号=2的行，'姓名'列
print(df.loc[2, '姓名']) # 输出：李四
# 选取第2行（索引=1），第1列（索引=0）
print(df.iloc[1, 0]) # 输出：李四
# 切片选择示例
df.iloc[1:3, 1:2]
学号 成绩
2 85
3 92
# 等效NumPy操作
import numpy as np
array = np.array([[1, '张三', 90],
[2, '李四', 85],
[3, '王五', 92],
[4, '赵六', 78]])
print(array[1:3, 1:2])
# 输出：[['李四'], ['王五']]
内存地址 | 数据
1000 | 1
1004 | 张三
1008 | 90
1012 | 2
1016 | 李四
1020 | 85
... | ...
# 列表选择示例
df.iloc[[1,2], [2,1]]
学号 成绩 姓名
2 85 李四
3 92 王五
# 等效NumPy操作
rows = np.array([1,2])
cols = np.array([2,1])
print(array[rows[:,None], cols])
# 输出：[[85 '李四']
# [92 '王五']]
内存地址 | 数据
1000 | 1
1004 | 张三
1008 | 90
1012 | 2
1016 | 李四
1020 | 85
... | ...
import time
# 创建大型数据集
big_df = pd.DataFrame(np.random.rand(1000000, 100))
# 聚合选择计时
start = time.time()
_ = big_df.iloc[500000:500100, 50:60]
print(f"Aggregate selection: {time.time()-start:.4f}s")
# 离散选择计时
start = time.time()
_ = big_df.iloc[list(range(500000,500100)), list(range(50,60))]
print(f"Discrete selection: {time.time()-start:.4f}s")
Aggregate selection: 0.0002s
Discrete selection: 0.0127s
# 误以为选择前三行
df.iloc[0:3] # 实际选择0,1,2行（前三行正确）
df.iloc[:3] # 等效写法（推荐）
# 当索引重置时出现问题
df_reset = df.reset_index()
df_reset.iloc[0:3] # 正确选择前三行
# 危险操作示例
try:
df.iloc[[1,2], [3]] # 列索引越界
except IndexError as e:
print(f"Error: {e}")
# 防御性编程
if df.shape[1] >= 3:
df.iloc[:, [2]]
else:
print("Column index out of bounds")
# 有效但危险的混合索引
df.iloc[[1,3], 0:2] # 行离散+列聚合
# 推荐的安全写法
selected_rows = [1,3]
selected_cols = slice(0,2)
df.iloc[selected_rows, selected_cols]
# 视图操作（可能引发SettingWithCopyWarning）
subset = df.iloc[1:3]
subset['成绩'] = 100 # 可能无效
# 明确创建副本
subset_copy = df.iloc[1:3].copy()
subset_copy['成绩'] = 100 # 安全操作
# 创建多层索引DataFrame
multi_df = pd.DataFrame(
np.random.randn(4, 3),
index=[['A', 'A', 'B', 'B'], [1, 2, 1, 2]],
columns=[['2023', '2023', '2024'], ['Q1', 'Q2', 'Q1']]
)
# 正确索引方法
print(multi_df.iloc[1:3, [0,2]])
# 布尔索引与位置索引结合
mask = df['成绩'] > 85
filtered_df = df[mask]
result = filtered_df.iloc[[0,2]] # 可能产生意外结果
# 推荐先重置索引
filtered_df = df[mask].reset_index(drop=True)
# 需要频繁离散访问时优化方案
# 将DataFrame转换为字典
name_dict = df['姓名'].to_dict()
score_dict = df['成绩'].to_dict()
# 快速查询
def fast_lookup(ids):
return {id: (name_dict[id], score_dict[id]) for id in ids}
print(fast_lookup([2,3]))
开始
│
├─ 是否需要自定义顺序？ → 选择离散索引
│ │
│ └─ 数据量是否大？ → 考虑转换为字典结构
│
├─ 是否选择连续区域？ → 使用聚合索引
│
└─ 是否需要混合选择？ → 明确分离行列选择条件
selected_rows = [1,3,5]
selected_cols = [0,2]
df.iloc[selected_rows, selected_cols]
def safe_iloc(df, rows, cols):
max_row = df.shape[0]-1
max_col = df.shape[1]-1
rows = [r for r in rows if r <= max_row]
cols = [c for c in cols if c <= max_col]
return df.iloc[rows, cols]
# 选择奇数行
df.iloc[1::2]
# 选择最后三列
df.iloc[:, -3:]
import numpy as np
# 生成随机索引
random_indices = np.random.choice(len(df), 2, replace=False)
df.iloc[random_indices]
# 根据条件生成索引
condition = df['成绩'] > 85
valid_indices = np.where(condition)[0].tolist()
df.iloc[valid_indices]
# 任务：选取前50%学生，交换姓名和成绩列位置
n = len(df)
selected = range(n//2)
df.iloc[selected, [2,1]] # 成绩列在前，姓名列在后
# 创建时间序列数据
date_rng = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
ts_df = pd.DataFrame(np.random.randn(len(date_rng)), index=date_rng)
# 提取特定时间段
start_idx = 3 # 2023-01-04
end_idx = 7 # 2023-01-08
ts_df.iloc[start_idx:end_idx]
# 分块处理策略
chunk_size = 10000
for i in range(0, len(big_df), chunk_size):
chunk = big_df.iloc[i:i+chunk_size]
process(chunk) # 自定义处理函数