Curitiba, PR

Copyright © 2019

1ª Edição, Dezembro de 2020

U NIVERSIDADE F EDERAL DO PARANÁ – UFPR

Setor de Educação Profissional e Tecnológica, SEPT
Realização
P ROGRAMA DE P ÓS -G RADUAÇÃO EM B IOINFORMÁTICA – UFPR
Parceria
P ROGRAMA DE P ÓS -G RADUAÇÃO EM C IÊNCIAS -B IOQUÍMICAS – UFPR
Edição Gráfica e Imagens
Camila Pereira Perico
Guilherme Taborda Ribas
Monique Schreiner
PPG Bioinformática UFPR
Site oficial: http://www.bioinfo.ufpr.br
Site dos alunos: https://www.bioinfodiscentes.com.br.

Licença: CC BY-NC-SA 4.0

Licenciado sob a Creative Commons Attribution-NonCommercial 4.0 Unported License.
http://creativecommons.org/licenses/by-nc/4.0.
Este documento é livre para uso, distribuição, adaptação e criação para fins não comerciais, desde
que seja atribuído devido crédito e que a licença do que fôr produzido a partir deste material possua
licença sob termos idênticos.

O modelo deste documento foi modificado de “The Legrand Orange Book”.

Obtido em overleaf.com, criado por Mathias Legrand ([email protected]).
Licença: CC BY-NC-SA 3.0 (creativecommons.org/licenses/by-nc-sa/3.0/)
 Sumário

1 A Linguagem Python e a Programação . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1 Primeiros Comandos 7
1.1.1 Função print() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.2 Função input() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2 Tipos de dados 8
1.2.1 Tipo string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.2 Tipo list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2.3 Tipo dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.2.4 Tranformando Dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.3 Operadores Aritméticos 14
1.4 Operadores Relacionais 15
1.5 Operadores Lógicos 16
1.6 Estrutura Condicional 16
1.7 Estruturas de Repetição 19
1.7.1 loop while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.7.2 Loop For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2 Tópicos Avançados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.1 Criando Funções 25
2.1.1 Variável local vs global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.2 Importando bibliotecas e pacotes 27
2.3 Criando Gráficos com Matplotlib 29
2.4 Manipulando dados com Pandas 32
2.4.1 Análise Breast Cancer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.5 Biopython 49
2.5.1 Manipulação de Sequências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.5.2 API Entrez do NCBI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.5.3 Diagrama Genômico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.5.4 BLAST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.5.5 KEGG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.5.6 PDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
 5

AUTORES

C HARLIE F ELIPE L IBERATI DA S ILVA Possui graduação em Ciência

da Computação pela Universidade Estadual do Centro-Oeste (2016).
Tem experiência na área de Ciência da Computação, com ênfase em
Ciência da Computação. Mestrando no PPG em Bioinformática pela
Universidade Federal do Paraná. Desenvolveu durante a graduação
interesse por computação natural, inteligência artificial e por aplicações
computacionais em áreas interdisciplinares, tal como Processamento
Digital de Imagem e Classificadores na Agricultura e Mapeamento de
Processos com Linguagem de Modelagem na Indústria..
Contato: [email protected]

G UILHERME TABORDA R IBAS Mestrando em Bioinformática pela

UFPR. Bacharel em engenharia industrial elétrica/ eletrotécnica pela
UTFPR (2009). Técnico em eletrotécnica pela Fundacen (2003). Atual-
mente, como aluno, integro o departamento de inteligência artificial do
programa de bioinformática. Atuo na pesquisa, desenvolvimento e classi-
ficação de métodos de inferência e comparação de árvores filogenéticas.
Possuo experiência em criação de rotinas automatizadas para tratamentos
estatísticos de dados. Em conjunto com o departamento de química da
UFPR trabalhei na otimização da coleta e processamento de dados de
espectrofotômetros para avaliação de rendimentos de dispositivos ele-
trocrômicos. De forma independente atuei na avaliação automatizada
de estratégias de negociação no mercado financeiro, desenvolvendo um
produto open source. E possuo experiência no processamento de mapas
e avaliação do desmatamento amazônico..
Contato: [email protected]
 1. A Linguagem Python e a Programação

G UILHERME TABORDA R IBAS

1.1 Primeiros Comandos

Um computador faz duas coisas, e apenas duas coisas: ele calcula e armazena o resultado do cálculo
[0]. Todas as instruções devem ser passadas ao computador através de um código, ou script. É
essa linguagem, ou lógica de programação, que vamos aprender. Aprenderemos a codificar nossas
necessidades e nossos cálculos para que o computador possa executar e armazenar.
Um script, ou código, é um documento composto por comandos, expressões, operadores,
variáveis e objetos. Esse documento então será executado pela linguagem escolhida, em nosso caso,
Python. Antes de adentrarmos à exploração desses comando mais específicos, vamos ver como
podemos ver os resultados de um script.
Um código pode retornar vários tipos de informações, como imagem, um gráfico, um número,
um texto, um som ou um sinal elétrico. Mas também pode não retornar nada a ser mostrado ao
usuário, ele pode apenas executar uma tarefa auxiliar outro script.
Neste momento de início de aprendizado, vamos estruturar todos os nossos scripts para retornar
um texto. Em Python isso é feito com a função print(). Vamos ao nosso primeiro script, o mais
clichê de todos.

Código 1.1: Hello World!

print('Hello World!')

Abra um novo arquivo .py, salve e execute. Este script simplesmente retorna a frase Hello
World!. Nós solicitamos ao computador que nos mostrasse o texto que está como argumento da
função print(). Qualquer outra coisa que você escreva ele irá imprimir no shell.
Caso tenha interesse, em nosso canal você encontrará vídeos básicos sobre programação e
bioinformática [0].
 8 Capítulo 1. A Linguagem Python e a Programação

1.1.1 Função print()

Conforme dito anteriormente, uma das formas de visulizarmos o resultado de um script é mostrá-lo
na forma de texto pela função print().
Uma função em programação assemelha-se a funções matemáticas. Quando estabelecemos
determinada relação matemática como: f (x) = x + 20, informamos o valor de x e a relação retorna
um valor de y. Para a função print() nós informamos o argumento Hello World! e a função retorna
o argumento impresso na tela.
Podemos inserir mais de argumento a ser impresso, por exemplo:

Código 1.2: print() com dois argumentos

print('Hello World!', 'Pronto para programar em Python?')

Além do texto a ser impresso, a função print pode ter outros argumentos, o sep e end. O sep
define o separador dos argumentos de texto, por exemplo:

Código 1.3: print(), sep

print('Hello World!', 'Pronto para programar em Python?',
sep=' <------> ')

Já o argumento end define o que será impresso ao final do print.

Código 1.4: print(), end

print('Hello World!')
print('Aprendendo Python.')

print('Hello World!', end=' ')

print('Aprendendo Python.', end=' ')

Caso esses argumentos não sejam especificados, os valores default são: sep=’ ’ e end=’\n’,
espaço e quebra de linha, respectivamente.

1.1.2 Função input()

Assim como os resultados retornados podem ser feitos de diversas formas, as entradas também
podem ser feitas de diversas formas: como arquivos de texto, imagens ou textos digitados pelo
usuário. Esta última opção é feita pela função input(). Essa função, em Python 3, receberá o texto
digitado em forma de string. Veja abaixo um exemplo.

Código 1.5: Função input()

x = input('Digite seu nome: ')
print('Olá,', x)

Note que armazenamos o valor digitado em uma variável chamada "x". Então imprimimos o
valor dessa variável na função print(). Em python string é apenas um dos tipos de variáveis. Existem
ainda os tipos que armazenam dados numéricos inteiros e flutuantes, int() e float(), respectivamente.
Os tipos binários ou booleanos, bool, que podem receber valores True ou False.
Existem tipos que armazenam sequência de dados, são as listas, sets, tuplas e dicionários. Cada
tipo de variável será detalhada a seguir.

1.2 Tipos de dados

Uma variável é um local nomeado usado para armazenar dados na memória [0]. O nome dado
a uma variável identifica o local físico em que o dado está, ou será, armazenado. E seu valor
pode ser atualizado a qualquer momento. A variável pode armazenar diferentes tipos de dados,
1.2 Tipos de dados 9

dados numéricos, texto, sequências e lógicos. A seguir temos exemplos destes tipos no Listing ??.
Nomeamos a variável e atribuímos um valor a ela utilizando o sinal de igual. Diferentemente de
outras linguagens, em Python não há a necessidade de especificar o tipo da variável, ou declará-la
antes utilizar.
Para visualizar o tipo da variável, utilizamos a função type() que retorna o tipo da variável.
Alguns outros exemplos podem ser vistos no site www.w3schools.com [0].

Código 1.6: Tipos de Dados 1

# Inteiro
x = 1
print(x, type(x))

# Flutuante
y = 2.555
print(y, type(y))

# Complexo
z = 3+5j
print(z, type(z))

# String
w = "bioinformática"
print(w, type(w))

# Lista
j = [10, 11, 55]
print(j, type(j))

# Tupla
k = (6,8,9)
print(k, type(k))

# Dicionário
m = {"A":"Adenina", "C":"Citosina"}
print(m, type(m))

# Lógico
n = True
print(n, type(n))

Os tipos numéricos podem ser inteiro, real ou complexo. Note que no tipo complexo a parte
imaginária é acompanhado do j, não confunda esta letra com o nome da variável da lista. São coisas
distintas com o mesmo sinal gráfico. Na representação do número complexo o j está "grudado"no
número. Portanto, caso o módulo de "j"seja igual a 1, deve-se escrever 1j, e não apenas j, uma vez
apenas j poderá ser o nome dado a uma variável. Conforme dito anteriormente, o valor de uma
variável pode ser alterado a qualquer momento e para tipos diferentes de dados.

Código 1.7: Tipos de Dados 2

# Valor inteiro atribuído àvariável "x"
x = 22
print('x = ', x)

# Atribui outro valor inteiro a "x"

x = 14
print('x = ', x)

# Atribui um valor flutuante a "x"

x = 3.14159
 10 Capítulo 1. A Linguagem Python e a Programação

print('x = ', x)

# Atribui um texto a "x"

x = 'hsa-mir-21'
print('x = ', x)

# Atribui um valor lógico a "x"

x = True
print('x = ', x)

Operações com dados numéricos serão vistos em Operadores Aritméticos. Vamos trabalhar e
apresentar algumas funções para os outros tipos de variáveis. As principais funções envolvendo
essas variáveis serão abordadas neste documento, porém, outras funções podem ser vistas neste link
http://www.codeskulptor.org/docs.html [0].
As variáveis podem ainda ser classificadas como local ou global. Mas isso será melhor analisado
no capítulo sobre funções.

1.2.1 Tipo string

.
Conforme visto anteriormente, valores tipo texto devem estar entre aspas simples ou duplas.
Para exemplificar, trabalharemos com duas pequena sequências nucleotídicas, mas os métodos
podem ser aplicados a qualquer texto.

Código 1.8: Trabalhando com strings

# Declaração e atribuição de valores às variáveis seq1 e seq2
seq1 = 'actgaacaggtttaattg'
seq2 = 'ctgcccGGaattgg'

print('seq1: ', seq1)

print('seq2: ', seq2)

# Tamanho da sequência
print('Tamanho da seq1: ', len(seq1))
print('Tamanho da seq2: ', len(seq2))

# Transforma todos os caracteres em caixa alta

print('seq1 caixa alta:', seq1.upper())
print('seq2 caixa alta:', seq2.upper())

# Transforma todos os caracteres em caixa baixa

print('seq1 caixa baixa:', seq1.lower())
print('seq2 caixa baixa:', seq2.lower())

# Encontra o primeiro caractere e substitui pelo segundo

print('Substitui "G" por "g" na seq2', seq2.replace('G','g'))

# Conta os caracteres da sequência

print('Quantos "a" na seq1: ', seq1.count('a'))
print('Quantos "tg" na seq2: ', seq2.count('tg'))

# Note que o valor original não éalterado

print('seq1: ', seq1)
print('seq2: ', seq2)

Nenhuma destas funções alteram o valor original das variáveis. Permitindo que sejam ma-
nipuladas, porém, sem que se perca o dado original. Vale lembra que algumas vezes deseja-se
alterar o valor original, sendo necessária a atualização da variável. Caso quisessemos contabilizar o
1.2 Tipos de dados 11

conteúdo GC% das duas sequências, seria necessário alterar os "GG"para "gg"na seq2. No exemplo
abaixo vamos utilizar o método lower(), e algumas operações aritméticas.

Código 1.9: Trabalhando com strings, conteúdo GC%

# Declaração e atribuição de valores às variáveis seq1 e seq2
seq1 = 'actgaacaggtttaattg'
seq2 = 'ctgcccGGaattgg'
print('seq1: ', seq1)
print('seq2: ', seq2)

# Atualização da variável seq2

seq2 = seq2.lower()
print('seq2: ', seq2)

# Calcula o conteúdo GC%. Quantidade de GC pelo total de bases

seq1_t = len(seq1)
seq1_GC = 100*( seq1.count('g') + seq1.count('c') )/seq1_t
print('GC% da seq1: ', seq1_GC)

seq2_t = len(seq2)
seq2_GC = 100*( seq2.count('g') + seq2.count('c') )/seq2_t
print('GC% da seq2: ', seq2_GC)

Os tipos string também podem ser concatenados com o sinal "+". Pode-se unir duas ou mais
strings "somando-as".

Código 1.10: Concatenação de strings

# Declaração e atribuição de valores às variáveis seq1 e seq2
seq1 = 'actgaacaggtttaattg'
seq2 = 'ctgcccGGaattgg'
print('seq1: ', seq1)
print('seq2: ', seq2)

# Concatenar as duas sequancias em uma única variável

seq = seq1 + seq2
print(seq)

# Note que a ordem das strings altera o resultado

seq = seq2 + seq1
print(seq)

A variável string, assim como as sequências ordenas (arrays), tem os elementos que a compõem
relacionados a sua posição. Por exemplo, o primeiro elemento possui índice 0, o segundo indice 1 e
assim sucessivamente. Ou ainda, o último elemento possui índice -1, o penúltimo -2 etc. O acesso
a cada elemento, ou range de elementos, é feito através dos colchetes. Para selecionar apenas
uma parte da string, ou qualquer outra sequência ordenada como listas, basta inserir o intervalo de
índices dentro dos colchetes. O primeiro índice é adcionado e o último não.

Código 1.11: Seleção e slice de elementos em strings

# Declaração e atribuição de valor àvariável seq
seq = 'ctgcccGGaattgg'

# O primeiro elemento da seq

print('pos 0: ', seq[0])

# O segundo elemento da seq

print('pos 1: ', seq[1])
 12 Capítulo 1. A Linguagem Python e a Programação

Figura 1.1: Índices de cada caracter. [0]

# O sétimo elemento da seq

print('pos 6: ', seq[6])

# O úlitmo elemento
print('pos -1: ', seq[-1])

# O penúlitmo elemento
print('pos -2: ', seq[-2])

# SLICE
# Do segundo elemento ao quinto
print('seq[2:5]: ', seq[2:5])

# Do quinto ao último (sem incluir o último)

print('seq[5:-1]: ', seq[5:-1])

# Do quinto ao último (incluir o último)

print('seq[5:]: ', seq[5:])

# Do elemento -7 elemento ao último

print('seq[-7:-1]: ', seq[-7:-1])

É possível, com o operador in determinar se determinado elemento ou sequência está presente

na string.

Código 1.12: Operador in na strings

# Declaração e atribuição de valor àvariável seq
seq = 'atgctgcccGGaattgg'

# "t" está na sequência?

print('há "t"?: ', 't' in seq)

# "atg" está na sequência?

print('há "atg"?: ', 'atg' in seq)

# "u" está na sequência?

print('há "u"?: ', 'u' in seq)

# "u" não está na sequência?

print('não há "u"?: ', 'u' not in seq)

1.2.2 Tipo list

Além da função len() já vista em strings, a seleção de determinado elemento ou parte da string com
o slice, e a utilização do operador in, estas outras funções podem ser aplicadas às listas. É importante
 1.2 Tipos de dados 13

lembrar que em Python uma lista pode ter elementos de diferentes tipos, como numéricos, textuais,
lógicos ou ainda outras listas, Listing 1.13.
Um elemento de uma lista pode ser uma outra lista, possibilitando a criação de uma matriz, ou
array com dimensão m × n. O tipo tuple, ou tupla, é basicamente uma lista em os elementos não
podem ser alterados. Já os tipos set() são conjuntos não ordenados de dados. Seus elementos são
acessados através do loop for, que será visto a seguir.
Código 1.13: Métodos aplicados à listas
# Declaração e atribuição de valor àvariável seq
codons = ['AUG', 'UCA', 'CGC', 'UAA', 'UAG']

# Tamanho da lista
print('len: ', len(codons))

# Inserir outro elemento àlista

codons.append('ACC')
print('codons: ', codons)

# Inserir elemento em posição específica

codons.append(2,'ACC')
print('codons: ', codons)

# Remover determinado elemento

codons.remove('AUG')
print('codons: ', codons)

# Remove específico índice

codons.pop(3)
print('codons: ', codons)

# Remove último elemento

codons.pop()
print('codons: ', codons)

# Inverter a posição dos elementos

codons.reverse()
print('codons: ', codons)

# Ordenar os elementos
codons.sort()
print('codons: ', codons)

# Lista de Listas (array)

array = [[3,5,8], [5,5,5], [7,12,9]]

1.2.3 Tipo dictionary

Listas e tuplas são sequências ordenadas pelos índices da posição de cada elemento, ou seja,
pode-se acessar determinado elemento a partir de um número interiro relacionado ao elemento.
Já nos dicionários os elementos são relacionados a palavras-chave determinadas na contrução do
dicionário. O dicionário é definido por "", o elemento e a palavra-chave são separadas por ":".
Código 1.14: Dicionários
# Declaração do dicionário
codonAmino = {'UUU':'Fenilalanina',
'UCA':'Serina',
'UCG':'Serina',
'UUA':'Leucina',
 14 Capítulo 1. A Linguagem Python e a Programação

'UUG':'Leucina',
'GAU':'Ácido aspártico',
'GAC':'Ácido aspártico',
'UAA':'Stop'}

# Requisitando os valores a partir da palavra-chave

print('Códon UAA é: ', codonAmino['UAA'])
print('Códon UUG é: ', codonAmino['UUG'])
print('Códon GAU é: ', codonAmino['GAU'])

# Lista de items. Cada item éuma tupla (valor,palavra-chave)

