{ "cells": [ { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Listas" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Listas são as estruturas de dados mais básicas de Python, substituindo os arrays de C. Por exemplo, strings são casos especiais de listas.\n", "\n", "Representamos uma lista colocando os valores separados por vírgulas entre [ e ]." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5]" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1, 2, 3, 4, 5]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Listas podem ser indexadas." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "minhalista = [1, 2, 4, 8, 16, 32, 64]" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(1, 8)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "minhalista[0], minhalista[3]" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[4, 8, 16]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "minhalista[2:5]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Ao contrário de strings, as listas podem ser alteradas (elas são mutáveis)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "minhalista[0] = -1" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[-1, 2, 4, 8, 16, 32, 64]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "minhalista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "O método `append` adiciona um valor ao final da lista." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "minhalista.append(128)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[-1, 2, 4, 8, 16, 32, 64, 128]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "minhalista" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "O método `pop` retorna o último valor da lista e o retira da lista." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "128" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "minhalista.pop()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[-1, 2, 4, 8, 16, 32, 64]" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "minhalista" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(minhalista)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "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[0mminhalista\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m8\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": [ "minhalista[8]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "As listas guardam apenas *referências* para objetos. Portanto, como variáveis, cada elemento da lista pode se referir a objetos de tipos distintos. Isto é, as listas podem ser mistas." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "listamista = [1, 2.3, 2 + 3j, 'esquisito']" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2.3, (2+3j), 'esquisito']" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "listamista" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Podemos inclusive colocar outras listas dentro de uma lista, formando uma estrutura aninhada." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "listaesquisita = [3, 4, listamista, minhalista]" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[3, 4, [1, 2.3, (2+3j), 'esquisito'], [-1, 2, 4, 8, 16, 32, 64]]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "listaesquisita" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "listaesquisita[1]" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "2.3" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "listaesquisita[2][1]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Lembre-se que nesses casos estamos guardando apenas referências para as listas aninhadas." ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se dentro da lista `l3` guardamos uma referência para outra lista `l2`, então, ao alterarmos o conteúdo de `l2` essa alteração será visível em `l3`." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l1 = [1, 2, 3]\n", "l2 = [5, 4, 3]\n", "l3 = [0, l1, l2]" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[0, [1, 2, 3], [5, 4, 3]]" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l3" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l2[1] = -1" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[5, -1, 3]" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l2" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[0, [1, 2, 3], [5, -1, 3]]" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l3" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l1.append(4)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[0, [1, 2, 3, 4], [5, -1, 3]]" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l3" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Em princípio, nada impede que façamos a inserção de uma referência para a lista dentro da própria lista. Nesse caso, tem-se que tomar cuidado ao manipular essa lista, para evitar problemas de código em *loop* infinito." ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l4 = [1,2]" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l4" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l4.append(l4)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, [...]]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l4" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l4.append(3)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, [...], 3]" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l4" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": true }, "outputs": [], "source": [ "par1 = [1, 2]\n", "par2 = [3, 4]\n", "par1.append(par2)\n", "par2.append(par1)" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, [3, 4, [...]]]" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "par1" ] }, { "cell_type": "raw", "metadata": {}, "source": [] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[3, 4, [1, 2, [...]]]" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "par2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lembre-se que se mais de uma variável referencia a mesma lista então ao alteramos a lista por meio de uma variável ela terá valor alterado quando acessada por outra variável. " ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": true }, "outputs": [], "source": [ "x = [1,2,3]" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": true }, "outputs": [], "source": [ "y = x" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": true }, "outputs": [], "source": [ "x[2]=4" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 4]" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 4]" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Se queremos evitar isso, precisamos fazer uma cópia da lista ao colocar em outra variável." ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": true }, "outputs": [], "source": [ "z = x.copy()" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 4]" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": true }, "outputs": [], "source": [ "x[2] = 3" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 4]" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "No caso de listas, uma outra forma de fazer cópia é simplesmente acessar um slice com todos os elementos." ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": true }, "outputs": [], "source": [ "z = x[:]" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": true }, "outputs": [], "source": [ "x[0] = -1" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[-1, 2, 3]" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[-1, 2, 3]" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Dicionários" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Dicionários são estruturas de dados que armazenam \"valores\" associados com certas \"chaves\". Isto é, dado uma chave, queremos o valor corresponde.\n", "\n", "Eles funcionam como uma generalização de listas, onde a indexação não precisa ser por inteiros consecutivos: a chave funciona como o índice e pode ser de qualquer tipo, inclusive inteiro, caso útil quando apenas alguns valores inteiros são de interesse." ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "idade = {'jose': 20, 'joão': 21, 'maria': 18}" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "20" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade['jose']" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "18" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade['maria']" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se tentamos indexar o dicionário por uma chave inexistente, isso é um erro." ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "KeyError", "evalue": "'pedro'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\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[0midade\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'pedro'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mKeyError\u001b[0m: 'pedro'" ] } ], "source": [ "idade['pedro']" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Dicionários podem ser impressos diretamente usando `print`, se o formato padrão for suficiente." ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{'jose': 20, 'joão': 21, 'maria': 18}" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'jose': 20, 'maria': 18, 'joão': 21}\n" ] } ], "source": [ "print(idade)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Um dicionário onde as chaves são inteiras permite guarda valores apenas para alguns inteiros escolhidos. Note que o valor associado às chaves pode ser de qualquer tipo." ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "di = {12: 0, 17: 2.3, 9: 'oi'}" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(0, 2.3)" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "di[12], di[17]" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "KeyError", "evalue": "15", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\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[0mdi\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mKeyError\u001b[0m: 15" ] } ], "source": [ "di[15]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A forma mais comumente usada de associar um valor a uma nova chave é através do operador de atribuição." ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{'jose': 20, 'joão': 21, 'maria': 18}" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "idade['pedro'] = 25" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{'jose': 20, 'joão': 21, 'maria': 18, 'pedro': 25}" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade" ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "idade['jose'] = 21" ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{'jose': 21, 'joão': 21, 'maria': 18, 'pedro': 25}" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Como já comentado, acesso a uma chave que não tem valor associado no dicionário é um erro." ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "KeyError", "evalue": "'antonio'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\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[0midade\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'antonio'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mKeyError\u001b[0m: 'antonio'" ] } ], "source": [ "idade['antonio']" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Portanto, precisamos de uma forma de testar se um dicionário já tem valor para uma dada chave (antes de ocasionar um erro na execução).\n", "\n", "Há duas formas principais de fazer isso:\n", "\n", "- Usar o operador `in`.\n", "- Usar o método `get`.\n", "\n", "O operador `in` retorna `True` se a chave especificada à esquerda tem valor associado no dicionário à direita." ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'antonio' in idade" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Na verdade, o operador `in` funciona não apenas para dicionários. Por exemplo, podemos ver se uma lista contém um valor especificado." ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 in [2, 3, 4, 5]" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "7 in [2, 3, 4, 5]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O método `get`, aplicado sobre um objeto do tipo dicionário, recebe dois parâmetros: o primeiro é a chave que se busca, o segundo é um valor. Se a chave for encontrada no dicionário, o método retorna o valor associado à chave; se a chave não for encontrada no dicionário, ele retorna o valor fornecido na chamada." ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{'jose': 21, 'joão': 21, 'maria': 18, 'pedro': 25}" ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade" ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "18" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade.get('maria', 0)" ] }, { "cell_type": "code", "execution_count": 75, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade.get('antonio', 0)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "É frequente que queiramos percorrer todas as chaves presentes em um dicionário. Para isso, usamos o método `keys`, que retorna essas chaves." ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "dict_keys(['pedro', 'jose', 'maria', 'joão'])" ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "idade.keys()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A ordem das chaves retornada por `keys` não é garantida, mas é a que permite percorrer o dicionário de forma mais eficiente.\n", "\n", "Se quisermos uma ordem específica (por exemplo, ordem crescente do valor das chaves), então devemos usar a função `sorted`:" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "['jose', 'joão', 'maria', 'pedro']" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sorted(idade)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Tuplas" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Tuplas são sequências ordenadas de valores (de possivelmente diferentes tipos). Ao contrário das listas, elas são *imutáveis*, isto é, uma vez formada uma tupla com certos objetos, essa tupla sempre se referenciará aos mesmos objetos.\n", "\n", "Tuplas são indicadas por listas entre parêntesis separadas por vírgulas." ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t1 = (1, 2, 3, 4)" ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t2 = (4, 7)" ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t3 = (\"Casa\", 12, 0.012)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Os objetos individuais das tuplas podem ser acessados por indexação." ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t1[0]" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t2[1]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Como convencional em Python, o índice fornecido é verificado." ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "IndexError", "evalue": "tuple 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[0mt3\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mIndexError\u001b[0m: tuple index out of range" ] } ], "source": [ "t3[4]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "No caso (frequente) em que não há confusão, os parêntesis podem ser omitidos." ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t4 = -1, -2, -3, -4" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(-1, -2, -3, -4)" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t4" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Novamente, nada impede que uma tupla seja aninhada dentro de outra, ou mesmo que tenhamos tuplas dentro de listas ou listas dentro de tuplas, ou dicionários dentro de listas, dentro de tuplas..." ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t5 = (t1, t2, t3)" ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "((1, 2, 3, 4), (4, 7), ('Casa', 12, 0.012))" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t5" ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "umalista = [4, 5]\n", "t6 = (0, umalista)" ] }, { "cell_type": "code", "execution_count": 89, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(0, [4, 5])" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t6" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A imutabilidade das tuplas significa que elas sempre se referenciam aos mesmos objetos da criação. No entanto, esses objetos podem ser alterados (se eles mesmos não forem imutáveis)." ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "umalista.append(6)" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(0, [4, 5, 6])" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t6" ] }, { "cell_type": "code", "execution_count": 92, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "umalista.append(t6)" ] }, { "cell_type": "code", "execution_count": 93, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[4, 5, 6, (0, [...])]" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "umalista" ] }, { "cell_type": "code", "execution_count": 94, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(0, [4, 5, 6, (...)])" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t6" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Lembre-se que, ao inserir um objeto em qualquer elemento (listas, tuplas, dicionários, ...) inserimos uma *referência* para esse objeto. Caso o objeto seja alterado, a alteração irá se manifestar em todos os lugares que mantém uma referência para esse objeto. No entanto, trocar uma das referências para outro objeto não afeta as referência anteriores.\n", "\n", "Por exemplo, inserimos em `t6` uma referência para o objeto referenciado por `umalista` (indicado acima). Se mudarmos o objeto ao qual a variável `umalista` referencia, isso não afeta o objeto `t6`." ] }, { "cell_type": "code", "execution_count": 95, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "umalista = [0, -1, 1]" ] }, { "cell_type": "code", "execution_count": 96, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[0, -1, 1]" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" } ], "source": [ "umalista" ] }, { "cell_type": "code", "execution_count": 97, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(0, [4, 5, 6, (...)])" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t6" ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t6[1].append(-1)" ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(0, [4, 5, 6, (...), -1])" ] }, "execution_count": 99, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t6" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "No caso acima, foi possível alterar o objeto lista referenciado por `t6` pois uma lista é mutável, e estamos apenas mexendo em seu conteúdo (sem mudar o objeto).\n", "\n", "No caso de inteiros, mudar o conteúdo é correspondente a trocar de objeto. Por exemplo, quando usamos o operador `+=`, na verdade estamos criando um novo objeto. Isso não é permitido em tuplas." ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 1" ] }, { "cell_type": "code", "execution_count": 101, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a += 2" ] }, { "cell_type": "code", "execution_count": 102, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 103, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t7 = (2, a)" ] }, { "cell_type": "code", "execution_count": 104, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(2, 3)" ] }, "execution_count": 104, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t7" ] }, { "cell_type": "code", "execution_count": 105, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a += 5" ] }, { "cell_type": "code", "execution_count": 106, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(2, 3)" ] }, "execution_count": 106, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t7" ] }, { "cell_type": "code", "execution_count": 107, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "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[0mt6\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "t6[0] += 1" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O método `len` pode ser usado também para tuplas." ] }, { "cell_type": "code", "execution_count": 108, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(4, 2, 2)" ] }, "execution_count": 108, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(t1), len(t2), len(t6)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Em algumas situações especiais, queremos criar tuplas com apenas um elemento. No entanto, a notação óbvia não funciona, pois o Python entende isso como uma expressão entre parêntesis, e não uma tupla." ] }, { "cell_type": "code", "execution_count": 109, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 109, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(7)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Para resolver isso, devemos incluir uma vírgula, mesmo que apenas um elemento exista na tupla." ] }, { "cell_type": "code", "execution_count": 110, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "t7 = (7,)" ] }, { "cell_type": "code", "execution_count": 111, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 111, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t7[0]" ] }, { "cell_type": "code", "execution_count": 112, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "IndexError", "evalue": "tuple 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[0mt7\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mIndexError\u001b[0m: tuple index out of range" ] } ], "source": [ "t7[1]" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Conjuntos" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Um outro tipo de dados da linguagem é o \"conjunto\", que representa uma conjunto de valores sem duplicação. Isto é, um certo valor está presente ou não no conjunto.\n", "\n", "Conjuntos são representados por valores entre `{` e `}` separados por vírgulas." ] }, { "cell_type": "code", "execution_count": 113, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "s = {1, 5, 6}" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A operação mais básica é verificar se um certo valor está no conjunto, o que se consegue usando o operador `in`." ] }, { "cell_type": "code", "execution_count": 114, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 114, "metadata": {}, "output_type": "execute_result" } ], "source": [ "5 in s" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Também temos operações de teoria dos conjuntos:\n", "\n", "- Intersecção, com `&`\n", "- União, com `|`\n", "- Diferença de conjuntos, com `-`\n", "- Relações de subconjunto, com `<` e `>`" ] }, { "cell_type": "code", "execution_count": 115, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "s2 = {1, 3, 6}" ] }, { "cell_type": "code", "execution_count": 116, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{1, 5, 6}" ] }, "execution_count": 116, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s" ] }, { "cell_type": "code", "execution_count": 117, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{1, 6}" ] }, "execution_count": 117, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s & s2" ] }, { "cell_type": "code", "execution_count": 118, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{1, 3, 5, 6}" ] }, "execution_count": 118, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s | s2" ] }, { "cell_type": "code", "execution_count": 119, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{5}" ] }, "execution_count": 119, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s - s2" ] }, { "cell_type": "code", "execution_count": 120, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{3}" ] }, "execution_count": 120, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s2 - s" ] }, { "cell_type": "code", "execution_count": 121, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 121, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s < s2" ] }, { "cell_type": "code", "execution_count": 122, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 122, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s2 < s" ] }, { "cell_type": "code", "execution_count": 123, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 123, "metadata": {}, "output_type": "execute_result" } ], "source": [ "{1, 3} < s" ] }, { "cell_type": "code", "execution_count": 124, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 124, "metadata": {}, "output_type": "execute_result" } ], "source": [ "{1, 3} < s2" ] }, { "cell_type": "code", "execution_count": 125, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 125, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s2 > {1, 3}" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Como nos tipos `int`, `float` e `double`, podemos usar os nomes dos tipos para conversão entre `list` e `set`." ] }, { "cell_type": "code", "execution_count": 126, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "s3 = set([1, 2])" ] }, { "cell_type": "code", "execution_count": 127, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{1, 2}" ] }, "execution_count": 127, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s3" ] }, { "cell_type": "code", "execution_count": 128, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2]" ] }, "execution_count": 128, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(s3)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Uma utilidade disso é quando queremos eliminar valores duplicados em listas (e não nos importamos com a ordem dos valores): Convertemos a lista para um conjunto, como o conjunto não tem duplicações, os valores duplicados são eliminados; em seguida, convertemos novamente o conjunto em uma lista." ] }, { "cell_type": "code", "execution_count": 129, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l7 = [1, 2, 3, 1, 2, 4, 1, 7, 9, 2, 4, 8]" ] }, { "cell_type": "code", "execution_count": 130, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 1, 2, 4, 1, 7, 9, 2, 4, 8]" ] }, "execution_count": 130, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l7" ] }, { "cell_type": "code", "execution_count": 131, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l8 = list(set(l7))" ] }, { "cell_type": "code", "execution_count": 132, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 7, 8, 9]" ] }, "execution_count": 132, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l8" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# A referência `None`" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Em algumas situações, queremos ter uma variável para se referenciar a um objeto, mas o objeto ainda não é conhecido. O mesmo ocorre dentro de estruturas como listas ou dicionários. Se não conhecemos inicialmente o objeto a ser referenciado, podemos usar a referência `None`, que indica que uma referência nula (nenhum objeto)." ] }, { "cell_type": "code", "execution_count": 133, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "None" ] }, { "cell_type": "code", "execution_count": 134, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "x = None" ] }, { "cell_type": "code", "execution_count": 135, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "l9 = [1, 2, x]" ] }, { "cell_type": "code", "execution_count": 136, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "x = 7" ] }, { "cell_type": "code", "execution_count": 137, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, None]" ] }, "execution_count": 137, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l9" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Arquivos" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Vejamos agora algumas operações básicas para acesso de arquivos.\n", "\n", "Se quisermos abrir um arquivo para leitura, basta usar a função `open`." ] }, { "cell_type": "code", "execution_count": 142, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "f = open('teste.txt')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Um método simples e eficiente (quando o arquivo não é muito grande) de leitura do arquivo é o `read`, que lê o arquivo todo como uma cadeia de caracteres. Mudanças de linha no arquivo aparecem como o caracter `\\n` na cadeia." ] }, { "cell_type": "code", "execution_count": 143, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "texto = f.read()" ] }, { "cell_type": "code", "execution_count": 144, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'Este é um teste.\\nSegunda linha\\n\\nEm cima foi um espaco.\\n\\n\\n\\n\\n\\nAcabou.\\n'" ] }, "execution_count": 144, "metadata": {}, "output_type": "execute_result" } ], "source": [ "texto" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Após acessar o arquivo, devemos fechá-lo, para liberar recursos usados pelo sistema operacional." ] }, { "cell_type": "code", "execution_count": 145, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "f.close()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Uma vez que temos o conteúdo do arquivo em uma cadeia, podemos usar os métodos de cadeias de caracteres para processá-lo." ] }, { "cell_type": "code", "execution_count": 147, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "17" ] }, "execution_count": 147, "metadata": {}, "output_type": "execute_result" } ], "source": [ "texto.find('Segunda')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Na verdade, a sintaxe apresentada acima é uma abreviação da sintaxe mais completa, que tem um segundo parâmetro que especifica o modo de abertura ('r' para leitura, 'w' para escrita)." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "f = open('teste.txt', 'r')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "f.close()" ] }, { "cell_type": "code", "execution_count": 148, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "f = open('outro.txt', 'w')" ] }, { "cell_type": "code", "execution_count": 149, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "novotexto = texto.upper()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Para escrever num arquivo, produzimos a cadeia de caracteres que queremos escrever e depois usamos o método `write`." ] }, { "cell_type": "code", "execution_count": 150, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'ESTE É UM TESTE.\\nSEGUNDA LINHA\\n\\nEM CIMA FOI UM ESPACO.\\n\\n\\n\\n\\n\\nACABOU.\\n'" ] }, "execution_count": 150, "metadata": {}, "output_type": "execute_result" } ], "source": [ "novotexto" ] }, { "cell_type": "code", "execution_count": 151, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "68" ] }, "execution_count": 151, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f.write(novotexto)" ] }, { "cell_type": "code", "execution_count": 152, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "f.close()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Estruturas de controle" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Vejamos agora as estruturas de controle simples de Python.\n", "\n", "O primeiro ponto a notar é que os blocos de comandos em Python são delimitados pela quantidade de indentação no texto do código. Comandos consecutivos que são indentados pelo mesmo número de espaços em branco estão dentro do mesmo bloco. Um bloco é começado pela presença de `:` no final da linha.\n", "\n", "Por exemplo, o código abaixo imprime \"sei matemática\" se 2 for menor que 3." ] }, { "cell_type": "code", "execution_count": 157, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sei matemática\n", "Ufa!\n" ] } ], "source": [ "if 2 < 3:\n", " print('Sei matemática')\n", " print('Ufa!')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "No código abaixo, os dois `print` estão no mesmo bloco (aquele dentro do `if`), pois são indentados de quantidades idênticas de espaços." ] }, { "cell_type": "code", "execution_count": 158, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Que tal exemplos melhores?\n", "Alguém achou criativo\n" ] } ], "source": [ "if 1 > 0:\n", " print('Que tal exemplos melhores?')\n", " print('Alguém achou criativo')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Já no código abaixo temos um erro, pois o segundo print está indentado de quantidade diferente do anterior, e não se encontra dentro de um novo bloco." ] }, { "cell_type": "code", "execution_count": 159, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "IndentationError", "evalue": "unindent does not match any outer indentation level (, line 3)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print('Alguém achou criativo')\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unindent does not match any outer indentation level\n" ] } ], "source": [ "if 1 > 0:\n", " print('Que tal exemplos melhores?')\n", " print('Alguém achou criativo')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A expressão da condição no `if` não precisa de parêntesis e pode ser tão complexa quanto necessário." ] }, { "cell_type": "code", "execution_count": 160, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "OK\n" ] } ], "source": [ "if 1 > 0 and -1 < 0:\n", " print('OK')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se temos pouco código dentro de um bloco, o bloco pode ser colocado na mesma linha do `:`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "if 1 > 0 and -1 < 0: print('OK')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Também podemos colocar mais de um comando na mesma linha, separando-os com `;`" ] }, { "cell_type": "code", "execution_count": 161, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a\n", "b\n" ] } ], "source": [ "print('a')\n", "print('b')" ] }, { "cell_type": "code", "execution_count": 162, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a\n", "b\n" ] } ], "source": [ "print('a'); print('b')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Por outro lado, a expressão condicional precisa estar na mesma linha do `if`" ] }, { "cell_type": "code", "execution_count": 163, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 1)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m if\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "if \n", " 0 < 1:\n", " print('OK')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Quebras de linha em um mesmo comando são permitidas apenas em alguns casos especiais. O principal deles é depois de uma vírgula, dentro de expressões delimitadas por `()`, `[]` ou `{}`, para permitir colocar valores literais de tuplas, parâmetros de função, listas, dicionários e conjuntos em múltiplas linhas." ] }, { "cell_type": "code", "execution_count": 164, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "{1, 2, 3, 4, 5, 6}" ] }, "execution_count": 164, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1, 2, 3,\n", " 4, 5, 6]\n", "{1, 2, 3,\n", " 4, 5, 6}" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Quando queremos executar uma operação também quando a condição é falsa, usamos um `else`, com notação similar." ] }, { "cell_type": "code", "execution_count": 165, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a não é maior\n" ] } ], "source": [ "a = 1\n", "b = 2\n", "if a > b:\n", " print('a é maior')\n", "else:\n", " print('a não é maior')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se tivermos várias condições a testar, podemos usar tantos `elif` (seguidos de condição) quanto necessários. A condição de um `elif` somente será testada se todas as condições anteriores forem falsas." ] }, { "cell_type": "code", "execution_count": 166, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a é menor\n" ] } ], "source": [ "a = 1\n", "b = 2\n", "if a < b:\n", " print('a é menor')\n", "elif a == b:\n", " print('são iguais')\n", "else:\n", " print('a é maior')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Existe uma forma abreviada de `if`, remanescente do operador `?:` de C. Ela tem o formato\n", "\n", "`val1 if cond else val2`\n", "\n", "e significa que se `cond` for verdadeira, o valor será `val1` e se ela for falsa, será `val2`." ] }, { "cell_type": "code", "execution_count": 167, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 167, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 2\n", "b = -1 if a < 0 else 1\n", "b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "*Loops* são expressos por `while`, seguido da condição de repetição." ] }, { "cell_type": "code", "execution_count": 168, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "9\n", "Acabou\n" ] } ], "source": [ "a = 0\n", "while a < 10:\n", " print(a)\n", " a += 1\n", "print('Acabou')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Como em C, você pode usar um `break` para sair do *loop* antes que a condição seja falsa." ] }, { "cell_type": "code", "execution_count": 169, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n" ] } ], "source": [ "a = 0\n", "while a < 10:\n", " if a == 7: break\n", " print(a)\n", " a += 1" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Ou pode usar um `continue` para descartar o restante desta interação e voltar para o teste da condição." ] }, { "cell_type": "code", "execution_count": 170, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "8\n", "9\n", "10\n" ] } ], "source": [ "a = 0\n", "while a < 10:\n", " a += 1\n", " if a == 7: continue\n", " print(a)\n" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Estranhamente, o `while` possui um `else`, que será executado apenas quando o *loop* terminar porque a condição ficou falsa (isto é, não é executado se o *loop* for interrompido por um `break`." ] }, { "cell_type": "code", "execution_count": 171, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "9\n", "Loop não interrompido\n" ] } ], "source": [ "a = 0\n", "while a < 10:\n", " if a > 20: break\n", " print(a)\n", " a += 1\n", "else:\n", " print('Loop não interrompido')" ] }, { "cell_type": "code", "execution_count": 172, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n" ] } ], "source": [ "a = 0\n", "while a < 10:\n", " if a == 7: break\n", " print(a)\n", " a += 1\n", "else:\n", " print('Loop não interrompido')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Uma outra forma de executar *loops* é o `for`. Ele permite avaliar todos os valores de uma sequência de valores fornecida. A sintaxe é:\n", "\n", " for x in seq:\n", " comandos\n", "\n", "onde `seq` é uma \"sequência\" de objetos (veremos em aulas posteriores a definição mais precisa), `x` é uma variável que vai referenciar cada um dos objetos na ordem determinada pela sequência, e `comandos` são os comandos a executar (em geral, fazem referência a `x`)." ] }, { "cell_type": "code", "execution_count": 173, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0\n", "1.0\n", "2.0\n", "3.0\n", "0.5\n", "1.5\n", "2.5\n", "3.5\n" ] } ], "source": [ "minhalista = [0, 2, 4, 6, 1, 3, 5, 7]\n", "for x in minhalista:\n", " print(x/2)" ] }, { "cell_type": "code", "execution_count": 174, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "2\n", "4\n", "6\n" ] } ], "source": [ "for x in minhalista:\n", " if x % 2 == 0:\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Uma forma bastante útil de conseguir valores para um `for` é através da função `range`. Se fornecemos apenas um valor inteiro `n`, ela retorna uma seqüência com os valores de `0` a `n-1`." ] }, { "cell_type": "code", "execution_count": 175, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "range(0, 10)" ] }, "execution_count": 175, "metadata": {}, "output_type": "execute_result" } ], "source": [ "range(10)" ] }, { "cell_type": "code", "execution_count": 176, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" ] }, "execution_count": 176, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(10))" ] }, { "cell_type": "code", "execution_count": 177, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "4\n", "9\n", "16\n", "25\n", "36\n", "49\n", "64\n", "81\n" ] } ], "source": [ "for i in range(10):\n", " print(i ** 2)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se fornecermos dois valores `n1` e `n2`, ela retorna os valores de `n1` até `n2` (excluindo `n2`, como convencional em Python)." ] }, { "cell_type": "code", "execution_count": 178, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "11\n", "12\n", "13\n", "14\n", "15\n", "16\n", "17\n", "18\n", "19\n", "20\n", "21\n", "22\n", "23\n", "24\n" ] } ], "source": [ "for i in range(10, 25):\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se adicionarmos um terceiro parâmetro, esse novo parâmetro é o passo entre dois valores consecutivos da sequência." ] }, { "cell_type": "code", "execution_count": 179, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "10\n", "20\n", "30\n", "40\n", "50\n", "60\n", "70\n", "80\n", "90\n" ] } ], "source": [ "for i in range(0,100, 10):\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O limite superior não precisa ser atingido exatamente: o range termina ao chegar em um valor maior ou igual ao limite superior." ] }, { "cell_type": "code", "execution_count": 180, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]" ] }, "execution_count": 180, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(range(0, 95, 10))" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "`range` é freqüentemente usado, junto com `len` para percorrer todos os elementos de uma lista." ] }, { "cell_type": "code", "execution_count": 181, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 0\n", "1 2\n", "2 4\n", "3 6\n", "4 1\n", "5 3\n", "6 5\n", "7 7\n" ] } ], "source": [ "for i in range(len(minhalista)):\n", " print(i, minhalista[i])" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Apesar de que para isso existe uma função de enumeração." ] }, { "cell_type": "code", "execution_count": 182, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 0\n", "1 2\n", "2 4\n", "3 6\n", "4 1\n", "5 3\n", "6 5\n", "7 7\n" ] } ], "source": [ "for i, x in enumerate(minhalista):\n", " print(i, x)" ] } ], "metadata": { "kernelspec": { "display_name": "Python [default]", "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.5.2" }, "name": "Aula03.ipynb" }, "nbformat": 4, "nbformat_minor": 0 }