We discussed in a previous episode how to search within a file using less. We can also search within files without even opening them, using grep. grep is a command-line utility for searching plain-text files for lines matching a specific set of characters (sometimes called a string) or a particular pattern (which can be specified using something called regular expressions). We’re not going to work with regular expressions in this lesson, and are instead going to specify the strings we are searching for. Let’s give it a try!
Nucleotide abbreviations
The four nucleotides that appear in DNA are abbreviated
A,C,TandG. Unknown nucleotides are represented with the letterN. AnNappearing in a sequencing file represents a position where the sequencing machine was not able to confidently determine the nucleotide in that position. You can think of anNas being aNy nucleotide at that position in the DNA sequence.
We’ll search for strings inside of our fastq files. Let’s first make sure we are in the correct directory:
$ cd ~/CF_Shell/untrimmed_fastqSuppose we want to see how many reads in our file have really bad segments containing 10 consecutive unknown nucleotides (Ns).
Let’s search for the string NNNNNNNNNN in the sample_02 file:
$ grep NNNNNNNNNN sample_02.fastqThis command returns a lot of output to the terminal. Every single line in the sample_02 file that contains at least 10 consecutive Ns is printed to the terminal, regardless of how long or short the file is. We may be interested not only in the actual sequence which contains this string, but in the name (or identifier) of that sequence. We discussed in a previous lesson that the identifier line immediately precedes the nucleotide sequence for each read in a FASTQ file. We may also want to inspect the quality scores associated with each of these reads. To get all of this information, we will return the line immediately before each match and the two lines immediately after each match.
We can use the -B argument for grep to return a specific number of lines before each match. The -A argument returns a specific number of lines after each matching line. Here we want the line before and the two lines after each matching line, so we add -B1 -A2 to our grep command:
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastqOne of the sets of lines returned by this command is:
@SRR098026.177 HWUSI-EAS1599_1:2:1:1:2025 length=35
CNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
+SRR098026.177 HWUSI-EAS1599_1:2:1:1:2025 length=35
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Search for the sequence GNATNACCACTTCC in the sample_02.fastq file. Have your search return all matching lines and the name (or identifier) for each sequence that contains a match.
Search for the sequence AAGTT in both FASTQ files. Have your search return all matching lines and the name (or identifier) for each sequence that contains a match.
grep -B1 GNATNACCACTTCC sample_02.fastq
@SRR098026.245 HWUSI-EAS1599_1:2:1:2:801 length=35
GNATNACCACTTCCAGTGCTGANNNNNNNGGGATGgrep -B1 AAGTT *.fastq
sample_01.fastq-@SRR097977.11 209DTAAXX_Lenski2_1_7:8:3:247:351 length=36
sample_01.fastq:GATTGCTTTAATGAAAAAGTCATATAAGTTGCCATG
--
sample_01.fastq-@SRR097977.67 209DTAAXX_Lenski2_1_7:8:3:544:566 length=36
sample_01.fastq:TTGTCCACGCTTTTCTATGTAAAGTTTATTTGCTTT
--
sample_01.fastq-@SRR097977.68 209DTAAXX_Lenski2_1_7:8:3:724:110 length=36
sample_01.fastq:TGAAGCCTGCTTTTTTATACTAAGTTTGCATTATAA
--
sample_01.fastq-@SRR097977.80 209DTAAXX_Lenski2_1_7:8:3:258:281 length=36
sample_01.fastq:GTGGCGCTGCTGCATAAGTTGGGTTATCAGGTCGTT
--
sample_01.fastq-@SRR097977.92 209DTAAXX_Lenski2_1_7:8:3:353:318 length=36
sample_01.fastq:GGCAAAATGGTCCTCCAGCCAGGCCAGAAGCAAGTT
--
sample_01.fastq-@SRR097977.139 209DTAAXX_Lenski2_1_7:8:3:703:655 length=36
sample_01.fastq:TTTATTTGTAAAGTTTTGTTGAAATAAGGGTTGTAA
--
sample_01.fastq-@SRR097977.238 209DTAAXX_Lenski2_1_7:8:3:592:919 length=36
sample_01.fastq:TTCTTACCATCCTGAAGTTTTTTCATCTTCCCTGAT
--
sample_02.fastq-@SRR098026.158 HWUSI-EAS1599_1:2:1:1:1505 length=35
sample_02.fastq:GNNNNNNNNCAAAGTTGATCNNNNNNNNNTGTGCG
grep allowed us to identify sequences in our FASTQ files that match a particular pattern. All of these sequences were printed to our terminal screen, but in order to work with these sequences and perform other operations on them, we will need to capture that output in some way.
We can do this with something called “redirection”. The idea is that we are taking what would ordinarily be printed to the terminal screen and redirecting it to another location. In our case, we want to print this information to a file so that we can look at it later and use other commands to analyze this data.
The command for redirecting output to a file is >.
Let’s try out this command and copy all the records (including all four lines of each record) in our FASTQ files that contain ‘NNNNNNNNNN’ to another file called bad_reads.txt.
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastq > bad_reads.txtFile extensions
You might be confused about why we’re naming our output file with a
.txtextension. After all, it will be holding FASTQ formatted data that we’re extracting from our FASTQ files. Won’t it also be a FASTQ file? The answer is, yes - it will be a FASTQ file and it would make sense to name it with a.fastqextension. However, using a.fastqextension will lead us to problems when we move to using wildcards later in this episode. We’ll point out where this becomes important. For now, it’s good that you’re thinking about file extensions!
The prompt should sit there a little bit, and then it should look like nothing happened. But type ls. You should see a new file called bad_reads.txt.
We can check the number of lines in our new file using a command called wc. wc stands for word count. This command counts the number of words, lines, and characters in a file. The FASTQ file may change over time, so given the potential for updates, make sure your file matches your instructor’s output.
As of Oct. 2022, wc gives the following output:
$ wc bad_reads.txt 537 1073 23217 bad_reads.txtThis will tell us the number of lines, words and characters in the file. If we want only the number of lines, we can use the -l flag for lines.
$ wc -l bad_reads.txt537 bad_reads.txt
wcHow many sequences are there in sample_02.fastq? Remember that every sequence is formed by four lines.
wc
$ wc -l sample_02.fastq996Now you can divide this number by four to get the number of sequences in your fastq file
wc IIHow many sequences in sample_02.fastq contain at least 3 consecutive Ns?
wc II
$ grep NNN sample_02.fastq > bad_reads.txt
$ wc -l bad_reads.txt249
We might want to search multiple FASTQ files for sequences that match our search pattern. However, we need to be careful, because each time we use the > command to redirect output to a file, the new output will replace the output that was already present in the file. This is called “overwriting” and, just like you don’t want to overwrite your video recording of your kid’s first birthday party, you also want to avoid overwriting your data files.
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastq > bad_reads.txt
$ wc -l bad_reads.txt537 bad_reads.txt$ grep -B1 -A2 NNNNNNNNNN sample_01.fastq > bad_reads.txt
$ wc -l bad_reads.txt4 bad_reads.txtHere, the output of our second call to wc shows that we have overwritten the contents of our bad_reads.txt file. The second file we searched, sample_01.fastq, only contains one bad read that matches our search sequence.
We can avoid overwriting our files by using the following syntax: >>. >> is known as the “append redirect” and will append new output to the end of a file, rather than overwriting it.
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastq > bad_reads.txt
$ wc -l bad_reads.txt537 bad_reads.txt$ grep -B1 -A2 NNNNNNNNNN sample_01.fastq >> bad_reads.txt
$ wc -l bad_reads.txt541 bad_reads.txtThe output of our second call to wc shows that we have not overwritten our original data, but rather added to it.
Since we might have multiple different criteria we want to search for, creating a new output file each time has the potential to clutter up our workspace. We also thus far haven’t been interested in the actual contents of those files, only in the number of reads that we’ve found. We created the files to store the reads and then counted the lines in the file to see how many reads matched our criteria. There’s a way to do this, however, that doesn’t require us to create these intermediate files - the pipe command (|).
This is probably not a key on your keyboard you use very much, so let’s all take a minute to find that key. For the standard QWERTY keyboard layout, the | character can be found using the key combination
What | does is take the output that is scrolling by on the terminal and uses that output as input to another command. When our output was scrolling by, we might have wished we could slow it down and look at it, like we can with less. Well it turns out that we can! We can redirect our output from our grep call through the less command.
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastq | lessWe can now see the output from our grep call within the less interface. We can use the up and down arrows to scroll through the output and use q to exit less.
If we don’t want to create a file before counting lines of output from our grep search, we could directly pipe the output of the grep search to the command wc -l. This can be helpful for investigating your output if you are not sure you would like to save it to a file.
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastq | wc -lBecause we asked grep for all four lines of each FASTQ record, we need to divide the output by four to get the number of sequences that match our search pattern. Since 537 / 4 = 134.25 and we are expecting an integer number of records, there is something added or missing in bad_reads.txt. If we explore bad_reads.txt using less, we might be able to notice what is causing the uneven number of lines. Luckily, this issue happens by the end of the file so we can also spot it with tail.
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastq | tail#!!!!!!!!!##########!!!!!!!!!!##!#!
@SRR098026.133 HWUSI-EAS1599_1:2:1:0:1978 length=35
ANNNNNNNNNTTCAGCGACTNNNNNNNNNNGTNGN
+SRR098026.133 HWUSI-EAS1599_1:2:1:0:1978 length=35
#!!!!!!!!!##########!!!!!!!!!!##!#!
--
@SRR098026.177 HWUSI-EAS1599_1:2:1:1:2025 length=35
CNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
+SRR098026.177 HWUSI-EAS1599_1:2:1:1:2025 length=35
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!The sixth line in the output displays -- which is used by default for grep to separate groups of lines matching the pattern. To fix this issue, we can redirect the output of grep to a second instance of grep as follows.
$ grep -B1 -A2 NNNNNNNNNN sample_02.fastq | grep -v '^--' | tail+SRR098026.132 HWUSI-EAS1599_1:2:1:0:320 length=35
#!!!!!!!!!##########!!!!!!!!!!##!#!
@SRR098026.133 HWUSI-EAS1599_1:2:1:0:1978 length=35
ANNNNNNNNNTTCAGCGACTNNNNNNNNNNGTNGN
+SRR098026.133 HWUSI-EAS1599_1:2:1:0:1978 length=35
#!!!!!!!!!##########!!!!!!!!!!##!#!
@SRR098026.177 HWUSI-EAS1599_1:2:1:1:2025 length=35
CNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
+SRR098026.177 HWUSI-EAS1599_1:2:1:1:2025 length=35
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!The -v option in the second grep search stands for --invert-match meaning grep will now only display the lines which do not match the searched pattern, in this case '^--'. The caret (^) is an anchoring character matching the beginning of the line, and the pattern has to be enclose by single quotes so grep does not interpret the pattern as an extended option (starting with --).
Remember when we were exploring the append redirect, we noticed that there was a bad read within sample_01.fastq as well. We can try combining some of the things we’ve learned, to gather all of our bad reads with a single line of code:
$ grep -h -B1 -A2 NNNNNNNNNN *.fastq | grep -v '^--' > bad_reads.txt
$ wc -l bad_reads.txt540 bad_reads.txtFile extensions - part 2
Since this is now a valid
.fastqfile, we could redirect our output to a file namedbad_reads.fastqto acknowledge that. However, this is a place to exercise caution. If we were to create a file calledbad_reads.fastq(perhaps during ourgreppractice) and then run the same command again,grepwould give us a warning.# If you tried running this twice: grep -h -B1 -A2 NNNNNNNNNN *.fastq | grep -v '^--' > bad_reads.fastqgrep: input file ‘bad_reads.fastq’ is also the output
grepis letting you know that the output filebad_reads.fastqis also included in your input to thegrepcall because it matches the*.fastqpattern. This is a situation that we want to avoid.
Custom
grepcontrolUse
man grepto read more about other options to customize the output ofgrepincluding extended options, anchoring characters, and much more.
Redirecting output is often not intuitive, and can take some time to get used to. Once you’re comfortable with redirection, however, you’ll be able to combine any number of commands to do all sorts of exciting things with your data!
None of the command line programs we’ve been learning do anything all that impressive on their own, but when you start chaining them together, you can do some really powerful things very efficiently.
Loops are key to productivity improvements through automation as they allow us to execute commands repeatedly. Similar to wildcards and tab completion, using loops also reduces the amount of typing (and typing mistakes). Loops are helpful when performing operations on groups of sequencing files, such as unzipping or trimming multiple files. We will use loops for these purposes in subsequent analyses, but will cover the basics of them for now.
When the shell sees the keyword for, it knows to repeat a command (or group of commands) once for each item in a list. Each time the loop runs (called an iteration), an item in the list is assigned in sequence to the variable, and the commands inside the loop are executed, before moving on to the next item in the list. Inside the loop, we call for the variable’s value by putting $ in front of it. The $ tells the shell interpreter to treat the variable as a variable name and substitute its value in its place, rather than treat it as text or an external command. In shell programming, this is usually called “expanding” the variable.
Sometimes, we want to expand a variable without any whitespace to its right. Suppose we have a variable named foo that contains the text abc, and would like to expand foo to create the text abcEFG.
$ foo=abc
$ echo foo is $foo
foo is abc
$ echo foo is $fooEFG # doesn't work
foo isThe interpreter is trying to expand a variable named fooEFG, which (probably) doesn’t exist. We can avoid this problem by enclosing the variable name in braces ({ and }, sometimes called “squiggle braces”).
Note:
bashtreats the#character as a comment character. Any text on a line after a#is ignored by bash when evaluating the text as code.
$ foo=abc
$ echo foo is $foo
foo is abc
$ echo foo is ${foo}EFG # now it works!
foo is abcEFG
Let’s write a for loop to show us the first two lines of the fastq files we downloaded earlier. You will notice the shell prompt changes from $ to > and back again as we were typing in our loop. The second prompt, >, is different to remind us that we haven’t finished typing a complete command yet. A semicolon, ;, can be used to separate two commands written on a single line.
$ cd ../untrimmed_fastq/$ for filename in *.fastq
> do
> head -n 2 ${filename}
> doneThe for loop begins with the formula for <variable> in <group to iterate over>. In this case, the word filename is designated as the variable to be used over each iteration. In our case sample_01.fastq and sample_02.fastq will be substituted for filename because they fit the pattern of ending with .fastq in the directory we’ve specified. The next line of the for loop is do. The next line is the code that we want to execute. We are telling the loop to print the first two lines of each variable we iterate over. Finally, the word done ends the loop.
After executing the loop, you should see the first two lines of both fastq files printed to the terminal. Let’s create a loop that will save this information to a file.
$ for filename in *.fastq
> do
> head -n 2 ${filename} >> seq_info.txt
> doneWhen writing a loop, you will not be able to return to previous lines once you have pressed Enter. Remember that we can cancel the current command using
If you notice a mistake that is going to prevent your loop for executing correctly.
Note that we are using >> to append the text to our seq_info.txt file. If we used >, the seq_info.txt file would be rewritten every time the loop iterates, so it would only have text from the last variable used. Instead, >> adds to the end of the file.
Basename is a function in UNIX that is helpful for removing a uniform part of a name from a list of files. In this case, we will use basename to remove the .fastq extension from the files that we’ve been working with.
$ basename sample_01.fastq .fastqWe see that this returns sample_01, and no longer has the .fastq file extension on it.
sample_01If we try the same thing but use .fasta as the file extension instead, nothing happens. This is because basename only works when it exactly matches a string in the file.
$ basename sample_01.fastq .fastasample_01.fastqBasename is really powerful when used in a for loop. It allows to access just the file prefix, which you can use to name things. Let’s try this.
Inside our for loop, we create a new name variable. We call the basename function inside the parenthesis, then give our variable name from the for loop, in this case ${filename}, and finally state that .fastq should be removed from the file name. It’s important to note that we’re not changing the actual files, we’re creating a new variable called name. The line > echo $name will print to the terminal the variable name each time the for loop runs. Because we are iterating over two files, we expect to see two lines of output.
$ for filename in *.fastq
> do
> name=$(basename ${filename} .fastq)
> echo ${name}
> done
Print the file prefix of all of the .txt files in our current directory.
$ for filename in *.txt
> do
> name=$(basename ${filename} .txt)
> echo ${name}
> done
One way this is really useful is to move files. Let’s rename all of our .fastq files using mv so that they have the years on them.
$ for filename in *.fastq
> do
> name=$(basename ${filename} .fastq)
> mv ${filename} ${name}_2022.fastq
> done