Existe uma maneira de ignorar as linhas de cabeçalho em uma classificação UNIX?

Eu tenho um arquivo de campo de largura fixa que estou tentando classificar usando o utilitário de classificação UNIX (Cygwin, no meu caso).

O problema é que há um cabeçalho de duas linhas na parte superior do arquivo que está sendo classificado na parte inferior do arquivo (pois cada linha de cabeçalho começa com dois pontos).

Existe uma maneira de dizer à classificação "passar as duas primeiras linhas entre não classificados" ou de especificar uma ordem que classifique as linhas de dois pontos no topo - as linhas restantes são sempre iniciadas com um numérico de 6 dígitos (que é na verdade a chave I estou classificando) se isso ajudar.

Exemplo:

:0:12345
:1:6:2:3:8:4:2
010005TSTDOG_FOOD01
500123TSTMY_RADAR00
222334NOTALINEOUT01
477821USASHUTTLES21
325611LVEANOTHERS00

deve classificar para:

:0:12345
:1:6:2:3:8:4:2
010005TSTDOG_FOOD01
222334NOTALINEOUT01
325611LVEANOTHERS00
477821USASHUTTLES21
500123TSTMY_RADAR00

(head -n 2 <file> && tail -n +3 <file> | sort) > newfile

Os parênteses criam um subshell, envolvendo o stdout para que você possa canalizá-lo ou redirecioná-lo como se tivesse vindo de um único comando.

Se você não se importa de usar awk, pode aproveitarawk capacidades de tubulação integradas do

por exemplo.

extract_data | awk 'NR<3{print $0;next}{print $0| "sort -r"}' 

Isso imprime as duas primeiras linhas textualmente e canaliza o resto através sort .

Observe que isso tem a vantagem muito específica de poder classificar seletivamente as partes de uma entrada canalizada. todos os outros métodos sugeridos apenas classificarão arquivos simples que podem ser lidos várias vezes. Isso funciona em qualquer coisa.

Esta é uma versão que funciona em dados canalizados:

(read -r; printf "%s\n" "$REPLY"; sort)

Se o seu cabeçalho tiver várias linhas:

(for i in $(seq $HEADER_ROWS); do read -r; printf "%s\n" "$REPLY"; done; sort)

Esta solução é daqui

Em casos simples, sedpode fazer o trabalho com elegância:

    your_script | (sed -u 1q; sort)

ou equivalente,

    cat your_data | (sed -u 1q; sort)

A chave está em 1q- imprime a primeira linha (cabeçalho) e sai (deixando o resto da entrada parasort ).

Para o exemplo dado, 2q fará o truque.

A -uopção (sem buffer) é necessária para aqueles seds (notavelmente, GNU's) que, de outra forma, leriam a entrada em blocos, consumindo, assim, os dados que você deseja acessar sort.

Você pode usar tail -n +3 <file> | sort ...(tail produzirá o conteúdo do arquivo da 3ª linha).

head -2 <your_file> && nawk 'NR>2' <your_file> | sort

exemplo:

> cat temp
10
8
1
2
3
4
5
> head -2 temp && nawk 'NR>2' temp | sort -r
10
8
5
4
3
2
1

Leva apenas 2 linhas de código ...

head -1 test.txt > a.tmp; 
tail -n+2 test.txt | sort -n >> a.tmp;

Para dados numéricos, -n é obrigatório. Para classificação alfa, o -n não é necessário.

Arquivo de exemplo:
$ cat test.txt

cabeçalho
8
5
100
1
-1

Resultado:
$ cat a.tmp

cabeçalho
-1
1
5
8
100

Então aqui está uma função bash onde os argumentos são exatamente como sort. Arquivos e canais de suporte.

function skip_header_sort() {
    if [[ $# -gt 0 ]] && [[ -f ${@: -1} ]]; then
        local file=${@: -1}
        set -- "${@:1:$(($#-1))}"
    fi
    awk -vsargs="$*" 'NR<2{print; next}{print | "sort "sargs}' $file
}

Como funciona. Esta linha verifica se há pelo menos um argumento e se o último argumento é um arquivo.

    if [[ $# -gt 0 ]] && [[ -f ${@: -1} ]]; then

Isso salva o arquivo para separar o argumento. Já que estamos prestes a apagar o último argumento.

        local file=${@: -1}

Aqui removemos o último argumento. Já que não queremos passá-lo como um argumento de classificação.

        set -- "${@:1:$(($#-1))}"

Finalmente, fazemos a parte do awk, passando os argumentos (menos o último argumento se for o arquivo) para classificar no awk. Isso foi originalmente sugerido por Dave e modificado para aceitar argumentos de classificação. Contamos com o fato de que $fileestará vazio se estivermos encanando, portanto, será ignorado.

    awk -vsargs="$*" 'NR<2{print; next}{print | "sort "sargs}' $file

Exemplo de uso com um arquivo separado por vírgulas.

$ cat /tmp/test
A,B,C
0,1,2
1,2,0
2,0,1

# SORT NUMERICALLY SECOND COLUMN
$ skip_header_sort -t, -nk2 /tmp/test
A,B,C
2,0,1
0,1,2
1,2,0

# SORT REVERSE NUMERICALLY THIRD COLUMN
$ cat /tmp/test | skip_header_sort -t, -nrk3
A,B,C
0,1,2
2,0,1
1,2,0

Com Python:

import sys
HEADER_ROWS=2

for _ in range(HEADER_ROWS):
    sys.stdout.write(next(sys.stdin))
for row in sorted(sys.stdin):
    sys.stdout.write(row)

Aqui está uma função shell bash derivada de outras respostas. Ele lida com arquivos e canais. O primeiro argumento é o nome do arquivo ou '-' para stdin. Os argumentos restantes são passados ​​para classificação. Alguns exemplos:

$ hsort myfile.txt
$ head -n 100 myfile.txt | hsort -
$ hsort myfile.txt -k 2,2 | head -n 20 | hsort - -r

A função shell:

hsort ()
{
   if [ "$1" == "-h" ]; then
       echo "Sort a file or standard input, treating the first line as a header.";
       echo "The first argument is the file or '-' for standard input. Additional";
       echo "arguments to sort follow the first argument, including other files.";
       echo "File syntax : $ hsort file [sort-options] [file...]";
       echo "STDIN syntax: $ hsort - [sort-options] [file...]";
       return 0;
   elif [ -f "$1" ]; then
       local file=$1;
       shift;
       (head -n 1 $file && tail -n +2 $file | sort $*);
   elif [ "$1" == "-" ]; then
       shift;
       (read -r; printf "%s\n" "$REPLY"; sort $*);
   else
       >&2 echo "Error. File not found: $1";
       >&2 echo "Use either 'hsort <file> [sort-options]' or 'hsort - [sort-options]'";
       return 1 ;
   fi
}

Esta é a mesma resposta de Ian Sherbin, mas minha implementação é: -

cut -d'|' -f3,4,7 $arg1 | uniq > filetmp.tc
head -1 filetmp.tc > file.tc;
tail -n+2 filetmp.tc | sort -t"|" -k2,2 >> file.tc;

cat file_name.txt | sed 1d | sort 

Isso fará o que você quiser.