<jupyter_start><jupyter_text>Computação científica para biólogos e pesquisadores Sumário[**Introdução: o porquê deste curso**](./introducao.md/)I.1 Apresentação  I.2 Informática cada vez mais necessária  I.3 As ferramentas[**Módulo 1: Ferramentas básicas**](./modulo_1.md)1.1 - Linha de comando: Terminal  1.2 - Editor de texto e IDE: Atom  1.3 - Linguagem de Programação: Python[**Módulo 2: Bibliotecas e ambientes virtuais**](./modulo_2.md)2.1 - Conda: Ambientes virtuais e instalação de dependências  2.2 - Bibliotecas essenciais: Pandas, Matplotlib e Jupyter  2.3 - Analisando o conjunto Iris no Jupyter Notebook  [**Módulo 3: Colaboração e boas práticas**](./modulo_3.md)3.1 - Boas práticas em computação científica  3.2 - Documentação e controle de versão: Git e GitHub  3.3 - Como aprender programação: dicas para biólogos- Módulo 2: 2.1 Conda: ambientes virtuais e dependências Pacotes e bibliotecasAssim como o `R`, a capacidade do `Python` é enormemente expandida por conta da grande quantidade de pacotes e bibliotecas disponíveis. Alguns são essenciais para quem quer realizar análise de dados.![Existem muitas bibliotecas de Python voltadas à análise de dados biológicos](../img/biopython.png).[Nesse tópico no site BioStars](https://www.biostars.org/p/50749/50758), esse usuário apontou algumas ferramentas em Python que são úteis para biólogos.Logo, é imprescindível aprender a baixar, instalar e rodar esses pacotes. Essa instalação é simples, mas é diferente de usar um "Install Wizard": geralmente é feita pela linha de comando.![Install wizard do RStudio](../img/rstudio.jpg)Você pode até se safar instalando o RStudio usando um Install Wizard, mas para instalação de pacotes Python vai ter que recorrer ao Terminal.Além disso, existe outra questão: muitos pacotes dependem de outros para funcionar, e todos dependem de ter uma instância de Python instalada. Pior, às vezes pacotes requerem versões **específicas** de outro pacote ou linguagem, e pacotes que requerem versões **diferentes** podem causar o que chamamos de um **conflito de dependência**. Ambientes virtuais: caixinhas no computadorPara instalarmos uma biblioteca, precisamos de um programa que faça isso para nós, um **gerenciador de pacotes**. Por sorte, o Python vem com um instalado de fábrica, o [`pip`](https://pip.pypa.io/en/stable/): pip installs packages. O `pip` faz download e instala pacotes disponíveis no [PyPI - Python Package Index](https://pypi.python.org/pypi), um repositório de bibliotecas aberto mantido pela Python Software Foundation. O `pip` funciona muito bem, no entanto queremos mais que isso.Para isso instalamos o Anaconda, que é uma plataforma para ciência de dados que inclue um gerenciador de pacotes chamado [`conda`](https://conda.io/docs/index.html). Além de baixar e instalar pacotes, o `conda` também gerencia **ambientes virtuais**.**Mas o que são e por que precisamos de ambientes virtuais?**Ambientes virtuais (*virtual environments* ou *envs*), são como caixinhas em nosso computador na qual instalamos programas, pacotes, bibliotecas, ou dependências, e elas funcionam naquele ambiente fechado, sem interferir com outras instalações fora desse ambiente.**Por exemplo:**Quando vamos baixar o Anaconda, podemos escolher entre Python versão 2.7 ou 3.4. Digamos que escolhemos a 3.4, por que é mais atualizada e compatível com a maioria dos programas. Porém, estamos fazendo um estudo de microbiologia e para analisar nossos dados, vamos precisar do [QIIME](http://qiime.org/), que requere a versão 2.7 do Python para rodar, e é incompatível com as versões 3.x. Além do Python, o QIIME requere versões específicas de diversas outras bibliotecas, que podem interferir com nosso ambiente **root** (nosso ambiente "global", sem nenhum ambiente virtual ativado. Sim, o nosso sistema operacional usa uma versão de Python para executar várias outras atividades, que nada tem a ver com o Conda).A solução é **criar um ambiente virtual** com Python 2.7 instalado, e nesse ambiente instalamos as **dependências** necessárias para que o QIIME rode. O `conda` permite que façamos isso.[![Quantitative Insights Into Microbial Ecology](../img/qiime.png)](http://qiime.org/) Criando um ambiente virtualEmbora a instalação do Anaconda nos propicia o Anaconda Navigator, uma interface gráfica, vamos utilizar o `conda` pelo Terminal.[Nesse documento](../papers/conda-cheatsheet.pdf) temos uma referência rápida dos comandos básicos do `conda`.Para criar um novo ambiente, usamos o comando `conda create` junto do nome do ambiente e a versão de Python que desejamos.`conda create --name qiime python=2.7`Agora que temos um ambiente com a versão que precisamos, podemos instalar o QIIME e o restante de suas dependências.Ativamos o novo ambiente com o comando:`source activate qiime` Instalando pacotes do Anaconda CloudDiferente do `pip`, o `conda` não baixa programas do [PyPI](https://pypi.python.org/pypi), e sim de outra base de dados, a [Anaconda Cloud.](https://anaconda.org/)[![https://anaconda.org/](../img/anaconda.png)](https://anaconda.org/)Esse repositório é muito útil pois fornece os pacotes disponíveis e os comandos para instalação.[![https://anaconda.org/bioconda/qiime](../img/qiimeinstall.png)](https://anaconda.org/bioconda/qiime)Copiamos o comando e uma mensagem irá confirmar a instalação do QIIME e todas as dependências necessárias.`conda install -c bioconda qiime`Acontece que perdemos todas as nossas sequências, então não vamos precisar do QIIME. Vamos aprender sobre outras bibliotecas mais essenciais no momento. Então, para remover ese ambiente virtual criado use os comandos:`source deactivate``conda remove -n qiime --all`Vamos criar um novo ambiente virtual para fazer uma análise de dados mais simples. Além da versão do Python, podemos especificar outros pacotes para o `conda` instalar quando criar o ambiente:`conda create -n tutorial Python=3 Pandas Matplotlib Jupyter`Selecionamos Python 3, bem como as bibliotecas [Pandas](https://pandas.pydata.org/), [Matplotlib](https://matplotlib.org/), [Jupyter](http://jupyter.org/) e suas dependências.Ativando o ambiente:`source activate tutorial`É importante aprender os diferentes comandos do `conda`. Outros gerenciadores de pacote como o `pip` também funcionam com comandos como `pip install `. Você pode utilizar o `pip` para instalar pacotes em ambientes criados pelo `conda`. Para ver os pacotes que estão no ambiente atual, use o comando `conda list`. Lembrando que o sumário dos comandos do `conda` pode ser acessado [nessa *cheat sheet*.](../papers/conda-cheatsheet.pdf) 2.2 Bibliotecas essenciais: Pandas, Matplotlib e Jupyter.É um equívoco comum, para quem está começando a aprender uma linguagem, pensar que o uso desta por si só vai levar ao resultado final do que se está buscando. Uma linguagem como Python, embora poderosa, necessita um conhecimento extenso para ser utilizada efetivamente sem o auxílio de pacotes externos. Para tirar o máximo proveito de um conhecimento básico de Python, vamos alavancar a funcionalidade da linguagem por meio dessas três bibliotecas. Sua combinação vai nos possibilitar um ambiente simples mas efetivo para análise de dados. Se o nosso objetivo fosse outro, como por exemplo, desenvolvimento web, faríamos uso de outras bibliotecas, como os *frameworks* [Flask](http://flask.pocoo.org/) ou [Django.](https://www.djangoproject.com/)[![https://pandas.pydata.org/](../img/pandas.png)](https://pandas.pydata.org/)[Pandas](https://pandas.pydata.org/) é uma biblioteca de análise contendo ferramentas de análise de dados de fácil uso e alta performance. Vamos utilizar **métodos** dessa biblioteca para importar e manipular nossos dados.[![https://matplotlib.org/](../img/matplotlib.png)](https://matplotlib.org/)[Matplotlib](https://matplotlib.org/) é uma biblioteca de plotagem inspirada no MATLAB, com a diferença de ser de graça e *open source*. Oferece uma variedade de ferramentas para plotar os dados que criamos com Pandas.[![http://jupyter.org/](../img/jupyter.png)](http://jupyter.org/)[Jupyter](http://jupyter.org/) é uma biblioteca muito interessante que nos fornece o [Jupyter Notebook](https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks), uma ferramenta muito útil para organizar um projeto de análise de dados.Um arquivo Jupyter Notebook permite a *execução de código* junto com texto MarkDown, como html. Vamos realizar nossa análise com `Pandas`, plotar com `Matplotlib` e anotar e organizar tudo com anotações utilizando o `Jupyter Notebook`.O arquivo [python\_primeiros_comandos.html](../python_primeiros_comandos.html) foi renderizado a partir de um arquivo Notebook. Vamos abrir o arquivo [modulo\_2_continuacao.ipynb](../notebooks/modulo\_2_continuacao.ipynb). Mas para isso precisamos abrir uma instância de Jupyter.No Terminal, digite `Jupyter Notebook` para abrir uma página no seu navegador web.-  2.3 Plotando dados no Jupyter NotebookContinuamos o Módulo 2 em um Jupyter Notebook. Essas páginas possibilitam a disposição de texto MarkDown (como este) e código Python (algumas caixas abaixo). Vamos anotar nossa análise com porções de MarkDown, mas o que cada comando específico faz será anotado com comentários no próprio código. Os comentários são precedidos do caracter '' que indica que aquela porção é um comentário e portanto não será executado como código. Diferente de uma IDE, os Notebooks **não são** ambientes ideais para testes, experimentos ou instalação de programas, mas são excelentes para descrição e organização de análises. Os Notebooks suportam uma variedade de linguagens, inclusive bash, então é possível comandar o Terminal por aqui. Basta botar um `!` na frente do comando.<jupyter_code>cd ..
!ls
# Se nosso ambiente não estiver ativo podemos rodar
!source activate tutorial<jupyter_output><empty_output><jupyter_text>Há muito o que se fazer com os Jupyter Notebooks, e é muito bom ficar confortável com eles! Bom, mas o que queremos agora é usa-los para realizar uma análise de dados que poderia caber a qualquer estudante de biologia. Vamos usar o famoso conjunto de dados Iris, que está em um arquivo .csv em nossa pasta local. Arquivos .csv ou .tsv (*comma* ou *tab-separated values*) são arquivos de texto usados para representar tabelas. Uma tabela do Excel, por exemplo, pode ser exportada como .csv.O uso do **Pandas** possibilita importar a tabela com os dados diretamente em um objeto do tipo *Dataframe*. Vamos importar a biblioteca Pandas com o comando `import` e abreviar ela como `pd`. Também vamos importar a biblioteca `matplotlib.pyplot` e abreviar como `plt`. Ambas essas abreviações são universais para esses pacotes. A razão que importamos `matplotlib.pyplot` ao invés de `matplotlib` é porque `pyplot` é uma **API**, um programa que serve como uma interface para 'conectar' os pacotes Pandas e Matplotlib.<jupyter_code># Importando as bibliotecas e suas respectivas abreviações
import pandas as pd
import matplotlib.pyplot as plt<jupyter_output><empty_output><jupyter_text>Agora já temos todos os métodos dessas bibliotecas à nossa disposição. Só falta importar os dados. Para isso, o Pandas oferece o método read_csv, que converte um arquivo .csv em dataframe. Vamos armazenar esse dataframe em uma variável `iris`.<jupyter_code># Vamos armazenar esse objeto Pandas em uma variável 'iris'
iris = pd.read_csv('data/iris.csv')
print(iris)<jupyter_output>SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm         species
0              5.1           3.5            1.4           0.2     Iris-setosa
1              4.9           3.0            1.4           0.2     Iris-setosa
2              4.7           3.2            1.3           0.2     Iris-setosa
3              4.6           3.1            1.5           0.2     Iris-setosa
4              5.0           3.6            1.4           0.2     Iris-setosa
5              5.4           3.9            1.7           0.4     Iris-setosa
6              4.6           3.4            1.4           0.3     Iris-setosa
7              5.0           3.4            1.5           0.2     Iris-setosa
8              4.4           2.9            1.4           0.2     Iris-setosa
9              4.9           3.1            1.5           0.1     Iris-setosa
10             5.4           3.7            1.5           0.2     Iris-setosa
11             4.8           3.4            1.6           0.2   [...]<jupyter_text>Nota sobre importar arquivosAqui é importante notar o que fizemos ao importar o conjunto Iris. Utilizamos o **método** ```pd.read_csv()```. Esse método serve apenas para arquivos do tipo CSV (comma-separated values). Esse formato de arquivo é bem comum, basicamente é um arquivo de texto contendo um tabela com valores separados por vírgulas (*commas*), ou qualquer outro *delimiter*. Uma planilha do Excel, por exemplo, pode ser salva em .csv. Se nosso arquivo tivesse os valores separados pelo caracter ";", precisamos "explicar" isso. Nosso comando seria ```pd.read_csv('data/iris.csv', delimiter = ';')```. O método ```pd.read_csv()``` tem um **argumento** obrigatório, que é o arquivo que será importado. O argumento "delimiter" é "," a não ser que especificado.A biblioteca Pandas é útil porque ela transforma arquivos em *Dataframes*, que são **objetos** que permitem uma fácil visualização e manipulação dos dados. Logo, depois do comando acima, temos um **objeto** (um Pandas dataframe) armazenado em uma variável (```iris```).Como o formato CSV é bem comum, sua importação é simples. Quando trabalhamos com outros formatos de arquivo, devemos nos atentar a como importa-los. Aqui existem muitas possibilidades, podemos coletar dados da web, importar dados de outro ambiente (como R, por exemplo), se estamos com um formato incomum, talvez precisaremos de algum pacote que converta ele em algo que o Pandas possa entender. Que tipo de dado você tem?<jupyter_code># Quando verificamos que tipo de dado é 'iris', vemos que o Pandas já converte o arquivo .csv em um Dataframe.
type(iris)
# Outra possibilidade de visualização é com os comandos head() e tail() ou describe().
iris.head()
iris.tail()
iris.describe() # species não foi incluído pois contém strings, e não floats.
# Podemos selecionar colunas específicas com colchetes e a string que dá nome à coluna.
iris['species']
# Podemos combinar com head():
iris['species'].head()
# ou com iloc[], que permite escolher as linhas:
iris['species'].iloc[10:51]<jupyter_output><empty_output><jupyter_text>Utilizamos o Pandas para importar nosso arquivo .csv em um *dataframe* armazenado na variável `iris`. Além de importar, o Pandas também possui o método `plot()`. Escolhemos nossos eixos bem como o tipo de Plot.<jupyter_code># Vamos tentar um scatter plot simples com o método plot(). Repare nos parâmetros definindo x, y e 'kind'
iris.plot(x='SepalLengthCm', y='SepalWidthCm', kind = 'scatter')
# Agora um pouco mais sofisticado, com cores.
# ax é um objeto da biblioteca Matplotlib, que corresponde a um eixo ou porção de uma figura
# Vamos projetar três plots, um para cada espécie, porém todos no mesmo eixo (ax)
# Também é possível adicionar labels e um título para o eixo.

ax = iris[iris.species=='Iris-setosa'].plot.scatter(x='SepalLengthCm', y='SepalWidthCm', 
                                                    color='red', label='setosa')
iris[iris.species=='Iris-versicolor'].plot.scatter(x='SepalLengthCm', y='SepalWidthCm', 
                                                color='green', label='versicolor', ax=ax)
iris[iris.species=='Iris-virginica'].plot.scatter(x='SepalLengthCm', y='SepalWidthCm', 
                                                color='blue', label='virginica', ax=ax)
ax.set_title("scatter")<jupyter_output><empty_output><jupyter_text>Esse último snippet foi retirado [deste notebook Kaggle.](https://www.kaggle.com/xuhewen/iris-dataset-visualization-and-machine-learning)Na verdade, o Pandas possui toda uma biblioteca de plotagem (pandas.plotting) que funciona por meio da API `matplotlib.pyplot`. Temos, por exemplo, os métodos `radviz()` e `parallel_coordinates()`, usados para visualizar dados multivariados. Exemplos retirados da [galeria do Pandas.](http://pandas.pydata.org/pandas-docs/version/0.13/visualization.html)<jupyter_code># Precisamos importar os métodos da biblioteca plotting do Pandas
from pandas.plotting import radviz, parallel_coordinates
# O método requere somente o dataframe e a seleção da coluna com nomes das classes (strings)
radviz(iris,'species')
# Vamos experimentar com o outro método, parallel_coordinates()
parallel_coordinates(iris, 'species')

# Aparentemente, o radviz() foi melhor que este pois ilustrou a diferença em 'SepalWidth' observada no scatterplot.<jupyter_output><empty_output><jupyter_text>Até agora, vimos como:* Abrir o Jupyter Notebook* Importar as bibliotecas Pandas e Matplotlib.pyplot* Usar o método do Pandas `pd.read_csv()`para importar o .csv como um Dataframe.* Selecionar porções do Dataframe com métodos como `head()` ou `iloc[]`.* Usar o Matplotlib para visualizar plots do Pandas.Conhecendo e usando as bibliotecas que se aprende a linguagem; existem galerias no site do [Pandas](http://pandas.pydata.org/pandas-docs/version/0.13/visualization.html) e [Matplotlib](https://matplotlib.org/users/pyplot_tutorial.html) com diversos exemplos, entretanto é melhor concentrar em um curso de fundamentos de Python antes. Abaixo exemplos da segunda galeria. Repare que com bibliotecas como Pandas e [NumPy](http://www.numpy.org/) (uma dependência do Pandas), é possível criar 'séries' numéricas para exemplos de plots.<jupyter_code>plt.plot([1,2,3,4])
plt.ylabel('some numbers')
plt.show()
# Vamos importar a biblioteca NumPy como np
import numpy as np

# Como mencionado anteriormente, podemos usa-la para criar uma série numérica.
t = np.arange(0., 5., 0.2)

# E plotar essa série de diferentes formas
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()
# Aqui temos um exemplo mais avançado de como fazer um plot com múltiplas figuras

# Essa linha estabelece uma função que gera os valores que serão plotados.
def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

# t1 e t2 são séries numéricas que serviram de argumento para a função f(t).
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

# Queremos UMA figura
plt.figure(1)
# Com DOIS subplots. Na segunda linha vamos plotar o primeiro subplot
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

# Plotando o segundo subplot
plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')

# Mostrar a figura
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08472752703211577, 'fraction_numerical': 0.01205013717790091, 'mean_word_length': 4.087575259989053, 'pattern_counts': {'":': 1, '<': 28, '<?xml version=': 0, '>': 28, 'https://': 22, 'lorem ipsum': 0, 'www.': 4, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 19, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '180958', 'license': 'BSD-3-Clause', 'n_tokens_mistral': 6372, 'n_tokens_neox': 6174, 'n_words': 2290, 'path': 'notebooks/.ipynb_checkpoints/modulo_2_completo-checkpoint.ipynb', 'repo_name': 'Grupo-de-Oceanografia-Costeira/CursoPraticasProg', 'size': '18589'}