Подсчет различных значений в столбце на основе второго столбца

У меня есть большой набор данных Stata со многими строками и столбцами, но мне нужны только 2 столбца: H и L.

Например:

    +----------+
    |  H  |  L |
    |-----|-----
 1. |  12 |  0 |
 2. |  43 |  1 |
 3. |  12 |  1 |
 4. |  43 |  1 |
 5. |  43 |  1 |
 6. |  3  |  0 |
 7. |  4  |  0 |
 8. |  3  |  1 |
 9. |  3  |  1 |
10. |  3  |  1 |
    +----------+

Мне нужны уникальные элементы из столбца H и общее количество sum для этого значения H в столбце L:

    +----------+
    |  H  |  L |
    |-----|-----
    |  12 |  1 |
    |  43 |  3 |
    |  3  |  3 |
    |  4  |  0 |
    +----------+

Я также хочу, чтобы значения отсортировались по убыванию сумм L и только значений в L больше, чем 2:

    +----------+
    |  H  |  L |
    |-----|-----
    |  43 |  3 |
    |  3  |  3 |
    +----------+

unique stata
person user3480774    schedule 23.01.2019    source источник

Ответы (2)


arrow_upward
3
arrow_downward

Если вы не хотите уничтожать свой набор данных с помощью collapse, вы можете сделать следующее:

clear
input H L
12 0
43 1
12 1
43 1
43 1
3 0
4 0
3 1
3 1
3 1
end

bysort H (L): generate M = sum(L)
bysort H (L): generate H2 = H if _n == _N
bysort H (L): generate L2 = M if _n == _N

gsort - H2 L2
list

     +----------------------+
     |  H   L   M   H2   L2 |
     |----------------------|
  1. | 43   1   3   43    3 |
  2. | 12   1   1   12    1 |
  3. |  4   0   0    4    0 |
  4. |  3   1   3    3    3 |
  5. | 43   1   2    .    . |
     |----------------------|
  6. |  3   1   2    .    . |
  7. |  3   0   0    .    . |
  8. |  3   1   1    .    . |
  9. | 12   0   0    .    . |
 10. | 43   1   1    .    . |
     +----------------------

Также:

generate H3 = H2 if L2 > 2
generate L3 = L2 if L2 > 2

gsort - L3
list

     +--------------------------------+
     |  H   L   M   H2   L2   H3   L3 |
     |--------------------------------|
  1. | 43   1   3   43    3   43    3 |
  2. |  3   1   3    3    3    3    3 |
  3. |  3   1   2    .    .    .    . |
  4. | 43   1   1    .    .    .    . |
  5. | 12   1   1   12    1    .    . |
     |--------------------------------|
  6. |  3   0   0    .    .    .    . |
  7. |  4   0   0    4    0    .    . |
  8. |  3   1   1    .    .    .    . |
  9. | 43   1   2    .    .    .    . |
 10. | 12   0   0    .    .    .    . |
     +--------------------------------+

С большими наборами данных быстрее работать на mata — матричном языке программирования Stata:

mata: 
D = st_data(., ("H", "L"))
H = uniqrows(D[1::rows(D),1])

_sort(D,1)
_sort(H,1)

rH = rows(H)
res = J(rH, 2, .)

for (i = 1; i <= rH; i++) {
    index = selectindex(D[.,1]:==H[i,1])
    sumL = sum(D[.,2][index])
    res[i,1] = H[i]
    res[i,2] = sumL
}

index = selectindex(res[.,2]:>2)
res2 = res[.,1][index], res[.,2][index]
_sort(res2,-1)
end

Это произведет:

mata: res
        1    2
    +-----------+
  1 |   3    3  |
  2 |   4    0  |
  3 |  12    1  |
  4 |  43    3  |
    +-----------+

mata: res2

        1    2
    +-----------+
  1 |  43    3  |
  2 |   3    3  |
    +-----------+

Затем вы можете передать результаты обратно в Stata следующим образом:

getmata (H2 L2)=res (H3 L3)=res2, force

list

     +----------------------------+
     |  H   L   H2   L2   H3   L3 |
     |----------------------------|
  1. | 12   0    3    3   43    3 |
  2. | 43   1    4    0    3    3 |
  3. | 12   1   12    1    .    . |
  4. | 43   1   43    3    .    . |
  5. | 43   1    .    .    .    . |
     |----------------------------|
  6. |  3   0    .    .    .    . |
  7. |  4   0    .    .    .    . |
  8. |  3   1    .    .    .    . |
  9. |  3   1    .    .    .    . |
 10. |  3   1    .    .    .    . |
     +----------------------------+
person Community    schedule 23.01.2019

arrow_upward
2
arrow_downward

Вы можете использовать collapse и сохранить определенные наблюдения.

collapse (sum) L, by(H)
gsort -H
keep if L >= 2

Выход:

 H    L

43    3
 3    3
person Joe Patten    schedule 23.01.2019