gists/data-science-gist-01-pt.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.8",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3"
    },
    "nteract": {
      "version": "0.14.5"
    },
    "colab": {
      "name": "data-science-gist-01-pt.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NxHIrnUUoQC-",
        "colab_type": "text"
      },
      "source": [
        "[Índice](https://github.com/jobdiogenes/data-science-recipes/blob/master/gists/index.md)\n",
        "# Série Receitas para Ciência de Dados \n",
        "## Episódio 1 - Apresentação, Conhecendo o Python\n",
        "### Introdução\n",
        "> ** Por que fazer isso? **\n",
        "A razão desta série de _gists_ é ajudar pessoas que vêm da biologia ou da ecologia a nadar e mergulhar na alfabetização em Ciência de Dados. Para esta tarefa optei por usar python. Existem muitos cursos e tutoriais para aprender python e Data Science, como os das pessoas do [carpentries.org] (https://carpentries.org/) que fornecem excelentes lições de ciência de dados para trabalhar com ecologia, genômica, ciências sociais, geoespacial e outros. Como o [Python for ecologists] (https://mesfind.github.io/python-ecology-lesson/). Esta série é um material complementar para os interessados em ciência de dados. E para pessoas querendo algo mais geral sobre Ciência de Dados e Python em português, o pessoal do IME da USP, disponibilizou [Como Pensar Como um Cientista da Computação](https://panda.ime.usp.br/pensepy/static/pensepy/index.html) um ótimo material e que inclui exercícios .  \n",
        "\n",
        "> **OBS** esse episódio é um pouco longo, pois abrange uma série de conceitos básicos. Os próximos serão mais curtos e práticos. Como é o conceito de GISTs.\n",
        "\n",
        "### Meta\n",
        "Ter as habilidades necessárias para extrair, manipular, analisar e visualizar dados públicos (ex: [FishBase](https://fishbase.org), [GBIF](https://www.gbif.org/), [GenBank](https://www.ncbi.nlm.nih.gov/genbank/), [Jbrj](https://www.jbrj.gov.br) usando a API do repositório (REST, GraphQL, FALCOR. GRPC)\n",
        "\n",
        "### Público alvo\n",
        "Pessoal da Biologia, Ecologia ou outras que apenas que tenham interesse em extração de dados de repositórios de dados públicos. \n",
        "\n",
        "### Como usar este material?\n",
        ">Todo este material está disponível como um publicação _gist_ e como um jupyter notebook, que pode ser baixado para ser executado através do [Jupyter](https://www.jupyter.org), [Nteract](https://nteract.io) ou outra plataforma que abra notebooks Jupyter (.ipynup) que tenha sido instalado no seu computador ou remotamente. \n",
        "\n",
        "Kernighan and Ritchie, autores da linguagem C, escreveram que programar é como andar de bicicleta, se aprende andando. Eu por outro lado associo aprender a programar como aprender a cozinhar, que envolve conhecer as ferramentas e ingredientes, praticar e estar sempre aprendendo e aprimorando. Cozinharr é importante assim como programação, mas é só quando temos necessidades ou desafios que realmente adquirimos habilidades. Há diversos cursos gratuitos ou baixo custo online de programação com ótima qualidade, usando diversos métodos de aprendizado e tecnologias assistivas. No entando fazer esses cursos sem realmente ter um desafio ou uma necessidade a responder, acaba não sendo muito frutífero. Falo isso por experiência própria, já fiz excelentes cursos online, resolvi os exercícios todos. Mas isso dificilmente nos habilita a fazer perguntas que possam ser resolvidas com o curso realizado, e realmente resolver problemas após o curso. Quem já fez algum curso de estatística entende isso. Aqui optamos pela linha de orientação, ou seja esse material é como um guia para quem esta começando, já conhece um pouco ou quer aprender a extrair dados. Por isso antes de começar, visite um ou mais repositórios de dados abertos disponíveis online, veja quais são os dados disponíveis e pense em algo que gostaria de fazer e **escreva isso** como meta! \n",
        "\n",
        "> **Ps:** conforme você for aprendendo, essa meta inicial irá sendo lapidada. Então, não se preocupe agora em ter uma meta muito bem definida. Se não tem nenhum lugar pra ir, qualquer um serve, ou até um lugar que outra pessoa esta indo e você deseja ir junto.\n",
        "\n",
        "### Onde executar e treinar com o python.\n",
        "Opções:\n",
        "\n",
        "1. Usar um ambiente python online.\n",
        "1. Usar o python no seu computador.\n",
        "1. Usar o Jupyter ou o Nteract.\n",
        "\n",
        "> **Opte pela opção 1** caso você tenha acesso fácil para internet, pois assim basta ter um computador com navegador. Há varios serviços _online_ e todos podem ser usados sem custo. Em geral não precsa fazer seu cadastro, basta fazer login usando uma conta no Gmail, Facebook ou GitHub e dar autorização. \n",
        "\n",
        "#\n",
        "> **Opte pela opção  2**, caso não tenha acesso fácil para internet, ou queira simplesmente usar no seu próprio computador. Se é usuário Linux ou MacOSX (10.2 acima) esses sistemas já vem com o python instalado. Aos usuários Windows que queiram usar no seu computador, também pode ser feito. Mas não cobrimos aqui como fazer. Há diversos guias sobre isso. Pergunte ao Google: \"como instalar o python no Windows\".\n",
        "\n",
        "#\n",
        "> **Opte pela opção 3**, caso já não seja iniciante.\n",
        "\n",
        "__Alguns serviços online com Python:__\n",
        "\n",
        "1. [Pyfiddle](https://pyfiddle.io/)\n",
        "1. [Repl.it](https://repl.it)\n",
        "1. [Katakoda Python Playground](https://www.katacoda.com/courses/python/playground)\n",
        "1. [Colab](https://colab.research.google.com/)\n",
        "\n",
        "> **Escolha** sempre o Python Versão 3 acima (3.6, 3.7, ...) \n",
        "\n",
        "### Quais são as capacidades necessárias a se obter?\n",
        "O ideal para quem esta aprendendo uma linguagem de programação como Python, R,Julia, etc, é já ter conhecimentos básicos sobre lógica. Este material faz uso de lógica de programação, mas não é o foco de ensino. Existem muitos materiais, livros e cursos bons disponíveis (Use o Google: \"lógica de programação\". Um livro que recomendo é o [Nature, In Code](http://www.natureincode.com/) de Marcel Salathé, que ensina programação usando consceitos básicos na biologia (seleção natural, epidemiologia, evolução da cooperação, etc) usando a linguagem JavaScript. \n",
        "\n",
        "Neste episódio temos os seguinte itens python:\n",
        "\n",
        "\n",
        "1.  [X]  Tipos básicos de dados, conversão e comentários\n",
        "1.  [X]  Operações (lógicas e numéricas)\n",
        "1.  [x]  Objetos/Classes\n",
        "1.  [X]  Coleções (Array/List, Tuple, Set, Dictionary)\n",
        "1.  [X]  Condicionais (if, else), Ciclos (for loop, while)\n",
        "\n",
        "> **ATENÇÃO!** Não copie, escreva!! Sim é possível usar esse material somente lendo, abrindo no Jupyter/Nteract/Colab, ou copiando e colando. E ao favor isso, você acaba até não cometendo erros de digitação, e **sem erros, sem aprendizado**. Somente escrevendo que você realmente irá memorizar. Então agora abra o **\"python versão 3.XXX\"**  online ou local e comece a fazer as atividades a seguir. É claro não é necessário escrever os comentários."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8GhOelJFoQDD",
        "colab_type": "text"
      },
      "source": [
        "### Item 1 - Tipos básicos de dados, conversão e comentários. \n",
        "\n",
        "**Comentários** no python um comentário é definido usando o **#**\n",
        "\n",
        "Exemplo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8k7oHxwNoQDG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Isso é um exemplo de comentário\n",
        "# O python trata como comentário tudo que for digitado após o \n",
        "# simbolo # e não tem uma sintáxe própria pra comentários longos\n",
        "# Mas ..."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false,
        "id": "j2u-wXmBoQDU",
        "colab_type": "text"
      },
      "source": [
        "**Textos** _strings_ são definidos entre aspas simples **'** ou aspas duplas **\"** "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g9m5fxOYoQDY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Código Exercício Exemplo:\n",
        "# Isso é um exemplo de texto com aspas simples\n",
        "nome = 'Fulano da Silva Sauro'\n",
        "\n",
        "# Isso é um exemplo de texto com aspas duplas\n",
        "name = \"Michael Sauro's\" \n",
        "\n",
        "# Isso é um exemplo de texto longo com multiplas linhas\n",
        "descricao = \"\"\"\n",
        "Textos com mais de uma linha podem ser definidos\n",
        "entre 3 aspas simples ou duplas\n",
        "\"\"\"\n",
        "description = '''\n",
        "This is a multiline example text\n",
        "under triple single cote\n",
        "'''\n",
        "\"\"\"\n",
        "Em python textos longos são definidos usando aspas triplas, \n",
        "mas se isso não estiver sendo usado para atribuir a uma variável o python ignora.\n",
        "Assim pode-se usar esta artimanha para escrever comentários maiores \n",
        "sem ter de anteceder para cada linha o #\n",
        "\"\"\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false,
        "id": "b--5MA93oQDl",
        "colab_type": "text"
      },
      "source": [
        "**Números** básicos em python são:\n",
        "\n",
        "os _inteiros_ ex: **1** \n",
        "\n",
        "os números _reais_ ou _ponto-flutuante_ ex: **4.1**\n",
        "\n",
        "os números complexos ex: **2j**\n",
        "\n",
        "ou _zeros-a-direita_ ex: **3e2** é o mesmo que **300**  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M1l_SMyJoQDn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Código exercício exemplo\n",
        "# Criando variávels com números e conversões\n",
        "# **Atenção** O Python diferencia maiúsculas de minúsculas. \n",
        "# Assim, uma variável XX é outra Xx , são variáveis diferentes. \n",
        "# E isso vale para funções e métodos para objtetos python.\n",
        "# Não se preocupe mais a frente será explicado o que são objetos e métodos.\n",
        "\n",
        "# criando 4 variáveis\n",
        "x = 2\n",
        "y = 3.1\n",
        "z = -4.1e2\n",
        "c = 3j\n",
        "# exibindo o tipo da variável\n",
        "print(type(x))\n",
        "print(type(y))\n",
        "print(type(z))\n",
        "print(type(c))\n",
        "\n",
        "# convertendo de um tipo a outro\n",
        "print(int(y))\n",
        "print(float(2))\n",
        "print(complex(z))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false,
        "id": "vsf_lD0koQDu",
        "colab_type": "text"
      },
      "source": [
        "### Item 2 - Operações numéricas e lógicas\n",
        "\n",
        "\n",
        "Operações com números:\n",
        "\n",
        "Somar: **+** ex: 2+3 \n",
        "\n",
        "Subtrair: **-** ex: 3-2\n",
        "\n",
        "Dividir: **/** ex: 4/2\n",
        "\n",
        "Dividir Inteiro: **//** ex: 3//2 é o mesmo que int(3/2) \n",
        "\n",
        "Módulo:  **%** ex: 2%2\n",
        "\n",
        "Elevado:  __**__ ex: 2**3 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iLH00zkooQDw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Código exemplo\n",
        "x = 2\n",
        "y = 3.1\n",
        "z = x + y\n",
        "p = 2**3 \n",
        "# o python permite fazer uma operação sobre si mesma\n",
        "# por exemplo \n",
        "x = x + 5\n",
        "# é o mesmo que \n",
        "x += 5\n",
        "# para isso você pode usar qualquer das operações matemáticas e qualquer expressão numérica"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false,
        "id": "NoHGymGOoQD3",
        "colab_type": "text"
      },
      "source": [
        "**Operadores de comparações**\n",
        "\n",
        "_Operação \tSignificado_\n",
        "\n",
        "**<** \t        menor que\n",
        "\n",
        "**<=** \t        menor ou iqual que\n",
        "\n",
        "**\\>**\t        maior que\n",
        "\n",
        "**\\>=**         maior ou igual que\n",
        "\n",
        "**==** \t        igual\n",
        "\n",
        "**!=** \t        diferente\n",
        "\n",
        "**Operadores Lógicos**\n",
        "\n",
        "**and** retorna True se ambos conteúdos são verdadeiros\n",
        "\n",
        "**or**   retorna True se um dos conteúdos for verdadeiro\n",
        "\n",
        "**not**  retorna o inverso lógico do conteúdo \n",
        "\n",
        "**Operadores de identidade**\n",
        "\n",
        "**is** retorna True se ambas variáveis são o mesmo objeto\n",
        "\n",
        "**is**   retorna True se são variáveis distintas\n",
        "\n",
        "** Operadores de participação **\n",
        "\n",
        "**in**  retorna True se um valor pertence a sequencia\n",
        "\n",
        "**not in** retorna True se um valore não pertence a sequencia"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N49y-VSmoQD5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Código exemplo\n",
        "n = 1\n",
        "m = 2\n",
        "m < n\n",
        "# retorna False\n",
        "n == 1\n",
        "# retorna True \n",
        "# ou seja apenas um = é uma atribuição e somente == é uma comparação. \n",
        "m = n \n",
        "# a expressão a seguir retorna True\n",
        "n == 1 and m>= 2\n",
        "# e esta retorna False\n",
        "not n == 1\n",
        "# Como exemplo de identidados usaremos os arrays \n",
        "x = [\"cascudo\",\"pintado\"]\n",
        "y = [\"cascudo\",\"pintado\"]\n",
        "z = y \n",
        "# a expressão a seguir retorna True\n",
        "'pintado' in x \n",
        "# já a expressão abaixo também retorna True pois a comparação é ser identica \n",
        "'Pintado' not in x\n",
        "\n",
        "# já a expressão abaixo volta True porque ao atribuir uma variavel array pra outra variável\n",
        "# cria-se um novo nome para uma mesma variável. mas isso só vale para listas \n",
        "print(z is y)\n",
        "# e esta retorna False pois mesmos sendo conetúdos iguais são variáveis diferentes \n",
        "print(y is x)\n",
        "# já esta volta True pois ambas tem o mesmo conteúdo\n",
        "print(x == y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AfoR-cTDoQEA",
        "colab_type": "text"
      },
      "source": [
        "### Item 3 - Objetos/Classes\n",
        "O python é uma linguagem de programação orientada a objetos, quase tudo em python é um objeto. Caso você não entenda o conceito, vamos aqui dar uma explicação suscinta usando o python. E por favor **não se desespere**, a idéia aqui é apenas para você saber o que são objetos, atributos e métodos, pois esses atrributos e métodos serão utilizados nos exemplos e exercícios. No momento você não vai precisar criar suas próprias classes. Vai apenas usar as que vem com o próprio python e com as biliotecas.\n",
        "\n",
        "> **Objeto** é um conceito onde uma determinada variável ou função possuem __atributos__ e __métodos__, os quais se associam a seu objetivo principal. \n",
        "\n",
        "> **Classe** por sua vez é a forma de descrever um modelo de objeto com seus atributos e métodos\n",
        "\n",
        "Por exemplo: Vamos dizer que vou criar uma classe com nome **Num** e definir atributos e métodos a mesma."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "outputHidden": false,
        "inputHidden": false,
        "id": "1HgL0vLxoQEC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# definindo a classe num\n",
        "class Num:\n",
        "  def __init__(self, valor=0):\n",
        "    self.valor = valor \n",
        "\n",
        "  def soma(self, quanto=1 ):\n",
        "      self.valor += quanto\n",
        "      return self.valor\n",
        "    \n",
        "  def exibe(self):\n",
        "      print(self.valor)\n",
        "    \n",
        "# criando um objeto \n",
        "x = Num()\n",
        "# chamando um método\n",
        "x.exibe()\n",
        "# criando o objeto com um valor inicial diferente do padrão\n",
        "y = Num(4)\n",
        "y.exibe()\n",
        "# acessando um atributo do objeto\n",
        "z = y.valor\n",
        "print(z)\n",
        "\n",
        "# como dito anteriormente quse tudo em python são objetos.\n",
        "# por exemplo os números possuem métodos padrões.\n",
        "# como:\n",
        "(4.5).is_integer()\n",
        "# ou \n",
        "N = 4.5\n",
        "N.is_integer()\n",
        "# retorna False, porque N se trata de um número com decimais."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q-Gv14mBoQEI",
        "colab_type": "text"
      },
      "source": [
        "Assim sempre que estiver fazendo algo procure antes ver se já existe um método ou atributo que possa lhe ser útil."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false,
        "id": "BjKNOrBSoQEL",
        "colab_type": "text"
      },
      "source": [
        "### Item 3 - Coleções\n",
        "\n",
        "Conhecer e saber trabalhar com dados do tipo coleção é o fundamento principal para quem quer extrair e manipular dados abertos de repositórios. O python oferece nativamente 4 tipos de dados de coleções, são eles:\n",
        "\n",
        "- **Lista**  _list_ é assim como um _array_ em outras linguagens é uma coleção de um ou mais valores mutáveis, indexados começando pelo índice 0 (zero) e definidos entre [ ] E permite duplicação dos elementos.\n",
        "- **Tupla** _tuple_ é uma coleção indexada imutável de valores. Ou seja depois de criado não pode alterar, incluir or tirar elementos.  São definidos entre ( ). Permite elementos duplicados.\n",
        "- **Conjunto** _set_ é uma coleção de valores não indexados e que não permite duplicação de seus elementos\n",
        "- **Dicionário** _dictionary_ é um conjunto de valores mutáveis indexados por chaves nomeadas.  \n",
        "\n",
        "> **OBS** como será mostrado a seguir essas funções nativas do python para trabalhar com conjunto são muito poderosas e permitem fazer muitas coisas com facilidade e eficiência, mas além disso há uma série de bibliotecas que acrescentam mais facilidades. Por exemplo, o [Pandas](https://pandas.pydata.org/) que é uma das principais ferramentas para análise de dados em python  usa uma estrutura própria o  Pandas Data Frame e Series. Como também há ferramentas para acessar bancos de dados SQL e NO-SQL. Que serão tratados em episódios posteriores. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XblmN0d5Fr8_",
        "colab_type": "text"
      },
      "source": [
        "**LISTAS** (_list_): operações e métodos\n",
        "\n",
        "\n",
        "---\n",
        "> **Quando usar listas?** listas são muito úteis quando precisamos lidar com dados dinâmicos de forma sequencial, por exemplo temos um conjunto de dados que precisamos por incluir, alterar, excluir dados e  colocar em ordem sequencial.  \n",
        "\n",
        "**Operadores lógicos:**\n",
        "\n",
        "**+**  retorna a união de duas listas\n",
        "\n",
        "**\\*** retorna a uma união de N listas\n",
        "\n",
        "**in** retorna se un valor esta em uma lista\n",
        "\n",
        "**is** retorna se uma variável é uma referência/apelido de uma lista\n",
        "\n",
        "**not in** e **not is** a negação das operações anterioes\n",
        "\n",
        "**Métodos**\n",
        "\n",
        "**append()**\tAdiciona um elemento ao final da lista\n",
        "\n",
        "**clear()**\tRemove todos elementos\n",
        "**copy()**\tRetorna uma cópia da lista\n",
        "\n",
        "**count()**\tRetorna quantos elementos tem um valor específico\n",
        "\n",
        "**extend()**\tAdiciona uma lista de elementos ao final da lista\n",
        "\n",
        "**index()**\tRetorna a posição do primeiro elemento encontrado com um determinado valor\n",
        "\n",
        "**insert()**\tInclui um elemento numa posição específica\n",
        "\n",
        "**pop()**\tRemove o último elemento ou de uma posição específica\n",
        "\n",
        "**remove()**\tRemove o primeiro elemento encontrado com um determinado valor\n",
        "\n",
        "**reverse()**\tOrdena a lista em ordem decrescente\n",
        "\n",
        "**sort()**\tOrdena a lista em ordem crescente"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "outputHidden": false,
        "inputHidden": false,
        "id": "xCciTTJzoQEO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# código exemplo - exercício\n",
        "# unindo duas listas\n",
        "lista1 = [1,2,3]\n",
        "lista2 = ['um','dois','três']\n",
        "lista3 = list1 + list2\n",
        "print(list3)\n",
        "\n",
        "# replicando uma lista\n",
        "lista4 = lista1 * 2\n",
        "print(lista4,'\\n')\n",
        "\n",
        "# contando o nº de elementos igual a um valor\n",
        "print(lista4.count(2))\n",
        "print(lista3.count('dois'),'\\n')\n",
        "\n",
        "# acessando um único valor pelo índice observe que começa em 0\n",
        "peixes = ['tilápia','dourado', 'cascudo']\n",
        "print(peixes[1],'\\n')\n",
        "\n",
        "# adcionando um elemento com o método append\n",
        "peixes.append('lambari')\n",
        "print('Peixes:',peixes,'\\n')\n",
        "\n",
        "peixes2 = ['sagui','corimba']\n",
        "# excluindo um elemento específico usando o método remove\n",
        "peixes2.remove( 'sagui' )\n",
        "\n",
        "# alterando um elemento - observe que foi removido um elemento antes\n",
        "peixes2[0] = 'curimba'\n",
        "print('Peixes2:',peixes2)\n",
        "\n",
        "# extendendo a lista com vários elementos\n",
        "peixes2.extend(['lambari','tilápia'])\n",
        "print('Peixes:',peixes2,'\\n')\n",
        "\n",
        "# contando o tamanho\n",
        "print(len(peixes2))\n",
        "      \n",
        "# lista multi dimensional\n",
        "peixes3 = [peixes,peixes2]\n",
        "print('Multi:',peixes3)\n",
        "\n",
        "# criando uma referencia a uma lista\n",
        "fishs = peixes\n",
        "print('É o mesmo:',fishs is peixes)\n",
        "print(fishs)\n",
        "\n",
        "# encontrando a posição de um valor numa lista\n",
        "p = peixes.index('cascudo')\n",
        "print('Posição:',p)\n",
        "\n",
        "# um problema do método index() e remove() é que se o valor não existir eles causam erro\n",
        "# por isso pra usar ele deve-ve verificar antes se o valor existe ou usar funções auxiliares \n",
        "# que já tratam os erros \n",
        "\n",
        "# inserindo um elemento numa posição específica\n",
        "peixes.insert(1, 'piranha')\n",
        "print('Peixes:',peixes,'\\n')\n",
        "\n",
        "# observe agora que ao exibir fishs ele contém o mesmo conteúdo de peixes pois é apenas uma \n",
        "# referência para peixes e não uma cópia\n",
        "# para se obter uma cópia podemos usar o método copy ou outro método que retorne \n",
        "# o conjunto todo. aqui redefinimas a variável fishs como uma cópia de peixes\n",
        "copia  = peixes.copy()\n",
        "print('Iguais:',copia == peixes)\n",
        "print('É o mesmo:',copia is peixes)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6jvo7X9FChOg",
        "colab_type": "text"
      },
      "source": [
        "**FATIAS**- no python o conteúdo de uma __lista ou tupla__ podem ser obtido através de referenciamento de posição usando dois pontos : \n",
        "\n",
        "Por exemplo para pegar uma fatia da lista **peixes[I:F:Q]** temos que:\n",
        "\n",
        "**P** é  o primeiro elemento da fatia se omitida considera-se o início, se negativo pelo final\n",
        "\n",
        "**S** é  o limite superior da fatia, se omitido retorna todo resto.\n",
        "\n",
        "**I**  incremento, se omitido é de um em um, se negativo devolve em ordem inversa  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ss6BRs6UFACD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l = [\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
        "# Assim para pegar o segundo ao e terceiro elemento temos\n",
        "print(l[1:3])\n",
        "\n",
        "# para os dois últimos temos\n",
        "print(l[-2:])\n",
        "\n",
        "# para os 3 primeiros \n",
        "print(l[:-3])\n",
        "\n",
        "# para os 2 últimos\n",
        "print(l[-2:])\n",
        "\n",
        "# pega a partir do 3 elemento (d) em ordem inversa pegar de 2 em 2 para trás\n",
        "print(l[-3::-2])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r4KLRwnA85q9",
        "colab_type": "text"
      },
      "source": [
        "**TUPLAS** (_tuple_) : operações e métodos\n",
        "\n",
        "---\n",
        "> **Quando usar Tuplas?** como explicado acima tuplas são como Listas mas imutáveis. A vantagem das tuplas é consumo de memória. Se você vai trabalhar com algo que não precisa alterar é vantajoso. Um exemplo prático, você pegou de uma base de dados uma lista de nomes de espécies de peixes e rios. Ai você quer trabalhar só com algumas espécies ou rios. Então pode criar uma tupla só com quais precisa e usar ela para pesquisar nessa lista de nomes e espécies. Isso é importante tanto pra economia de memória como pra evitar erros. Pois um erro comum em programdores novatos em python é quando quer fazer uma comparação usar = ao invés de ==. se você tem uma tupla do lado esquerdo isso causa um erro,pois tuplas são imutáveis, mas se for uma lista você estara alterando-a.  \n",
        "\n",
        "\n",
        "**Operadores lógicos:**\n",
        "\n",
        "**+**  retorna a união de duas listas\n",
        "\n",
        "**\\*** retorna a uma união de N listas\n",
        "\n",
        "**in** retorna se un valor esta em uma lista\n",
        "\n",
        "**is** retorna se uma variável é uma referência/apelido de uma lista\n",
        "\n",
        "**not in** e **not is** a negação das operações anterioes\n",
        "\n",
        "**Métodos**\n",
        "\n",
        "**count()**\tRetorna quantos elementos tem um valor específico\n",
        "\n",
        "**index()**\tRetorna a posição do primeiro elemento encontrado com um determinado valor\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KFptCuytbY0E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Criando uma tupla\n",
        "rios_pr = (\"Ivaí\",\"Piquiri\", \"Iguaçu\", \"Paraná\", \"Piquiri\")\n",
        "rios_sc = (\"Rio das Pedras\", \"Rio do Peixe\", \"Rio Preto\", \"Rio Canoinha\", \"Rio Uruguai\")\n",
        "rios_rs = (\"Rio Turvo\",\"Rio Gravatai\", \"Rio Ibicuí\", \"Rio Carreiro\",\"Rio Uruguai\")\n",
        "# exibindo o 3º elemento - lembre-se sempre que o índice começa em 0\n",
        "print(rios_pr[2])\n",
        "\n",
        "# criando uma tupla com rios dos 3 estados\n",
        "rios_sul = rios_pr + rios_sc + rios_rs\n",
        "\n",
        "# contar quantas vezes aparece o Rio Uruguai\n",
        "print(rios_sul.count('Rio Uruguai'))\n",
        "\n",
        "# exibir os 2 ultimos elementos \n",
        "print(rios_pr[-2:])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DcBIBAMUk60a",
        "colab_type": "text"
      },
      "source": [
        "**CONJUNTOS** (_set_): operadores e métodos\n",
        "\n",
        "---\n",
        "> **Quando usar conjuntos?** conjuntos são muito úteis quando se quer trabalhar com coleções de dados não repetidos e desejamos obter informações sobre eles. Por exemplo, você tem um conjunto especies de peixes de seu interesse e uma lista rios cada um com um conjunto de espécies de peixes e você deseja saber quais especies do seu conjunto estão em cada rio. Ou simplesmente, quer uma lista de todas as espécies de todos os rios sem duplicação. O python ofecere para trabalhar com conjuntos operações e métodos tais quais usamos ao lidar com conjuntos na matemática, tais como *união*, *interseção*, *diferença*, etc. Ou seja, é um ferramenta muito útil e poderosa que pode ajudar o cientista de dados a obter uma série de resultados com poucas linhas de programação.   \n",
        "\n",
        "**Operações com conjuntos**\n",
        "\n",
        "Considerando  os conjuntos **s** e **p** e o elemento **t**\n",
        "\n",
        "Método/função | Operador equivalente | Ação\n",
        "----------|----------------------|-----\n",
        "len(s) | | retorna o nº de lementos do conjunto s\n",
        "t **in** s | | verifica se t pertence a s\n",
        "t **not in** s | | veifica se t não pertence a s\n",
        "| s **!=** p | verifica se s não é igual a p  \n",
        "s.**isdisjoint(**p**)** | | verifica se s não tem elementos em comum com p\n",
        "s.**issubset(**p**)** | s **<=** p| verifica se todos elementos de s estão em p\n",
        "| s **<** p | verifica se s  **<=** p e  s **!=** p\n",
        "s.**issuperset(**p**)** | s **>=** p | verifica se todos elementos de p  estão em s\n",
        "| s **>** p | verifica se s  **>=** p e  s **!=** p\n",
        "s.**union(**p**)** | s **\\|** p | retorna um conjunto novo com os valores únicos de s e p\tjuntos\n",
        "s.**intersection(**p**)** | s **&** p | retorna um conjunto novo de elementos comuns a s e p\n",
        "s.**difference(**p**)** | s **-** p | retorna um conjunto novo de elementos que estão em s mas não em p \n",
        "s.**symmetric_difference(**t**)** |  s **^** t | retorna um conjunto novo de elementos que estão em s ou p mas não em ambos\n",
        "s.**copy()** | | retorna uma cópia de s \n",
        "s.**update(**p**)** | s **\\|=** p | inclui em s todos elementos de p\n",
        "s.**intersection_update(**p**)** | s **&=** p | faz s ter apenas os elementos que estão também em p\n",
        "s.**difference_update(**p**)** |  s **-=** p | remove de s os elementos que estão em p\n",
        "s.**symmetric_difference_update(**p**)** | s **^=** p | faz s ter apenas os elementos que estão neles mas não em ambos\n",
        "s.**add(**t**)** | | adciona em s o elemento t\n",
        "s.**remove(**t**)** || remove o elemento t de s, causa erro se não existir\n",
        "s.**discard(**t**)** || remove o elemento t de s \n",
        "s.**pop()** || remove e retorna um elemento qualquer de s e causa erro se s estiver vazio.\n",
        "s.**clear()** || remove todos elementos de s\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X1eH1G6pPEtT",
        "colab_type": "code",
        "outputId": "035be5f1-269f-4f39-b0e0-820b9e4bd5ad",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        }
      },
      "source": [
        "# criando conjuntos com nomes de rios\n",
        "pr = {\"Rio Ivaí\",\"Rio Piquiri\", \"Rio Iguaçu\", \"Rio Paraná\", \"Rio Piquiri\"}\n",
        "sc = {\"Rio das Pedras\", \"Rio do Peixe\", \"Rio Negro\", \"Rio Canoinha\", \"Rio Uruguai\", \"Rio Pelotas\"}\n",
        "rs = {\"Rio Turvo\",\"Rio Gravatai\", \"Rio Ibicuí\", \"Rio Carreiro\",\"Rio Uruguai\"}\n",
        "\n",
        "# adcionando um rio ao conjunto pr e exibir conjunto pr\n",
        "pr.add('Rio Negro')\n",
        "print(pr)\n",
        "\n",
        "# verifica se Rio Turvo pertence a rs\n",
        "print('Rio Turvo esta no RS?', 'Rio Turvo' in rs )\n",
        "\n",
        "# adcionando vários rios a rs \n",
        "rs |= {'Rio Jacuí', 'Rio Caí', 'Rio dos Sinos', 'Rio Pelotas'}\n",
        "print(rs)\n",
        "\n",
        "# exibir os rios que pertencem a rs e sc\n",
        "print( rs & sc )\n",
        "\n",
        "# exibir os rios que estãoem pr mas não em sc\n",
        "print( pr - sc )\n",
        "\n",
        "# criar um conjunto com pr sc e rs\n",
        "sul = pr | sc | rs\n",
        "print(sul)\n",
        "\n",
        "# exibir quantos rios estão em sc e rs\n",
        "print(len( sc & rs))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'Rio Paraná', 'Rio Ivaí', 'Rio Negro', 'Rio Iguaçu', 'Rio Piquiri'}\n",
            "Rio Turvo esta no RS? True\n",
            "{'Rio Carreiro', 'Rio dos Sinos', 'Rio Ibicuí', 'Rio Gravatai', 'Rio Pelotas', 'Rio Caí', 'Rio Uruguai', 'Rio Jacuí', 'Rio Turvo'}\n",
            "{'Rio Pelotas', 'Rio Uruguai'}\n",
            "{'Rio Iguaçu', 'Rio Paraná', 'Rio Ivaí', 'Rio Piquiri'}\n",
            "{'Rio Paraná', 'Rio Carreiro', 'Rio dos Sinos', 'Rio Ibicuí', 'Rio Gravatai', 'Rio Ivaí', 'Rio do Peixe', 'Rio Pelotas', 'Rio Caí', 'Rio Uruguai', 'Rio Negro', 'Rio Jacuí', 'Rio Iguaçu', 'Rio das Pedras', 'Rio Canoinha', 'Rio Piquiri', 'Rio Turvo'}\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7kIO8unnbPMt",
        "colab_type": "text"
      },
      "source": [
        "**DICIONÁRIOS** (_dictionary_) \n",
        "\n",
        "----\n",
        "> **Quando usar dicionários?** usamos dicionários quando precisamos ter uma composição contendo várias informações que podem ou não existir em todas instâncias. Dicionários são estruturas fundamentais pra o cientista de dados. Quase todos repositórios públicos fornecem dados em formato JSON os quais podem ser tratados como dicionários em Python. Ou mesmo quando o repositório nãofornece nativamente em JSON há bibliotecas de acesso a endereços de internet em python que convertem automaticamente para JSON e porfim para dicionários em python. Repositórios também fornecem em formato XML, o qual também há bliotecas em python para acessar. Mas isso só iremos tratar mais a frente, quando se tratar de extrair dados de sites sem API próprias.\n",
        "\n",
        "**Operações com dicionários:**\n",
        "\n",
        "Considerando o dicionario **d**\n",
        "\n",
        "Método | Descrição da ação\n",
        "-------|------------------\n",
        "d.**clear()** | remove todos elementos do dicionário\n",
        "d.**copy()** | retorna uma cópia do dicionário\n",
        "d.**fromkeys()** | retorna um dicionário com as chaves e valores específicos\n",
        "d.**get(**C**)** | retorna o valor para a chave C  \n",
        "d.**items()** | retorna uma lista contendo uma tupla para cada par de chaves\n",
        "d.**keys()** | retorna uma lista com as chaves do dicionário\n",
        "d.**pop(**C**)** | remove um elemento para a chave C\n",
        "d.**popitem()** | remove o último para de chave e valor \n",
        "d.**setdefault()** | retorna o valor de uma chave ou se não existir a cria com o valor especificado\n",
        "d.**update()** | atualiza o dicionário pelos pares espeficidados de chave-valor.\n",
        "d.**values()** | retorna uma lista de todos valores no dicionário"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DyVJeI-jZcyu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Há duas formas de criar um dicionário uma usando {} e outras o construtor dict()\n",
        "# O exemplo abaixo from extraído do fishbase \n",
        "# \n",
        "\n",
        "tax = {\n",
        "            \"SpecCode\": 55016,\n",
        "            \"Genus\": \"Serrasalmus\",\n",
        "            \"Species\": \"marginatus\",\n",
        "            \"Author\": \"Valenciennes, 1837\",\n",
        "            \"SpeciesRefNo\": 39031,\n",
        "            \"FBname\": None,\n",
        "            \"FamCode\": 686,\n",
        "            \"GenCode\": 829,\n",
        "            \"Remark\": None,\n",
        "            \"SubGenCode\": None,\n",
        "            \"SubFamily\": None,\n",
        "            \"Family\": \"Serrasalmidae\",\n",
        "            \"Order\": \"Characiformes\",\n",
        "            \"Class\": \"Actinopterygii\"\n",
        "        }\n",
        "\n",
        "spec =  {\n",
        "            \"SpecCode\": 55016,\n",
        "            \"Genus\": \"Serrasalmus\",\n",
        "            \"Species\": \"marginatus\",\n",
        "            \"SpeciesRefNo\": 39031,\n",
        "            \"Author\": \"Valenciennes, 1837\",\n",
        "            \"DemersPelag\": \"benthopelagic\",\n",
        "            \"Vulnerability\": 21.77,\n",
        "            \"Length\": 27.1,\n",
        "            \"LTypeMaxM\": \"TL\",\n",
        "            \"LengthFemale\": 32.4,\n",
        "            \"LTypeMaxF\": \"TL\",\n",
        "            \"MaxLengthRef\": 115169,\n",
        "            \"CommonLength\": None,\n",
        "            \"LTypeComM\": None,\n",
        "            \"CommonLengthF\": None,\n",
        "            \"LTypeComF\": None,\n",
        "            \"CommonLengthRef\": None,\n",
        "            \"Weight\": 440,\n",
        "            \"WeightFemale\": 783,\n",
        "            \"MaxWeightRef\": 115169,\n",
        "            \"UsedforAquaculture\": \"never/rarely\",\n",
        "            \"UsedasBait\": \"never/rarely\",\n",
        "            \"Aquarium\": \"never/rarely\",\n",
        "            \"Dangerous\": \"harmless\",\n",
        "            \"Electrogenic\": \"no special ability\",\n",
        "            \"Comments\": \"Feeds mainly during the daytime, though some large fish (15-20 cm SL) extend their foraging activity to dusk (about 1800-1900H).  Night is spent sheltered among vegetation.  Small-sized to medium-sized fish (7-10 cm) are solitary and patrol feeding territories (3-4 square m.) in a way similar to that reported for the scale-eating <i>Catoprion mento</i>.  Stalking with some use of plant cover is a frequent mode of hunting employed by <i>S. marginatus</i>.  It approaches its prey with a slow, stealthy movement from behind or below.  It strikes its prey on the tail or anal fin, of which a piece is clipped out with a jerking motion of the body.  This clipping is audible underwater.  Lurking is also employed during daytime (Ref. 9080).\",\n",
        "            \"DateEntered\": \"2000-02-04T00:00:00.000Z\",\n",
        "            \"Modified\": 65,\n",
        "            \"DateModified\": \"2017-06-23T00:00:00.000Z\",\n",
        "            \"Expert\": 747,\n",
        "            \"DateChecked\": \"2001-06-25T00:00:00.000Z\",\n",
        "            \"image\": \"https://www.fishbase.de/images/species/Semar_ue.jpg\"\n",
        "        }\n",
        "\n",
        "# exibindo as chaves do dicionário \n",
        "print(spec.keys())\n",
        "\n",
        "# exibindo o valor de uma chave\n",
        "print(spec['Length'])\n",
        "\n",
        "# incluindo uma chave \n",
        "spec['CommonName'] = 'Piranha'\n",
        "\n",
        "# excluindo uma chave\n",
        "spec.pop('Expert')\n",
        "# ou\n",
        "del spec['LTypeComF']\n",
        "\n",
        "# inclui/atualiza várias chaves\n",
        "spec.update({'pH': '6.0 - 7.4', 'LifeSpec' : '10y', 'Dangerous' : 'agressive'})\n",
        "\n",
        "# exibe dicionário\n",
        "print(spec)\n",
        "\n",
        "# exibe itens \n",
        "print(spec.items())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w7OJl8SOq_Kc",
        "colab_type": "text"
      },
      "source": [
        "### Item 4 - Condicionais e Ciclos\n",
        "> **OBS** até aqui todos os comandos que executados foram de uma linha. somente a definição de dicionário precisou usar várias linhas de forma organizada por identação. O python diferente de outras linguagens não usa caracteres como {  .. } ou palavras padrão como begin .. end para delimitar os comandos dentro de uma condição lógica ou de ciclo.  Para definir a abrangência de uma condição ou ciclo o python exige que seja feito identação. Ou seja os comandos dentro de uma condição ou ciclo devem estar com um ou mais espaços em relação a sua condição ou ciclo\n",
        "\n",
        "Por exemplo o código abaixo apesar de compreensível para quem vê causa erro no python, pois não tem identação: \n",
        "\n",
        "```python\n",
        "a = 10\n",
        "if a > 5 and a < 20:\n",
        "print('Valor dentro dos limites')\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GNBYroLjvscm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# a codificação correta para o se (if) é:\n",
        "a = 10\n",
        "if a > 5 and a < 20:\n",
        "  print('Valor dentro dos limites')\n",
        "  \n",
        "# com o senão: else \n",
        "if a > 10:\n",
        "  print('Valor mínimo alcançado')\n",
        "else\n",
        "  print('Valor abaixo do esperado')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a7vyvHHExZry",
        "colab_type": "text"
      },
      "source": [
        "O python possui uma forma curta de uma linha pra o condicional if. \n",
        "\n",
        "Veja os mesmos exemplos acima mas na forma curta. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NpCrfo19x-Ra",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# usando if curto numa linha\n",
        "a = 10\n",
        "if a > 5 and a < 20: print('Dentro dos limites')\n",
        "\n",
        "# com else\n",
        "print('Valor mínimo alcançado') if a > 10 else print('Valor abaixo do esperado')\n",
        "\n",
        "# é possível também aninha ifs numa linha ex:\n",
        "print('menor') if a < 10 else print('=') if a == 10 else print('maior')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LiCIdwCQ0Pgh",
        "colab_type": "text"
      },
      "source": [
        "**Ciclos** _loop_  \n",
        "  - **while** (enquanto)\n",
        "  - **for** (para)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PdENJn0V08_Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# o clico enquanto 'while' no python é semelhante as outras linguagens\n",
        "# apenas como tudo em python deve-se usar identação adequadamente. \n",
        "i = 10\n",
        "while i > 0:\n",
        "  if i == 5:\n",
        "    print('metade')\n",
        "  else \n",
        "    print(i)\n",
        "  i -= 1  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aFp4MXVY2NdG",
        "colab_type": "text"
      },
      "source": [
        "O cilclo **for** do python não contém contadores, como em outras linguagens como  C ou Javascript. O python possui uma sintaxe semelhante ao R. \n",
        "\n",
        "para um ciclo de 1 a 10 \n",
        "\n",
        "Em __Javascript__ temos:\n",
        "\n",
        "```javascript\n",
        "for (i = 1; i < 10; i++ ) {\n",
        "    console.log('i=',i)\n",
        "}\n",
        "\n",
        "```\n",
        "Em __R__ temos:\n",
        "```r\n",
        "for (i in 1:10) {\n",
        "  print(paste(\"i=\",i))\n",
        "}\n",
        "```\n",
        "\n",
        "Em __Python__ temos:\n",
        "```python\n",
        "for i in range(1,10):\n",
        "  print('i=',i)\n",
        "```\n",
        "\n",
        "> Ou seja o python semelhante ao R usa o conceito de iteração dentro de um conjunto. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "op40spxb7lrJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# exemplos de for \n",
        "rios_rs = (\"Rio Turvo\",\"Rio Gravatai\", \"Rio Ibicuí\", \"Rio Carreiro\",\"Rio Uruguai\")\n",
        "tax = {\n",
        "            \"SpecCode\": 55016,\n",
        "            \"Genus\": \"Serrasalmus\",\n",
        "            \"Species\": \"marginatus\",\n",
        "            \"Author\": \"Valenciennes, 1837\",\n",
        "            \"SpeciesRefNo\": 39031,\n",
        "            \"FBname\": None,\n",
        "            \"FamCode\": 686,\n",
        "            \"GenCode\": 829,\n",
        "            \"Remark\": None,\n",
        "            \"SubGenCode\": None,\n",
        "            \"SubFamily\": None,\n",
        "            \"Family\": \"Serrasalmidae\",\n",
        "            \"Order\": \"Characiformes\",\n",
        "            \"Class\": \"Actinopterygii\"\n",
        "        }\n",
        "# exemplo de for para uma tupla\n",
        "for v in rios_rs:\n",
        "  print(v)\n",
        "  \n",
        "# exemplo com range e incremento 2\n",
        "# Observe o uso do len para obter o nº de lementos da tupla e o -1, para adequar ao último índice \n",
        "for i in range(0,len(rios_rs)-1,2):\n",
        "   print('Pares:',rios_rs[i])\n",
        "    \n",
        "# exemplo de for loop de duas variáveis\n",
        "for chave, valor in tax.items():\n",
        "  print(chave,'=',valor)  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bAKJyb9Z_usG",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "Bom chega aqui o final do 1º episódio. \n",
        "\n",
        "Como expresso no início esse material é apenas um material complemenar para quem quer aprender python e ciência de dados. \n",
        "\n",
        "Programação se aprende fazendo e estudando, o que foi apresentado aqui fornece os conceitos básicos, necessários para lidar com os dados extraidos dos repositórios. No decorrer dos novos episódios, sera apresentado como extrair os dados, como juntar e filtra-los. E depois usar ferramentas poderosoas como o Pandas, SciPy. que lidam tanto com os dados como para fazer análises e gráficos.\n",
        "\n",
        "**OBS** os próximos episódios serão menores e mais práticos. Onde novos recursos irão sendo agregados conforme buscamos atender aos desafios.\n",
        "\n",
        "Qual é o seu desafio?\n",
        "\n",
        "## PROXIMO EPISÓDIO: \n",
        "Conceitos básicos sobre repositórios e Rest API, com exemplos de extração de dados do FishBase."
      ]
    }
  ]
}