Un moyen efficace de transposer un fichier dans Bash

J'ai un énorme fichier séparé par des tabulations formaté comme ça

X column1 column2 column3
row1 0 1 2
row2 3 4 5
row3 6 7 8
row4 9 10 11

Je voudrais le transposer de manière efficace en n'utilisant que des commandes bash (je pourrais écrire un script Perl d'une dizaine de lignes pour cela, mais il devrait être plus lent à exécuter que les fonctions bash natives). Ainsi, la sortie devrait ressembler à

X row1 row2 row3 row4
column1 0 3 6 9
column2 1 4 7 10
column3 2 5 8 11

J'ai pensé à une solution comme celle-ci

cols=`head -n 1 input | wc -w`
for (( i=1; i <= $cols; i++))
do cut -f $i input | tr $'\n' $'\t' | sed -e "s/\t$/\n/g" >> output
done

Mais c'est lent et ne semble pas la solution la plus efficace. J'ai vu une solution pour vi dans cet article , mais elle est toujours trop lente. Des pensées / suggestions / idées brillantes? :-)

awk '
{ 
    for (i=1; i<=NF; i++)  {
        a[NR,i] = $i
    }
}
NF>p { p = NF }
END {    
    for(j=1; j<=p; j++) {
        str=a[1,j]
        for(i=2; i<=NR; i++){
            str=str" "a[i,j];
        }
        print str
    }
}' file

production

$ more file
0 1 2
3 4 5
6 7 8
9 10 11

$ ./shell.sh
0 3 6 9
1 4 7 10
2 5 8 11

Performance par rapport à la solution Perl de Jonathan sur un fichier de 10000 lignes

$ head -5 file
1 0 1 2
2 3 4 5
3 6 7 8
4 9 10 11
1 0 1 2

$  wc -l < file
10000

$ time perl test.pl file >/dev/null

real    0m0.480s
user    0m0.442s
sys     0m0.026s

$ time awk -f test.awk file >/dev/null

real    0m0.382s
user    0m0.367s
sys     0m0.011s

$ time perl test.pl file >/dev/null

real    0m0.481s
user    0m0.431s
sys     0m0.022s

$ time awk -f test.awk file >/dev/null

real    0m0.390s
user    0m0.370s
sys     0m0.010s

EDIT par Ed Morton (@ ghostdog74 n'hésitez pas à supprimer si vous désapprouvez).

Peut-être que cette version avec des noms de variables plus explicites aidera à répondre à certaines des questions ci-dessous et à clarifier généralement ce que fait le script. Il utilise également des tabulations comme séparateur que l'OP avait initialement demandé afin de gérer les champs vides et cela par coïncidence embellit un peu la sortie pour ce cas particulier.

$ cat tst.awk
BEGIN { FS=OFS="\t" }
{
    for (rowNr=1;rowNr<=NF;rowNr++) {
        cell[rowNr,NR] = $rowNr
    }
    maxRows = (NF > maxRows ? NF : maxRows)
    maxCols = NR
}
END {
    for (rowNr=1;rowNr<=maxRows;rowNr++) {
        for (colNr=1;colNr<=maxCols;colNr++) {
            printf "%s%s", cell[rowNr,colNr], (colNr < maxCols ? OFS : ORS)
        }
    }
}

$ awk -f tst.awk file
X       row1    row2    row3    row4
column1 0       3       6       9
column2 1       4       7       10
column3 2       5       8       11

Les solutions ci-dessus fonctionneront dans n'importe quel awk (sauf l'ancien awk cassé bien sûr - il y a YMMV).

Les solutions ci-dessus lisent cependant le fichier entier en mémoire - si les fichiers d'entrée sont trop volumineux pour cela, vous pouvez le faire:

