PHYTON - APRENDA E SIMPLIFIQUE, Exercícios de Programação Funcional

Baixe PHYTON - APRENDA E SIMPLIFIQUE e outras Exercícios em PDF para Programação Funcional, somente na Docsity!

Aprenda Computação com Python 3.

Versão 1

Allen Downey, Jeff Elkner and Chris Meyers

• 1 Prefácio
  • 1.1 Como e porque eu vim a usar Python
  • 1.2 Encontrando um livro-texto
  • 1.3 Introduzindo programação com Python
  • 1.4 Construindo uma comunidade
• 2 Apresentação
• 3 Capítulo 1: O caminho do programa
  • 3.1 1.1 A linguagem de programação Python
  • 3.2 1.2 O que é um programa?
  • 3.3 1.3 O que é depuração (debugging)?
  • 3.4 1.4 Linguagens naturais e linguagens formais
  • 3.5 1.5 O primeiro programa
  • 3.6 1.6 Glossário
• 4 Capítulo 2: Variáveis, expressões e comandos
  • 4.1 2.1 Valores e tipos
  • 4.2 2.2 Variáveis
  • 4.3 2.3 Nomes de variáveis e palavras reservadas
  • 4.4 2.4 Comandos
  • 4.5 2.5 Avaliando expressões
  • 4.6 2.6 Operadores e operandos
  • 4.7 2.7 Ordem dos operadores
  • 4.8 2.8 Operações com strings
  • 4.9 2.9 Composição
  • 4.10 2.11 Glossário
• 5 Capítulo 3: Funções
  • 5.1 3.1 Chamadas de funções
  • 5.2 3.2 Conversão entre tipos
  • 5.3 3.3 Coerção entre tipos
  • 5.4 3.4 Funções matemáticas
  • 5.5 3.5 Composição
  • 5.6 3.6 Adicionando novas funções
  • 5.7 3.7 Definições e uso
  • 5.8 3.8 Fluxo de execução
  • 5.9 3.9 Parâmetros e argumentos
  • 5.10 3.10 Variáveis e parâmetros são locais
  • 5.11 3.11 Diagramas da pilha
  • 5.12 3.12 Funções com resultados
  • 5.13 3.13 Glossário
• 6 Capítulo 4: Condicionais e recursividade
  • 6.1 4.1 O operador módulo
  • 6.2 4.2 Expressões booleanas
  • 6.3 4.3 Operadores lógicos
  • 6.4 4.4 Execução condicional
  • 6.5 4.5 Execução alternativa
  • 6.6 4.6 Condicionais encadeados
  • 6.7 4.7 Condicionais aninhados
  • 6.8 4.8 A instrução return
  • 6.9 4.9 Recursividade
  • 6.10 4.10 Diagramas de pilha para funções recursivas
  • 6.11 4.11 Recursividade infinita
  • 6.12 4.12 Entrada pelo teclado
  • 6.13 4.13 Glossário
• 7 Capítulo 5: Funções frutíferas
  • 7.1 5.1 Valores de retorno
  • 7.2 5.2 Desenvolvimento de programas
  • 7.3 5.3 Composição
  • 7.4 5.4 Funções booleanas
  • 7.5 5.5 Mais recursividade
  • 7.6 5.6 Voto de confiança (Leap of faith)
  • 7.7 5.7 Mais um exemplo
  • 7.8 5.8 Checagem de tipos
  • 7.9 5.9 Glossário
• 8 Capítulo 6: Iteração
  • 8.1 6.1 Reatribuições
  • 8.2 6.2 O comando while
  • 8.3 6.3 Tabelas
  • 8.4 6.4 Tabelas de duas dimensões (ou bi-dimensionais)
  • 8.5 6.5 Encapsulamento e generalização
  • 8.6 6.6 Mais encapsulamento
  • 8.7 6.7 Variáveis locais
  • 8.8 6.8 Mais generalização
  • 8.9 6.9 Funções
  • 8.10 6.10 Glossário
• 9 Capítulo 7: Strings
  • 9.1 7.1 Um tipo de dado composto
  • 9.2 7.2 Comprimento
  • 9.3 7.3 Travessia e o loop for
  • 9.4 7.4 Fatias de strings
  • 9.5 7.5 Comparação de strings
  • 9.6 7.6 Strings são imutáveis
  • 9.7 7.7 Uma função find (encontrar)
  • 9.8 7.8 Iterando e contando
  • 9.9 7.9 O módulo string
  • 9.10 7.10 Classificação de caracteres
  • 9.11 7.11 Glossário
• 10 Capítulo 8: Listas
  • 10.1 8.1 Valores da lista
  • 10.2 8.2 Acessado elementos
  • 10.3 8.3 Comprimento da lista
  • 10.4 8.4 Membros de uma lista
  • 10.5 8.5 Listas e laços for
  • 10.6 8.6 Operações em listas
  • 10.7 8.7 Fatiamento de listas
  • 10.8 8.8 Listas são mutáveis
  • 10.9 8.9 Remoção em lista
  • 10.10 8.10 Ojetos e valores
  • 10.11 8.11 Apelidos
  • 10.12 8.12 Clonando listas
  • 10.13 8.13 Lista como parâmetro
  • 10.14 8.14 Lista aninhadas
  • 10.15 8.15 Matrizes
  • 10.16 8.16 Strings e listas
  • 10.17 8.17 Glossário
  • 10.18 Outros termos utilizados neste capítulo
• 11 Capítulo 9: Tuplas
  • 11.1 9.1 Mutabilidade e tuplas
  • 11.2 9.2 Atribuições de tupla
  • 11.3 9.3 Tuplas como valores de retorno
  • 11.4 9.4 Números aleatórios
  • 11.5 9.5 Lista de números aleatórios
  • 11.6 9.6 Contando
  • 11.7 9.7 Vários intervalos
  • 11.8 9.8 Uma solução em um só passo
  • 11.9 9.9 Glossário
• 12 Capítulo 10: Dicionários
  • 12.1 10.1 Operações dos Dicionários
  • 12.2 10.2 Métodos dos Dicionários
  • 12.3 10.3 Aliasing (XXX) e Copiar
  • 12.4 10.4 Matrizes Esparsas
  • 12.5 10.5 Hint XXX
  • 12.6 10.6 Inteiros Longos
  • 12.7 10.7 Contando Letras
  • 12.8 10.8 Glossário
• 13 Capítulo 11: Arquivos e exceções
  • 13.1 Arquivos e exceções
  • 13.2 11.1 Arquivos texto
  • 13.3 11.2 Gravando variáveis
  • 13.4 11.3 Diretórios
  • 13.5 11.4 Pickling
  • 13.6 11.5 Exceções
  • 13.7 11.6 Glossário
• 14 Capítulo 12: Classes e objetos
  • 14.1 12.1 Tipos compostos definidos pelo usuário
  • 14.2 12.2 Atributos
  • 14.3 12.3 Instâncias como parâmetros
  • 14.4 12.4 O significado de “mesmo”
  • 14.5 12.5 Retângulos
  • 14.6 12.6 Instancias como valores retornados
  • 14.7 12.7 Objetos são mutáveis
  • 14.8 12.8 Copiando
  • 14.9 12.9 Glossário
• 15 Capítulo 13: Classes e funções
  • 15.1 13.1 Horario
  • 15.2 13.2 Funções Puras
  • 15.3 13.3 Modificadores
  • 15.4 13.4 O que é melhor?
  • 15.5 13.5 Desenvolvimento Prototipado versus Desenvolvimento Planejamento
  • 15.6 13.6 Generalização
  • 15.7 13.7 Algoritmos
  • 15.8 13.8 Glossário
• 16 Capítulo 14: Classes e métodos
  • 16.1 14.1 Características da orientação a objetos
  • 16.2 14.2 exibeHora (printTime)
  • 16.3 14.3 Um outro exemplo
  • 16.4 14.4 Um exemplo mais complicado
  • 16.5 14.10 Glossário
• 17 Capítulo 15: Conjuntos de objetos
  • 17.1 15.1 Composição
  • 17.2 15.2 Objetos Carta
  • 17.3 15.3 Atributos de classe e o método str
  • 17.4 15.4 Comparando cartas
  • 17.5 15.5 Baralhos
  • 17.6 15.6 Imprimindo o baralho
  • 17.7 15.7 Embaralhando
  • 17.8 15.8 Removendo e distribuindo cartas
  • 17.9 15.9 Glossário
• 18 Capitulo 16: Herança
  • 18.1 16.1 Herança
  • 18.2 16.2 Uma mão de cartas
  • 18.3 16.3 Dando as cartas
  • 18.4 16.4 Exibindo a mao
  • 18.5 16.5 A classe JogoDeCartas
  • 18.6 16.6 Classe MaoDeMico
  • 18.7 16.7 Classe Mico
  • 18.8 16.8 Glossário
• 19 Capítulo 17: Listas encadeadas
  • 19.1 17.1 Referências Embutidas
  • 19.2 17.2 A classe No (Node)
  • 19.3 17.3 Listas como Coleções
  • 19.4 17.4 Listas e Recorrência
  • 19.5 17.5 Listas Infinitas
  • 19.6 17.6 O Teorema da Ambigüidade Fundamental
  • 19.7 17.7 Modificando Listas
  • 19.8 17.8 Envoltórios e Ajudadores
  • 19.9 17.9 A Classe ListaLigada
  • 19.10 17.10 Invariantes
  • 19.11 17.11 Glossário
• 20 Capítulo 18: Pilhas
  • 20.1 18.1 Tipos abstratos de dados
  • 20.2 18.2 O TAD Pilha
  • 20.3 18.3 Implementando pilhas com listas de Python
  • 20.4 18.4 Empilhando e desempilhando
  • 20.5 18.5 Usando uma pilha para avaliar expressões pós-fixas
  • 20.6 18.6 Análise sintática
  • 20.7 18.7 Avaliando em pós-fixo.
• 21 Capítulo 19: Filas
  • 21.1 19.1 Um TDA Fila
  • 21.2 19.2 Fila encadeada
  • 21.3 19.3 Características de performance
  • 21.4 19.4 Fila encadeada aprimorada
  • 21.5 19.5 Fila por prioridade
  • 21.6 19.6 A classe Golfer
  • 21.7 19.7 Glossário
• 22 Capítulo 20: Árvores
  • 22.1 20.1 Construindo árvores
  • 22.2 20.2 Percorrendo árvores
  • 22.3 20.3 Árvores de expressões
  • 22.4 20.4 Percurso de árvores
  • 22.5 20.5 Construindo uma árvore de expressão
  • 22.6 20.6 Manipulando erros
  • 22.7 20.7 A árvore dos animais
  • 22.8 20.8 Glossário
• 23 Apêndice A: Depuração
  • 23.1 A.1 Erros de sintaxe
  • 23.2 A.2 Erros de tempo de execução
  • 23.3 A.3 Erros de semântica
• 24 Apêndice B: Criando um novo tipo de dado
  • 24.1 B.1 Multiplicação de frações
  • 24.2 B.2 Soma de frações
  • 24.3 B.3 Simplificando frações: O algoritmo de Euclides
  • 24.4 B.4 Comparando frações
  • 24.5 B.5 Indo mais além...
  • 24.6 B.6 Glossário
• 25 Apêndice C: Leituras recomendadas
  • 25.1 C.1 Recomendações para leitura
  • 25.2 C.2 Sites e livros sobre Python
  • 25.3 C.3 Livros de ciência da computação recomendados
• 26 Apêndice D: GNU Free Documentation License

27 Indices and tables 201

vi

Aprenda Computação com Python 3.0, Versão 1

2 Conteúdo

CAPÍTULO 1

Prefácio

Por Jeff Elkner

Este livro deve sua existência à colaboração possibilitada pela Internet e pelo movimento do software livre. Seus três autores – um professor universitário, um professor secundarista e um programador profissional – ainda não se encontraram pessoalmente, mas temos sido capazes de trabalhar em estreita colaboração e temos sido ajudados por muitos colegas maravilhosos que têm dedicado seu tempo e energia para ajudar a fazer deste um livro cada vez melhor.

Achamos que este livro é um testemunho dos benefícios e possibilidades futuras deste tipo de colaboração, cujo modelo tem sido posto em prática por Richard Stallman e pela Free Software Foundation.

1.1 Como e porque eu vim a usar Python

Em 1999, o Exame de Colocação Avançada em Ciência da Computação da Comissão de Faculdades (College Board’s Advanced Placement (AP) Computer Science XXX) foi aplicado em C++ pela primeira vez. Como em muitas escolas secundárias através do país, a decisão de mudar linguagens teve um impacto direto no currículo de ciência da com- putação na Yorktown High School em Arlington, Virginia, onde leciono. Até então, Pascal era a linguagem didática para nossos cursos de primeiro ano e avançado. Mantendo a prática corrente de dar aos estudantes dois anos de ex- posição à mesma linguagem, tomamos a decisão de mudar para C++ no curso de primeiro ano para o ano letivo de 1997-98 de modo que estaríamos em sincronismo com a mudança da Comissão de Faculdades (College Board’s XXX) em relação ao curso avançado (AP XXX) para o ano seguinte.

Dois anos depois, eu estava convencido que C++ foi uma escolha infeliz para introduzir os alunos em ciência da computação. Ao mesmo tempo em que é certamente uma linguagem de programação muito poderosa, também é uma linguagem extremamente difícil de aprender e de ensinar. Eu me encontrava constantemente lutando com a sintaxe difícil de C++ e as múltiplas maneiras de fazer a mesma coisa, e estava, como resultado, perdendo muitos alunos desnecessariamente. 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 máquinas em nosso laboratório Linux bem como nas platafor- mas Windows e Macintosh que a maioria dos alunos tinha em casa. Eu precisava que ela fosse gratuita e disponível eletronicamente, assim os alunos poderiam utilizá-la em casa independentemente de suas rendas. Eu queria uma linguagem que fosse utilizada por programadores profissionais, e que tivesse uma comunidade de desenvolvimento ativa em torno dela. Ela teria que suportar ambas, programação procedural e orientada a objetos. E, mais importante, deveria ser fácil de aprender e de ensinar. Quando considerei as alternativas tendo em mente aquelas metas, Python sobressaiu-se como a melhor candidata para a tarefa.

Aprenda Computação com Python 3.0, Versão 1

#include <iostream.h>

void main() { cout << "Alô, mundo." << endl; }

Na versão Python, ele se transforma em:

print ("Alô, Mundo!")

Mesmo sendo um exemplo trivial, as vantagens do Python saltam aos olhos. O curso de Ciência da Computação I que ministro em Yorktown não tem pré-requisitos, assim, muitos dos alunos que veem esse exemplo estão olhando para o seu primeiro programa. Alguns deles estão indubitavelmente nervosos, por já terem ouvido falar que programação de computadores é difícil de aprender. A versão C++ tem sempre me forçado a escolher entre duas opções insatisfatórias: ou explicar os comandos #include, void main(), {, e } e arriscar confundir ou intimidar alguns dos alunos logo assim que iniciam, ou dizer a eles “Não se preocupem com todas estas coisas agora; falaremos sobre elas mais tarde,” e correr o mesmo risco. O objetivo educacional neste ponto do curso é introduzir os alunos à idéia de comando em programação e vê-los escrever seu primeiro programa, deste modo introduzindo-os ao ambiente de programação. O programa em Python tem exatamente o que é necessário para conseguir isto, e nada mais.

Comparar o texto explicativo do programa em cada versão do livro ilustra ainda mais o que significa para o aluno iniciante. Existem treze parágrafos de explicação do “Alô, mundo!” na versão C++; na versão Python existem apenas dois. Mais importante, os onze parágrafos perdidos não se ocupam das “idéias chave” da programação de computa- dores, mas com a minúcia da sintaxe C++. Vejo a mesma coisa acontecendo através de todo o livro. Parágrafos inteiros simplesmente desaparecem da versão Python do texto porque a sintaxe muito mais clara de Python os torna desnecessários.

Utilizar uma linguagem de tão alto nível como Python, permite ao professor deixar para falar mais tarde sobre os níveis mais baixos, próximos à máquina, quando os alunos já terão a experiência necessária para ver com mais sentido os detalhes. Desta maneira podemos pedagogicamente “por em primeiro lugar as primeiras coisas”. Um dos melhores exemplos disto é a maneira com que Python lida com variáveis. Em C++ uma variável é um nome para um lugar que guarda uma coisa. Variáveis têm de ser declaradas com seu tipo pelo menos em parte por que o tamanho do lugar a que se referem precisa ser predeterminado. Assim, a idéia de variável fica amarrada ao hardware da máquina. O conceito poderoso e fundamental de variável já é bastante difícil para o aluno iniciante (tanto em ciência da computação quanto em álgebra). Bytes e endereços não ajudam neste caso. Em Python uma variável é um nome que se refere a uma coisa. Este é um conceito muito mais intuitivo para alunos iniciantes e está muito mais próximo do significado de “variável” que eles aprenderam em seus cursos de matemática. Eu tive muito menos dificuldade em ensinar variáveis este ano do que tive no passado, e gastei menos tempo ajudando aos alunos com problemas no uso delas.

Um outro exemplo de como Python ajuda no ensino e aprendizagem de programação é em sua sintaxe para função. Meus alunos têm sempre tido grande dificuldade na compreensão de funções. O problema principal gira em torno da diferença entre a definição de uma função e a chamada de uma função, e a distinção relacionada entre um parâmetro e um argumento. Python vem em auxílio com uma sintaxe não apenas curta quanto bela. As definições de função começam com def, então eu simplesmente digo aos meus alunos “Quando você define uma função, comece com def, seguido do nome da função que você está definindo; quando você chama uma função, simplesmente chame-a digitando o nome dela”. Parâmetros ficam nas definições; argumentos vão com as chamadas. Não existem tipos de retorno, tipos de parâmetro ou passagem de parâmetros por valor ou por referência no meio do caminho, permitindo- me ensinar funções em menos da metade do tempo que isto me tomava anteriormente, com uma melhor compreensão.

A utilização do Python tem melhorado a efetividade de nosso programa em ciência da computação para todos os estudantes. Eu vejo um nível geral de sucesso muito mais alto e um nível mais baixo de frustração do que experimentei durante os dois anos em que ensinei C++. Eu avanço mais rápido com melhores resultados. Mais alunos deixam o curso com a habilidade de criar programas significativos e com uma atitude positiva em relação a experiência de programação que isso traz.

1.3. Introduzindo programação com Python 5

Aprenda Computação com Python 3.0, Versão 1

1.4 Construindo uma comunidade

Tenho recebido e-mails de todo o planeta de pessoas utilizando este livro para aprender ou ensinar programação. Uma comunidade de usuários tem começado a emergir e muitas pessoas têm contribuído com o projeto enviando seus materiais para o Website cooperativo em:

http://www.thinkpython.com

Com a publicação do livro em formato impresso, minha expectativa quanto ao crescimento da comunidade de usuários é que ela seja contínua e acelerada. O surgimento desta comunidade de usuários e a possibilidade que sugere de colaboração semelhante entre educadores tem sido para mim a parte mais excitante do trabalho neste projeto. Tra- balhando juntos, podemos aumentar a qualidade do material disponível para o nosso uso e poupar tempo valioso. Eu convido você a se juntar a nossa comunidade e espero ouvir algo de você. Por favor, escreva para os autores em [email protected].

Jeffrey Elkner

Yorktown High School

Arlington, Virginia

6 Capítulo 1. Prefácio

Aprenda Computação com Python 3.0, Versão 1

Python ainda toma emprestado certas características de linguagens de programação funcionais e pode ser usado para introduzir conceitos cujos detalhes poderiam ser aprofundados em cursos de Scheme e Lisp.

Lendo o prefácio de Jeffrey, fiquei impressionado com seu comentário de que Python o fez ver um “maior nível de sucesso e um menor nível de frustração” o que lhe permitiu “progredir mais depressa com resultados melhores”. Em- bora estes comentários refiram-se aos seus cursos introdutórios, eu às vezes uso Python exatamente pelas mesmas razões em cursos avançados de pós-graduação (graduate = pos-graduacao XXX) em ciência da computação na Uni- versidade de Chicago. Nestes cursos, enfrento constantemente a assustadora tarefa de cobrir muitos tópicos difíceis em um rapidíssimo trimestre (quarter XXX) de nove semanas. Embora me seja possível inflingir um bocado de dor e sofrimento pelo uso de uma linguagem como C++, tenho percebido muitas vezes que este enfoque é contraproducente, especialmente quando o curso é sobre um tópico não relacionado apenas com “programar”. Acho que usar Python me permite um melhor foco no tópico em questão, enquanto permite que os alunos completem projetos substanciais em classe.

Embora Python seja ainda uma linguagem jovem e em evolução, acredito que tem um futuro brilhante em educação. Este livro é um passo importante nessa direção.

David Beazley

Universidade de Chicago

Autor de Python Essencial Reference

8 Capítulo 2. Apresentação

CAPÍTULO 3

Capítulo 1: O caminho do programa

Tópicos

• Capítulo 1: O caminho do programa
  • 1.1 A linguagem de programação Python
  • 1.2 O que é um programa?
  • 1.3 O que é depuração (debugging)?
    • 1.3.1 Erros de sintaxe
    • 1.3.2 Erros em tempo de execução (runtime errors)
    • 1.3.3 Erros de semântica (ou de lógica)
    • 1.3.4 Depuração experimental (debugging)
  • 1.4 Linguagens naturais e linguagens formais
  • 1.5 O primeiro programa
  • 1.6 Glossário

O objetivo deste livro é ensinar o leitor a pensar como um cientista da computação. Essa maneira de pensar combina algumas das melhores características da matemática, da engenharia e das ciências naturais. Como os matemáticos, os cientistas da computação usam linguagens formais para representar ideias (especificamente, computações). Como os engenheiros, 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 hipóteses e testam previsões.

A habilidade mais importante de um cientista da computação é a solução de problemas. Solução de problemas é a habilidade de formular questões, pensar criativamente sobre soluções possíveis e expressar uma solução de forma clara e precisa. Ocorre que aprender a programar é uma excelente oportunidade de praticar a habilidade da solução de problemas. É por isso que este capítulo se chama “O caminho do programa”.

Em certo nível, você estará aprendendo a programar, habilidade que é útil em si mesma. Em outro nível, você usará a programação como um meio para atingir um objetivo. À medida que você for avançando na leitura, esse objetivo ficará mais claro.

3.1 1.1 A linguagem de programação Python

Python é a linguagem de programação que você vai estudar neste livro. Python é um exemplo de linguagem de programação de alto nível. Outras linguagens de alto nível de que você já pode ter ouvido falar são C++, PHP e Java.

Aprenda Computação com Python 3.0, Versão 1

Um arquivo como este é chamado de script. Por exemplo, usamos um editor de texto para criar um arquivo chamado leticia.py com o seguinte conteúdo:

print (1 + 1)

Por convenção, arquivos que contenham programas em Python têm nomes que terminam com .py.

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

$ python leticia.py 2

Em outros ambientes de desenvolvimento, os detalhes da execução de programas podem ser diferentes. Além disso, a maioria dos programas são mais interessantes do que esse.

A maioria dos exemplos neste livro são 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á-los imediatamente. Uma vez que você tem um programa que funciona, deve guardá-lo em um script, de forma a poder executá-lo ou modificá-lo no futuro.

3.2 1.2 O que é um programa?

Um programa é uma sequência de instruções que especificam como executar um cálculo ou determinada tarefa. Tal tarefa pode matemática, como solucionar um sistema de equações ou encontrar as raízes de um polinômio, mas também pode ser simbólica, como buscar e substituir uma palavra em um documento ou (estranhamente) compilar um programa.

Os detalhes são diferentes em diferentes linguagens, mas algumas instruções básicas aparecem em praticamente todas as 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 saída.

calcular: Executar operações matemáticas básicas, como adição e multiplicação.

executar condicionalmente: Checar certas condições e executar a sequência apropriada de instruções.

repetir: Executar alguma ação repetidamente, normalmente com alguma variação.

Acredite se quiser: isso é praticamente tudo. Todos os programas que você já usou, não importa quão complicados, são feitos de instruções mais ou menos parecidas com essas. Assim, poderíamos definir programação como o processo de dividir uma tarefa grande e complexa em subtarefas cada vez menores, até que as subtarefas sejam simples o suficiente para serem executadas com uma dessas instruções básicas.

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

3.3 1.3 O que é depuração (debugging)?

Programar é um processo complicado e, como é feito por seres humanos, frequentemente conduz a erros. Por mero capricho, erros em programas são chamados de bugs e o processo de encontrá-los e corrigi-los é chamado de depu- ração (debugging).

Três tipos de erro podem acontecer em um programa: erros de sintaxe, erros em tempo de execução (runtime errors) e erros de semântica (também chamados de erros de lógica). Distinguir os três tipos ajuda a localizá-los mais rápido:

3.2. 1.2 O que é um programa? 11

Aprenda Computação com Python 3.0, Versão 1

3.3.1 1.3.1 Erros de sintaxe

O interpretador do Python só executa um programa se ele estiver sintaticamente correto; caso contrário, o processo falha e retorna uma mensagem de erro. Sintaxe se refere à estrutura de um programa e às regras sobre esta estrutura. Por exemplo, em português, uma frase deve começar com uma letra maiúscula e terminar com um ponto.

esta frase contém um erro de sintaxe. Assim como esta

Para a maioria dos leitores, uns errinhos de sintaxe não chegam a ser um problema significativo e é por isso que conseguimos ler a poesia moderna de e. e. cummings sem cuspir mensagens de erro. Python não é tão indulgente. Se o seu programa tiver um único erro de sintaxe em algum lugar, o interpretador Python vai exibir uma mensagem de erro e vai terminar - e o programa não 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 experiência, entretanto, cometerá menos erros e os localizará mais rápido.

3.3.2 1.3.2 Erros em tempo de execução (runtime errors)

O segundo tipo de erro é o erro de runtime, ou erro em tempo de execução, assim chamado porque só aparece quando você roda o programa. Esses erros são também conhecidos como exceções, porque normalmente indicam que alguma coisa excepcional (e ruim) aconteceu.

Erros de runtime são raros nos programas simples que você vai ver nos primeiros capítulos - então, vai demorar um pouco até você se deparar com um erro desse tipo.

3.3.3 1.3.3 Erros de semântica (ou de lógica)

O terceiro tipo de erro é o erro de semântica (mais comumente chamado erro de lógica). Mesmo que o seu programa tenha um erro de semântica, ele vai rodar com sucesso, no sentido de que o computador não vai gerar nenhuma mensagem de erro. Só que o programa não 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 não é aquele que você queria escrever. O significado do programa (sua semântica ou lógica) está errado. Identificar erros semânticos pode ser complicado, porque requer que você trabalhe de trás para frente, olhando a saída do programa e tentando imaginar o que ele está fazendo.

3.3.4 1.3.4 Depuração 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 programação.

De certa maneira, a depuração é como um trabalho de detetive. Você se depara com pistas, e tem que deduzir os processos e eventos que levaram aos resultados que aparecem.

Depurar também é como uma ciência experimental. Uma vez que você tem uma ideia do que está errado, você modifica o seu programa e tenta de novo. Se a sua hipótese estava correta, então você consegue prever o resultado da modificação e fica um passo mais perto de um programa que funciona. Se a sua hipótese estava errada, você tem que tentar uma nova. Como Sherlock Holmes mostrou: “Quando você tiver eliminado o impossível, aquilo que restou, ainda que improvável, deve ser a verdade.” (Arthur Conan Doyle, O signo dos quatro).

Para algumas pessoas, programação e depuração são a mesma coisa. Ou seja, programar é o processo de gradualmente depurar um programa, até que ele faça o que você quer. A ideia é começar com um programa que faça alguma coisa e ir fazendo pequenas modificações, depurando-as conforme avança, de modo que você tenha sempre um programa que funciona.

12 Capítulo 3. Capítulo 1: O caminho do programa