Aprenda Computação com Python 3.0.pdf

Aprenda Computao com Python 3.0Verso 1

Allen Downey, Jeff Elkner and Chris Meyers

14/09/2009

Contedo

1 Prefcio 31.1 Como e porque eu vim a usar Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Encontrando um livro-texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3 Introduzindo programao com Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.4 Construindo uma comunidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Apresentao 7

3 Captulo 1: O caminho do programa 93.1 1.1 A linguagem de programao Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.2 1.2 O que um programa? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.3 1.3 O que depurao (debugging)? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.4 1.4 Linguagens naturais e linguagens formais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.5 1.5 O primeiro programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.6 1.6 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4 Captulo 2: Variveis, expresses e comandos 174.1 2.1 Valores e tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174.2 2.2 Variveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184.3 2.3 Nomes de variveis e palavras reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.4 2.4 Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.5 2.5 Avaliando expresses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.6 2.6 Operadores e operandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.7 2.7 Ordem dos operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.8 2.8 Operaes com strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.9 2.9 Composio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.10 2.11 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

5 Captulo 3: Funes 255.1 3.1 Chamadas de funes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255.2 3.2 Converso entre tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265.3 3.3 Coero entre tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265.4 3.4 Funes matemticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275.5 3.5 Composio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

i

5.6 3.6 Adicionando novas funes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285.7 3.7 Definies e uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.8 3.8 Fluxo de execuo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.9 3.9 Parmetros e argumentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315.10 3.10 Variveis e parmetros so locais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.11 3.11 Diagramas da pilha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.12 3.12 Funes com resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.13 3.13 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

6 Captulo 4: Condicionais e recursividade 356.1 4.1 O operador mdulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356.2 4.2 Expresses booleanas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366.3 4.3 Operadores lgicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366.4 4.4 Execuo condicional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.5 4.5 Execuo alternativa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.6 4.6 Condicionais encadeados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386.7 4.7 Condicionais aninhados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386.8 4.8 A instruo return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396.9 4.9 Recursividade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396.10 4.10 Diagramas de pilha para funes recursivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416.11 4.11 Recursividade infinita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416.12 4.12 Entrada pelo teclado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.13 4.13 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

7 Captulo 5: Funes frutferas 457.1 5.1 Valores de retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457.2 5.2 Desenvolvimento de programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467.3 5.3 Composio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.4 5.4 Funes booleanas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497.5 5.5 Mais recursividade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.6 5.6 Voto de confiana (Leap of faith) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517.7 5.7 Mais um exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527.8 5.8 Checagem de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527.9 5.9 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

8 Captulo 6: Iterao 558.1 6.1 Reatribuies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558.2 6.2 O comando while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568.3 6.3 Tabelas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578.4 6.4 Tabelas de duas dimenses (ou bi-dimensionais) . . . . . . . . . . . . . . . . . . . . . . . . . . 598.5 6.5 Encapsulamento e generalizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608.6 6.6 Mais encapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608.7 6.7 Variveis locais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618.8 6.8 Mais generalizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628.9 6.9 Funes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638.10 6.10 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

9 Captulo 7: Strings 659.1 7.1 Um tipo de dado composto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659.2 7.2 Comprimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669.3 7.3 Travessia e o loop for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669.4 7.4 Fatias de strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679.5 7.5 Comparao de strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689.6 7.6 Strings so imutveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699.7 7.7 Uma funo find (encontrar) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

ii

9.8 7.8 Iterando e contando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699.9 7.9 O mdulo string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709.10 7.10 Classificao de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719.11 7.11 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

10 Captulo 8: Listas 7310.1 8.1 Valores da lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7310.2 8.2 Acessado elementos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7410.3 8.3 Comprimento da lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7510.4 8.4 Membros de uma lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7610.5 8.5 Listas e laos for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7610.6 8.6 Operaes em listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7710.7 8.7 Fatiamento de listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7710.8 8.8 Listas so mutveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7710.9 8.9 Remoo em lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7810.10 8.10 Ojetos e valores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7910.11 8.11 Apelidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8010.12 8.12 Clonando listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8010.13 8.13 Lista como parmetro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8110.14 8.14 Lista aninhadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8210.15 8.15 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8210.16 8.16 Strings e listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8310.17 8.17 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8310.18 Outros termos utilizados neste captulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

11 Captulo 9: Tuplas 8511.1 9.1 Mutabilidade e tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8511.2 9.2 Atribuies de tupla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8611.3 9.3 Tuplas como valores de retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8711.4 9.4 Nmeros aleatrios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8711.5 9.5 Lista de nmeros aleatrios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8811.6 9.6 Contando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8811.7 9.7 Vrios intervalos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8911.8 9.8 Uma soluo em um s passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9011.9 9.9 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

12 Captulo 10: Dicionrios 9312.1 10.1 Operaes dos Dicionrios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9412.2 10.2 Mtodos dos Dicionrios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9412.3 10.3 Aliasing (XXX) e Copiar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9512.4 10.4 Matrizes Esparsas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9612.5 10.5 Hint XXX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9712.6 10.6 Inteiros Longos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9912.7 10.7 Contando Letras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9912.8 10.8 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

13 Captulo 11: Arquivos e excees 10113.1 Arquivos e excees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10113.2 11.1 Arquivos texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10313.3 11.2 Gravando variveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10413.4 11.3 Diretrios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10613.5 11.4 Pickling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10613.6 11.5 Excees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10713.7 11.6 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

iii

14 Captulo 12: Classes e objetos 10914.1 12.1 Tipos compostos definidos pelo usurio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10914.2 12.2 Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11014.3 12.3 Instncias como parmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11114.4 12.4 O significado de mesmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11114.5 12.5 Retngulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11214.6 12.6 Instancias como valores retornados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11314.7 12.7 Objetos so mutveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11314.8 12.8 Copiando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11414.9 12.9 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

15 Captulo 13: Classes e funes 11715.1 13.1 Horario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11715.2 13.2 Funes Puras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11815.3 13.3 Modificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11915.4 13.4 O que melhor ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12015.5 13.5 Desenvolvimento Prototipado versus Desenvolvimento Planejamento . . . . . . . . . . . . . . . 12015.6 13.6 Generalizao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12115.7 13.7 Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12115.8 13.8 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

16 Captulo 14: Classes e mtodos 12316.1 14.1 Caractersticas da orientao a objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12316.2 14.2 exibeHora (printTime) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12416.3 14.3 Um outro exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12516.4 14.4 Um exemplo mais complicado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12516.5 14.10 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

17 Captulo 15: Conjuntos de objetos 12717.1 15.1 Composio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12717.2 15.2 Objetos Carta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12717.3 15.3 Atributos de classe e o mtodo __str__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12817.4 15.4 Comparando cartas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12917.5 15.5 Baralhos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13017.6 15.6 Imprimindo o baralho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13017.7 15.7 Embaralhando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13217.8 15.8 Removendo e distribuindo cartas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13217.9 15.9 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

18 Capitulo 16: Herana 13518.1 16.1 Herana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13518.2 16.2 Uma mo de cartas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13618.3 16.3 Dando as cartas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13618.4 16.4 Exibindo a mao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13718.5 16.5 A classe JogoDeCartas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13818.6 16.6 Classe MaoDeMico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13818.7 16.7 Classe Mico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14018.8 16.8 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

19 Captulo 17: Listas encadeadas 14519.1 17.1 Referncias Embutidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14519.2 17.2 A classe No (Node) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14619.3 17.3 Listas como Colees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14719.4 17.4 Listas e Recorrncia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14819.5 17.5 Listas Infinitas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

iv

19.6 17.6 O Teorema da Ambigidade Fundamental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14919.7 17.7 Modificando Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15019.8 17.8 Envoltrios e Ajudadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15119.9 17.9 A Classe ListaLigada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15119.10 17.10 Invariantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15219.11 17.11 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

20 Captulo 18: Pilhas 15520.1 18.1 Tipos abstratos de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15520.2 18.2 O TAD Pilha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15620.3 18.3 Implementando pilhas com listas de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15620.4 18.4 Empilhando e desempilhando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15720.5 18.5 Usando uma pilha para avaliar expresses ps-fixas . . . . . . . . . . . . . . . . . . . . . . . . 15720.6 18.6 Anlise sinttica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15720.7 18.7 Avaliando em ps-fixo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

21 Captulo 19: Filas 16121.1 19.1 Um TDA Fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16121.2 19.2 Fila encadeada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16121.3 19.3 Caractersticas de performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16221.4 19.4 Fila encadeada aprimorada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16321.5 19.5 Fila por prioridade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16421.6 19.6 A classe Golfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16521.7 19.7 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

22 Captulo 20: rvores 16722.1 20.1 Construindo rvores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16822.2 20.2 Percorrendo rvores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16922.3 20.3 rvores de expresses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16922.4 20.4 Percurso de rvores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17022.5 20.5 Construindo uma rvore de expresso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17222.6 20.6 Manipulando erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17522.7 20.7 A rvore dos animais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17622.8 20.8 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

23 Apndice A: Depurao 18123.1 A.1 Erros de sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18223.2 A.2 Erros de tempo de execuo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18323.3 A.3 Erros de semntica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

24 Apndice B: Criando um novo tipo de dado 18924.1 B.1 Multiplicao de fraes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19024.2 B.2 Soma de fraes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19124.3 B.3 Simplificando fraes: O algoritmo de Euclides . . . . . . . . . . . . . . . . . . . . . . . . . . 19224.4 B.4 Comparando fraes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19324.5 B.5 Indo mais alm... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19324.6 B.6 Glossrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

25 Apndice C: Leituras recomendadas 19525.1 C.1 Recomendaes para leitura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19525.2 C.2 Sites e livros sobre Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19625.3 C.3 Livros de cincia da computao recomendados . . . . . . . . . . . . . . . . . . . . . . . . . . 197

26 Apndice D: GNU Free Documentation License 199

v

27 Indices and tables 201

vi

Aprenda Computao com Python 3.0, Verso 1

Contents:

Contedo 1


2 Contedo

CAPTULO 1

Prefcio

Por Jeff Elkner

Este livro deve sua existncia colaborao possibilitada pela Internet e pelo movimento do software livre. Seustrs autores um professor universitrio, um professor secundarista e um programador profissional ainda no seencontraram pessoalmente, mas temos sido capazes de trabalhar em estreita colaborao e temos sido ajudados pormuitos colegas maravilhosos que tm dedicado seu tempo e energia para ajudar a fazer deste um livro cada vez melhor.

Achamos que este livro um testemunho dos benefcios e possibilidades futuras deste tipo de colaborao, cujomodelo tem sido posto em prtica por Richard Stallman e pela Free Software Foundation.

1.1 Como e porque eu vim a usar Python

Em 1999, o Exame de Colocao Avanada em Cincia da Computao da Comisso de Faculdades (College BoardsAdvanced Placement (AP) Computer Science XXX) foi aplicado em C++ pela primeira vez. Como em muitas escolassecundrias atravs do pas, a deciso de mudar linguagens teve um impacto direto no currculo de cincia da com-putao na Yorktown High School em Arlington, Virginia, onde leciono. At ento, Pascal era a linguagem didticapara nossos cursos de primeiro ano e avanado. Mantendo a prtica corrente de dar aos estudantes dois anos de ex-posio mesma linguagem, tomamos a deciso de mudar para C++ no curso de primeiro ano para o ano letivo de1997-98 de modo que estaramos em sincronismo com a mudana da Comisso de Faculdades (College Boards XXX)em relao ao curso avanado (AP XXX) para o ano seguinte.

Dois anos depois, eu estava convencido que C++ foi uma escolha infeliz para introduzir os alunos em cincia dacomputao. Ao mesmo tempo em que certamente uma linguagem de programao muito poderosa, tambm umalinguagem extremamente difcil de aprender e de ensinar. Eu me encontrava constantemente lutando com a sintaxedifcil de C++ e as mltiplas maneiras de fazer a mesma coisa, e estava, como resultado, perdendo muitos alunosdesnecessariamente. Convencido de que deveria existir uma linguagem melhor para a nossa classe de primeiro ano,fui procurar por uma alternativa a C++.

Eu precisava de uma linguagem que pudesse rodar nas mquinas em nosso laboratrio Linux bem como nas platafor-mas Windows e Macintosh que a maioria dos alunos tinha em casa. Eu precisava que ela fosse gratuita e disponveleletronicamente, assim os alunos poderiam utiliz-la em casa independentemente de suas rendas. Eu queria umalinguagem que fosse utilizada por programadores profissionais, e que tivesse uma comunidade de desenvolvimentoativa em torno dela. Ela teria que suportar ambas, programao procedural e orientada a objetos. E, mais importante,deveria ser fcil de aprender e de ensinar. Quando considerei as alternativas tendo em mente aquelas metas, Pythonsobressaiu-se como a melhor candidata para a tarefa.

3


Pedi para um dos talentosos estudantes de Yorktown, Matt Ahrens, que experimentasse Python. Em dois meses ele nos aprendeu a linguagem como tambm escreveu uma aplicao chamada pyTicket que possibilitou nossa equipereportar problemas de tecnologia pela Web. Eu sabia que Matt no poderia ter finalizado uma aplicao daqueleporte em perodo to curto em C++, e esta realizao, combinada com a avaliao positiva de Python dada por Matt,sugeriam que Python era a soluo que eu estava procurando.

1.2 Encontrando um livro-texto

Tendo decidido usar Python em minhas aulas introdutrias de cincia da computao do ano seguinte, o problemamais urgente era a falta de um livro-texto disponvel.

O contedo livre veio em socorro. Anteriormente naquele ano, Richard Stallman tinha me apresentado a AllenDowney. Ambos havamos escrito a Richard expressando interesse em desenvolver contedo educacional livre. Allenj tinha escrito um livro-texto para o primeiro ano de cincia da computao, How to Think Like a Computer Scientist.Quando li este livro, soube imediatamente que queria utiliz-lo nas minhas aulas. Era o mais claro e proveitoso textoem cincia da computao que eu tinha visto. Ele enfatizava o processo de reflexo envolvido em programao emvez de caractersticas de uma linguagem em particular. L-lo fez de mim imediatamente um professor melhor.

O How to Think Like a Computer Scientist era no s um excelente livro, como tambm fora lanado sob uma licenapblica GNU, o que significava que ele poderia ser usado livremente e modificado para atender as necessidades de seuusurio. Uma vez que eu havia decidido usar Python, me ocorreu que eu poderia traduzir a verso original do livro deAllen do Java para a nova linguagem. Apesar de no estar capacitado para escrever eu mesmo um livro-texto, tendoo livro de Allen para trabalhar, tornou possvel para mim faz-lo, ao mesmo tempo demonstrando que o modelo dedesenvolvimento cooperativo to bem utilizado em software poderia tambm funcionar para contedo educacional.

Trabalhar neste livro pelos ltimos dois anos tem sido recompensador para mim e meus alunos, e eles tiveram umgrande papel neste processo. A partir do momento em que eu podia fazer mudanas instantneas assim que algumencontrasse um erro ortogrfico ou um trecho difcil, eu os encorajei a procurar por erros no livro, dando a eles pontosde bonificao cada vez que fizessem uma sugesto que resultasse em uma mudana no texto. Isto teve o duplobenefcio de encoraj-los a ler o texto mais cuidadosamente e de ter o texto totalmente revisado por seus crticos maisimportantes: alunos utilizando-o para aprender cincia da computao.

Para a segunda metade do livro, sobre programao orientada a objetos, eu sabia que seria preciso algum com umamaior experincia do que a minha em programao real para faz-lo corretamente. O livro esteve em estado inacabadopor quase um ano at que a comunidade de software livre providenciasse mais uma vez os meios necessrios para suaconcluso.

Eu recebi um e-mail de Chris Meyers mostrando interesse no livro. Chris um programador profissional que comeoua dar um curso de programao no ano anterior usando Python no Lane Community College em Eugene, Oregon. Aperspectiva de dar aquele curso ligou Chris ao livro, e ele comeou a ajudar o trabalho imediatamente. At o finaldo ano letivo ele tinha criado um projeto colaborativo em nosso Website em http://www.ibiblio.org/obpchamado Python for Fun e estava trabalhando com alguns dos meus alunos mais avanados como um guru (masterteacher XXX), guiando-os alm de onde eu poderia lev-los.

1.3 Introduzindo programao com Python

O processo de traduzir e utilizar How to Think Like a Computer Scientist pelos ltimos dois anos tem confirmado aconvenincia de Python no ensino de alunos iniciantes. Python simplifica tremendamente os programas exemplo etorna idias importantes de programao mais fceis de ensinar.

O primeiro exemplo do texto ilustra este ponto. o tradicional programa Al mundo, o qual na verso C++ do livrose parece com isto:

4 Captulo 1. Prefcio


#include

void main(){

cout


1.4 Construindo uma comunidade

Tenho recebido e-mails de todo o planeta de pessoas utilizando este livro para aprender ou ensinar programao.Uma comunidade de usurios tem comeado a emergir e muitas pessoas tm contribudo com o projeto enviando seusmateriais para o Website cooperativo em:

http://www.thinkpython.com

Com a publicao do livro em formato impresso, minha expectativa quanto ao crescimento da comunidade de usurios que ela seja contnua e acelerada. O surgimento desta comunidade de usurios e a possibilidade que sugere decolaborao semelhante entre educadores tem sido para mim a parte mais excitante do trabalho neste projeto. Tra-balhando juntos, podemos aumentar a qualidade do material disponvel para o nosso uso e poupar tempo valioso. Euconvido voc a se juntar a nossa comunidade e espero ouvir algo de voc. Por favor, escreva para os autores [email protected].

Jeffrey Elkner

Yorktown High School

Arlington, Virginia

6 Captulo 1. Prefcio

CAPTULO 2

Apresentao

Por David Beazley

Como educador, pesquisador e autor de livros, regozija-me ver completo este trabalho. Python uma linguagem deprogramao divertida e extremamente fcil de usar que tem ganho forte popularidade nestes ltimos poucos anos.Desenvolvida dez anos atrs por Guido van Rossun, a sintaxe simples do Python e seu sentido geral so grande-mente derivados do ABC, uma linguagem didtica que foi desenvolvida nos anos 80. Entretanto, Python tambm foicriado para solucionar problemas reais e tomou emprestado uma grande quantidade de caractersticas de linguagensde programao como C++, Java, Modula-3 e Scheme. Por causa disso, uma das mais notveis caractersticas doPython o grande apelo que tem junto a desenvolvedores profissionais de software, cientistas, pesquisadores, artistase educadores.

A Despeito deste apelo do Python junto s mais variadas comunidades, voc pode ainda estar pensando por quePython? ou por que ensinar programao com Python?. Responder estas perguntas no uma tarefa fcil,especialmente se a opinio pblica est do lado de alternativas mais masoquistas como C++ e Java. Entretanto, euacho que a resposta mais direta que programar com Python um bocado divertido e mais produtivo.

Quando ministro cursos de cincias da computao, o que desejo cobrir conceitos importantes alm de tornar amatria interessante e os alunos participativos. Infelizmente, existe uma tendncia entre os cursos introdutrios deprogramao a focar ateno demais em abstraes matemticas, e de frustrao entre os alunos com problemasenfadonhos e inoportunos relacionados a detalhes de sintaxe em baixo nvel, compilao e a imposio de regrasque aparentemente s um expert pode compreender (enforcement of seemingly arcane rules XXX). Embora algumaabstrao e formalismo sejam importantes para engenheiros profissionais de software e estudantes que planejam con-tinuar seus estudos em cincias da computao, escolher tal abordagem em um curso introdutrio faz da cincia dacomputao algo entediante. Quando ministro um curso, no desejo uma sala cheia de alunos sem inspirao. Em vezdisso, preferiria muito mais v-los tentando solucionar problemas interessantes explorando idias diferentes, trilhandocaminhos no convencionais, quebrando regras, e aprendendo a partir de seus erros. Fazendo assim, no pretendodesperdiar metade de um semestre tentando explicar problemas obscuros de sintaxe, mensagens ininteligveis decompiladores ou as vrias centenas de maneiras pelas quais um programa pode gerar uma falha geral de proteo.

Uma das razes pelas quais eu gosto de Python que ele oferece um equilbrio realmente bom entre o lado prtico eo lado conceitual. Sendo Python interpretado, os iniciantes podem pegar a linguagem e comear a fazer coisas legaisquase imediatamente sem se perderem em problemas de compilao e ligao (linking XXX). Alm disso, Python vemcom uma grande biblioteca de mdulos que podem ser utilizados para fazer todo tipo de tarefa, desde a programaopara a web at grficos. Com tal enfoque prtico temos uma bela maneira de alcanar o engajamento dos alunos epermitir que eles finalizem projetos significativos. Entretanto, Python tambm pode servir de excelente embasamentopara a introduo de conceitos importantes em cincia da computao. J que Python suporta plenamente procedi-mentos (procedures) e classes, os alunos podem ser gradualmente introduzidos a tpicos como abstrao procedural,estruturas de dados, e programao orientada a objetos ? todos aplicveis em cursos posteriores de Java ou C++.

7


Python ainda toma emprestado certas caractersticas de linguagens de programao funcionais e pode ser usado paraintroduzir conceitos cujos detalhes poderiam ser aprofundados em cursos de Scheme e Lisp.

Lendo o prefcio de Jeffrey, fiquei impressionado com seu comentrio de que Python o fez ver um maior nvel desucesso e um menor nvel de frustrao o que lhe permitiu progredir mais depressa com resultados melhores. Em-bora estes comentrios refiram-se aos seus cursos introdutrios, eu s vezes uso Python exatamente pelas mesmasrazes em cursos avanados de ps-graduao (graduate = pos-graduacao XXX) em cincia da computao na Uni-versidade de Chicago. Nestes cursos, enfrento constantemente a assustadora tarefa de cobrir muitos tpicos difceisem um rapidssimo trimestre (quarter XXX) de nove semanas. Embora me seja possvel inflingir um bocado de dor esofrimento pelo uso de uma linguagem como C++, tenho percebido muitas vezes que este enfoque contraproducente,especialmente quando o curso sobre um tpico no relacionado apenas com programar. Acho que usar Python mepermite um melhor foco no tpico em questo, enquanto permite que os alunos completem projetos substanciais emclasse.

Embora Python seja ainda uma linguagem jovem e em evoluo, acredito que tem um futuro brilhante em educao.Este livro um passo importante nessa direo.

David Beazley

Universidade de Chicago

Autor de Python Essencial Reference

8 Captulo 2. Apresentao

CAPTULO 3

Captulo 1: O caminho do programa

Tpicos

Captulo 1: O caminho do programa 1.1 A linguagem de programao Python 1.2 O que um programa? 1.3 O que depurao (debugging)?

* 1.3.1 Erros de sintaxe* 1.3.2 Erros em tempo de execuo (runtime errors)* 1.3.3 Erros de semntica (ou de lgica)* 1.3.4 Depurao experimental (debugging)

1.4 Linguagens naturais e linguagens formais 1.5 O primeiro programa 1.6 Glossrio

O objetivo deste livro ensinar o leitor a pensar como um cientista da computao. Essa maneira de pensar combinaalgumas das melhores caractersticas da matemtica, da engenharia e das cincias naturais. Como os matemticos, oscientistas da computao usam linguagens formais para representar ideias (especificamente, computaes). Como osengenheiros, eles projetam coisas, montando sistemas a partir de componentes e avaliando as vantagens e desvanta-gens de diferentes alternativas. Como os cientistas naturais, eles observam o comportamento de sistemas complexos,formulam hipteses e testam previses.

A habilidade mais importante de um cientista da computao a soluo de problemas. Soluo de problemas a habilidade de formular questes, pensar criativamente sobre solues possveis e expressar uma soluo de formaclara e precisa. Ocorre que aprender a programar uma excelente oportunidade de praticar a habilidade da soluo deproblemas. por isso que este captulo se chama O caminho do programa.

Em certo nvel, voc estar aprendendo a programar, habilidade que til em si mesma. Em outro nvel, voc usara programao como um meio para atingir um objetivo. medida que voc for avanando na leitura, esse objetivoficar mais claro.

3.1 1.1 A linguagem de programao Python

Python a linguagem de programao que voc vai estudar neste livro. Python um exemplo de linguagem deprogramao de alto nvel. Outras linguagens de alto nvel de que voc j pode ter ouvido falar so C++, PHP e Java.

9


Como voc pode deduzir a partir da expresso linguagem de alto nvel, tambm existem as linguagens de baixonvel, s vezes chamadas de linguagens de mquina ou linguagem assembly (linguagens de montagem). Deforma simples, o computador s consegue executar programas escritos em linguagens de baixo nvel. Deste modo,programas escritos em linguagens de alto nvel precisam ser processados antes que possam rodar. Esse processamentoextra toma algum tempo, o que uma pequena desvantagem em relao s linguagens de alto nvel.

Mas as vantagens so enormes. Primeiro, muito mais fcil programar em uma linguagem de alto nvel. maisrpido escrever programas em uma linguagem de alto nvel; eles so mais curtos e mais fceis de ler, e h maiorprobabilidade de esterem corretos. Segundo, as linguagens de alto nvel so portveis, o que significa que podemrodar em diferentes tipos de computador, com pouca ou nenhuma modificao. Programas em baixo nvel s podemrodar em um nico tipo de computador e precisam ser re-escritos para rodar em outro tipo.

Devido a essas vantagens, quase todos os programas so escritos em linguagens de alto nvel. As de baixo nvel soutilizadas somente para umas poucas aplicaes especializadas.

Dois tipos de programas processam linguagens de alto nvel, traduzindo-as em linguagens de baixo nvel: interpreta-dores e compiladores. O interpretador l um programa escrito em linguagem de alto nvel e o executa, ou seja, faz oque o programa diz. Ele processa o programa um pouco de cada vez, alternadamente: hora lendo algumas linhas, horaexecutando essas linhas e realizando clculos.

O compilador l o programa e o traduz completamente antes que o programa comece a rodar. Neste caso, o programaescrito em linguagem de alto nvel chamado de cdigo fonte, e o programa traduzido chamado de cdigo objetoou executvel. Uma vez que um programa compilado, voc pode execut-lo repetidamente, sem que precise de novatraduo.

Python considerada uma linguagem interpretada, pois os programas em Python so executados por um interpretador.Existem duas maneiras de usar o interpretador: no modo de linha de comando e no modo de script. No modo de linhade comando, voc digita programas em Python e o interpretador mostra o resultado:

$ python3.0Python 3.0.1+ (r301:69556, Apr 15 2009, 15:59:22)[GCC 4.3.3] on linux2Type "help", "copyright", "credits" or "license" for more information.>>> print (1 + 1)2

A primeira linha deste exemplo o comando que inicia o interpretador Python. As trs linhas seguintes so mensagensdo interpretador. A quarta linha comea com >>>, que o sinal usado pelo interpretador para indicar que ele estpronto. No exemplo anterior, digitamos print (1 + 1) e o interpretador respondeu 2.

Voc tambm pode escrever um programa em um arquivo e usar o interpretador para executar o contedo desse arquivo.

10 Captulo 3. Captulo 1: O caminho do programa


Um arquivo como este chamado de script. Por exemplo, usamos um editor de texto para criar um arquivo chamadoleticia.py com o seguinte contedo:

print (1 + 1)

Por conveno, arquivos que contenham programas em Python tm nomes que terminam com .py.

Para executar o programa, temos de dizer ao interpretador o nome do script:

$ python leticia.py2

Em outros ambientes de desenvolvimento, os detalhes da execuo de programas podem ser diferentes. Alm disso, amaioria dos programas so mais interessantes do que esse.

A maioria dos exemplos neste livro so executados a partir da linha de comando. Trabalhar com a linha de comando conveniente no desenvolvimento e testagem de programas, porque voc pode digitar os programas e execut-losimediatamente. Uma vez que voc tem um programa que funciona, deve guard-lo em um script, de forma a poderexecut-lo ou modific-lo no futuro.

3.2 1.2 O que um programa?

Um programa uma sequncia de instrues que especificam como executar um clculo ou determinada tarefa.Tal tarefa pode matemtica, como solucionar um sistema de equaes ou encontrar as razes de um polinmio, mastambm pode ser simblica, como buscar e substituir uma palavra em um documento ou (estranhamente) compilar umprograma.

Os detalhes so diferentes em diferentes linguagens, mas algumas instrues bsicas aparecem em praticamente todasas linguagens:

entrar: Pegar dados do teclado, de um arquivo ou de algum outro dispositivo de entrada.

sair: Mostrar dados na tela ou enviar dados para um arquivo ou outro dispositivo de sada.

calcular: Executar operaes matemticas bsicas, como adio e multiplicao.

executar condicionalmente: Checar certas condies e executar a sequncia apropriada de instrues.

repetir: Executar alguma ao repetidamente, normalmente com alguma variao.

Acredite se quiser: isso praticamente tudo. Todos os programas que voc j usou, no importa quo complicados, sofeitos de instrues mais ou menos parecidas com essas. Assim, poderamos definir programao como o processo dedividir uma tarefa grande e complexa em subtarefas cada vez menores, at que as subtarefas sejam simples o suficientepara serem executadas com uma dessas instrues bsicas.

Isso pode parecer um pouco vago, mas vamos voltar a esse tpico mais adiante, quando falarmos sobre algoritmos.

3.3 1.3 O que depurao (debugging)?

Programar um processo complicado e, como feito por seres humanos, frequentemente conduz a erros. Por merocapricho, erros em programas so chamados de bugs e o processo de encontr-los e corrigi-los chamado de depu-rao (debugging).

Trs tipos de erro podem acontecer em um programa: erros de sintaxe, erros em tempo de execuo (runtime errors)e erros de semntica (tambm chamados de erros de lgica). Distinguir os trs tipos ajuda a localiz-los mais rpido:

3.2. 1.2 O que um programa? 11


3.3.1 1.3.1 Erros de sintaxe

O interpretador do Python s executa um programa se ele estiver sintaticamente correto; caso contrrio, o processofalha e retorna uma mensagem de erro. Sintaxe se refere estrutura de um programa e s regras sobre esta estrutura.Por exemplo, em portugus, uma frase deve comear com uma letra maiscula e terminar com um ponto.

esta frase contm um erro de sintaxe. Assim como esta

Para a maioria dos leitores, uns errinhos de sintaxe no chegam a ser um problema significativo e por isso queconseguimos ler a poesia moderna de e. e. cummings sem cuspir mensagens de erro. Python no to indulgente.Se o seu programa tiver um nico erro de sintaxe em algum lugar, o interpretador Python vai exibir uma mensagemde erro e vai terminar - e o programa no vai rodar. Durante as primeiras semanas da sua carreira como programador,voc provavelmente perder um bocado de tempo procurando erros de sintaxe. Conforme for ganhando experincia,entretanto, cometer menos erros e os localizar mais rpido.

3.3.2 1.3.2 Erros em tempo de execuo (runtime errors)

O segundo tipo de erro o erro de runtime, ou erro em tempo de execuo, assim chamado porque s aparece quandovoc roda o programa. Esses erros so tambm conhecidos como excees, porque normalmente indicam que algumacoisa excepcional (e ruim) aconteceu.

Erros de runtime so raros nos programas simples que voc vai ver nos primeiros captulos - ento, vai demorar umpouco at voc se deparar com um erro desse tipo.

3.3.3 1.3.3 Erros de semntica (ou de lgica)

O terceiro tipo de erro o erro de semntica (mais comumente chamado erro de lgica). Mesmo que o seu programatenha um erro de semntica, ele vai rodar com sucesso, no sentido de que o computador no vai gerar nenhumamensagem de erro. S que o programa no vai fazer a coisa certa, vai fazer alguma outra coisa. Especificamente,aquilo que voc tiver dito para ele fazer (o computador trabalha assim: seguindo ordens).

O problema que o programa que voc escreveu no aquele que voc queria escrever. O significado do programa(sua semntica ou lgica) est errado. Identificar erros semnticos pode ser complicado, porque requer que voctrabalhe de trs para frente, olhando a sada do programa e tentando imaginar o que ele est fazendo.

3.3.4 1.3.4 Depurao experimental (debugging)

Uma das habilidades mais importantes que voc vai adquirir a de depurar. Embora possa ser frustrante, depurar uma das partes intelectualmente mais ricas, desafiadoras e interessantes da programao.

De certa maneira, a depurao como um trabalho de detetive. Voc se depara com pistas, e tem que deduzir osprocessos e eventos que levaram aos resultados que aparecem.

Depurar tambm como uma cincia experimental. Uma vez que voc tem uma ideia do que est errado, vocmodifica o seu programa e tenta de novo. Se a sua hiptese estava correta, ento voc consegue prever o resultado damodificao e fica um passo mais perto de um programa que funciona. Se a sua hiptese estava errada, voc tem quetentar uma nova. Como Sherlock Holmes mostrou: Quando voc tiver eliminado o impossvel, aquilo que restou,ainda que improvvel, deve ser a verdade. (Arthur Conan Doyle, O signo dos quatro).

Para algumas pessoas, programao e depurao so a mesma coisa. Ou seja, programar o processo de gradualmentedepurar um programa, at que ele faa o que voc quer. A ideia comear com um programa que faa alguma coisa eir fazendo pequenas modificaes, depurando-as conforme avana, de modo que voc tenha sempre um programa quefunciona.



Por exemplo, o Linux um sistema operacional que contm milhares de linhas de cdigo, mas comeou como umprograma simples, que Linus Torvalds usou para explorar o chip Intel 80386. De acordo com Larry Greenfield, Umdos primeiros projetos de Linus Torvalds foi um programa que deveria alternar entre imprimir AAAA e BBBB. Issodepois evoluiu at o Linux. (The Linux Users Guide Verso Beta 1)

Captulos posteriores faro mais sugestes sobre depurao e outras prticas de programao.

3.4 1.4 Linguagens naturais e linguagens formais

Linguagens naturais so as linguagens que as pessoas falam, como o portugus, o ingls e o espanhol. Elas no foramprojetadas pelas pessoas (muito embora as pessoas tentem colocar alguma ordem nelas); elas evoluram naturalmente.

Linguagens formais so linguagens que foram projetadas por pessoas, para aplicaes especficas. Por exemplo,a notao que os matemticos usam uma linguagem formal, que particularmente boa em denotar relaes entrenmeros e smbolos. Os qumicos usam uma linguagem formal para representar a estrutura qumica das molculas. E,mais importante:

Linguagens de programao so linguagens formais que foram desenvolvidas para expressar com-putaes.

As linguagens formais tendem a ter regras estritas quanto sintaxe. Por exemplo, 3 + 3 = 6 uma expresso matemticasintaticamente correta, mas 3=+6$ no . H2O um nome qumico sintaticamente correto, mas 2Zz no .

As regras de sintaxe so de dois tipos, um relacionado aos smbolos, outro estrutura. Os smbolos so os elementosbsicos da linguagem, como as palavras, nmeros, e elementos qumicos. Um dos problemas com 3=+6$ que $ no um smbolo vlido em linguagem matemtica (pelo menos at onde sabemos). Do mesmo modo, 2Zz invlidaporque no existe nenhum elemento cuja abreviatura seja Zz.

O segundo tipo de erro de sintaxe est relacionado estrutura de uma expresso, quer dizer, ao modo como os sm-bolos esto arrumados. A expresso 3=+6$ estruturalmente invlida, porque voc no pode colocar um sinal demais imediatamente aps um sinal de igual. Do mesmo modo, frmulas moleculares devem ter ndices subscritoscolocados depois do nome do elemento, no antes.

Faa este exerccio: crie o que parea ser uma frase bem estruturada em portugus com smbolos irrecon-hecveis dentro dela. Depois escreva outra frase com todos os smbolos vlidos, mas com uma estruturainvlida.

Quando voc l uma frase em portugus ou uma expresso em uma linguagem formal, voc tem de imaginar como a estrutura da frase (embora, em uma linguagem natural, voc faa isso inconscientemente). Este processo, nacomputao, chamado parsing (anlise sinttica).

Por exemplo, quando voc ouve a frase, Caiu a ficha, entende que a ficha o sujeito e caiu o verbo. Uma vezque voc analisou a frase, consegue entender o seu significado, ou a semntica da frase. Assumindo que voc saiba oque uma ficha e o que significa cair, voc entender o sentido geral dessa frase.

Muito embora as linguagens formais e as naturais tenham muitas caractersticas em comum (smbolos, estrutura,sintaxe e semntica), existem muitas diferenas:

ambiguidade: As linguagens naturais esto cheias de ambiguidades, que as pessoas contornam usando pistas con-textuais e outras informaes. J as linguagens formais so desenvolvidas para serem quase ou totalmentedesprovidas de ambiguidade, o que significa que qualquer expresso tem precisamente s um sentido, indepen-dentemente do contexto.

redundncia: Para compensar a ambiguidade e reduzir maus entendidos, emprega-se muita redundncia nas lingua-gens naturais, o que frequentemente as torna prolixas. As linguagens formais so menos redundantes e maisconcisas.

3.4. 1.4 Linguagens naturais e linguagens formais 13


literalidade: As linguagens naturais esto cheias de expresses idiomticas e metforas. Se eu digo Caiu a ficha, possvel que no exista ficha nenhuma, nem nada que tenha cado. Nas linguagens formais, no h sentidoambguo.

Pessoas que crescem falando uma linguagem natural, ou seja, todo mundo, muitas vezes tm dificuldade de se acostu-mar com uma linguagem formal. De certa maneira, a diferena entre linguagens formais e naturais como a diferenaentre poesia e prosa, porm mais acentuada:

poesia: As palavras so usadas pela sua sonoridade, alm de seus sentidos, e o poema como um todo cria um efeitoou uma reao emocional. A ambiguidade no apenas frequente, mas na maioria das vezes, proposital.

prosa: O sentido literal das palavras mais importante, e a estrutura contribui mais para o significado. A prosa maisfcil de analisar do que a poesia, mas ainda , muitas vezes, ambgua.

programas: O significado de um programa de computador exato e literal, e pode ser inteiramente entendido pelaanlise de seus smbolos e de sua estrutura.

Aqui vo algumas sugestes para a leitura de programas (e de outras linguagens formais). Primeiro, lembre-se de quelinguagens formais so muito mais densas do que linguagens naturais, por isso, mais demorado l-las. A estruturatambm muito importante, logo, geralmente no uma boa ideia ler de cima para baixo, da esquerda para a direita.Em vez disso, aprenda a analisar o programa na sua cabea, identificando os smbolos e interpretando a estrutura.Finalmente, os detalhes so importantes. Pequenas coisas, como erros ortogrficos e m pontuao, com as quais vocpode se safar nas linguagens naturais, podem fazer uma grande diferena em uma linguagem formal.

3.5 1.5 O primeiro programa

Tradicionalmente, o primeiro programa escrito em uma nova linguagem de programao chamado de Al, Mundo!porque tudo que ele faz apresentar as palavras Al, Mundo!. Em Python, ele assim:

print ("Al, Mundo!")

Isso um exemplo de um comando que faz a chamada da funo print, que, na realidade, no imprime nada empapel. Ele apresenta o valor na tela. Neste caso, o resultado so as palavras:

Al, Mundo!

As aspas no programa marcam o comeo e o fim do valor, elas no aparecem no resultado final.

Algumas pessoas julgam a qualidade de uma linguagem de programao pela simplicidade do programa Al,Mundo!. Por esse padro, Python se sai to bem quanto possvel.

3.6 1.6 Glossrio

algoritmo (algorithm) Processo geral para soluo de uma certa categoria de problema.

anlise sinttica (parse) Examinar um programa e analisar sua estrutura sinttica.

bug Erro em um programa.

cdigo fonte (source code) Um programa em uma linguagem de alto nvel, antes de ter sido compilado.

cdigo objeto (object code) A sada do compilador, depois que ele traduziu o programa.

funo print (print statement) Funo que leva o interpretador Python a apresentar um valor na tela.

compilar (compile) Traduzir todo um programa escrito em uma linguagem de alto nvel para uma de baixo nvel deuma s vez, em preparao para uma execuo posterior.



depurao (debugging) O processo de encontrar e remover qualquer um dos trs tipos de erros de programao.

erro de semntica ou lgica (semantic error) Erro em um programa, que o leva a fazer algo diferente do que pre-tendia o programador.

erro de sintaxe (syntax error) Erro em um programa, que torna impossvel a anlise sinttica (logo, tambm impos-svel a interpretao).

erro em tempo de execuo (runtime error) Erro que no ocorre at que o programa seja executado, mas que impedeque o programa continue.

exceo (exception) Um outro nome para um erro em tempo de execuo ou erro de runtime.

executvel (executable) Um outro nome para cdigo objeto que est pronto para ser executado.

interpretar (interpret) Executar um programa escrito em uma linguagem de alto nvel, traduzindo-o uma linha decada vez.

linguagem de alto nvel (high-level language) Uma linguagem de programao como Python: projetada para serfcil para os seres humanos utilizarem.

linguagem de baixo nvel (low-level language) Uma linguagem de programao que concebida para ser fcil paraum computador, tal como a linguagem de mquina ou a linguagem montagem (assembly language)

linguagem formal (formal language) Qualquer linguagem desenvolvida pelas pessoas para propsitos especficos,tais como, a representao de ideias matemticas ou programas de computadores; todas as linguagens de pro-gramao so linguagens formais.

linguagem natural (natural language) Qualquer lngua falada pelos seres humanos que tenha evoludo natural-mente.

portabilidade (portability) Propriedade que um programa tem de rodar em mais de um tipo de computador.

programa (program) Conjunto de instrues que especifica uma computao.

script Um programa guardado em um arquivo (normalmente um que ser interpretado).

semntica (semantics) O significado de um programa.

smbolo (token) Um elemento bsico da estrutura sinttica de um programa, anlogo a uma palavra em uma lin-guagem natural.

sintaxe (syntax) A estrutura de um programa.

soluo de problemas (problem solving) O processo de formular um problema, encontrar uma soluo e expressaresta soluo.

3.6. 1.6 Glossrio 15

CAPTULO 4

Captulo 2: Variveis, expresses ecomandos

Tpicos

Captulo 2: Variveis, expresses e comandos 2.1 Valores e tipos 2.2 Variveis 2.3 Nomes de variveis e palavras reservadas 2.4 Comandos 2.5 Avaliando expresses 2.6 Operadores e operandos 2.7 Ordem dos operadores 2.8 Operaes com strings 2.9 Composio 2.11 Glossrio

4.1 2.1 Valores e tipos

O valor (por exemplo, letras e nmeros) uma das coisas fundamentais que um programa manipula. Os valores quej vimos at agora foram o 2 (como resultado, quando adicionamos 1 + 1) e "Al, Mundo!".

Esses valores pertencem a tipos diferentes: 2 um inteiro, e "Al, Mundo!" uma string, assim chamada porquestring, em ingls, quer dizer sequncia, srie, cadeia (de caracteres), ou neste caso, srie de letras. Voc (e ointerpretador) consegue identificar strings porque elas aparecem entre aspas.

A funo print tambm funciona com inteiros:

>>> print (4)4

Se voc estiver em dvida sobre qual o tipo de um determinado valor, o interpretador pode revelar:

>>> type("Al, Mundo!")

17


>>> type(17)

Nenhuma surpresa: strings pertencem ao tipo str e inteiros pertencem ao tipo int. Menos obviamente, nmeroscom um ponto decimal pertencem a um tipo chamado float, porque estes nmeros so representados em um formatochamado ponto flutuante 1:

>>> type(3.2)

O que dizer de valores como "17" e "3.2"? Eles parecem nmeros, mas esto entre aspas, como strings:

>>> type("17")

>>> type("3.2")

Eles so strings.

Ao digitar um nmero grande, tentador usar pontos entre grupos de trs dgitos, assim: 1.000.000. Isso no funcionapor que Python usa o ponto como separador decimal. Usar a vrgula, como se faz em ingls, resulta numa expressovlida, mas no no nmero que queramos representar:

>>> print (1,000,000)1 0 0

No nada do que se esperava! Python interpreta 1,000,000 como uma tupla, algo que veremos no Captulo 9. Porhora, lembre-se apenas de no colocar vrgulas nos nmeros.

4.2 2.2 Variveis

Uma das caractersticas mais poderosas de uma linguagem de programao a habilidade de manipular variveis.Uma varivel um nome que se refere a um valor.

O comando de atribuio cria novas variveis e d a elas valores:

>>> mensagem = "E a, Doutor?">>> n = 17>>> pi = 3.14159

Este exemplo faz trs atribuies. A primeira atribui a string "E a, Doutor?" a uma nova varivel chamadamensagem. A segunda d o valor inteiro 17 a n, e a terceira atribui o nmero de ponto flutuante 3.14159 varivelchamada pi.

Uma maneira comum de representar variveis no papel escrever o nome delas com uma seta apontando para ovalor da varivel. Esse tipo de figura chamado de diagrama de estado porque mostra em que estado cada varivelest (pense nisso como o estado de esprito da varivel). O diagrama a seguir mostra o resultado das instrues deatribuio:

1 N.T.: Observe o uso de ponto no lugar da vrgula para separar a parte inteira da parte fracionria.

18 Captulo 4. Captulo 2: Variveis, expresses e comandos


A funo print tambm funciona com variveis:

>>> print (mensagem)E a, Doutor?>>> print (n)17>>> print (pi)3.14159

Em cada um dos casos, o resultado o valor da varivel. Variveis tambm tm tipo. Novamente, podemos perguntarao interpretador quais so eles:

>>> type(mensagem)

>>> type(n)

>>> type(pi)

O tipo de uma varivel o tipo do valor ao qual ela se refere.

4.3 2.3 Nomes de variveis e palavras reservadas

Os programadores geralmente escolhem nomes significativos para suas variveis, pois os nomes documentam para oque a varivel usada.

Nomes de variveis podem ser arbitrariamente longos. Eles podem conter tanto letras quanto nmeros, mas tm decomear com uma letra. Embora seja vlida a utilizao de letras maisculas, por conveno, no usamos. Se voc ofizer, lembre-se de que maisculas e minsculas so diferentes. Bruno e bruno so variveis diferentes.

O caractere para sublinhado ( _ ) pode aparecer em um nome. Ele muito utilizado em nomes com mltiplas palavras,tal como em meu_nome ou preco_do_cha_na_china.

Se voc der a uma varivel um nome invlido, causar um erro de sintaxe:

>>> 76trombones = "grande parada"SyntaxError: invalid syntax>>> muito$ = 1000000SyntaxError: invalid syntax>>> class = "Ciencias da Computacao 101"SyntaxError: invalid syntax

76trombones invlida por no comear com uma letra. muito$ invlida por conter um caractere ilegal, ocifro. Mas o que est errado com class?

4.3. 2.3 Nomes de variveis e palavras reservadas 19


Ocorre que class uma das palavras reservadas em Python. Palavras reservadas definem as regras e a estrutura dalinguagem e no podem ser usadas como nomes de variveis.

Python tem 33 palavras reservadas:

and def for is raise Falseas del from lambda return Noneassert elif global nonlocal try Truebreak else if not whileclass except import or withcontinue finally in pass yield

Pode ser til ter essa lista mo. Se o interpretador acusar erro sobre um de seus nomes de varivel e voc no soubero porqu, veja se o nome est na lista. Essa lista pode ser obtida atravs do prprio interpretador Python, com apenasdois comandos:

import keywordprint (keyword.kwlist)

4.4 2.4 Comandos

Um comando uma instruo que o interpretador Python pode executar. Vimos at agora dois tipos de comandos: deexibio (a chamada da funo print) e de atribuio.

Quando voc digita um comando na linha de comando, o Python o executa e mostra o resultado, se houver um. Oresultado de um comando como a chamada da funo print a exibio de um valor. Comandos de atribuio noproduzem um resultado visvel.

Um script normalmente contm uma sequncia de comandos. Se houver mais de um comando, os resultados apare-cero um de cada vez, conforme cada comando seja executado.

Por exemplo, o script:

print (1)x = 2print (2)

produz a sada:

12

Lembrando que o comando de atribuio no produz sada.

4.5 2.5 Avaliando expresses

Uma expresso uma combinao de valores, variveis e operadores. Se voc digitar uma expresso na linha decomando, o interpretador avalia e exibe o resultado:

>>> 1 + 12

Embora expresses contenham valores, variveis e operadores, nem toda expresso contm todos estes elementos. Umvalor por si s considerado uma expresso, do mesmo modo que uma varivel:



>>> 1717>>> x2

Avaliar uma expresso no exatamente a mesma coisa que imprimir um valor:

>>> mensagem = "E a, Doutor?">>> mensagemE a, Doutor?>>> print (mensagem)E a, Doutor?

Quando Python exibe o valor de uma expresso, usa o mesmo formato que voc usaria para entrar com o valor. Nocaso de strings, isso significa que as aspas so includas 2. Mas o comando print imprime o valor da expresso, que,neste caso, o contedo da string.

Num script, uma expresso sozinha um comando vlido, porm sem efeito. O script:

173.2"Al, Mundo!"1 + 1

no produz qualquer sada. Como voc mudaria o script para exibir os valores destas quatro expresses?

4.6 2.6 Operadores e operandos

Operadores so smbolos especiais que representam computaes como adio e multiplicao. Os valores que ooperador usa so chamados operandos.

Todas as expresses seguintes so vlidas em Python e seus significados so mais ou menos claros:

20+32 hora-1 hora*60+minuto minuto/60 minuto//60 5**2 (5+9)*(15-7)

Em Python, os smbolos +, -, / e o uso de parnteses para agrupamento tm o mesmo significado que em matemtica.O asterisco (*) o smbolo para multiplicao, ** o smbolo para potenciao e // o smbolo para diviso inteira.

Quando um nome de varivel aparece no lugar de um operando, ele substitudo pelo valor da varivel, antes daoperao ser executada.

Adio, subtrao, multiplicao e potenciao fazem o que se espera: quando todos os operandos so inteiros, oresultado da operao um valor inteiro. Voc pode ficar surpreso com a diviso. Observe as seguintes operaes:

>>> minuto = 59>>> minuto/600.98333333333333328>>> minuto = 59>>> minuto//600

O valor de minuto 59 e, em aritmtica convencional (/), 59 dividido por 60 0,98333. J a diviso inteira (//) de 59por 60 0.

2 N.T.: Python aceita aspas simples ou duplas para delimitar strings.

4.6. 2.6 Operadores e operandos 21


4.7 2.7 Ordem dos operadores

Quando mais de um operador aparece em uma expresso, a ordem de avaliao depende das regras de precedncia.Python segue as mesmas regras de precedncia para seus operadores matemticos que a matemtica. O acrnimoPEMDAS uma maneira prtica de lembrar a ordem das operaes:

P: Parnteses tm a mais alta precedncia e podem ser usados para forar uma expresso a ser avaliadana ordem que voc quiser. J que expresses entre parnteses so avaliadas primeiro, 2 * (3-1) 4, e(1+1)**(5-2) 8. Voc tambm pode usar parnteses para tornar uma expresso mais fcil de ler, como em(minuto * 100) / 60, ainda que isso no altere o resultado.

E: Exponenciao ou potenciao tem a prxima precedncia mais alta, assim 2**1+1 3 e no 4, e 3*1**3 3 e no 27.

MDAS: Multiplicao e Diviso tm a mesma precedncia, que mais alta do que a da Adio e da Subtrao,que tambm tm a mesma precedncia. Assim 2*3-1 d 5 em vez de 4, e 2/3-1 -1, no 1 (lembre-se deque na diviso inteira, 2/3=0).

Operadores com a mesma precedncia so avaliados da esquerda para a direita. Assim, na expressominuto*100/60, a multiplicao acontece primeiro, resultando em 5900/60, o que se transforma pro-duzindo 98. Se as operaes tivessem sido avaliadas da direita para a esquerda, o resultado poderia ter sido59*1, que 59, que est errado.

4.8 2.8 Operaes com strings

De maneira geral, voc no pode executar operaes matemticas em strings, ainda que as strings se paream comnmeros. O que segue invlido (assumindo que mensagem do tipo string):

mensagem-1 "Al"/123 mensagem*"Al" "15"+2

Interessante o operador +, que funciona com strings, embora ele no faa exatamente o que voc poderia esperar.Para strings, o operador + representa concatenao, que significa juntar os dois operandos ligando-os pelos extremos.Por exemplo:

fruta = "banana"assada = " com canela"print (fruta + assada)

A sada deste programa banana com canela. O espao antes da palavra com parte da string e necessriopara produzir o espao entre as strings concatenadas.

O operador * tambm funciona com strings; ele realiza repetio. Por exemplo, "Legal"*3 "LegalLegaLegal". Um dos operadores tem que ser uma string; o outro tem que ser um inteiro.

Por um lado, esta interpretao de + e * faz sentido pela analogia entre adio e multiplicao. Assim como 4*3equivale a 4+4+4, no de estranhar que "Legal"*3 seja o mesmo que "Legal"+"Legal"+"Legal". Poroutro lado, uma diferena significativa separa concatenao e repetio de adio e multiplicao. Voc saberia men-cionar uma propriedade da adio e da multiplicao que no ocorre na concatenao e na repetio?

4.9 2.9 Composio

At agora, vimos os elementos de um programa (variveis, expresses, e instrues ou comandos) isoladamente, semmencionar como combin-los.



Uma das caractersticas mais prticas das linguagens de programao a possibilidade de pegar pequenos blocos ecombin-los numa composio. Por exemplo, ns sabemos como somar nmeros e sabemos como exibi-los; aconteceque podemos fazer as duas coisas ao mesmo tempo:

>>> print (17 + 3)20

Na realidade, a soma tem que acontecer antes da impresso, assim, as aes no esto na realidade acontecendo aomesmo tempo. O ponto que qualquer expresso envolvendo nmeros, strings, e variveis pode ser usada dentro deuma chamada da funo print. Voc j tinha visto um exemplo disto:

print ("Nmero de minutos desde a meia-noite: ", hora*60+minuto)

Esta possibilidade pode no parecer muito impressionante agora, mas voc ver outros exemplos em que a composiotorna possvel expressar clculos e tarefas complexas de modo limpo e conciso.

Ateno: Existem limites quanto ao lugar onde voc pode usar certos tipos de expresso. Por exemplo, o lado esquerdode um comando de atribuio tem que ser um nome de varivel, e no uma expresso. Assim, o seguinte no vlido:minuto+1 = hora.

4.10 2.11 Glossrio

atribuio (assignment) Comando que atribui um valor a uma varivel.

avaliar (evaluate) Simplificar uma expresso atravs da realizao de operaes, para produzir um valor nico.

comando (statement) Trecho de cdigo que representa uma instruo ou ao. At agora, os comandos vistos foramde atribuio e exibio.

comentrio (comment) Informao em um programa dirigida a outros programadores (ou qualquer pessoa que estejalendo o cdigo fonte) e que no tem efeito na execuo do programa.

composio (composition) Habilidade de combinar expresses e comandos simples em expresses e comandos com-postos, de forma a representar operaes complexas de forma concisa.

concatenar (concatenate) Juntar dois operandos lado a lado.

diagrama de estado (state diagram) Representao grfica de um conjunto de variveis e os valores aos quais elasse referem.

diviso inteira (integer division) Operao que divide um inteiro por outro e resulta em um inteiro. A diviso inteiraresulta no nmero de vezes que o numerador divisvel pelo denominador e descarta qualquer resto.

expresso (expression) Combinao de variveis, operadores e valores, que representa um resultado nico.

operando (operand) Um dos valores sobre o qual o operador opera.

operador (operator) Smbolo especial que representa uma computao simples, como adio, multiplicao ou con-catenao de strings.

palavra-chave (keyword) Palavra reservada usada pelo compilador/interpretador para analisar o programa; voc nopode usar palavras-chave como if, def, e while como nomes de variveis.

ponto-flutuante (floating-point) Formato para representar nmeros que possuem partes fracionrias.

regras de precedncia (rules of precedence) O conjunto de regras que governa a ordem em que expresses envol-vendo mltiplos operadores e operandos so avaliadas.

tipo (type) Um conjunto de valores. O tipo de um valor determina como ele pode ser usado em expresses. At agora,os tipos vistos so: inteiros (tipo int), nmeros em ponto-flutuante (tipo float) e strings (tipo string).

4.10. 2.11 Glossrio 23


valor (value) Um nmero ou string (ou outra coisa que ainda vamos conhecer) que pode ser atribuda a uma varivelou computada em uma expresso.

varivel (variable) Nome que se refere a um valor.


CAPTULO 5

Captulo 3: Funes

Tpicos

Captulo 3: Funes 3.1 Chamadas de funes 3.2 Converso entre tipos 3.3 Coero entre tipos 3.4 Funes matemticas 3.5 Composio 3.6 Adicionando novas funes 3.7 Definies e uso 3.8 Fluxo de execuo 3.9 Parmetros e argumentos 3.10 Variveis e parmetros so locais 3.11 Diagramas da pilha 3.12 Funes com resultados 3.13 Glossrio

5.1 3.1 Chamadas de funes

Voc j viu um exemplo de uma chamada de funo:

>>> type(32)

O nome da funo type e ela exibe o tipo de um valor ou varivel. O valor ou varivel, que chamado deargumento da funo, tem que vir entre parnteses. comum se dizer que uma funo recebe um valor ou maisvalores e retorna um resultado. O resultado chamado de valor de retorno.

Em vez de imprimir um valor de retorno, podemos atribui-lo a uma varivel:

>>> bia = type(32)>>> print (bia)

25


Como outro exemplo, a funo id recebe um valor ou uma varivel e retorna um inteiro, que atua como um identifi-cador nico para aquele valor:

>>> id(3)134882108>>> bia = 3>>> bia(beth)134882108

Todo valor tem um id, que um nmero nico relacionado ao local onde ele est guardado na memria do computador.O id de uma varivel o id do valor a qual ela se refere.

5.2 3.2 Converso entre tipos

Python prov uma coleo de funes nativas que convertem valores de um tipo em outro. A funo int recebe umvalor e o converte para inteiro, se possvel, ou, se no, reclama:

>>> int(32)32>>> int(Al)ValueError: invalid literal for int() : Al

int tambm pode converter valores em ponto flutuante para inteiro, mas lembre que isso trunca a parte fracionria:

>>> int(3.99999)3>>> int(-2.3)-2

A funo float converte inteiros e strings em nmeros em ponto flutuante:

>>> float(32)32.0>>> float(3.14159)3.14159

Finalmente, a funo str converte para o tipo string:

>>> str(32)32>>> str(3.14149)3.14149

Pode parecer curioso que Python faa distino entre o valor inteiro 1 e o valor em ponto flutuante 1.0. Eles podemrepresentar o mesmo nmero, mas pertencem a tipos diferentes. A razo que eles so representados de mododiferente dentro do computador.

5.3 3.3 Coero entre tipos

Agora que podemos converter entre tipos, temos outra maneira de lidar com a diviso inteira. Voltando ao exemplo docaptulo anterior, suponha que queiramos calcular a frao de hora que j passou. A expresso mais bvia, minuto/ 60, faz aritmtica inteira, assim, o resultado sempre 0, mesmo aos 59 minutos passados da hora.

26 Captulo 5. Captulo 3: Funes


Uma soluo converter minuto para ponto flutuante e fazer a diviso em ponto flutuante:

>>> minuto = 59>>> float(minuto) / 600.983333333333

Opcionalmente, podemos tirar vantagem das regras de converso automtica entre tipos, chamada de coero detipos. Para os operadores matemticos, se qualquer operando for um float, o outro automaticamente convertidopara float:

>>> minuto = 59>>> minuto / 60.00.983333333333

Fazendo o denominador um float, foramos o Python a fazer a diviso em ponto flutuante.

5.4 3.4 Funes matemticas

Em matemtica, voc provavelmente j viu funes como seno (sen, sin em ingls) e logaritmo (log), e apren-deu a resolver expresses como sen(pi/2) e log(1/x). Primeiro voc resolve e expresso entre parnteses (oargumento). Por exemplo, pi/2 aproximadamente 1,571, e 1/x 0.1 (se x for 10,0).

A voc avalia a funo propriamente dita, seja procurando numa tabela ou realizando vrios clculos. O sen de 1,571 1 e o log de 0,1 -1 (assumindo que log indica o logaritmo na base 10).

Este processo pode ser aplicado repetidamente para avaliar expresses mais complicadas, comolog(1/sen(pi/2)). Primeiro voc avalia o argumento na funo mais interna, depois avalia a funo eassim por diante.

Python tem um mdulo matemtico que prov a maioria das funes matemticas mais familiares. Um mdulo umarquivo que contm uma coleo de funes relacionadas agrupadas juntas.

Antes de podermos usar as funes contidas em um mdulo, temos de import-lo:

>>> import math

Para chamar uma das funes, temos que especificar o nome do mdulo e o nome da funo, separados por um ponto.Esse formato chamado de notao de ponto:

>>> decibel = math.log10(17.0)>>> angulo = 1.5>>> altura = math.sin(angulo)

A primeira instruo atribui a decibel o logaritmo de 17 na base 10. Existe tambm uma funo chamada log,usada para calcular o logaritmo em outra base ou o logaritmo natural de um nmero (base e).

A terceira instruo encontra o seno do valor da varivel angulo. sin e as outras funes trigonomtricas (cos,tan, etc.) recebem argumentos em radianos. Para converter de graus em radianos, divida por 360 e multiplique por2*pi. Por exemplo, para encontrar o seno de 45 graus, primeiro calcule o ngulo em radianos e depois ache o seno:

>>> graus = 45>>> angulo = graus * 2 * math.pi / 360.0>>> math.sin(angulo)0.707106781187

5.4. 3.4 Funes matemticas 27


A constante pi tambm parte do mdulo math. Se voc sabe geometria, pode checar o resultado anteriorcomparando-o com a raiz quadrada de dois dividido por dois:

>>> math.sqrt(2) / 2.00.707106781187

5.5 3.5 Composio

Do mesmo modo como nas funes matemticas, as funes do Python podem ser compostas, o que significa que vocpode usar uma expresso como parte de outra. Por exemplo, voc pode usar qualquer expresso como um argumentopara uma funo:

>>> x = math.cos(angulo + pi/2)

Esta instruo toma o valor de pi, divide-o por 2, e soma o resultado ao valor de angulo. A soma ento passadacomo um argumento para a funo cos.

Voc tambm pode pegar o resultado de uma funo e pass-lo como um argumento para outra:

>>> x = math.exp(math.log(10.0))

Esta instruo encontra o logaritmo natural (base e) de 10 e ento eleva e quela potncia. O resultado atribudo ax.

5.6 3.6 Adicionando novas funes

At aqui, temos utilizado somente as funes que vm com Python, mas tambm possvel adicionar novas funes.Criar novas funes para resolver seus prprios problemas uma das coisas mais teis de uma linguagem de progra-mao de propsito geral.

No contexto de programao, funo uma sequncia nomeada de instrues ou comandos, que realizam uma oper-ao desejada. Esta operao especificada numa definio de funo. At agora, as funes que usamos neste livroso pr-definidas e suas definies no foram apresentadas. Isso demonstra que podemos usar funes sem ter que nospreocupar com os detalhes de suas definies.

A sintaxe para uma definio de funo :

def NOME_DA_FUNCAO( LISTA DE PARAMETROS ) :COMANDOS

Voc pode usar o nome que quiser para as funes que criar, exceto as palavras reservadas do Python. A lista deparmetros especifica que informao, se houver alguma, voc tem que fornecer para poder usar a nova funo.

Uma funo pode ter quantos comandos forem necessrios, mas eles precisam ser endentados a partir da margemesquerda. Nos exemplos deste livro, usaremos uma endentao de dois espaos.

As primeiras funes que vamos mostrar no tero parmetros, ento, a sintaxe ter esta aparncia:

def novaLinha():print ()



Esta funo chamada de novaLinha. Os parnteses vazios indicam que ela no tem parmetros. Contm apenasum nico comando, que gera como sada um caractere de nova linha (isso o que acontece quando voc chama afuno print sem qualquer argumento).

A sintaxe para a chamada desta nova funo a mesma sintaxe para as funes nativas:

print (Primeira Linha.)novaLinha()print (Segunda Linha.)

A sada deste programa :

Primeira Linha.

Segunda Linha.

Observe o espao extra entre as duas linhas. E se quisssemos mais espao entre as linhas? Poderamos chamar amesma funo repetidamente:

print (Primeira Linha.)novaLinha()novaLinha()novaLinha()print (Segunda Linha.)

Ou poderamos escrever uma nova funo chamada tresLinhas, que produzisse trs novas linhas:

def tresLinhas() :novaLinha()novaLinha()novaLinha()

print (Primeira Linha.)tresLinhas()print (Segunda Linha.)

Esta funo contm trs comandos, todos com recuo de quatro espaos a partir da margem esquerda. J que o prximocomando no est endentado, Python reconhece que ele no faz parte da funo.

Algumas coisas que devem ser observadas sobre este programa:

1. Voc pode chamar o mesmo procedimento repetidamente. Isso muito comum, alm de til.

2. Voc pode ter uma funo chamando outra funo; neste caso tresLinhas chama novaLinha.

Pode no estar claro, at agora, de que vale o esforo de criar novas funes - existem vrias razes, mas este exemplodemonstra duas delas:

Criar uma nova funo permite que voc coloque nome em um grupo de comandos. As funes podem simpli-ficar um programa ao ocultar a execuo de uma tarefa complexa por trs de um simples comando cujo nomepode ser uma palavra em portugus, em vez de algum cdigo misterioso.

Criar uma nova funo pode tornar o programa menor, por eliminar cdigo repetido. Por exemplo, um atalhopara imprimir nove novas linhas consecutivas chamar tresLinhas trs vezes.

Como exerccio, escreva uma funo chamada noveLinhas que use tresLinhas para imprimirnove linhas em branco. Como voc poderia imprimir vinte e sete novas linhas?

5.6. 3.6 Adicionando novas funes 29


5.7 3.7 Definies e uso

Reunindo os fragmentos de cdigo da Seo 3.6, o programa completo fica assim:

def novaLinha() :print ()

def tresLinhas() :novaLinha()novaLinha()novaLinha()

print (Primeira Linha.)tresLinhas()print (Segunda Linha.)

Esse programa contm duas definies de funes: novaLinha e tresLinhas. Definies de funes so exe-cutadas como quaisquer outros comandos, mas o efeito criar a nova funo. Os comandos dentro da definio dafuno no so executados at que a funo seja chamada, logo, a definio da funo no gera nenhuma sada.

Como voc j deve ter imaginado, preciso criar uma funo antes de poder execut-la. Em outras palavras, a definioda funo tem que ser executada antes que ela seja chamada pela primeira vez.

Como exerccio, mova as ltimas trs linhas deste programa para o topo, de modo que a chamada dafuno aparea antes das definies. Rode o programa e veja que mensagem de erro voc ter.

Tambm a ttulo de exerccio, comece com a verso que funciona do programa e mova a definio denovaLinha para depois da definio de tresLinhas. O que acontece quando voc roda este pro-grama?

5.8 3.8 Fluxo de execuo

Para assegurar que uma funo esteja definida antes do seu primeiro uso, preciso saber em que ordem os comandosso executados, ou seja, descobrir qual o fluxo de execuo do programa.

A execuo sempre comea com o primeiro comando do programa. Os comandos so executados um de cada vez,pela ordem, de cima para baixo.

As definies de funo no alteram o fluxo de execuo do programa, mas lembre-se que comandos dentro da funono so executados at a funo ser chamada. Embora no seja comum, voc pode definir uma funo dentro de outra.Neste caso, a definio mais interna no executada at que a funo mais externa seja chamada.

Chamadas de funo so como um desvio no fluxo de execuo. Em vez de ir para o prximo comando, o fluxo saltapara a primeira linha da funo chamada, executa todos os comandos l e ento volta atrs para retomar de onde haviadeixado.

Parece muito simples, at a hora em que voc lembra que uma funo pode chamar outra. Enquanto estiver no meiode uma funo, o programa poderia ter de executar os comandos em uma outra funo. Mas enquanto estivesseexecutando esta nova funo, o programa poderia ter de executar ainda outra funo!

Felizmente, Python adepto de monitorar a posio onde est, assim, cada vez que uma funo se completa, oprograma retoma de onde tinha parado na funo que a chamou. Quando chega ao fim do programa, ele termina.

Qual a moral dessa histria srdida? Quando voc for ler um programa, no o leia de cima para baixo. Em vez disso,siga o fluxo de execuo.



5.9 3.9 Parmetros e argumentos

Algumas das funes nativas que voc j usou requerem argumentos, aqueles valores que controlam como a funofaz seu trabalho. Por exemplo, se voc quer achar o seno de um nmero, voc tem que indicar qual nmero . Destemodo, sin recebe um valor numrico como um argumento.

Algumas funes recebem mais de um argumento. Por exemplo, pow recebe dois argumentos, a base e o expoente.Dentro da funo, os valores que lhe so passados so atribudos a variveis chamadas parmetros.

Veja um exemplo de uma funo definida pelo usurio, que recebe um parmetro:

def imprimeDobrado(bruno):print (bruno, bruno)

Esta funo recebe um nico argumento e o atribui a um parmetro chamado bruno. O valor do parmetro (a essaaltura, no sabemos qual ser) impresso duas vezes, seguido de uma nova linha. Estamos usando bruno paramostrar que o nome do parmetro deciso sua, mas claro que melhor escolher um nome que seja mais ilustrativo.

A funo imprimeDobrado funciona para qualquer tipo que possa ser impresso:

>>> imprimeDoobrado(Spam)Spam Spam>>> imprimeDobrado(5)5 5>>> imprimeDobrado(3.14159)3.14159 3.14159

Na primeira chamada da funo, o argumento uma string. Na segunda, um inteiro. Na terceira um float.

As mesmas regras de composio que se aplicam a funes nativas tambm se aplicam s funes definidas pelousurio, assim, podemos usar qualquer tipo de expresso como um argumento para imprimeDobrado:

>>> imprimeDobrado(Spam*4)SpamSpamSpamSpam SpamSpamSpamSpam>>> imprimeDobrado(math.cos(math.pi))-1.0 -1.0

Como acontece normalmente, a expresso avaliada antes da execuo da funo, assim imprimeDobrado imprimeSpamSpamSpamSpam SpamSpamSpamSpam em vez de Spam*4 Spam*4.

Como exerccio, escreva um chamada a imprimeDobrado que imprima Spam*4 Spam*4.Dica: strings podem ser colocadas tanto entre aspas simples quanto duplas e o tipo de aspas que nofor usado para envolver a string pode ser usado dentro da string, como parte dela.

Tambm podemos usar uma varivel como argumento:

>>> miguel = Eric, the half a bee.>>> imprimeDobrado(miguel)Eric, the half a bee. Eric, the half a bee.

N.T.: Eric, the half a bee uma msica do grupo humorstico britnico Monty Python. A linguagem Python foibatizada em homenagem ao grupo e, por isso, os programadores gostam de citar piadas deles em seus exemplos.

Repare numa coisa importante: o nome da varivel que passamos como um argumento (miguel) no tem nada a vercom o nome do parmetro (bruno). No importa de que modo o valor foi chamado de onde veio (do chamador);aqui, em imprimeDobrado, chamamos a todo mundo de bruno.

5.9. 3.9 Parmetros e argumentos 31


5.10 3.10 Variveis e parmetros so locais

Quando voc cria uma varivel local dentro de uma funo, ela s existe dentro da funo e voc no pode us-la forade l. Por exemplo:

def concatDupla(parte1, parte2)concat = parte1 + parte2imprimeDobrado(concat)

Esta funo recebe dois argumentos, concatena-os, e ento imprime o resultado duas vezes. Podemos chamar a funocom duas strings:

>>> canto1 = Pie Jesu domine, >>> canto2 = dona eis requiem. >>> concatDupla(canto1, canto2)Pie Jesu domine, Dona eis requiem. Pie Jesu domine, Dona eis requiem.

Quando a funo concatDupla termina, a varivel concat destruda. Se tentarmos imprimi-la, teremos um erro:

>>> print (concat)NameError: concat

Parmetros so sempre locais. Por exemplo, fora da funo imprimeDobrado, no existe nada que se chamabruno. Se voc tentar utiliz-la, o P

Documents

Aprenda Computação com Python 3.0.pdf