{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "##
Introdução à Lógica de Programação
\n", "###
Um curso prático para estudantes das Ciências da Vida
\n", "---\n", "##
Aula 4. Listas
\n", "#####
Instrutor: Pedro C. de Siracusa
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nas aulas anteriores aprendemos como armazenar um valor, de qualquer tipo, em uma variável. Vimos também como isso é útil para organizarmos nosso código, torná-lo mais legível e, principalmente, para aproveitar resultados obtidos em etapas anteriores e reutilizá-los várias vezes durante nosso programa.\n", "Mas variáveis só podem ser usadas para referenciar um único valor. E se quiséssemos armazenar um conjunto de valores em uma mesma variável, de forma que pudéssemos acessá-los todos de uma só vez?\n", "Para isso recorremos a uma estrutura de dados nativa de *Python*, chamada lista." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Listas** são representadas pelo tipo *list*, e permitem armazenar um conjunto de valores em uma única estrutura! Cada elemento ocupando uma posição dentro da lista é chamado de **item** (ou **elemento**). O número de itens que uma lista armazena é referido como seu **comprimento**. A princípio não há limites para o comprimento de uma lista, embora listas grandes demais certamente exigem mais recursos computacionais, podendo se tornar intratáveis. Outra característica importante das listas é que elas permitem armazenar itens de tipos diferentes dentro de uma mesma estrutura (embora seja mais usual armazenar itens do mesmo tipo). Podemos por exemplo armazenar dentro de uma única lista *strings*, *booleanos*, *inteiros*, *floats*, e até outras *listas*!\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Na ilustração acima, temos uma lista de comprimento 5, armazenando itens de tipos diferentes. Cada item da lista ocupa um espaço próprio, representado como um \"quadradinho\". Os números abaixo de cada quadrado representam os **índices** de cada item na lista. Os índices nada mais são que endereços numéricos, que nos permitem referenciar elementos em cada posição na lista. Por exemplo, se quisermos nos referir ao número 42, indicaremos o índice (ou endereço) 2.\n", "\n", "**Obs:** Em *Python*, a numeração dos índices começa em zero, e portanto o primeiro elemento se encontra na posição 0. Da mesma forma, o último item de uma lista de comprimento $n$ se encontra na posição $n-1$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Objetivos. \n", "\n", "Após esta aula você deverá ser capaz de:\n", "* Reconhecer a utilidade das listas como estruturas de dados;\n", "* Construir e combinar listas;\n", "* Recuperar elementos de uma lista." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Construindo uma lista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Existem algumas formas diferentes de se construir uma lista em *Python*. A mais simples consiste em inserir uma sequência de itens separados por vírgulas entre colchetes.\n", "Note que a ordem dos itens permanece a mesma em que foram inseridos durante s criação da lista." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Pedro', 29, 1.83]" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Como exemplo, uma lista contendo um nome, uma idade e uma altura\n", "[\"Pedro\", 29, 1.83]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Podemos também usar a função `list`, passando como argumento uma sequência de números inteiros (ou *range*). Uma *range* pode ser criada usando a função `range`." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Lista de 0 até 10\n", "list(range(11))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Lista de 1 até 10\n", "list(range(1,11))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 3, 5, 7, 9]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Lista de 1 até 10 de 2 em 2\n", "list(range(1,11,2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A linguagem *Python* fornece outras formas mais eficientes de se criar listas, como o método de [**compreensão de listas**](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions). Mas para manter a simplicidade do material não abordaremos este método por enquanto. Fica apenas a referência para os mais curiosos." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Acessando elementos da lista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Agora que temos uma lista, como acessar os elementos dentro dela? Existem basicamente duas formas: a indexação (**indexing**) e o recorte (**slicing**). Por fim, podemos usar também algumas funções aplicáveis a listas. Vejamos cada um deles." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Indexing" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Usando a **notação de indexação** `[i]` podemos recuperar o elemento em determinada posição em uma lista. Para isso basta indicar o índice `i` do elemento que queremos entre colchetes, ao lado da nossa lista (ou da variável que a armazena).\n", "Se tentarmos passar um índice que não exista na lista (por exemplo o índice 9 em uma lista de comprimento 5), o interpretador encerrará a execução do programa e nos mostrará uma mensagem de erro." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "l = [\"Pedro\", 29, 1.83]" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Pedro'" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[0]" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "29" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[1]" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.83" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[2]" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "ename": "IndexError", "evalue": "list index out of range", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ml\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mIndexError\u001b[0m: list index out of range" ] } ], "source": [ "l[3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Podemos usar números negativos para nos referir a elementos na lista seguindo uma lógica de ordem reversa. Por exemplo, podemos usar o índice -1 para nos referir ao último elemento, -2 ao penúltimo, e assim por diante." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.83" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[-1]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "29" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[-2]" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Pedro'" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[-3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Slicing" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Usando a **notação de recorte** `[i:j]` podemos recuperar um conjunto de elementos de uma lista. A diferença para a indexação é que o recorte retorna uma sublista (um pedaço, ou *slice* da lista original), em vez de um único elemento. Para isso indicamos, entre colchetes e separados por dois pontos, dois números: o primeiro (`i`) é o índice do elemento no começo do recorte; o segundo (`j`) é o índice do elemento que delimita o fim do pedaço (não-inclusivo). " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "l = [1,2,3,4,5,6,7,8,9,10]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[0:3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Podemos omitir o número `i` ou `j` se quisermos que o pedaço comece do primeiro elemento da lista ou que termine no último elemento da lista, respectivamente." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[:3]" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[4, 5, 6, 7, 8, 9, 10]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[3:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Embora pouco usual, podemos definir o **passo** do recorte alterando a notação de recorte para `[i:j:k]`. Neste caso, `k` é o tamanho do passo, ou seja, o número de elementos que devem ser pulados." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[3, 5, 7, 9]" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l[2:9:2]" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 3, 5, 7, 9]" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Percorrendo toda a lista de 2 em 2\n", "l[::2]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 4, 7, 10]" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Percorrendo toda a lista de 3 em 3\n", "l[::3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Funções aplicáveis a listas" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "E se quisermos obter o elemento de maior ou menor valor dentro da lista? Para isso podemos usar as funções `max` e `min`, respectivamente." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "l = [34, 5, -1, 8, 43, -7, 0, 1]" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "43" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "max(l)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-7" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "min(l)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A função `reversed` espera receber uma lista e retorna uma nova lista com os elementos em ordem inversa." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "l = [1,2,3,4,5,6,7,8,9,10]" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(reversed(l))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finalmente, podemos verificar se um elemento com determinado valor existe dentro de uma lista. Para isso, construímos uma expressão utilizando o operador `in`. Caso o elemento exista na lista, a expressão retornará o valor booleano `True` e, caso contrário, `False`." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "nomes = [\"Pedro\", \"Adriana\", \"Nicole\"]" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Pedro\" in nomes" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Adriana\" in nomes" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Ana\" in nomes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Combinando listas" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "É possível construir listas facilmente a partir de outras. Para isso usamos o operador `+`, que pode ser usado para concatenar listas. É importante que ambos os operandos sejam do mesmo tipo: lista." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'e']" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l1 = [1,2,3,4,5]\n", "l2 = ['a','b','c','d','e']\n", "\n", "l1 + l2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Este operador é comumente usado para inserir novos elementos em uma lista. Mas lembre-se que listas só podem ser somadas a listas!" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1,2,3,4,5] + [6]" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "can only concatenate list (not \"int\") to list", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m6\u001b[0m \u001b[0;31m# este erro ocorreu pq tentamos somar um inteiro a uma lista!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list" ] } ], "source": [ "[1,2,3,4,5] + 6 # este erro ocorreu pq tentamos somar um inteiro a uma lista!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercícios." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ex 1.** Você recebeu a seguinte tabela com dados de espécies coletadas pela sua turma na saída de Zoologia dos Vertebrados:\n", "\n", "|id| Localidade | Espécie| Nome comum | Contagem | Turma\n", "|--|--|--|--|--|--|\n", "|0| FAL | *Ameiva ameiva*| Calango | 4 | Zoovert 1/2018\n", "|1| FAL | *Phyllomedusa oreades* | Perereca-arborícola | 2 | Zoovert 1/2018\n", "|2| FAL | *Artibeus sp.* | Morcego | 4 | Zoovert 1/2018\n", "|3| FAL | *Athene cunicularia* | Coruja-buraqueira | 5 | Zoovert 1/2018\n", "|4| FAL | *Hypostomus sp.* | Peixe-cascudo | 7 | Zoovert 1/2018\n", "|5| FAL | *Cariama cristata* | Seriema | 4 | Zoovert 1/2018\n", "|6| JBB | *Ameiva ameiva* | Calango | 1 | Zoovert 1/2018\n", "|7| JBB | *Chrysocyon brachyurus* | Lobo-guará | 1 | Zoovert 1/2018\n", "|8| JBB | *Cariama cristata* | Seriema | 2 | Zoovert 1/2018\n", "|9| IBGE | *Bothrops neuwiedi* | Jararaca | 1 | Zoovert 1/2018" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(i)** Armazene os nomes científicos das espécies coletadas em uma lista, e guarde a referência à lista em uma variável chamada `especies`. Observe se as listas permitem armazenar mais de um elemento com um mesmo valor." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "especies = [ 'Ameiva ameiva','Phyllomedusa oreades', 'Artibeus sp.', \n", " 'Athene cunicularia', 'Hypostomus sp.', 'Cariama cristata',\n", " 'Ameiva ameiva', 'Chrysocyon brachyurus', 'Cariama cristata',\n", " 'Bothrops neuwiedi' ]" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Ameiva ameiva',\n", " 'Phyllomedusa oreades',\n", " 'Artibeus sp.',\n", " 'Athene cunicularia',\n", " 'Hypostomus sp.',\n", " 'Cariama cristata',\n", " 'Ameiva ameiva',\n", " 'Chrysocyon brachyurus',\n", " 'Cariama cristata',\n", " 'Bothrops neuwiedi']" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "especies" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(ii)** Usando a notação de *slicing*, obtenha três pedaços da lista `especies`: o primeiro com as espécies coletadas na FAL, o segundo com as espécies coletadas no JBB e o terceiro com as espécies coletadas no IBGE. Armazene cada uma dessas sublistas em variáveis de nome `especies_fal`, `especies_jbb` e `especies_ibge`, respectivamente. " ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Ameiva ameiva',\n", " 'Phyllomedusa oreades',\n", " 'Artibeus sp.',\n", " 'Athene cunicularia',\n", " 'Hypostomus sp.',\n", " 'Cariama cristata']" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "especies_fal = especies[:6]\n", "especies_fal" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Ameiva ameiva', 'Chrysocyon brachyurus', 'Cariama cristata']" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "especies_jbb = especies[6:9]\n", "especies_jbb" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['Bothrops neuwiedi']" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "especies_ibge = especies[-1:]\n", "especies_ibge" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(iii)** Agora vamos guardar cada uma três listas de cada localidade em uma única estrutura!\n", "Você deverá construir uma lista armazenando as três listas criadas no item anterior (cada uma por sua vez contendo nomes de espécies).\n", "Armazene o resultado em uma variável chamada `listas_especies`.\n", "Em seguida, tente recuperar a lista de espécies para cada uma das localidades usando a variável que você acabou de criar." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[['Ameiva ameiva',\n", " 'Phyllomedusa oreades',\n", " 'Artibeus sp.',\n", " 'Athene cunicularia',\n", " 'Hypostomus sp.',\n", " 'Cariama cristata'],\n", " ['Ameiva ameiva', 'Chrysocyon brachyurus', 'Cariama cristata'],\n", " ['Bothrops neuwiedi']]" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "listas_especies = [\n", " especies_fal,\n", " especies_jbb,\n", " especies_ibge\n", "]\n", "\n", "listas_especies" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(iv)** Escreva uma função `coletadaEm`, que recebe como argumentos: \n", "* o nome científico de alguma espécie;\n", "* a lista contendo a lista de espécies para cada uma das três localidades (você a criou no item acima). \n", "\n", "Sua função deve retornar uma lista com os nomes das localidades em que a espécie passada como argumento ocorre. Em que localidades *Cariama cristata* ocorre? E *Phyllomedusa oreades*?" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "def coletadaEm( especie, listas_especies ):\n", " res = [] # esta lista começa vazia, e deve ir sendo preenchida ao longo do código\n", " \n", " if especie in listas_especies[0]:\n", " res = res + [ 'fal' ]\n", " \n", " if especie in listas_especies[1]:\n", " res = res + [ 'jbb' ]\n", " \n", " if especie in listas_especies[2]:\n", " res = res + [ 'ibge' ]\n", " \n", " return res" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['fal', 'jbb']" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Cariama cristata foi coletada na FAL e no JBB\n", "coletadaEm('Cariama cristata', listas_especies)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['fal']" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Hypostomus sp. foi coletada apenas na FAL\n", "coletadaEm('Hypostomus sp.', listas_especies)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Puma concolor não foi coletada em nenhuma das localidades\n", "coletadaEm('Puma concolor', listas_especies)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ex 2.** Em um levantamento florístico, você definiu um *grid* espacial de $5 \\times 5$ células para registrar a ocorrência de espécies. Para cada espécie, armazenamos os dados em uma matriz da seguinte forma: \n", "* Cada elemento da matriz representa uma célula do *grid*;\n", "* Caso a espécie tenha sido registrada em uma célula do grid, sua presença é registrada como um $1$ no elemento correspondente da matriz;\n", "* Caso a espécie não tenha sido registrada em uma célula, sua ausência é registrada como um $0$ no elemento correspondente da matriz.\n", "\n", "Os dados de ocorrência de *Caryocar brasiliense* (vulgo Pequi) foram registrados em uma lista de listas! \n", "Pare por um instante e tente entender como uma lista de listas pode ser usada para representar uma matriz." ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "# Apenas execute esta célula\n", "grid_caryocar = [ [1,0,0,1,0],\n", " [0,0,0,1,0],\n", " [1,0,1,1,1],\n", " [0,0,1,0,0],\n", " [1,0,1,1,0] ]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Agora, seu desafio é acessar apenas os elementos da matriz acima em que a ocorrência de *Caryocar brasiliense* foi registrada (ou seja, os $1$s)." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "grid_caryocar[0][0]" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "grid_caryocar[0][3]" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "grid_caryocar[1][3]" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "grid_caryocar[4][0]" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.5" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": false, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }