Eu tenho alguma saída na forma de:

count  id     type
588    10 |    3
 10    12 |    3
883    14 |    3
 98    17 |    3
 17    18 |    1
77598    18 |    3
10000    21 |    3
17892     2 |    3
20000    23 |    3
 63    27 |    3
  6     3 |    3
 2446    35 |    3
 14    4 |    3
 15     4 |    1
253     4 |    2
19857     4 |    3
 1000     5 |    3
...

O que é bastante confuso e precisa ser limpo em um CSV para que eu possa presenteá-lo a um gerente de projeto para eles a planilha.

O núcleo do problema é este: preciso que a saída seja:

id, sum_of_type_1, sum_of_type_2, sum_of_type_3

Um exemplo disso é o ID "4":

14    4 |    3
 15     4 |    1
253     4 |    2
19857     4 |    3

Em vez disso, deve ser:

4,15,253,19871

Infelizmente, sou um lixo nesse tipo de coisa, consegui limpar todas as linhas e entrar no CSV, mas não consegui desduplicar e agrupar as linhas. Agora eu tenho isso:

awk 'BEGIN{OFS=",";} {split($line, part, " "); print part[1],part[2],part[4]}' | awk '{ gsub (" ", "", $0); print}'

Mas tudo o que faz é limpar os caracteres do lixo e imprimir as linhas novamente.

Qual é a melhor maneira de massagear as linhas na saída mencionada acima?

Uma maneira de fazer isso é colocar tudo em um hash.

# put values into a hash based on the id and tag
awk 'NR>1{n[$2","$4]+=$1}
END{
    # merge the same ids on the one line
    for(i in n){
        id=i;
        sub(/,.*/,"",id);
        a[id]=a[id]","n[i];
    }
    # print everyhing
    for(i in a){
        print i""a[i];
    }
}'

editar: minha primeira resposta não respondeu à pergunta corretamente

Perl para o resgate:

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

<>;  # Skip the header.

my %sum;
my %types;
while (<>) {
    my ($count, $id, $type) = grep length, split '[\s|]+';
    $sum{$id}{$type} += $count;
    $types{$type} = 1;
}

say join ',', 'id', sort keys %types;
for my $id (sort { $a <=> $b } keys %sum) {
    say join ',', $id, map $_ // q(), @{ $sum{$id} }{ sort keys %types };
}

Ele mantém duas tabelas, tabela de tipos e tabela de IDs. Para cada ID, ele armazena a soma por tipo.

Se o GNU datamash for uma opção para você, então

awk 'NR>1 {print $1, $2, $4}' OFS=, file | datamash -t, -s --filler=0 crosstab 2,3 sum 1
,1,2,3
10,0,0,588
12,0,0,10
14,0,0,883
17,0,0,98
18,17,0,77598
2,0,0,17892
21,0,0,10000
23,0,0,20000
27,0,0,63
3,0,0,6
35,0,0,2446
4,15,253,19871
5,0,0,1000

Python (e a pandasbiblioteca em particular é muito adequada para esse tipo de trabalho

data = """count  id     type
588    10 |    3
 10    12 |    3
883    14 |    3
 98    17 |    3
 17    18 |    1
77598    18 |    3
10000    21 |    3
17892     2 |    3
20000    23 |    3
 63    27 |    3
  6     3 |    3
 2446    35 |    3
 14    4 |    3
 15     4 |    1
253     4 |    2
19857     4 |    3
 1000     5 |    3"""

import pandas as pd
from io import StringIO # to read from string, not needed to read from file

df = pd.read_csv(StringIO(data), sep=sep='\s+\|?\s*', index_col=None, engine='python')

Isso lê os dados csv em um pandas DataFrame

    count  id  type
0     588  10     3
1      10  12     3
2     883  14     3
3      98  17     3
4      17  18     1
5   77598  18     3
6   10000  21     3
7   17892   2     3
8   20000  23     3
9      63  27     3
10      6   3     3
11   2446  35     3
12     14   4     3
13     15   4     1
14    253   4     2
15  19857   4     3
16   1000   5     3

Em seguida, agrupamos esses dados por ide pegamos a soma da colunacount

df_sum = df.groupby(('type', 'id'))['count'].sum().unstack('type').fillna(0)

o unstack remodelações para mover os IDs para as colunas e fillnapreenche os campos vazios com os 0s

df_sum.to_csv()

Isso retorna

id,1,2,3
2,0.0,0.0,17892.0
3,0.0,0.0,6.0
4,15.0,253.0,19871.0
5,0.0,0.0,1000.0
10,0.0,0.0,588.0
12,0.0,0.0,10.0
14,0.0,0.0,883.0
17,0.0,0.0,98.0
18,17.0,0.0,77598.0
21,0.0,0.0,10000.0
23,0.0,0.0,20000.0
27,0.0,0.0,63.0
35,0.0,0.0,2446.0

Como o quadro de dados contém dados ausentes (combinações vazias de tipo de identificação), o pandas transforma os ints em float(limitação do funcionamento interno). Se você souber que as entradas serão apenas int, poderá alterar a penúltima linha paradf_sum = df.groupby(('type', 'id'))['count'].sum().unstack('type').fillna(0).astype(int)

Você pode usar o Perl para fazer um loop sobre o arquivo CSV e acumular a soma dos tipos apropriados em um hash enquanto estiver no caminho. E, no final, exiba as informações coletadas para cada ID.

Estrutura de dados

%h = (
   ID1    =>  [ sum_of_type1, sum_of_type2, sum_of_type3 ],
   ...
)

Isso ajuda a entender o código abaixo:

Perl

perl -wMstrict -Mvars='*h' -F'\s+|\|' -lane '
   $, = chr 44, next if $. == 1;

   my($count, $id, $type) = grep /./, @F;
   $h{ $id }[ $type-1 ] += $count}{
   print $_, map { $_ || 0 } @{ $h{$_} } for sort { $a <=> $b } keys %h
' yourcsvfile

Resultado

2,0,0,17892
3,0,0,6
4,15,253,19871
5,0,0,1000
...

minha opinião, não muito diferente dos outros. Usa o GNU awk que possui matrizes de matrizes

gawk '
    NR == 1 {next}
    {count[$2][$4] += $1}
    END {
        for (id in count) {
            printf "%d", id
            for (type=1; type<=3; type++) {
                # add zero to coerce possible empty string into a number 
                printf ",%d", 0 + count[id][type]
            }
            print ""        # adds the newline for this line
        }
    }
' file

saídas

2,0,0,17892
3,0,0,6
4,15,253,19871
5,0,0,1000
10,0,0,588
12,0,0,10
14,0,0,883
17,0,0,98
18,17,0,77598
21,0,0,10000
23,0,0,20000
27,0,0,63
35,0,0,2446

Você pode usar esse código para resumir valores com base na sua coluna de ID,

Eu adicionei uma declaração awk após o seu código

awk 'BEGIN{OFS=",";} {split($line, part, " "); print part[1],part[2],part[4]}' abcd | awk '{ gsub (" ", "", $0); print}' | awk 'BEGIN{FS=OFS=SUBSEP=","}{arr[$2,$3]+=$1;}END{for ( i in arr ) print i,arr[i];}'

Vá em frente com isso ...