Programacao para Bioinformatica-1

PROGRAMAÇÃO PARA
BIOINFORMÁTICA
Elaboração
Kelly Cristina Rodrigues Simi
Produção
Equipe Técnica de Avaliação, Revisão Linguística e Editoração

SUMÁRIO
APRESENTAÇÃO....................................................................................................................................................................................... 4
ORGANIZAÇÃO DO CADERNO DE ESTUDOS E PESQUISA.................................................................................................. 5
INTRODUÇÃO.............................................................................................................................................................................................. 7
UNIDADE I
INTRODUÇÃO À PROGRAMAÇÃO................................................................................................................................................................................... 9
CAPÍTULO 1
LÓGICA DE PROGRAMAÇÃO E ALGORITMOS........................................................................................................................................... 9
CAPÍTULO 2
VARIÁVEIS, CONSTANTES E OPERADORES.............................................................................................................................................. 14
ESTRUTURAS DE DECISÃO, REPETIÇÃO, FUNÇÕES E PROCEDIMENTOS................................................................................. 24
UNIDADE II
LINGUAGEM R E PYTHON E SUAS IDES.................................................................................................................................................................... 45
CAPÍTULO 1
IDES PARA R E PYTHON.................................................................................................................................................................................... 45
PROGRAMAÇÃO EM PYTHON........................................................................................................................................................................ 48
CAPÍTULO 3
LINGUAGEM R....................................................................................................................................................................................................... 63
UNIDADE III
USO DE BANCO DE DADOS.............................................................................................................................................................................................. 71
CAPÍTULO 1
O QUE SÃO BANCO DE DADOS....................................................................................................................................................................... 71
CAPÍTULO 2
TIPOS DE BANCOS DE DADOS....................................................................................................................................................................... 77
USO DE BANCO DE DADOS EM BIOINFORMÁTICA................................................................................................................................ 81
UNIDADE IV
ALGORITMOS DE BIOINFORMÁTICA.......................................................................................................................................................................... 85
CAPÍTULO 1
MODELOS DE ALGORITMOS ......................................................................................................................................................................... 85
CAPÍTULO 2
FONTES DE ALGORITMOS PARA USO EM BIOINFORMÁTICA......................................................................................................... 95
PRINCIPAIS ALGORITMOS EM R E PYTHON PARA RESOLVER PROBLEMAS EM BIOINFORMÁTICA............................ 99
REFERÊNCIAS....................................................................................................................................................................................... 126
APRESENTAÇÃO
Caro aluno
A proposta editorial deste Caderno de Estudos e Pesquisa reúne elementos que se

entendem necessários para o desenvolvimento do estudo com segurança e qualidade.
Caracteriza-se pela atualidade, dinâmica e pertinência de seu conteúdo, bem como
pela interatividade e modernidade de sua estrutura formal, adequadas à metodologia
da Educação a Distância – EaD.
Pretende-se, com este material, levá-lo à reflexão e à compreensão da pluralidade dos

conhecimentos a serem oferecidos, possibilitando-lhe ampliar conceitos específicos
da área e atuar de forma competente e conscienciosa, como convém ao profissional
que busca a formação continuada para vencer os desafios que a evolução científico-
tecnológica impõe ao mundo contemporâneo.
Elaborou-se a presente publicação com a intenção de torná-la subsídio valioso, de modo

a facilitar sua caminhada na trajetória a ser percorrida tanto na vida pessoal quanto na
profissional. Utilize-a como instrumento para seu sucesso na carreira.
Conselho Editorial
4
ORGANIZAÇÃO DO CADERNO
DE ESTUDOS E PESQUISA
Para facilitar seu estudo, os conteúdos são organizados em unidades, subdivididas em

capítulos, de forma didática, objetiva e coerente. Eles serão abordados por meio de
textos básicos, com questões para reflexão, entre outros recursos editoriais que visam
tornar sua leitura mais agradável. Ao final, serão indicadas, também, fontes de consulta
para aprofundar seus estudos com leituras e pesquisas complementares.
A seguir, apresentamos uma breve descrição dos ícones utilizados na organização dos
Cadernos de Estudos e Pesquisa.
Provocação
Textos que buscam instigar o aluno a refletir sobre determinado assunto
antes mesmo de iniciar sua leitura ou após algum trecho pertinente para
o autor conteudista.
Para refletir
Questões inseridas no decorrer do estudo a fim de que o aluno faça uma
pausa e reflita sobre o conteúdo estudado ou temas que o ajudem em
seu raciocínio. É importante que ele verifique seus conhecimentos, suas
experiências e seus sentimentos. As reflexões são o ponto de partida para
a construção de suas conclusões.
Sugestão de estudo complementar

Sugestões de leituras adicionais, filmes e sites para aprofundamento do
estudo, discussões em fóruns ou encontros presenciais quando for o caso.
Atenção
Chamadas para alertar detalhes/tópicos importantes que contribuam
para a síntese/conclusão do assunto abordado.
5
Organização do Caderno de Estudos e Pesquisa
Saiba mais
Informações complementares para elucidar a construção das sínteses/
conclusões sobre o assunto abordado.
Sintetizando
Trecho que busca resumir informações relevantes do conteúdo, facilitando
o entendimento pelo aluno sobre trechos mais complexos.
Para (não) finalizar

Texto integrador, ao final do módulo, que motiva o aluno a continuar a
aprendizagem ou estimula ponderações complementares sobre o módulo
estudado.
6
INTRODUÇÃO
Atualmente, estamos vivendo o período da história da humanidade em que a informação

nunca esteve tão acessível quanto nesse momento. O volume de informação produzido
excede, de forma exponencial, a capacidade de análise, a qual é essencial para a produção
de conhecimento. Desta forma, é válido afirmar que a informação não é o mesmo que
o conhecimento, e a análise das informações geradas é uma prática indispensável.
Dentro desse contexto, os analistas desses dados são profissionais essenciais para
sobrevivermos a este “dilúvio” de dados.
Não é diferente quando se trata de dados biológicos. Embora algumas décadas foram
necessárias, desde que a estrutura do DNA foi proposta até a leitura da informação
contida nesta molécula, com o surgimento das máquinas automatizadas que permitiram
o sequenciamento do genoma humano, a quantidade de informação, gerada a partir
daí, experimentou os crescimentos excepcionais. Isso tornou impraticável a análise
das sequências de DNA de forma manual. Logo, as ferramentas de bioinformática
surgiram como uma necessidade de otimizar as análises de sequências genéticas.
Para se analisar grandes genomas, tal como genoma humano, pode-se demorar vários
dias de processamento aplicando muita memória, mesmo utilizando os computadores
com múltiplos processadores para montar os fragmentos. Com isso, o conjunto
resultante, geralmente, apresenta muitas lacunas que devem ser preenchidas depois
(SILVA et al., 2020).
Segundo Can (2014), a bioinformática é um campo interdisciplinar que envolve,
principalmente, a biologia molecular e a genética, a ciência da computação, a matemática
e a estatística. Desta forma, pode-se concluir que os problemas biológicos de grande
escala e intensivos, em dados, são tratados do ponto de vista computacional. Uma
solução de bioinformática, geralmente, envolve as seguintes etapas: a coleta de dados
biológicos, a construção de modelo computacional, a resolução de problemas de
modelagem, a testagem e a avaliação do algoritmo computacional.
As análises, em bioinformática, concentram-se, predominantemente, em três tipos
de grandes conjuntos de dados disponíveis em biologia molecular: as estruturas
macromoleculares, as sequências de genoma e os resultados de experimentos de
genômica funcional (LUSCOMBE et al., 2001). Esses dados são armazenados em
grandes Bancos de Dados Biológicos (BDB), os quais se assemelham bastante com
outros tipos de BD, ou seja, têm a função de armazenar, de relacionar e de tornar,
mais eficiente, a manipulação desses dados. Geralmente, os dados, armazenados nos
BDB, são provenientes de experimentações biológicas.
7
Os dados biológicos estão distribuídos em BDB especializados, sendo que o maior
deles é o Centro Nacional de Informação de Biotecnologia (National Center for
Biotechnoly Information – NCBI), um banco de dados de uso gratuito que fornece
diversas ferramentas para as análises. O repositório do NCBI é vasto, contendo dados
de literaturas médica e científica, de sequenciamentos genômicos e proteicos, de dados
clínicos etc.
A quantidade de submissão de dados biológicos, diariamente, nos BDB especializados,

tem crescido de forma vertiginosa nos últimos anos. Este fato aumenta, cada vez mais,
a necessidade de profissionais habilitados a realizar as análises utilizando ferramentas
computacionais.
A análise dos dados biológicos envolve, principalmente, escrever e executar os programas

que utilizam uma vasta gama de algoritmos com fins específicos. Muitas linguagens de
programação podem ser utilizadas para essas análises; dentre as quais, as mais populares
são: Python, Perl e R. Desse modo, um bioinformata necessita ter os conhecimentos
básicos de dados biológicos, compreender a estrutura de bancos de dados, ter noções
básicas de lógica e de linguagem de programação, e compreender os principais algoritmos
em Python e R para resolver problemas básicos de bioinformática.
Objetivos
» Conceituar a lógica de programação e descrever os métodos para a criação
de algoritmos.
» Identificar a diferença básica entre os tipos de dados e compreender a
declaração de variáveis.
» Compreender os diferentes tipos de estruturas de decisão e de repetição.
» Diferenciar as funções de procedimentos.
» Desenvolver noções básicas de programação em Python e em R.
» Compreender os principais tipos de bancos de dados.
» Entender as aplicações de bancos de dados em bioinformática.
» Analisar os tipos principais de algoritmos de bioinformática.
» Executar algoritmos básicos em Python e em R para resolver problemas de

bioinformática.
INTRODUÇÃO À
PROGRAMAÇÃO UNIDADE I
CAPÍTULO 1
Lógica de programação e algoritmos
A palavra lógica é derivada da palavra grega, logos, e está associada ao raciocínio. Desta
forma, a lógica pode ser considerada como a arte de pensar corretamente. Ela trata das
formas de pensamento dedutivo, indutivo, hipotético, as quais visam à determinação do
que é verdadeiro ou não. Utilizamos a lógica no dia a dia para organizar o pensamento de
forma coerente; para permitir chegar a determinadas conclusões e, ainda, para escolher
caminhos para resolver problemas conhecidos. A lógica é, frequentemente, associada à
matemática, contudo sua aplicabilidade é muito mais ampla. Podemos utilizar a lógica
para definir etapas que devem ser realizadas para alcançar determinado objetivo. Uma
tarefa simples, como “retirar o carro da garagem”, envolve diversas etapas que devem
ser seguidas passo a passo: (1) pegar a chave; (2) abrir o carro; (3) entrar no carro; (4)
colocar a chave na ignição; (5) engatar a marcha ré; e (6) dirigir o carro. A definição
da ordem das etapas é realizada utilizando lógica, já que, pela lógica, sabemos que
não é possível dirigir o carro sem entrar nele primeiro. Desse modo, para alcançar o
objetivo final, deve-se seguir todas as etapas na ordem definida.
Lógica de programação
Aplicando os conceitos de lógica no âmbito computacional, é fácil compreender a
importância da lógica para a criação de algoritmos. A lógica de programação se iniciou
nos anos 1970 por meio de sistemas de dedução automatizados que testavam teoremas
e inteligência artificial.
A lógica de programação tem como objetivo mostrar métodos para solucionar problemas,
além de determinar a sequência lógica para o desenvolvimento de um programa
(ALMEIDA, 2008).
Desta forma, a lógica consiste em um conjunto de regras e de conceitos que direcionam

a criação de um código para uma máquina, e é estruturada por um sequência de
9
Unidade I | Introdução à programação
procedimentos que são executadas sobre dados para transformá-los em informações.

As sequencias lógicas são conhecidas como algoritmos, os quais funcionam como se
fossem uma receita de bolo, mostrando para o computador o que deve ser feito em
cada sequencia lógica.
Um algoritmo pode ser definido como uma sequência de passos que visam atingir um
objetivo bem definido. Na medida em que precisamos especificar uma sequência de
passos, é necessário utilizar ordem, ou seja, “pensar em ordem”, portanto precisamos
utilizar lógica (FORBELLONE, 2005).
Os algoritmos devem ser os mais simples, claros e precisos, já que o computador

consegue apenas seguir os passos e não raciociná-los.É importante salientar que
não existe uma única forma de escrever um algoritmo. Existem vários algoritmos
que podem obter o mesmo resultado final, utilizando passos e etapas diferentes. De
forma geral, um algoritmo possui os seguintes elementos básicos representados na
imagem abaixo.
Figura 1. Elementos básicos de um algoritmo
Fonte: elaboração do próprio autor.
Representação de algoritmos
Os algoritmos podem ser representados de diversas formas, contudo as representações

mais utilizadas são: descrição narrativa, pseudocódigo e fluxograma.
Descrição narrativa
A descrição narrativa, também, é conhecida como linguagem natural. É a forma

de representação mais simples, pois utiliza a linguagem do dia a dia e as etapas são
escritas com um texto simples. Considere que seja necessário criar um algoritmo
para mostrar o resultado da soma de dois números. Na representação de descrição
narrativa, o algoritmo seria escrito da forma representada abaixo.
Passo 1 – início
Passo 2 – receber o primeiro número
Passo 3 – receber o segundo número
Passo 4 – realizar a soma dos dois números
Passo 5 – mostrar o resultado obtido
10
Introdução à programação | Unidade I
Pseudocódigo
O pseudocódigo, também, conhecido como linguagem estruturada ou portugol, é rica

em detalhes e é a forma de representação mais bem aceita. Sua grande vantagem é
a possibilidade de adaptação do código para qualquer linguagem de programação.
Contudo, é necessário aprender as regras básicas de construção de um pseudocódigo.
Se o mesmo algoritmo de soma de dois números fosse escrito em pseudocódigo, ele
seria escrito da seguinte forma.
1 algoritmo “exemplo1”
2 var n1, n2, soma: real
3 inicio
3 escreval (“digite o primeiro número”)
4 leia (n1)
5 escreval (“digite o segundo número”)
6 leia (n2)
7 soma <- n1 + n2
8 escreva (“a soma é = “, soma)
fimalgoritmo
Fluxograma
A representação, em forma de fluxograma, utiliza os símbolos convencionais e é

representado por desenhos geométricos básicos para mostrar: dados de entrada,
processamentos e saída de dados.
A figura, abaixo, demonstra a representação de fluxograma de um algoritmo de soma
de dois números.
Figura 2. Representação de algoritmo em fluxograma.
11
Esse tipo de representação é mais sucinto que a textual, mas para construí-lo é necessário
aprender a simbologia dos fluxogramas. O quadro a seguir, representa os principais
simbolos utilizados no fluxograma.
Quadro 1. Símbolos de fluxograma.
Simbolo Aplicação
Utilizado para indicar o início ou o fim do algoritmo.
Utilizado para conectar os simbolos do fluxograma e, ainda, indicar o sentido dos dados.
Utilizado para representar a entrada dos dados.
Utilizado par representar a saída dos dados.
Utilizado para indicar a tomada de decisões.
Existem alguns programas (gratuitos ou pagos) que permitem a criação de fluxogramas,

os quais podem ser instalados no computador ou utilizados como ferramentas online.
Um bom exemplo é o Lucidchart, o qual possui diversos recursos, mesmo na versão
gratuita (https://www.lucidchart.com/pages/pt).
Etapas para construção de algoritmos
Segundo Ascencio e Campos (2002), para a construção de qualquer tipo de algoritmo,

deve-se levar em consideração algumas etapas básicas.
» Definir qual a problemática que deve ser resolvida com o algoritmo.
» Definir quais os dados de entradas, ou seja, o que o usuário deve fornecer para
o algoritmo.
» Qual tipo de transformação esses dados sofrerão no processamento.
12
» Quais dados serão gerados na saída (após o processamento).
» Construir o algoritmo em uma de suas representações (descrição narrativa,

pseudocódigo ou fluxograma).
» Testar o algoritmo e realizar simulações.
Todas essas etapas podem ser resumidas em três principais.
» Análise: estuda-se o enunciado do problema para definir os dados de entrada,

o processamento e os dados de saída.
» Algoritmo: criação do algoritmo em uma das representações.
» Codificação: onde o algoritmo é transformado em códigos de uma linguagem

de programação.
Linguagem de programação
Se um algoritmo não está escrito de forma que o computador entenda, é necessário

traduzi-lo em uma linguagem para que ele compreenda. Essa linguagem é conhecida
como Linguagem de Programação (LP). Existem vários tipos de LPs, com paradigmas
e níveis de abstração diferentes.
Quando uma LP assemelha-se à linguagem falada ou escrita por um ser
humano, ela é dita de alto nível, e, quando ela aproxima-se da linguagem
de máquina, é dita de baixo nível. Da mesma forma que o Português, por
exemplo, tem regras (sintaxe) para que seja compreendido por qualquer
pessoa que fale esta lingua, as LPs também têm um conjunto de regras com
as quais é possível traduzir um algoritmo e gerar um programa (SANTOS
et al., 2018, p. 3).
Um programa, por sua vez, é um software computacional que realiza uma tarefa utilizando
uma linguagem de programação. Se fizermos uma pequena busca no Google utilizando
os seguintes termos de busca, “As 5 linguagens de programação mais utilizadas em
2020”, teremos o seguinte resultado: 1º Java, 2º JavaScript, 3º Python, 4º PHP e 5º C++.
É claro que o ranqueamento pode mudar com o tempo, visto que novas linguagens
surgem no mercado, o que faz com que outras se tornem obsoletas.
13
CAPÍTULO 2
Variáveis, constantes e operadores
Variáveis e constantes
Ao escrever um programa, para realizar determinada tarefa, é necessário definir quais
tipos de dados serão utilizados, dados esses que são fornecidos pelo usuário. Os dados
utilizados deverão ser armazenados na memória do computador. Para compreender
melhor essa forma de armazenamento, vamos utilizar a analogia de um arquivo,
daqueles utilizados em escritórios, cheios de gavetas etiquetadas, para armazenamento
de documentos ou de objetos. A memória é como se fosse esse grande arquivo, e as
gavetas são as variáveis que têm nomes (etiquetas) diferentes. Ainda, imagine que as
gavetas tenham tamanhos diferentes, isso representa os tipos diferentes de variáveis,
os quais podem ocupar mais ou menos espaço na memória.
Neste capítulo, iremos realizar algumas aplicações práticas em pseudocódigo. Para isso,
o VisualG será indicado para criar e executar algoritmos em português estruturado
(Portugol), por se tratar de um programa de domínio público, simples e ideal para
programadores iniciantes. Para baixá-lo, basta acessar: http://visualg3.com.br.
Variáveis
Uma variável é um local que armazena um conteúdo específico dentro da memória

do computador, esse conteúdo pode conter valores e tamanhos diferentes. Em outras
palavras, a variável é responsável por receber valores de maneira que o computador
possa utilizá-los dentro de um programa. As variáveis são definidas pelo tipo de dados
associados a elas.
Tipos de variáveis
O tipo de uma variável, basicamente, está associado ao tipo de dado associado a ela. Se
uma variável armazenar um número, ela é do tipo numérica, se armazenar letras, é do
tipo caractere e, assim, por diante. Os tipos de dados são bem similares para qualquer
tipo de linguagem de programação e podem ser classificadas em duas principais
categorias: dados primitivos e dados derivados (customizados).
14
Dados Primitivos
São os tipos de dados básicos utilizados em algoritmos. A maioria das linguagens

utiliza quatro tipos principais: inteiro, real, caractere e lógico.
Inteiro
Contém valores pertencentes ao conjunto dos números inteiros. Podem ser positivos,
negativos e nulos. Os valores inteiros não podem conter casas decimais Exemplo: -8,
-3, 0, 1, 2, 100.
Real
Contém valores pertencentes ao conjunto dos números reais. Além de poderem ser
negativos ou positivos, ainda, podem conter casas decimais, representadas por ponto
(“.”). Exemplo: -8.72, 0.0, 4.83.
Caractere
Contém valores pertencentes ao conjunto de caracteres alfanuméricos. Deve ser escrito

com apóstrofo ou aspas simples. Exemplo: ‘a’, ‘1’, ‘$’, ‘!’, ‘@’ etc.
Lógicos ou booleanos
Informação que pode assumir apenas dois valores possíveis: verdadeiro (true) ou falso
(false); ou, ainda, sim (yes) ou não (not). Esses dados, também, são conhecidos como
booleanos, homenagem ao filósofo inglês George Boole, por causa da sua grande
contribuição à área de lógica matemática.
Dados derivados
Algumas linguagens de programação dividem os dados primitivos baseando-se no espaço

necessário para o armazenamento dos valores da variável. Esses dados são conhecidos
como dados derivados e pode variar de acordo com a linguagem de programação
utilizada. O quadro a seguir, lista os principais tipos de dados derivados dos dados
primitivos.
Tabela 2. Principais tipos de dados derivados
Dado Derivado Tipo Valor armazenado

Byte Inteiro 8 bits
Short Inteiro 16 bits
Int Inteiro 32 bits
15
Dado Derivado Tipo Valor armazenado

Long Inteiro 64 bits
Float Real Ponto flutuante de 32 bits
double Real Ponto flutuante de 64 bits
string Caractere Conjunto de caracteres
Declaração de variáveis
A declaração de variável dentro de um algoritmo tem como objetivo fazer com que o
computador reserve um espaço para armazenar algum tipo de dado. Esse espaço será
identificado por um nome (que será o nome da variável). Em pseudocódigo, a declaração
da variável ocorre antes da atribuição de valores. Já em linguagens de programação,
é possível declarar e já atribuir variáveis com um valor na mesma linha do código. É
importante salientar que cada variável só pode armazenar um único dado por vez e
esse dado deve ser do mesmo tipo que foi declarado.
Regra de nomenclatura de variáveis
O nome, atribuído a uma variável, é chamado de identificador. Algumas regras básicas

devem ser levadas em consideração para a definição de um identificador.
» Pode ter no máximo 32 caracteres de comprimento.
» O primeiro caractere deve ser uma letra do alfabeto.
» Os demais caracteres podem ser letra, números e underline (_).
» Não utilizar espaços em nomes compostos (nesses casos, pode-se utilizar

o underline _).
» Não pode utilizar palavras reservadas da linguagem, por exemplo: um

comando específico da linguagem de programação utilizada.
Algumas linguagens podem fazer distinção entre letra maiúscula e minúscula, conhecidas
como case-sensitive. Nesses casos, a variável “nome” é diferente de “Nome” e de “NOME”.
Exemplos de declaração de variáveis
Vamos utilizar alguns exemplos de declaração de variáveis dentro do VisualG, a qual

executa algoritmos em português estruturados.
16
Exemplo 1: declaração de variáveis de um algoritmo que faz perguntas simples ao

usuário e imprime as informações inseridas na tela.
1 algoritmo “Exemplo 1”
2 // Função : perguntas e respostas
3 // Autor :
4 // Data :
5 // Seção de Declarações
6 var
7 nome: caracter
8 idade: inteiro
9 inicio
10 // Seção de Comandos
11 escreval (“Qual é o seu nome? “)
12 leia (nome)
13 escreval (“Qual é a sua idade? “)
14 leia (idade)
15 escreval (“O seu nome é “, nome)
16 escreval (“A sua idade é “, idade)
17 fimalgoritmo
A execução do código está representada abaixo.

Qual é o seu nome?
Mary
Qual é a sua idade?
28
O seu nome é Mary
A sua idade é 28
*** Fim da execução.
*** Feche esta janela para retornar ao Visualg.
Entendendo o código
O algoritmo em português é estruturado da seguinte forma: algoritmo (identificação
do nome – é dado pelo usuário), descrições a respeito do código que não são
consideradas na execução do programa (identificadas pelas duas barras //), var
(seção de declaração das variáveis), início (local onde é escrito todo o código, com
os procedimentos) e fimalgoritmo (indica que o código finalizou).
Declaração das variáveis (linhas 7 e 8): as variáveis são declaradas dentro da seção
de declaração (var). Elas devem ter um identificador (exemplo: nome, idade) e tipo
de dados atribuído (exemplo: caracter e inteiro).
Seção de comandos: linhas 11 e 13: comando escreval  imprime, na tela, tudo

que está entre aspas “ ” (nesse espaço, é permitido qualquer tipo de caractere:
17
números, letras ou símbolos). Permite a entrada dos dados de acordo o tipo da

variável, ou seja, se o usuário tentar inserir dados alfanuméricos em uma variável
do tipo inteiro, uma mensagem de erro será mostrada na tela.
Linhas 12 e 14: comando leia  basicamente, pede para o programa receber o

dado digitado pelo usuário.
Linhas 15 e 16: comando escreval  tem a mesma função do escreval das linhas
11 e 13, só que, aqui, além de imprimir, na tela, a informação contida entre aspas
“ ”, irá imprimir os valores contidos em cada variável.
Exemplo 2: declaração de variáveis de um algoritmo que realiza soma de dois números

inteiros informados pelo usuário.
2 // Função : soma de dois números
3 // Autor :
4 // Data :
6 var
7 n1, n2, soma: inteiro
8 inicio
10 escreval (“Digite o primeiro número “)
11 leia (n1)
12 escreval (“Digite o segundo número “)
13 leia (n2)
14 soma <- n1+n2
15 escreval (“A soma dos dois números é”, soma)
16 fimalgoritmo

Digite o primeiro número
10
Digite o segundo número
8
A soma dos dois números é 18
Entendendo o código
Aqui, você já entendeu a estrutura do algoritmo, os comandos leia e escreval. Então,
o que faz o código da linha 14? A linha 14 resolve uma operação de soma. A linha
diz o seguinte: a variável soma recebe (representada pelos símbolos <-) o valor
armazenado na variável n1 somado (+) ao valor armazenado na n2. Lembre-se de
18
que, quando o programa executa essa linha, o usuário já forneceu os valores de n1

e n2 e o programa armazenou esses valores (pelo comando leia das linhas 11 e 13).
Constantes
Diferente das variáveis, que possuem valores que podem alterar durante a execução
do código, as constantes armazenam os valores fixos e inalteráveis. Uma constante
é bastante utilizada dentro de expressões matemáticas. Um exemplo clássico de uma
constante, não apenas dentro do âmbito computacional, é o valor de Pi (π) 3,1415. As
mesmas regras, para a nomeação de variáveis, aplicam-se para as constantes. Segue,
logo mais, um exemplo da utilização de uma constante em um pseudocódigo, o qual
tem como objetivo calcular o volume de um cilindro utilizando a seguinte expressão
matemática: V = π x r2 x h (onde V = volume do cilindro; π é a nossa constante, com
valor de 3.1415; r = raio e h = altura).
1 ALGORITMO “EXEMPLO 3”
2 // FUNÇÃO : VOLUME DE UM CILINDRO
3 // AUTOR :
4 // DATA :
5 // SEÇÃO DE DECLARAÇÕES
6 VAR
7 V, R, H: REAL
8 INICIO
9 // SEÇÃO DE COMANDOS
10 ESCREVAL (“DIGITE O VALOR DO RAIO DO CILINDRO “)
11 LEIA (R)
12 ESCREVAL (“DIGITE O VALOR DA ALTURA DO CILINDRO “)
13 LEIA (H)
14 PI <- 3.141515
15 V <- PI * R^2 * H
16 ESCREVAL (“O VOLUME DO CILINDRO É”, V)
17 FIMALGORITMO

Digite o valor do raio do cilindro
2
Digite o valor da altura do cilindro
4
O volume do cilindro é 50.2654824574367
19
Operadores lógicos, aritméticos e relacionais

Os operadores definem, exatamente, de qual forma os dados armazenados serão
trabalhados. As variáveis, armazenadas na memória, não teriam sentido algum se não
fossem processadas. O processamento desses dados pode ser realizado por meio de
operadores que executam cálculos ou comparações. As linguagens de programação
oferecem operadores para diversos fins. Eles podem ser categorizados da seguinte
forma: operadores lógicos, operadores aritméticos e operadores de comparação.
Operadores lógicos
Esses operadores implementam a lógica booleana por meio de a avaliação de expressões

que geram os valores verdadeiros ou falsos (Quadro 3). Essas operações podem ser de
conjunção (e), disjunção (ou) ou de negação (não). Em uma conjunção, o resultado
verdadeiro será obtido apenas quando os dados comparados forem verdadeiros. Na
disjunção, o valor será verdadeiro quando um dos dados for verdadeiro. Quando os
dados comparados forem falsos, o resultado da conjunção ou disjunção será também
falso. No caso de a negação, o valor será verdadeiro apenas quando o valor dado não
for verdadeiro.
Quadro 3. Resultados de operações da lógica booleana
Resultados das operações lógicas

A B A e B (Conjunção) A ou B (Disjunção) Não A (Negação)
V V V V F
V F F V F
F V F V V
F F F F V
Exemplificando, imagine que você esteja preparando uma viagem para o exterior, mas,
para isso, você precisa poupar dinheiro e/ou ganhar mesada (quadro 4). Aplicando a
lógica booleana dentro deste contexto, teríamos os possíveis resultados: caso a condição
para viagem ao exterior seja poupar dinheiro e ganhar mesada, você apenas viajaria
caso as duas condições fossem verdadeiras. Contudo, se você necessitasse de apenas
uma das condições para viajar, você só não viajaria caso não conseguisse nem juntar
dinheiro e nem recebesse mesada.
20
Quadro 4. Exemplo da aplicação da lógica booleana.
Viagem para o exterior

Poupou dinheiro (A) Ganhou Mesada (B) AeB A ou B
V V V V
V F F V
F V F V
F F F F
No caso de negação, imagine que, para viajar, necessitasse de poupar dinheiro. Logo,
se poupar dinheiro, você viaja, se não poupar, você não viaja.
Operadores aritméticos
Os operadores aritméticos são utilizados para definir quais ferramentas serão utilizados
para a execução do processamento matemático. Eles podem ser classificados em duas
categorias: binários (aqueles utilizados em operações de radiciação, exponenciação,
divisão, multiplicação, adição e substração) e unários (aqueles utilizados para inverter
um valor numérico: negativo para positivo ou positivo para negativo).
Quadrow 5. Operadores aritméticos
Operador Descrição
+ (soma) Efetua a soma entre dois números.
- (subtração) Efetua a subtração entre dois números.
* (multiplicação) Efetua mutiplicação entre dois números.
/ (divisão) Efetua a divisão entre dois números (resulta em número com ponto flutuante).
\ ou div Efetua a divisão entre dois números inteiros e o resultado é um número inteiro (despreza a parte
fracionária).
% ou mod Retorna o resto da divisão de inteiros.
Abaixo, segue um exemplo de um algoritmo que realiza todas as operações aritméticas

relacionadas no quadro 5.
2 // Função : operações aritméticas
3 // Autor :
4 // Data :
6 var
7 A, B, C, D, soma, subtração, multiplicacao: inteiro
8 divisao, divDB, modDB: real
21
9 inicio
11 A <- 1
12 B <- 3
13 C <- 5
14 D <- 25
15 soma <- A+B
16 subtracao <- D-C
17 multiplicacao <- D*B
18 divisao <- D/C
19 divDB <- D div B
20 modDB <- D mod B
21 escreval (“A soma de 1 e 3 é igual a “, soma)
22 escreval (“A subtração de 25 e 5 é igual a “, subtracao)
23 escreval (“A multiplicação de 25 e 3 é igual a a “, multi-
plicacao)
24 escreval (“A divisão de 25 e 5 é igual a “, divisao)
25 escreval (“O número inteiro, resultado da divisão de 25 e 3
é igual a “, divDB)
26 escreval (“O resto da divisão de 25 e 3 é igual a “, modDB)
27 fimalgoritmo

A soma de 1 e 3 é igual a 4
A subtração de 25 e 5 é igual a 20
A multiplicação de 25 e 3 é igual a a 75
A divisão de 25 e 5 é igual igual a 5
O número inteiro, resultado da divisão de 25 e 3 é igual a 8
O resto da divisão de 25 e 3 é igual a 1
Operadores de comparação ou relacionais
São aqueles que comparam ou relacionam dois valores ou variáveis. Essas comparações
podem utilizar os seguintes operadores.
Quadro 6. Operadores relacionais
Operadores Descrição
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a
= ou == Igual a
22
!= Não igual a
<> Diferente de
Prioridades das operações
Para executar corretamente as operações aritméticas, é ncessário conhecer a ordem

das prioridades dessas operações. Imagine a seguinte expressão matemática.
130 + 85 – 12 / 3 * 8
Quais operações serão executadas primeiro? Neste caso, primeiro será realizada a
divisão e a multiplicação, na ordem em que aparecem. Depois, as operações de soma
e de subtração. O algoritmo, abaixo, executa a expressão acima.
2 // Função : prioridades de operações
3 // Autor :
4 // Data :
6 var
7 resultado: real
8 inicio
10 resultado <- 130+85-12/3*8
11 escreval (“O resultado da expressão é “, resultado)
12 fimalgoritmo
De acordo com as prioridades, a execução do código retornará o valor abaixo.

O resultado da expressão é 183
A ordem de prioridades está definida no quadro a seguir.
Tabela 7. Ordem de prioridades de operadores
Prioridade Operadores
1º *, /, \
2º +, -, E e OU
3º =, <>, <, > <=, >=
23
CAPÍTULO 3
Estruturas de decisão, repetição,
funções e procedimentos
Estruturas de decisão e repetição

Até o momento, trabalhamos com algoritmos com estrutura sequencial, onde cada
linha do script é lida e executada, uma após a outra. Contudo, esta estrutura não é a
única forma de escrever um algoritmo, é possível inserir comandos dentro de uma
estrutura de repetição ou de decisão. Na estrutura de repetição, é possível inserir um
conjunto de comandos que podem ser execução por número N de vezes, definido pelo
programador. Já na estrutura condicional, o programa pode escolher o que executar,
de acordo com condição que foi imposta.
Estruturas de decisões ou condicionais
Às vezes, é necessário que o algoritmo consiga estabelecer uma ação de desvio

na sequência de comando. Esse desvio é definido por uma condição e, de acordo
com a condição, uma decisão é tomada para execução do código. Do ponto de vista
computacional, a condição é determinada por uma expressão booleana de valor lógico
verdadeiro ou falso. Desta forma, a tomada de decisão depende destes valores. Se a
condição é verdadeira, pode-se definir um comando dentro da estrutura que será
diferente de quando a condição for falsa. O estabelecimento da condição é feito por
meio dos operadores relacionais (quadro 6).
A lógica da tomada de decisão pode ser definida pela relação entre variável versus
variável, variável versus constante ou constante versus variável. Existem dois tipos
principais de desvio condicional: desvio condicional simples ou composto. Quando
é necessário usar verificações lógicas sucessivas para a tomada de decisão que são
baseadas em diversas condições, pode-se utilizar desvios sequenciais, encadeados ou
por seleção. Todas estas tomadas de decisões podem ser simples ou compostas.
24
Desvio condicional simples
Esse tipo de desvio é processado apenas para o lado em que a condição for verdadeira.
Em português estruturado, essa tomada de decisão utiliza os comandos se, entao
e fimse (figura 3).
Figura 3. Desvio condicional simples.
Exemplificando este tipo de desvio, considere um algoritmo que deve receber duas
notas de aluno, calcular a média e escrever na tela, caso o aluno seja aprovado. Imagine
que a condição de aprovação seja média com valor igual ou maior que 6. Perceba que,
neste caso, o algoritmo só imprime, na tela, caso a condição seja verdadeira. Não existe
desvio caso a condição seja falsa.
1 algoritmo “desvio condicional simples”
2 // Função : cálculo de média do aluno
3 // Autor :
4 // Data :
6 var
25
7 nota1, nota2, media: real
8 inicio
10 escreval (“digite a nota 1 do aluno: “)
12 leia (nota1)
14 leia (nota2)
15 media <- (nota1+nota2)/2
16 escreval (“A média do aluno é: “, media)
17 se media >= 6 entao
18 escreval (“O aluno foi aprovado”)
19 fimse
20 fimalgoritmo
Abaixo, segue a execução do programa caso a condição seja verdadeira.

digite a nota 1 do aluno:
10
A média do aluno é: 9
O aluno foi aprovado
E agora, caso a condição seja falsa.

5
4
A média do aluno é: 4.5
26
Perceba que, neste último caso, nenhuma mensagem foi impressa na tela, pois o
programa não foi instruído desta forma. A mensagem aparece apenas quando a
condição é verdadeira.
Observação: a ordem de prioridade das operações matemáticas foi determinada pelo

parênteses (). Como a operação de divisão sempre ocorre antes da soma, neste caso,
a operação de soma foi representada dentro do parêntese para que ela fosse realizada
antes da operação de divisão.
Desvio condicional composto
Neste caso, as instruções, associadas ao desvio, são definidas tanto para a condição
verdadeira quanto para a falsa (figura 4). Em português estruturado, os comandos,
para este tipo de estrutura, são se, então, senao e fimse.
Figura 4. Desvio condicional composto.
Utilizando, ainda, o exemplo de cálculo de média, perceba que, neste caso, uma
informação será impressa na tela caso a condição seja falsa.
» 1 algoritmo “desvio condicional composto”
2 // Função : cálculo de média do aluno
3 // Autor :
4 // Data :
27
6 var
7 nota1, nota2, media: real
8 inicio
11 leia (nota1)
13 leia (nota2)
15 escreval (“a média do aluno é: “, media)
17 escreval (“O aluno foi aprovado”)
18 senao
19 escreval (“O aluno foi reprovado”)
20 fimse
21 fimalgoritmo
Abaixo, segue a execução do programa caso a condição seja verdadeira.

10
a média do aluno é: 9
O aluno foi aprovado
28
E agora, caso a condição seja falsa. Perceba que, neste caso, há uma mensagem associada
a esse desvio condicional.
a média do aluno é: 4.5
O aluno foi reprovado
Desvio condicional sequencial
Neste caso, as tomadas de decisões (sejam simples ou compostas) ocorrem sucessivamente

(figuras 5 e 6). Nas condições sequenciais simples, são se, entao, fimse ....
se, entao, fimse; e, nas compostas, se, então, senão, fimse....
se, então, senão, fimse.... se.
Figura 5. Desvio condicional sequencial simples.
29
Figura 6. Desvio condicional sequencial composto.
Utilizando, ainda, o exemplo de cálculo de média de aluno, mas, neste caso, vamos
introduzir uma outra operação que será executada, a de cálculo de frequência do
aluno. Os algoritmos, abaixo, são exemplos de desvio condicional sequencial, simples
e composto, para a problemática acima.
1 algoritmo “desvio condicional sequencial simples”
2 // Função : cálculo de notas e frequências de alunos
3 // Autor :
4 // Data :
6 var
7 nota1, nota2, media, CH, faltas, frequencia: real
30
8 inicio
10 leia (nota1)
12 leia (nota2)
13 escreval (“Digite a carga horária da disciplina: “)
14 leia (CH)
16 escreval (“Digite a quantidade de faltas do aluno na

disciplina: “)
17 leia (faltas)
19 frequencia <- ((CH - faltas)/CH)*100
20 escreval (“a média do aluno foi: “, media)
21 escreval (“a frequencia do aluno foi: “, frequencia,

“%”)
22 //aqui a frequencia é calculada baseando-se na

seguinte expressão:
23 //frequência = ((carga horária - faltas)/carga

horária) * 100
24 //a frequência é expressa em %
26 escreval (“Aluno aprovado por média”)
27 fimse
28 se frequencia >= 75 entao
29 escreval (“Aluno aprovado por frequência”)
30 fimse
31 fimalgoritmo
Segue a execução do programa caso as duas condições sejam verdadeiras. Perceba que,
neste caso, a situação do aluno, em relação à nota e à frequência, é impressa na tela.
31
10
Digite a carga horária da disciplina:
40
Digite a quantidade de faltas do aluno na disciplina:
a média do aluno foi: 9
a frequência do aluno foi: 87.5%
Aluno aprovado por média
Aluno aprovado por frequência
Segue a execução do programa, caso apenas um das condições seja verdadeira. Perceba
que, neste caso, apenas uma mensagem é impressa na tela sobre a situação do aluno.
10
40
12
a média do aluno foi: 7.5
a frequência do aluno foi: 70%
Aluno aprovado por média
32
Abaixo, segue a execução do programa caso as duas condições sejam falsas. Perceba
que, neste caso, não é impressa nenhuma mensagem sobre a situação do aluno. Apenas
o cálculo da média e da frequência.
40
12
a frequencia do aluno foi: 70%
Desvio condicional encadeado
Aqui, os desvios condicionais simples (figura 7) ou compostos (figura 8) podem ser

utilizados um dentro de outro. Desta forma, uma condição dependerá de outra para
ser executada.
33
Figura 7. Desvio condicional encadeado simples.
Figura 8. Desvio condicional encadeado composto.
34
Continuaremos utilizando o mesmo exemplo de cálculo de nota e de frequência do

aluno para o programa dizer a situação em relação à aprovação ou à reprovação. O
algoritmo, abaixo, representa uma estrutura condicional encadeada simples.
2 // Função : cálculo de notas e frequências de alunos
3 // Autor :
4 // Data :
6 var
8 inicio CX
11 leia (nota1)
13 leia (nota2)
15 leia (CH)

disciplina: “)
17 leia (faltas)
21 escreval (“a frequência do aluno foi: “, frequencia,

“%”)
22 //aqui, a frequência é calculada baseando-se na


horária) * 100
35
27 escreval (“Aluno aprovado”)
28 fimse
29 fimse
30 fimalgoritmo
Neste caso, a situação do aluno só será informada apenas quando as duas condições
forem verdadeiras. Caso contrário, somente, será informada a média e a frequência.
40
Aluno aprovado
O algoritmo, abaixo, representa uma estrutura condicional encadeada composta.

2 // Função :
3 // Autor :
4 // Data :
6 var
36
8 inicio
11 leia (nota1)
13 leia (nota2)
15 leia (CH)

disciplina: “)
17 leia (faltas)
21 escreval (“a frequencia do aluno foi: “, frequencia,

“%”)
22 //aqui a frequencia é calculada baseando-se na


horária) * 100
27 escreval (“Aluno aprovado”)
28 senao
29 escreval (“Aluno aprovado por média, mas

reprovado por frequência”)
30 fimse
31 senao
32 escreval (“Aluno reprovado”)
37
33 fimse
34 fimalgoritmo
Segue a execução do programa, caso as duas condições sejam verdadeiras.

10
40
Aluno aprovado
Na estrutura condicional encadeada composta, diferente da simples, a situação do

aluno, também, será informada quando a condição 1 for verdadeira e a 2 for falsa.
Neste caso, a mensagem impressa será: “Aluno aprovado pormédia, mas reprovado
por frequência.”. Quando as duas condições forem falsas, a execução do programa será
da seguinte forma.
38
a frequencia do aluno foi: 33.3333333333333%
Aluno reprovado
Estruturas de repetição
São aquelas que permitem a execução de um trecho do algoritmo mais de uma vez. O
trecho repetido é chamado de loop ou de laço. Algo importante, dentro deste contexto,
é que as repetições devem sempre ser finitas. Se elas não forem bem implementadas,
pode-se criar loops infinitos.
Para... até... faça (for)
Neste tipo de repetição, o bloco de instrução é repetido por um número determinado

de vez. Este tipo de laço deve ser utilizado apenas quando se sabe quantas vezes o
código deve ser repetido. A quantidade de repetições é determinada pelo programador.
1 algoritmo “Exemplo6”
2 // Função : para.. até.... faça
3 // Autor :
4 // Data :
6 var
7 i: inteiro
8 inicio
10 para i de 1 ate 10 faca
11 escreval (“repetindo até 10”)
12 fimpara
13 fimalgoritmo
Segue a execução do laço de repetição do algoritmo acima.

Início da execução
repetindo até 10
repetindo até 10
repetindo até 10
repetindo até 10
repetindo até 10
repetindo até 10
39
repetindo até 10
repetindo até 10
repetindo até 10
repetindo até 10
Fim da execução.
T8. Enquanto... faça (While)
Nesta estrutura de repetição, antes de entrar no laço, uma condição é avaliada. A

repetição ocorre enquanto a condição for verdadeira.
2 // Função : repita enquanto condição for verdadeira
3 // Autor :
4 // Data :
6 var
7 A, B: inteiro
8 inicio
10 A <- 2
11 B <- 6
12 enquanto A < B faca
13 A <- A+3
14 B <- B+2
15 escreval (“A = “, A)
16 escreval (“B = “, B)
17 fimenquanto
18 fimalgoritmo
Execução da repetição.
A = 5
B = 8
A = 8
B = 10
A = 11
B = 12
A = 14
B = 14
40
T9. Repita... até (do... while)
Este tipo estrutura de repetição difere das anteriores pois o código é repetido enquanto
a condição for falsa. E, neste caso, a avaliação da expressão ocorre no fim do loop. Ela
pode ser utilizada nas condições em que se desconhece a quantidade de vezes em que
o código deve ser executado. O algoritmo, abaixo, exemplifica este tipo de estrutura.
2 // Função : repita até
3 // Autor :
4 // Data :
6 var
7 i: inteiro
8 inicio
10 i <- 10
11 repita
12 escreval (i)
13 i <- i + 2
14 ate i > 20
15 fimalgoritmo
Segue a tela de execução para a estrutura de repetição.

10
12
14
16
18
20
Funções e procedimentos (sub-rotinas)

As funções e os procedimentos são sub-rotinas ou sub-programas utilizados dentro
de um programa principal. São blocos de instruções que são executados quantas vezes
forem necessárias. Um programa pode ter quantas sub-rotinas forem necessárias. O
uso de sub-rotinas deixa os códigos mais organizados e mais fáceis de manutenção.
Diversas linguagens de programação já possuem diversas sub-rotinas já implementadas,
também, conhecidos como módulos. Uma sub-rotina, que retorna um valor, é conhecida
como função, já que aquela que não retorna é conhecida como procedimento.
41
Funções
As funções são projetadas para realizar tarefas específicas dentro do programa principal.
Sua estrutura é similar a um algoritmo, com o início, a seção de declarações de variáveis,
a seção de comandos e o fim. Depois de criada, a função pode ser chamada dentro do
programa principal (figura 9).
Figura 9. Estrutura das funções.
Uma das grandes vantagens de utilizar funções dentro do programa é não ter que
repetir códigos toda vez que um método deve ser aplicado, basta criar a função uma
única vez e chamá-la dentro do programa sempre que for necessário.
A sintaxe de uma função pode ser definida da seguinte forma.
O exemplo, abaixo, define a estrutura de um programa dentro do Visualg, o qual

contém uma função que cálcula o volume de um cilindro.
2 // Função : função
42
3 // Autor :
4 // Data :
5 //Seção da sub-rotina
6 funcao CalculoVolume:real
7 var
8 vol: real
9 inicio
10 pi <- 3,141515
11 vol <- pi * r^2 * h
12 retorne vol
13 fimfuncao
14
15 // Seção do programa
16 var
17 r, h, volume: real
18 inicio
19 escreval (“Digite o valor do raio do cilindro: “)
20 leia (r)
21 escreval (“Digite o valor da altura do cilindro: “)
22 leia (h)
23 // o volume recebe o resultado da função CalculoVolume
24 volume <- CalculoVolume
25 escreval (“O volume do cilindro é :”, volume)
26 fimalgoritmo
Execução do algoritmo.
Digite o valor do raio do cilindro:
2
Digite o valor da altura do cilindro:
3
O volume do cilindro é : 37.6991118430775
*** Feche esta janela para retornar ao Visualg..
Procedimentos
O funcionamento de um procedimento é muito semelhante ao de uma função. A

principal diferença é que um procedimento não retorna valor.
Observe como a sintaxe do procedimento é muito similar a de uma função.
43
Segue, abaixo, a estrutura de um programa dentro do Visualg, o qual contém um

procedimento que soma dois números.
2 // Função : procedimento
3 // Autor :
4 // Data :
6 var
7 n1, n2, resultado:inteiro
8 // Seção do Procedimento
9 procedimento soma
10 var res_soma: inteiro
11 inicio
12 res_soma<-n1+n2
13 resultado<-res_soma
14 fimprocedimento
15
16 // Seção do Programa
17 inicio
18 escreval (“escreva um número”)
19 leia(n1)
20 escreval (“escreva outro número”)
21 leia(n2)
22 soma
23 escreva(resultado)
24 fimalgoritmo
Execução do algoritmo.
escreva um número
2
escreva outro número
4
6
44
LINGUAGEM R E
PYTHON E SUAS IDES UNIDADE II
CAPÍTULO 1
IDEs para R e Python
O que são IDEs?

IDE (Integrated Development Environment) é um ambiente de desenvolvimento
integrado que auxilia o desenvolvimento de algumas aplicações. Basicamente, une
ferramentas necessárias para escrever e testar códigos em uma interface gráfica de
usuário (Graphical User Interface – GUI). A escolha de uma IDE depende muito da
linguagem a ser utilizada. De forma geral, as IDEs utilizam um editor de código-fonte,
um compilador e um debugger.
O editor é a funcionalidade básica da IDE, é uma ferramenta de texto que permite o

desenvolvedor digitar as instruções de acordo com a linguagem escolhida. O compilador
transforma o código-fonte em uma linguagem de baixo nível que possa ser compreendida
pela máquina. O debbuger realiza a depuração do código indicando os erros, o que
permite ao desenvolvedor testar e corrigir esses erros.
Existem diversas IDEs para Python e R (quadro 8) e a escolha depende das funcionalidades
que cada IDE oferece e de como elas podem tornar as rotinas de desenvolvimento mais
rápidas e ágeis. Ainda, a escolha depende do nível de aprendizado do desenvolvedor.
Existem IDEs para iniciantes e outras, as que exigem um conhecimento maior sobre
a linguagem.
As linguagens R e Python são as mais utilizadas quando se trata de coleta e de análise

de dados biológicos. Cada uma tem suas peculiaridades e podem ser utilizadas para
propósitos diferentes. A linguagem R é utilizada principalmente para a análise e a
visualização de dados. Tem uma história longa e uma comunidade forte. Possui milhares
de pacotes lançados, todos gratuitos, que aumentam a capacidade de análise. Quando
45
Unidade II | Linguagem R e Python e suas IDEs
as análises envolvem os cálculos estatísticos complexos, R é a indicada. Python é uma

linguagem de utilização bastante variada. Ela consegue realizar, praticamente, qualquer
tipo de tarefa, desde a coleta e a análise de dados até a construção de aplicações. Logo,
o contexto, aqui, não é dizer qual a melhor, mas, sim, mostrar que ambas as linguagens
serão utilizadas ao longo de uma tarefa que envolve a coleta e as análises de dados
biológicos. Cada uma executa instruções dentro de cada etapa do fluxograma de tarefas.
Quadro 8. Principais IDEs utilizadas para Python e R.
Python
IDE Plataforma Descrição
Netbeans Linux, macOS, Solaris e Gratuito e de código aberto utilizado para várias linguagens,
Windows. incluindo Python. Foi lançado em 2000 pela Apache Software
Foundation.
Pycharm Linux, macOS e Windows. Desenvolvido especificamente para Python. A versão community é
código aberto. Foi lançado em 2010 pela JetBrains.
Pyzo Linux, macOS e Windows. Ambiente específico para Python, projetado para iniciantes.
Thonny Linux, macOS e Windows. Ambiente específico para Python, projetado para iniciantes.
Spyder Linux, macOS e Windows. Ambiente específico para Python, lançado em 2009.
PyDev Eclipse. É um plugin utilizado dentro do Eclipse, lançado em 2009.
R
IDE Plataforma Descrição
RStudio Linux, macOS e Windows. Software livre lançado especificamente pela RStudio Inc em 2008.
Atom Linux, macOS e Windows. IDE utilizada para diversas linguagems de programação e permite
instalação de pacotes R.
Eclipse Linux, macOS e Windows. IDE utilizada para diversas linguagems de programação, o que
permite instalação de pacotes R.
Pyzo e RStudio
As IDEs Pyzo e RStudio são ambientes de computação gratuitos para a programação
em Python e R, respectivamente. São indicados para programadores iniciantes por
serem simples e interativos.
» Pyzo: é uma IDE Python com um design bastante prático. Consiste em um editor
de texto, um shell e diversas ferramentas que facilitam a codificação. Ele permite
várias maneiras de executar o código de forma bem interativa: diretamente no
shell, por meio de seleção de linhas específicas, por meio de um arquivo, por
meio de script etc.
46
Linguagem R e Python e suas IDEs | Unidade II
» RStudio: é um ambiente de desenvolvimento em R disponível em duas edições:

RStudio Desktop e RStudio Server. Consiste em um editor de script e um console
R, além de janelas de visualização de histórico, pacotes, gráficos etc.
As duas IDEs estão disponíveis para Windows, MacOS e Linux e são bastante úteis
para os desenvolvedores iniciantes.
47
CAPÍTULO 2
Programação em Python
Linguagem Python
A linguagem de programação Python surgiu na Holanda no final da década de 1980.
Foi criada por Guido van Rossum no Centro Winskunde & Informática (CWI). O
nome, ao contrário do que todos pensam, não tinha relação com serpente, e foi mais
uma brincadeira de Guido, que era um grande fã da série britânica, “Monty Python’s
Flying Circus”, em português, Os malucos do circo. A associação, com uma cobra, surgiu
depois da publicação do livro “Programming Python” pela editora O’Reilly; a qual,
como tradição, utilizava ilustração de animais na capa de seus livros. Desta forma, o
logotipo oficial da linguagem passou a ser duas pítons.
Python é uma linguagem de programação de alto nível que depende de um interpretador

para execução de scripts. É uma liguagem tipada orientada aos objetos, que organiza
o código em classes. A primeira versão de Python foi liberada em fevereiro de 1991
(versão 0.9.0). A versão 1.0 foi lançada em janeiro de 1994. Python versão 2.0 foi
lançada apenas em 2000. No momento, a versão mais atual é Python 3.9.0, lançada
em outubro de 2020.
Um dos principais motivos, pelos quais Python é uma ótima linguagem para
bioinformática, é o de sua capacidade de suportar arquivos de formto FASTA, GenBank,
Expasy, UniGene, ClustaIW etc. Além disso, são encontradas diversas bibliotecas
específicas para Python, o que facilita diversos tipos de análises de dados biológicos.
Instalando Python
Antes de utilizarmos o Python dentro de uma IDE, nós o utilizaremos sem uma GUI.
Para realizar a instalação de um terminal (console) Python, basta acessar o site: https://
www.python.org/downloads/. Neste primeiro momento, vamos trabalhar com alguns
códigos dentro de IDEs instaladas na máquina. Contudo, na última unidade, uma
alternativa será ensinada para trabalhar com os códigos sem necessitar de a realização
de instalações.
48
Figura 10. Site da Linguagem Python
Fonte: Python Software Foundation, 2001.
Baixe a versão mais atual de acordo com o sistema operacional da sua máquina. Abra
o arquivo executável e siga o passo a passo da instalação. Ao abrir o Python, perceberá
que não há interface gráfica, apenas tela preta com um prompt que lembra muito o
ms-dos.
Operadores, expressões e variáveis

Uma das grandes vantagens de Python é a não necessidade de declarar variáveis. Em
relação aos tipos de dados utilizados, temos os mesmos tipos estudados na linguagem
estruturada, com algumas variações. Abra o terminal de Python e comece utilizando-o
como uma calculadora para realizar as operações matemáticas básicas.
# soma
>>>6+4
10
# subtração
>>>6-2
4
# multiplicação
>>>6*3
18
# divisão
>>>6/2
49
# exponencial
>>>6**2
36
# operação aritmética com definição de prioridades pelo uso

de parênteses
>>>(30+(8-2)/2)*3
99.0
# div
>>>25//3
8
# mod
>>>25%3
1
Para as expressões booleanas, vamos utilizar alguns operadores de comparação (<, >,
==, != etc...).
# verifica de 4 é menor que 5
>>>4<5
True
# verifica de 4 é maior que 5
>>>4>5
False
# verifica de 4 é igual a 4
>>>4==4
True
# verifica de 4 é diferente de 4
>>>4!=4
False
# verifica de 4 é menor ou igual a 5
>>>4<=5
True
# verifica de 4 é maior ou igual a 5
>>>4>=5
50
False
# retorna o resultado contrário após verificar se 4 é menor

ou igual a 5
>>>not (4>=5)
True
Em relação à declaração de variáveis, aqui, não há necessidade e você pode realizar as

atribuições de nomes a valores diretamente. As regras de nomes de variáveis são as
mesmas da linguagem estruturada.
# criação da variável x e atribuição de valor numérico
>>>x=5
# criação da variável y e atribuição de valor numérico
>>>y=2
# multiplicação de x e y
>>>x*y
10
# criação da variável z e atribuição de valor numérico
>>>z=3
# criação da variável k e atribuição de valor numérico

>>>k=-2
# operação aritmética
>>>x+(z**k)/y
5.0555555555555
# criação da variável l e atribuição de valor por meio de

operação aritmética
>>>l=z-k
# imprime na tela valor atribuído a variável ‘l’
>>>print (‘a subtração de z e k é igual a: ‘, l)
a subtração de z e k é igual a: 5
Podemos, ainda, utilizar as strings (str) para receber sequências de caracteres. Neste
caso, devemos utilizar os valores entre apóstrofo (´´).
# criação da string seq1 e atribuição de valor
>>>seq1 = ‘GCCGTT’
# verifica valor atribuído a seq1
51
>>>seq1
‘GCCGTT’
# criação da string seq2 e atribuição de valor
>>>seq2 = ‘GGCGTA’
# verifica valor atribuído a seq2
>>>seq2
‘GGCGTA’
Podemos, ainda, utilizar diversos operadores de strings.

# verifica se seq1 é igual a seq2
>>>seq1 == seq2
False
# verifica se seq1 é diferente de seq2
>>>seq1!=seq2
True
# mostra a primeira letra de seq1 (operador de indexação)
>>>seq1[0]
‘G’
# mostra a segunda letra de seq1 (operador de indexação)
>>>seq1[1]
‘C’
# verifica se a segunda letra de seq1 é igual a segunda

letra de seq2
>>>seq1[1]==seq2[1]
False
# verifica se ‘CC’ é uma substring da string seq1
>>>’CC’ in seq1
True
# verifica se ‘CC’ é uma substring da string seq2

>>>’CC’ in seq2
False
# concatenação de seq1 e seq2
>>> seq1+seq2
‘GCCGTTGGCGTA’
# repete seq1 cinco vezes
>>>seq1*5
52
‘GCCGTTGCCGTTGCCGTTGCCGTTGCCGTT’
# determina o comprimento da string seq1
>>>len(seq1)
6
# determina o comprimento da concatenação de seq1 e seq2
>>>len(seq1+seq2)
12
# determina o tamanho da string seq1 repetida cinco vezes
>>>len(seq1*5)
30
Listas
Quando trabalhamos com análise de dados, na maioria das situações, esses dados estão
organizados em listas. Uma lista é, basicamente, uma sequência de tipos diferentes de
objetos (exemplos: números e strings). A seguir, estão demonstrados alguns exemplos
de atribuições de variáveis a listas.
# cria lista ‘sequencias’ e atribui valores
>>> sequencias = [‘GCG’, ‘ATT’, ‘AAC’, ‘TTA’]
# cria lista ‘aminoacidos e atribui valores
>>> aminoacidos = [‘ALA’, ‘ISO’, ‘ASN’, ‘LEU’]
# concatenação dos valores das duas listas
>>> sequencias+aminoácidos
[‘GCG’, ‘ATT’, ‘AAC’, ‘TTA’, ‘ALA’, ‘ISO’, ‘ASN’, ‘LEU’]
# mostra quantas vezes ‘AAC’ aparece na lista
>>> sequencias.count(‘AAC’)
1
# inverte a ordem dos valores da lista
>>> sequencias.reverse()
>>> sequencias
[‘TTA’, ‘AAC’, ‘ATT’, ‘GCG’]
# mostra o tamanho da lista
>>>len(sequencias)
4
Quando uma lista envolve valores numéricos, pode-se realizar operações e funções.
# cria lista “lst1” e atribui valores
53
>>> lst1=[28, 36, 2, 4, 8, 123]

>>> lst1
[28, 36, 2, 4, 8, 123]
# cria lista “lst2” e atribui valores
>>> lst2=[21, 4, 52, 8, 3, 50, 12]

>>> lst2
[21, 4, 52, 8, 3, 50, 12]
# concatenação dos valores das duas listas
>>> lst1+lst2
[28, 36, 2, 4, 8, 123, 21, 4, 52, 8, 3, 50, 12]
# mostra o menor valor da lst1
>>> min(lst1)
2
# mostra o maior valor da lst1

>>> max(lst2)
52
soma todos os valores da lst1
>>> sum(lst1)
201
# soma todos os valores da lst1 e lst2

>>> sum(lst1+lst2)
351
Os valores das listas podem ser modificados, removidos ou inseridos.

# altera o valor na segunda posição
>>>sequencias[1]=’aac’
>>>sequencias
[‘GCG’, ‘aac’, ‘AAC’, ‘TTA’]
# .append() insere um novo valor a lista de sequências
>>> sequencias.append(‘GGA’)
>>> sequencias
[‘GCG’, ‘aac’, ‘AAC’, ‘TTA’, ‘GGA’]
# .insert() insere um novo valor em um posição definida na

lista
>>>sequencias.insert(0, ‘AGT’)
>>> sequencias
[‘AGT’, ‘GCG’, ‘aac’, ‘AAC’, ‘TTA’, ‘GGA’]
# .remove() remove valores específicos da lista
54
>>> sequencias.remove(‘AGT’)
>>>sequencias
[‘GCG’, ‘aac’, ‘AAC’, ‘TTA’, ‘GGA’]
# .sort() classifica a lista
>>>sequencias.sort()
[‘AAC’, ‘GCG’, ‘GGA’, ‘TTA’, ‘aac’]
# .pop() remove o último valor da lista
>>> sequencias.pop()
‘aac’
>>> sequencias
[‘AAC’, ‘GCG’, ‘GGA’, ‘TTA’]
# .index() mostra a posição (índice) da ocorrência do item dentro
da lista
>>> sequencias.index(‘GGA’)
Módulos, pacotes e bibliotecas

Segundo Mariano et al. (2016), módulos são arquivos contendo as funções e as classes
que podem ser importados para o Python utilizando a instrução import. Pacotes são
pastas utilizadas pelo interpretador para organizar módulos, de forma hierárquica, e
bibliotecas que contêm conjuntos de módulos e pacotes. Python já possui uma série de
bibliotecas padrões instaladas, contudo é possível instalar uma variedade de bibliotecas
de terceiros. Veja, abaixo, como carregar módulos e instalar pacotes dentro do Python.
Se tentarmos executar uma função que está dentro de um módulo antes de importá-lo,
o programa mostrará uma mensagem de erro.
# ao tentar imprimir a raiz quadrada de 25 sem importar o
módulo, aparece mensagem de erro
>>> print(sqrt(25))
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
NameError: name ‘sqrt’ is not defined
Agora, se antes de executarmos o comando, importarmos o módulo math (onde a

função sqrt se encontra), python conseguirá retornar um valor.
# importa o módulo math com todas suas funções
>>> import math
55
# verifica se o módulo math foi importado
>>> math
<module ‘math’ (built-in)>
# imprime na tela a raiz quadrada de 25
>>> print(math.sqrt(25))
5.0
Se quiser listar todos os pacotes disponíveis no python ou as funções disponíveis para

cada módulo, basta dar os comandos abaixo.
# lista todos os pacotes disponíveis para importação
>>> help(‘modules’)
# lista todas as funções dentro do módulo math
>>> help(‘math’)
Instalando IDE para Python

A partir de agora, vamos trabalhar com bibliotecas mais direcionadas às análises de
bioinformática. Dentro deste contexto, o Biopython é umas das mais utilizadas para
a manipulação de dados biológicos.
Biopython é uma biblioteca que contém uma coleção de classes, de módulos e de