$ cat tst.awk
BEGIN { FS=OFS="\t" }
{ printf "%s%s", (FNR>1 ? OFS : ""), $ARGIND }
ENDFILE {
    print ""
    if (ARGIND < NF) {
        ARGV[ARGC] = FILENAME
        ARGC++
    }
}
$ awk -f tst.awk file
X       row1    row2    row3    row4
column1 0       3       6       9
column2 1       4       7       10
column3 2       5       8       11

qui n'utilise presque pas de mémoire mais lit le fichier d'entrée une fois par nombre de champs sur une ligne, il sera donc beaucoup plus lent que la version qui lit le fichier entier en mémoire. Il suppose également que le nombre de champs est le même sur chaque ligne et utilise GNU awk pour ENDFILEet ARGINDmais tout awk peut faire la même chose avec des tests sur FNR==1et END.

Une autre option consiste à utiliser rs:

rs -c' ' -C' ' -T

-cmodifie le séparateur de colonne d'entrée, -Cmodifie le séparateur de colonne de sortie et -Ttranspose les lignes et les colonnes. Ne pas utiliser à la -tplace de -T, car il utilise un nombre de lignes et de colonnes calculé automatiquement qui n'est généralement pas correct. rs, qui porte le nom de la fonction de remodelage dans APL, est fourni avec les BSD et OS X, mais il devrait être disponible auprès des gestionnaires de paquets sur d'autres plates-formes.

Une deuxième option consiste à utiliser Ruby:

ruby -e'puts readlines.map(&:split).transpose.map{|x|x*" "}'

Une troisième option consiste à utiliser jq:

jq -R .|jq -sr 'map(./" ")|transpose|map(join(" "))[]'

jq -R .imprime chaque ligne d'entrée en tant que littéral de chaîne JSON, -s( --slurp) crée un tableau pour les lignes d'entrée après avoir analysé chaque ligne en tant que JSON, et -r( --raw-output) génère le contenu des chaînes au lieu des littéraux de chaîne JSON. L' /opérateur est surchargé pour fractionner les chaînes.

Une solution Python:

python -c "import sys; print('\n'.join(' '.join(c) for c in zip(*(l.split() for l in sys.stdin.readlines() if l.strip()))))" < input > output

Ce qui précède est basé sur les éléments suivants:

import sys

for c in zip(*(l.split() for l in sys.stdin.readlines() if l.strip())):
    print(' '.join(c))

Ce code suppose que chaque ligne a le même nombre de colonnes (aucun remplissage n'est effectué).

le projet transpose sur sourceforge est un programme C de type coreutil pour exactement cela.

gcc transpose.c -o transpose
./transpose -t input > output #works with stdin, too.

Pure BASH, pas de processus supplémentaire. Un bel exercice:

declare -a array=( )                      # we build a 1-D-array

read -a line < "$1"                       # read the headline

COLS=${#line[@]}                          # save number of columns

index=0
while read -a line ; do
    for (( COUNTER=0; COUNTER<${#line[@]}; COUNTER++ )); do
        array[$index]=${line[$COUNTER]}
        ((index++))
    done
done < "$1"

for (( ROW = 0; ROW < COLS; ROW++ )); do
  for (( COUNTER = ROW; COUNTER < ${#array[@]}; COUNTER += COLS )); do
    printf "%s\t" ${array[$COUNTER]}
  done
  printf "\n" 
done

Jetez un œil au datamash GNU qui peut être utilisé comme datamash transpose. Une future version prendra également en charge la tabulation croisée (tableaux croisés dynamiques)

Voici un script Perl moyennement solide pour faire le travail. Il existe de nombreuses analogies structurelles avec la awksolution de @ ghostdog74 .

#!/bin/perl -w
#
# SO 1729824

use strict;

my(%data);          # main storage
my($maxcol) = 0;
my($rownum) = 0;
while (<>)
{
    my(@row) = split /\s+/;
    my($colnum) = 0;
    foreach my $val (@row)
    {
        $data{$rownum}{$colnum++} = $val;
    }
    $rownum++;
    $maxcol = $colnum if $colnum > $maxcol;
}

my $maxrow = $rownum;
for (my $col = 0; $col < $maxcol; $col++)
{
    for (my $row = 0; $row < $maxrow; $row++)
    {
        printf "%s%s", ($row == 0) ? "" : "\t",
                defined $data{$row}{$col} ? $data{$row}{$col} : "";
    }
    print "\n";
}

Avec la taille des données de l'échantillon, la différence de performance entre perl et awk était négligeable (1 milliseconde sur 7 au total). Avec un ensemble de données plus grand (matrice 100x100, entrées de 6 à 8 caractères chacune), perl a légèrement surpassé awk - 0,026s contre 0,042s. Ni l'un ni l'autre ne posera probablement de problème.

Timings représentatifs pour Perl 5.10.1 (32 bits) vs awk (version 20040207 lorsque '-V') vs gawk 3.1.7 (32 bits) sur MacOS X 10.5.8 sur un fichier contenant 10000 lignes avec 5 colonnes par ligne:

Osiris JL: time gawk -f tr.awk xxx  > /dev/null

real    0m0.367s
user    0m0.279s
sys 0m0.085s
Osiris JL: time perl -f transpose.pl xxx > /dev/null

real    0m0.138s
user    0m0.128s
sys 0m0.008s
Osiris JL: time awk -f tr.awk xxx  > /dev/null

real    0m1.891s
user    0m0.924s
sys 0m0.961s
Osiris-2 JL: 

Notez que gawk est beaucoup plus rapide que awk sur cette machine, mais toujours plus lent que perl. De toute évidence, votre kilométrage variera.

Si vous avez scinstallé, vous pouvez faire:

psc -r < inputfile | sc -W% - > outputfile

Il existe un utilitaire spécialement conçu pour cela,

Utilitaire de datamash GNU

apt install datamash  

datamash transpose < yourfile

Tiré de ce site, https://www.gnu.org/software/datamash/ et http://www.thelinuxrain.com/articles/transposing-rows-and-columns-3-methods

En supposant que toutes vos lignes ont le même nombre de champs, ce programme awk résout le problème:

{for (f=1;f<=NF;f++) col[f] = col[f]":"$f} END {for (f=1;f<=NF;f++) print col[f]}

En mots, lorsque vous bouclez sur les lignes, pour chaque champ, fdéveloppez une chaîne séparée par un «:» col[f]contenant les éléments de ce champ. Une fois que vous avez terminé avec toutes les lignes, imprimez chacune de ces chaînes sur une ligne distincte. Vous pouvez ensuite remplacer «:» pour le séparateur souhaité (par exemple, un espace) en acheminant la sortie à travers tr ':' ' '.

Exemple:

$ echo "1 2 3\n4 5 6"
1 2 3
4 5 6

$ echo "1 2 3\n4 5 6" | awk '{for (f=1;f<=NF;f++) col[f] = col[f]":"$f} END {for (f=1;f<=NF;f++) print col[f]}' | tr ':' ' '
 1 4
 2 5
 3 6

GNU datamash est parfaitement adapté à ce problème avec une seule ligne de code et une taille de fichier potentiellement arbitrairement grande!

datamash -W transpose infile > outfile

Une solution perl hackish peut être comme ça. C'est bien car il ne charge pas tous les fichiers en mémoire, imprime les fichiers temporaires intermédiaires, puis utilise la pâte merveilleuse

#!/usr/bin/perl
use warnings;
use strict;

my $counter;
open INPUT, "<$ARGV[0]" or die ("Unable to open input file!");
while (my $line = <INPUT>) {
    chomp $line;
    my @array = split ("\t",$line);
    open OUTPUT, ">temp$." or die ("unable to open output file!");
    print OUTPUT join ("\n",@array);
    close OUTPUT;
    $counter=$.;
}
close INPUT;

# paste files together
my $execute = "paste ";
foreach (1..$counter) {
    $execute.="temp$counter ";
}
$execute.="> $ARGV[1]";
system $execute;

La seule amélioration que je peux voir pour votre propre exemple est l'utilisation de awk, qui réduira le nombre de processus exécutés et la quantité de données acheminées entre eux:

/bin/rm output 2> /dev/null

cols=`head -n 1 input | wc -w` 
for (( i=1; i <= $cols; i++))
do
  awk '{printf ("%s%s", tab, $'$i'); tab="\t"} END {print ""}' input
done >> output

J'utilise normalement ce petit awkextrait de code pour cette exigence:

  awk '{for (i=1; i<=NF; i++) a[i,NR]=$i
        max=(max<NF?NF:max)}
        END {for (i=1; i<=max; i++)
              {for (j=1; j<=NR; j++) 
                  printf "%s%s", a[i,j], (j==NR?RS:FS)
              }
        }' file

Cela charge simplement toutes les données dans un tableau bidimensionnel a[line,column], puis les réimprime en tant que a[column,line], de sorte qu'il transpose l'entrée donnée.

Cela doit garder une trace du maxnombre imum de colonnes du fichier initial, de sorte qu'il soit utilisé comme nombre de lignes à imprimer.

J'ai utilisé la solution de fgm (merci fgm!), Mais j'avais besoin d'éliminer les caractères de tabulation à la fin de chaque ligne, donc j'ai modifié le script ainsi:

#!/bin/bash 
declare -a array=( )                      # we build a 1-D-array

read -a line < "$1"                       # read the headline

COLS=${#line[@]}                          # save number of columns

index=0
while read -a line; do
    for (( COUNTER=0; COUNTER<${#line[@]}; COUNTER++ )); do
        array[$index]=${line[$COUNTER]}
        ((index++))
    done
done < "$1"

for (( ROW = 0; ROW < COLS; ROW++ )); do
  for (( COUNTER = ROW; COUNTER < ${#array[@]}; COUNTER += COLS )); do
    printf "%s" ${array[$COUNTER]}
    if [ $COUNTER -lt $(( ${#array[@]} - $COLS )) ]
    then
        printf "\t"
    fi
  done
  printf "\n" 
done

Je cherchais juste un tranpose bash similaire mais avec un support pour le rembourrage. Voici le script que j'ai écrit basé sur la solution de fgm, qui semble fonctionner. Si cela peut être utile ...

#!/bin/bash 
declare -a array=( )                      # we build a 1-D-array
declare -a ncols=( )                      # we build a 1-D-array containing number of elements of each row

SEPARATOR="\t";
PADDING="";
MAXROWS=0;
index=0
indexCol=0
while read -a line; do
    ncols[$indexCol]=${#line[@]};
((indexCol++))
if [ ${#line[@]} -gt ${MAXROWS} ]
    then
         MAXROWS=${#line[@]}
    fi    
    for (( COUNTER=0; COUNTER<${#line[@]}; COUNTER++ )); do
        array[$index]=${line[$COUNTER]}
        ((index++))

    done
done < "$1"

for (( ROW = 0; ROW < MAXROWS; ROW++ )); do
  COUNTER=$ROW;
  for (( indexCol=0; indexCol < ${#ncols[@]}; indexCol++ )); do
if [ $ROW -ge ${ncols[indexCol]} ]
    then
      printf $PADDING
    else
  printf "%s" ${array[$COUNTER]}
fi
if [ $((indexCol+1)) -lt ${#ncols[@]} ]
then
  printf $SEPARATOR
    fi
    COUNTER=$(( COUNTER + ncols[indexCol] ))
  done
  printf "\n" 
done

Je cherchais une solution pour transposer tout type de matrice (nxn ou mxn) avec tout type de données (nombres ou données) et j'ai obtenu la solution suivante:

Row2Trans=number1
Col2Trans=number2

for ((i=1; $i <= Line2Trans; i++));do
    for ((j=1; $j <=Col2Trans ; j++));do
        awk -v var1="$i" -v var2="$j" 'BEGIN { FS = "," }  ; NR==var1 {print $((var2)) }' $ARCHIVO >> Column_$i
    done
done

paste -d',' `ls -mv Column_* | sed 's/,//g'` >> $ARCHIVO

Si vous ne voulez extraire qu'une seule ligne (délimitée par des virgules) $ N d'un fichier et la transformer en colonne:

head -$N file | tail -1 | tr ',' '\n'

Pas très élégant, mais cette commande "sur une seule ligne" résout le problème rapidement:

cols=4; for((i=1;i<=$cols;i++)); do \
            awk '{print $'$i'}' input | tr '\n' ' '; echo; \
        done

Ici cols est le nombre de colonnes, où vous pouvez remplacer 4 par head -n 1 input | wc -w.

Une autre awksolution et une entrée limitée avec la taille de la mémoire dont vous disposez.

awk '{ for (i=1; i<=NF; i++) RtoC[i]= (RtoC[i]? RtoC[i] FS $i: $i) }
    END{ for (i in RtoC) print RtoC[i] }' infile

Cela joint chaque même position de numéro de fichier dans ensemble et ENDimprime le résultat qui serait la première ligne de la première colonne, la deuxième ligne de la deuxième colonne, etc.

X row1 row2 row3 row4
column1 0 3 6 9
column2 1 4 7 10
column3 2 5 8 11

Certains utilitaires standard * nix one-liners, aucun fichier temporaire n'est nécessaire. NB: le PO voulait une solution efficace , (c'est-à-dire plus rapide), et les premières réponses sont généralement plus rapides que cette réponse. Ces one-liners sont pour ceux qui aiment les outils logiciels * nix , pour quelque raison que ce soit. Dans de rares cas ( par exemple, E / S et mémoire rares), ces extraits peuvent en fait être plus rapides que certaines des principales réponses.

Appelez le fichier d'entrée foo .

1. Si nous savons que foo a quatre colonnes:

   for f in 1 2 3 4 ; do cut -d ' ' -f $f foo | xargs echo ; done

2. Si nous ne savons pas combien de colonnes foo a:

   n=$(head -n 1 foo | wc -w)
   for f in $(seq 1 $n) ; do cut -d ' ' -f $f foo | xargs echo ; done

   xargsa une taille limite et ferait donc un travail incomplet avec un long fichier. Quelle taille limite dépend du système, par exemple:

   { timeout '.01' xargs --show-limits ; } 2>&1 | grep Max

   Longueur maximale de commande que nous pourrions réellement utiliser: 2088944

3. tr& echo:

   for f in 1 2 3 4; do cut -d ' ' -f $f foo | tr '\n\ ' ' ; echo; done

   ... ou si le nombre de colonnes est inconnu:

   n=$(head -n 1 foo | wc -w)
   for f in $(seq 1 $n); do 
       cut -d ' ' -f $f foo | tr '\n' ' ' ; echo
   done

4. L'utilisation set, qui aime xargs, a des limitations similaires basées sur la taille de la ligne de commande:

   for f in 1 2 3 4 ; do set - $(cut -d ' ' -f $f foo) ; echo $@ ; done

#!/bin/bash

aline="$(head -n 1 file.txt)"
set -- $aline
colNum=$#

#set -x
while read line; do
  set -- $line
  for i in $(seq $colNum); do
    eval col$i="\"\$col$i \$$i\""
  done
done < file.txt

for i in $(seq $colNum); do
  eval echo \${col$i}
done

une autre version avec set eval

Une autre variante bash

$ cat file 
XXXX    col1    col2    col3
row1    0       1       2
row2    3       4       5
row3    6       7       8
row4    9       10      11

Scénario

#!/bin/bash

I=0
while read line; do
    i=0
    for item in $line; { printf -v A$I[$i] $item; ((i++)); }
    ((I++))
done < file
indexes=$(seq 0 $i)

for i in $indexes; {
    J=0
    while ((J<I)); do
        arr="A$J[$i]"
        printf "${!arr}\t"
        ((J++))
    done
    echo
}

Production

$ ./test 
XXXX    row1    row2    row3    row4    
col1    0       3       6       9   
col2    1       4       7       10  
col3    2       5       8       11

Voici une solution Haskell. Une fois compilé avec -O2, il fonctionne légèrement plus vite que awk de ghostdog et légèrement plus lent que le python c finement enveloppé de Stephan sur ma machine pour les lignes d'entrée répétées "Hello world". Malheureusement, le support de GHC pour passer le code de ligne de commande est inexistant pour autant que je sache, vous devrez donc l'écrire dans un fichier vous-même. Il tronquera les lignes à la longueur de la ligne la plus courte.

transpose :: [[a]] -> [[a]]
transpose = foldr (zipWith (:)) (repeat [])

main :: IO ()
main = interact $ unlines . map unwords . transpose . map words . lines

Une solution awk qui stocke l'ensemble de la baie en mémoire

    awk '$0!~/^$/{    i++;
                  split($0,arr,FS);
                  for (j in arr) {
                      out[i,j]=arr[j];
                      if (maxr<j){ maxr=j}     # max number of output rows.
                  }
            }
    END {
        maxc=i                 # max number of output columns.
        for     (j=1; j<=maxr; j++) {
            for (i=1; i<=maxc; i++) {
                printf( "%s:", out[i,j])
            }
            printf( "%s\n","" )
        }
    }' infile

Mais nous pouvons "parcourir" le fichier autant de fois que les lignes de sortie sont nécessaires:

#!/bin/bash
maxf="$(awk '{if (mf<NF); mf=NF}; END{print mf}' infile)"
rowcount=maxf
for (( i=1; i<=rowcount; i++ )); do
    awk -v i="$i" -F " " '{printf("%s\t ", $i)}' infile
    echo
done

Qui (pour un faible nombre de lignes de sortie est plus rapide que le code précédent).

Voici un one-liner Bash basé sur la simple conversion de chaque ligne en colonne et pasteleur assemblage:

echo '' > tmp1;  \
cat m.txt | while read l ; \
            do    paste tmp1 <(echo $l | tr -s ' ' \\n) > tmp2; \
                  cp tmp2 tmp1; \
            done; \
cat tmp1

m.txt:

0 1 2
4 5 6
7 8 9
10 11 12

1. crée un tmp1fichier pour qu'il ne soit pas vide.

2. lit chaque ligne et la transforme en colonne en utilisant tr

3. colle la nouvelle colonne dans le tmp1fichier

4. les copies sont renvoyées dans tmp1.

PS: Je voulais vraiment utiliser des io-descripteurs mais je n'ai pas pu les faire fonctionner.

Un oneliner utilisant R ...

  cat file | Rscript -e "d <- read.table(file('stdin'), sep=' ', row.names=1, header=T); write.table(t(d), file=stdout(), quote=F, col.names=NA) "

J'ai utilisé ci-dessous deux scripts pour effectuer des opérations similaires auparavant. Le premier est en awk qui est beaucoup plus rapide que le second qui est en bash "pur". Vous pourrez peut-être l'adapter à votre propre application.

awk '
{
    for (i = 1; i <= NF; i++) {
        s[i] = s[i]?s[i] FS $i:$i
    }
}
END {
    for (i in s) {
        print s[i]
    }
}' file.txt

declare -a arr

while IFS= read -r line
do
    i=0
    for word in $line
    do
        [[ ${arr[$i]} ]] && arr[$i]="${arr[$i]} $word" || arr[$i]=$word
        ((i++))
    done
done < file.txt

for ((i=0; i < ${#arr[@]}; i++))
do
    echo ${arr[i]}
done