企业官网建设流程全解析

1. 项目概述：为什么DataFrame的插入操作值得深究？

如果你刚开始用pandas处理数据，可能会觉得在DataFrame里加一行或一列数据，不就是个append或者直接赋值的事儿吗？我刚开始也这么想，直到在一个处理千万级用户行为日志的项目里踩了坑。当时为了在循环里逐行插入计算结果，用了最直观的df.loc[len(df)] = new_row，结果程序跑了一个多小时还没完，内存占用还飙升。后来才发现，在pandas里，“插入”这个动作背后，藏着从数据结构、内存管理到性能优化的大学问。它远不止是“把数据放进去”那么简单，而是关系到你整个数据处理流程是否高效、内存是否可控、代码是否优雅的关键操作。

无论是做数据分析、机器学习特征工程，还是简单的数据清洗，我们几乎每天都在和DataFrame的增删改查打交道。而“插入”操作，尤其是动态的、条件性的插入，更是高频动作。理解pandas提供的多种插入方法及其适用场景，能让你避免我当年那种“暴力操作”导致的性能灾难，写出更专业、更高效的代码。这篇文章，我就结合自己多年的实战经验，把DataFrame插入行和列的各种方法掰开揉碎了讲清楚，重点不止于“怎么做”，更在于“为什么这么做”以及“什么时候该用哪种方法”。

2. 核心思路与方案选型：理解DataFrame的“不可变性”

在深入具体方法之前，我们必须建立一个核心认知：pandas的DataFrame在设计上倾向于“不可变”（immutable）操作。这意味着，大多数返回新DataFrame的操作（如concat,assign）并不会直接修改原始数据，而是创建一份副本。而像df['new_col'] = values这样的原地（in-place）操作，虽然修改了原DataFrame，但其底层也可能触发数据的复制（copy-on-write等机制）。理解这一点，是选择正确插入方法的基础。

为什么pandas要这么设计？主要是为了数据安全性和链式调用（chaining）的便利性。你可以放心地对一个DataFrame进行多种操作，而不必担心原始数据被意外修改。但这带来了性能上的权衡：频繁创建副本会消耗内存和时间。

因此，我们的方案选型将围绕几个核心维度展开：

1. 操作对象：是插入行还是插入列？
2. 插入位置：是在头部、尾部，还是在任意指定的索引位置？
3. 数据形态：要插入的是单个标量值、一个列表/数组、一个Series，还是另一个DataFrame？
4. 性能考量：是一次性插入大量数据，还是循环中少量多次插入？
5. 代码风格：是追求链式调用的函数式风格，还是清晰的命令式风格？

基于这些维度，我将插入操作分为“列插入”和“行插入”两大类，并逐一解析其下的具体方法、原理和最佳实践。

3. 列插入：五种方法详解与实战场景

给DataFrame增加一列新数据是最常见的操作之一。根据数据来源和插入逻辑的不同，至少有五种主流方法。

3.1 直接赋值法：最直观的原地操作

这是最简单、最常用的方法，语法直白得像给字典赋值。

import pandas as pd import numpy as np # 创建一个示例DataFrame df = pd.DataFrame({ 'A': [1, 2, 3], 'B': [4, 5, 6] }) print("原始df:") print(df) # 方法1：直接赋值，插入新列‘C’ df['C'] = [7, 8, 9] print("\n插入列C后:") print(df) # 方法2：插入一个标量值，整列填充 df['D'] = 0 print("\n插入常数列D后:") print(df) # 方法3：插入一个NumPy数组或Series df['E'] = pd.Series([10, 11, 12]) print("\n插入Series列E后:") print(df)

核心原理与注意事项：

• 原地修改：df['new_col'] = ...是典型的原地操作，会直接修改原始的df。
• 长度必须匹配：右侧赋值的列表、数组或Series的长度，必须与DataFrame的行数一致，否则会抛出ValueError。这是新手最常见的错误之一。
• 标量广播：如果赋值的是一个标量（如df[‘D’] = 0），pandas会自动将该值广播（broadcast）到所有行，创建一列相同的值。这在初始化列时非常方便。
• 性能：对于单列插入，直接赋值性能很好。但如果是在循环中多次插入不同列，需注意每次赋值都可能涉及内存分配。

实操心得：我习惯用df[‘col’] = value来初始化空列或填充常数列。在需要根据已有列计算新列时，结合np.where、np.select或apply函数，这是构建特征工程的主力方法。例如，df[‘is_adult’] = np.where(df[‘age’] >= 18, True, False)。

3.2assign()方法：函数式编程与链式调用的利器

如果你想保持代码的整洁和链式风格，避免中间变量，assign()是你的首选。它不会修改原DataFrame，而是返回一个包含新列的新DataFrame。

# 使用assign插入新列 df_new = df.assign(F = [13, 14, 15], G = lambda x: x['A'] * 2) # 可以引用当前（即将被赋值的）DataFrame print("使用assign创建的新df_new:") print(df_new) print("\n原始df未被修改:") print(df)

核心优势与场景：

• 非原地操作：原始数据安全，适合在数据管道（pipeline）中进行多步转换。
• 链式调用：可以流畅地连接多个操作，如df.pipe(clean_data).assign(new_col=...).query(...)，代码可读性极高。
• Lambda表达式：assign()允许使用lambda函数，该函数的输入是当前被操作的DataFrame。这意味着你可以在定义新列时，引用刚刚在同一assign()调用中创建的其他新列（虽然不推荐过于复杂的依赖，因为可能产生歧义）。
• 动态列名：列名直接作为关键字参数名，非常直观。

避坑指南：assign()中lambda函数里的x，指的是正在被assign的DataFrame。如果同时创建多个有依赖关系的新列，它们的计算顺序是不确定的（因为Python字典的键值对顺序在3.6之前不保证，之后虽保证插入顺序但依赖它仍是危险行为）。因此，不要写出df.assign(a = lambda x: x[‘b’] + 1, b = 10)这样的代码，a对b的引用可能发生在b被赋值之前。安全的做法是分步assign或使用其他方法。

3.3insert()方法：精准控制插入位置

如果你想在指定的列索引位置插入新列，而不是默认追加到末尾，insert()方法是唯一的内置选择。

# 在索引位置1（0-based，即在第一列‘A’之后）插入新列‘H’ df.insert(loc=1, column='H', value=[16, 17, 18]) print("\n在位置1插入列H后:") print(df)

参数解析：

• loc：整数，表示要插入的位置。0表示在最前面，len(df.columns)表示在最后面（但这时不如直接用df[‘col’]=value）。
• column：新列的名称。
• value：要插入的值，可以是标量、列表、数组或Series。长度必须与行数匹配。
• allow_duplicates：可选参数，默认为False。如果为False，当尝试插入一个已存在的列名时会报错。设置为True可以允许重复列名（但这通常不是好主意，会导致后续索引混乱）。

适用场景：

• 固定结构输出：当你需要生成的DataFrame有严格的列顺序要求时（例如，导出给下游系统或生成固定格式的报告）。
• 在特定列后插入计算列：比如，在“销售额”列后面立即插入“利润率”列，使相关字段排列在一起，便于阅读和分析。

性能提示：insert()是原地操作，但由于它可能需要在内存中移动大量数据来腾出位置，在列数非常多（比如上千列）的DataFrame中间插入列，可能会有一定的性能开销。不过对于常见的几十上百列的数据集，开销可以忽略不计。

3.4concat()方法：批量合并列的强大工具

虽然concat()常被用于合并行，但它同样是批量合并列的终极武器。当你需要将多个DataFrame或Series在列方向上拼接时，它是不二之选。

# 创建两个要合并的DataFrame或Series df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}) df2 = pd.DataFrame({'C': [5, 6], 'D': [7, 8]}) series_to_add = pd.Series([9, 10], name='E') # 沿axis=1（列方向）进行合并 df_combined = pd.concat([df1, df2, series_to_add], axis=1) print("使用concat合并列后的结果:") print(df_combined)

关键参数与技巧：

• axis=1：这是关键，指定沿列方向拼接。
• ignore_index=False：对于列拼接，通常保持为False以保留原有的列名。如果设置为True，列名将被重置为0, 1, 2, …
• 处理索引：concat默认按索引对齐。如果df1和df2的行索引不一致，结果中会出现NaN。确保索引一致或使用reset_index(drop=True)是常见的预处理步骤。
• 批量插入：这是concat最大的优势。如果你有十几列数据分散在不同的DataFrame或列表中，用一句pd.concat([df, df_new_cols], axis=1)就能全部搞定，比循环赋值高效、清晰得多。

3.5reindex()与join()：更高级的列插入策略

这两种方法通常用于更复杂的数据对齐和合并场景，但在特定条件下，也能优雅地实现“插入列”的效果。

reindex()主要用于改变索引或列的顺序。你可以通过传入一个新的列列表（包含原有列名和新的列名），来“扩展”DataFrame的列，新列会自动用NaN填充。

# 使用reindex扩展列 df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}) df_expanded = df.reindex(columns=['A', 'New_Col', 'B']) print("使用reindex扩展列（新列为NaN）:") print(df_expanded)

这在你需要预先定义一个固定列结构，然后分批填充数据时很有用。

join()方法用于基于索引合并两个DataFrame。如果你想将一个小的、只有一列或几列的DataFrame合并到主DataFrame上，join非常方便，尤其是当它们有共同索引时。

df_main = pd.DataFrame({'A': [1, 2, 3]}, index=['x', 'y', 'z']) df_extra = pd.DataFrame({'Extra': [10, 20, 30]}, index=['x', 'y', 'z']) df_joined = df_main.join(df_extra) # 默认按索引左连接 print("\n使用join合并列:") print(df_joined)

join提供了多种连接方式（how=‘left’, ‘right’, ‘inner’, ‘outer’），可以处理更复杂的索引对齐和合并逻辑。

4. 行插入：四种策略与性能陷阱

与列插入相比，行插入需要更多的谨慎，因为不当的操作很容易导致严重的性能下降。核心原则是：避免在循环中逐行插入。

4.1loc索引器赋值：在尾部“追加”单行

这是最像“插入”操作的方法，但请注意，它通常只用于在已知索引的尾部添加一行。

df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=[0, 1]) print("原始df:") print(df) # 在索引位置2（假设是新的行索引）插入一行 # 注意：如果索引2不存在，这实际上是“追加”行为 df.loc[2] = [5, 6] print("\n使用df.loc[2]赋值后:") print(df) # 更常见的用法：使用len(df)作为新索引，确保追加到末尾 df.loc[len(df)] = [7, 8] print("\n使用df.loc[len(df)]追加后:") print(df)

工作原理与严重警告：

• 当使用df.loc[index] = row_data时，如果index已存在，则会修改该行；如果index不存在，pandas会扩展索引并在该位置创建新行。
• df.loc[len(df)]是一个常用技巧，因为len(df)返回行数，对于默认的整数索引（0, 1, 2…），这个值正好是下一个不存在的索引，从而实现尾部追加。
• 性能陷阱：千万不要在循环中使用这种方法！每次df.loc[len(df)] = ...操作，pandas都可能需要为整个DataFrame创建一个新的数据块（block），并复制所有数据。循环N次，时间复杂度接近O(N²)，数据量大时速度会急剧下降，内存也会频繁波动。

血泪教训：我开头提到的那个耗时一小时的案例，罪魁祸首就是在一个百万级循环里用了df.loc[len(df)]。正确的做法是将要插入的行数据先收集到列表或另一个DataFrame中，最后一次性合并。

4.2concat()方法：行插入的黄金标准

对于批量行插入，或者在循环中收集数据后一次性添加，pd.concat()是性能最好、最安全的方法。

# 准备要追加的新数据，可以是字典列表、另一个DataFrame等 new_rows_list = [{'A': 9, 'B': 10}, {'A': 11, 'B': 12}] new_rows_df = pd.DataFrame(new_rows_list) # 或者另一个DataFrame df_another = pd.DataFrame({'A': [13, 14], 'B': [15, 16]}) # 使用concat进行行合并 (axis=0 是默认值，可省略) df_appended = pd.concat([df, new_rows_df, df_another], ignore_index=True) print("使用concat合并多行后的结果 (ignore_index=True):") print(df_appended)

最佳实践：

1. 收集再合并：在循环中，不要直接concat，而是先将每一行数据（可以是字典、列表或Series）添加到一个列表中。循环结束后，一次性将这个列表转换为DataFrame，再与原始DataFrame进行concat。

   rows_to_add = [] for item in some_iterable: # ... 一些计算逻辑 ... new_row = {'col1': value1, 'col2': value2} rows_to_add.append(new_row) # 收集到列表 # 循环结束后一次性合并 if rows_to_add: df_new_rows = pd.DataFrame(rows_to_add) df = pd.concat([df, df_new_rows], ignore_index=True)

2. ignore_index=True：在行合并后，通常需要重置索引，使其保持连续。设置此参数为True可以自动完成，避免索引重复。
3. 性能优势：concat在底层进行了优化，一次性处理批量数据，避免了多次内存分配和复制的开销，性能远优于循环内单行插入。

4.3append()方法：已弃用的便捷语法

在pandas的旧版本中，df.append()方法曾因其简洁的语法而被广泛使用。但是，从pandas 1.4.0版本开始，此方法已被正式弃用（deprecated），并在未来的2.0版本中会被移除。

# 不推荐！仅作了解 # df = df.append(new_row, ignore_index=True)

为什么不推荐？

• 性能差：与循环中使用loc类似，每次append都可能产生完整的数据副本，导致性能低下。
• 语法糖的代价：它虽然写法简单，但掩盖了其背后昂贵的复制操作，容易误导开发者写出低效代码。
• 官方推荐替代：官方明确建议使用pd.concat()替代append。concat功能更强大、语义更清晰、性能更优。

强烈建议：即使你还在用较旧的pandas版本，也请从现在开始习惯使用concat，让你的代码面向未来。

4.4 通过iloc和切片在任意位置插入行

这是一个相对高级且小众的需求：在DataFrame的中间（非头部非尾部）插入一行。pandas没有直接的insert_row函数，但我们可以通过组合iloc切片和concat来实现。

def insert_row(df, index, row_data): """ 在DataFrame的指定索引位置插入一行。 df: 原始DataFrame index: 要插入的位置（整数） row_data: 要插入的数据，可以是字典、列表或Series。必须与df的列匹配。 """ # 确保row_data是一个单行的DataFrame if isinstance(row_data, dict): row_df = pd.DataFrame([row_data]) elif isinstance(row_data, pd.Series): row_df = pd.DataFrame([row_data.to_dict()]) elif isinstance(row_data, list): # 假设row_data是值的列表，顺序与df.columns一致 row_df = pd.DataFrame([row_data], columns=df.columns) else: raise TypeError("row_data must be dict, list or Series") # 将原DataFrame切分为上下两部分，中间插入新行，再合并 top_part = df.iloc[:index] bottom_part = df.iloc[index:] # 使用concat合并 new_df = pd.concat([top_part, row_df, bottom_part], ignore_index=True) return new_df # 示例使用 df = pd.DataFrame({'A': [1, 3, 4], 'B': [5, 7, 8]}) print("原始df:") print(df) df_inserted = insert_row(df, 1, {'A': 2, 'B': 6}) # 在索引1的位置插入新行 print("\n在索引1处插入行后:") print(df_inserted)

实现原理与注意点：

• 这个函数通过iloc将原DataFrame在目标位置index处切分成两部分（top_part和bottom_part）。
• 然后将上半部分、新行数据（转换为DataFrame）、下半部分用concat拼接起来。
• ignore_index=True确保了新DataFrame的索引是连续的。
• 性能：这种方法涉及一次切片和一次concat。如果只是偶尔操作，完全没问题。但如果需要在循环中频繁在任意位置插入行，性能依然会是个问题，因为这本质上是多次数据复制。对于这种极端场景，可能需要考虑其他数据结构（如链表）或在数据处理流程上做优化。

5. 高级技巧与性能优化实战

掌握了基本方法后，我们来看看如何在实际项目中组合运用，并规避性能瓶颈。

5.1 混合插入：同时添加多行多列

实际项目中，我们经常需要同时扩展DataFrame的维数。最清晰的做法是分步进行。

# 假设我们有一个初始DF，需要同时添加来自不同数据源的新列和新行 df_base = pd.DataFrame({'UserID': [101, 102], 'Score': [85, 92]}) # 步骤1：从另一个数据源合并新列（例如用户信息） df_user_info = pd.DataFrame({'UserID': [101, 102], 'Age': [25, 30], 'City': ['Beijing', 'Shanghai']}) # 使用merge基于UserID合并列 df_enhanced = pd.merge(df_base, df_user_info, on='UserID', how='left') print("合并用户信息列后:") print(df_enhanced) # 步骤2：收集一批新的用户记录（新行） new_users_data = [ {'UserID': 103, 'Score': 88, 'Age': 28, 'City': 'Guangzhou'}, {'UserID': 104, 'Score': 95, 'Age': 35, 'City': 'Shenzhen'} ] df_new_users = pd.DataFrame(new_users_data) # 步骤3：使用concat一次性添加所有新行 df_final = pd.concat([df_enhanced, df_new_users], ignore_index=True) print("\n最终合并了新行和新列的DataFrame:") print(df_final)

策略：优先使用基于键的合并（merge）来添加列，使用concat来添加行。保持操作步骤的清晰和原子性。

5.2 避免循环插入的性能模式

这是本文最重要的实战经验。无论插入行还是列，都要极力避免在循环内部直接修改DataFrame。

反面教材（性能极差）：

df = pd.DataFrame(columns=['A', 'B']) for i in range(10000): new_row = {'A': i*2, 'B': i*3} df = df.append(new_row, ignore_index=True) # 或 df.loc[len(df)] = new_row

正面教材（性能优秀）：

# 模式1：收集字典到列表 rows_list = [] for i in range(10000): rows_list.append({'A': i*2, 'B': i*3}) df = pd.DataFrame(rows_list) # 模式2：如果数据可向量化计算，直接构建DataFrame（最佳性能） import numpy as np n = 10000 df = pd.DataFrame({ 'A': np.arange(n) * 2, 'B': np.arange(n) * 3 }) # 模式3：循环中收集，循环后一次性concat（适用于动态条件插入） df_base = pd.DataFrame(columns=['A', 'B']) rows_to_add = [] for item in some_complex_iterable: if some_condition(item): # 只有满足条件才需要插入 rows_to_add.append(process_item(item)) if rows_to_add: df_to_add = pd.DataFrame(rows_to_add) df_base = pd.concat([df_base, df_to_add], ignore_index=True)

性能差异：第一种反面教材在处理万级数据时就会明显变慢，十万级数据可能让人无法忍受。而第二种和第三种模式，即使处理百万级数据也非常快。核心思想是让pandas在底层用C语言或高度优化的算法处理批量数据，而不是在Python解释器层面进行低效的单步操作。

5.3 使用itertuples()或apply()进行行级转换而非插入

有时我们觉得需要“插入行”，其实是想根据现有行生成新的衍生行。与其插入，不如先构建所有新行，再合并。

# 示例：将每个用户的记录拆分为多条（例如，按日期展开） df_orders = pd.DataFrame({ 'UserID': [101, 102], 'OrderDates': [['2023-01-01', '2023-01-05'], ['2023-01-02']], 'Amount': [[100, 150], [200]] }) # 目标：将列表展开，每个日期和金额对成为一行 expanded_rows = [] for _, row in df_orders.iterrows(): user_id = row['UserID'] for date, amt in zip(row['OrderDates'], row['Amount']): expanded_rows.append({'UserID': user_id, 'Date': date, 'Amount': amt}) df_expanded = pd.DataFrame(expanded_rows) print("展开列表后的DataFrame:") print(df_expanded)

在这个例子中，我们通过遍历原DataFrame，在Python列表中构建了所有新行，最后一次性创建新DataFrame。这比在循环中不断插入行要高效得多。

6. 常见问题排查与解决方案实录

在实际操作中，你肯定会遇到各种报错和意外情况。这里我整理了一份“避坑指南”。

6.1ValueError: Length of values does not match length of index

问题描述：这是列插入时最常见的错误。当你尝试df[‘new_col’] = values时，右侧的values长度与DataFrame的行数不匹配。

df = pd.DataFrame({'A': [1, 2, 3]}) df['B'] = [4, 5] # 错误！列表长度2，df长度3。

解决方案：

1. 检查数据源：确保你准备的数据列表、数组或Series的长度与len(df)一致。
2. 使用标量广播：如果你想用同一个值填充整列，直接使用标量：df[‘B’] = 0。
3. 使用np.full或列表推导式：快速生成一个等长的列表。

   df['B'] = np.full(len(df), fill_value=99) # 或 df['B'] = [calculate_value(i) for i in range(len(df))]

6.2 插入后数据丢失或错位

问题描述：使用concat或merge后，发现有些行的数据变成了NaN，或者顺序乱了。

根本原因：索引没有对齐。pandas在合并数据时，默认按索引进行对齐。

解决方案：

