使用Bash脚本选择具有特定名称的列和行

Question

I'm working with a very large text file (4GB) and I want to make a smaller file with only the data I need in it. It is a tab deliminated file and there are row and column headers. I basically want to select a subset of the data that has a given column and/or row name.

     colname_1    colname_2    colname_3    colname_4
row_1    1            2             3            5
row_2    4            6             9            1
row_3    2            3             4            2

I'm planning to have a file with a list of the columns I want.

colname_1    colname_3

I'm a newbie to bash scripting and I really don't know how to do this. I saw other examples, but they all new what column number they wanted in advance and I don't. Sorry if this is a repeat question, I tried to search.

I would want the result to be

     colname_1     colname_3
row_1    1             3
row_2    2             9
row_3    2             4 

Answer 1

You can actually do this by keeping track of the array indexes for the columns that match the column names in your file containing the column list . After you have found the array indexes in the data file for the column names in your column list file, you simply read your data file (beginning at the second line) and output the row_label plus the data for the columns at the array index you determined in matching the column list file to the original columns.

There are probably several ways to approach this and the following assumes the data in each column does not contain any whitespace. The use of arrays presumes bash (or other advanced shell supporting arrays) and not POSIX shell.

The script takes two file names as input. The first is your original data file. The second is your column list file. An approach could be:

#!/bin/bash

declare -a cols  ## array holding original columns from original data file
declare -a csel  ## array holding columns to select (from file 2)
declare -a cpos  ## array holding array indexes of matching columns

cols=( $(head -n 1 "$1") )  ## fill cols from 1st line of data file
csel=( $(< "$2") )          ## read select columns from file 2

## fill column position array
for ((i = 0; i < ${#csel[@]}; i++)); do
    for ((j = 0; j < ${#cols[@]}; j++)); do
        [ "${csel[i]}" = "${cols[j]}" ] && cpos+=( $j )
    done
done

printf " " 
for ((i = 0; i < ${#csel[@]}; i++)); do   ## output header row
    printf "    %s" "${csel[i]}"
done

printf "\n"     ## output newline
unset cols      ## unset cols to reuse in reading lines below

while read -r line; do        ## read each data line in data file 
    cols=( $line )            ## separate into cols array
    printf "%s" "${cols[0]}"  ## output row label
    for ((j = 0; j < ${#cpos[@]}; j++)); do
        [ "$j" -eq "0" ] && { ## handle format for first column
            printf "%5s" "${cols[$((${cpos[j]}+1))]}"
            continue
        }                     ## output remaining columns
        printf "%13s" "${cols[$((${cpos[j]}+1))]}"
    done
    printf "\n"
done < <( tail -n+2 "$1" )

Using your example data as follows:

Data File

$ cat dat/col+data.txt
     colname_1    colname_2    colname_3    colname_4
row_1    1            2             3            5
row_2    4            6             9            1
row_3    2            3             4            2

Column Select File

$ cat dat/col.txt
colname_1    colname_3

Example Use/Output

$ bash colnum.sh dat/col+data.txt dat/col.txt
     colname_1    colname_3
row_1    1            3
row_2    4            9
row_3    2            4

Give it a try and let me know if you have any questions. Note, bash isn't known for its blinding speed handling large files, but as long as the column list isn't horrendously long, the script should be reasonably fast.

Answer 2

Bash works best as "glue" between standard command-line utilities. You can write loops which read each line in a massive file, but it's painfully slow because bash is not optimized for speed. So let's see how to use a few standard utilities -- grep, tr, cut and paste -- to achieve this goal.

For simplicity, let's put the desired column headings into a file, one per line. (You can always convert a tab-separated line of column headings to this format; we're going to do just that with the data file's column headings. But one thing at a time.)

$ printf '%s\n' colname_{1,3} > columns
$ cat columns
colname_1
colname_2

An important feature of the printf command-line utility is that it repeats its format until it runs out of arguments.

Now, we want to know which column in the data file each of these column headings corresponds to. We could try to write this as a loop in awk or even in bash, but if we convert the header line of the data file into a file with one header per line, we can use grep to tell us, by using the -n option (which prefixes the output with the line number of the match).

Since the column headers are tab-separated, we can get turn them into separate lines just by converting tabs to newlines using tr :

$ head -n1 giga.dat | tr '\t' '\n'

colname_1
colname_2
colname_3
colname_4

Note the blank line at the beginning. That's important, because colname_1 actually corresponds to column 2, since the row headers are in column 1.

So let's look up the column names. Here, we will use several grep options:

• -F The pattern argument consists of several patterns, one per line, which are interpreted as ordinary strings instead of regexes.
• -x The pattern must match the complete line.
• -n The output should be prefixed by the line number of the match.

If we have Gnu grep , we could also use -f columns to read the patterns from the file named columns . Or if we're using bash, we could use the bashism "$(<columns)" to insert the contents of the file as a single argument to grep. But for now, we'll stay Posix compliant:

$ head -n1 giga.dat | tr '\t' '\n' | grep -Fxn "$(cat columns)"
2:colname_1
4:colname_3

OK, that's pretty close. We just need to get rid of everything other than the line number; comma-separate the numbers, and put a 1 at the beginning.

 $ { echo 1
 >   grep -Fxn "$(<columns)" < <(head -n1 giga.dat | tr '\t' '\n')
 > } | cut -f1 -d: | paste -sd,
 1,2,4

• cut -f1 Select field 1. The argument could be a comma-separated list, as in cut -f1,2,4 .
• cut -d: Use : instead of tab as a field separator ("delimiter")
• paste -s Concatenate the lines of a single file instead of corresponding lines of several files
• paste -d, Use a comma instead of tab as a field separator.

So now we have the argument we need to pass to cut in order to select the desired columns:

$ cut -f"$({ echo 1
>   head -n1 giga.dat | tr '\t' '\n' | grep -Fxn -f columns 
> } | cut -f1 -d: | paste -sd,)" giga.dat
        colname_1       colname_3
row_1   1       3
row_2   4       9
row_3   2       4