Python 合并具有不同索引的多个系列，对重复的索引求和

假设我有三个系列

s1 = pd.Series(data=np.arange(5))
s2 = pd.Series(data=np.arange(5),index=np.arange(2,7))
s3 = pd.Series(data=np.arange(5),index=np.arange(5,10))

这是将它们合并为一个序列的最有效方法，该序列对重复索引中的

数据

值求和，并保留非重复索引中的值。换句话说，对于

s1

，

s2

，

s3

，我们希望输出：

0    0
1    1
2    2
3    4
4    6
5    3
6    5
7    2
8    3
9    4

---

实际上，我们可能有大量的序列和大量的数据项，因此循环是无效的。

让我们在这里使用

concat

和

sum

：

pd.concat([s1, s2, s3]).sum(level=0)

0    0
1    1
2    2
3    4
4    6
5    3
6    5
7    2
8    3
9    4
dtype: int64

串联是一种O（n）操作（线性复杂度），建议99%的时间使用

---

如果你喜欢方法链接，这个适合你

s1.append(s2).append(s3).sum(level=0)

0    0
1    1
2    2
3    4
4    6
5    3
6    5
7    2
8    3
9    4
dtype: int64

---

不建议超过3个系列。一次追加两个结果在复杂性上是二次的

这是一个带有NumPy工具的-

def sum_series(L): # L is list of series
    aL = [list(l.index) for l in L]
    intL,unqL = pd.factorize(np.concatenate(aL))
    sums = np.bincount(intL,np.concatenate(L))
    return pd.Series(sums, index=unqL)

样本运行-

In [158]: L = [s1,s2,s3] # list of series

In [159]: sum_series(L)
Out[159]: 
0    0.0
1    1.0
2    2.0
3    4.0
4    6.0
5    3.0
6    5.0
7    2.0
8    3.0
9    4.0
dtype: float64

In [225]: sum_series_v2(L)
Out[225]: 
Label0    0
Label1    1
Label2    2
Label3    4
Label4    6
Label5    3
Label6    5
Label7    2
Label8    3
Label9    4
dtype: int64

使用通用标签-

In [170]: L
Out[170]: 
[Label0    0
 Label1    1
 Label2    2
 Label3    3
 Label4    4
 dtype: int64, Label2    0
 Label3    1
 Label4    2
 Label5    3
 Label6    4
 dtype: int64, Label5    0
 Label6    1
 Label7    2
 Label8    3
 Label9    4
 dtype: int64]

In [171]: sum_series(L)
Out[171]: 
Label0    0.0
Label1    1.0
Label2    2.0
Label3    4.0
Label4    6.0
Label5    3.0
Label6    5.0
Label7    2.0
Label8    3.0
Label9    4.0
dtype: float64

版本#2

在数组数据上使用串联并使用智能输出数据类型，可能可以通过类似的方式获得更理想的输出-

def sum_series_v2(L): # L is list of series
    aL = [list(l.index) for l in L]
    v = [l.values for l in L]
    intL,unqL = pd.factorize(np.concatenate(aL))
    sums = np.bincount(intL,np.concatenate(v))
    dtype = np.result_type(*[l.dtype for l in L])
    return pd.Series(sums.astype(dtype), index=unqL)

样本运行-

In [158]: L = [s1,s2,s3] # list of series

In [159]: sum_series(L)
Out[159]: 
0    0.0
1    1.0
2    2.0
3    4.0
4    6.0
5    3.0
6    5.0
7    2.0
8    3.0
9    4.0
dtype: float64

In [225]: sum_series_v2(L)
Out[225]: 
Label0    0
Label1    1
Label2    2
Label3    4
Label4    6
Label5    3
Label6    5
Label7    2
Label8    3
Label9    4
dtype: int64

---

很好-我猜

concat

正在处理引擎盖下的外部连接。@ojlm这在技术上不是连接操作，因为您只是垂直连接。当水平合并它们时，

join

参数会产生不同的效果。关于这个主题，这里有一个详尽的讨论：这个系列的所有索引都是升序的吗？它们都是正的吗？不一定，它们也可能是另一种方法