Một cách hiệu quả để chuyển đổi tệp trong Bash

Tôi có một tệp lớn được phân tách bằng tab được định dạng như thế này

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

Tôi muốn chuyển nó theo cách hiệu quả chỉ bằng cách sử dụng các lệnh bash (tôi có thể viết một tập lệnh Perl mười dòng hoặc lâu hơn để làm điều đó, nhưng nó sẽ chậm hơn để thực thi so với các hàm bash gốc). Vì vậy, đầu ra sẽ giống như

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

Tôi đã nghĩ ra một giải pháp như thế này

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

Nhưng nó chậm và có vẻ không phải là giải pháp hiệu quả nhất. Tôi đã thấy một giải pháp cho vi trong bài đăng này , nhưng nó vẫn quá chậm. Bất kỳ suy nghĩ / đề xuất / ý tưởng tuyệt vời? :-)

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

đầu ra

$ 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

Hiệu suất chống lại giải pháp Perl của Jonathan trên tệp 10000 dòng

$ 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

CHỈNH SỬA bởi Ed Morton (@ ghostdog74 vui lòng xóa nếu bạn không đồng ý).

Có thể phiên bản này với một số tên biến rõ ràng hơn sẽ giúp trả lời một số câu hỏi bên dưới và nói chung làm rõ tập lệnh đang làm gì. Nó cũng sử dụng các tab làm dấu phân cách mà OP đã yêu cầu ban đầu để nó xử lý các trường trống và nó ngẫu nhiên cải tiến đầu ra một chút cho trường hợp cụ thể này.

$ 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

Các giải pháp trên sẽ hoạt động trong bất kỳ awk nào (tất nhiên là ngoại trừ awk cũ, bị hỏng - có YMMV).

Tuy nhiên, các giải pháp trên có thể đọc toàn bộ tệp vào bộ nhớ - nếu các tệp đầu vào quá lớn thì bạn có thể thực hiện việc này:

$ 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

mà hầu như không sử dụng bộ nhớ nhưng đọc tệp đầu vào một lần cho mỗi số trường trên một dòng nên sẽ chậm hơn nhiều so với phiên bản đọc toàn bộ tệp vào bộ nhớ. Nó cũng giả định rằng số lượng trường là như nhau trên mỗi dòng và nó sử dụng GNU awk cho ENDFILEvà ARGINDnhưng bất kỳ awk nào cũng có thể làm như vậy với các bài kiểm tra trên FNR==1và END.

Một tùy chọn khác là sử dụng rs:

rs -c' ' -C' ' -T

-cthay đổi dấu phân tách cột đầu vào, -Cthay đổi dấu phân tách cột đầu ra và -Thoán vị các hàng và cột. Không sử dụng -tthay thế -Tvì nó sử dụng số lượng hàng và cột được tính toán tự động thường không chính xác. rs, được đặt tên theo chức năng định hình lại trong APL, đi kèm với BSD và OS X, nhưng nó sẽ có sẵn từ các trình quản lý gói trên các nền tảng khác.

Tùy chọn thứ hai là sử dụng Ruby:

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

Tùy chọn thứ ba là sử dụng jq:

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

jq -R .in từng dòng đầu vào dưới dạng ký tự chuỗi JSON, -s( --slurp) tạo một mảng cho các dòng đầu vào sau khi phân tích cú pháp mỗi dòng dưới dạng JSON và -r( --raw-output) xuất nội dung của chuỗi thay vì ký tự chuỗi JSON. Các /nhà điều hành được nạp chồng để chuỗi phân chia.

Một giải pháp 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

Trên đây là dựa trên những điều sau:

import sys

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

Mã này giả định rằng mọi dòng có cùng số cột (không có phần đệm được thực hiện).

các transpose dự án trên SourceForge là một giống như coreutil C chương trình cho chính xác điều đó.

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

BASH nguyên chất, không có quy trình bổ sung. Một bài tập hay:

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

Hãy xem GNU datamash có thể được sử dụng như thế nào datamash transpose. Một phiên bản trong tương lai cũng sẽ hỗ trợ lập bảng chéo (bảng tổng hợp)

Đây là một tập lệnh Perl vừa phải chắc chắn để thực hiện công việc. Có nhiều phép tương tự về cấu trúc với awkgiải pháp của @ 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";
}

Với kích thước dữ liệu mẫu, sự khác biệt về hiệu suất giữa perl và awk là không đáng kể (1 mili giây trên tổng số 7). Với tập dữ liệu lớn hơn (ma trận 100x100, mỗi mục nhập 6-8 ký tự), perl có phần nhỉnh hơn awk - 0,026 giây so với 0,042 giây. Không có khả năng là một vấn đề.

Thời gian đại diện cho Perl 5.10.1 (32-bit) so với awk (phiên bản 20040207 khi được cung cấp '-V') so với gawk 3.1.7 (32-bit) trên MacOS X 10.5.8 trên tệp chứa 10.000 dòng với 5 cột mỗi hàng:

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: 

Lưu ý rằng gawk nhanh hơn awk trên máy này rất nhiều, nhưng vẫn chậm hơn perl. Rõ ràng, số dặm của bạn sẽ khác nhau.

Nếu bạn đã sccài đặt, bạn có thể làm:

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

Có một mục đích xây dựng tiện ích cho việc này,

Tiện ích GNU datamash

apt install datamash  

datamash transpose < yourfile

Lấy từ trang web này, https://www.gnu.org/software/datamash/ và http://www.thelinuxrain.com/articles/transposing-rows-and-columns-3-methods

Giả sử tất cả các hàng của bạn có cùng số trường, chương trình awk này giải quyết vấn đề:

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

Nói cách khác, khi bạn lặp qua các hàng, đối với mỗi trường fsẽ phát triển một ':' - chuỗi được phân tách col[f]chứa các phần tử của trường đó. Sau khi bạn hoàn thành tất cả các hàng, hãy in từng chuỗi đó trong một dòng riêng biệt. Sau đó, bạn có thể thay thế ':' cho dấu phân cách bạn muốn (giả sử, một dấu cách) bằng cách chuyển đầu ra qua tr ':' ' '.

Thí dụ:

$ 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 hoàn toàn phù hợp cho vấn đề này chỉ với một dòng mã và kích thước tệp có thể lớn tùy ý!

datamash -W transpose infile > outfile

Một giải pháp hackish perl có thể như thế này. Thật tuyệt vì nó không tải tất cả tệp trong bộ nhớ, in các tệp tạm thời trung gian và sau đó sử dụng cách dán tuyệt vời

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

Cải tiến duy nhất mà tôi có thể thấy đối với ví dụ của riêng bạn là sử dụng awk, điều này sẽ giảm số lượng quy trình được chạy và lượng dữ liệu được ghép nối giữa chúng:

/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

Tôi thường sử dụng awkđoạn mã nhỏ này cho yêu cầu này:

  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

Thao tác này chỉ tải tất cả dữ liệu vào một mảng bidimensional a[line,column]và sau đó in nó trở lại a[column,line], để nó chuyển đổi đầu vào đã cho.

Điều này cần theo dõi maxsố lượng cột mà tệp ban đầu có, để nó được sử dụng làm số hàng cần in trở lại.

Tôi đã sử dụng giải pháp của fgm (cảm ơn fgm!), Nhưng cần phải loại bỏ các ký tự tab ở cuối mỗi hàng, vì vậy đã sửa đổi tập lệnh do đó:

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

Tôi chỉ đang tìm kiếm tranpose bash tương tự nhưng có hỗ trợ đệm. Đây là kịch bản tôi đã viết dựa trên giải pháp của fgm, có vẻ như hoạt động. Nếu nó có thể giúp được ...

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