print(codonAmino.items())

# Lista de palavras-chave
print(codonAmino.keys())

# Lista dos valores, ou seja, elementos

print(codonAmino.values())

# Tamanho do dicionário
print( len(codonAmino.values() )

1.2.4 Tranformando Dados

Muitas vezes precisamos transformar uma variável de determinado tipo em outro tipo. Por exemplo,
um texto em numérico. Lembre-se que uma forma de "comunicação"entre um usuário e seu script
é através da função input(), mas esta função recebe qualquer valor como texto. Para manipular
alguma entrada numéricamente, será necessário converter a entrada para float, por exemplo.

Código 1.15: Convertendo dados

# Entrada de dados através da função input()
c = input('Digite a temperatura em C: ')

# Tipo da variável "c"

print('tipo "c": ', type(c))

# Converter "c" em float

c = float(c)
print('tipo "c" após conversão: ', type(c))
# Calcular a temperatura em Kelvin
k = 273.15 + c

# O método format() insere valores não textuais àstring

# Os valores de c e k são inseridos na ordem em que
# aparecem da esquerda para a direita.
print('{} graus Celsius => {} Kelvin'.format(c, k))

Outras funções de conversão de tipos são: int(), complex(), str(), bool(), list(), tuple(), dict().
Que convertem os valores em inteiro, complexo, string, lógico, lista, tupla e dicionário, respectiva-
mente.

1.3 Operadores Aritméticos

A resolução das expressões aritméticas segue a mesma ordem prioritária da matemática. Primeira-
mente, resolve-se o que está entre os parênteses mais internos. Então as operações de exponenciação,
multiplicação, divisão, soma e subtração são executadas nesta ordem. A multiplicação e a divisão
estão no mesmo nível de prioridade, porém, se ambas aparecerem, o conflito de prioridade é
 1.4 Operadores Relacionais 15

resolvido pela operação mais à esquerda. A mesma lógica se aplica à adição e subtração. Para
lembrar dessa ordem, pode-se lembrar da sigla PEMDAS.

P Parênteses, então
E Exponenciação, então
MD Multiplicação e Divisão, esquerda para a direita, então
AS Adição e Subtração, esquerda para a direita

Os operadores aritméticos são representados em python da seguinte maneira:

Operador Nome Exemplo Resultado

+ Adição 11 + 3 14
- Subtração 11 − 3 8
* Multiplicação 11 ∗ 3 33
/ Divisão 11/3 3.666666665
// Parte inteira da divisão 11//3 3
% Resto da Divisão (Módulo) 11%3 2
** Exponenciação 11 ∗ ∗3 1331

Para visualizar o resultado, usa-se a função print (colocar referência do capítulo), que terá como
argumento o que se deseja ver na tela.

Código 1.16: Operadores aritméticos

print('Adição:', 11+3 )
print('Subtração: ', 11-3 )
print('Multiplicação: ', 11*3 )
print('Divisão: ', 11/3 )
print('Parte Inteira da Divisão: ', 11//3 )
print('Resto da Divisão:', 11%3 )
print('Exponenciação: ', 11**3 )

Exercício: Dada a eq. que descreve o movimento de um ponto material. Utilizando python,
calcule a distância percorrida pelo móvel para t = 20s.

s = 20 + 12 × t + 4 × t 2 (1.1)

Monte um script em que o valor de t é inserido pelo usuário através da função input().

1.4 Operadores Relacionais

Esses operadores são utilizados para comparar dois valores. Por exemplo, saber se um valor é
igual a outro. O retorno da operação são valores do tipo booleano, ou seja, verdadeiro ou falso. Os
operadores relacionais são os seguintes:

Operador Nome Exemplo Resultado

== Igual a 11 == 3 False
!= Diferente de 11 ! = 3 True
> Maior que 11 > 3 True
>= Maior ou igual a 11 >= 3 True
< Menor que 11 < 3 False
<= Menor ou igual a 11 <= 3 False

Para melhor visualizar, novamente usa-se a função print.

 16 Capítulo 1. A Linguagem Python e a Programação

Código 1.17: Operadores relacionais

print('Igual a: ', 11 == 3 )
print('Diferente de: ', 11 != 3 )
print('Maior que: ', 11 > 3 )
print('Maior ou igual a: ', 11 >= 3 )
print('Menor que: ', 11 < 3 )
print('Menor ou igual a: ', 11 <= 3 )

1.5 Operadores Lógicos

Operadores lógicos comparam dois valores lógicos, ou seja, valores booleanos verdadeiro ou falso.
São utilizados para combinar expressões lógicas. São principalmente utilizados em instruções
condicionais. Os operadores lógicos são:

Operador Descrição Exemplo Resultado

and Retorna verdadeiro apenas se os dois True and True True
valores forem verdadeiros
or Retorna verdadeiro se pelo menos um True or False True
dos valores for verdadeiro
not Inverte o valor. Se o valor for verda- not True False
deiro inverte para falso e vice-versa

Exemplificando em python, tem-se o seguinte:

Código 1.18: Expressões lógicas

print('True and True: ', True )
print('True and False: ', False)
print('False and True: ', False )
print('False and False: ', False )

print('True or True: ', True )

print('True or False: ', True)
print('False or True: ', True)
print('False or False: ', False )

print('not True:', False)

print('not False: ', True )

Exemplo: Qual o resultado das expressões abaixo? Tente resolver, apenas use python para
conferir sua resposta.
1. (7 > 3) and (5 > 2)
2. (3 == 2) or (1 > 0)
3. True and (9 <= 9) and (not False)
4. (0 a0 == 0 a0 )
5. (0 G0 == 0 g0 )

1.6 Estrutura Condicional

A estrutura condicional é composta por pelo menos um teste lógico. Caso o valor de teste seja
verdadeiro, ele executa um comando específico, caso contrário, executa outro comando. Por
exemplo:

Código 1.19: Estrutra Condicional

1.6 Estrutura Condicional 17

a = 7
b = 3

if a > b:
print('a é maior que b')
else:
print('a não é maior que b')
# O código acima deve retornar 'a émaior que b'

a = 1
b = 5

if a > b:
print('a é maior que b')
else:
print('a não é maior que b')
# O código acima deve retornar 'a não émaior que b'

Podemos montar a mesma estrutura utilizando a função input(), para criar uma interação com
o usuário. Criamos duas entradas input. Lembrando que essa função lê a entrada como string,
portanto, transformamos em int ou float.
Código 1.20: Estrutra Condicional 2
a = input('Digite um número: ')
b = input('Digite outro número: ')

a = int(a)
b = int(b)

if a > b:
print('a é maior que b')
else:
print('a não é maior que b')

Uma mesma estrutura também pode combinar mais uma comparação usando elif. Por exemplo:
Código 1.21: Estrutra Condicional 3
a = input('Digite um número: ')
b = input('Digite outro número: ')

a = int(a)
b = int(b)

if a > b:
print('a é maior que b')
elif b > a:
print('b é maior que a')
else:
print('a e b são iguais')

Exercícios resolvidos: Utilizando a função input, projete uma estrutura condicional que
imprima o nome da base nitrogenada relacionada à letra que o usuário digitar. Lembre-se que:
Símbolo Nome
a Adenina
c Citosina
g Guanina
t Timina
u Uracila
18 Capítulo 1. A Linguagem Python e a Programação

Resolução:

Código 1.22: Estrutra Condicional 4

base = input('Digite o símbolo da base: ')

if base == 'a':
print('Adenina')
elif base == 'c':
print('Citosina')
elif base == 'g':
print('Guanina')
elif base == 't':
print('Timina')
elif base == 'u':
print('Uracila')
else:
print('Símbolo não reconhecido')

Note que o código não é sensível a letras maiúsculas. Para A, C, G, T e U sejam reconhecidas,
deve-se também inserir essas possibilidades nas condições. Com o operador lógico or faz-se o
seguinte:

Código 1.23: Estrutra Condicional e operador lógico

base = input('Digite o símbolo da base: ')

if base == 'a' or base == 'A':

print('Adenina')
elif base == 'c' or base == 'C':
print('Citosina')
elif base == 'g' or base == 'G':
print('Guanina')
elif base == 't' or base == 'T':
print('Timina')
elif base == 'u' or base == 'U':
print('Uracila')
else:
print('Símbolo não reconhecido')

Outra maneira de se fazer isso é transformando a entrada do usuário em letra minúscula com o
método lower(). Dessa forma basta comparar apenas com minúsculas.

Código 1.24: Estrutra Condicional e lower()

base = input('Digite o símbolo da base: ')
base = base.lower()

if base == 'a':
print('Adenina')
elif base == 'c':
print('Citosina')
elif base == 'g':
print('Guanina')
elif base == 't':
print('Timina')
elif base == 'u':
print('Uracila')
else:
print('Símbolo não reconhecido')
 1.7 Estruturas de Repetição 19

O método lower() transforma toda a string em minúsculas. Já o método upper() transforma

todas as strings em maiúsculas. Estes métodos estão listados no capítulo sobre strings.

Exercício proposto Projete um script que retorne a base complementar da inserida pelo usuário.
Use como esqueleto um dos exemplos anteriores.

1.7 Estruturas de Repetição

1.7.1 loop while
Esta estrutura de repetição executa determinado comando enquanto determinada condição for
verdadeira. Para isso geralmente utilizamos uma variável auxiliar para controlar o número de
repetições. Por exemplo:

Código 1.25: Loop While 1

i = 0
while i < 5:
print('executou i =' , i)
i = i+1

A cada nova iteração o valor de i é atualizado somando-se um ao valor anterior. E quando i for
igual a 5, a condição i<5 será falsa, interrompendo assim o loop.
Dentro do loop é possível inserir a estrutura if... else. Caso queira-se imprimir apenas os valores
pares enquanto a condição seja satisfeita, pode-se fazer o seguinte:

Código 1.26: Loop While 2

i = 0
while i < 20:
if i % 2 == 0:
print(i)
i = i + 1

Lembrando que um número pode ser considerado par caso o resto de sua divisão por 2 seja
igual zero.
Caso exista alguma condição em que o loop deva ser encerrado antes, pode-se utilizar o
comando break. Por exemplo, caso queira-se encerrar o loop se o valor de i for igual a 11. Faz-se o
seguinte:

Código 1.27: Loop While 3

i = 0
while i < 20:
if i % 2 == 0:
print(i)
if i == 11:
break
i = i + 1

Pode-se também utilizar o operador continue. Este operador interrompe a iteração atual e
continua com a próxima iteração. Suponha que se queira mostrar os números de um a cinco com
exceção do número três. Pode-se fazer o seguinte:

Código 1.28: Loop While 4

i = 0
while i < 5:
i = i + 1
if i == 3:
20 Capítulo 1. A Linguagem Python e a Programação

continue
print(i)

É possível acessar todos os elementos de uma lista ou caracteres de uma string com o loop
while. Para isso é necessário saber o tamanho da lista ou string, ou seja, quantos elementos ela
possui. Lembre-se que é possível acessar cada elemento de uma sequência ordenada indicando o
seu índice. Caso tenha dúvidas quanto a isso, volte ao capítulo sobre strings ou listas.

Código 1.29: Loop While 5

seq='acgtttggacaca'
i = 0
while i < len(seq):
print(seq[i])
i=i+1

Utilizando como base o exemplo XXXX, pode-se com o loop while solicitar a entrada de uma
sequência para o usuário, e não apenas uma base. Então retornar a base complementar. Para melhor
visualizar a sequência complementar, na função print insira o argumento end=”.

Código 1.30: Loop While 5

seq = input('Digite uma sequência de DNA: ')
seq = seq.lower()

i = 0
while i < len(seq):
if seq[i] == 'a':
print('t', end='')
elif seq[i] == 'c':
print('g', end='')
elif seq[i] == 'g':
print('c', end='')
elif seq[i] == 't':
print('a', end='')
else:
print('N', end='')
i += 1

Muitas vezes sequências de bancos de dados possuem um caractere que indica o fim da
sequência, por exemplo, “acgggttaatcct/”. A barra indica o fim da sequência. Se esse for o caso,
ao invés de utilizar a função len(), pode-se projetar a condição do while para valores diferentes do
caracter terminador, no caso a barra “/”.

Código 1.31: Loop While 6

seq = input('Digite uma sequência de DNA: ')
seq = seq.lower()

i = 0
while seq[i] != '/':
if seq[i] == 'a':
print('t', end='')
elif seq[i] == 'c':
print('g', end='')
elif seq[i] == 'g':
print('c', end='')
elif seq[i] == 't':
print('a', end='')
else:
print('N', end='')
1.7 Estruturas de Repetição 21

i+=1

Uma alternativa é utilizar o break quando o caractere terminador aparecer. Neste caso, o while
deve repetir indefinidamente, até que o loop seja interrompido pelo break.

Código 1.32: Loop While 7

seq = input('Digite uma sequência de DNA: ')
seq = seq.lower()

i = 0
while True:
if seq[i] == 'a':
print('t', end='')
elif seq[i] == 'c':
print('g', end='')
elif seq[i] == 'g':
print('c', end='')
elif seq[i] == 't':
print('a', end='')
elif seq[i] == '/':
break
else:
print('N', end='')
i+=1

Nestes dois últimos casos é importante que se tenha certeza que o caractere terminador esteja na
sequência, caso contrário o loop while será infinito. Uma maneira de ser verificar se um determinado
caractere está em determinada sequência é utilizando o operador not in.

Código 1.33: Loop While 8

seq = input('Digite uma sequência de DNA: ')
seq = seq.lower()

# variável auxiliar, avalia se deve-se entrar no loop while

barraPresente = True

# Teste de presença do caracter terminador.

# Caso não o caractere não esteja na sequência,
# o valor da variável auxiliar éalterado para False.
if '/' not in seq:
barraPresente = False
print('Não foi encotrado o caractere terminador!')
print('Processo Finalizado!')

i = 0
while barraPresente:
if seq[i] == 'a':
print('t', end='')
elif seq[i] == 'c':
print('g', end='')
elif seq[i] == 'g':
print('c', end='')
elif seq[i] == 't':
print('a', end='')
elif seq[i] == '/':
break
else:
print('N', end='')
 22 Capítulo 1. A Linguagem Python e a Programação

Exercício proposto: Tomando-se como base o exercício anterior. Projete um tradutor de bases
complementares de DNA que solicite sequências ao usuário indefinidamente até que o usuário
escreva FIM. A Dica: utilize loop while com a função input dentro.

1.7.2 Loop For

Semelhante ao loop while, o loop for também é uma estrutura de repetição. Diferentemente de
outras linguagens, como Java e C++, em Python o loop for é utilizado sobre sequências, sejam
elas strings, listas, tuplas ou set. A estrutura for irá varrer termo a termo da sequência, sem a
necessidade de projetar uma condição de repetição como no loop while.

Código 1.34: Loop For 1

seq = 'acgtttggacaca'
for base in seq:
print(base, end='')

Note que não há necessidade da criação da variável auxiliar “i” para contar a quantidade de
repetições e acessar os itens da sequência pelo índice. Os elementos da sequência são armazenados,
neste exemplo, na variável base. A cada nova iteração o valor da variável base é atualizado. O
nome dessa variável pode ser qualquer um, como x, i, j etc. Substituindo no exemplo XXX o while
por for, temos:

Código 1.35: Loop For 2

seq = input('Digite uma sequência de DNA: ')
seq = seq.lower()

for base in seq:

if base == 'a':
print('t', end='')
elif base == 'c':
print('g', end='')
elif base == 'g':
print('c', end='')
elif base == 't':
print('a', end='')
else:
print('N', end='')

Também é possível utilizar o operador break, da mesma forma como foi utilizado no loop while.
Assim como o operador continue. Neste exemplo, quando nenhum caractere for reconhecido pelo
programa, o código irá pular o caractere ao invés de imprimir “N”.

Código 1.36: Loop For 3

seq = input('Digite uma sequência de DNA: ')
seq = seq.lower()

for base in seq:

if base == 'a':
print('t', end='')
elif base == 'c':
print('g', end='')
elif base == 'g':
print('c', end='')
elif base == 't':
print('a', end='')
elif base == '/':
break
1.7 Estruturas de Repetição 23

else:
continue

A entrada de dados de um programa pode ser feita pela função input() ou por um arquivo fasta,
por exemplo.
Para isso utilizamos a função open(). E armazenamos o conteúdo do arquivo em uma variável.
 2. Tópicos Avançados

G UILHERME TABORDA R IBAS

2.1 Criando Funções

Imagine que em seu código você precise efetuar determinado processo mais de uma vez. Pense
num script que calcule a temperatura em Kelvin e Fahrenheit para seguidas entradas do usuário,
conforme o código abaixo.

Código 2.1: Código repetitivo

# Entrada da temperatura em Celsius
c = input('Digite a temperatura em Celsius: ')

# Converte a variável "c" em float

c = float(c)

# Calcula a temperatura em Kelvin e Fahrenheit

k = 273.15 + c
f = c*9/5 + 32
print('{}C equivale a {}F e {}K.'.format(c, f, k))

# O mesmo processo para novos inputs

c = input('Digite a temperatura em Celsius: ')
c = float(c)
k = 273.15 + c
f = c*9/5 + 32
print('{}C equivale a {}F e {}K.'.format(c, f, k))

Caso quiséssemos inserir novos inputs, teríamos que repetir o processo todas as vezes. Se
o algoritmo fosse maior que este de conversão de temperatura seria exaustivo repetí-lo. E prici-
palmente, caso tivéssemos que alterar algo na fórmula do cálculo, teríamos que modificar todo o
código repetidas vezes. Por isso, montar uma função é a forma mais fácil e mais organizada de
estruturar seu código.
26 Capítulo 2. Tópicos Avançados

Uma função é declarada pelo operador def, seguido do nome da função e os parâmetro de
entrada. Perceba que igualmente aos operadores if, else, elif, while e for, a definição é concluída
com ":". Vamos ao exemplo de conversão de temperaturas.

Código 2.2: Criação de função

# Definição da função
# Composta por def, nome, argumento, ":" e corpo
def converteTemperatura(c):
c = float(c)
k = 273.15 + c
f = c*9/5 + 32
print('{}C equivale a {}F e {}K.'.format(c, f, k))

# Entrada da temperatura em Celsius

entradaCelsius = input('Digite a temperatura em Celsius: ')

# Agora basta chamar a função com o argumento

converteTemperatura(entradaCelsius)

entradaCelsius = input('Digite a temperatura em Celsius: ')

converteTemperatura(entradaCelsius)

entradaCelsius = input('Digite a temperatura em Celsius: ')

converteTemperatura(entradaCelsius)

entradaCelsius = input('Digite a temperatura em Celsius: ')

converteTemperatura(entradaCelsius)

Veja que o código é muito mais limpo, fácil de entender. E caso a fórmula precise de ajuste,
basta alterar a função uma única vez. A função pode ter mais de um argumento ou nenhum,
depende do que se deseja fazer. A função também pode ou não retornar algum resultado. Abaixo
um exemplo sem argumento, com vários argumentos e outro com a função retornando um valor.

Código 2.3: Função sem argumento

# Definição da função
def converteTemperatura():
c = input('Digite a temperatura em Celsius: ')
c = float(c)
k = 273.15 + c
f = c*9/5 + 32
print('{}C equivale a {}F e {}K.'.format(c, f, k))

# Chamadas da função
converteTemperatura()
converteTemperatura()
converteTemperatura()

Código 2.4: Criação de função com mais de um argumento

# Definição da função
def converteTemperatura(c, l):
c = float(c)
k = 273.15 + c
f = c*9/5 + 32
print('Leitura: ', l)
print('{}C equivale a {}F e {}K.'.format(c, f, k))

# Entrada da temperatura em Celsius

entradaCelsius = input('Digite a temperatura em Celsius: ')
 2.2 Importando bibliotecas e pacotes 27

leitura = input('Digite o número da leitura: ')

converteTemperatura(entradaCelsius, leitura)

entradaCelsius = input('Digite a temperatura em Celsius: ')

leitura = input('Digite o número da leitura: ')
converteTemperatura(entradaCelsius, leitura)

Código 2.5: Criação de função com return

# Definição da função
def converteTemperatura(c):
c = float(c)
k = 273.15 + c
return k
# Entrada da temperatura em Celsius
entradaCelsius = input('Digite a temperatura em Celsius: ')

# O valor retornado pela função

# pode ser armazenado em outra variável
saidaKelvin = converteTemperatura(entradaCelsius)
print(entradaCelsius,'C', 'igual a', saidaKelvin, 'K')
# Ou pode ser diretamente passado como argumento da função print
print(entradaCelsius,'C', 'igual a',
converteTemperatura(entradaCelsius), 'K')

2.1.1 Variável local vs global

Agora que sabemos construir uma função, fica mais fácil diferenciar uma variável global e uma
variável local. As variáveis definidas dentro de uma função têm um escopo local e as definidas fora
têm um escopo global. Isso significa que variáveis locais podem ser acessadas somente dentro da
função em que são declaradas, enquanto variáveis globais podem ser acessadas em todo o corpo do
programa por todas as funções. Quando você chama uma função, as variáveis declaradas dentro
dela são colocadas no escopo.

Código 2.6: Escopo da variável global vs local

# Declaração da variável "c" de escopo global
c = 44
def converteTemperatura(c):
# Variável "c" de escopo local
c = c + 6
print('Dentro da função c = ', c)
converteTemperatura(c)
print('Fora da função c = ', c)

2.2 Importando bibliotecas e pacotes

Muitas funcionalidades em Python são organizadas em módulos, ou seja, bibliotecas que podem
ser utilizada por referência. Como por exemplo: math, time, random e re. Cada uma com métodos
que podem ser tuilizados em seu código apenas importando-os com o operador import.

Código 2.7: Módulo math

# importando o módulo math
import math

# Alguns métodos desse módulo

# Fatorial 4! = 4x3x2x1
28 Capítulo 2. Tópicos Avançados

print('4! = ', math.factorial(4))

#Raiz Quadrada: raiz(16) = 4

print('raiz(16) = ', math.sqrt(16))

# Exponenciação
print('4^7 = ', math.pow(4,7))

# Exponenciação base neperiana

print('e^4 = ', math.exp(4))

# Neperiano e = 2.7182...
print('e = ', math.e)

# pi = 3.1415...
print('pi = ', math.pi)

# Seno, cosseno e tangente

print('sin(pi/4), cos(pi/4), tan(pi/4): ',
math.sin(math.pi/4), math.cos(math.pi/4),
math.tan(math.pi/4))

# Logaritmo
print('log(10000, 10) = ', math.log(10000, 10))

Muitos outros métodos do módulo math são encontradas na documentação do python

https://docs.python.org/3/library/math.html.
Outro pacote muitas vezes utilizado é o random. Em que possui métodos de geração de números
aleatórios.
Código 2.8: Módulo random
# importando o módulo random
import random

# Alguns métodos desse módulo

# Número inteiro entre um intervalo randint
print('n entre 0 e 10 = ', random.randint(0, 10))
print('n entre -20 e 10 = ', random.randint(-20, 10))

# Número inteiro entre um intervalo com step randrange

print('n entre 0 e 10 = ', random.randrange(0, 10, 5))
print('n entre -20 e 10 = ', random.randrange(-20, 10, 10))

# Escolhe aleatoriamente um elemento de uma lista

lista = ["A", "G", "T", "U", "C", "5'", "3'"]
print(random.choice(lista))

# Embaralha os elementos de uma lista

lista = ["A", "G", "T", "U", "C", "5'", "3'"]
random.shuffle(lista)
print(lista)

Caso necessite, durante a execução o código, do tempo exato, pode-se utilizar o múdulo time.
Código 2.9: Módulo time intervalo de tempo
import time
# intervalo de tempo de uma execução
t1 = time.time()
time.sleep(5) # pausa a execução em 5 s
print('t2 - t1 = ', time.time()-t1, 'segundos')
 2.3 Criando Gráficos com Matplotlib 29

Código 2.10: Módulo time

# importando o módulo random
# Hora atual GMT
t = time.time()
t = time.gmtime(t)
print('Tempo agora GMT: ', t)
print('Hora GMT: ', t.tm_hour, t.tm_min, t.tm_sec)

# Hora atual local

t = time.time()
t = time.localtime(t)
print('Tempo agora local: ', t)
print('Hora local: ', t.tm_hour, t.tm_min, t.tm_sec)

Outro módulo muito usado em bioinformática é o regex, nesta apostila ele tem um tópico
próprio para ele: Expressões Regulares Regex.
Além dos módulos nativos da linguagem Python, existem pacotes de terceiros que podem ser
instalados e usados da mesma maneira, com o operador import. A seguir aprenderemos a utilizar
o pacote Pandas para manipulação de dados, Scypi para estatística, Matplotlib para gráficos e
Biopython para aplicações em bioinformática.

2.3 Criando Gráficos com Matplotlib

O principal pacote para visualização de gráficos em Python é o Matplotlib. Existem uma vasta
documentação e inúmeros exemplos em seu site.
https://matplotlib.org
Com os seguintes dados do eixo x = [−2, −1, 0, 1, 2, 3, 4, 5] e do eixo y = [0.25, 0.5, 1, 2, 4, 8, 16, 32],
podemos rapidamente plotar o gráfico da seguinte maneira:

Código 2.11: Matplotlib - plot 1

# Importa a biblioteca e a nomeia como plt
import matplotlib.pyplot as plt

# Chama o método plot() que cria o gráfico

# com dados x, y como argumentos
plt.plot([-2, -1, 0, 1, 2, 3, 4, 5],
[0.25, 0.5, 1, 2, 4, 8, 16, 32])

# Mostra o gráfico
plt.show()

A saída do código acima é a Figura 2.1. Note que não há título, nomes dos eixos nem linhas
de grade. No próximo script vamos inserir essas informações e o estilo da linha. Partiremos do
princípio de que o comando de importação do pacote foi executado.
30 Capítulo 2. Tópicos Avançados

Figura 2.1: Gráfico Matplotlib 1

Código 2.12: Matplotlib - plot 2

# Chama o método plot() que cria o gráfico
# com dados x,y e estilo como argumentos
plt.plot([-2, -1, 0, 1, 2, 3, 4, 5],
[0.25, 0.5, 1, 2, 4, 8, 16, 32], '--')

# Insere título
plt.title('Crescimento em função do tempo')
# Insere o nome do eixo x
plt.xlabel('Tempo (h)')
# Insere o nome do eixo y
plt.ylabel('População (milhões)')
# Insere o grid
plt.grid(True) # em apenas um dos eixos plt.grid(True, axis='x')
# Mostra o gráfico
plt.show()
2.3 Criando Gráficos com Matplotlib 31

Figura 2.2: Gráfico Matplotlib 2

O método plot() tem a seguinte ordem de argumentos: o eixo x, o eixo y e o estilo da linha.
Numa mesma função pode-se inserir mais de uma sequência de dados nesta mesma ordem. Suponha
que queiramos plotar o crescimento de três espécies diferentes.

Código 2.13: Matplotlib - plot 3

# Chama a função plot() com várias sequências
plt.plot([-2, -1, 0, 1, 2, 3, 4, 5],
[0.25, 0.5, 1, 2, 4, 8, 16, 32], '*-.',

[-2, -1, 0, 1, 2, 3, 4, 5],

[0.16, 0.4, 1.0, 2.5, 6.2, 15.6, 39.0, 97.6], 'r^-',

[-2, -1, 0, 1, 2, 3, 4, 5],

[-30, -15, 0, 15, 30, 45, 60, 75], 'o:')
plt.title('Crescimento em função do tempo')
plt.xlabel('Tempo (h)')
plt.ylabel('População (milhões)')
plt.grid(True, axis='x')
plt.show()
 32 Capítulo 2. Tópicos Avançados

Figura 2.3: Gráfico Matplotlib 3

É possível com os métodos bar, pie, hist, scatter plotar diversos outros tipos de gráficos. Porém,
existem algumas maneiras muito mais simples e fáceis de utilizar o Matplotlib. Com Pandas e
Seaborn, por exemplo, que são pacotes que iremos ver a seguir.

2.4 Manipulando dados com Pandas

A manipulação de dados com Pandas, assim como a visualização de gráficos é mais interativa e
de fácil com a IDE Jupyter. No primeiro capítulo ensinamos como instalar e utilizar esse pacote.
Neste capítulo nós apresentaremos algumas das principais funções do Pandas que podem facilitar a
filtragem de dados estatísticos de forma simples e rápida.
Nos primeiros exemplos nós vamos trabalhar com dados da flor de íris, vulgarmennte connhe-
cida como lírio [0]. Os dados apresentam comprimento e largura das pétalas e sépalas de diversas
amostras de flores (Figura 2.4). Três espécies de íris são analisadas: a setosa, versicolor e virginica.
Os dados são importados de um arquivo "iris.csv". No Jupyter os dados são apresentados conforme
Figura 2.5. Com colunas de comprimento e largura das sépalas e pétalas e as espécies (sepal_length,
sepal_width, petal_length, petal_width, species).
Vamos ao Script e a algumas funções. Note que diferentemente de como fizemos com o método
math ou random. Em pandas nós vamos dar um nome ao objeto usando o operador as. Você verá
que alguns nicknames são comuns na comunidade Python.

Código 2.14: Pandas - funções

# Importa o pacote panda e o nomeia como "pd"
import pandas as pd

# Importar o arquivo ".csv" como DataFrame.

# O separador éa ",", se fosse outro, usar sep=';'.
df = pd.read_csv('iris.csv')
# Em Jupyter basta escrever o nome do DataFrame.
# Sem o print()
df
2.4 Manipulando dados com Pandas 33

Figura 2.4: Comprimento e largura das pétalas e sépalas [0]

Figura 2.5: DataFrame dos dados das íris

34 Capítulo 2. Tópicos Avançados

# Para acessar qualquer coluna, basta fazer

df[['sepal_length']]
df[['sepal_length', 'sepal_width']]
# Somar os valores das linhas de cada coluna
df.sum() # ou df.sum(axis=0)
# Somar os valores das colunas de todas as linhas
df.sum(axis=1)
# Calcular as médias, desvios padrão, máximos, mínimos
# e a quantidade de dados de cada coluna
df.mean()
df.std()
df.max()
df.min()
df.count()
# Calcular quartis ou decis
df.quantile(q=0.25) # primeiro quartil
df.quantile(q=0.50) # segundo quartil (mediana)
df.quantile(q=0.75) # terceiro quartil
df.quantile(q=0.10) # primeiro decil
df.quantile(q=0.30) # terceiro decil
# Ou ainda, a função describe que fornece tudo isso
df.describe()

Além das aplicações diretas ao DataFrame inteiro, pode-se selecionar uma coluna e aplicar as
fórmulas, ou ainda, selecionar dados a partir de uma condição. Por exmeplo, apenas às sépalas que
com comprimento maior que 6.0. Os códigos a seguir partem do princípio que as linhas 2 e 6 do
Script 2.14 foram executadas.

Código 2.15: Pandas - seleção condicional

# Selação da coluna 'sepal_lenght' > 6.0
# Retorna todo o DataFrame com a condição
df[df['sepal_lenght']>6.0]

# Retorna apenas a coluna 'sepal_lenght'

df[df['sepal_length']>6.][['sepal_length']]

# Retorna apenas a coluna 'petal_length'

df[df['sepal_length']>6.][['petal_length']]

# Retorna as duas colunas 'petal_length' e 'species'

df[df['sepal_length']>6.][['petal_length', 'species']]

# Retorna todo o DataFrame apenas com espécie 'setosa'

df[df['species']=='setosa']

# Todas as funções podem ser aplicadas

df[df['species']=='setosa'].describe()

Podemos agrupar os dados com referência aos valores de uma coluna com a função groupby().
Essa função cria um novo objeto, e as funções vistas em 2.14 podem ser aplicadas ao objeto.

Código 2.16: Pandas - groupby()

# Cria um objeto agrupado por espécies
specieGroup = df.groupby('species')

# Aplicação das funções já vistas

specieGroup.sum()
specieGroup.mean()
specieGroup.std()
2.4 Manipulando dados com Pandas 35

specieGroup.max()
specieGroup.min()

specieGroup.describe()

A função sort_values() ordena o DataFrame na ordem crescente ou decrescente. Como principal

argumento tem-se a coluna que deve ser oredenada.

Código 2.17: Pandas - ordena o DataFrame (sort_values())

# Ordena o DataFrame em ordem crescente de 'sepal_length'
df.sort_values(by='sepal_length')

# Ordena o DataFrame em ordem decrescente de 'sepal_length'

df.sort_values(by='sepal_length', ascending=False)

É possível efetuar operações matemáticas entre duas colunas ou linhas de um DataFrame. E

ainda criar uma nova coluna com o resultado da operação.

Código 2.18: Pandas - operações entre colunas

# Operações entre colunas
df['sepal_length'] + df['sepal_width']
df['sepal_length'] + df['sepal_width'] + df['petal_length']

# Neste caso mais uma coluna será criada.

df['sepal_area'] = df['sepal_length']*df['sepal_width']/2

O pacote Matplotlib para criação de gráficos pode ser utilizado diretamente pelo pacote Pandas.
Para plotar um gráfico com dados do DataFrame, além do pacote Pandas, deve-se importar o pacote
Matplotlib. Então utilizar o método plot() do Pandas. Vamos visualizar rapidamente para entender
pandas na próxima seção.

Código 2.19: Pandas - plot 1

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('dadosIris.csv', index_col=0)

# Gera o gráfico para todo o DataFrame

df.plot()
# Mostra o gráfico
plt.show()
36 Capítulo 2. Tópicos Avançados

Figura 2.6: Gráfico Pandas 1

Note que o gráfico automaticamente gera a legenda com os nomes das colunas. Perceba também
que ao invés do d f .plot, também seria possível plotar apenas d f [[0 sepall enght 0 ,0 sepalw idth0 ]]. Ou
qualquer outro DataFrame derivado.
Caso esteja usando a IDE Jupyter, pode-se inserir o comando %mat plotlib inline. Dessa
maneira o gráfico será plotado na chamada d f .plot(), sem a necessidade do comando plt.show() a
cada plotagem.

Código 2.20: Pandas - plot 2, inline

import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

df = pd.read_csv('dadosIris.csv', index_col=0)
df.plot()

Caso quiséssemos ter uma idéia de qual é a relação entre o comprimento e a largura das sépalas,
podemos fazer utilizar o gráfico tipo scatter.

Código 2.21: Pandas - scatter

df = pd.read_csv('dadosIris.csv', index_col=0)

df[['sepal_length', 'sepal_width']].plot(x='sepal_length',
y='sepal_width',
kind='scatter')
2.4 Manipulando dados com Pandas 37

Figura 2.7: Gráfico Pandas scatter

A distribuição dos dados pode ser feita pelo gráfico histograma ou boxplot.

Código 2.22: Pandas - histograma

df = pd.read_csv('dadosIris.csv', index_col=0)

# Histograma
df.plot(kind='hist', stacked=True, bins=20, alpha=.5)

# Boxplot
df.plot(kind='box')

# Barras
df[df['species']=='setosa'][['sepal_length',
'sepal_width']].plot(kind='bar')
38 Capítulo 2. Tópicos Avançados

Figura 2.8: Gráfico pandas histograma

Figura 2.9: Gráfico pandas boxplot

2.4 Manipulando dados com Pandas 39

Figura 2.10: Gráfico pandas barras

Para maiores informações sobre gráficos disponíveis em Pandas, e sua formatação/customiza-

ção, entre em
https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html.

Para gráficos com melhor qualidade, e com a mesma facilidade de plotagem, utilize o pacote
Seaborn. Os exemplos foram tirados de https://seaborn.pydata.org, mas os dados são do arquivo
"dadosIrirs.csv". Vamos a alguns exemplos e aplicações.

Código 2.23: Seaborn - scatter

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv('dadosIris.csv', index_col=0)

# Para aumentar o tamanho da Figura

plt.figure(figsize=(16, 6))

# Gera e mostra o gráfico scatter lenght vs width

sns.scatterplot(x='sepal_length',y='sepal_width',
data=df)

# Gera gráfico agrupado pela specia hue='species'

sns.scatterplot(x='sepal_length',y='sepal_width',
hue='species',data=df)
40 Capítulo 2. Tópicos Avançados

Figura 2.11: Gráfico seaborn scatter. Direita sem definir o argumento hue. Esquerda com hue=’species’

Outro gráfico scatter interessante de se analisar é o scatterplot matrix. Neste gráfico todas as
variáveis são traçadas contra todas, criando vários scatters e curvas de distribuição.

Código 2.24: Seaborn - scatterplot matrix

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv('dadosIris.csv', index_col=0)

# Para aumentar o tamanho da Figura

plt.figure(figsize=(16, 6))

# Gera e mostra o gráfico scatter matrix

sns.pairplot(df, hue="species")
2.4 Manipulando dados com Pandas 41

Figura 2.12: Gráfico seaborn scatterplot matrix

A análise de distribuição de dados também pode ser feita por boxplot.

Código 2.25: Seaborn - boxplot

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv('dadosIris.csv')

# Para aumentar o tamanho da Figura

plt.figure(figsize=(16, 10))

# Gera e mostra o gráfico boxplot

sns.boxplot(x='species', y='sepal_width', data=df)
sns.boxplot(x='species', y='sepal_length', data=df)
sns.boxplot(x='species', y='petal_width', data=df)
sns.boxplot(x='species', y='petal_length', data=df)
42 Capítulo 2. Tópicos Avançados

Figura 2.13: Gráfico seaborn boxplot

Uma variação do boxplot é o violinplot, em que pode-se dimensionar além dos quartis, a
distribuição dos dados.

Código 2.26: Seaborn - violinplot

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv('dadosIris.csv')

# Para aumentar o tamanho da Figura

plt.figure(figsize=(16, 10))

# Gera e mostra o gráfico boxplot

sns.violinplot(x='species', y='sepal_width', data=df)
sns.violinplot(x='species', y='sepal_length', data=df)
sns.violinplot(x='species', y='petal_width', data=df)
sns.violinplot(x='species', y='petal_length', data=df)
2.4 Manipulando dados com Pandas 43

Figura 2.14: Gráfico seaborn violinplot

Podemos também plotar o gráfico de regressão linear dos dados. O seaborn permite plotar
todas as variáveis species em um único gráfico ou em gráficos separados.

Código 2.27: Seaborn - lmplot 1

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv('dadosIris.csv')

# Para aumentar o tamanho da Figura

plt.figure(figsize=(10, 10))

# Gera e mostra um gráfico lmplot com as três espécies

sns.lmplot(x='sepal_length', y='sepal_width',
hue='species',data=df)

# Gera e mostra três gráfico lmplot com cada espécie

# Note a presença do argumento col='species'
sns.lmplot(x='sepal_length', y='sepal_width',
hue='species',col='species',data=df)
 44 Capítulo 2. Tópicos Avançados

Figura 2.15: Gráfico seaborn lmplot 1

Figura 2.16: Gráfico seaborn lmplot 6

2.4.1 Análise Breast Cancer

Todos os códigos e desenvolvimentos do exemplo de Breast Cancer serão demosntrados a seguir.
Os dados podem ser obtidos em https://www.kaggle.com/uciml/breast-cancer-wisconsin-data.

Código 2.28: Exemplo - Breast Cancer

#Apenas se estiver usando o google colab utilize o camndo abaixo

from google.colab import files
uploaded = files.upload()

import pandas as pd

df = pd.read_csv('data.csv')

df.shape

df.info()

df.head()
df.tail()
2.4 Manipulando dados com Pandas 45

df['radius_mean']

cols = ['diagnosis','radius_mean', 'texture_mean']

df[cols]

Código 2.29: Subdataframe - Breast Cancer

# Exmplo de Lista
a = [25,88,100,23,99,77]
a[2:]
a[3:5]

# Função iloc
df.iloc[:,:]

df.set_index('id')
df.head()
df.set_index('id', inplace=True)

# Função loc
df.loc[:,:]
df.loc[:,'id':'fractal_dimension_mean']
df.loc[:,'id','fractal_dimension_mean']

Código 2.30: Estatística - Breast Cancer

df.mean()
df.median()
df.std()
df.max()
df.min()
df.sum()
df.quantile(q=.5)
df.median()
df.corr()
df.cov()

df.describe()

df.describe().T

cols=['radius_mean', 'texture_mean', 'compactness_mean']

df[cols].mean()

df.describe()

## apply

def c_radius(value):
return 2*value

df.apply(c_radius)

df.head()
46 Capítulo 2. Tópicos Avançados

Código 2.31: Expressões Aritméticas e Condicionais- Breast Cancer

##Expressões Aritméticas

df['difRadius_mean_worst'] = df['radius_mean'] - df['radius_worst']

df['difRadius_mean_worst'] = 100*(df['radius_mean'] - df['radius_worst'])/df['

radius_worst']

#Condicionais
df['radius_mean'].median()
13.37

df['radius_mean']>=13.37

df[df['radius_mean']>=13.37]

df[df['radius_mean']>=13.37].min()

df[df['radius_mean']<13.37]
df[df['radius_mean']<13.37].max()

df.loc[,'class_radius'] = 'H'

df.loc[(df['radius_mean']>=13.37),'class_radius'] = 'H'

df.loc[(df['radius_mean']<13.37),'class_radius'] = 'L'

df.head()

df.drop('class_radius', axis=1)

df.head()

##NP select
import numpy as np

cond = [(df['radius_mean']>=13.37), (df['radius_mean']<13.37)]

esc = ['H','L']

df['class_radius'] = np.select(cond, esc, default=None)

Código 2.32: groupby - Breast Cancer

##groupby

df.groupby('class_radius').mean()
df.groupby('class_radius').corr()

df.groupby('diagnosis').mean()
df.groupby('diagnosis').corr()

df.groupby(['diagnosis','class_radius']).mean()
df.groupby(['diagnosis','class_radius']).corr()

Código 2.33: merge e concat - Breast Cancer

2.4 Manipulando dados com Pandas 47

##merge

import random

AGE = []
SEX = []

df.shape

df.shape[0]

random.seed(222)

for i in range(df.shape[0]):
AGE.append(random.randint(20,75))
SEX.append(random.choice(['H','F']))

df['id'].sort_values()

df['id'].sort_values().tolist()

df2 = pd.DataFrame(data={'id':ID, 'age':AGE, 'sex':SEX})

df.merge(df2, how='inner', on='id')

dfMerge = df.merge(df2, how='inner', on='id')

diferentes nomes
dfMerge = df.merge(df2, how='inner', right_on='ident', left_on='id')

##CONCAT
df3 = dfMerge.iloc[:10,:]*0

pd.concat([dfMerge, df3])

pd.concat([dfMerge, df3], ignore_index=True)

Código 2.34: pivot e pivott able − BreastCancer

##Pivot
dfMerge.pivot(index='id', columns='diagnosis', values='radius_mean')
dfMerge.pivot(index='id', columns='diagnosis', values='radius_mean').fillna(0)

##Pivot_table
dfMerge.pivot_table(index='sex', columns='diagnosis', values='radius_mean')

dfMerge.pivot_table(index='sex', columns='diagnosis', values='radius_mean',

aggfunc='mean')

aggfunc='count', 'sum', 'std', 'median', min, max

##Transposta
dfMerge.pivot_table(index='sex', columns='diagnosis', values='radius_mean',
aggfunc='count').T

##Graficos
48 Capítulo 2. Tópicos Avançados

dfMerge.pivot_table(index='sex', columns='diagnosis', values='radius_mean',

aggfunc='count')['M'].plot(kind='pie')

dfMerge.pivot_table(index='sex', columns='diagnosis', values='radius_mean',

aggfunc='count').T['M'].plot(kind='pie')

dfMerge['radius_mean'].plot()

dfMerge['radius_mean'].plot(kind='bar')
dfMerge['radius_mean'].plot(kind='bar', figsize=(15,7))

Código 2.35: plot - Breast Cancer

##Graficos

dfMerge.pivot_table(index='sex', columns='diagnosis', values='radius_mean',

aggfunc='count')['M'].plot(kind='pie')

dfMerge.pivot_table(index='sex', columns='diagnosis', values='radius_mean',

aggfunc='count').T['M'].plot(kind='pie')

dfMerge['radius_mean'].plot()

dfMerge['radius_mean'].plot(kind='bar')
dfMerge['radius_mean'].plot(kind='bar', figsize=(15,7))

dfMerge.plot(x='radius_mean', y='texture_mean', kind='scatter', figsize=(15,7))

dfMerge.plot(y='texture_mean', kind='box', figsize=(15,7))

dfMerge.plot(y=['texture_mean', 'radius_mean'], kind='box', figsize=(15,7))

Código 2.36: Seaborn - Breast Cancer

##SEABORN
import seaborn as sns
sns.boxplot(data=dfMerge[['texture_mean', 'radius_mean']])

sns.boxplot(x='sex', y='texture_mean', data=dfMerge)

sns.boxplot(x='diagnosis', y='texture_mean', data=dfMerge)

sns.swarmplot(x='diagnosis', y='texture_mean', data=dfMerge)

sns.barplot(x='diagnosis', y='texture_mean', hue='sex' ,data=dfMerge)

sns.catplot(x='diagnosis', y='texture_mean', hue='sex' ,data=dfMerge)
sns.pointplot(x='diagnosis', y='texture_mean', hue='sex' ,data=dfMerge)

sns.countplot(x='diagnosis', hue='sex', data=dfMerge)

sns.scatterplot(x='concavity_mean', y='texture_mean' ,data=dfMerge)

sns.scatterplot(x='concavity_mean', y='texture_mean', hue='diagnosis', data=
dfMerge)

sns.lmplot(x='concavity_mean', y='texture_mean', hue='diagnosis', data=dfMerge)

sns.pairplot(data=dfMerge)
 2.5 Biopython 49

cols = ['diagnosis','radius_mean', 'texture_mean','compactness_mean', '

concavity_mean',
'concave points_mean', 'symmetry_mean']

sns.pairplot(data=dfMerge[cols], kind='reg', hue='diagnosis', corner=True)

sns.violinplot(x='sex', y='texture_mean', data=dfMerge)

sns.violinplot(x='diagnosis', y='texture_mean', data=dfMerge)

sns.violinplot(x='diagnosis', y='texture_mean', hue='sex', data=dfMerge)

sns.violinplot(x='diagnosis', y='texture_mean', hue='sex', data=dfMerge, inner=

'quartile')

sns.violinplot(x='diagnosis', y='texture_mean', hue='sex', data=dfMerge, inner=

'quartile', scale='width')

sns.boxenplot(x='diagnosis', y='texture_mean', hue='sex', data=dfMerge)

##HEATMAP
dfMerge.groupby('diagnosis').corr()
sns.heatmap(dfMerge.groupby('diagnosis').corr())

dfMerge.pivot(index='id', columns='diagnosis', values='radius_mean')

dfMerge.pivot(index='id', columns='diagnosis', values='radius_mean').fillna(0)

sns.heatmap(dfMerge.pivot(index='id',columns='diagnosis',values='radius_mean').
fillna(0))

Pivot_table
dfMerge.pivot_table(index='sex',columns='diagnosis',values='radius_mean')
dfMerge.pivot_table(index='sex',columns='diagnosis',values='radius_mean',
aggfunc='mean')

sns.heatmap(dfMerge.pivot_table(index='sex',columns='diagnosis',values='
radius_mean', aggfunc='std'),
annot=True, fmt=".2f")

sns.heatmap(dfMerge.pivot_table(index='class_radius',columns='diagnosis',values
='radius_mean', aggfunc='count'),
annot=True, fmt=".2f")

##ClusterMap
sns.clustermap(dfMerge.groupby('diagnosis').corr())

sns.clustermap(dfMerge.pivot(index='id',columns='diagnosis',values='radius_mean
').fillna(0))

2.5 Biopython
Biopython O Biopython é uma biblioteca destinada para manipulação de dados biológicos. Os
tradicionais arquivos FASTA, amplamente utilizados em bioinformática, podem ser processados
utilizando o Biopython. O arsenal de recursos da biblioteca também inclui: desenho de plasmídeos
para engenharia genética, criação de diagramas para análise genômica e execução de algoritmos de
aprendizado de máquina. Existe um tutorial oficial do Biopython, bastante completo, que pode ser
acessado através do endereço: biopython.org/DIST/docs/tutorial/Tutorial.html.
 50 Capítulo 2. Tópicos Avançados

2.5.1 Manipulação de Sequências

Código 2.37: Manipulação de Sequências

#Molde
dnaM = Seq('ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG')
dnaM
type(dnaM)

#Fita Complementar
dnaC = dnaM.complement()
dnaC

print('Fita Molde:', dnaM)

print('Fita Compl:', dnaC)

#Transcrito
rnaMen = dnaC.transcribe()
rnaMen

print('Fita DNA:', dnaM)

print('Fita RNA:', rnaMen)

#Tradução a partir do RNA

prot = rnaMen.translate()
prot

prot = rnaMen.translate(to_stop=True)
prot

prot = rnaMen.translate(table=6)
prot

Código 2.38: Alinhamento de Sequências

#Alinhamento Simples
from Bio import pairwise2

align = pairwise2.align.globalms(seq1, seq2, 5, -4, -2, -0.5)

https://biopython.org/docs/1.75/api/Bio.pairwise2.html

align
align[0]
print(pairwise2.format_alignment(*align[0]))

print(pairwise2.format_alignment(*align[-1]))

align = pairwise2.align.localms(seq1, seq2, 5, -4, -2, -0.5)

print(pairwise2.format_alignment(*align[0]))

#Alinhamento prot
from Bio.SubsMat import MatrixInfo as matlist
matrizBlosum = matlist.blosum62

seq1 = 'MSLSAKDKANVKAFFDKVAPKAEEIGRETL'
seq2 = 'SRTLFVYQTVKAFIGRETLFDKVAPKEE'

align = pairwise2.align.globaldx(seq1, seq2, matrizBlosum)

print(pairwise2.format_alignment(*align[0]))
 2.5 Biopython 51

matrizPam = matlist.pam120
align = pairwise2.align.globaldx(seq1, seq2, matrizPam)
print(pairwise2.format_alignment(*align[0]))

print(matlist.available_matrices)

2.5.2 API Entrez do NCBI

Código 2.39: API Entrez NCBI

from Bio import Entrez
from Bio import SeqIO

Entrez.email = '[email protected]'
handle = Entrez.esearch(db='nucleotide', term='SARS-CoV-2 human', retmax='10')
record = Entrez.read(handle)

record

seq_handle = Entrez.efetch(db='nucleotide', rettype='fasta', id=record['IdList'

])

seq_record=SeqIO.parse(seq_handle, 'fasta')
SeqIO.write(seq_record, 'covHuman.fasta', 'fasta')

#LER FASTA
arq = open('covHuman.fasta','r')
seqs = []
for i in SeqIO.parse(arq,'fasta'):
seqs.append(i)

seqs
seqs[0]

seqs[0].seq
seqs[1].seq

seqs[0].seq.complement()
seqs[0].seq.transcribe()
seqs[0].seq.transcribe().translate()

from Bio.SeqUtils import GC

gc = GC(seq[0].seq)

print(gc)
print(100 - gc)

##Genbank

seq_handle = Entrez.efetch(db='nucleotide', rettype='gb', id='45478711')

seq_record = SeqIO.parse(seq_handle,'gb')
SeqIO.write(seq_record, 'NC_005816.gb', 'gb')

2.5.3 Diagrama Genômico

Código 2.40: Diagrama Genômico

from IPython.display import Image
 52 Capítulo 2. Tópicos Avançados

!pip install reportlab

from reportlab.lib import colors

from reportlab.lib.units import cm
from Bio.Graphics import GenomeDiagram

gd_diagram = GenomeDiagram.Diagram("Yersinia pestis biovar Microtus plasmid

pPCP1")
gd_track_for_features = gd_diagram.new_track(1, name="Annotated Features")
gd_feature_set = gd_track_for_features.new_set()

record = SeqIO.read('NC_005816.gb', "genbank")

record.features

for feature in record.features:

if feature.type != "gene":
# Exclude this feature
continue
if len(gd_feature_set) % 2 == 0:
color = colors.blue
else:
color = colors.lightblue
gd_feature_set.add_feature(feature, color=color, label=True,sigil="BOX") #'
ARROW','JAGGY'

gd_diagram.draw(
format="circular", ##linear
circular=True,
pagesize=(20*cm,20*cm),#"A4",
start=0,
end=len(record),
circle_core=0.7
)

gd_diagram.write("plasmid_linear.png", "png")

Image(filename='plasmid_linear.png')

2.5.4 BLAST

Código 2.41: BLAST

from Bio import SeqIO, SearchIO
from Bio.Blast import NCBIWWW

arq = SeqIO.read('exemplo.fasta', format='fasta')

resultBlast = NCBIWWW.qblast('blastn', 'nt', arq.seq)

blast_qresult = SearchIO.read(resultBlast, "blast-xml")

print(blast_qresult)

2.5.5 KEGG

Código 2.42: KEGG

from Bio import SeqIO
 2.5 Biopython 53

from Bio.KEGG import REST

result = REST.kegg_info("kegg").read()
print(result)

result = REST.kegg_info("pathway").read()
print(result)

result = REST.kegg_list("pathway").read()
print(result)

result = REST.kegg_list("drug").read()
print(result)

result = REST.kegg_find("genes", "Herbaspirillum").read()

print(result)

result = REST.kegg_find('disease','covid').read()
print(result)

result = REST.kegg_find("compound", "Glutathione").read()

print(result)

result = REST.kegg_get("cpd:C00051").read()
print(result)

result = REST.kegg_get("cpd:C00051", "image").read()

Image(result)

result = REST.kegg_find("pathway", "Fatty+acid+biosynthesis").read()

to_df(result)

result = REST.kegg_get("map00061", "image").read()

Image(result)

from Bio.KEGG import Enzyme

request = REST.kegg_get('ec:5.4.2.2')
f = open('ec_5422.txt', 'w')
f.write(request.read())
f.close()

records = Enzyme.parse(open('ec_5422.txt'))
record = list(records)[0]

#ABRIR O ARQUIVO E MOSTRAR AS FEATURES

record.name
record.entry
record.classname
record.pathway
record.reaction
record.substrate
record.product
record.genes

2.5.6 PDB

Código 2.43: PDB

from Bio.PDB import *
54 Capítulo 2. Tópicos Avançados

pdb = PDBList()
pdb.retrieve_pdb_file('2FAT', pdir = '/', file_format = 'mmCif')

parser = MMCIFParser(QUIET = True)

struct = parser.get_structure("2FAT", "2fat.cif")

struct

struct.header

struct.header['structure_method']

struct.header['resolution']

struct[0]

model = struct.get_models()

models = list(model)

models[0]

chains = list(models[0].get_chains())

chains

chains[0].id

chains[1].id

residueL = list(chains[0].get_residues())
residueH = list(chains[1].get_residues())

residueH

residueH[0]
residueH[0].resname

atoms = list(residueL[0].get_atoms())

atoms

atoms[0].name

atoms[0].coord

atoms[0].get_vector()

atoms[0]-atoms[2]