按 numpy 中的數字對數組求和

Question

假設我有一個 numpy 數組，如：[1,2,3,4,5,6] 和另一個數組：[0,0,1,2,2,1] 我想按組對第一個數組中的項目求和（第二個數組）並按組號順序獲得 n 組結果（在這種情況下，結果為 [3, 9, 9]）。 我如何在 numpy 中執行此操作？

Answer 1

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 2

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 3

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 4

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 5

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 6

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 7

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 8

我嘗試了不同的方法來做到這一點，我發現使用np.bincount確實是最快的。 見亞歷克斯的回答

    import numpy as np
    import random
    import time
    
    size = 10000
    ngroups = 10
    
    groups = np.random.randint(low=0,high=ngroups,size=size)
    values = np.random.rand(size)
    
    
    # Test 1                                                                                                                                                                                                           
    beg = time.time()
    result = np.zeros(ngroups)
    for i in range(size):
        result[groups[i]] += values[i]
    print('Test 1 took:',time.time()-beg)
    
    # Test 2                                                                                                                                                                                                           
    beg = time.time()
    result = np.zeros(ngroups)
    for g,v in zip(groups,values):
        result[g] += v
    print('Test 2 took:',time.time()-beg)
    
    # Test 3                                                                                                                                                                                                           
    beg = time.time()
    result = np.zeros(ngroups)
    for g in np.unique(groups):
        wh = np.where(groups == g)
        result[g] = np.sum(values[wh[0]])
    print('Test 3 took:',time.time()-beg)
    
    
    # Test 4                                                                                                                                                                                                           
    beg = time.time()
    result = np.zeros(ngroups)
    for g in np.unique(groups):
        wh = groups == g
        result[g] = np.sum(values, where = wh)
    print('Test 4 took:',time.time()-beg)
    
    # Test 5                                                                                                                                                                                                           
    beg = time.time()
    result = np.array([np.sum(values[np.where(groups == g)[0]]) for g in np.unique(groups) ])
    print('Test 5 took:',time.time()-beg)
    
    # Test 6                                                                                                                                                                                                           
    beg = time.time()
    result = np.array([np.sum(values, where = groups == g) for g in np.unique(groups) ])
    print('Test 6 took:',time.time()-beg)
    
    # Test 7                                                                                                                                                                                                           
    beg = time.time()
    result = np.bincount(groups, weights = values)
    print('Test 7 took:',time.time()-beg)

結果：

    Test 1 took: 0.005615234375
    Test 2 took: 0.004812002182006836
    Test 3 took: 0.0006084442138671875
    Test 4 took: 0.0005099773406982422
    Test 5 took: 0.000499725341796875
    Test 6 took: 0.0004980564117431641
    Test 7 took: 1.9073486328125e-05

Answer 9

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 10

假設我有一個像[1,2,3,4,5,6]這樣的numpy數組，另一個數組是[0,0,1,2,2,1]，我想按組對第一個數組中的項求和（第二個數組）並按組號順序獲得n個組的結果（在這種情況下，結果將為[3，9，9]）。 我該如何在numpy中執行此操作？

Answer 11

這是一種適用於按任何類型（不僅是 int）的值分組的任何維度的對象求和的方法：

grouping = np.array([1.1, 10, 1.1, 15])
to_sum = np.array([
    [1, 0],
    [0, 1],
    [0.5, 0.3],
    [2, 5],
])

groups, element_group_ixs = np.unique(grouping, return_inverse=True)
accum = np.zeros((groups.shape[0], *to_sum.shape[1:]))
np.add.at(accum, element_group_ixs, to_sum)

結果是：

groups = array([ 1.1, 10. , 15. ])
accum = array([
    [1.5, 0.3],
    [0. , 1. ],
    [2. , 5. ]
])

（np.add.at 想法取自彼得的回答）