1. 使用ignore_index=True：如果你不关心原始索引，希望在合并后得到一个新的连续整数索引，这是最简单的方法。pd.concat([df1, df2], ignore_index=True)
2. 在合并前重置索引：如果每个部分的索引是独立的且需要丢弃，先统一reset_index(drop=True)。

   df1_reset = df1.reset_index(drop=True) df2_reset = df2.reset_index(drop=True) df_combined = pd.concat([df1_reset, df2_reset], axis=1)

3. 检查merge的on参数：使用merge时，确保on参数指定的键列在两个DataFrame中都存在且含义一致。善用how参数（‘left’, ‘right’, ‘inner’, ‘outer’）控制合并逻辑。

6.3 内存使用量激增

问题描述：在插入操作，特别是循环插入后，程序内存占用异常高。

诊断与解决：

1. 首要怀疑：循环内的原地扩展。立即检查代码中是否存在df.loc[len(df)] = ...或已弃用的df.append()在循环内被调用。这是内存激增最常见的原因。
2. 转换为列表再构建：如前所述，将循环内的数据收集到Python列表（list）或字典列表（list of dict）中。Python原生列表的内存管理效率远高于在循环中不断扩容DataFrame。
3. 使用pd.DataFrame.from_records()：如果你已经有一个字典列表，from_records是构建DataFrame的高效方法之一。
4. 监控内存：对于大数据处理，可以使用df.info(memory_usage=‘deep’)查看DataFrame的内存使用详情，或用psutil库监控进程内存。

6.4 插入后列顺序不符合预期

问题描述：使用concat或assign插入多列后，列的排列顺序乱了。

原因与解决：

• concat拼接列时，列的顺序就是传入的DataFrame列表的顺序。
• assign添加的列总是放在最后。
• 如果需要精确控制列顺序，有几种方法：
  1. 使用insert()方法：可以精确指定每一列的插入位置。
  2. 最后使用reindex()：在所有列都添加完毕后，用df = df.reindex(columns=[‘col1’, ‘col2’, ‘new_col’, ‘col3’])来重新排序。
  3. 使用双括号[[...]]索引：df = df[[‘A’, ‘NewCol’, ‘B’, ‘C’]]可以创建一个具有指定列顺序的新视图（或副本）。

6.5 处理重复的列名

问题描述：插入列时，如果新列名与现有列名重复，默认会报错（insert方法）或覆盖（直接赋值）。

解决方案：

• 检查并重命名：在插入前，检查列名是否已存在。if ‘new_col’ in df.columns: ...
• 使用allow_duplicates=True：insert(loc, column, value, allow_duplicates=True)。但极其不推荐，因为后续通过列名索引df[‘col’]会返回一个DataFrame（多列），而不是Series，极易导致混淆和错误。
• 系统化命名：对于批量生成的列，使用有规律的命名，如f‘feature_{i}’，避免冲突。

7. 总结与个人工具箱

经过上面这些拆解，你会发现pandas中的数据插入远不止一个函数调用。它是一套需要根据场景、数据和性能要求进行综合选择的方法论。

在我的日常工具箱里，对于列插入，优先级是这样的：

1. 直接赋值df[‘col’]=val：用于单列、基于现有列的计算或常量初始化。快、直观。
2. assign()：用于链式操作、函数式编程风格，或者需要保持原始数据不变时。
3. concat(axis=1)：用于批量合并多个列集合，或者从其他DataFrame合并列。
4. insert()：仅当需要精确控制新列插入位置时使用。
5. reindex/join/merge：用于更复杂的数据对齐和合并需求。

对于行插入，我的原则更简单：

1. 永远首选pd.concat()：无论是批量添加还是循环收集后添加。
2. 彻底告别append()：即使当前版本还能用，为了代码的长期健康和性能，不要再用了。
3. 谨慎使用df.loc[index]：只用于在交互式环境或脚本中手动添加一两行数据，绝不用于循环。
4. 任意位置插入：使用自定义的insert_row函数，并清楚其性能代价。

最后，再分享一个我调试这类问题的小技巧：当你对一段数据操作的性能或结果有疑虑时，不要在大数据集上直接测试。先用df.head(10)创建一个极小的样本数据，在这个样本上快速验证你的逻辑是否正确，结果是否符合预期。确认无误后，再放到全量数据上运行。这能帮你节省大量等待和调试的时间。数据处理，思路清晰比盲目尝试更重要。