{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Listas em Python\n",
"\n",
"\n",
"Listas são um tipo de dado que você pode usar para armazenar uma coleção de elementos vinculados a uma mesmo nome de variável. Outros tipos de dados que já conhecemos são: strings, números e booleanos.\n",
"\n",
"Você pode atribuir elementos a uma lista com uma expressão da forma:\n",
"\n",
"```python\n",
"nome_lista = [item_1, item_2]\n",
"```\n",
"Observe que os itens aparecem entre colchetes. Uma lista também pode ser vazia: `lista_vazia = []`.\n",
"\n",
"Listas são muito semelhantes a strings, mas possuem algumas diferenças.\n",
"\n",
"Vejamos um primeiro exemplo. A lista `animais_fazenda` possui três itens (veja-os na linha 1). Acrescente um quarto animal, editando diretamente na linha 1 (basta digitar o nome de outro animal como uma string depois da vírgula e antes do colchete ]."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['vaca', 'galinha', 'cavalo']\n"
]
}
],
"source": [
"animais_fazenda = ['vaca', 'galinha', 'cavalo', ] # Está faltando um animal\n",
"\n",
"print(animais_fazenda)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Acesso por índice\n",
"\n",
"Você pode acessar um elemento individual na lista pelo seu índice. Um índice é como um endereço que identifica a posição do elemento na lista. O índice aparece diretamente depois do nome da lista, entre colchetes:\n",
"```python\n",
"nome_lista[indice]\n",
"```\n",
"\n",
"Índices de listas começam do 0 (zero), da mesma forma que com strings. Você acessa o primeiro elemento na lista usando `nome_lista[0]`, o segundo elemento está no índice 1: `nome_lista[1]`.\n",
"\n",
"Na célula abaixo, escreva um comando que mostra o resultado de somar o segundo e o quarto elementos da lista. Você deve acessar os elemento pelos seus índices na lista.\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Somando os números nos índices 0 e 2...\n",
"12\n",
"Somando os números nos índices 1 e 3...\n"
]
}
],
"source": [
"numeros = [5, 6, 7, 8]\n",
"\n",
"print(\"Somando os números nos índices 0 e 2...\")\n",
"print(numeros[0] + numeros[2])\n",
"print(\"Somando os números nos índices 1 e 3...\")\n",
"# Escreva o seu código aqui"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Alterando elementos da lista\n",
"\n",
"Um índice de lista funciona como qualquer outro nome de variável. Tanto ele pode ser usado para acessar os elementos como para atribuir novos valores.\n",
"\n",
"Vimos como acessar um índice de lista assim:\n",
"\n",
"```python\n",
"animais_fazenda[0]\n",
"# Obtém o valor \"vaca\"\n",
"```\n",
"Para atribuir um valor, usamos assim:\n",
"```python\n",
"animais_fazenda[2] = \"porco\"\n",
"# Altera \"cavalo\" para \"porco\"\n",
"```\n",
"Na célula abaixo, escreva um comando que vai substituir o elemento que armazena o valor \"galinha\" com outro animal (como string). Pode ser qualquer outro animal que você queira."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['vaca', 'galinha', 'porco']\n"
]
}
],
"source": [
"animais_fazenda = ['vaca', 'galinha', 'cavalo'] # Está faltando um animal\n",
"\n",
"animais_fazenda[2] = \"porco\" # Altera \"cavalo\" para \"porco\"\n",
"\n",
"# Escreva o seu comando aqui\n",
"\n",
"print(animais_fazenda)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Adicionando elementos à lista\n",
"Uma lista não precisar ter um tamanho fixo. Você pode adicionar elementos ao final de uma lista sempre que desejar. Além disso, assim como para strings, também podemos usar a função `len()` para saber o tamanho de uma lista. Veja o exemplo abaixo:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n",
"4\n",
"['a', 'b', 'c', 'd']\n"
]
}
],
"source": [
"letras = ['a', 'b', 'c']\n",
"print(len(letras))\n",
"# Até aqui letras tinha tamanho 3\n",
"# Vamos adicionar mais uma letra à lista\n",
"\n",
"letras.append('d')\n",
"print(len(letras))\n",
"# Agora a lista aumentou de tamanho\n",
"print(letras)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"No exempolo acima, nós inicialmente criamos uma lista chamada `letras`. Depois usamos `len()` para mostrar o tamanho da lista. Então, nós adicionamos a `string 'd'` ao final da list usando o método `.append()`. Depois mostramos mais uma vez o tamanho da lista (que agora possui 4 elementos) e também mostramos a lista ao final: `['a', 'b', 'c', 'd']`.\n",
"\n",
"Na célula abaixo foi criada uma lista vazia chamada mochila e depois adicionado o elemento `\"caderno\"`. Adicione outros 3 elementos (escolha o que quiser) à mochila e complete o código restante."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sua mochila possui 1 elementos.\n",
"['caderno']\n"
]
}
],
"source": [
"mochila = []\n",
"\n",
"# Adicionando um caderno\n",
"mochila.append(\"caderno\")\n",
"\n",
"# Adicione mais elementos\n",
"\n",
"\n",
"\n",
"tamanho_lista = _______ # Coloque aqui o comando para calcular o tamanho da lista\n",
"\n",
"print(\"Sua mochila possui %s elemento(s).\" % (tamanho_lista))\n",
"print(mochila)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fatiamento de listas\n",
"Semelhante ao que fizemos com strings, também podemos pegar porções (fatias) da lista, usando a construção `lista[inicio:fim]`. Veja o exemplo abaixo:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['b', 'c']\n",
"['a', 'b', 'c', 'd', 'e']\n"
]
}
],
"source": [
"letras = ['a', 'b', 'c', 'd', 'e']\n",
"fatia = letras[1:3]\n",
"print(fatia)\n",
"print(letras)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"No exemplo acima nós inicialmente criamos uma lista chamada `letras`.<br>\n",
"Depois, tomamos uma subseção da lista e a armazenamos na lista `fatia`. Nós começamos do índice `1`, que corresponde a letra 'b' e continuamos até o índice `3`, mas não o incluímos na fatia (lembre-se de que o índice final é não inclusivo).<br>\n",
"Depois disso, nós mostramos o conteúdo de fatia: `['b', 'c']` e na linha seguinte o conteúdo de letras: `['a', 'b', 'c', 'd', 'e']` para mostrar que a lista letras não foi modificada, o fatiamento sempre gera uma cópia da original.\n",
"\n",
"Na célula abaixo, complete o código da seguinte maneira:\n",
"* na linha 7, crie uma lista chamada `meio` com os dois elementos do meio\n",
"* na linha 10, crie uma lista chamada `ultimos` com os dois últimos elementos"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"mochila = [\"caderno\", \"lápis\", \"caneta\", \"borracha\", \"livro\", \"pendrive\"]\n",
"\n",
"# Tomando os primeiros dois elementos\n",
"primeiros = mochila[0:2]\n",
"\n",
"# Tomando o terceiro e o quarto elementos\n",
"meio = \n",
"\n",
"# Tomando o quinto e o sexto elementos\n",
"ultimos = \n",
"\n",
"# Vamos ver o conteúdo das fatias\n",
"print(primeiros)\n",
"print(meio)\n",
"print(ultimos)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Buscando elementos na lista\n",
"\n",
"Às vezes precisamos buscar um dado elemento em uma lista. Para descobrir a posição de um elemento, usamos o método `.index(elemento)`. Veja um exemplo:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n"
]
}
],
"source": [
"mochila = [\"caderno\", \"lápis\", \"caneta\", \"borracha\", \"livro\", \"pendrive\"]\n",
"print(mochila.index(\"caneta\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"No exemplo acima, inicialmente nós uma lista chamada mochila com seis coisas.<br>\n",
"Então nós mostramos o primeiro índice da lista em que aparece o elemento `\"caneta\"`, ou seja, o 2.\n",
"\n",
"Nós também podemos inserir elementos na lista, em um determinado índice (não precisar ser no final), usando o método `.insert(indice, elemento)`. Veja um exemplo:\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['caderno', 'lápis', 'fone de ouvido', 'caneta', 'borracha', 'livro', 'pendrive']\n"
]
}
],
"source": [
"mochila.insert(2, \"fone de ouvido\")\n",
"print(mochila)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nós inserimos \"fone de ouvido no índice 2, que empurra todo mundo para a direita em uma posição. Depois mostramos a lista com o novo elemento: ['caderno', 'lápis', 'fone de ouvido', 'caneta', 'borracha', 'livro', 'pendrive'].\n",
"\n",
"Agora vamos praticar um pouco. Na célula abaixo:\n",
"* Use o método `.index(elemento)` para encontrar o índice de \"borracha\". Atribua o resultado à variável `indice_borracha`. \n",
"* Então use `.insert(indice, elemento)` para inserir \"marcador\" nesse índice."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid syntax (<ipython-input-13-e6e99ca39868>, line 2)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"<ipython-input-13-e6e99ca39868>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m indice_borracha = # Use index() para achar \"borracha\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
]
}
],
"source": [
"mochila = [\"caderno\", \"lápis\", \"caneta\", \"borracha\", \"livro\", \"pendrive\"]\n",
"indice_borracha = # Use index() para achar \"borracha\"\n",
"\n",
"# Escreva o seu código para inserir o novo elemento aqui \n",
"\n",
"print(mochila)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Percorrendo listas com o comando for\n",
"\n",
"Nós já vimos o comando for antes. Se você quiser fazer alguma coisa com cada elemento da lista, você pode usar o comando `for`.\n",
"```python\n",
"for variavel in lista:\n",
" # Do stuff!\n",
"```\n",
"Um nome de variável (`variavel`) aparece depois da palavra `for`, ela representa um elemento da lista por vez. Depois temos a palavra reservada `in` e o nome da lista que o loop for vai atuar. Não se esqueça de colocar dois pontos no final (:) e de indentar o código abaixo do comando. Tudo o que estiver indentado, será repetido para cada item na lista. \n",
"\n",
"Na célula abaixo, escreva um comando que irá mostrar o dobro de cada elemento da lista de números."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "unexpected EOF while parsing (<ipython-input-14-065f737021ee>, line 5)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"<ipython-input-14-065f737021ee>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m \u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unexpected EOF while parsing\n"
]
}
],
"source": [
"minha_lista = [1,7,5,2,3,6]\n",
"\n",
"for numero in minha_lista:\n",
" # Escreva o seu código aqui\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ordenando listas\n",
"\n",
"Se você quiser ordenar a sua lista, você pode usar o método `.sort()`."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"daniele\n",
"jonas\n",
"mauricio\n",
"sandra\n"
]
}
],
"source": [
"alunos = [\"sandra\", \"mauricio\", \"jonas\", \"daniele\"]\n",
"alunos.sort()\n",
"\n",
"for aluno in alunos:\n",
" print(aluno)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Primeiro, nós criamos uma lista chamada alunos com quatro strings.<br>\n",
"As strings não estão em ordem alfabética.<br>\n",
"Depois nós ordenamos a lista (ordem alfabética).<br>\n",
"Observe que `.sort()` **modifica a lista e não retorna uma nova cópia**.<br>\n",
"Finalmente, para cada elemento em alunos, nós mostramos aquele elemento na sua própria linha.\n",
"\n",
"Na célula abaixo, escreva um for que percorre `lista_inicial` e `append()` cada número elevado ao quadrado na lista `lista_quadrados`. Depois ordene a lista para mostrá-la do menor para o maior elemento."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"lista_inicial = [3, 5, 1, 4, 2]\n",
"lista_quadrados = []\n",
"\n",
"# escreva o seu código aqui\n",
"\n",
"\n",
"print(lista_quadrados)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Removendo elementos da lista\n",
"\n",
"Às vezes precisamos remover alguns elementos de uma lista. Podemos usar a função `.remove(elemento)`. \n",
"\n",
"Veja o exemplo abaixo:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['ouros', 'espadas', 'copas', 'paus']\n"
]
}
],
"source": [
"naipes = [\"ouros\", \"espadas\",\"copas\",\"paus\", \"pedras\"]\n",
"\n",
"naipes.remove(\"pedras\")\n",
"print(naipes)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nós inicialmente criamos uma lista `naipes` com 5 strings.<br> \n",
"Depois nós removemos o primeiro elemento da lista que é igual à string \"pedras\".<br>\n",
"Note que se houvesse outra string \"pedras\" na lista, somente a primeira ocorrência seria removida.<br>\n",
"Além disso, `.remove(elemento)` retorna nada, por isso o seu resultado não pode ser atribuído a uma variável.\n",
"Finalmente nós mostramos a lista só para mostrar que \"pedras\" for realmente removida.\n",
"\n",
"Na célula abaixo, remova \"canivete\" da lista de elementos da mochila."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['caderno', 'lápis', 'caneta', 'canivete', 'borracha']\n"
]
}
],
"source": [
"mochila = [\"caderno\", \"lápis\", \"caneta\", \"canivete\", \"borracha\"]\n",
"\n",
"# Remova \"canivete\" de mochila\n",
"\n",
"# mostre o conteúdo de mochila\n",
"print(mochila)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"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.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}