在Bash中转置文件的有效方法

我有一个巨大的制表符分隔文件，格式如下

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

我想仅使用bash命令以一种有效的方式对其进行转置（我可以编写十行左右的Perl脚本来做到这一点，但执行起来应该比本地bash函数要慢一些）。所以输出应该看起来像

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

我想到了这样的解决方案

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

但这很慢，而且似乎不是最有效的解决方案。我已经在这篇文章中看到了vi的解决方案，但它仍然过慢。有什么想法/建议/好主意吗？:-)

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

输出

$ 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

乔纳森（Jonathan）在10000行文件中针对Perl解决方案的性能

$ 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

埃德·莫顿（Ed Morton）编辑（@ ghostdog74，如果您不同意，可以随时删除）。

也许此版本带有一些更明确的变量名将有助于回答以下一些问题，并通常阐明脚本的功能。它还使用制表符作为OP最初要求的分隔符，因此它可以处理空字段，并且在这种特殊情况下，它会巧合地增加输出。

$ 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

上面的解决方案可以在任何awk中使用（当然，旧的破损awk除外-当然是YMMV）。

上面的解决方案确实将整个文件读入内存-如果输入文件太大，则可以这样做：

$ 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

它几乎不占用内存，但是每行的每个字段读取一次输入文件，因此它比将整个文件读取到内存的版本要慢得多。它还假定每行上的字段数相同，并且使用GNU awk ENDFILE和，ARGIND但是任何awk都可以对FNR==1and 进行相同的测试END。

另一种选择是使用rs：

rs -c' ' -C' ' -T

-c更改输入列分隔符，-C更改输出列分隔符，并-T转置行和列。不要使用-t代替-T，因为它会使用通常不正确的自动计算的行和列数。rs，它以APL中的reshape函数命名，随BSD和OS X一起提供，但其他平台上的程序包管理器应可以使用它。

第二种选择是使用Ruby：

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

第三种选择是使用jq：

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

jq -R .打印每个输入线作为JSON字符串文字，-s（--slurp）每行解析为JSON之后创建用于将输入线的阵列，和-r（--raw-output）输出字符串而非JSON字符串文字的内容。该/操作符被重载到拆分字符串。

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

以上基于以下内容：

import sys

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

该代码确实假设每一行都有相同的列数（不执行填充）。

sourceforge上的转置项目就是一个类似于coreutil的C程序。

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

纯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\t" ${array[$COUNTER]}
  done
  printf "\n" 
done

看一下可以像一样使用的GNU datamashdatamash transpose。将来的版本还将支持交叉列表（数据透视表）

这是完成此任务的适当的Perl脚本。@ ghostdog74的awk解决方案有许多结构类比。

#!/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";
}

使用样本数据大小，perl和awk之间的性能差异可以忽略不计（总共7毫秒中只有1毫秒）。对于较大的数据集（100x100矩阵，每个条目6-8个字符），perl的效果稍差于awk-0.026s和0.042s。两者都不是问题。

MacOS X 10.5.8上Perl 5.10.1（32位）vs awk（给定为-V时为20040207版本）vs gawk 3.1.7（32位）的代表性时序，文件包含10,000行，每行5列线：

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: 

请注意，gawk在这台机器上比awk快得多，但仍然比perl慢。显然，您的里程会有所不同。

如果已sc安装，则可以执行以下操作：

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

为此有一个专用的实用程序，

GNU datamash实用程序

apt install datamash  

datamash transpose < yourfile

取自该站点，https://www.gnu.org/software/datamash/和 http://www.thelinuxrain.com/articles/transposed-rows-and-columns-3-methods

假设您所有的行都具有相同数量的字段，那么这个awk程序可以解决此问题：

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

换句话说，当您在行上循环时，对于每个字段，都将以f'：'分隔的字符串col[f]包含该字段的元素。完成所有行之后，将这些字符串中的每个字符串打印在单独的一行中。然后，您可以通过将输出通过管道传递到所需的分隔符（例如，空格）来替换“：”tr ':' ' '。

例：

$ 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仅用一行代码和可能任意大的文件大小来非常适合此问题！

datamash -W transpose infile > outfile

骇人的perl解决方案可以是这样的。很好，因为它不会将所有文件加载到内存中，不会打印中间临时文件，然后使用所有精彩的粘贴信息

#!/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;

我可以看到您自己的示例的唯一改进是使用了awk，它将减少运行的进程数以及在它们之间传递的数据量：

/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

我通常使用此小awk片段来满足此要求：

  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

这只是将所有数据加载到一个二维数组中a[line,column]，然后将其打印为a[column,line]，以便转置给定的输入。

这需要跟踪max初始文件的最大列数，以便将其用作要打印回的行数。

我使用了fgm的解决方案（感谢fgm！），但是需要消除每行末尾的制表符，因此修改了脚本：

#!/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

我只是在寻找类似的bash转置，但支持填充。这是我根据fgm解决方案编写的脚本，似乎可以正常工作。如果有帮助...

#!/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

我一直在寻找一种解决方案，可以将任何类型的矩阵（nxn或mxn）与任何类型的数据（数字或数据）进行转置，并获得以下解决方案：

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

如果只想从文件中抓取一行（用逗号分隔）$ N，然后将其变成一列：

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

不是很优雅，但是此“单行”命令可以快速解决问题：

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

这里的cols是列数，您可以在其中将4替换为 head -n 1 input | wc -w。

另一种awk解决方案是根据您拥有的内存大小来进行有限的输入。

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

这END会将每个相同的归档数字位置连接在一起，并打印结果，该结果将是第一列的第一行，第二列的第二行，等等。将输出：

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

一些* nix标准的util一线式，不需要临时文件。注意：OP希望有一个有效的解决方案（即更快），并且最常见的答案通常比该答案快。 这些单行代码是出于各种原因而喜欢* nix 软件工具的人的。在极少数情况下（例如，稀缺的IO和内存），这些摘要实际上可能比某些最佳答案要快。

调用输入文件foo。

1. 如果我们知道foo有四列：

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

2. 如果我们不知道foo有多少列：

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

   xargs有大小限制，因此使用长文件将无法完成工作。大小限制取决于系统，例如：

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

   我们可以实际使用的最大命令长度：2088944

3. tr＆echo：

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

   ...或者如果列数未知：

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

4. 使用set和一样xargs，具有类似的基于命令行大小的限制：

   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

另一个版本 set eval

另一个bash变体

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

脚本

#!/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
}

输出量

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

这是Haskell解决方案。用-O2编译时，对于重复的“ Hello world”输入行，它的运行速度比ghostdog的awk略快，并且比Stephan的薄包装c python 略慢。不幸的是，据我所知，GHC不支持传递命令行代码，因此您必须自己将其写入文件。它将把行截断为最短行的长度。

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

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

将整个数组存储在内存中的awk解决方案

    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

但是我们可以根据需要的输出行“遍历”文件多次：

#!/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

哪一个（对于较少的输出行，比以前的代码要快）。

这是一个Bash单行代码，其基础是将每行简单地转换为一列并将paste它们-ing在一起：

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. 创建tmp1文件，因此它不为空。

2. 读取每一行并将其转换为使用 tr

3. 将新列粘贴到tmp1文件中

4. 将结果复制回tmp1。

PS：我真的很想使用io-descriptor，但无法使其正常工作。

使用R的oneliner ...

  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) "

我以前在下面两个脚本中使用过类似的操作。第一个是在awk中，比第二个在“纯” bash中要快得多。您可能可以使其适应您自己的应用程序。

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