Chapt 5

Chapt 5
Chapter 5
Applying Perl
5.1
Introduction to chapter 5
In this chapter we will use the knowledge gathered during the first two weeks in order to
solve some problems that may occur in the field of Bioinformatics. There will also be a
lecture on how to use references in Perl. The following list is a summary of this chapter:
• Change of file formats
• References, objects and methods
• Searching in large text files
• Parsing Blast result files
During the lectures we will study programs (or part of programs) that solves the different
tasks. We will look at both the structure of the program (i.e. how the author decided to
logically solve the problem) and details in the Perl code.
5.2
Change of file formats
Pretend that you are performing a multiple sequence alignment. The result of such an
alignment (using e.g. clustalw) can be a text file showing the alignment of the sequences.
There are different formats for this text file. At a later step in your analysis of the alignments
you may be faced with the problem of converting one text format to another. We will now
look at the task of converting clustalw files (aln format) to phylip files (phylip format) and
vise versa.
5.2.1
clustalw to phylip and phylip to clustalw
Here is an alignment of the 6 proteins ACT1 FUGRU, ACT2 FUGRU, ACT3 FUGRU,
5H1A FUGRU, 5H1B FUGRU, 5H1D FUGRU, shown in the “clustalw” format,
87
88
CHAPTER 5. APPLYING PERL
CLUSTAL W (1.82) multiple sequence alignment
ACT1_FUGRU
ACT2_FUGRU
ACT3_FUGRU
5H1A_FUGRU
5H1B_FUGRU
5H1D_FUGRU
-----------------------MEDEIAALVVDNGSGMCKAGFAGDDAPRAVFPSIVGR
-----------------------MDDEIAALVVDNGSGMCKAGFAGDDAPRAVFPSIVGR
-----------------------MEDEVASLVVDNGSGMCKAGFAGDDAPRAVFPSIVGR
MDLRATSSNDSNATSGYSDTAAVDWDEGENATGSGSLPDPELSYQIITSLFLGALILCSI
-------MEGTNNTTGWT-----HFDSTSNRTSKSFDEEVKLSYQVVTSFLLGALILCSI
-------MELDNNSLDYFSSN--FTDIPSNTTVAHWTEATLLGLQISVSVVLAIVTLATM
*
.
.
:
:
37
37
37
60
48
51
ACT1_FUGRU
ACT2_FUGRU
ACT3_FUGRU
5H1A_FUGRU
5H1B_FUGRU
5H1D_FUGRU
PRHQGVMVGMGQK-------DSYVGDEAQS--KRGILTLKYPIEHGIVTNWDDMEKIWHH
PRHQGVMVGMGQK-------DSYVGDEAQS--KRGILTLKYPIEHGIVTNWDDMEKIWHH
PRHQGVMVGMGQK-------DSYVGDEAQS--KRGILTLKYPIEHGIVTNWDDMEKIWHH
FGNSCVVAAIALERSLQNVANYLIGSLAVTDLMVSVLVLPMAALYQVLNKWTLGQDICDL
FGNACVVAAIALERSLQNVANYLIGSLAVTDLMVSVLVLPMAALYQVLNRWTLGQIPCDI
LSNAFVIATIFLTRKLHTPANFLIGSLAVTDMLVSILVMPISIVYTVSKTWSLGQIVCDI
: *:. :
: :*. * :
.:*.: . : : . *
:
.
88
88
88
120
108
111
.
.
.
ACT1_FUGRU
ACT2_FUGRU
ACT3_FUGRU
5H1A_FUGRU
5H1B_FUGRU
5H1D_FUGRU
PSIVHRKCF-PSIVHRKCF-PSIVHRKCF-KKILRCKFHRH
KKIIKCHFCRA
QKLIK--FRR.:::
375
375
375
423
416
379
and here is the corresponding alignment in the phylip format,
6
431
ACT1_FUGRU ---------ACT2_FUGRU ---------ACT3_FUGRU ---------5H1A_FUGRU MDLRATSSND
5H1B_FUGRU -------MEG
5H1D_FUGRU -------MEL
---------------------------SNATSGYSDT
TNNTTGWT-DNNSLDYFSS
---MEDEIAA
---MDDEIAA
---MEDEVAS
AAVDWDEGEN
---HFDSTSN
N--FTDIPSN
LVVDNGSGMC
LVVDNGSGMC
LVVDNGSGMC
ATGSGSLPDP
RTSKSFDEEV
TTVAHWTEAT
KAGFAGDDAP
KAGFAGDDAP
KAGFAGDDAP
ELSYQIITSL
KLSYQVVTSF
LLGLQISVSV
RAVFPSIVGR
RAVFPSIVGR
RAVFPSIVGR
FLGALILCSI
LLGALILCSI
VLAIVTLATM
PRHQGVMVGM
PRHQGVMVGM
PRHQGVMVGM
FGNSCVVAAI
FGNACVVAAI
LSNAFVIATI
GQK------GQK------GQK------ALERSLQNVA
ALERSLQNVA
FLTRKLHTPA
DSYVGDEAQS
DSYVGDEAQS
DSYVGDEAQS
NYLIGSLAVT
NYLIGSLAVT
NFLIGSLAVT
--KRGILTLK
--KRGILTLK
--KRGILTLK
DLMVSVLVLP
DLMVSVLVLP
DMLVSILVMP
ASLSTFQQMW
ASLSTFQQMW
ASLSTFQQMW
SLLNPIIYAY
SLLNPIIYAY
SLINPVIYTV
ISKQEYDESG
ISKQEYDESG
ISKQEYDESG
FN-KDFQSAF
FN-KDFQSAF
FN-DEFKQAF
PSIVHRKCFPSIVHRKCFPSIVHRKCFKKILRCKFHR
KKIIKCHFCR
QKLIK--FRR
H
A
-
.
.
.
The task is to write a program that can read a text file containing an alignment in one
format and print (on the screen) the alignment using the other format. And vice versa. As
usual when we are programming in Perl there many ways of solving this problem. I will
present one of many possible solutions.
5.2. CHANGE OF FILE FORMATS
89
The program, called convert-missing.pl is divided into the following parts:
• Main program i.e. read command line arguments and load the alignment file to convert
• Subroutine parsing the Phylip format
• Subroutine parsing the ClustalW format
• Subroutine writing (to screen) a Phylip format
• Subroutine writing (to screen) a ClustalW format
Here is the main program.
convert-missing.pl - Main program
1
2
3
use strict;
our(%Seq, @Species);
# Global variables
4
5
6
7
8
9
#### The main program ####
open my $FH, ’<’, $ARGV[1] or die "Cannot open file $ARGV[1]: $!\n";
my @indata = <$FH>;
close $FH;
10
11
12
13
14
15
16
17
18
19
20
21
if( uc($ARGV[0]) eq ’P2C’ ) {
ReadPhylip(@indata);
WriteClustalW();
}
elsif( uc($ARGV[0]) eq ’C2P’ ) {
ReadClustalW(@indata);
WritePhylip();
}
else {
die "Error: Unknown conversion mode!\n";
}
22
convert-missing.pl - Main program
This program uses two global variables declared using the our(%Seq, @Species); statement. The file is read using the statement my @indata = <$INFILE>, which reads everything into the array @indata. The uc() function converts characters to upper case.
Here is the subroutine that reads a phylip file.
convert-missing.pl - sub ReadPhylip
1
2
sub ReadPhylip {
3
4
5
# Copy the supplied data to a local data array
my @data = @_;
6
7
8
# Use the first line to find the number of proteins
my ($nprot, $plen) = split ’ ’, shift @data;
90
CHAPTER 5. APPLYING PERL
9
# Read the first $nprot lines to get the species and the start of the seq
my @tmp;
for ( my $i = 0; $i < $nprot; $i++ ) {
($Species[$i], @tmp) = split ’ ’, shift @data;
chomp @tmp;
$Seq{ $Species[$i] } = join ’’, @tmp;
}
10
11
12
13
14
15
16
17
# Continue to read lines of sequences
my $np = 0;
while ( my $line = shift @data ) {
next if ( $line =~ /^\s*$/ );
18
19
20
21
22
### TO BE COMPLETED ###
23
24
$Seq{ $Species[$np] } .=
25
$line;
26
$np += 1;
if ( $np == $nprot ) {$np = 0;}
27
28
}
29
30
}
convert-missing.pl - sub ReadPhylip
To store the alignments a hash is used (i.e. the global variable %Seq), where a sequence is
index by its name (i.e. the species). These names are also stored, in the correct order, in
the array @Species. Some notations:
• The line my @data = @_; simply makes a copy of the supplied array and stores it in
the local array @data.
• Throughout this routine the contents in @data is accessed using the shift function
that chops off the first item of the array and returns it.
• The split() function is used here to split on whitespace.
• The “TO BE COMPLETED” will be left as an follow-up exercise.
Next, the corresponding routine that reads a clustalw file.
convert-missing.pl - sub ReadClustalW
1
2
sub ReadClustalW {
3
4
5
# Copy the supplied data to a local data array
my @data = @_;
6
7
8
# Skip starting blank lines
while ( $data[0] =~ /^\s*$/ ) {shift @data;}
9
10
11
12
# The first non-blank line should contain the word CLUSTAL
unless ( $data[0] =~ /CLUSTAL/ ) {
die "The input file does not contain the word CLUSTAL!\n";
5.2. CHANGE OF FILE FORMATS
91
}
shift @data;
13
14
15
# Store the sequenses in a hash
my %aux;
while ( my $line = shift @data ) {
next unless ( $line =~ /(-|\w)/ );
16
17
18
19
20
my ($name, $seqtmp, $lentmp) = split ’ ’, $line;
$Seq{$name} .= $seqtmp;
21
22
23
# Find the name in correct order
unless ( defined $aux{$name} ) {
push @Species, $name;
$aux{$name} = 1;
}
24
25
26
27
28
}
29
30
}
convert-missing.pl - sub ReadClustalW
Since the protein names are printed on every line of the alignment, it is easy to store the
sequences in the %Seq hash. More specific comments:
• The line
while( $data[0] =~ /^\s*$/ ) {shift @data;}
is a short way of skipping blank lines in the beginning.
• There is a regexp for detecting lines that contains the alignments, namely {/(-|\w)/}
which matches the character ’-’ or alphanumeric characters.
• The %aux hash is only used to get the correct order of the alignment when storing the
names in the @Species array.
Next, the routine that writes a ClustalW format.
convert-missing.pl - sub WriteClustalW
1
2
sub WriteClustalW {
3
4
5
# Write the ClustalW header
print "CLUSTAL W (1.82) multiple sequence alignment\n\n\n";
6
7
8
9
10
11
12
13
14
15
my $nprot = scalar @Species;
my @aacount;
while ( length($Seq{ $Species[0] }) > 0 ) {
foreach my $i (0 .. $nprot-1) {
printf "%10s\t", $Species[$i];
$Seq{ $Species[$i] } =~ s/^(.{1,60})//;
my $aas = $1;
print "$aas";
92
CHAPTER 5. APPLYING PERL
# Count the number of non - in the aas
my $Naa = 0;
while ( $aas =~ /\w/g ) {
$Naa += 1;
}
$aacount[$i] += $Naa;
if ( $aacount[$i] > 0 ) {
print " $aacount[$i]\n";
}
16
17
18
19
20
21
22
23
24
}
print "\n\n";
25
26
}
27
28
}
convert-missing.pl - sub WriteClustalW
The task is here to write the names on each line followed by 60 amino acid symbols including
gap characters. The line should end with a count of the number of amino acid letters written
sofar.
• The line $Seq{ $Species[$i] } =~ s/^(.{1,60})//; may need some explanation.
Here the task is “chop off”, if possible, the first 60 characters of the sequence. This
is accomplished with the above regexp. s/^(.{q1,60})// means up to 60 characters
are replaced with nothing using the s/// function. However the match is collected in
$1 using () in the regexp.
Finally, the routine that writes a Phylip format.
convert-missing.pl - sub WritePhylip
1
2
sub WritePhylip {
3
4
5
# Print the header line
printf "%d\t%d\n", scalar @Species, length($Seq{ $Species[0] });
6
7
8
9
10
# Now the rest of the sequences
my $PrintName = 1;
my $nprot = scalar @Species;
while ( length($Seq{ $Species[0] })
> 0 ) {
11
12
13
14
# The names
foreach my $i (0 .. $nprot-1) {
my $name = $Species[$i];
15
16
17
18
19
20
if( $PrintName == 1 ) {
printf "%10s\t", $name;
} else {
printf "%10s\t", ’ ’;
}
21
22
23
24
25
# The sequences
$Seq{$name} =~ s/^(.{1,50})//;
my $aas_tmp = $1;
5.2. CHANGE OF FILE FORMATS
93
### TO BE COMPLETED ###
26
27
print "$aas\n";
}
print "\n";
$PrintName = 0;
28
29
30
31
}
32
33
}
convert-missing.pl - sub WritePhylip
5.2.2
Follow-up tasks 5-1
Download the files for this exercise:
convert-missing.pl, clustalw1.aln, clustalw2.aln, phylip1.aln and phylip2.aln.
and complete the following tasks:
1. Complete the first “TO BE COMPLETED”. The $line scalar contains one line of the
phylip file (without the names), e.g.
K------LCY VALDFEQEMG TAASSSSLEK SYELPD---- --------GQ
Use a regular expression to get rid of the spaces and newline characters in $line.
2. Complete the second “TO BE COMPLETED”. This is the other way around. You
have $aas tmp which is a subsequence of length 50 and you should create $aas which
is the same as $aas tmp but space delimited after every 10 character. E.g.
K------LCYVALDFEQEMGTAASSSSLEKSYELPD------------GQ
should be
K------LCY VALDFEQEMG TAASSSSLEK SYELPD---- --------GQ
3. Test the program using the files clustalw1.align, phylip1.align or
clustalw2.align, phylip2.align.
Note this program will not handle the
conservation line appearing in the clustalw format.
4. Change the program so that one does not have to specify the conversion to make, i.e.
the program should recognize that it reads a clustalw file and then convert it to a
phylip file (and vice versa).
5. Add a subroutine to the program that finds the number of full matches in the multiple
alignment. This number should be written at the end of the conversion. By a full
match I mean a residue that is fully conserved among the proteins. Note: For the
“clustal1.aln” alignment this number is 21.
Item 5 can be considered as “things to do if you have time”.
94
CHAPTER 5. APPLYING PERL
5.3
5.3.1
References, objects and methods
1
Creating references
What is a reference? This leads us to the concept of how Perl is storing values in variables.
Each variable has a name and the address that corresponds to a piece of memory associated
with it. Storing addresses is fundamental to references because a reference is a value that
contains the location of another value. We call the scalar value that contains the memory
address a reference. Lets look at the reference of a simple scalar variable,
$var = ’Hello world’;
We can create a reference to this variable using the backslash operator.
$varref = \$var;
Both $var and $varref are scalars. Let’s print them!
print "$var\n";
print "$varref\n";
results in the following output:
Hello world
SCALAR(0x815d7e4)
Here we can see that the reference is just a memory address that holds the value of $var. Why
use references? In some circumstances it is very convenient and sometimes it is necessary.
For example if you want to pass two arrays to a sub-routine, then we need references. We
recall that everything passed to a sub-routine is stored in the @ array, which makes it difficult
to pass two arrays. Another example is if we want to create hashes of arrays, then we also
need references. Before we look at examples we need to know how to create references.
The backslash operator
You can create a reference to any named variable or subroutine with a backslash. Here are
some examples:
$scalarref
$arrayref
$hashref
$constref
$coderef
($globref
1
= \$foo;
= \@ARGV;
= \%ENV;
= \12341.42;
= \&myfunction;
= \*STDOUT;
#
#
#
#
#
#
Reference
Reference
Reference
Reference
Reference
Reference
to
to
to
to
to
to
a scalar
an array
a hash
a constant
a sub-routine
a glob)
Inspiration of how to write this section is coming from “Programming Perl, third edition”
5.3. REFERENCES, OBJECTS AND METHODS
2
95
Anonymous data
In the examples just shown, the backslash operator makes a copy of a reference that is already
in a variable name, with one exception; The 12341.42 is not referenced by a named variable,
it is just a value. We can also create such anonymous arrays, hashes, and subroutines. For
a reference to an anonymous array we use square brackets:
$anonarr1 = [1, 2, 4, 5, 6];
$anonarr2 = [1, 2, [’One’, ’Two’, ’Three’, ’Four’]];
The last one is a reference to an array, where the third element itself is a reference to another
array. For hashes we use curly brackets to create the anonymous reference.
$anonhash1 =
’A’
=>
’C’
=>
’D’
=>
};
$anonhash2 =
’A’
=>
’C’
=>
’D’
=>
};
{
’CGA’,
’TGC’,
’GAC’
# Reference to a hash
{
# Reference to a hash of arrays
[’CGA’, ’GCC’, ’GCG’, ’GCT’],
[’TGC’, ’TGT’],
[’GAC’, ’GAT’]
We can summarize the with the following table:
Reference to
Scalar
Array
Hash
Code
5.3.2
Named
\$scalar
\@array
\%hash
\&function
Anonymous
[ LIST ]
{ LIST }
{ CODE }
Using references
There are many ways of creating references, as there are many way of using or dereference
references. Before we look at small examples were we use references, we must learn how to
dereference them.
Variable names
When you come across a scalar like $amino, you should be thinking ”the scalar value of
amino”. This means that there is a amino entry in the “symbol table”, and the $ character
is a way of obtaining the scalar value behind the name. If what is inside is a reference, you
can look inside that (dereferencing $amino) by prepending another $ character. Formulating
96
CHAPTER 5. APPLYING PERL
it in another way, you can replace the literal amino in $amino with a scalar variable that
points to the actual referent. Here is an example,
$amino
$scalarref
$deref
= "PERLISFUN";
= \$amino;
= ${$scalarref};
# $scalarref is now a reference to $amino
# $deref is now "PERLISFUN"
We can of course use this way of dereferencing on both arrays and hashes. More examples,
$arrayref = \@aminos;
# Make a reference to the array aminos
${$arrayref}[0] = "Gly";
# Set the first element of @$arrayref
push @{$arrayref}, "Ala";
# Add one element to @$arrayref
@{$arrayref}[2..4] = qw/Val Leu Ile/; # Set several elements of @$arrayref
$hashref = \%ahash;
# Make a reference to the hash ahash
%{$hashref} = (’GCA’ => "A", ’GCC’ => "A"); # Initialize whole hash
${$hashref}{’GCG’} = "A";
# Set one key/value pair
Is is important to understand that dereferencing happens before any array or hash lookups.
This is why it is important (at least in the beginning) to use curly braces. We can of course
use shortcuts,
$deref = ${$scalarref};
is the same as
$deref = $$scalarref;
@{$arrayref}
is the same as
@$arrayref
%{$hashref}
is the same as
%$hashref
The use of braces is recommended. To help you understand this, note the important difference between ${$arrayref}[0] and ${$arrayref[0]} where the former means the first
element of the array referred to by $arrayref and the latter, which is dereferencing the first
element of the array named @arrayref. It is important to understand this!
The arrow operator
For references to arrays, hashes (or even subroutines), a third method of dereferencing involves the use of the -> operator. Look at the following equivalent ways of dereferencing:
${$arrayref}[2] = "Val";
$$arrayref[2]
= "Val";
$arrayref->[2] = "Val";
# The standard way
# The shortcut way
# This preferred "arrow way"
5.3. REFERENCES, OBJECTS AND METHODS
${$hashref}{’GCG’} = "A";
$$hashref{’GCG’}
= "A";
$hashref->{’GCG’} = "A";
3
97
# The standard way
# The shortcut way
# This preferred "arrow way"
We can even use many of these arrow operators,
print $array[3]->{"Perl"}->[0];
You can see from this expression that the fourth element of array is a hash reference, and
the value of the ”Perl” entry in that hash is an array reference.
5.3.3
Examples of using references
Here we will show two examples of how to use references. The first one deals with subroutines
and in the other one we create a hash of arrays.
Passing arrays to subroutines
ref2.pl
1
2
#! /usr/bin/perl -w
use strict;
3
4
5
#### Main part of the program
my @fasta = <>;
6
7
my $hashref = SearchFasta(\@fasta, [’TGG’]);
8
9
10
11
12
my %res = %{$hashref};
foreach my $key ( sort keys %res ) {
print "$key: $res{$key}\n";
}
13
14
sub SearchFasta {
15
16
17
# Get the references from the argument array
my ($f1ref, $subsref) = @_;
18
19
20
# Dereference
my @f1 = @{$f1ref}; # This makes a copy of the referenced array
21
22
23
# Make a long string of the fasta sequence
my $seq = join ’’, @f1;
24
25
26
# Remove all comment lines
$seq =~ s/>.*?\n//g;
27
28
29
# Remove all new lines
$seq =~ s/\n//g;
30
31
# Loop over all substrings to search for
98
CHAPTER 5. APPLYING PERL
my %cnt;
foreach my $sub ( @{$subsref} ) {
$cnt{$sub} = ($seq =~ s/$sub/$sub/g);
}
32
33
34
35
36
# Return the hash of matches
return \%cnt;
37
38
39
}
ref2.pl
This small program contains one subroutine SearchFasta that takes two arguments, both
references to arrays. The subroutine returns a reference to a hash. Can you figure out
the purpose of the program? If we run the program on the first entry in the fasta file
ecoli.fasta we get the following output:
1
TGG: 2044
Hash of arrays
In this little example we create a hash and where each value in the hash is an array. This
can only be accomplished using references.
ref3.pl†
1
2
#! /usr/bin/perl -w
use strict;
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# The translation table
my %codon;
$codon{’A’} = [’GCA’, ’GCC’, ’GCG’, ’GCT’];
$codon{’C’} = [’TGC’, ’TGT’];
$codon{’D’} = [’GAC’, ’GAT’];
$codon{’E’} = [’GAA’, ’GAG’];
$codon{’F’} = [’TTC’, ’TTT’];
$codon{’G’} = [’GGA’, ’GGC’, ’GGG’, ’GGT’];
$codon{’H’} = [’CAC’, ’CAT’];
$codon{’I’} = [’ATA’, ’ATC’, ’ATT’];
$codon{’K’} = [’AAA’, ’AAG’];
$codon{’L’} = [’CTA’, ’CTC’, ’CTG’, ’CTT’, ’TTA’, ’TTG’];
$codon{’M’} = [’ATG’];
$codon{’N’} = [’AAC’, ’AAT’];
$codon{’P’} = [’CCA’, ’CCC’, ’CCG’, ’CCT’];
$codon{’Q’} = [’CAA’, ’CAG’];
$codon{’R’} = [’AGA’, ’AGG’, ’CGA’, ’CGC’, ’CGG’, ’CGT’];
$codon{’S’} = [’AGC’, ’AGT’, ’TCA’, ’TCC’, ’TCG’, ’TCT’];
$codon{’T’} = [’ACA’, ’ACC’, ’ACG’, ’ACT’];
$codon{’V’} = [’GTA’, ’GTC’, ’GTG’, ’GTT’];
$codon{’W’} = [’TGG’];
$codon{’Y’} = [’TAC’, ’TAT’];
26
27
28
# Print the translation table
foreach my $aa ( sort keys %codon ) {
5.3. REFERENCES, OBJECTS AND METHODS
99
print "$aa: ";
foreach my $nuc ( @{$codon{$aa}} ) {
print "$nuc ";
}
print "\n";
29
30
31
32
33
34
4
}
ref3.pl†
Note the square brackets when defining the hash codon. The expression @{$codon{$aa}}
should be read as: The array referred to by the key $aa in the hash %codon.
5.3.4
Objects and methods
This very short section about objects and methods is meant as a very brief introduction to
prepare you for the coming lectures about CPI.pm and the modules in the BioPerl project.
From “Programming Perl 3rd edition”:
An object is a data structure with a collection of behaviors. Every object gets its behaviors
by virtue of being an instance of a class. The class defines methods: behaviors that apply
to the class and its instances. When the distinction matters, we refer to methods that
apply only to a particular object as instance methods and those that apply to the entire
class as class methods. But this is only a convention–to Perl, a method is just a method,
distinguished only by the type of its first argument.
You can think of an instance method as some action performed by a particular object,
such as printing itself out, copying itself, or altering one or more of its properties. Class
methods might perform operations on many objects collectively or provide other operations
that aren’t dependent on any particular object.
Method invocation
This is how we invoke a method:
invocant->method(list)
invocant->method
E.g.
1
$seq1 = $gb->get_Seq_by_acc($ans);
5.3.5
Follow-up tasks 5-2
1. Make sure you understand the programs ref2.pl and ref3.pl.
2. Write a subroutine that takes two arrays as arguments and returns a hash. The hash
is created from the two arrays such that the first element of the first array is used as
a key and the first element of the second array is the corresponding value, and so on.
Test your subroutine on some arrays.
100
CHAPTER 5. APPLYING PERL
3. Create an array and where each element of the array is a reference to a hash. Write
a subroutine that takes such an array of hashes and display the values and keys of all
hashes defined. Test your subroutine.
5.4
Searching in large text files
In this application, and the exercises that follows, we will use Perl to scan through large text
files. The example below will utilize the Swiss-Prot database used in previous exercises and
a cross-reference file, pdb2sprot.txt, linking PDB id’s with Swiss-Prot ID/AC strings.
The task is to complete the missing information in the second column of the following table:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
PDB
2YTE
1K46
1RJJ
113L
1S1J
2QKD
9LDB
3BW6
3MEJ
1S1S
7ZNF
1DU5
1C4Y
1FAD
1HY5
Organism
The “organism” information can be found in the Swiss-Prot database file and the link between an PDB ID and the Swiss-Prot ID can be found in the pdb2sprot.txt. Let’s look at
the two files!
5.4.1
The Swiss-Prot flat file
From the user manual of the Swiss-Prot file on can read5 :
Swiss-Prot is an annotated protein sequence database. It was established in
1986 and maintained collaboratively, since 1987, by the group of Amos
Bairoch first at the Department of Medical Biochemistry of the University of
Geneva and now at the Swiss Institute of Bioinformatics (SIB) and the EMBL
Data Library (now the EMBL Outstation - The European Bioinformatics
Institute (EBI)). The Swiss-Prot Protein Knowledgebase consists of sequence
5
http://www.expasy.ch/sprot/userman.html
5.4. SEARCHING IN LARGE TEXT FILES
101
entries. Sequence entries are composed of different line types, each with
their own format. For standardization purposes the format of Swiss-Prot
follows as closely as possible that of the EMBL Nucleotide Sequence
Database.
Here is one entry from the Swiss-Prot file:
ID
AC
DT
DT
DT
DE
GN
OS
OC
OC
OX
RN
RP
RC
RX
RA
RT
RL
CC
CC
CC
CC
DR
DR
DR
DR
DR
DR
DR
PE
KW
FT
FT
SQ
Y491_PASMU
Reviewed;
127 AA.
Q9CNE1;
22-AUG-2003, integrated into UniProtKB/Swiss-Prot.
01-JUN-2001, sequence version 1.
10-AUG-2010, entry version 25.
RecName: Full=Uncharacterized protein PM0491;
OrderedLocusNames=PM0491;
Pasteurella multocida.
Bacteria; Proteobacteria; Gammaproteobacteria; Pasteurellales;
Pasteurellaceae; Pasteurella.
NCBI_TaxID=747;
[1]
NUCLEOTIDE SEQUENCE [LARGE SCALE GENOMIC DNA].
STRAIN=Pm70;
MEDLINE=21145866; PubMed=11248100; DOI=10.1073/pnas.051634598;
May B.J., Zhang Q., Li L.L., Paustian M.L., Whittam T.S., Kapur V.;
"Complete genomic sequence of Pasteurella multocida Pm70.";
Proc. Natl. Acad. Sci. U.S.A. 98:3460-3465(2001).
----------------------------------------------------------------------Copyrighted by the UniProt Consortium, see http://www.uniprot.org/terms
Distributed under the Creative Commons Attribution-NoDerivs License
----------------------------------------------------------------------EMBL; AE004439; AAK02575.1; -; Genomic_DNA.
RefSeq; NP_245428.1; -.
GeneID; 1243838; -.
GenomeReviews; AE004439_GR; PM0491.
KEGG; pmu:PM0491; -.
NMPDR; fig|272843.1.peg.491; -.
BioCyc; PMUL272843:PM0491-MONOMER; -.
4: Predicted;
Complete proteome.
CHAIN
1
127
Uncharacterized protein PM0491.
/FTId=PRO_0000216293.
SEQUENCE
127 AA; 14589 MW; A85EFFC5579E4184 CRC64;
MQLVFSYIEH KSQVIPVCFW KENHQLHPLT GYLNDPMGGL NYFAFLDKVL SMLRDEDIQQ
GDISSNSWGV EIHGDQVYFC FLFAQEDTSL HFALSRAVLI DILVLWLAFR SQKPVAGYQE
VLSFAEA
//
In this application we will use the ID,OS and SQ lines.
102
5.4.2
CHAPTER 5. APPLYING PERL
The pdb2sprot.txt file
The pdb2sprot.txt file is a cross-reference between PDB ID’s and (if possible) corresponding
Swiss-Prot ID’s. The first few lines of the file looks like this:
code
101M
102L
102M
103L
103M
104L
104M
105M
106M
5.4.3
Swiss-Prot entry name(s)
MYG_PHYCA
(P02185)
LYS_BPT4
(P00720)
MYG_PHYCA
(P02185)
LYS_BPT4
(P00720)
MYG_PHYCA
(P02185)
LYS_BPT4
(P00720)
MYG_PHYCA
(P02185)
MYG_PHYCA
(P02185)
MYG_PHYCA
(P02185)
search.pl
Here is a program that will accomplish the task oulined obove. Use sprot-subset2.dat,
whick is a subset of the full Swissprot database. sprot-subset2.dat is available at the
course homepage.
search.pl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/perl -w
##### Program description #######
#
# Title: search.pl
#
# Author(s): Mattias Ohlsson
#
# Description:
#
# List of subroutines:
#
# Overall procedure:
#
# Usage: ./search.pl {table-file} {key-file} {swissprot-file}
#
##################################
use strict;
18
19
20
21
22
#### The main program ####
unless ( @ARGV == 3 ) {
die "You must have three files as argument";
}
23
24
25
# Read the key file
my $keyref = readKey($ARGV[1]);
26
27
28
# Open the table that we should complete
open my $tableFH, ’<’, $ARGV[0] or die "Cannot open table file $ARGV[0]";
5.4. SEARCHING IN LARGE TEXT FILES
29
30
31
32
33
34
35
while ( my $line = <$tableFH> ) {
next if ( $line =~ /^PDB/ );
chomp $line;
my $pdbID = $line;
$pdbID =~ s/\s*$//;
my $swissID = $keyref->{$pdbID};
my ($os, $seq) = searchSwiss($swissID, $ARGV[2]);
36
37
38
39
print "$pdbID\t$os\n";
}
close $tableFH;
40
41
#### End of main program #####
42
43
44
45
sub readKey {
my ($keyFile) = @_;
46
47
open my $kFH, ’<’, $keyFile or die "Cannot open file $keyFile";
48
49
50
51
my %ptos;
while ( my $line = <$kFH> ) {
next if ( $line =~ /^code/ );
52
53
54
# Each line contains 3 items, we are only interested in the first two
my ($pdb, $sid) = split ’ ’, $line;
55
56
57
58
59
# Store in a hash
$ptos{$pdb} = $sid;
}
close $kFH;
60
61
return \%ptos;
62
63
} # End of readKey
64
65
66
67
sub searchSwiss {
my ($swissID, $swissFile) = @_;
68
69
open my $sFH, ’<’, $swissFile or die "Cannot open file $swissFile";
70
71
72
73
my $os = ’’;
my $seq = ’’;
while ( my $line = <$sFH> ) {
74
75
76
# Check for the correct ID line
next unless ( $line =~ /^ID\s+$swissID\s+/ );
77
78
79
80
# Now scan for OS and SQ
my $read = 0;
while ( my $line = <$sFH> ) {
81
82
83
# Stop if we hit the last of entry code
last if ( $line =~ m|^//| );
103
104
CHAPTER 5. APPLYING PERL
84
# Collect the OS line
if ( $line =~ /^OS\s+(.+)$/ ) {
$os .= $1 . ’ ’;
}
85
86
87
88
89
# Collect the sequence
if( $read ) {
$seq .= $line;
} elsif ( $line =~ /^SQ/ ) {
$read = 1;
}
90
91
92
93
94
95
96
}
last;
97
98
}
close $sFH;
99
100
101
$seq =~ s/\n//g;
$seq =~ s/\s//g;
102
103
104
return ($os, $seq);
105
106
107
} # End of searchSwiss
search.pl
5.4.4
Follow-up tasks 5-3
The following files are needed for the below exercises:
search.pl, PDB-table.txt,
sprot-subset2.dat.
pdb seqres.txt,
mkindex.pl,
pdb2sprot.txt
and
1. Make sure that you understand this program and then write a program header for
search.pl.
2. Modify the program so that all of the (optional) RX lines are returned and printed
instead of the organism.
3. The file pdb seqres.txt6 contain all PDB entries in Fasta format. Use this file to
extract the protein sequences for all PDB codes in the PDB-table.txt file. Compare
each sequence with the corresponding sequence from the Swiss-Prot database. Print
the difference in length together with the other information.
4. Optimization of the code. The subroutine searchSwiss always starts from the beginning of the Swiss-Prot flat file. For relatively small files this is an acceptable solution,
but for really large files this approach can take very long time.
The Perl functions seek and tell can be used to “move around” in a file handle.
Using the tell function we can create an index that relates a certain ID to a position
6
ftp://ftp.wwpdb.org/pub/pdb/derived data/pdb seqres.txt.gz
5.5. BLAST PARSING
105
in the file. With the use of this index and the seek function we can jump directly to
the position of a certain ID.
The Perl script mkindex.pl contains a subroutine that makes such an index. Use this
index and modify the searchSwiss routine to make use of the seek function. This
will significantly speed up the code.
5.5
Blast parsing
In this section we will look at a Perl program that parses the large amount of information
that a Blast run produces. Below is (part of) such a result file (1TEN blastp.res) produced
by the blastp program, when blasting the protein 1TEN (PDB id).
BLASTP 2.2.30+
Reference: Stephen F. Altschul, Thomas L. Madden, Alejandro
A. Schaffer, Jinghui Zhang, Zheng Zhang, Webb Miller, and
David J. Lipman (1997), "Gapped BLAST and PSI-BLAST: a new
generation of protein database search programs", Nucleic
Acids Res. 25:3389-3402.
Reference for compositional score matrix adjustment: Stephen
F. Altschul, John C. Wootton, E. Michael Gertz, Richa
Agarwala, Aleksandr Morgulis, Alejandro A. Schaffer, and
Yi-Kuo Yu (2005) "Protein database searches using
compositionally adjusted substitution matrices", FEBS J.
272:5101-5109.
RID: 3CDJ5NH701R
Database: All non-redundant GenBank CDS
translations+PDB+SwissProt+PIR+PRF excluding environmental samples
from WGS projects
49,886,901 sequences; 17,905,752,166 total letters
Query=
Length=90
Sequences producing significant alignments:
pdb|1TEN|A Chain A, Structure Of A Fibronectin Type Iii Domai...
dbj|BAG64930.1| unnamed protein product [Homo sapiens]
.
.
.
ref|XP_005498448.1| PREDICTED: tenascin isoform X3 [Columba l...
gb|KFQ87172.1| Tenascin-R [Phoenicopterus ruber ruber]
Score
(Bits)
E
Value
182
191
4e-57
2e-54
158
158
3e-42
3e-42
ALIGNMENTS
>pdb|1TEN|A Chain A, Structure Of A Fibronectin Type Iii Domain From Tenascin
Phased By Mad Analysis Of The Selenomethionyl Protein
Length=90
Score =
182 bits (461), Expect = 4e-57, Method: Compositional matrix adjust.
Identities = 90/90 (100%), Positives = 90/90 (100%), Gaps = 0/90 (0%)
Query
1
Sbjct
1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
60
60
106
CHAPTER 5. APPLYING PERL
Query
61
Sbjct
61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT
NLKPDTEYEVSLISRRGDMSSNPAKETFTT
NLKPDTEYEVSLISRRGDMSSNPAKETFTT
90
90
>dbj|BAG64930.1| unnamed protein product [Homo sapiens]
Length=1080
Score =
191 bits (486), Expect = 2e-54, Method: Composition-based stats.
Identities = 90/90 (100%), Positives = 90/90 (100%), Gaps = 0/90 (0%)
Query
.
.
.
1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
60
There are of course many ways we can try to “summarize” the information found in this
file. The program presented below parses a blast result file (like 1TEN blastp.res) in the
following way: Alignments with the number of identities between a user defined interval are
extracted and (optionally) printed on the screen together with the first identification line
and the actual number of identities (in %).
parse.pl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#!/usr/bin/perl -w
####### Program description #######
#
# Title: parse.pl
#
# Author(s): Mattias Ohlsson
#
# Description:
# This is a parser for result files produced by the Blastp program
# for sequence alignment.
#
# List of subroutines:
# GetSubjects();
# GetHSPs();
# AnalyzeHSP();
#
# Overall procedure:
# This program loads a result file from a blastp run. The program does
# not check that the loaded file is a valid blastp file, only that it
# is a non-empty file. The file is stored as a single scalar. All the
# analysis is performed on scalar and not on an array containing lines
# of the result file. The first step is to split the result into
# subjects, this is performed in the GetSubjects routine. The program
# then makes a loop over all found subjects and for each subject all
# the high scoring pairs are extracted (GetHSP). A second loop is over
# all HSPs found and where each HSP is analyzed in the AnalyzeHSP
# routine. This routine extracts all the information needed in order
# to select the ones with a percentage of identities within a specified
# range. The selected ones are printed together with the alignment
# (optional).
#
# Usage:
# ./parse.pl {blast result file}
5.5. BLAST PARSING
34
35
36
#
###################################
use strict;
37
38
#### The main program ####
39
40
41
42
43
44
45
### Part 1: Read the input file and check that is non-zero
undef $/;
my $Blast = (<>);
unless ( length $Blast > 0 ) {
die "Zero length input file\n";
}
46
47
48
49
50
### Part 2: Some hardcoded constants
my $Icutlow = 80;
my $Icuthigh = 85;
my $PrintAlign = 1;
51
52
53
### Part 3: The rest
my @subjects = GetSubjects($Blast);
54
55
56
my (@Idents, @Alns);
foreach my $subj ( @subjects ) {
57
my ($sID, $rHSPs) = GetHSPs($subj); # All the high scoring pairs
58
59
undef @Idents;
undef @Alns;
for (my $i = 0; $i < @{$rHSPs}; $i++) {
my $rHPSres = AnalyzeHSP($rHSPs->[$i]);
my $id = $rHPSres->{’Pid’};
60
61
62
63
64
65
# Check the criteria
if ( $id >= $Icutlow && $id <= $Icuthigh ) {
push @Idents, $id;
push @Alns, $rHPSres->{’Aln’};
}
66
67
68
69
70
}
71
72
if ( @Idents ) {
print "======= ID: $sID =======\n";
foreach (my $i = 0; $i < @Idents; $i++) {
print "=> Identities: $Idents[$i]%\n";
if ( $PrintAlign == 1 ) { print $Alns[$i], "\n"; }
}
}
73
74
75
76
77
78
79
80
}
81
82
83
84
85
sub GetSubjects {
# The blast "file"
my ($blast) = @_; # Note this is a copy of the supplied blast "file"!
86
87
88
# Get rid of everything before the ALIGNMENTS line
$blast =~ s/^.*ALIGNMENTS\n//s;
107
108
CHAPTER 5. APPLYING PERL
89
90
91
# and everthing after the database statement
$blast =~ s/\s\sDatabase:.*//s;
92
93
94
# Now split on the >xxx pattern but keep the >xxx itself
my @subjects = split /(?=>\w{2,3})/, $blast;
95
96
return @subjects;
97
98
} # End of GetSubjects
99
100
101
102
103
sub GetHSPs {
# One subject
my ($subject) = @_; # Note this is a copy of the supplied subject!
104
105
106
107
108
109
110
111
112
113
# Extract an ID
my $id;
if ( $subject =~ /^>(\w{2,3}\|.*?\|)/ ) {
$id = $1;
} else {
print "Warning: Subject does not start with a known format\n";
print $subject;
exit;
}
114
115
116
117
# Now get HSPs by dividing at the Score line
$subject =~ s/^.*?(?=Score)//s;
my @hsps = split /(?=\sScore)/, $subject;
118
119
return($id, \@hsps);
120
121
} # End of GetHSPs
122
123
124
125
126
sub AnalyzeHSP {
# The HSP
my ($hsp) = @_; # Note this is a copy of the supplied hsp!
127
128
129
130
131
132
133
134
# This will store the results
my %HSPres;
#Identities = 90/90 (100%), Positives = 90/90 (100%), Gaps = 0/90 (0%)
# Find the score
if ( $hsp =~ /Identities\s+=\s+\d+\/\d+\s+\((\d+)%\)/ ) {
$HSPres{’Pid’} = $1;
}
135
136
137
138
139
# Get the Alignment
$hsp =~ s/^.*?(?=Query)//s;
$hsp =~ s/\n(?=\n)//g;
$HSPres{’Aln’} = $hsp;
140
141
142
143
# Now return a reference to the result hash
return \%HSPres;
5.5. BLAST PARSING
144
109
} # End of AnalyzeHSP
parse.pl
A few details in this program is worth noting.
• The program treats the input file as single scalar ($Blast) including all line breaks.
A convenient way to read an file into a single scalar is to modify the special variable
$/, called the input record separator. This variable is usually set to \n, the new line
character. By undefining this variable we get the whole input file as a single scalar
(see line 41-42).
• Pattern matching. Normally in a regular expression the dot (.) matches any character,
except the new line one (\n). However if we use the s modifier it matches the new line
character also. This is used in the program several times (e.g. line 88).
• Positive lookahead assertion. Sometimes it useful to have regular expression that
matches in a hypothetical way. Perl have four such constructs. The positive lookahead assertion is used in this program and it looks like (?=PATTERN). You can see an
example of it at line 138. The regexp s/\n(?=\n)//g looks for two consecutives \n\n
characters, but when it finds two it will on only replace the first one with “nothing”
since the second is a lookahead assertion only. As they put in the Learning Perl textbook: The Engine works it all out for us by actually trying to match the hypothetical
pattern, and then pretending that it didn’t match (if it did).
This program run on the 1TEN blastp.res file (e.g. >> ./parse.pl 1TEN blastp.res)
results in the following output:
1
2
3
4
5
6
7
8
Result of: ./parse.pl 1TEN blastp.res
======= ID: ref|XP_005022418.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 772 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
Sbjct 832 NLRPHTEYEVTLISRRGDMESDPVKEVFVT 861
60
831
9
10
11
12
13
14
15
16
17
======= ID: ref|XP_006137248.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIEV+DVTDTTALITWFKPLAEID +EL+YG KDVPGDRTTIDL+EDE+QYSIG
Sbjct 804 KLDAPSQIEVRDVTDTTALITWFKPLAEIDDMELSYGPKDVPGDRTTIDLSEDESQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NLKP TEYEV+LISRRGDM+S+P KETF T
Sbjct 864 NLKPHTEYEVTLISRRGDMTSDPVKETFVT 893
60
863
18
19
20
21
22
23
24
======= ID: ref|XP_005022417.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 772 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
60
831
110
CHAPTER 5. APPLYING PERL
25
26
Sbjct
832
NL+P TEYEV+LISRRGDM S+P KE F T
NLRPHTEYEVTLISRRGDMESDPVKEVFVT
861
27
28
29
30
31
32
33
34
35
======= ID: ref|XP_005022415.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 772 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
Sbjct 832 NLRPHTEYEVTLISRRGDMESDPVKEVFVT 861
60
831
36
37
38
39
40
41
42
43
44
======= ID: ref|XP_005022416.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 772 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
Sbjct 832 NLRPHTEYEVTLISRRGDMESDPVKEVFVT 861
60
831
45
46
47
48
49
50
51
52
53
======= ID: gb|EOA99266.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 772 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
Sbjct 832 NLRPHTEYEVTLISRRGDMESDPVKEVFVT 861
60
831
54
55
56
57
58
59
60
61
62
======= ID: ref|XP_005022414.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 772 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
Sbjct 832 NLRPHTEYEVTLISRRGDMESDPVKEVFVT 861
60
831
63
64
65
66
67
68
69
70
71
======= ID: gb|KFQ40359.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 454 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
Sbjct 514 NLRPHTEYEVTLISRRGDMESDPMKEVFVT 543
60
513
72
73
74
75
76
77
78
79
======= ID: ref|XP_005498448.1| =======
=> Identities: 83%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLA+I+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 741 KLDAPSQIEAKDVTDTTALITWSKPLADIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
60
800
5.6. HAND-IN EXERCISE 3
80
Sbjct
801
NLRPHTEYEVTLISRRGDMESDPMKEVFVT
111
830
81
82
83
84
85
86
87
88
89
======= ID: gb|KFQ87172.1| =======
=> Identities: 84%
Query 1
RLDAPSQIEVKDVTDTTALITWFKPLAEIDGIELTYGIKDVPGDRTTIDLTEDENQYSIG
+LDAPSQIE KDVTDTTALITW KPLAEI+GIELTYG KDVPGDRTTIDL+EDENQYSIG
Sbjct 456 KLDAPSQIEAKDVTDTTALITWSKPLAEIEGIELTYGPKDVPGDRTTIDLSEDENQYSIG
Query 61
NLKPDTEYEVSLISRRGDMSSNPAKETFTT 90
NL+P TEYEV+LISRRGDM S+P KE F T
Sbjct 516 NLRPHTEYEVTLISRRGDMESDPMKEVFVT 545
60
515
90
Result of: ./parse.pl 1TEN blastp.res
5.5.1
Follow-up tasks 5-4
Download the files:
parse.pl and 1TEN blastp.res.
and complete the following tasks:
1. Add code the subroutine AnalyzeHSP to also extract the number of gaps (if any) in
the alignment and print this on the screen.
2. For each HSP that you select, find the longest sub-alignment that contains only identities and print it on the screen. As an example, the following alignment
Query: 41 FAGKDLESIKGTAPFETHANRIVGFFSKIIGELPN 75
FAGKDL+S+K TA F THA RIVGF S+I+ + N
Sbjct: 1 FAGKDLDSLKNTASFATHAGRIVGFVSEIVALMGN 35
has FAGKDL as the longest sub-alignment with identities.
3. For each alignment that you select, count the number of sub-alignments, with only
identities, larger than a given number.
Task 3 is of the type: “to do if you have time”.
5.6
Hand-in exercise 3
Select one of the following problems as the hand-in exercise for this week.
1. The program for converting between clustalw and phylip file formats (first section of
this chapter) does not handle the conservation line used in the clustalw files. Write
a Perl program (or add more functionality to an existing one) so that when you
convert from phylip to clustalw format the conservation line is also created. This
program should also recognize the input format, i.e. one should not have to specify
the direction of conversion. Below is a definition of the conservation line:
112
CHAPTER 5. APPLYING PERL
Three characters are now used in the conservation line:
’*’ Indicates positions which have a single, fully conserved residue.
’:’ Indicates that one of the following “strong” groups is fully conserved:
STA, NEQK, NHQK, NDEQ, QHRK, MILV, MILF, HY, FYW
’.’ Indicates that one of the following ’weaker’ groups is fully conserved:
CSA, ATV, SAG, STNK, STPA, SGND, SNDEQK, NDEQHK, NEQHRK,
FVLIM, HFY
Summary: You should write a Perl program that converts clustalw files to phylip files
and vice versa. When you run your program on clustalw1.align/clustalw2.align
you should get exactly the phylip1.align/phylip2.align and the other way around.
2. Write a parser for the result files produced by the FASTA sequence alignment program.
This parser should, for each alignment, print the percentage of identities and print the
length of the longest sub-alignment with only identities. To identify each aligned sequence, extract the first group characters after >> (e.g. TR:E7EVS8 HUMAN. The FASTA
result file that you should work with is called 1TEN fasta.res and is available at the
course web page.
Summary: Write a parser for the 1TEN fasta.res file. Your output should look like
the sample output file sample-1TEN fasta.txt.
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement