{ "cells": [ { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Testes de igualdade" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O operador == testa a igualdade de **valor** entre dois objetos." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 == 1 + 1" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "3 == 3" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 2\n", "b = 3 - 1" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "b += 1" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Além de verificar se os valores são iguais, podemos querer saber se duas variáveis se referem ao mesmo objeto.\n", "\n", "Isso é feito com o operador is." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "b = a" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b is a" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Para objetos numéricos (que são *imutáveis*) quando mudamos o valor associado a uma variável, na verdade criamos um outro objeto com o mesmo valor." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "b += 1" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b is a" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Isso acontece porque o += não altera o valor do objeto (o que é impossível, pois o objeto é imutável), mas sim cria um novo objeto.\n", "\n", "Na verdade, b += 1 é equivalente a b = b + 1." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "b = b + 1" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se um objeto é mutável (como uma lista), então é possível realizar operações que mudam o valor do objeto. Essa mudança, como vimos, se reflete em todas as variáveis que se referem a esse objeto." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = [1, 2, 3]\n", "b = a" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b == a" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b is a" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a.append(4)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4]" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "b.append(5)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5]" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b is a" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se queremos ter objetos distinto em variáveis distintas, para que as operações em uma variável não afetem a outra, precisamos fazer uma cópia.\n", "\n", "No caso de listas e similares com indexação (como strings) isso é fácil." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "b = a[:]" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Agora, como os objetos são diferentes, ao mudarmos o objeto por meio de uma variável, o da outra variável não é afetado." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a.append(6)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "([1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a, b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Uma outra forma mais geral de fazer cópias é usar o método copy()." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "c = a.copy()" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6]" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c is a" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Quando atribuimos um objeto a uma variável, estamos criando o objeto, que será um objeto novo e diferente dos anteriormente existentes, mesmo que tenha o mesmo valor." ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = [1, 2, 3]\n", "b = [1, 2, 3]" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "No entanto, uma exceção existe para **objetos inteiro e string pequenos**. Neste caso, como os objetos são imutáveis, o Python faz uma otimização e reutiliza objetos." ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 2\n", "b = 2" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is b" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 'oi'\n", "b = 'oi'" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Mas isso só é feito para objetos pequenos." ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 1234567890\n", "b = 1234567890" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "E também apenas para inteiros e cadeias." ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 1.0\n", "b = 1.0" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a is b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Mais sobre atribuições" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Atribuições são bastante versáteis em Python. Já vimos que podemos usar uma sintaxe de tuplas para atribuir a múltiplas variáveis de uma vez." ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a, b = 1, 3" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a, b, c, d = 10, 20, 30, 40" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O número de valores atribuídos deve ser igual ao número de variáveis." ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "ValueError", "evalue": "not enough values to unpack (expected 4, got 3)", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\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[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \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[0m\n\u001b[0m", "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 4, got 3)" ] } ], "source": [ "a, b, c, d = 1, 2, 3" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A sintaxe funciona não apenas com tuplas, mas também com listas." ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "[e, f, g] = [4, 5, 6]" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Podemos também misturar tuplas e listas. Desde que o número de elementos seja correto." ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a, b, c = [1, 2, 3]" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "[a, b, c] = (1, 2, 3)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Estruturas aninhadas (tuplas dentro de tuplas, listas dentro de listas, ou misturas) também são possíveis. Cada estrutura aninhada é um elemento." ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "((a, b), c) = ((-1, -2), -3)" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(-1, -2, -3)" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a, b, c" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "A estrutura tem que ser similar dos dois lados." ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "TypeError", "evalue": "'int' object is not iterable", "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;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\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;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable" ] } ], "source": [ "((a,b), c) = (1, (2, 3))" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Também existe uma forma de separar uma parte e coletar o resto em uma variável, como uma lista (com o uso de um asterisco)." ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "primeiro, *resto = [1, 2, 3, 4, 5, 6]" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "primeiro" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[2, 3, 4, 5, 6]" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "resto" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "primeiro, *resto = (1, 2, 3, 4)" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "primeiro" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[2, 3, 4]" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "resto" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Python lida corretamente com casos especiais." ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "primeiro, *resto = (1,)" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "primeiro" ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "resto" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "O Python também permite coletar elementos no final ou no começo." ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "*resto, ultimo = [1, 2, 3, 4, 5]" ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ultimo" ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4]" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "resto" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Ou mesmo no meio..." ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "primeiro, *resto, ultimo = [1, 2, 3, 4, 5]" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "primeiro" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ultimo" ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[2, 3, 4]" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "resto" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Print (de novo)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Ao fazer um print de um objeto ele é convertido para cadeia de caracteres (por um método próprio do tipo do objeto) e essa cadeia é mostrada na tela." ] }, { "cell_type": "code", "execution_count": 75, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "oi\n" ] } ], "source": [ "print('oi')" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n" ] } ], "source": [ "print(3)" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3]\n" ] } ], "source": [ "print([1, 2, 3])" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "É possível imprimir vários objetos em um mesmo print (separados por vírgula) e será inserido um caracter de espaço em branco entre cada objeto." ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A soma de 1 com 1 vale 2\n" ] } ], "source": [ "print('A soma de 1 com 1 vale', 1+1)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "No final de cada print é normalemente inserido um caracter de mudança de linha." ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Uma\n", "Outra\n" ] } ], "source": [ "print('Uma')\n", "print('Outra')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Podemos controlar o que é colocado após a impressão dos objetos usando o parâmetro 'end', que pode especificar qualquer cadeia de caracteres." ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Aguarde...Pronto\n" ] } ], "source": [ "print('Aguarde...', end='',flush=True)\n", "i = 0\n", "while i < 1<<23: i += 1\n", "print('Pronto')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "No código acima, o 'flush' foi inserido para que o 'Aguarde...' seja mostrado ao usuário antes do loop demorado começar. O flush força a impressão de todos os caracteres que estão no buffer de impressão.\n", "\n", "Podemos também mudar o caracter inserido entre cada par de objetos, com especificação do parâmetro 'sep'." ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "12/3/2015\n" ] } ], "source": [ "dia = 12\n", "mes = 3\n", "ano = 2015\n", "print(dia, mes, ano, sep='/')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "# Funções" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Funções são definidas através do comando `def` seguido do nome da função e a lista de parâmetros. Os comandos a serem executados pela função são, como sempre em Python, especificados por um \"dois pontos\" seguido de um bloco indentado." ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "def saudacao():\n", " print('Oi')" ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Oi\n" ] } ], "source": [ "saudacao()" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Para usar parâmetros na função, basta indicar o nome das variáveis dentro dos parêntesis (separadas por vírgulas).\n", "\n", "Como os parâmetros são variáveis, não é necessário declarar tipo, pois elas apenas guardarão uma referência para o objeto passado na chamada." ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "def saudacao_variavel(mens):\n", " print(mens)" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Alô\n" ] } ], "source": [ "a = 'Alô'\n", "saudacao_variavel(a)" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bom dia!\n" ] } ], "source": [ "saudacao_variavel('Bom dia!')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Como não especificamos o tipo, um objeto de qualquer tipo pode ser passado para a função. Se a função não souber o que fazer com esse tipo de objetos, haverá um erro durante a execução." ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "32\n" ] } ], "source": [ "saudacao_variavel(2**5)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Vejamos agora uma função com dois parâmetros e que retorna um valor." ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "def mult(a, b):\n", " return a * b" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Note que a única operação feita na função é o produto `*`. Isso significa que qualquer tipo que tiver operador `*` definido pode ser usado com a função `mult`. " ] }, { "cell_type": "code", "execution_count": 89, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mult(2,3)" ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "10.35" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mult(2.3, 4.5)" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "(-18+14j)" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mult(2+4j, 1+5j)" ] }, { "cell_type": "code", "execution_count": 92, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "9.0" ] }, "execution_count": 92, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mult(2, 4.5)" ] }, { "cell_type": "code", "execution_count": 93, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "'yeahyeahyeah'" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mult('yeah', 3)" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Se tentarmos fazer uma operação não definida, ocorre um erro em tempo de execução." ] }, { "cell_type": "code", "execution_count": 94, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "ename": "TypeError", "evalue": "can't multiply sequence by non-int of type 'str'", "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[0mmult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'yeah'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'oi'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m\u001b[0m in \u001b[0;36mmult\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'" ] } ], "source": [ "mult('yeah', 'oi')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Com tudo em Python, a definição de função é um comando executável. Isso significa que podemos definir uma função em qualquer parte do código. Inclusive dentro de outras estruturas de controle." ] }, { "cell_type": "code", "execution_count": 95, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "a = 1\n", "if a == 0:\n", " def f():\n", " print('Primeiro caso')\n", "else:\n", " def f():\n", " print('Segundo caso')\n" ] }, { "cell_type": "code", "execution_count": 96, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Segundo caso\n" ] } ], "source": [ "f() # Mude o valor de a para diferente de zero e execute novamente" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Uma função que pode se aplicar a diversos tipos de dados é denominada uma \"função genérica\". Em Python, todas as funções são em princípio genéricas (a não ser que usem operações definidas apenas para um tipo de dados ou que sejam explicitamente limitadas a um tipo).\n", "\n", "Vejamos mais um exemplo de função genérica." ] }, { "cell_type": "code", "execution_count": 97, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "def intersect(s1, s2):\n", " res = []\n", " for x in s1:\n", " if x in s2:\n", " res.append(x)\n", " return res" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "Esta função pode ser aplicada a quaisquer tipos, desde que o objeto referenciado por `s1` aceite ter seus elementos percorridos (pelo `for`) e o objeto referenciado por `s2` aceite o operador `in` para verificar se um objeto está contido nele.\n", "\n", "Isso se aplica, por exemplo, a listas." ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 2]" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" } ], "source": [ "intersect([1, 2, 3], [1, 2, 4])" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "E também a cadeias de caracteres." ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "['J', 'o', 'o']" ] }, "execution_count": 99, "metadata": {}, "output_type": "execute_result" } ], "source": [ "intersect('João', 'José')" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "E também a tuplas." ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[1, 3, 4]" ] }, "execution_count": 100, "metadata": {}, "output_type": "execute_result" } ], "source": [ "intersect([1,2,3,4], (4,3,1))" ] }, { "cell_type": "markdown", "metadata": { "ein.tags": [ "worksheet-0" ] }, "source": [ "## Exemplo: Crivo de Eratóstenes\n", "\n", "Vamos agora definir uma função que calcula todos os número primos menores ou iguais a um inteiro `n` (maior ou igual a 2) fornecido como parâmetro.\n", "\n", "A função irá utilizar o denominado \"Crivo de Eratóstenes\", onde se faz uma lista de todos os inteiros de 2 a n e então se começa riscando os números que sabemos que não são primos, inicialmente por todos os múltiplos de 2, depois todos os múltiplos de 2, depois todos os múltiplos de 5 (múltiplos de 4 não precisão ser considerados, pois já foram excluídos ao retirar os múltiplos de 2), etc...\n", "\n", "O processo termina quando se chega na raiz quadrada (prove que não é necessário considerar fatores primos maiores que a raiz quadrada de um número para saber se ele é primo).\n", "\n", "OBS: Há como escrever um código mais simples usando elementos da linguagem que vamos aprender mais adiante." ] }, { "cell_type": "code", "execution_count": 101, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [], "source": [ "import math\n", "def primos_ate(n):\n", " # Primeiro formamos uma lista com os inteiros de 2 a n\n", " # Esses são os candidatos a primos.\n", " candidatos = list(range(2, n + 1))\n", " # Ao calcular a raiz quadrada de n, arredondamos para cima, \n", " # para evitar problemas com aproximação numérica.\n", " raiz_n = int(math.ceil(math.sqrt(n)))\n", " # i mantém a posição do primo atual (que está limpando a lista)\n", " # corrente é o valor de candidatos[i]\n", " # começamos na posição inicial (que tem valor 2)\n", " i, corrente = 0, candidatos[0]\n", " while corrente <= raiz_n:\n", " # Os múltiplos de corrente são os que estão nas posições\n", " # j = i + k * corrente, k = 1, 2, ...\n", " j = i + corrente\n", " while j < len(candidatos):\n", " candidatos[j] = None # Marcamos os múltiplos com None\n", " j += corrente\n", " # Agora que eliminamos os múltiplos de corrente, vamos\n", " # avançar corrente (e i) para o próximo não eliminado\n", " j = i + 1\n", " while j < len(candidatos):\n", " # Se encontramos um candidato não eliminado saímos\n", " if candidatos[j] is not None: break\n", " # Senão, testamos o próximo\n", " j += 1\n", " else:\n", " # Se não houve break, não foi achado candidato.\n", " # Isso quer dizer que não há mais primos a testar.\n", " break\n", " # Se o código continua, então candidatos[j] é o próximo primo.\n", " i, corrente = j, candidatos[j]\n", " # Agora todos os que não estão marcados com None são primos.\n", " # Copio esses valores em uma lista de resultados.\n", " res = []\n", " for x in candidatos:\n", " if x is not None:\n", " res.append(x)\n", " return res" ] }, { "cell_type": "code", "execution_count": 102, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[2, 3, 5, 7, 11, 13]" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" } ], "source": [ "primos_ate(15)" ] }, { "cell_type": "code", "execution_count": 103, "metadata": { "autoscroll": "json-false", "collapsed": false, "ein.tags": [ "worksheet-0" ] }, "outputs": [ { "data": { "text/plain": [ "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]" ] }, "execution_count": 103, "metadata": {}, "output_type": "execute_result" } ], "source": [ "primos_ate(50)" ] }, { "cell_type": "code", "execution_count": 104, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[2,\n", " 3,\n", " 5,\n", " 7,\n", " 11,\n", " 13,\n", " 17,\n", " 19,\n", " 23,\n", " 29,\n", " 31,\n", " 37,\n", " 41,\n", " 43,\n", " 47,\n", " 53,\n", " 59,\n", " 61,\n", " 67,\n", " 71,\n", " 73,\n", " 79,\n", " 83,\n", " 89,\n", " 97,\n", " 101,\n", " 103,\n", " 107,\n", " 109,\n", " 113,\n", " 127,\n", " 131,\n", " 137,\n", " 139,\n", " 149,\n", " 151,\n", " 157,\n", " 163,\n", " 167,\n", " 173,\n", " 179,\n", " 181,\n", " 191,\n", " 193,\n", " 197,\n", " 199,\n", " 211,\n", " 223,\n", " 227,\n", " 229,\n", " 233,\n", " 239,\n", " 241,\n", " 251,\n", " 257,\n", " 263,\n", " 269,\n", " 271,\n", " 277,\n", " 281,\n", " 283,\n", " 293,\n", " 307,\n", " 311,\n", " 313,\n", " 317,\n", " 331,\n", " 337,\n", " 347,\n", " 349,\n", " 353,\n", " 359,\n", " 367,\n", " 373,\n", " 379,\n", " 383,\n", " 389,\n", " 397,\n", " 401,\n", " 409,\n", " 419,\n", " 421,\n", " 431,\n", " 433,\n", " 439,\n", " 443,\n", " 449,\n", " 457,\n", " 461,\n", " 463,\n", " 467,\n", " 479,\n", " 487,\n", " 491,\n", " 499,\n", " 503,\n", " 509,\n", " 521,\n", " 523,\n", " 541,\n", " 547,\n", " 557,\n", " 563,\n", " 569,\n", " 571,\n", " 577,\n", " 587,\n", " 593,\n", " 599,\n", " 601,\n", " 607,\n", " 613,\n", " 617,\n", " 619,\n", " 631,\n", " 641,\n", " 643,\n", " 647,\n", " 653,\n", " 659,\n", " 661,\n", " 673,\n", " 677,\n", " 683,\n", " 691,\n", " 701,\n", " 709,\n", " 719,\n", " 727,\n", " 733,\n", " 739,\n", " 743,\n", " 751,\n", " 757,\n", " 761,\n", " 769,\n", " 773,\n", " 787,\n", " 797,\n", " 809,\n", " 811,\n", " 821,\n", " 823,\n", " 827,\n", " 829,\n", " 839,\n", " 853,\n", " 857,\n", " 859,\n", " 863,\n", " 877,\n", " 881,\n", " 883,\n", " 887,\n", " 907,\n", " 911,\n", " 919,\n", " 929,\n", " 937,\n", " 941,\n", " 947,\n", " 953,\n", " 967,\n", " 971,\n", " 977,\n", " 983,\n", " 991,\n", " 997]" ] }, "execution_count": 104, "metadata": {}, "output_type": "execute_result" } ], "source": [ "primos_ate(1000)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "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 }