Este conteúdo faz parte do livro “Introdução à Programação para Bioinformática com Perl“. Você pode adquirir a versão impressa desse livro aqui ou a versão para Kindle aqui. Para nos citar, consulte este link.
Em Bioinformática, uma sequência constitui num conjunto de letras que representam um fragmento de DNA, RNA e de proteína. BioPerl fornece quatro módulos para análise de sequências. São eles: Bio::Seq, Bio::SeqEvolution, Bio::SeqFeature e Bio::SeqIO.
Neste capítulo abordaremos técnicas para manipulação de sequências usando BioPerl e até mesmo funções básicas do Perl.
Sequências de DNA, RNA e proteína
Nucleotídeos presentes em sequências de DNA podem ser representados pelos caracteres A, T, C e G, ou seja, adenina, timina, citosina e guanina, respectivamente. Para sequências de RNA, o caractere T é substituído por U, que representa o nucleotídeo uracila. Entretanto, existem ainda caracteres utilizados para representar grupos de nucleotídeos, como por exemplo, o caractere R que representa purinas (nucleotídeos adenina ou guanina).
Observe abaixo a tabela de nucleotídeos e seus respectivos caracteres identificadores.
Caractere | Nucleotídeo |
A | Adenina |
T | Timina |
C | Citosina |
G | Guanina |
U | Uracila |
R | Purina (A ou G) |
Y | Pirimidina (C, T, ou U) |
M | C ou A |
K | T, U, ou G |
W | T, U, ou A |
S | C ou G |
B | C, T, U, ou G (exceto A) |
D | A, T, U, ou G (exceto C) |
H | A, T, U, ou C (exceto G) |
V | A, C, ou G (exceto T, exceto U) |
N | Qualquer base (A, C, G, T, ou U) |
Proteínas são compostas por aminoácidos interligados por ligações peptídicas. Aminoácidos podem ser representados por códigos de três letras ou por códigos de uma letra. O código de uma letra, mais utilizado em sequências de aminoácidos, é composto por 22 letras: 20 representando os aminoácidos, além dos caracteres B, que pode ser Asparagina ou Aspartato, e Z, que pode ser Glutamina ou Glutamato.
Aminoácido | Código três letras | Código uma letra |
Alanina | ALA | A |
Asparagina ou Aspartato | ASX | B |
Cisteína | CYS | C |
Aspartato | ASP | D |
Glutamato | GLU | E |
Fenilalanina | PHE F | F |
Glicina | GLY | G |
Histidina | HIS | H |
Isoleucina | ILE | I |
Lisina | ILE | I |
Leucina | LEU | L |
Metionina | MET | M |
Asparagina | ASN | N |
Prolina | PRO | P |
Glutamina | GLN | Q |
Arginina | ARG | R |
Serina | SER | S |
Treonina | THR | T |
Valina | VAL | V |
Triptofano | TRP | W |
Tirosina | TYR | Y |
Glutamina ou Glutamato | GLX | Z |
Obtendo o tamanho de uma sequência
Para se obter o tamanho de uma sequência com BioPerl podemos utilizar o módulo Bio::Seq e o método length. Você aprendeu anteriormente sobre sub-rotinas (ou funções), entretanto em orientação a objetos elas são conhecidas como “métodos”. Observe:
use Bio::Seq;
my $seq = Bio::Seq->new(-id => 'seq1', -seq => 'ATCGGT');
print $seq->id.": ".$seq->length." pb. \n"; # Seq1: 6 pb.
Observe que no campo id podemos inserir um nome para a sequência (no exemplo chamada de seq1). Aplicando o método length ao objeto $seq, BioPerl executa uma sub-rotina que calcula a quantidade de caracteres da sequência.
Podemos ainda inserir outros campos para descrever uma sequência, como por exemplo, “-desc” para descrição. Esses campos são conhecidos como “argumentos”.
Sequência reversa complementar
Uma função básica do BioPerl é obtenção de sequências reversas complementares. Define-se como sequência reversa complementar a sequência formada por bases que pareiam com bases de outra fita de DNA, ou seja, bases que realizam ligações de hidrogênio na formação da dupla hélice do DNA. Logo, A pareia com T, pois adenina realiza ligações de hidrogênio com timina, assim como C pareia com G, devido as ligações entre citosina e guanina. Ela é reversa pois a outra fita transcreve em sentido oposto.
O módulo Bio::Seq fornece métodos para determinação dessas sequências.
use Bio::Seq;
my $seq = Bio::Seq->new(-id => 'seq_teste', -seq => 'ATCGGT');
print $seq->seq."\n".$seq->revcom->seq."\n";
# ATCGGT
# ACCGAT
Para obter o reverso complementar utilizamos o método revcom, que recebe a sequência presente em seq. Observe que o reverso complementar da sequência “ATCGGT” é “ACCGAT”.
Transcrição
O processo de transcrição permite a formação do RNA mensageiro com base na região codificante do DNA. Computacionalmente falando, podemos analisar a transcrição como um processo de modificações em strings.

Vamos reproduzir o exemplo acima utilizando o método transcribe do BioPerl:
use Bio::Seq;
my $seq = Bio::Seq->new(
-id => 'seq_teste',
-seq => 'ATCGGT',
-alphabet => 'dna'
);
print $seq->seq." (DNA)\n".$seq->transcribe->seq." (RNA)\n";
#ATCGGT (DNA)
#AUCGGU (RNA)
Observe que na declaração da sequência inserimos um novo campo: alphabet (alfabeto). O argumento alphabet permite indicar ao BioPerl que tipo de sequências se está trabalhando, no caso sequências de DNA. O campo alphabet pode receber os valores “dna”, “rna” ou “protein”. Se esse campo não for passado, BioPerl tenta predizer o tipo de sequências.
Tradução
No processo de tradução, a sequência de RNA mensageiro será utilizada como molde para a junção dos aminoácidos, e assim, a formação da proteína.

O método translate permite converter uma sequência de DNA ou RNA mensageiro em uma sequência de aminoácidos. A função traduz uma sequência de três nucleotídeos (codon) em um aminoácido.
use Bio::Seq;
my $seq = Bio::Seq->new(
-id => 'seq_teste',
-seq => 'ATCGGT',
-alphabet => 'dna'
);
print $seq->seq." (DNA)\n".$seq->transcribe->seq." (RNA)\n".$seq->translate->seq." (Protein)\n";
# ATCGGT (DNA)
# AUCGGU (RNA)
# IG (Protein)
Codons são sequências de três bases de nucleotídeos que, ao serem lidas durante o processo de tradução, representam um determinado aminoácido. O start codon representa uma sequência que indica o início da transcrição, e o stop codon, uma sequência que avisa a maquinaria celular que a tradução chegou ao fim.
Aminoácido | Codons |
Alanina | GCU, GCC, GCA, GCG |
Arginina | CGU, CGC, CGA, CGG, AGA, AGG |
Asparagina | AAU, AAC |
Aspartato | GAU, GAC |
Cisteína | UGU, UGC |
Glutamina | CAA, CAG |
Glutamato | GAA, GAG |
Glicina | GGU, GGC, GGA, GGG |
Histidina | CAU, CAC |
Isoleucina | AUU, AUC, AUA |
Start codon ou Metionina | AUG |
Leucina | UUA, UUG, CUU, CUC, CUA, CUG |
Lisina | AAA, AAG |
Fenilalanina | UUU, UUC |
Prolina | CCU, CCC, CCA, CCG |
Serina | UCU, UCC, UCA, UCG, AGU, AGC |
Treonina | ACU, ACC, ACA, ACG |
Triptofano | UGG |
Tirosina | UAU, UAC |
Valina | GUU, GUC, GUA, GUG |
Stop codon* | UAG, UGA, UAA |
Leitura e gravação de sequências
BioPerl fornece o módulo Bio::SeqIO (IO: input e output) para leitura e gravação de sequências. SeqIO suporta uma série de formatos, como por exemplo FASTA, GenBank, pir, embl, raw, ace, bsml e swiss. O argumento “-format” é utilizado para determinar o formato do arquivo.
Sequências em geral são gravadas em arquivos no formato FASTA (extensões “.fasta”, “.fas”, “.fa”, dentre outras). O formato FASTA é composto por um cabeçalho, indicado pelo caractere “>”, seguido por uma sequência de nucleotídeos ou aminoácidos. Cada arquivo pode conter uma ou mais sequências (arquivo Multi-FASTA).
>Exemplo_cabeçaho_de_arquivo_fasta_nucleotídeos
ATCTGCGGCCCCCCCCACACACACACATCTGCGGCCCCCCCCACACACACACA
GTCAGTCAGCATCGATCGATATTATTTTGATATTATTTGATATTATTTGATAT
TCGGTCAGCATCGATCGATATTATA
O formato GenBank, além de possuir sequências de nucleotídeos, armazena também informações de anotações. Ele ainda pode armazenar sequências de aminoácidos obtidas pela tradução das regiões codificantes.
No exemplo a seguir vamos ler um arquivo GenBank e gravar a sequência obtida no formato FASTA.
use Bio::SeqIO;
my $in = Bio::SeqIO->new(
'-file' => "arquivo4.txt",
'-format' => 'GenBank'
);
my $out = Bio::SeqIO->new(
'-file' => ">arquivo4.fasta",
'-format' => 'Fasta'
);
while (my $seq = $in->next_seq()) {
$out->write_seq($seq);
}
Observe que o comando new do módulo Bio::SeqIO abre um arquivo. O argumento “-file” indica o nome do arquivo que será aberto ou criado. Para criar um novo arquivo o comando é semelhante, sendo necessário apenas inserir o símbolo “>” antes do nome.
Um laço é utilizado para percorrer o arquivo GenBank. Por fim, o comando write_seq pode ser utilizado para gravar as sequências no arquivo. A seguir veremos melhor como percorrer arquivos FASTA.
Percorrendo arquivos FASTA
Para o exemplo a seguir vamos utilizar o “arquivo6.txt”. Esse arquivo contém sequências Multi-FASTA.
use Bio::SeqIO;
# Abrindo arquivo
my $in = Bio::SeqIO->new(
-file => "arquivo6.txt",
-format => "Fasta"
);
my $i = 0; #contador
while(my $seq = $in->next_seq()){
print $seq->id.": ";
print $seq->length." pb\n";
$i++;
}
print "Detectamos $i sequencias.\n";
#seq1: 334 pb
#seq2: 224 pb
#seq3: 282 pb
#seq4: 227 pb
#seq5: 211 pb
#seq6: 216 pb
#seq7: 155 pb
#Detectamos 7 sequencias.
Como visto anteriormente, o método next_seq serve tanto para percorrer arquivos GenBank quanto para arquivos FASTA. Esse comando retorna a próxima sequência de um arquivo Multi-FASTA. Em conjunto com um laço, o método next_seq permite percorrer todo o arquivo, e assim, obter informações como, por exemplo, nome e tamanho de sequências. Nesse exemplo ainda utilizamos um contador $i para determinar a quantidade de sequências no arquivo.
Agora vamos ler esse arquivo FASTA e convertê-lo para o formato GenBank. Perceba como diversas informações serão inseridas no arquivo.
use Bio::SeqIO;
my $in = Bio::SeqIO->new(
'-file' => "arquivo6.txt",
'-format' => 'fasta'
);
my $out = Bio::SeqIO->new(
'-file' => ">arquivo6.gbk",
'-format' => 'genbank'
);
while (my $seq = $in->next_seq()) {
$out->write_seq($seq);
}
Agora observe a diferença entre um arquivo FASTA e um arquivo Genbank.
>seq1
CGATCGATCGACTAGCTAGCATCGATCTGTGTGTGTGTGCTACAAGCTACGATCGATCG
CGTGCTAGCTACGATATATAAAAAAAGATCGATCGACTAGCTAGCATCGATCAGCTACG
CGATCGCGATCGATCGACTACATCGACTAGCTAGCATCGATCAGCTACGATCGATCGAC
CGATCGATCGACTAGCTAGCATCGATCTGTGTGTGTGTGCTACAAGCTACGATCGATCG
CGATCGCGATCGATCGACTACATCGACTAGCTAGCATCGATCAGCTACGATCGATCGAC
ACTAGCTAGCATCGATCTGTGTGTGTGTGCTACAAGCTA
Veja abaixo a mesma sequência representada no formato GenBank:
LOCUS seq1 334 bp dna li-near UNK
ACCESSION unknown
FEATURES Location/Qualifiers
ORIGIN
1 cgatcgatcg actagctagc atcgatctgt gtgtgtgtgc tac-aagctac gatcgatcgc
61 gtgctagcta cgatatataa aaaaagatcg atcgactagc tag-catcgat cagctacgcg
121 atcgcgatcg atcgactaca tcgactagct agcatcgatc agc-tacgatc gatcgaccga
181 tcgatcgact agctagcatc gatctgtgtg tgtgtgctac aagc-tacgat cgatcgcgat
241 cgcgatcgat cgactacatc gactagctag catcgatcag ctac-gatcga tcgacactag
301 ctagcatcga tctgtgtgtg tgtgctacaa gcta
//
Obtendo sequências de um banco de dados
Você pode obter sequências de bancos de dados externos através do módulo Bio::DB. BioPerl fornece suporte para os bancos de dados Genbank, SwissProt, GenPept, EMBL, SeqHound, Entrez Gene e RefSeq. Para obter sequências é necessário inserir um código identificador da sequência no banco. Em seguida, BioPerl fará as consultas pela Internet.
No exemplo abaixo faremos uma consulta ao GenBank para extrair a sequência cujo o id é 2.
use Bio::DB::GenBank;
my $db = Bio::DB::GenBank->new;
my $seq = $db->get_Seq_by_id(2);
print "ID: ".$seq->id."\nSEQ: ".$seq->seq."\n";
#ID: A00002
#SEQ: #AATTCATGCGTCCGGACTTCTGCCTCGAGCCGCCGTACACTGGGCCCTG
#CAAAGCTCGTATCATCCGTTACTTCTACAATGCAAAGGCAGGCCTGTGTCAGACCTT
#CGTATACGGCGGTTGCCGTGCTAAGCGTAACAACTTCAAATCCGCGGAAGACTG
#CGAACGTACTTGCGGTGGTCCTTAGTAAAGCTTG
Inicialmente declaramos o uso do módulo em questão: Bio::DB::GenBank. O método new cria uma nova conexão ao banco e a grava em um objeto. Esse objeto deverá ser utilizado todas as vezes que uma requisição for feita. O método get_Seq_by_id é utilizado para realizar buscas pelo id. Podemos ainda substituí-lo pelo método get_Seq_by_acc, que faz buscas pelo número de acesso.
Realizando buscas em bancos de dados externos
O módulo Bio::DB ainda fornece meios para realizar buscas em bancos de dados externos. Para isso devemos utilizar o módulo Bio::DB::Query.
No exemplo a seguir vamos realizar uma busca por proteínas beta-glicosidase do organismo Homo sapiens no GenBank. Por fim, vamos imprimir o id da sequência, seguido pela descrição e pelo tamanho da sequência.
use Bio::DB::GenBank;
use Bio::DB::Query::GenBank;
my $query = "Homo sapiens[ORGN] AND beta-glucosidase[TITL]";
my $qobj = Bio::DB::Query::GenBank->new(
-db => 'nucleotide',
-query => $query
);
my $gobj = Bio::DB::GenBank->new;
my $sobj = $gobj->get_Stream_by_query($qobj);
while (my $seq = $sobj->next_seq){
print $seq->id. "\t".$seq->desc. "\t". $seq->length. "\n";
}
# AF323990 Homo sapiens cytosolic beta-glucosidase (CBG)
# mRNA, complete cds. 2125
# S44552 beta-glucosidase {exon 2/intron 2 boundary,
# pseudogene} [human, Gaucher disease patient, Genomic,
95 nt]. 95
# S44219 beta-glucosidase {exon 2/intron 2 boundary}
# [human, Gaucher disease patient, Genomic Mutant, # 95 nt]. 95
# S44217 beta-glucosidase {exon 2/intron 2 boundary}
# [human, Gaucher disease patient, Genomic, 95 nt]. 95
# AF317840 Homo sapiens cytosolic beta-glucosidase
# mRNA, complete cds. 1410
# AK298377 Homo sapiens cDNA FLJ55639 complete cds, highly
# similar to Cytosolic beta-glucosidase (EC 3.2.1.21)2019
# AJ309567 Homo sapiens mRNA for bile acid
# beta-glucosidase. 3639
# AJ278964 Homo sapiens partial mRNA for cytosolic
# beta-glucosidase (GLUC gene). 1407
# AK222963 Homo sapiens mRNA for cytosolic
# beta-glucosidase variant, clone: HSI00871. 1544
Observe que criamos um objeto para a busca (query), depois utilizamos o método get_Stream_by_query para recuperar um conjunto de resultados e inseri-los no objeto que fará a query no GenBank.
Objetos de sequência
Aprendemos até agora como extrair algumas informações de objetos de sequência, entretanto há uma grande gama de informações que podem ser obtidas. Na tabela abaixo, obtida em <http://www.bioperl.org/wiki/HOWTO:Beginners> (adaptada), estão listados os principais métodos para objetos de sequência.
Nome | Retorna |
accession_number | Código identificador. Ex.: $acc = $so->accession_number; |
alphabet | Alfabeto. Ex.: $so->alphabet(‘dna’); |
authority | Organização. Ex.: $so->authority(“FlyBase”); |
desc | Descrição. Ex.: $so->desc(“Exemplo 1”); |
display_id | Código identificador. Ex.: $so->display_id(“NP_123456”); |
division | Divisão. Ex.: $div = $so->division; |
get_dates | Datas. Ex.: @dates = $so->get_dates; |
get_secondary_accessions | Outros identificadores. Ex.: @accs = $so->get_secondary_accessions; |
is_circular | Verdadeiro ou falso. Ex.: if $so->is_circular { # }; |
keywords | Palavras-chave. Ex.: @array = $so->keywords; |
length | Tamanho da sequência. Ex.: $len = $so->length; |
molecule | Tipo molecular (DNA, RNA, protein). Ex.: $type = $so->molecule; |
namespace | Namespace, se disponível. Ex.: $so->namespace(“Private”); |
new | Cria objeto de sequência. Ex.: $so = Bio::Seq->new(-seq => “MPQRAS”); |
pid | Pid. Ex.: $pid = $so->pid; |
primary_id | Código identificador. Ex.: $so->primary_id(12345); |
revcom | Reverso complementar. Ex.: $so2 = $so1->revcom; |
seq | Sequência, como uma string. Ex.: $seq = $so->seq; |
seq_version | Versão. Ex.: $so->seq_version(“1”); |
species | Cria objeto de espécie. Ex.: $species_obj = $so->species; |
subseq | Parte da sequência. Ex.: $string = $seq_obj->subseq(10,40); |
translate | Tradução da sequência. Ex.: $prot_obj = $dna_obj->translate; |
trunc | Objeto de sequência. Ex.: $so2 = $so1->trunc(10,40); |
Quer aprender mais? Conheça nossos cursos profissionalizantes à partir de R$19,99:
Capítulo 1
Introdução ao Perl
Capítulo 2
Comandos condicionais
Capítulo 3
Strings
Capítulo 4
Arrays
Capítulo 5
Laços de repetição
Capítulo 6
Manipulando arquivos
Capítulo 7
Sub-rotinas
Capítulo 8
“O guia de sobrevivência para expressões regulares em Perl”
Capítulo 9
Introdução ao BioPerl
Capítulo 10
Sequências
Capítulo 11
BLAST
Capítulo 12
Estruturas de proteínas
Capítulo 13
Hierarquia do BioPerl
Epílogo
Referências bibliográficas
Sobre os autores
Por favor, nos cite:
MARIANO, DIEGO CÉSAR BATISTA; de MELO-MINARDI, R. C. . Introdução à Programação para Bioinformática com Perl. 1. ed. North Charleston, SC (EUA): CreateSpace Independent Publishing Platform, 2016. v. 2. 200p .