Pandas实现带初始滞后的交叉求和（非逐行编写方案）

云上老周

2026-8-5

解决方案

方法1：循环实现（简洁直观）

直接初始化列后逐行迭代，逻辑和你描述的完全对应，适合小数据集：

import pandas as pd

df = pd.DataFrame([[1],[2],[4]], columns=['A'])

# 初始化B、C列
df['B'] = 0.0
df['C'] = 0.0

# 处理第一行
if df.loc[0, 'A'] > 0:
    df.loc[0, 'B'] = df.loc[0, 'A']
df.loc[0, 'C'] = df.loc[0, 'A']

# 从第二行开始迭代计算
for i in range(1, len(df)):
    prev_c = df.loc[i-1, 'C']
    if df.loc[i, 'A'] > 0:
        df.loc[i, 'B'] = df.loc[i, 'A'] + prev_c
    df.loc[i, 'C'] = prev_c + df.loc[i, 'B']

运行结果：

A	B	C
1	1	1
2	3	4
4	8	12

方法2：向量化递推（高效处理大数据）

通过numpy数组替代DataFrame逐行操作，减少开销，适合中等规模数据集：

import pandas as pd
import numpy as np

df = pd.DataFrame([[1],[2],[4]], columns=['A'])
a_arr = df['A'].values
n = len(a_arr)

# 计算C数组：推导递推公式简化计算
c_arr = np.zeros(n)
c_arr[0] = a_arr[0] if a_arr[0] > 0 else 0
for i in range(1, n):
    if a_arr[i] > 0:
        c_arr[i] = 2 * c_arr[i-1] + a_arr[i]
    else:
        c_arr[i] = c_arr[i-1]

# 计算B数组：利用C的差值反推
b_arr = np.zeros(n)
b_arr[0] = c_arr[0]
b_arr[1:] = c_arr[1:] - c_arr[:-1]

# 赋值回DataFrame
df['B'] = b_arr
df['C'] = c_arr

方法3：numba加速（超大数据集）

用numba编译循环，大幅提升计算速度，适合十万行以上的数据集：

import pandas as pd
import numpy as np
from numba import jit

@jit(nopython=True)
def compute_bc(a):
    n = len(a)
    b = np.zeros(n)
    c = np.zeros(n)
    
    if a[0] > 0:
        b[0] = a[0]
    c[0] = a[0]
    
    for i in range(1, n):
        prev_c = c[i-1]
        if a[i] > 0:
            b[i] = a[i] + prev_c
        c[i] = prev_c + b[i]
    return b, c

df = pd.DataFrame([[1],[2],[4]], columns=['A'])
b_arr, c_arr = compute_bc(df['A'].values)
df['B'] = b_arr
df['C'] = c_arr