pacotes, a qual permite:
» análises de sequências.
» alinhamentos de sequências.
» análises de estruturas de proteínas.
» análises de genética de populações.
» entre outras.
Neste ponto, iremos utilizar uma IDE para Python. Lembre-se de que existe uma
variedade de IDE’s, das mais simples até as de maiores complexidades. A IDE, a ser
utilizada, aqui, é o Pyzo, uma alternativa gratuita, interativa e simples. Segue a lista
de tudo que deve ser instalado para a utilização da biblioteca Biopython.
» Instalação do Python
Caso não tenha instalado ainda, siga o passo a passo do tópico 2.
56
» Instalando Pyzo
Abra o endereço (https://pyzo.org/start.html) e instale Pyzo de acordo com o seu

sistema operacional. Siga a instalação até o final.
Figura 11. Site da IDE Pyzo
Fonte: The Pyzo, 2015.
» Instalando Biopyhton
Antes de instalar o pacote Biopython, deve-se atualizar o gerenciador de pacotes do

Python, conhecido como pip. Para isto, abra o pyzo e siga as instruções abaixo.
Dentro do componente shell do Pyzo, execute o seguinte comando.

>>> pip install –-upgrade pip
Para poder realizar a instalação do Biopyhton, alguns módulos precisam ser instalados
antes, tais como numpy e reportlab. Execute os comandos abaixo para instalá-los.
>>> pip install numpy
>>> pip install reportlab
Agora, é possível realizar a instalação do biopython.

>>> pip install biopython
57
Utilizando Pyzo e Biophyton

Ao abrir o Pyzo, perceberá que tem uma interface bem simples. Você consegue
executar os comandos diretamente no shell, ou pode escrever o códon no editor e
depois executá-lo.
Figura 12. Componentes do Pyzo
Vamos realizar algumas manipulações bem simples utilizando Pyzo e a biblioteca

Biopython, direto no shell. Observação: não codifique os comentários precedido por
#, apenas os códigos.
» Função transcribe() e complement()
A função transcribe() consegue transcrever uma sequência de DNA em uma sequência

de RNA. Já a função complement() retorna com a sequência de DNA complementar.
# importação do modulo Seq da biblioteca Bio (biophyton)
>>>from Bio.Seq import Seq
# criação do objeto DNA_1 e atribuição de valor pela

função Seq()
>>> DNA_1 = Seq(“ATGAAAGCCGAACGCTATTCCGCATAA”)
# verificação do valor atribuído a DNA_1
DNA_1
58
Seq(‘ATGAAAGCCGAACGCTATTCCGCATAA’)
# criação do objeto RNA_1 e atribuição de valor a partir

da transcrição de DNA_1 pela função transcribe()
>>> RNA_1 = DNA_1.transcribe()
RNA_1
# verificação do valor atribuído a RNA_1
Seq(‘AUGAAAGCCGAACGCUAUUCCGCAUAA’)
# criação do objeto DNA_1_complemento e atribuição de

valor a partir da sequência complementar de DNA_1 pela
função complement()
DNA_1_complemento = DNA_1.complement()
# verificação do valor atribuído
DNA_1_complemento
# Seq(‘TACTTTCGGCTTGCGATAAGGCGTATT’)
» Função translate()
# importação do modulo Seq dentro da biblioteca Bio

(biophyton)
# criação do objeto RNA_1 e atribuição de valor pela

função Seq()
>>> RNA_1 = Seq(“AUGAAAGCCGAACGCUAUUCCGCAUAA”)
# verificação do valor atribuído a RNA_1
>>> RNA_1
Seq(‘AUGAAAGCCGAACGCUAUUCCGCAUAA’)
# criação do objeto AA_RNA_1 e atribuição de valor a

partir da transcrição de DNA_1 pela função translate()
>>> AA_RNA1 = RNA_1.translate()
# verificação do valor atribuído a AA_RNA_1
>>> AA_RNA1
Seq(‘MKAERYSA*’)
» Concatenando sequências
59
É possível unir (concaternar) sequências no Python, simplesmente utilizando o operador

+ como mostrado a seguir.
# importação do modulo Seq dentro da biblioteca Bio
(biophyton)

função Seq()
>>> DNA_1 = Seq(“ATGAAAGCCGAACGCTATTCCGCATAA”)

função Seq()
>>> DNA_2 = Seq(“TGGCATTCCAAGCGTAAATCGAACGAC”)

concatenação de DNA_1 e DNA_2
>>> DNA_3 = DNA_1 + DNA_2
# verificação do valor atribuído a DNA_3
>>> DNA_3
Seq(‘ATGAAAGCCGAACGCTATTCCGCATAATGGCATTCCAAGCGTAAATCGAACGAC’)
Observação: para saber mais sobre métodos do módulo Seq, basta digitar: help
(Seq) diretamente no shell. Após executar o comando, serão listados todos os métodos
que podem ser utilizados importando o módulo Seq.
» Abrindo e analisando arquivos
Crie uma pasta dentro de C:\ e nomeie como scripts. Agora, crie um arquivo dentro
desta pasta utilizando um editor de texto para códigos (exemplo: Geany, disponível
em: https://www.geany.org/), com as sequências abaixo, e salve como multiseq.fasta.
Observação: sequências FASTA devem ter um cabeçalho identificado com ‘>’.

>seq1
CAATACCAAGGAATTTTTTTGGGCAATTGTATGAGGGAAATGAAGCTGGAGATATTGGTT
>seq2
CAACACCAAGCAATTTTTTTGGGCAATTGAATGAGGGAATTGAAGCTGGAGATATTGGTT
>seq3
CAATAGCAAGCAATTTTTTTGGGCAATAGAATGAGGGAAATGAAGCTGGAGATCTTGGTT
60
>seq4
CAATACCAAGCAATTATTCTGGGCAATTGAATGAGGTAAATGAAGCTGGAGATATTGGTT
Agora, realize o alinhamento das sequências diretamente no shell de Pyzo a partir das
seguintes instruções.
# importa o modulo AlignIO que realiza alinhamentos
>>>from Bio import AlignIO
# objeto alinhamento recebe o resultado da função AlignIO.

read depois na análise do arquivo multiseq.fata (deve-se
identificar o caminho do arquivo no computador)
>>>alinhamento = AlignIO.read(“C:\scripts\multiseq.fasta”,
“fasta”)
>>>print (alinhamento)
CAATACCAAGGAATTTTTTTGGGCAATTGTATGAGGGAAATGAA...GTT seq1
CAACACCAAGCAATTTTTTTGGGCAATTGAATGAGGGAATTGAA...GTT seq2
CAATAGCAAGCAATTTTTTTGGGCAATAGAATGAGGGAAATGAA...GTT seq3
CAATACCAAGCAATTATTCTGGGCAATTGAATGAGGTAAATGAA...GTT seq4
Observação: para saber mais sobre métodos do módulo AlignIO, basta digitar: help
(AlignIO) diretamente no shell.
» Sub-pacotes do Biopython
O biopython possui inúmeros sub-pacotes (contendo seus diversos módulos) que

são bastante úteis para solucionar diversos problemas em bioinformática. Todos os
subpacotes estão listados no seguinte endereço: https://biopython.org/docs/1.74/api/
Bio.html#subpackages. Para compreender as aplicações básicas de cada sub-pacote ou
de seus módulos, basta acessar o tutorial do biopython pelo seguinte endereço: http://
biopython.org/DIST/docs/tutorial/Tutorial.pdf. Ainda, de modo alternativo, pode-
se buscar as informações de como utilizá-los diretamente no shell, como no exemplo
abaixo.
61
Figura 13. Tela do Pyzo com o resultado do comando help
62
CAPÍTULO 3
Linguagem R
Linguagem R
R é uma linguagem de programação utilizada para manipulação e análise de dados
estatísticos. Fornece um conjunto de pacotes e bibliotecas muito mais amplo do que
Python (mais de 5.000) e é capaz de executar análises estatísticas bem complexas. A
linguagem foi derivada da linguagem S e desenvolvida por Robert Gentleman e Ross
Ihaka, em 1991, na Nova Zelândia, embora sua distribuição tenha iniciado em 1993
pela StatLib.
Por ser gratuito, R, rapidamente, tornou-se uma linguagem bastante popular entre
os estatísticos e os engenheiros. Porém, sua utilização se tornou muito mais ampla,
envolvendo as áreas médicas, biomédicas e biológicas. Sua popularidade se deve,
principalmente, ao fato de R conseguir processar e analisar grandes volumes de dados
e integrar com outas linguagens, tais como Java, SQL e Python. Além de ser gratuito,
R possui uma comunidade forte, formada por desenvolvedores do mundo todo que
contribuem com criações de diversos pacotes, o que torna a linguagem mais poderosa,
ainda, para a manipulação de dados.
A linguagem R possui uma rede de arquivos conhecida como CRAN (Comprehensive

R Archive Network), a qual serve como uma rede para armazenar versões idênticas e
atualizadas de código e documentação R. Também, é utilizado como um repositório
de pacotes R.
Instalando R e RStudio
Para realizar a instalação do R, basta baixar a versão mais recente dentro do repositório
do CRAN no site (https://cran.r-project.org/), de acordo com seu sistema operacional.
Após baixar o programa, siga o passo a passo para instalação. Esse programa é o R
“puro”, que tem disponível apenas o console para realizar as codificações.
63
Figura 14. Site da Linguagem R
Fonte: Cran, 2010.
Depois de instalar o R, é necessário instalar uma IDE para facilitar a codificação. O

RStudio será a recomendada aqui. Esse programa é um ambiente. Para baixar, acesse
o site (https://rstudio.com/products/rstudio/download/) e baixa a versão gratuita
(edição de código aberto), de acordo com seu sistema operacional. Siga o passo a passo
da instalação. É importante baixar e instalar a linguagem R primeiro, para o RStudio
funcionar corretamente.
Figura 15. Site do R Studio
Fonte: PBC, 2021.
64
Abrindo o RStudio
Ao abrir o RStudio, é possível observar que ele é formado por janelas.
» Janela de Scripts: onde serão escritos os códigos antes do executá-los. Para

criar novos scripts, basta acessar: File > New File > R Script. Uma nova guia
será adicionada na janela de scripts. Para salvar um script, basta acessar: File
> Save ou, alternativamente, pressionar CTRL+S. Para executar o script no
console, basta pressionar o RUN na janela do script ou CTRL+Enter. Se você
quiser testar uma linha de código do script, basta selecioná-la e executá-la.
» Janela do Console: é o local onde o script será executado. É possível executar

os códigos diretamente no console.
» Janela de Ambiente e Histórico: mostra todos os elementos que foram

criados utilizando o código (na guia Environment) e o histórico de todos os
códigos executados (History).
» Janela de Arquivos, gráficos e pacotes: esta janela é formada pela guia de

arquivos (File), pela guia de gráficos (plots), pela guia de pacotes (package),
pela guia de ajuda (help) e pela guia do visualizador (viewer). Na guia de
pacotes, é possível visualizar todos os pacotes instalados e carregados.
Figura 16. Tela do RStudio
65
Instalando e carregando pacotes no R Studio

Assim, como em Python, para se utilizar métodos e funções para análises específicas,
é necessário realizar a instalação de pacotes e carregá-los. O R já contém diversas
bibliotecas e pacotes que fazem parte da instalação básica. As outras são necessárias
serem instaladas conforme a necessidade. Existem mais de 5 mil pacotes disponíveis
para utilização em R. Para instalar pacotes, basta digitar o comando install.
packages() e, para removê-los, basta digitar remove.packages() diretamente
no console, como exemplificado abaixo. Dependendo do tamanho do pacote, o processo
pode demorar mais tempo.
> install.packages(“Rcmdr”)
> remove.packages(“Rcmdr”)
Outra forma de instalar e desistalar um pacote é abrindo a guia Pacotes (Packages) e

pressionar Install. Uma janela abrirá e, assim, basta, apenas, buscar o pacote e instalá-lo.
Para removê-lo, basta procurá-lo na guia de Pacotes e pressionar o ícone ao lado do
seu nome. Uma vantagem de instalar o programa pela guia pacote é a da possibilidade
de instalar os pacotes requeridos para o pacote que deve ser instalado automaticamente.
Para carregar o pacote, basta digitar library() no console, como exemplificado abaixo.
> library(“Rcmdr”)
Utilizando RStudio
Criando Vetores
As variáveis dentro de R são conhecidas como vetores e eles podem armazenar qualquer
tipo de valores. Para criar um vetor e atribuir valores, basta utilizar a seguinte sintaxe
nome_do_vetor <-c(valor, valor, valor, n…). Lembre-se de que,
se for um valor do tipo string, é necessário colocar entre aspas. Se o vetor possuir mais
de um valor, é necessário colocar o “c”, logo após, o símbolo de atribuição <-. Desta
forma, os valores serão armazenados em colunas.
Vamos criar alguns vetores para realizar análises posteriores, conforme as informações
contidas na tabela a seguir.
66
Tabela 9. Informações para criação de vetores
GeneA GeneB GeneC GeneD
Nivel_exp1 1.2 3.4 5.2 4.7
Nivel_exp2 3.4 2.2 1.3 2.0
Nivel_exp3 1.0 4.0 2.8 3.5
Nivel_exp4 2.8 6.2 3.8 2.2
Nivel_exp5 1.8 4.3 1.6 2.7
Crie os vetores utilizando as linhas de comandos a seguir, as quais devem ser executadas
diretamente no prompt do console.
# para criar vetor contendo valores de string, deve-se utilizar
os valores entre aspas.
> nome_gene<-c(‘GeneA’, ‘GeneB’, ‘GeneC’, ‘GeneD’)
> nivel_exp1<-c(1.2, 3.4, 5.2, 4.7)
> nivel_exp2<-c(3.4, 2.2, 1.3, 2.0)
> nivel_exp3<-c(1.0, 4.0, 2.8, 3.5)
> nivel_exp4<-c(2.8, 6.2, 3.8, 2.2)
> nivel_exp5<-c(1.8, 4.3, 1.6, 2.7)
Para imprimir ou visualizar os valores armazenados em cada vetor criado, deve-se,

apenas, escrever seu nome no prompt de comando; não há necessidade de usar o
comando print.
> nome_gene
[1] “GeneA” “GeneB” “GeneC” “GeneD”
> nivel_exp1
[1] 1.2 3.4 5.2 4.7
> nivel_exp2
[1] 3.4 2.2 1.3 2.0
> nivel_exp3
[1] 1.0 4.0 2.8 3.5
> nivel_exp4
[1] 2.8 6.2 3.8 2.2
> nivel_exp5
[1] 1.8 4.3 1.6 2.7
67
Para saber mais a respeito de vetores, digite o código help(“vector”) diretamente

no console.
Criando fatores
Diferente dos vetores, os fatores são usados para representar variáveis categóricas,
tal como positivo ou negativo, feminino ou masculino, reagente ou não reagente,
baixo, médio ou alto. Esses objetos são criados por meio da função fator(). Os valores,
armazenados dentro de um fator, são chamados de levels (níveis).
> resultado <- factor(c(“positivo”, “negativo”, “indetermina-
do”))
Visualização dos valores do fator criado.

> resultado
[1] positivo negativo indeterminado
Levels: indeterminado negativo positivo
Para saber mais a respeito de fatores, digite o código help(“factor”) diretamente

no console.
Criando Listas
As listas são coleções de elementos que podem ser criadas utilizando a função list().
Esses elementos não precisam ser da mesma classe, logo, uma lista poderá conter
vetores ou outras listas. Abaixo, seguem alguns exemplos de como criar listas.
> nomes_de_genes <-list(“CTLA4”, “CD4”, “IL2RA”, “CD80”, “GITR”)
Logo mais, visualização da lista criada.

> nomes_de_genes
[[1]]
[1] “CTLA4”
[[2]]
[1] “CD4”
[[3]]
[1] “IL2RA”
[[4]]
[1] “CD80”
[[5]]
[1] “GITR”
68
Para saber mais a respeito de lista, digite o código help(“list”) diretamente no

console.
Criando Dataframes
Os data frames podem ser utilizados como banco de dados, já que são úteis para armazenar
valor organizados em tabelas contendo linhas e colunas. Cada coluna representa uma
variável e cada linha armazena as observações dessas variáveis. O data frame por conter
n variáveis de diferentes classes. Existem várias formas de criar data frames em R.
» Criando data frame a partir de vetores
Vamos utilizar os vetores que foram criados anteriormente e juntá-los em um único

objeto, o qual iremos nomear como genes, utilizando a função cbind().
genes<-cbind(nome_gene, nivel_exp1, nivel_exp2, nivel_exp3, ni-
vel_exp4, nivel_exp5)
Após a junção, o resultado será igual ao mostrado a seguir.

> genes
nome_gene nivel_exp1 nivel_exp2 nivel_exp3 nivel_exp4
[1,] “GeneA” “1.2” “3.4” “1” “2.8”
[2,] “GeneB” “3.4” “2.2” “4” “6.2”
[3,] “GeneC” “5.2” “1.3” “2.8” “3.8”
[4,] “GeneD” “4.7” “2” “3.5” “2.2”
nivel_exp5
[1,] “1.8”
[2,] “4.3”
[3,] “1.6”
[4,] “2.7”
Depois de juntar os elementos dos dois vetores em linhas e em colunas, basta convertê-
los em um data frame, utilizando a função as.data.frame().
> nivel_expressao<-as.data.frame(genes)
Visualização do data frame.

nome_gene
nivel_exp1 nivel_exp2 nivel_exp3 ni-
vel_exp4
1 GeneA 1.2 3.4 1 2.8
2 GeneB 3.4 2.2 4
6.2
3 GeneC 5.2 1.3 8.2
3.8
4 GeneD 4.7 2 5.3
69
2.2
nivel_exp5
1 1.8
2 4.3
2 1.6
4 2.7
» Criando data frame pela função data.frame()
Utilizando as mesmas variáveis do exemplo anterior, vamos criar o data frame diretamente
pela função data.frame(), sem a necessidade de criar os vetores previamente.
> data.frame(nome_gene=c(“Gene A”, “Gene B”, “Gene C”,
“Gene D”), nível_exp1=c(1.2, 3.4, 5.2, 4.7), nível_
exp2=c(3.4, 2.2, 1.3, 2), nível_exp3=c(1, 4, 2.8, 3.5),
nivel_exp4=c(2.8, 6.2, 3.8, 2.2))
Visualização do data frame.

nome_gene
nivel_exp1 nivel_exp2 nivel_exp3 ni-
vel_exp4
1 GeneA 1.2 3.4 1 2.8
2 GeneB 3.4 2.2 4
6.2
3 GeneC 5.2 1.3 8.2
3.8
4 GeneD 4.7 2 5.3
2.2
nivel_exp5
1 1.8
2 4.3
3 1.6
70
USO DE BANCO DE
DADOS UNIDADE III
CAPÍTULO 1
O que são banco de dados
Histórico
A produção de conhecimento ou de informações sempre expressa a mesma preocupação:
“como guardá-las?” e “como acessá-las?”. As informações são armazenadas desde os
primórdios da humanidade e, desde as épocas mais primitivas, essas informações
eram armazenadas e catalogadas para facilitar, de alguma forma, o seu acesso. Até
algumas décadas atrás, antes da invenção do primeiro computador, as informações
eram armazenadas em livros, o que necessitava de espaços físicos gigantes e sistemas
de catalogação bem complexos para conseguir acessar a informação. Com o surgimento
dos primeiros computadores e com a evolução da tecnologia, esse armazenamento se
tornou mais fácil. Contudo, com o advento da internet, a quantidade de informações
geradas se tornou assustadora. Desta forma, o desenvolvimento de sistema de banco
de dados é vital para o armazenamento e a utilização dessas informações.
O primeiro sistema de Banco de Dados (BD) surgiu na década da IBM, depois de

extensas pesquisas para a automação de escritório. Naquela época, percebeu-se que
a contratação de empregados, para armazenar e organizar arquivos, era bem custoso.
Desta forma, a IBM investiu bastante para conseguir um método mais barato. Dessas
pesquisas, surgiu o primeiro sistema de BD, conhecido como IMS (Information
Management System), ainda, na década de 1960, pela própria IBM. Contudo, o IMS
trouxe problemas diversos na implementação, com redundâncias, inconsistências,
insegurança e dificuldade de acesso.
Na década de 1970, o pesquisador da IBM, Ted Codd, publicou o primeiro artigo sobre
banco de dados relacionais, o qual visava resolver os problemas que o IMS trouxeram. O
que Codd pretendeu ao desenvolver esse tipo de banco de dados era que o usuário fosse
71
Unidade III | Uso de banco de dados
capaz de acessar as informações contidas em tabelas, por meio de comandos. Embora

a aplicação prática disso não tenha sido tão simples, isso levou a IBM a desenvolver
um sistema de banco de dados relacional, conhecido como Sistema R (R System), o
qual utilizava uma linguagem chamada de Linguagem de Consulta Estrutura SQL
(Structured Query Language). Outros modelos de BD surgiram a partir daí, tais como o
modelo Entidade-Relacionamento (ER), proposto por Peter Chen, o que trouxe novas
percepções nos conceitos de modelos de dados.
Apenas na década 1980, surgiu o primeiro sistema de BD comercial da Oracle,

desenvolvido baseado na linguagem SQL. Com isso, os BD começaram a sofrer
modificações conceituais, surgindo diversos outros modelos. Ainda, na década de 1980,
os primeiros conceitos de bancos de dados, orientados aos objetos, foram implementados,
o que expandiu, assim, as possibilidades de armazenamento e de consultas.
Na década de 1990, surgiram os primeiros Sistemas de Gerenciadores de Bancos de

Dados (SGDB). Com eles, novas classes de aplicações (mineração de dados, vídeo
sob-demanda, hipermídia e multimídias etc.) e novas abordagens, tais como sistemas
para tratar dados oriundos de vários websites, “armazéns” de dados (Data Warehouse),
entre outros. Atualmente, os bancos de dados são a essência de muitas empresas e,
dentro deste cenário, encontramos os maiores bancos de dados do mundo, tais como
o do Google e das redes sociais.
Conceitos básicos de banco de dados

Uma entidade (entity) de um banco de dados é um objeto do mundo real que difere
dos outros e possui um conjunto de atributos. Já os atributos são as características da
entidade. A imagem, abaixo, representa esses elementos básicos de um banco de dados.
72
Uso de banco de dados | Unidade III
Figura 17. Elementos de banco de dados relacionais.
Em banco de dados, um relacionamento é uma associação entre duas ou mais entidades.

Na ilustração acima, a entidade aluno tem um relacionamento com a entidade curso
pelo atributo ID_Curso.
Desenvolvimento de um banco de dados

A criação de um banco de dados não é um processo trivial e envolve diversas etapas.
A primeira etapa é a da análise de requisitos, a qual tem como objetivo definir as
necessidades do banco de dados. A segunda etapa é a modelagem dos dados que ocorrem
em três níveis de abstração: conceitual, lógico e físico.
Análise de requisitos
Nesta etapa, são definidos os requisitos dos dados: a descrição da informação dos
elementos dos dados; a definição dos relacionamentos entre os dados; a definição
das restrições que devem ser impostas ao acessar os dados; e a definição de softwares,
linguagem de programação, hardware etc.
Modelagem dos dados
Esta etapa é essencial para a criação do banco de dados. Neste modelo, é criada uma
representação de fácil compreensão que define como os dados serão armazenados,
classificados, acessados e manipulados. Existem duas formas de realizar a modelagem
de dados. A primeira é por meio de a Linguagem de Modelagem Unificada (Unified
73
Modeling Language- UML), uma coleção de ferramentas que facilita a modelagem de

dados e de documentação de sistemas.
A segunda forma ocorre por meio de o modelo Entidade-Relacionamento (ER),

que se baseia na representação das diferentes entidades e nos seus relacionamentos
por meio de fluxogramas (SILVA et al., 2020). A modelagem dos dados é realizada
em três níveis de abstração: modelo conceitual (nível mais simples), modelo lógico e
modelo físico (nível mais complexo).
O modelo conceitual define as entidades e as relações existentes entre elas, sem

definir seus atributos. O modelo conceitual, normalmente, é construído na forma de
um diagrama de ER. A figura, abaixo, representa um exemplo de modelo conceitual
construído como fluxogramas de ER.
Figura 18. Exemplo de modelo conceitual.
No modelo lógico (figura 19) é construído com base no modelo conceitual. Nesta
etapa, são descritos, com mais detalhes, os dados que devem ser armazenados, todas
as entidades e suas relações e seus atributos. Além disso, é definido como o banco de
dados será implementado no SGBD.
Figura 19. Exemplo de modelo lógico.
No modelo físico, são criadas todas as tabelas do banco de dados, baseando-se no

modelo lógico. A figura, abaixo, representa um exemplo deste modelo.
74
Figura 20. Exemplo de modelo físico.
T6. Sistema de Gerenciamento de Banco de Dados

(SGBD)
Segundo Ramakrishnam e Gehrke (2011), Banco de Dados (BD) é uma coleção de

dados que descreve as atividades de uma ou mais organizações relacionadas. E um
Sistema de Gerenciamento de Bancos de Dados (SGBD) é um software projetado para
auxiliar a manutenção e a utilização de vastos conjuntos de dados.
Um SGBD é um sistema formado por coleções de dados inter-relacionados e um

conjunto de programas capazes de acessar esses dados. O objetivo principal do SGDB
é gerar um ambiente eficiente para que os usuários consigam armazenar e acessar as
informações. Além de ser capaz de armazenar grandes massas de dados, o SGDB deve
fornecer segurança das informações armazenadas para impedir acessos indevidos. A
imagem, abaixo, representa o funcionamento de um SGDB.
75
Figura 21. Funcionamento de um SGDB.
O SGDB deve fornecer aos usuários uma visão mais abstrata dos dados, ocultando detalhes
de como os dados são armazenados, já que estes não são treinados em computação.
Desta forma, os desenvolvedores ocultam a complexidade da estrutura do sistema sob
diversos níveis de abstração.
As principais vantagens, em usar um SGBD para gerenciar os dados, são: a independência

dos dados, o acesso eficiente aos dados por meio de técnicas sofisticadas, a integridade
e a segurança dos dados por meio de controles de acesso, a administração de dados, o
acesso concorrente aos dados, a proteção dos usuários dos efeitos de falhas de sistema e
a facilitação no desenvolvimento rápido de aplicativos (RAMAKRISHNAM; GEHRKE
2011).
Os bancos de dados são estruturados se baseando em modelo de dados, um conjunto

de ferramentas conceituais para descrever os dados e suas relações. Existem dois tipos
principais de modelo de dados: modelo relacional e modelo não relacional; os quais
serão descritos mais à frente.
76
CAPÍTULO 2
Tipos de bancos de dados
Bancos de dados relacionais e não relacionais
Bancos de dados relacionais - SQL
O banco de dado relacional foi proposto em 1970 por Codd. Até então, os sistemas de
BD eram baseados no modelo hierárquico e de rede, os quais apresentavam diversas
limitações. Desta forma, o BD relacional revolucionou a área de bancos de dados, sendo,
atualmente, o modelo mais dominante do mercado. Os dados do modelo relacional são
armazenados em tabelas com linhas e colunas (figura 21), uma forma de representação
bem simples e elegante que constitui um dos motivos pelos quais esse modelo superou
os mais antigos. As consultas desses dados são realizadas por meio de SGBD.
Os bancos de dados relacionais possuem quatro propriedades básicas, conhecidas como

ACID (acrônimo de Atomicidade, Consistência, Isolamento e Durabilidade).
Atomicidade significa que, quando uma sequência de operações seja executada, ela será
executada totalmente ou não será executada, ou seja, será tudo ou nada. Consistência se
refere a quando uma operação for executada de forma a criar um estado para os dados,
se houver falha, os dados voltam ao seu estado original. A propriedade de Isolamento
garante que uma operação não é interferida por outra. E a Durabilidade garante que
os dados validados estejam disponíveis no estado correto, mesmo quando há alguma
falha ou quando o sistema é reiniciado.
77
Figura 22. Exemplo de banco de dados relacional.
Fonte: Novaes, 2019.
Bancos de dados não relacionais NoSQL

Esses bancos de dados, quando surgiram, não teve o objetivo de substituir os modelos
relacionais, já que estes estão muito bem fundamentados até hoje, mas surgiram para
os casos em que não se enquadravam dentro no modelo relacional. Eles se referem aos
bancos de dados que utilizam outras linguagens não SQL e, embora eles existam desde a
década de 1960, sua popularização ocorreu com a revolução da internet. A necessidade
de o uso desse tipo de banco de dados surgiu quando sites abriram as portas para os
usuários adicionar o conteúdo na internet (Youtube, por exemplo). Os principais
bancos de dados, noSQL, são: Redis, Amazon DynamoDB, MongoDB entre outros.
Existem quatro categorias básicas de bancos de dados NoSQL, classificados de acordo

com a estrutura de dados armazenados: NoSQL orientada aos documentos, orientada
à chave-valor, orientada aos grafos e orientada às colunas (figura 23). As estruturas
estão descritas a seguir.
78
Figura 23. Tipos de bancos de dados NoSQL.
» NoSQL orientada a documento: esse tipo de banco de dados é projetado

para armazenar, acessar e gerenciar documentos. Neste tipo de banco, os
dados são semi-estruturados e cada documento é considerado como um objeto
que tem uma chave única. Os documentos criados são dinâmicos, podendo
ser modificados depois de criados. São diferentes dos bancos relacionais,
os quais são estruturados e não permitem mudanças na estrutura depois
de implementada. O atual líder de banco de dados NoSQL, orientada ao
documento, é o MongoDB.
» NoSQL orientados a grafos: neste tipo de banco de dados, é utilizado uma

estrutura de gráficos, o que torna a estrutura bastante flexível. Os registros
de dados, também conhecidos como nós, armazena os ponteiros diretos para
todos os nós com os quais estão conectados. Desta forma, as consultas se
tornam muito mais rápida quando comparado aos outros tipos de bancos de
dados. O Neo4j é um exemplo de software utilizado para a criação de dados
orientados aos grafos.
» NoSQL chave-valor: este tipo de estrutura utiliza chaves para identificação

de forma exclusiva das informações armazenadas. É o tipo de estrutura
mais simples dentro dos bancos de dados NoSQL. A chave, geralmente,
utiliza um dado do tipo string já o valor pode armazenar qualquer tipo de
dado. Um exemplo clássico de aplicação deste tipo de banco de dados é o
79
armazenamento de informação de usuário e a senha de sessões dentro da

web. O banco de dados mais popular, para criar esse tipo de estrutura, é o
Amazon DynamoDB.
» NoSQL orientado a colunas: é o tipo de banco de dados mais próximo aos

bancos de dados relacionais, contudo existem algumas diferenças básicas.
A primeira diferença é a da flexibilidade. O desenvolvedor cria o que é
chamado de família de colunas sem precisar definir toda a estrutura do banco.
Desta forma, podem ser inseridas as colunas que forem necessárias para o
armazenamento dos registros, sem precisar alterar a estrutura do banco.
Outra característica importante deste tipo de banco é a escalabilidade, a qual
gerencia grandes quantidades de dados sem comprometer o desempenho.
Este tipo de banco é utilizado, por exemplo, pelos serviços de mensagem
do Facebook. Um dos softwares mais populares, para esse tipo de aplicação,
é o Apache Cassandra.
Diferenças entre banco de dados relacionais e não

relacionais
Tanto os bancos de dados relacionais como os não relacionais são importantes para
o gerenciamento de dados, contudo suas finalidades são diferentes. Quando os dados
têm uma estrutura tabular, em que é possível utilizar os esquemas pré-definidos,
sem necessidade de grandes mudanças, os BD relacionais são indicados. Contudo, se
a finalidade é armazenar os dados, como os documentos, os dados geo-espaciais, as
hipermídias etc.; o banco de dados estruturado, em tabela, não se aplica. Desta forma,
a estruturação, como coleções de dados, é o mais indicado. , O quadro a seguiir, trata
das principais características que diferenciam os dois tipos de bancos de dados.
Quadro 10. Características de bancos de dados relacionais e não relacionais.
Características Banco de dados relacionais Banco de dados não relacionais

Armazenamento de dados Tabelas Coleções
Aplicações Centralizadas Não centralizadas
Esquemas Pré-definidos Dinâmicos
Linguagem SQL UnQL
Velocidade Moderada Alta
Fontes dos dados Poucas Múltiplas
Volume de dados Moderado Alto
Exemplos Oracle, SQL Server, IBM DB2, SQLite e mongoDB, redis, Cassndra e Apacha
MySQL HBase
80
CAPÍTULO 3
Uso de banco de dados em
bioinformática
Bancos de dados biológicos

As análises de bioinformática sempre tem como entrada os dados biológicos que são
coletados por meio de experimentos científicos e biotecnológicos. Existem diversos
bancos de dados que armazenam essas informações. Esses dados incluem sequências
de DNA, RNA ou proteínas, interações moleculares, expressão gênicas, dados clínicos
etc. Nas últimas décadas, o volume de dados biológicos, armazenados nos bancos de
dados, cresceu de forma vertiginosa. E, a cada ano, esse crescimento ocorre de forma
exponencial, com uma estimativa de petabyte (PB) ou até exabyte (EB) de dados
armazenados.
Todos esses dados, se analisados, poderiam geram informações valiosas para diversas
áreas médicas, biomédicas, biológicas e farmacêuticas. Contudo, isso está longe de ser
obtido por diversos motivos. Se por um lado, houve um avanço no desenvolvimento
de novas tecnologias para as análises, de outro lado, temos a falta de capacitação
de profissionais capazes de dominar essas ferramentas. Nos últimos vinte anos, a
Biblioteca Nacional de Medicina (NLM) vem impulsionando os avanços significativos
em informática biomédica, possuindo um dos maiores repositórios do mundo de dados
biológicos (NCBI) integrado com mais de 40 bancos de dados de biologia molecular.
A figura, abaixo, mostra o crescimento de depósitos de sequências no GenBank até o
ano de 2019.
81
Figura 24. Crescimento do volume de sequências depositadas no GenBank e NCBI.
Fonte: NML, 2021.
Os dados, obtidos pelos bancos de dados biológicos, podem estar em diversos formatos
e existem diversas formas de analisá-los. Uma alternativa, para não se usar um SGBD,
é armazenar os dados em arquivos e escrever o código específico para manipulá-los em
diferentes linguagens (como Python e R). Os principais bancos de dados biológicos,
que podem ser utilizados como fontes de informações para análises de bioinformática,
estão descritos a seguir.
Centro Nacional de Informações Biotecnológicas

(NCBI)
Um dos maiores bancos de dados biológicos é o Centro Nacional de Informação
Biotecnológicas (NCBI - National Center for Biotechology Information). Patrocinado
pelo senado americano, surgiu em 1988 como uma divisão da Biblioteca Nacional de
Medicina (NLM) no Instituto Nacional de Saúde (NIH), após o reconhecimento da
importância de métodos computadorizados de processamento de informações para a
realização de pesquisas biomédicas.
Segundo o próprio NCBI (1988), sua missão é desenvolver novas tecnologias de

informação para auxiliar na compreensão dos processos moleculares e genéticos
fundamentais que controlam a saúde e as doenças; criar sistemas automatizados para
armazenar e analisar conhecimentos sobre biologia molecular, bioquímica e genética;
facilitar o uso de tais bancos de dados e software pela comunidade médica e de pesquisa;
coordenar esforços para reunir informações sobre biotecnologia tanto nacional quanto
internacionalmente; e realizar pesquisas em métodos avançados de processamento de
82
informação baseado em computador para analisar a estrutura e função de moléculas

biologicamente importantes.
O NCBI está integrado com mais de 40 bancos de dados de biologia molecular e oferece
diversas ferramentas de bioinformática, tais como GenBank, RefSeq, dbGaP e ClinVar.
Os bancos de dados do NCBI podem ser classificados como descrito abaixo.
Compreensivo
» Análise de sequência nucleotídica
› GenBank.
› EMBL (Laboratório de Biologia Molecular Europeu).
› DDBJ (Banco de Dados de DNA do Japão).
» Análise de proteínas
› Swiss-Prot.
› PIR-International (Fonte de Informação de Proteína).
› PDB (Banco de Dados de Proteínas).
› MMDB (Banco de Dados de Modelagem Molecular).
» Genomas e Mapas
› Entrez Genomes.
» Especializado
» Organismo Específico
› Sequenciamento do Genoma Humano.
› GDB (Banco de Dados Genômico Humano).
› MGB (Banco de Dados de Genoma de Camundongo).
› SGD (Banco de Dados de Genoma de Saccharomyces).
83
» Funcional
› TRANSFAC (Fator de Transcrição).
› Banco de Dados de Vetor.
» Tecnologia de Sequenciamento
› EST (Marcador de Sequência Genética).
› GSS (Sequências de Pesquisa de Genoma).
› STS (Sequências Identificados de Sequências).
Sistema de busca
O Entrez é o principal sistema de busca do NCBI e integra o banco de dados PubMed de
literatura biomédica com 38 outros bancos de dados de literatura e de dados moleculares.
As consultas do Entrez podem ser palavras únicas, frases curtas, sentenças identificadoras
de banco de dados, símbolos de genes ou nomes etc. Podem, ainda, utilizar-se de
operadores booleanos, como AND, OR e NOT.
Swiss-Prot
Criado em 1986, o Swiss-Prot é um banco de dados com sequências de proteínas com

anotações. É mantido pelo grupos Amos Bairoch (Universidade de Genebra) e EMBL
(Instituto Europeu de Bioinformática).
Neste banco de dados, são armazenados os dados da sequência da proteína, as infomações

de citação, os dados taxonômicos e as informações de anotação; tais como a função
da proteína, a estrutura, os domínios e os sítios de ligação, as doenças associadas etc.
Esse banco de dados difere de outros por tentar minimizar redundâncias de sequências
armazenadas. Quando há algum conflito, eles são indicados.
84
ALGORITMOS DE
BIOINFORMÁTICA UNIDADE IV
CAPÍTULO 1
Modelos de algoritmos
Fundamentos de algoritmos em bioinformática

Relembrando o que são algoritmos, podemos descrevê-los, rudemente, como sequências
de instruções as quais, executadas em uma determinada ordem, solucionam um problema
bem formulado a partir de uma entrada de dados fornecendo um resultado como saída
(JONES; PEVZNER; PEVZNER, 2004). Eles podem ser descritos em uma linguagem
inteligível conhecida como pseudocódigo, mas, para funcionar em computadores
modernos, eles precisam ser traduzidos para uma linguagem de programação como
Python, R, ou C.
A variedade e a complexidade dos problemas, envolvidos em análises de Bioinformática, é

alvo de várias estratégias que combinam técnicas e ferramentas de matemática, estatística
e computação para prover soluções. Há, no entanto, problemas tratáveis e problemas
não tratáveis. Nesse sentido, os problemas podem ser categorizados conforme sua
complexidade e, para resolvê-los, é preciso desenvolver algoritmos capazes de serem
executados em um tempo factível ou polinomial. Um exemplo clássico é o problema
do Caixeiro Viajante, ou Salesman Problem, o qual consiste em encontrar o menor
caminho entre uma lista de cidades, visitando cada cidade apenas uma vez. Problemas,
como o caso do caixeiro viajante, encaixam-se numa categoria de problemas para os
quais, ainda, não se conhece algoritmo que execute em tempo polinomial, os chamados
problemas NP-completos. Há, inclusive, os prêmios milionários ofertados para a
solução de problemas como esse, os chamados Millennium Prize Problems (http://
www.claymath.org/millennium-problems/millennium-prize-problems).
85
Unidade IV | Algoritmos de bioinformática
Técnicas de desenho de algoritmos
Algoritmos recursivos versus algoritmos interativos
Algoritmos recursivos tem, basicamente, três princípios: resolvem um problema a partir

da solução de subproblemas menores de mesmo teor, oriundos do problema original;
têm uma condição de parada; e uma chamada para si mesmos (chamada recursiva). Os
algoritmos iterativos, por sua vez, resolvem os problemas sem uma chamada para si
mesmos, podem ou não dividir o problema em subproblemas, mas, ainda, têm uma
condição de parada.
Tomemos, como exemplo, a sequência de Fibonacci para demonstrar a diferença entre

um algoritmo recursivo e um algoritmo iterativo. Leonardo Fibonacci (Pisa-Itália,
1170-1250) foi um dos mais talentosos matemáticos da Idade Média. Ficou conhecido
pela sequência de Fibonacci e pela sua participação na introdução dos algarismos
hindu-arábicos na Europa. A sequência de Fibonacci é uma sequência de números
inteiros, começando normalmente por 0 e 1. Cada termo subsequente corresponde à
soma dos dois anteriores. Os números 0, 1, 1, 2, 3, 5, 8, e 13 podem ser considerados
uma sequência de Fibonacci. Vejamos, então, dois algoritmos para gerar a sequência
de Fibonacci, um recursivo e outro iterativo.
FibonacciRecursivo( n )
If n = 1 or n = 2
Return 1
Else
A <- FibonacciRecursivo( n-1 )# chamada recursiva
A <- FibonacciRecursivo( n-2 )# chamada recursiva
Return a + b
FibonacciIterativo( n )
F1 <- 1
F2 <- 1
For i <- 3 to n
Fi <- Fi-1 + Fi-2
Return Fn
Busca exaustiva
A busca exaustiva ou a força bruta são um tipo de algoritmo que examina todas as
alternativas para encontrar uma solução particular. Imagine que você esqueceu onde
deixou seu telefone celular. Numa busca exaustiva, você olharia em cada lugar da casa
86
Algoritmos de bioinformática | Unidade IV
até encontrá-lo. Assim, é garantido que, se o celular estiver em algum lugar da casa,
eventualmente, você vai encontrá-lo. Porém, essa estratégia pode ser muito custosa,
já que o celular poderia estar no último lugar em que você procurou.
Branch and Bound ou Prunning (poda)
Tomemos, como exemplo, o exemplo anterior no qual seu celular está perdido em
algum lugar da casa. Já percebemos que o algoritmo de força bruta é um tanto quanto
custoso. Assim, pode-se pensar em alguma estratégia para evitar procurar em todos
os lugares. Você poderia pedir a alguém para ligar para o celular antes de começar a
procurar. Se o som do celular vier da cozinha, você poderá evitar procurar em todos
os outros cômodos da casa, tornando o algoritmo de força bruta um pouco mais
eficiente. No entanto, ainda, terá de procurar em toda a cozinha. Algoritmos desse
tipo podem ser aplicados se for possível, a partir dos dados do problema, verificar, de
alguma forma, qual o espaço de busca pode ser excluído.
Algoritmos gulosos
Os algoritmos gulosos (greedy algorithms) escolhem a alternativa mais atrativa na iteração.

Considere o problema de trocar dinheiro. Um caixa eletrônico tem uma quantidade
limitada de notas de cada valor. Eventualmente, alguém vai sacar um determinado
valor e o algoritmo precisa combinar as notas disponíveis de acordo com o valor
solicitado. Uma solução possível seria uma combinação que maximize a quantidade
de notas com valores altos. Dessa forma, sempre que alguém pedir qualquer valor,
o algoritmo decidirá entregar o máximo de notas com valor mais alto que estiverem
disponíveis após cada saque.
Programação dinâmica
Um algoritmo de programação dinâmica “quebra” o problema em problemas menores

e usa a solução desses subproblemas para construir uma solução do problema maior.
A quantidade de subproblemas pode ser bastante grande e eles são resolvidos de tal
forma a evitar computar valores para os quais já se tem a resposta. Particularmente,
a programação dinâmica é um tipo de algoritmo muito usado em Bioinformática,
especialmente na comparação de sequências.
Considere as seguintes sequências de DNA, GACGGATTAG e GATCGGAATAG,

apresentadas em Setubal e Meidanis (1997). As únicas diferenças entre elas são um
“T” extra na segunda sequência e uma troca de “A” para “T” na quarta posição da
87
direita para a esquerda. Um algoritmo eficiente que alinhe essas sequências pode
usar programação dinâmica através de uma matriz bidimensional que compute os
alinhamentos ótimos locais.
Vamos exemplificar essa matriz para alinhar 2 sequências AAAC e AGC, construindo
a matriz de programação dinâmica (i, j).
» I (i − 1, j): posição anterior vertical.
» I (i − 1, j − 1): posição anterior diagonal.
» I (i, j − 1): posição anterior horizontal.
Onde p(i, j) = +1 se s[i] = t[j] ou −1 se s[i] ≠ t[j].
Seguindo esta fórmula que divide o problema do alinhamento entre duas sequências
em problemas menores, temos o que se segue.
Figura 25. Matriz das sequências com valores iniciais penalizando gaps (inserção ou deleção de nucleotídeos com –2
cumulativamente)
88
Figura 26. Computação da primeira célula da matriz inserindo o valor máximo entre as alternativas de
alinhamento para a primeira posição.
Figura 27. Computação da próxima célula da matriz inserindo o valor máximo entre as alternativas
de alinhamento para a posição, considerando o valor já calculado anteriormente à esquerda.
Figura 28. Computação da próxima célula da matriz inserindo o valor máximo entre as alternativas
de alinhamento para a posição, considerando o valor já calculado anteriormente acima.
89
Figura 29. Matriz de programação dinâmica completamente computada.
Uma vez computados os valores da matriz, partindo do último valor computado,

procura-se os “caminhos de volta” com maior peso somando os valores das células por
onde passar. O(s) caminho(s) com maior pontuação representam o(s) alinhamento(s)
ótimo(s).
Figura 30. Caminho de volta na matriz computada para encontrar melhores alinhamentos a partir
dos caminhos com maior pontuação acumulada.
Para o exemplo acima, os alinhamentos ótimos são os descritos a seguir.
90
Figura 31. Alinhamentos ótimos.
Divisão e conquista
Um grande problema pode ser difícil de resolver, mas, se ele puder ser dividido em dois
problemas com metade do tamanho, sua solução pode ser facilitada significantemente. A
partir de essa premissa, algoritmos que utilizam o método dividir para conquistar dividem
o problema recursivamente em subproblemas; resolvem cada um dos subproblemas
individualmente; e, depois, combinam as soluções dos subproblemas na solução do
problema original.
O ponto crítico desse tipo de algoritmo é, justamente, a combinação das soluções, que
pode consumir muito processamento ou muita memória. O próprio alinhamento de
sequências, usando a matriz de programação dinâmica apresentado anteriormente,
ilustra esse problema. A programação dinâmica é, geralmente, um algoritmo eficiente
em termos de tempo, mas não de espaço, uma vez que a matriz pode ser muito grande
quando comparamos sequências grandes, como dois cromossomos. Para resolver o
problema de espaço em matrizes de programação dinâmica nos anos 1970, Hirschberg
(1975) propôs uma abordagem de divisão e a, conquista que era capaz de executar
o alinhamento usando espaço linear, mas ao custo de dobrar o tempo de execução.
Nesse algoritmo, a matriz era dividida em submatrizes e, depois, as soluções de cada
submatriz eram combinadas.
Machine Learning
Ao longo do tempo, a quantidade de dados disponíveis tem aumentado e novas técnicas

têm sido desenvolvidas para lidar com eles. Nos algoritmos convencionais, é informada
uma entrada, o programador cria um conjunto de regras para computar ou analisar
dos dados e prover uma saída. O aprendizado de máquina, ou Machine Learning, é
91
uma proposta na qual o programador informa uma entrada e uma saída esperada e o
computador “aprende” regras que levam àquela saída.
Existem várias técnicas diferentes de Machine Learning que podem ser organizadas da
seguinte maneira.
Figura 32. Organização dos métodos de aprendizado de máquina.
Vários programas de computador têm sido desenvolvidos para resolver problemas

de biologia molecular utilizando aprendizado de máquina. Um exemplo é o software
SnoReport (OLIVEIRA et al., 2016), o qual é capaz de dizer se uma dada sequência é
ou não é um small nucleolar RNA, com base em uma série de características inferidas
por aprendizado de máquina a partir da sequência. Ainda, em áreas mais recentes na
Bioinformática, como é o caso de a análise de single-cell RNA, muitos métodos têm
sido estudados e aplicados para conseguir, adequadamente, separar diferentes tipos
de células a partir do agrupamento de seus transcritos. Em outro exemplo, o trabalho
de Huang et al. (2021) faz uma síntese do desempenho de vários métodos de machine
learning quanto à sua acurácia e o tempo de execução para esse tipo de problema.
Segundo, Huang et al. (2021), todos os métodos testados apresentaram bom desempenho
na acurácia, em agrupar diferentes tipos de células, mas os métodos de aprendizado
supervisionado, Linear Support Vector Machine (linear-SVM) e Logistic Regression
Classifier, conseguem ser mais rápidos.
Alinhamento de sequências
O estudo de moléculas é fundamental para entender a vida. A partir de tecnologias
modernas para obtenção de sequências de DNA, a quantidade de dados, a ser analisada,
tem alcançado patamares conhecidos como Big Data. A genômica, a transcritômica,
a proteômica e outras áreas, conhecidas como ômicas, têm produzido tamanha
quantidade de dados a qual deve alcançar, nos próximos quatro anos, a casa dos Zeta
Bytes (STEPHENS et al., 2015).
92
Isso cria uma demanda por análise de dados sem precedentes na história humana. Essas
análises são executadas por meio de algoritmos, os quais, no caso de a Bioinformática,
lidam, primordialmente, com sequências de DNA, RNA ou proteínas (resíduos de
aminoácidos), representados na forma de textos por letras de um alfabeto limitado,
como mostra o quadro a seguir.
Quadro 10. Representação da informação contida no DNA, no RNA e nas proteínas
Molécula Alfabeto
DNA A, C, G, T
RNA A, C, G, U
Aminoácidos G, A, L, V, I, P, F, S, T, C, Y, N, Q, D, E, R, K, H, W, M
O alinhamento de sequências, sejam elas de DNA, de RNA ou de aminoácidos, é a

principal ferramenta da Bioinformática para resolver os problemas biológicos. Um
alinhamento consiste em uma comparação de duas ou mais sequências (DNA, RNA
ou aminoácidos) com o objetivo de estabelecer uma relação biológica entre elas. Num
alinhamento, podem ser inseridos ou removidos buracos (gaps), mas não se pode
trocar a posição de nenhuma letra que componha a sequência.
Isso quer dizer que um alinhamento é o posicionamento das sequências, com indicação
das posições em que as sequências são iguais e das que são diferentes, o que preserva a
ordem dos nucleotídeos ou dos aminoácidos de cada sequência. São considerados, num
alinhamento, os conceitos, como identidade, que é a quantidade de nucleotídeos ou de
aminoácidos idênticos e a similaridade que ocorre quando se alinha os aminoácidos ou
os nucleotídeos diferentes, mas que, naquele contexto, podem ter um papel biológico
similar.
Sejam as duas palavras: JERICOAQUOARA e ARARAQUARA, assim, um alinhamento

possível é descrito abaixo.
J E R I C O A C O A R A
A R A R A C O A R A - -
O alinhamento, acima, teve zero identidade, ou seja, nenhuma letra foi idêntica a
outra. Porém, é possível fazer outros alinhamentos, nos quais haja mais identidade,
como o exemplo abaixo.
93
J E R I C O A C O A R A
- A R - A R A Q U A R A
Desta vez, a sequência de letras ARARAQUARA foi reorganizada em função da

sequência de letras JERICOACOARA, inserindo gaps, mas sem mudar as posições
das letras de cada sequência. Com isso, foi possível obter um alinhamento com maior
identidade do que o anterior.
Os alinhamentos podem ser classificados de acordo com algumas características. A

tabela, abaixo, resume alguns dos tipos mais frequentes de alinhamentos.
Tabela 12. Características dos tipos de alinhamentos
parwise Alinhamento de 2 sequências

Número de sequências
múltiplo Alinhamento de múltiplas sequências
local
Estratégia
global
nucleotídeos DNA ou RNA

Tipo de entrada sequências
Resíduos de aminoácidos
proteicas
94
CAPÍTULO 2
Fontes de algoritmos para uso em
bioinformática
Um programa escrito, em uma determinada linguagem de programação, é um arquivo

ou uma coleção de arquivos que são, então, interpretados ou compilados, a depender da
arquitetura da linguagem de programação utilizada. C, por exemplo, é uma linguagem
compilada. Isso significa que um programa, escrito em C, é lido pelo compilador e, após
o processo de compilação, um arquivo único executável é gerado. Já em linguagens de
script, ou interpretadas, o programa é executado à medida que suas linhas de código
são lidas pelo interpretador da linguagem. É o caso de Python e R, por exemplo.
Repositórios digitais podem ser entendidos como bases de dados que reúnem e organizam
dados ou arquivos online. Repositórios de códigos de uma linguagem de programação,
frequentemente, têm mecanismos de versionamento. Ou seja, é possível manter um
histórico dos arquivos e das modificações as quais, nele, ocorreram ao longo do tempo.
O versionamento é muito útil para controlar as versões do programa, permitir que
múltiplos programadores possam trabalhar em um mesmo código sem comprometer
o trabalho uns dos outros entre outras coisas.
Assim, como em outras áreas, algoritmos, em Bioinformática, são frequentemente

obtidos de repositórios digitais. Alguns são especializados, outros são mais gerais.
Neste capítulo, vamos conhecer algumas fontes de softwares de Bioinformática e seus
mecanismos de instalação, de licenças e outras características.
Python
A maneira mais conhecida de instalar um programa em Python é por meio do programa
pip. Mas antes de verificar como instalar pacotes Python com pip, vamos entender melhor
o que é um pacote. A Python Packaging Authority (PyPA) é um grupo de trabalho
que mantém o núcleo de projetos de software usados para empacotar os programas em
Python. Como os programas em Python são, frequentemente, compostos de vários
arquivos de código fonte, convêm que eles sejam distribuídos como o conjunto que são.
Portanto, a PyPA estabelece os parâmetros de empacotamento e os meios para que,

uma vez empacotados, os programas Python possam ser instalados com um simples
comando, usando pip, por exemplo. Há três níveis de empacotamento: .py (código
95
fonte executável), sdist (arquivos comprimidos no formato “.tar.gz”) e wheel (um formato
de empacotamento especialmente desenhado para Python). Saiba mais em: https://
packaging.python.org/overview.
Para instalar um pacote em Python, basta digitar, no terminal pip install

<nome_do_pacote>. Por exemplo, um dos pacotes, que veremos sobre seu uso
no próximo capítulo, é o biopython, o qual pode ser instalado pelo comando pip
install biopython.
Anaconda
Muitas vezes, um pacote precisa de outro pacote para funcionar, o qual, por sua vez,
precisa de outro pacote para funcionar. São as chamadas dependências. Não raras vezes,
o bioinformata precisa investir um longo tempo instalando dependências antes de
instalar seu pacote de interesse. A iniciativa anaconda (https://www.anaconda.com)
tomou, para si, a tarefa de gerenciar as dependências e de fazer a instalação de pacotes
e suas dependências menos trabalhosa.
Anaconda mantém um repositório próprio de mais de 7.500 pacotes de softwares

livres, científicos e verificados por uma equipe técnica, o que garante sempre os
pacotes atualizados. Mais do que isso, anaconda usa ambientes virtuais separados
(virtual-environments), como os containers Docker. Neles, é possível instalar os pacotes
de interesse separados dos pacotes instalados diretamente em seu computador, o que
evita a incompatibilidade de versões, por exemplo.
Anaconda pode acessar canais de software específicos, como é o caso de o bioconda

(https://bioconda.github.io), o qual contém, apenas, softwares de bioinformática
(GRÜNING et al., 2018). Uma vez instalado o gerenciador de pacotes anaconda, para
adicionar o canal bioconda, basta digitar no terminal: conda config --add
channels bioconda. Depois, para criar um ambiente virtual com os alinhadores
de sequências mais utilizados na atualizada, bastaria a linha de comando: conda
create -n alinhadores bwa bowtie hisat star blast; seguida
pelo comando conda activate alinhadores; para entrar no ambiente
virtual e começar a usar os alinhadores.
Similarmente ao Python, a linguagem R, também, tem seus padrões de empacotamento

de scripts que podem ser distribuídos como um programa em um pacote R. A linguagem R
96
tem, no Comprehensive R Archive Network (CRAN), um de seus principais repositórios

de pacotes. O CRAN é um repositório de pacotes R que pode ser espelhado em vários
lugares do mundo, o que permite que haja redundância da disponibilidade de pacotes,
evita os problemas de disponibilidade e até de velocidade de download, ao escolher um
“mirror” do CRAN mais próximo de sua localização geográfica, por exemplo.
Da mesma forma que em Python, para a linguagem R, também, há canais de pacotes

especializados em Bioinformática. É o caso de o Bioconductor (https://www.
bioconductor.org). Para instalar o canal Bioconductor, bastam as linhas de comando,
a seguir, no terminal do R.
if (!requireNamespace(“BiocManager”, quietly = TRUE))
install.packages(“BiocManager”)
BiocManager::install()
Em seguida, para instalar um pacote R usando o Bioconductor, basta a linha de comando

BiocManager::install(“Nome_do_pacote”); para verificar os pacotes
disponíveis para instalação: BiocManager::available(). Os pacotes de
Bioinformática, em R, são, particularmente, muito utilizados em análises estatísticas
de sequenciamento de RNA, em quantificação de variações em populações e em redes
de regulação gênica, além de plotar gráficos a partir de os resultados das análises. No
próximo capítulo, veremos alguns exemplos.
T4. GitHub
Git é um sistema de versionamento de arquivos e Hub é um aparelho que permite

a conexão de vários computadores numa rede. A junção dessas palavras foi usada
para criar uma espécie de rede social de programadores, a qual funciona como um
repositório com o versionamento, a possibilidade de reportar problemas num fórum,
de etiquetar releases dos softwares entre outras coisas. A maioria dos softwares, que
outrora estiveram em repositórios, como source-forge (https://sourceforge.net), têm
migrado para GitHub (https://github.com).
Além de perfis individuais, é possível criar perfis de entidades ou de empresas no

GitHub. Por isso, vários laboratórios ou grupos de pesquisa e mesmo empresas têm
usado o GitHub para centralizar o desenvolvimento de seus softwares, uma vez que
é possível trabalhar com repositório visíveis ou não ao público. Por exemplo, o
Hospital JH moveu, para o GitHub em 2015, o código fonte da suite de programas
para a análise de RNA-Seq chamada Tuxedo, na qual está, por exemplo, o alinhador
97
TopHat (https://github.com/infphilo/tophat). Para instalar um software do GitHub,

o que se faz é clonar o repositório em seu computador e seguir os passos indicados
pelo desenvolvedor a partir de o código fonte.
Licenças
A GNU, General Public License (GPL), é uma licença baseada em 4 liberdades: i) executar
o programa, para qualquer propósito; ii) acessar, estudar e adaptar o programa para as
suas necessidades; iii) redistribuir cópias do programa original; iv) distribuir cópias do
programa com seus aperfeiçoamentos. Softwares que utilizam de códigos distribuídos
por esta licença precisam, caso licenciados de outra forma, manter as mesmas liberdades.
A linguagem R é licenciada em GPL, enquanto a linguagem Python 3.x utiliza a licença
Python Software Foundation (PSF), que é compatível com a licença GPL.
Isso tem algumas implicações práticas: se você fizer qualquer melhoria nas linguagens
R ou Python 3, essas melhorias não podem ser distribuídas de uma forma incompatível
com a licença GPL. Mas se você apenas usa as linguagens para desenvolver um software,
você pode licenciar esse software de forma não compatível com GPL. Por isso, é
importante se atentar para as licenças dos pacotes de software que podem ser usadas,
tanto em Python quanto em R. Muitos deles são gratuitos apenas para fins científicos
e podem exigir um pagamento para fins comerciais ou industriais.
98
CAPÍTULO 3
Principais algoritmos em R e
Python para resolver problemas em
bioinformática
Pipelines e Scripts
Os pipelines ou worflows científicos podem ser entendidos como conjuntos de atividades
gerenciadas executadas por diferentes entidades de processamento. É comum, em
Bioinformática, aplicar pipelines para resolver os problemas em Biologia Molecular,
notadamente, aqueles relacionados às análises de sequência (WERCELENS et al., 2019).
Assim, uma vez que tais análises têm várias etapas e, em cada etapa, um ou mais
algoritmos podem ser combinados para resolver o problema, os pipelines podem,
também, ser entendidos como um encadeamento de programas, no qual a saída de
um programa serve como entrada para um próximo programa. Pipelines, com mesmos
propósitos em Bioinoformática, costumam ter etapas idênticas ou similares, mas que
podem usar diferentes programas e algortimos para a solução de cada etapa.
Montagem de genomas
A montagem de genomas consiste em combinar as reads, as quais são os fragmentos de
DNA oriundos do sequenciamento. As reads são sequências de caracteres com alfabeto
limitado (A,C,G,T) representando os nucleotídeos sequenciados.
Um arquivo de read é, normalmente, apresentado no formato FASTQ. Um arquivo

fastq é um arquivo de texto que contém uma sequência de DNA e a respectiva qualidade
de cada nucleotídeo na sequência. Essa qualidade é representada por um caractere da
tabela ASCII (https://www.ascii-code.com), na qual cada símbolo tem um número
associado a ele. Esse número representa a qualidade daquele nucleotídeo em particular
em uma escala de qualidade, geralmente, a escla PHRED (https://gatk.broadinstitute.
org/hc/en-us/articles/360035531872-Phred-scaled-quality-scores). A escala PHRED
usa uma escala logarítmica para estabelecer uma relação de porcentagens de erro por
base sequenciada. A tabela, a seguir, mostra alguns limiares de valores de acurácia e o
erro para cada base sequenciada (base call).
99
Tabela 13. Limiares de valores de acurácia e de erro.
Qualidade na escala PHRED Probabilidade de base call incorreto Acurácia de base call
10 1 em 10 90%
20 1 em100 99%
30 1 em1.000 99,9%
40 1 em10.000 99,99%
50 1 em100.000 99,999%
60 1 em1.000.000 99,9999%
É possível gerar relatórios de qualidade das sequências e filtrá-las com softwares como
o fastqc (https://www.bioinformatics.babraham.ac.uk/projects/fastqc), quast (https://
github.com/ablab/quast), sickle (https://github.com/najoshi/sickle) e trimmomatic
(http://www.usadellab.org/cms/?page=trimmomatic).
Figura 33. Exemplo de relatório de qualidade das reads de um dado sequenciamento utilizando o software fastqc.
A figura, abaixo, mostra uma read em um arquivo do tipo fastq. Nela, é possível ver
que a primeira linha contém dados que identificam a read, os quais dependem do
sequenciador utilizado. A segunda linha contém o fragmento de DNA sequenciado. A
terceira linha é, apenas, um sinal de “+” que funciona como separador para a terceira
linha, a qual contém a qualidade referente a cada nucleotídeo sequenciado. O primeiro
nucleotídeo, “T”, tem, portanto, uma qualidade igual a 33 na escala PHRED, porque
o caracter “!” é correspondente ao número 33 na tabela ASCII.
100
Figura 34. Exemplo de read em arquivo do tipo fastq.
A montagem de genomas consiste, em termos práticos, na combinação de todas as reads

disponíveis através de alinhamentos, de forma que, ao final, obtenha-se uma (genoma)
ou mais sequências (partes do genoma, como cromossomos) contífuas, representando
o DNA original de onde foram sequenciados os fragmentos apresentados como reads.
É, basicamente, um trabalho de quebra-cabeças que pode ser feito com diversos tipos
de algoritmos. Os mais utilizados, para esse essa tarefa, atualmente, são os algoritmos
gulosos, os métodos OLC (overlap-layout-consensus) e os grafos De Bruijn graphs
baseados em k-mers (WERCELENS, 2019).
Uma vez montado o genoma, é, normalmente, apresentado em um arquivo do tipo

fasta. Arquivos fasta podem ser usados para representar nucleotídeos ou aminoácidos,
os quais consistem, basicamente, de 2 partes.
» Um cabeçalho iniciado por “>” seguido de um identificador da sequência e

outras informações. Alguns bancos de dados têm padrões para este cabeçalho.
» Na linha seguinte ao cabeçalho, aparece a sequência em si.
Pode haver várias sequências em um mesmo arquivo (multi-fasta). A figura, abaixo,

mostra um exemplo de arquivo fasta de um gene de resistência aos antibióticos de
uma bactéria em particular.
Figura 35. Exemplo de arquivo no formato fasta.
101
Para garantir que, após o alinhamento, as reads sejam armazenadas tal qual elas
foram alinhadas, outro formato de arquivo é usado. O formato SAM (Sequence
Alignment/MAP) guarda o alinhamento das reads e pode ser lido por diversos softwares
como o IGV (Integrated Genome Viewer).
O formato BAM (Binary Alignment/MAP) é uma versão equivalente ao SAM, mas

comprimida para binários. A figura, abaixo, ilustra a visualização de um arquivo SAM
no software IGV (http://software.broadinstitute.org/software/igv). Nela, é possível
notar que cada read, em cinza, está posicionada exatamente onde ela se alinha com
outras reads. Quanto mais reads houver em sobreposição, maior a cobertura do genoma
naquela região e, consequentemente, maior a certeza de que aquele pedaço de genoma
está corretamente montado.
Figura 36. Exemplo de visualização de uma montagem no software IGV. As tiras cinzas representam as reads posicionadas
exatamente onde houve alinhamento umas contra as outras.
Montagem de novo
Algumas vezes, o sequenciamento de DNA é feito a partir de um organismo para o qual

não existe, ainda, genoma disponível. Neste caso, a estratégia de montagem consiste
em combinar as reads, alinhado-as todas contra todas para obter o resultado. Esta
estratégia é chamda de montagem de novo, ou seja, do início porque não há nenhum
organismo de referência para guiar a montagem.
102
Montagem com referência
A outra maneira de montar um genoma é a montagem com a referência, a qual, como

o próprio nome sugere, usa um organismo filogeneticamente próximo, para guiar o
alinhamento das reads.
Análise de transcritoma
As reads, para a montagem de genoma, são oriundas de DNA genômico, ou seja,
contêm exons, introns, regiões intergênicas, enfim, tudo. Nos experimentos de RNA-
Seq, as reads contêm, apenas, RNA mensageiro, o RNA transcrito (por isso, a palavra
transcritoma) de determinados genes; para, posteriormente, fabricar proteínas, se for
RNA codificador de proteínas, ou agir em vários processos biológicos, como regulação,
se for RNA não codificador.
As análises de transcritomas, assim, como as análises de genoma, podem ocorrer via

montagem de novo, caso não haja genoma de referência disponível, ou via mapeamento
das reads para o genoma de referência disponível.
Hands On (“mão na massa”)

Vamos, então, verificar todos esses conceitos por meio de uma prática. Para isso,
vamos usar dados públicos de sequenciamento da bactéria Klebsiella Pneumoniae. K.
Pneumoniae é um importante patógeno humano que causa sérias infecções hospitalares,
como é o caso recente de um hospital de Recife (ROCHA et al., 2020). Neste estudo
de caso, vamos usar reads Klebsiella Pneumoniae sequenciadas pelo hospital da Johns
Hopkins University, disponíveis no NCBI no endereço: https://trace.ncbi.nlm.nih.
gov/Traces/sra/?run=SRR13893512.
O pipeline consiste no que é descrito abaixo.

1. Baixar as reads
2. Analisar sua qualidade usando a escala PHRED usando o

software fastqc.
3. Filtrar eventuais reads de má qualidade (Q<30) usando o

software fastp.
4. Fazer a montagem de novo do genoma usando o software

SPAdes.
5. Verificar statísticas da montagem com o software quast.
103
Uma consideração importante é a de que a maioria dos pipelines e dos softwares, para a
Bioinformática, é feita para o sistema operacional Linux. Assim, neste estudo de caso,
todo o ambiente do pipeline é executado em Linux, e o passo a passo, para reproduzir
o exprimento, está descrito abaixo, com comentários sobre os algoritmos utilizados
em cada software.
Se o sistema operacional que você usa não é um Linux, é possível baixar e “emular”
o Linux de dentro de seu sistema operacional (inclusive Windows) com todas as
ferramentas instaladas e configuradas, utilizando um software chamado Docker. Docker
é um software que “simula” sistemas operacionais em containers isolando a emulação,
sem a necessidade de instalar o sistema operacional emulado em seu computador. O
endereço, para baixar o Docker, é: https://www.docker.com. As instruções de instalação,
para Windows, estão em: https://docs.docker.com/docker-for-windows/install.
Depois de instalado o Docker, a imagem, com o ambiente configurado, está disponível

em: https://hub.docker.com/repository/docker/waldeyr/bioinfo_basic. Ou, ainda,
é possível usar uma máquina virtual com Linux e instalar o ambiente a partir de os
comandos a seguir.
# Comandos para instalação do ambiente usando o Linux Fedora
versão >= 31
mkdir /home/bioinfo
cd /home/bioinfo
dnf update -y
dnf install dnf install libXcomposite libXcursor libXi libXtst
libXrandr alsa-lib mesa-libEGL libXdamage mesa-libGL libXScrn-
Saver perl perl-CGI wget nano git -y
dnf groupinstall “Development Tools” -y
wget https://repo.anaconda.com/archive/Anaconda3-2020.11-
Linux-x86_64.sh
chmod +x Anaconda3-2020.11-Linux-x86_64.sh
./Anaconda3-2020.11-Linux-x86_64.sh
export PATH=”/home/anaconda3/bin:$PATH”
conda config --add channels defaults
conda config --add channels bioconda
conda config --add channels conda-forge
conda install -c bioconda sra-tools fastqc fastp spades glimmer
blast seqkit -y
pip install quast
104
O primeiro passo é fazer o download das reads de K. Pneumoniae. Há, no banco de

dados SRA, um enorme número de sequenciamentos disponíveis, cada um deles com
um identificador. No caso de o sequenciamento que utilizaremos, o identificador é
SRR13893512. Para fazer o download, usaremos o programa fastq-dump, que é parte
do pacote de ferramentas e bibliotecas, chamado de sra-tools. O sra-tools é fornecido
pelo NCBI para a interação com os dados do banco de dados Sequence Read Archives
(SRA), nos quais são depositadas para o acesso público reads sequenciadas com as
diversas tecnologias atuais. Saiba mais em: https://www.ncbi.nlm.nih.gov/sra.
# Baixando as reads separadas em forward e reverse em um diretó-
rio chamado assembly
fastq-dump --split-files --outdir assembly SRR13893512
Ao final do download, você terá 2 arquivos, SRR13893512_1.fastq e SRR13893512_2.

fastq, cada um deles com 1.4 GB. A figura, abaixo, mostra um trecho da primeira
read do arquivo SRR13893512_1.fastq. Nela, é possível observar que a primeira e
a terceita linhas como identificadores das reads, a segunda linha sendo a sequência
de nucleotídeos, e a quarta linha sendo o caracter da tabela ASCII correspondente à
qualidade de cada nucleotídeo.
Figura 37. Trecho da primeira read do arquivo SRR13893512_1.fastq.
Vamos, agora, ao segundo passo, que é verificar a qualidade das reads. Para isso,
utilizaremos o software fastqc.
# Executando a análise de qualidade das reads
fastqc SRR13893512_1.fastq SRR13893512_2.fastq
105
O resultado da análise pode ser visto em um browser, abrindo os arquivos

SRR13893512_1_fastqc.html e SRR13893512_2_fastqc.html. Vamos analisar os
resultados de SRR13893512_1 gerados no gráfico do relatório abaixo (figura 38). As
reads têm tamanhos entre 35 e 250 pares de bases, nas quais, em geral, a qualidade está
acima de 30, exceto para os últimos nucleotídeos.
106
Figura 38. Relatório da qualidade das reads do arquivo SRR13893512_1.fastq.
Ainda, é possível ver outros dados estatísticos, como a qualidade média das reads
na figura abaixo. Nela, é possível notar que uma limitada quantidade de reads tem
qualidade média menor que 30.
Figura 39. Qualidade médias das reads do arquivo SRR13893512_1.fastq.
107
O terceiro passo é o de filtrar as reads com determinados critérios de qualidade baseados

na escala PHRED. Para isso, vamos utilizar o software fastp v0.20.1.
# os parâmetros -I e –I denotam respctivamente as reads de entrada 1 e 2
# os parâmetros -o e –O denotam respectivamente as reads filtradas 1 e 2
# -q 30 indica que a qualidade mínima de um nucleotídeo deve ser de 30
# -e 30 indica que a qualidade média dos nucleotídeos de uma read deve ser
pelo menos 30
# -l 50 indica que reads que foram filtradas (tiverem nucleotídeos cortados)
precisam ter tamanho mínimo final de pelo menos 50 nucleotídeos
fastp -i SRR13893512_1.fastq -o SRR13893512_1_FILTERED.fastq -I SRR13893512_2.
fastq -O SRR13893512_2_FILTERED.fastq -q 30 -l 50 -e 30
Após a execução do comando acima, 95.558949% das reads atenderam aos critérios
estabelecidos. Após a filtragem, um novo relatório em .html é gerado pelo fastp. Entre
as informações lá contidas, o novo gráfico de qualidade é apresentado na figura abaixo.
Figura 40. Gráfico de qualidade das reads após filtragem.
Uma vez que temos, agora, as reads com requisitos estabelecidos de qualidade, vamos à
montagem delas. Para isso, vamos utilizar o software SPAdes genome assembler v3.13.0.
O algoritmo do SPAdes é baseado no grafo De Bruijn (COMPEAU, 2011). Neste caso,
as reads são quebradas em k-mers, que são substrings da read com tamanho k, as quais
são, então, ligadas por um grafo. Por exemplo, tomando a read AACCGG e um k=1,
108
teríamos os k-mers AACC—ACCG—CCGG. Em seguida, é computado um caminho

Euleriano, ou seja, um percurso no grafo que passe em todas as arestas.
Há outros montadores que utilizam outros algoritmos, como algoritmos gulosos,

nos quais uma determinada read é alinhada com outras a partir de o maior grau de
similaridade (ZHANG, 2000). Há, também, montadores baseados em OLC (Overlap-
Layout-Consensus). Algoritmos OLC comparam todas reads em busca de similaridades,
ligando, em seguida, aquelas mais similares através de um grafo de sobreposição, no
qual os nós são reads e as arestas são as ligações entre as reads, as quais têm, como peso,
o tamanho da sobreposição. Em seguida, o algoritmo constrói um caminho que passa
por todos os nós, o que já vimos pelo problema do Caixeiro Viajante, que é bastante
custoso computacionalmente.
Usando o SPAdes, vamos, assim, montar o genoma da bactéria K. Pneumoniae a partir

de as reads filtradas.
# Os aparâmetros -pe1-1 e –pe1-2 indicam respsctivamente os
dois arquivos de entrada., as reads paired-end
# O parâmetro -t 4 indica que serão utilizados 4 núcleos do pro-
cesador ao mesmo tempo
# o parâmetro --carefull é uma tentativa de reduzir o número de
mismatches e pequenas deleções.
# o parâmetro --cov-cutoff auto deixa que o SPAdes decida o
ponto de corte de cobertura (quantidade mínima de reads que ali-
nharam-se formando um trecho maior)
# o parâmetro -o indica a pasta onde os resultados serão escri-
tos
# o tamanho de k para o k-mer é selecionado automaticamente com
base no tamanho das reads (também é possível especificar)
spades.py --pe1-1 SRR13893512_1_FILTERED.fastq --pe1-2
SRR13893512_2_FILTERED.fastq -t 4 --careful --cov-cutoff auto -o
K_Pneumoniae_assembly
Após a montagem que deve durar algo em torno de 3 horas, deverá haver diversos
arquivos e pastas com os resultados. Vamos verificar os mais importantes.
109
Figura 41. Pastas e arquivos resultantes da montagem do genoma.
O SPAdes é escrito em C++ e Python, e faz várias montagens com diferentes k-mers.
Na figura acima, há uma pasta para cada k-mer, escolhida pelo SPAdes, sendo 127,
99, 77, 55, 33 e 21. Com a melhor montagem, o SPAdes gera um arquivo chamado de
scaffolds.fasta, o qual podemos considerar como o genoma semi-pronto. Se você abrir
o arquivo, verá que, no arquivo multi-fasta, há sequências com tamanhos menores
do que aqueles das reads depois de filtragem (35-250). São, possivelmente, reads que
foram cortadas na etapa de filtragem e não foram aproveitadas durante a montagem.
Podemos cortar do genoma qualquer sequência menor que um determinado limiar.
Vamos usar, aqui, 500 pares de bases como limiar. Para isso, vamos usar o software seqkit.
# Cortando sequências do genoma que são muito pequenas para se-
rem representativas
seqkit seq -m 1000 scaffolds.fasta -o genoma_K_Pneumoniae.fasta
O arquivo scaffolds.fasta que, nesta montagem teve 181 sequências finais, após o corte
de sequências menores que 100 bp, passou a ter 77 sequências finais e foi salvo no
arquivo genoma_K_Pneumoniae.fasta. O próximo passo é gerar algumas estatísticas
para analisar quão boa foi a montagem. Para isso, podemos utilizar o software quast,
que é escrito em Python.
110
# Obtendo estatísticas sobre a montagem do genoma com o software quast

quast.py assembly/K_Pneumoniae_assembly/scaffolds.fasta
Vamos, agora, entender melhor alguns dados gerados pelo quast. Os contigs são cada
sequência que foi possível montar com as reads. Há um total de 77 contigs no arquivo
genoma_K_Pneomoniae.fasta, dos quais 25 têm mais de 50 mil pares de bases, por
exemplo. O maior contig tem, sozinho, 455.585 bp. O tamanho total do genoma é de
5.769.659 bp. Repare que, inicialmente, tínhamos quase 3 GB de reads, representando
pedaços aleatórios desse genoma, o qual, agora, apresenta-se com pouco mais de 5 MB.
N50 é uma medida estatística que descreve o quão completo é o genoma. O número
N50 = 270.452 significa que este é o tamanho da sequência que representa 50% do
genoma se colocarmos todas as sequências em ordem decrescente de tamanho. Ou seja,
quanto maior o N50, menos fragmentada está a montagem. A figura, abaixo, mostra
um trecho do arquivo genoma_K_Pneomoniae.fasta.
111
Figura 42. Trecho do genoma da bactéria K. pneomoniae montado.
No trecho acima, o identificador do primeiro contig é dado por NODE_1_length_455858_

cov_88.954611, onde NODE_ é o nó do grafo De Brujin de onde o contig veio; 455858
é o tamanho do contig; 88.954611 é a cobertura média desse contig; ou seja, quantas
reads, em média, alinharam-se para formar cada região desse contig.
Jupyter Notebooks
Usando anaconda, podemos instalar um ambiente Jupyter para executar os códigos
em Python e R. JupyterLab (https://jupyter.org) é um ambiente de desenvolvimento
interativo Web para códigos Python e R. Assim, cria-se o ambiente com anaconda.
# Criando um ambiente virtual anaconda chamado notebooks
conda create -n notebooks
# Entrando no ambiente virtual notebooks
conda activate notebooks
# Instalando o jupyter e o R no ambiente
conda install -c r r-essentials
112
Explorando os notebooks Python e R desta

apostila
https://github.com/waldeyr/apostila_bioinfo
Assumindo um ambiente com Linux instalado, como acessar o ambiente virtual

notebooks?
conda activate notebooks
Uma vez no ambiente virtual, como obter os códigos e abri-los?

git clone https://github.com/waldeyr/apostila_bioinfo.git
cd apostila_bioinfo
jupyter-notebook
Uma lista de arquivos vai se abrir, entre eles, estão:
» Python_Notebook.ipynb; e
» R_Notebook.ipynb.
Abra-os e bom trabalho!
Python
(https://github.com/waldeyr/apostila_bioinfo/blob/main/Python_Notebook.ipynb)
O pacote Biopython traz uma enorme quantidade de programas em Python para

lidar com as mais comuns tarefas de manipulação de dados em Bioinformática. Aqui,
vamos ver alguns exemplos que podem ser consultados online em: https://github.
com/waldeyr/apostila_bioinfo. É possível seguir os passos descritos lá para rodar seu
Python notebook abrindo o arquivo Python_Notebook.ipynb.
Vamos apresentar, portanto, algumas das tarefas que os códigos disponíveis, no

repositório do GitHub, podem fazer. Primeiramente, precisamos clonar o projeto
do GitHub e, depois, entrar no ambiente virtual de notebooks, criado, assim, como
apresentado na seção anterior, manipulação de dados biológicos com Python.
Aqui, são apresentadas várias situações cotidianas do trabalho do bioinformata, nas

quais pode ser aplicada a linguagem Python, usando um pacote chamado BioPython
113
(https://biopython.org). Para isso, são apresentadas diversas situações-problema e

suas soluções usando programação em Python 3.
Figura 43. Instalação e importação de pacotes necessários.
Problema 01: nucleotídeos com maiúsculas e minúsculas em uma sequência.
Solução: converter todos os caracteres para maiúsculo.
Figura 44. Problema 01.
Problema 02: obter a fita complementar de uma fita de DNA.
Solução: calcular o nucleotídeo que se liga a cada nucleotídeo da fita original.
114
Problema 03: obter a fita de RNA transcrita de uma fita de DNA.
Solução: calcular os nucleotídeos da fita de DNA que serão transcritos pela enzima
RNA polimerase.
Problema 04: obter a sequência de aminoácidos que será traduzida a partir de uma
fita de DNA.
Solução: traduzir de DNA para os aminoácidos usando uma tabela de códons.
115
Problema 05: obter a sequência de aminoácidos que será traduzida a partir de uma
fita de DNA em uma mitocôndria humana.
Solução: traduzir de DNA para aminoácidos usando uma tabela de códons mitocondriais
em vertebrados.
Problema 06: baixar e ler, em uma variável, o genoma original do vírus Sars-Cov-2
de Wuhan.
Solução: fazer uma requisição via URL e carregar o arquivo do genoma em formato
genbank para uma variável.
116
Problema 07: verificar metadados do genoma.
Solução: imprimir, na tela, o NCBI ID do genoma, o seu tamanho, a quantidade de

anotações (features) e a quantidade de genes anotados.
Problema 08: obter a sequência de aminoácidos da proteína spike do vírus.
Solução: percorrer o genoma procurando por regiões codificadoras (CDS) e, ao

identificar a região da proteína spike, traduzir os aminoácidos a partir daquele trecho
de DNA.
Problema 09: obter sequências de aminoácidos de anticorpos humanos que interagem

com a proteína spike.
Solução: utilizar uma requisição via URL com o endereço onde está o arquivo.
117
Problema 10: obter os nomes de genes da via metabólica de vitamina C.
Solução: consultar os dados de vias metabólicas no banco de dados KEGG.
118
Problema 11: obter detalhes de uma proteína a partir de seu ID no banco de dados
Uniprot.
Solução: consultar os dados da proteína no banco de dados Uniprot.
R
(https://github.com/waldeyr/apostila_bioinfo/blob/main/R_Notebook.ipynb)
Vamos, aqui, analisar os genes, diferencialmente, expressos em células de glândulas

mamárias de camundongos fêmeas em duas situações: grávidas e lactantes. O desenho
do experimento original tem as células dos subtipos basal e luminal em três condições:
virgens, grávidas e lactantes. O artigo original do trabalho (FU et al., 2015) pode ser
encontrado em: https://www.ncbi.nlm.nih.gov/pubmed/25730472. Os dados do
experimento estão depositados em: https://www.ncbi.nlm.nih.gov/geo/query/acc.
cgi?acc=GSE60450.
Passo 01: instalar os pacotes R necessários.
Figura 55. Códigos para instalação de pacotes.
119
Passo 02: carregar os pacotes R instalados.
Figura 56. Códigos para carregar pacotes.
Passo 03: download e leitura dos arquivos. Os arquivos são baixados e lidos como um
dataframe chamado de dados.
Figura 57. Códigos para o download de arquivos.
Passo 04: criar uma dataframe auxiliar com os dados do desenho do experimento.
120
Figura 58. Códigos para criação de dataframe.
Passo 05: criação do objeto DGEList. O objeto DGEList é a forma com a qual o pacote
EdgeR organiza os dados para serem analisados.
Figura 59. Códigos para criação do objeto DGEList.
Passo 06: anotação dos genes. A primeira coluna dos genes (ver passo 3) contém
números que são os identificadores de cada gene no NCBI. Usando o pacote org.
121
Mm.eg.db, podemos mapear esses números para as respectivas anotações de genes

de Mus musculus.
Figura 60. Códigos para a anotação dos genes.
Passo 07: filtragem. Há muitos genes que não são expressos ou têm uma quantidade
significativa de reads. É possível estabelecer critérios e selecionar apenas genes expressos
que atendam a tais critérios. Neste exemplo, vamos utilizar uma métrica, chamada de
count per million (cpm), para selecionar, apenas, genes expressos > 1 cpm que estejam
em, pelo menos, 2 amostras.
122
Figura 61. Códigos para filtragem.
Passo 08: Normalização. A normalização visa transformar os dados para uma escala
diferente evitando vieses por ordem de grandeza. O pacote EdgeR usa o método
trimmed mean of M-values (TMM) para a normalização.
Figura 62. Códigos para normalização.
123
Passo 09: expressão diferencial. Aqui, o primeiro passo será o de criar uma matriz com
o desenho do experimento. Em seguida, uma matriz de contraste entre os dois casos
que analisaremos: basal lactante e basal grávida. Depois disso, será possível calcular
a dispersão e a distribuição binomial negativa, o que nos dará a False Discovery Rate
(FDR).
Figura 63. Criação de matriz basal lactante e basal grávida.
Figura 64. Cálculo da dispersão.
124
Figura 65. Código para calcular distribuição negativa binomial.
Figura 66. Gráfico da expressão diferencial.
125
REFERÊNCIAS
ALMEIDA, M. Curso essencial de lógica de programação. Universo dos Livros Editora, 2008.
ASCENCIO, A. F. G.; CAMPOS, E. A. V. Fundamentos da Programação de Computadores.
São Paulo: Prentice Hall, 2002.
CAN, T. Introduction to bioinformatics. Methods Mol Biol., v. 1107, pp. 51-71, 2014. (doi:
10.1007/978-1-62703-748-8_4. PMID: 24272431).
COMPEAU, P. E. C.; PEVZNER, P. A.; TESLER, G. Why are de Bruijn graphs useful for genome
assembly?. Nature biotechnology, v. 29, n. 11, pp. 987, 2011.
CRAN. The Comprehensive R Archive Network, 2010. Disponível em: https://cran.r-project.
org/. Acesso em: dez. 2020.
FORBELLONE, A. L. V.; EBERSPACHER, H. F. Lógica de Programação: construção de algoritmos
e estrutura de dados. 3. ed. São Paulo: Prentice Hall, 2005.
FU, N. Y. et al. EGF-mediated induction of Mcl-1 at the switch to lactation is essential for alveolar
cell survival. Nature Cell Biology, v. 17, n. 4, pp. 365-375, 2015.
GRÜNING, B. et al. Bioconda: Sustainable and Comprehensive Software Distribution for the Life
Sciences. Nature Methods, 2018. (doi:10.1038/s41592-018-0046-7).
HIRSCHBERG, D. S. A linear space algorithm for computing maximal common subsequences.
Communications of the ACM, v. 18, n. 6, pp. 341-343, 1975.
HUANG, Y.; ZHANG, P. Evaluation of machine learning approaches for cell-type identification
from single-cell transcriptomics data. Briefings in Bioinformatics, 2021.
JONES, N. C.; PEVZNER, P. A.; PEVZNER, P. An introduction to bioinformatics algorithms.
MIT press, 2004.
LUSCOMBE, N. M.; GREENBAUM, D.; GERSTEIN, M. What is bioinformatics? A proposed
definition and overview of the field. Methods Inf Med., v. 40, n. 4, pp. 346-358, 2001. (PMID:
11552348).
MARIANO, D.; BARROSO, J. R.; CORREIA, T. M. R. C. Introdução a programação para
bioinformática com Biopython. 3ª ed. Belo Horozinte. 2016.
OLIVEIRA, J. V. A. et al. SnoReport 2.0: new features and a refined Support Vector Machine to
improve snoRNA identification. BMC bioinformatics, v. 17, n. 18, pp. 73-86, 2016.
PBC. RStudio, 2021. Disponível em: https://rstudio.com/products/rstudio/download/. Acesso
em: 12 jan. 2021.
PYTHON SOFTWARE FOUNDATION, Python, 2001. Disponível em: https://www.python.org/
downloads/. Acesso em: 12 dez. 2020.
RAMARKRISHNAN, R.; GEHRKE, J. Sistemas de gerenciamento de banco de dados. 3. ed.
Porto Alegre : AMGH, 2011.
126
Referências
ROCHA, I. V. et al. Diverse and emerging molecular mechanisms award polymyxins resistance to
Enterobacteriaceae clinical isolates from a tertiary hospital of Recife, Brazil. Infection, Genetics
and Evolution, v. 85, pp. 104-584, 2020.
SANTOS, M. G.; SARAIVA, M. O.; GONÇALVES, P. F. Linguagem de Programação. Porto
Alegre: SAGAH, 2018.
SETUBAL, C.; MEIDANIS, J. Introduction to Computational Biology. Boston, MA, USA: PWS
Publishing Company,1997.
SILVA, S. A.; NOTARI, D. L.; DALL’ALBA, G. Bioinformática: contexto computacional e aplicações.
Caxias do Sul, RS: Educs, 2020.
STEPHENS, Z. D. et al. Big Data: astronomical or genomical?. PLoS Biol, v. 13, n. 7, 2015. (e1002195).
THE PYZO, Introdução a Pyzo, 2015. Disponível em: https://pyzo.org/start.html. Acesso em:
12 dez. 2020.
NML. Congressional Justification NLM, 2021. Department of Health and Human Services –
National Institute of Health. Disponível em: https://www.nlm.nih.gov/about/2021CJ_NLM.pdf.
Acesso em: 12 jan. 2021.
NOVAES, R. V. Introdução a bancos de dados. Roberto Vasconcelos Novaes, 2019. Disponível
em: https://www.robertonovaes.com.br/index.php/2019/02/19/aulas-12-13-e-14-introducao-
a-bancos-de-dados-o-modelo-relacional-jurimetria-e-analise-estatistica-do-direito-na-pratica/.
Acesso em: 12 dez. 2020.
WERCELENS, P. et al. Bioinformatics Workflows With NoSQL Database in Cloud Computing.
Evolutionary Bioinformatics, v. 15, pp. 117-693, 2019.
ZHANG, Z. et al. A greedy algorithm for aligning DNA sequences. Journal of Computacional
biology, v. 7, n. 12, p. 203-214, 2000.
127

Programacao para Bioinformatica-1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programacao para Bioinformatica-1

Enviado por

Direitos autorais:

Formatos disponíveis

PROGRAMAÇÃO PARA

Kelly Cristina Rodrigues Simi

Equipe Técnica de Avaliação, Revisão Linguística e Editoração

ORGANIZAÇÃO DO CADERNO DE ESTUDOS E PESQUISA.................................................................................................. 5

ESTRUTURAS DE DECISÃO, REPETIÇÃO, FUNÇÕES E PROCEDIMENTOS................................................................................. 24

USO DE BANCO DE DADOS EM BIOINFORMÁTICA................................................................................................................................ 81

PRINCIPAIS ALGORITMOS EM R E PYTHON PARA RESOLVER PROBLEMAS EM BIOINFORMÁTICA............................ 99

A proposta editorial deste Caderno de Estudos e Pesquisa reúne elementos que se

Pretende-se, com este material, levá-lo à reflexão e à compreensão da pluralidade dos

Elaborou-se a presente publicação com a intenção de torná-la subsídio valioso, de modo

Para facilitar seu estudo, os conteúdos são organizados em unidades, subdivididas em

Sugestão de estudo complementar

Para (não) finalizar

Atualmente, estamos vivendo o período da história da humanidade em que a informação

A quantidade de submissão de dados biológicos, diariamente, nos BDB especializados,

A análise dos dados biológicos envolve, principalmente, escrever e executar os programas

» Diferenciar as funções de procedimentos.

» Desenvolver noções básicas de programação em Python e em R.

» Compreender os principais tipos de bancos de dados.

» Entender as aplicações de bancos de dados em bioinformática.

» Analisar os tipos principais de algoritmos de bioinformática.

» Executar algoritmos básicos em Python e em R para resolver problemas de

Desta forma, a lógica consiste em um conjunto de regras e de conceitos que direcionam

procedimentos que são executadas sobre dados para transformá-los em informações.

Os algoritmos devem ser os mais simples, claros e precisos, já que o computador

Figura 1. Elementos básicos de um algoritmo

Fonte: elaboração do próprio autor.

Os algoritmos podem ser representados de diversas formas, contudo as representações

A descrição narrativa, também, é conhecida como linguagem natural. É a forma

O pseudocódigo, também, conhecido como linguagem estruturada ou portugol, é rica

A representação, em forma de fluxograma, utiliza os símbolos convencionais e é

Figura 2. Representação de algoritmo em fluxograma.

Fonte: elaboração do próprio autor.

Quadro 1. Símbolos de fluxograma.

Utilizado para indicar o início ou o fim do algoritmo.

Utilizado para representar a entrada dos dados.

Utilizado par representar a saída dos dados.

Utilizado para indicar a tomada de decisões.

Fonte: elaboração do próprio autor.

Existem alguns programas (gratuitos ou pagos) que permitem a criação de fluxogramas,

Etapas para construção de algoritmos

Segundo Ascencio e Campos (2002), para a construção de qualquer tipo de algoritmo,

» Definir qual a problemática que deve ser resolvida com o algoritmo.

» Qual tipo de transformação esses dados sofrerão no processamento.

» Quais dados serão gerados na saída (após o processamento).

» Construir o algoritmo em uma de suas representações (descrição narrativa,

» Testar o algoritmo e realizar simulações.

Todas essas etapas podem ser resumidas em três principais.

» Análise: estuda-se o enunciado do problema para definir os dados de entrada,

» Algoritmo: criação do algoritmo em uma das representações.

» Codificação: onde o algoritmo é transformado em códigos de uma linguagem

Se um algoritmo não está escrito de forma que o computador entenda, é necessário

Uma variável é um local que armazena um conteúdo específico dentro da memória

São os tipos de dados básicos utilizados em algoritmos. A maioria das linguagens

Contém valores pertencentes ao conjunto de caracteres alfanuméricos. Deve ser escrito

Algumas linguagens de programação dividem os dados primitivos baseando-se no espaço

Tabela 2. Principais tipos de dados derivados

Dado Derivado Tipo Valor armazenado

Dado Derivado Tipo Valor armazenado

Regra de nomenclatura de variáveis

O nome, atribuído a uma variável, é chamado de identificador. Algumas regras básicas

» Pode ter no máximo 32 caracteres de comprimento.

» O primeiro caractere deve ser uma letra do alfabeto.