Question

我想为每一列求和。我认为我应该使用apply（）使用特殊的聚合，但是我不知道正确的代码

A  B  C  D  E  F  G
1  2  3  4  5  6  7
1  3  3  4  8  7  7
2  2  3  5  8  1  1
2  1  3  5  7  5  1

#i want to have this result 
for each value in column A

A  B  C  D  E   F   G
1  5  3  4  13  13  7
2  3  3  5  15  6   1

Answer 1

您可以通过删除每个索引位置的重复项来进行向量化。然后，您可以使用稀疏矩阵方便地重新创建原始矩阵。

您可以完成创建零数组并添加的相同操作，但是如果您的A列非常稀疏，则可以避免占用大量内存。

from scipy import sparse

def non_dupe_sums_2D(ids, values):
    v = np.unique(ids)
    x, y = values.shape
    r = np.arange(y)
    m = np.repeat(a, y)
    n = np.tile(r, x)
    u = np.unique(np.column_stack((m, n, values.ravel())), axis=0)
    return sparse.csr_matrix((u[:, 2], (u[:, 0], u[:, 1])))[v].A

a = df.iloc[:, 0].to_numpy()
b = df.iloc[:, 1:].to_numpy()

non_dupe_sums_2D(a, b)

array([[ 5,  3,  4, 13, 13,  7],
       [ 3,  3,  5, 15,  6,  1]], dtype=int64)

性能

df = pd.DataFrame(np.random.randint(1, 100, (100, 100)))

a = df.iloc[:, 0].to_numpy()
b = df.iloc[:, 1:].to_numpy()

%timeit pd.concat([g.apply(lambda x: x.unique().sum()) for v,g in df.groupby(0) ], axis=1)
1.09 s ± 9.19 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit df.iloc[:, 1:].groupby(df.iloc[:, 0]).apply(sum_unique)
1.05 s ± 4.97 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit non_dupe_sums_2D(a, b)
7.95 ms ± 30.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

验证

>>> np.array_equal(non_dupe_sums_2D(a, b), df.iloc[:, 1:].groupby(df.iloc[:, 0]).apply(sum_unique).values)
True

Answer 2

不太理想，但这是LocalDate.now(ZoneId.of("Europe/London")); now.minus(1, IsoFields.QUARTER_OF_YEAR);的一种方法：

apply

输出：

pd.concat([g.apply(lambda x: x.unique().sum()) for v,g in df.groupby('A') ], axis=1)

您当然可以转置数据框以获得预期的输出。

Answer 3

我会做类似的事情：

def sum_unique(x):
    return x.apply(lambda x: x.unique().sum())

df.groupby('A')[df.columns ^ {'A'}].apply(sum_unique).reset_index()

这给了我

   A  B  C  D   E   F  G
0  1  5  3  4  13  13  7
1  2  3  3  5  15   6  1

这似乎就是您所期望的

总结熊猫数据框中的不同值

3 个答案: