# 选取学号=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)  # 自定义处理函数