Tôi đang tìm giải pháp để hoán vị bất kỳ loại ma trận nào (nxn hoặc mxn) với bất kỳ loại dữ liệu nào (số hoặc dữ liệu) và nhận được giải pháp sau:

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ếu bạn chỉ muốn lấy một dòng duy nhất (được phân cách bằng dấu phẩy) $ N ra khỏi tệp và biến nó thành một cột:

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

Không thanh lịch lắm, nhưng lệnh "một dòng" này giải quyết vấn đề một cách nhanh chóng:

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

Ở đây cols là số cột, nơi bạn có thể thay thế 4 bằng head -n 1 input | wc -w.

Một awkgiải pháp khác và đầu vào hạn chế với dung lượng bộ nhớ bạn có.

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

Điều này nối từng positon số đã được đệ trình lại với nhau và ENDin ra kết quả sẽ là hàng đầu tiên trong cột đầu tiên, hàng thứ hai trong cột thứ hai, v.v. Sẽ xuất ra:

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

Một số tiêu chuẩn * nix sử dụng một lớp lót, không cần tệp tạm thời. NB: OP muốn một bản sửa lỗi hiệu quả , (tức là nhanh hơn), và các câu trả lời hàng đầu thường nhanh hơn câu trả lời này. Những phần mềm này dành cho những người thích công cụ phần mềm * nix , vì bất kỳ lý do gì. Trong một số trường hợp hiếm hoi, ( ví dụ: IO và bộ nhớ khan hiếm), những đoạn mã này thực sự có thể nhanh hơn một số câu trả lời hàng đầu.

Gọi foo tệp đầu vào .

1. Nếu chúng ta biết foo có bốn cột:

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

2. Nếu chúng ta không biết foo có bao nhiêu cột :

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

   xargscó giới hạn về kích thước và do đó sẽ làm cho hoạt động không hoàn chỉnh với một tệp dài. Giới hạn kích thước nào phụ thuộc vào hệ thống, ví dụ:

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

   Độ dài tối đa của lệnh mà chúng tôi thực sự có thể sử dụng: 2088944

3. tr& echo:

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

   ... hoặc nếu số cột không xác định:

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

4. Việc sử dụng set, giống như xargs, có các giới hạn dựa trên kích thước dòng lệnh tương tự:

   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

phiên bản khác với set eval

Một biến thể bash khác

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

Kịch bản

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

Đầu ra

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

Đây là một giải pháp Haskell. Khi được biên dịch với -O2, nó chạy nhanh hơn một chút so với awk của ghostdog và chậm hơn một chút so với python c được bọc mỏng của Stephan trên máy của tôi đối với các dòng nhập "Hello world" lặp lại. Thật không may, GHC hỗ trợ truyền mã dòng lệnh không tồn tại theo như tôi có thể nói, vì vậy bạn sẽ phải tự ghi nó vào một tệp. Nó sẽ cắt ngắn các hàng theo độ dài của hàng ngắn nhất.

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

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

Một giải pháp awk lưu toàn bộ mảng trong bộ nhớ

    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

Nhưng chúng tôi có thể "đi" tệp nhiều lần khi các hàng xuất cần thiết:

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

Cái nào (đối với số lượng hàng đầu ra thấp sẽ nhanh hơn mã trước đó).

Đây là một lớp lót Bash dựa trên việc chuyển đổi đơn giản mỗi dòng thành một cột và pasteghép chúng lại với nhau:

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. tạo tmp1tệp để nó không trống.

2. đọc từng dòng và chuyển nó thành một cột bằng cách sử dụng tr

3. dán cột mới vào tmp1tệp

4. bản sao kết quả trở lại tmp1.

Tái bút: Tôi thực sự muốn sử dụng io-descriptors nhưng không thể làm cho chúng hoạt động.

Một tấm lót sử dụng 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) "

Tôi đã sử dụng hai tập lệnh dưới đây để thực hiện các hoạt động tương tự trước đây. Đầu tiên là ở awk, nhanh hơn rất nhiều so với thứ hai ở bash "thuần túy". Bạn có thể điều chỉnh nó cho ứng dụng của riêng bạn.

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