Fundamentos de Python: Primeiros programas - Tradução da 2ª edição norte-americana by Cengage Brasil

FUNDAMENTOS DE PYTHON: PRIMEIROS PROGRAMAS

KENNETH A. LAMBERT MARTIN OSBORNE, AUTOR COLABORADOR

Fundamentos_Python.indb 1

17/10/2022 10:47:55

Dados Internacionais de Catalogação na Publicação (CIP) (Câmara Brasileira do Livro, SP, Brasil) Lambert, Kenneth A. Fundamentos de Python: primeiros programas/Kenneth A. Lambert; Martin Osborne, autor colaborador; [tradução Edson Furmankiewicz]. – 1. ed. – São Paulo: Cengage Learning, 2022. Título original: Fundamentals of Python: first programs 2. ed. norte-americana. ISBN 978-65-5558-429-5 1. Python (Linguagem de programação para computadores) I. Martin Osborne. II. Título. 22-128893

CDD-005.133 Índice para catálogo sistemático:

1. Python: Linguagem de programação: Computadores: Processamento de dados 005.133 Cibele Maria Dias – Bibliotecária – CRB-8/9427

Fundamentos_Python.indb 2

17/10/2022 10:47:55

FUNDAMENTOS DE PYTHON: PRIMEIROS PROGRAMAS TRADUÇÃO DA 2ª EDIÇÃO NORTE-AMERICANA

KENNETH A. LAMBERT MARTIN OSBORNE, AUTOR COLABORADOR

Tradução Edson Furmankiewicz (Docware Traduções)

Revisão técnica Flávio Soares Correa da Silva Livre-docente, Depto. de Ciência da Computação, Universidade de São Paulo Docente em disciplinas de Inteligência Artificial e Técnicas de Programação (Básicas e Avançadas)

Austrália • Brasil • Canadá • México • Cingapura • Reino Unido • Estados Unidos

Fundamentos_Python.indb 3

17/10/2022 10:47:55

Fundamentos de Python: primeiros programas Tradução da 2ª edição norte-americana 1ª edição brasileira Kenneth A. Lambert Gerente editorial: Noelma Brocanelli Editora de desenvolvimento: Gisela Carnicelli Supervisora de produção gráfica: Fabiana Alencar Albuquerque Título original: Fundamentals of Python: First programs, 2nd edition (ISBN 13: 978-1-337-56009-2) Tradução: Edson Furmankiewicz (Docware Traduções)

© 2019, 2012 Cengage Learning, Inc. © 2023 Cengage Learning Edições Ltda. Todos os direitos reservados. Nenhuma parte deste livro poderá ser reproduzida, sejam quais forem os meios empregados, sem a permissão, por escrito, da Editora. Aos infratores aplicam-se as sanções previstas nos artigos 102, 104, 106 e 107 da Lei no 9.610, de 19 de fevereiro de 1998. Esta editora empenhou-se em contatar os responsáveis pelos direitos autorais de todas as imagens e de outros materiais utilizados neste livro. Se porventura for constatada a omissão involuntária na identificação de algum deles, dispomo-nos a efetuar, futuramente, os possíveis acertos. A Editora não se responsabiliza pelo funcionamento dos sites contidos neste livro que possam estar suspensos.

Revisão técnica: Flávio Soares Correa da Silva

Para informações sobre nossos produtos, entre em contato pelo telefone +55 11 3665-9900

Revisão: Fábio Gonçalves e Olívia Frade Zambone

Para permissão de uso de material desta obra, envie seu pedido para direitosautorais@cengage.com

Diagramação: Alfredo Carracedo Castillo Indexação: Olívia Frade Zambone

Capa: Alberto Mateus (Crayon Editorial)

ISBN-13: 978-65-5558-429-5

Imagem da capa: Alberto Mateus (Crayon Editorial)

ISBN-10: 65-5558-429-7 Cengage Condomínio E-Business Park Rua Werner Siemens, 111 – Prédio 11 – Torre A – 9o andar Lapa de Baixo – CEP 05069-010 – São Paulo – SP Tel.: +55 11 3665-9900 Para suas soluções de curso e aprendizado, visite www.cengage.com.br

Aviso ao leitor O editor não assegura nem garante nenhum dos produtos descritos neste livro ou executa qualquer análise independente em conexão com qualquer uma das informações do produto aqui contidas. A editora não supõe, e se isenta expressamente, qualquer obrigação para obter e incluir informações que não as fornecidas pelo fabricante. O leitor é expressamente alertado a considerar e adotar todas as precauções de segurança que possam ser indicadas pelas atividades aqui descritas e para evitar todos os potenciais perigos. Seguindo as instruções aqui contidas, o leitor aceita voluntariamente os riscos em conexão com tais instruções. A editora não faz representações ou garantias de qualquer tipo, incluindo, mas não se limitando a, garantias de adequação para um propósito específico ou comercialização, nem quaisquer representações implícitas em relação ao material aqui estabelecido, e a editora não assume qualquer responsabilidade em relação a esse material. A editora não será responsável por quaisquer danos especiais, consequenciais ou exemplares resultantes, no todo ou em parte, do uso, ou confiança, pelos leitores deste material.

Impresso no Brasil. Printed in Brazil. 1a impressão – 2022

Fundamentos_Python.indb 4

17/10/2022 10:47:55

Sumário PREFÁCIO

CAPÍTULO 1

Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1

Duas ideias fundamentais da ciência da computação: algoritmos e processamento de informações . . . . . . . . . . . . . . . . . . 2 Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Processando informações . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 A estrutura de um sistema de computador moderno . . . . . . . . . . . . . . . 4 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Uma história não tão breve dos sistemas de computação . . . . . . . . . . . . 8 Antes dos computadores digitais eletrônicos . . . . . . . . . . . . . . . . . 9 Os primeiros computadores digitais eletrônicos (1940-1950) . . . . . . . . .11 As primeiras linguagens de programação (1950-1965) . . . . . . . . . . . .12 Circuitos integrados, interação e compartilhamento de tempo (1965-1975) . . 13 Computadores pessoais e redes (1975-1990) . . . . . . . . . . . . . . . . 14 Consulta, comunicação e comércio eletrônico (1990-2000) . . . . . . . . . .15 Aplicativos móveis e computação onipresente (2000-presente) . . . . . . . . 17 Introdução à programação em Python . . . . . . . . . . . . . . . . . . . . . 18 Execução do código no shell interativo . . . . . . . . . . . . . . . . . . . .18 Entrada, processamento e saída . . . . . . . . . . . . . . . . . . . . . . .20 Edição, gravação e execução de um script . . . . . . . . . . . . . . . . . .22 Nos bastidores: como funciona o Python . . . . . . . . . . . . . . . . . . .23 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .24 Detecção e correção de erros de sintaxe . . . . . . . . . . . . . . . . . . . .24 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25 Sugestões para leitura adicional . . . . . . . . . . . . . . . . . . . . . . . . 25 Resumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25 Perguntas de revisão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 Projetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27

Fundamentos_Python.indb 5

17/10/2022 10:47:55

Fundamentos de Python: primeiros programas

CAPÍTULO 2

Desenvolvimento de software, tipos de dados e expressões. . . . 28 O processo de desenvolvimento de software . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Calculadora de imposto de renda . . . . . . . . . . . . . Strings, atribuição e comentários . . . . . . . . . . . . . . . . . . . . . Tipos de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Literais de string . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sequências de escape . . . . . . . . . . . . . . . . . . . . . . . . . Concatenação de strings . . . . . . . . . . . . . . . . . . . . . . . . Variáveis e instruções de atribuição . . . . . . . . . . . . . . . . . . . Comentários de programa e docstrings . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tipos de dados numéricos e conjuntos de caracteres. . . . . . . . . . . . Inteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Números de ponto flutuante . . . . . . . . . . . . . . . . . . . . . . . Conjuntos de caracteres . . . . . . . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Expressões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Expressões aritméticas . . . . . . . . . . . . . . . . . . . . . . . . . Aritmética de modo misto e conversões de tipo . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Utilização de funções e módulos . . . . . . . . . . . . . . . . . . . . . . Funções chamadoras: especificação de argumentos e valores de retorno . O módulo math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . O módulo principal (main) . . . . . . . . . . . . . . . . . . . . . . . . Formato e estrutura do programa . . . . . . . . . . . . . . . . . . . . Execução de um script a partir de um prompt de comando do terminal . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CAPÍTULO 3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

29 31 31 34 34 35 36 36 36 37 38 39 39 39 40 41 41 41 43 44 45 45 46 47 47 48 49 50 51 52

Instruções de laço e de seleção . . . . . . . . . . . . . . . . . 53 Iteração definida: o laço for . . . . . . . . . . . . . . . . . Execução de uma instrução determinado número de vezes . Laços controlados por contagem . . . . . . . . . . . . . Atribuição aumentada . . . . . . . . . . . . . . . . . . . Erros em laços: erro por uma repetição . . . . . . . . . . Percorrendo o conteúdo de uma sequência de dados . . . Especificação de passos em um intervalo . . . . . . . . . Laços que fazem contagem regressiva . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . Formatação de texto para saída . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Um relatório de investimento . . . . . . . . Seleção: instruções if e if-else . . . . . . . . . . . . . . O tipo booleano, comparações e expressões booleanas . . Instruções if-else . . . . . . . . . . . . . . . . . . .

Fundamentos_Python.indb 6

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

54 54 55 56 56 57 57 57 58 58 60 60 63 64 64

17/10/2022 10:47:55

Sumário

Instruções de seleção unidirecional . . . . . . . . . . Instruções if multidirecionais . . . . . . . . . . . . . Operadores lógicos e expressões booleanas compostas Avaliação de curto-circuito . . . . . . . . . . . . . . Testes de instruções de seleção. . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . Iteração condicional: O laço while . . . . . . . . . . . . A estrutura e o comportamento de um laço while . . . Controle de contagem com um laço while. . . . . . . O laço while True e a instrução break . . . . . . . . Números aleatórios . . . . . . . . . . . . . . . . . . Lógica, erros e testes de laço . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Aproximação de raízes quadradas . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . . CAPÍTULO 4

. . . . . . . . . . . . . . . . .

66 66 67 69 70 70 71 71 72 73 74 75 76 76 79 80 81

vii

Strings e arquivos de texto . . . . . . . . . . . . . . . . . . . 84 Acesso a caracteres e substrings em strings. . . . . . . A estrutura das strings . . . . . . . . . . . . . . . . O operador subscrito . . . . . . . . . . . . . . . . . Fatiamento de substrings . . . . . . . . . . . . . . . Testes de uma substring com o operador in . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . Criptografia de dados . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . Strings e sistemas numéricos . . . . . . . . . . . . . . O sistema posicional para representar números . . . . Conversão de binário para decimal . . . . . . . . . . Conversão de decimal para binário . . . . . . . . . . Atalhos de conversão . . . . . . . . . . . . . . . . . Números octais e hexadecimais . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . Métodos de string. . . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . Arquivos de texto . . . . . . . . . . . . . . . . . . . . Arquivos de texto e seu formato . . . . . . . . . . . . Gravação de texto em um arquivo . . . . . . . . . . . Gravação de números em um arquivo . . . . . . . . . Leitura de texto de um arquivo . . . . . . . . . . . . Leitura de números de um arquivo . . . . . . . . . . . Acesso e manipulação de arquivos e diretórios no disco Exercícios . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Análise de texto . . . . . . . . . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . .

Fundamentos_Python.indb 7

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. 85 . 85 . 86 . 86 . 87 . 87 . 88 . 90 . 90 . 91 . 91 . 92 . 93 . 93 . 94 . 95 . 97 . 98 . 98 . 98 . 99 . 99 .100 .101 .103 .104 .107 .108 .109

17/10/2022 10:47:55

Fundamentos de Python: primeiros programas

CAPÍTULO 5

Listas e dicionários . . . . . . . . . . . . . . . . . . . . . . . 111 Listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . Literais de lista e operadores básicos . . . . . . . . . . . Substituição de um elemento em uma lista. . . . . . . . . Métodos de lista para inserir e remover elementos . . . . . Busca em uma lista . . . . . . . . . . . . . . . . . . . . Ordenação de uma lista . . . . . . . . . . . . . . . . . . Métodos modificadores e o valor None . . . . . . . . . . . Codinomes (aliases) e efeitos colaterais . . . . . . . . . . Igualdade: identidade de objeto e equivalência estrutural . . Exemplo: uso de uma lista para encontrar a mediana de um conjunto de números . . . . . . . . . . . . . . . . . . Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . Definição de funções simples . . . . . . . . . . . . . . . . A sintaxe das definições de funções simples . . . . . . . . Parâmetros e argumentos . . . . . . . . . . . . . . . . . A instrução return . . . . . . . . . . . . . . . . . . . . Funções booleanas . . . . . . . . . . . . . . . . . . . . Definição de uma função main . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Gerando sentenças . . . . . . . . . . . . . Dicionários . . . . . . . . . . . . . . . . . . . . . . . . . Literais de dicionário . . . . . . . . . . . . . . . . . . . Adição de chaves e substituição de valores . . . . . . . . Acesso a valores . . . . . . . . . . . . . . . . . . . . . Remoção de chaves . . . . . . . . . . . . . . . . . . . Percorrendo um dicionário . . . . . . . . . . . . . . . . Exemplo: o sistema hexadecimal revisitado . . . . . . . . Exemplo: busca da moda em uma lista de valores . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Psicoterapia não diretiva . . . . . . . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . . . .

viii

CAPÍTULO 6

. . . . . . . . .

.112 .112 .114 .115 .116 .117 .117 .117 .119

. . . . . . . . . . . . . . . . . . . . . . . .

.119 .120 .121 .121 .122 .122 .123 .123 .123 .124 .124 .127 .127 .128 .128 .128 .129 .130 .130 .131 .132 .135 .135 .136

Design com funções. . . . . . . . . . . . . . . . . . . . . . . 138 Uma revisão rápida do que são funções e como elas funcionam. . . . . . . . Funções como mecanismos de abstração . . . . . . . . . . . . . . . . . Funções eliminam a redundância . . . . . . . . . . . . . . . . . . . . . Funções ocultam complexidade . . . . . . . . . . . . . . . . . . . . . . Funções servem de base para métodos gerais com variações sistemáticas . Funções servem de base para a divisão do trabalho . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Solução de problemas com design de cima para baixo . . . . . . . . . . . . O design do programa de análise de texto . . . . . . . . . . . . . . . . . O design do programa gerador de sentenças . . . . . . . . . . . . . . . O design do programa doctor . . . . . . . . . . . . . . . . . . . . . .

Fundamentos_Python.indb 8

.139 .139 .140 .140 .141 .141 .142 .142 .142 .143 .144

17/10/2022 10:47:55

Sumário

Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . Design com funções recursivas . . . . . . . . . . . . . . . . . . Definição de uma função recursiva. . . . . . . . . . . . . . . . Monitoramento de execução de uma função recursiva . . . . . . Uso de definições recursivas para construir funções recursivas . . Recursão na estrutura da frase . . . . . . . . . . . . . . . . . Recursão infinita . . . . . . . . . . . . . . . . . . . . . . . . Os custos e os benefícios da recursão. . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Coleta de informações de um sistema de arquivos . Gerenciamento do espaço de nomes (namespace) de um programa. Variáveis de módulo, parâmetros e variáveis temporárias . . . . . Escopo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tempo de vida . . . . . . . . . . . . . . . . . . . . . . . . . Uso de palavras-chave para argumentos padrão e opcionais . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . Funções de ordem superior . . . . . . . . . . . . . . . . . . . . As funções como objetos de primeira classe . . . . . . . . . . . Mapeamento . . . . . . . . . . . . . . . . . . . . . . . . . . Filtragem . . . . . . . . . . . . . . . . . . . . . . . . . . . . Redução . . . . . . . . . . . . . . . . . . . . . . . . . . . . Uso de lambda para criar funções anônimas . . . . . . . . . . . Criação de tabelas de salto . . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . CAPÍTULO 7

. . . . . . . . . . . . . . . . . . . . . . . . . . .

.145 .145 .145 .146 .147 .148 .148 .149 .150 .151 .156 .157 .157 .158 .158 .160 .160 .160 .161 .162 .162 .163 .163 .164 .164 .166 .167

Gráficos simples e processamento de imagens . . . . . . . . . . 169 Gráficos simples . . . . . . . . . . . . . . . . . . . . . . . . . Visão geral dos gráficos de tartaruga . . . . . . . . . . . . . . Operações de tartaruga. . . . . . . . . . . . . . . . . . . . . Configuração de um arquivo turtle.cfg e execução de IDLE . . . . Instanciação de objetos e o módulo turtle . . . . . . . . . . . Desenho de formas bidimensionais . . . . . . . . . . . . . . . Exame dos atributos de um objeto. . . . . . . . . . . . . . . . Manipulação da tela de uma tartaruga . . . . . . . . . . . . . . Passeio aleatório . . . . . . . . . . . . . . . . . . . . . . . . Cores e o sistema RGB . . . . . . . . . . . . . . . . . . . . . Exemplo: preenchimento de padrões radiais com cores aleatórias Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Padrões recursivos em fractais . . . . . . . . . . Processamento de imagens . . . . . . . . . . . . . . . . . . . . Informações analógicas e digitais . . . . . . . . . . . . . . . . Amostragem e digitalização de imagens . . . . . . . . . . . . . Formatos de arquivo de imagem. . . . . . . . . . . . . . . . . Operações de manipulação de imagem . . . . . . . . . . . . . As propriedades das imagens . . . . . . . . . . . . . . . . . . O módulo images . . . . . . . . . . . . . . . . . . . . . . . .

Fundamentos_Python.indb 9

. . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

.170 .170 .171 .172 .173 .174 .176 .176 .177 .178 .179 .180 .180 .183 .183 .184 .184 .185 .185 .186

17/10/2022 10:47:55

Fundamentos de Python: primeiros programas

Um padrão de laço para percorrer uma grade . . Algumas palavras sobre tuplas . . . . . . . . . Conversão de uma imagem para preto e branco . Conversão de uma imagem para escala de cinza. Cópia de uma imagem . . . . . . . . . . . . . Esmaecimento de uma imagem . . . . . . . . . Detecção de borda . . . . . . . . . . . . . . . Redução do tamanho da imagem . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . .

CAPÍTULO 8

. . . . . . . . . . . .

.188 .189 .190 .191 .191 .192 .193 .194 .195 .196 .197 .198

Interfaces do usuário (GUI – graphical user interfaces) . . . . . . 201 O comportamento de programas baseados em terminal e programas baseados em GUI . . . . . . . . . . . . . . . . . . . . . . . . . A versão baseada em terminal. . . . . . . . . . . . . . . . . . . A versão baseada em GUI . . . . . . . . . . . . . . . . . . . . . Programação orientada a eventos . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Codificação de programas simples baseados em GUI . . . . . . . . . Um simples programa “Hello World” . . . . . . . . . . . . . . . . Um modelo para todos os programas GUI . . . . . . . . . . . . . A sintaxe das definições de classe e método. . . . . . . . . . . . Subclasses e herança como mecanismos de abstração . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Janelas e componentes de janelas . . . . . . . . . . . . . . . . . . Janelas e seus atributos. . . . . . . . . . . . . . . . . . . . . . Layout de janela . . . . . . . . . . . . . . . . . . . . . . . . . Tipos de componentes de janela e seus atributos . . . . . . . . . Exibição de imagens . . . . . . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Botões de comando e resposta a eventos . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entrada e saída com campos de entrada . . . . . . . . . . . . . . . Campos de texto . . . . . . . . . . . . . . . . . . . . . . . . . Campos inteiros e flutuantes para dados numéricos . . . . . . . . Uso de caixas de mensagens pop-up . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definição e uso de variáveis de instância . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: O jogo de adivinhação revisitado . . . . . . . . . . Outros recursos úteis da GUI . . . . . . . . . . . . . . . . . . . . Uso de quadros aninhados para organizar componentes . . . . . . Áreas de texto de várias linhas . . . . . . . . . . . . . . . . . . Caixas de diálogo de arquivo . . . . . . . . . . . . . . . . . . . Entrada com caixas de prompter . . . . . . . . . . . . . . . . . Botões de verificação . . . . . . . . . . . . . . . . . . . . . . . Botões do rádio . . . . . . . . . . . . . . . . . . . . . . . . .

Fundamentos_Python.indb 10

. . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.202 .202 .203 .204 .205 .205 .205 .206 .207 .207 .208 .208 .208 .209 .210 .211 .213 .213 .215 .215 .215 .216 .218 .219 .219 .221 .221 .224 .224 .226 .227 .230 .230 .232

17/10/2022 10:47:55

Sumário

Eventos de teclado . . . . . Trabalhando com cores . . . Uso de um seletor de cores . Resumo. . . . . . . . . . . . Perguntas de revisão . . . . . Projetos . . . . . . . . . . . CAPÍTULO 9

. . . . . .

.233 .234 .235 .237 .238 .239

Design com classe . . . . . . . . . . . . . . . . . . . . . . . 241 Objetos e classes . . . . . . . . . . . . . . . . . . . . . . . . . . . Um primeiro exemplo: a classe Student . . . . . . . . . . . . . . . Docstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definições de método . . . . . . . . . . . . . . . . . . . . . . . . O método __init__ e as variáveis de instância . . . . . . . . . . . O método __str__ . . . . . . . . . . . . . . . . . . . . . . . . . Acessores e modificadores . . . . . . . . . . . . . . . . . . . . . A vida útil dos objetos. . . . . . . . . . . . . . . . . . . . . . . . Regras de ouro para definir uma classe simples . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: O jogo craps . . . . . . . . . . . . . . . . . . . . . Exemplos de modelagem de dados . . . . . . . . . . . . . . . . . . Números racionais . . . . . . . . . . . . . . . . . . . . . . . . . Aritmética de número racional e sobrecarga do operador . . . . . . . Métodos de comparação . . . . . . . . . . . . . . . . . . . . . . Igualdade e método __eq__ . . . . . . . . . . . . . . . . . . . . . Contas poupança e variáveis de classe . . . . . . . . . . . . . . . Colocação das contas em um banco . . . . . . . . . . . . . . . . Uso de pickle para armazenamento permanente de objetos . . . . Entrada de Objetos e a instrução try-except . . . . . . . . . . . . Jogo de cartas . . . . . . . . . . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Um caixa eletrônico. . . . . . . . . . . . . . . . . . Construção de uma nova estrutura de dados: a grade bidimensional . . A interface da classe Grid . . . . . . . . . . . . . . . . . . . . . A implementação da classe Grid: variáveis de instância para os dados A implementação da classe Grid: subscrito e busca . . . . . . . . . Estudo de caso: Criptografia de dados com uma cifra de bloco . . . . . Estruturação de classes com herança e polimorfismo . . . . . . . . . Hierarquias e modelagem de herança . . . . . . . . . . . . . . . . Exemplo 1: Uma conta de poupança restrita . . . . . . . . . . . . . Exemplo 2: O crupiê e um jogador no jogo blackjack . . . . . . . . . Métodos polimórficos . . . . . . . . . . . . . . . . . . . . . . . . Os custos e benefícios da programação orientada a objetos . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Fundamentos_Python.indb 11

. . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.242 .243 .245 .245 .245 .246 .246 .246 .247 .247 .248 .254 .254 .255 .257 .257 .258 .260 .262 .263 .263 .266 .266 .271 .271 .272 .273 .273 .276 .277 .278 .279 .283 .283 .284 .284 .285 .286

17/10/2022 10:47:55

Fundamentos de Python: primeiros programas

CAPÍTULO 10

Multithreading, redes e programação cliente/servidor . . . . . . . 289 Threads e processos . . . . . . . . . . . . . . . . . . . . . . . . . Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Threads suspensas . . . . . . . . . . . . . . . . . . . . . . . . . Produtor, consumidor e sincronização . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . O problema dos leitores e gravadores . . . . . . . . . . . . . . . . . Uso da classe SharedCell . . . . . . . . . . . . . . . . . . . . . Implementação da interface da classe SharedCell. . . . . . . . . . Implementação dos auxiliares da classe SharedCell . . . . . . . . . . . . . . . . . . . . . . . . . . . . Teste da classe SharedCell com um objeto contador . . . . . . . . Definição de uma classe thread-safe . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Redes, clientes e servidores . . . . . . . . . . . . . . . . . . . . . . Endereços IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . Portas, servidores e clientes . . . . . . . . . . . . . . . . . . . . Soquetes e um script de cliente de dia/hora . . . . . . . . . . . . . Um script de servidor de dia/hora . . . . . . . . . . . . . . . . . . Um script de bate-papo bidirecional . . . . . . . . . . . . . . . . . Atendimento de vários clientes simultaneamente . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estudo de caso: Configuração de conversas entre médicos e pacientes . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

xii

CAPÍTULO 11

. . . . . . . .

.290 .291 .293 .294 .299 .299 .300 .301

. . . . . . . . . . . . . . . .

.302 .303 .304 .305 .305 .305 .306 .307 .308 .310 .311 .313 .313 .317 .318 .319

Busca, ordenação e análise de complexidade. . . . . . . . . . . 321 Eficiência dos algoritmos . . . . . . . . . . . . . . . Tempo de execução de um algoritmo . . . . . . . . Instruções de contagem . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . Análise de complexidade . . . . . . . . . . . . . . . Ordens de complexidade . . . . . . . . . . . . . . Notação Big-O . . . . . . . . . . . . . . . . . . . O papel da constante de proporcionalidade . . . . . Memória usada por um algoritmo . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . Algoritmos de busca . . . . . . . . . . . . . . . . . Busca de um mínimo . . . . . . . . . . . . . . . . Busca sequencial em uma lista . . . . . . . . . . . Desempenho no melhor caso, pior caso e caso médio Busca binária em uma lista ordenada . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . Algoritmos de ordenação básicos . . . . . . . . . . . Ordenação por seleção . . . . . . . . . . . . . . . Ordenação por bolha . . . . . . . . . . . . . . . . Ordenação por inserção. . . . . . . . . . . . . . .

Fundamentos_Python.indb 12

. . . . . . . .

. . . . . . . . . . . . . . . . . . . .

.322 .322 .324 .326 .326 .327 .328 .329 .329 .330 .330 .330 .331 .331 .332 .333 .333 .334 .335 .336

17/10/2022 10:47:55

Sumário

Desempenho no melhor caso, pior caso e caso médio possíveis revisitados. Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ordenação mais rápida . . . . . . . . . . . . . . . . . . . . . . . . . . . Quicksort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ordenação por mesclagem . . . . . . . . . . . . . . . . . . . . . . . . Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Um algoritmo exponencial: Fibonacci recursivo . . . . . . . . . . . . . . . . Conversão de Fibonacci em um algoritmo linear . . . . . . . . . . . . . . . Estudo de caso: Um perfilador de algoritmo . . . . . . . . . . . . . . . . . Resumo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Perguntas de revisão . . . . . . . . . . . . . . . . . . . . . . . . . . . . Projetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.337 .337 .338 .338 .341 .344 .344 .345 .346 .351 .351 .352

APÊNDICE A

Recursos do Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355

APÊNDICE B

Instalação das bibliotecas images e breezypythongui . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

APÊNDICE C

A API para processamento de imagens . . . . . . . . . . . . . . . . . . . . 358

APÊNDICE D

Transição de Python para Java e C++ . . . . . . . . . . . . . . . . . . . . . 360

GLOSSÁRIO

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361

xiii

ÍNDICE REMISSIVO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

Fundamentos_Python.indb 13

17/10/2022 10:47:55

Fundamentos_Python.indb 14

17/10/2022 10:47:55

Prefácio

“Todo mundo deveria aprender a codificar.” Essa é a minha citação favorita de Suzanne Keen, professora de inglês do Thomas Broadus e reitora da faculdade da Washington and Lee University, onde lecionei ciência da computação por mais de 30 anos. A citação também explica a razão pela qual escrevi a primeira edição de Fundamentos de Python: primeiros programas, e por que agora ofereço a vocês esta segunda edição. O livro destina-se a ser um curso introdutório sobre programação e solução de problemas. Este livro abrange cinco aspectos principais da computação: 1.

Fundamentos de programação — Tipos de dados, estruturas de controle, desenvolvimento de algoritmos e design de programas com funções são ideias básicas que você precisa dominar para resolver problemas com computadores. Este livro examina esses temas principais em detalhes e fornece a prática de empregar sua compreensão deles para resolver uma ampla variedade de problemas.

Programação orientada a objetos (POO) — A programação orientada a objetos é o paradigma de programação dominante utilizado para desenvolver grandes sistemas de software. Este livro apresenta os princípios fundamentais da POO e permite aplicá-los com sucesso.

Processamento de dados e informações — A maioria dos programas úteis depende de estruturas de dados para resolver problemas. Essas estruturas de dados incluem strings, arrays, arquivos, listas e dicionários. Este livro apresenta essas estruturas de dados comumente utilizadas e inclui exemplos que ilustram os critérios para selecionar as estruturas de dados apropriadas para determinados problemas.

Ciclo de vida de desenvolvimento de software — Em vez de isolar as técnicas de desenvolvimento de software em um ou dois capítulos, este livro trata delas no contexto de vários estudos de caso. Entre outras coisas, você aprenderá que codificar um programa nem sempre é o aspecto mais dif ícil ou desafiador da solução de problemas e do desenvolvimento de software.

Aplicativos contemporâneos da computação — A melhor maneira de aprender sobre programação e solução de problemas é criar programas interessantes com aplicativos do mundo real. Aqui, você começará criando aplicativos que envolvem problemas numéricos e processamento de texto. Por exemplo, aprenderá os fundamentos das técnicas de criptografia, como aquelas utilizadas para tornar seu número de cartão de crédito e outras informações seguras na Internet. Mas, ao contrário de muitos outros textos introdutórios, este não se restringe a problemas envolvendo números e texto. A maioria dos aplicativos contemporâneos envolve interfaces gráficas de usuário, programação orientada a eventos, gráficos, manipulação de imagens e comunicações em rede. Esses temas não são relegados, mas sim apresentados em profundidade depois que você estiver dominando os fundamentos da programação.

Fundamentos_Python.indb 15

17/10/2022 10:47:55

Fundamentos do Python: primeiros programas

Por que Python?

xvi

A tecnologia e os aplicativos de computação se tornaram cada vez mais sofisticados nas últimas três décadas, assim como o currículo da ciência de computação, especialmente no nível introdutório. Os alunos de hoje aprendem um pouco sobre programação e resolução de problemas e então espera-se que passem rapidamente para tópicos como desenvolvimento de software, análise de complexidade e estruturas de dados que, 30 anos atrás, eram relegados a cursos avançados. Além disso, a ascensão da programação orientada a objetos como o paradigma dominante da resolução de problemas levou instrutores e autores de livros didáticos a implementar linguagens de programação poderosas e de força industrial, como C++ e Java, no currículo introdutório. Como resultado, em vez de experimentar as recompensas e o entusiasmo da resolução de problemas com computadores, os alunos iniciantes na ciência da computação muitas vezes ficam sobrecarregados com as tarefas combinadas de dominar conceitos avançados, bem como a sintaxe de uma linguagem de programação. Este livro utiliza a linguagem de programação Python como uma forma de tornar o primeiro ano do estudo de ciência da computação mais gerenciável e atraente para alunos e instrutores. O Python tem os seguintes benef ícios pedagógicos: • O Python tem sintaxe simples e convencional. As instruções em Python são muito semelhantes às dos algoritmos em pseudocódigo, e as expressões em Python usam a notação convencional encontrada na álgebra. Assim, os alunos podem gastar menos tempo aprendendo a sintaxe de uma linguagem de programação e mais tempo aprendendo a resolver problemas interessantes. • O Python tem semântica segura. Qualquer expressão ou instrução cujo significado viole a definição da linguagem produz uma mensagem de erro. • O Python tem boa escalabilidade. É muito fácil para iniciantes escrever programas simples em Python. O Python também inclui todos os recursos avançados de uma linguagem de programação moderna, como suporte para estruturas de dados e desenvolvimento de software orientado a objetos, para uso quando necessário. • O Python é altamente interativo. Expressões e instruções podem ser inseridas nos prompts de um interpretador para permitir que o programador teste o código experimental e receba feedback imediato. Segmentos de código mais longos podem ser compostos e salvos em arquivos de script para serem carregados e executados como módulos ou aplicativos independentes. • O Python é de uso geral. No contexto atual, isso significa que a linguagem inclui recursos para aplicativos contemporâneos, incluindo computação de mídia e redes. • O Python é gratuito e está em uso generalizado na indústria. Os alunos podem baixar o programa para executá-lo em vários dispositivos. Há uma grande comunidade de usuários Python, e a experiência em programação Python tem grande valor para o currículo. Em resumo, o Python é um veículo cômodo e flexível para expressar ideias sobre computação, tanto para iniciantes como para especialistas. Se os alunos aprenderem bem essas ideias no primeiro curso, eles não devem ter problemas para fazer uma transição rápida a outras linguagens pré-requisitos para cursos posteriores no currículo. Mais importante ainda, os alunos iniciantes passarão menos tempo olhando para a tela do computador e mais tempo pensando em problemas interessantes para resolver.

Fundamentos_Python.indb 16

17/10/2022 10:47:55

Prefácio

Organização do livro A abordagem neste texto é descontraída, com cada novo conceito introduzido apenas quando necessário. O Capítulo 1 apresenta a ciência da computação concentrando-se em duas ideias fundamentais, algoritmos e processamento de informações. Uma breve visão geral sobre hardware e software de computador, seguida por uma discussão extensa da história da computação, define o contexto para a resolução de problemas computacionais. Os capítulos 2 e 3 abordam os fundamentos da solução de problemas e desenvolvimento de algoritmos utilizando as estruturas de controle padrão de avaliação de expressão, sequenciamento, lógica booleana, seleção e iteração com os tipos de dados numéricos básicos. A ênfase nestes capítulos é a resolução de problemas que é tanto sistemática como experimental, envolvendo projeto, teste e documentação de algoritmos. Os capítulos 4 e 5 apresentam o uso de strings, arquivos de texto, listas e dicionários. Essas estruturas de dados são notavelmente fáceis de manipular no Python e suportam alguns aplicativos interessantes. O Capítulo 5 também apresenta definições de função simples como uma maneira de organizar o código algorítmico. O Capítulo 6 explora a técnica e os benef ícios da abstração procedural com definições de função. Projeto de cima para baixo, refinamento passo a passo e projeto recursivo com funções são examinados como meios de estruturar código para resolver problemas complexos. Discutimos os detalhes da organização do espaço de nomes (parâmetros, variáveis temporárias e variáveis de módulo) e da comunicação entre os componentes de software. Uma seção sobre programação funcional com funções de ordem superior mostra como explorar padrões de projeto funcionais para simplificar soluções. O Capítulo 7 foca no uso de objetos e classes existentes para compor programas. Atenção especial é dada à interface de programação de aplicativos (API), ou conjunto de métodos, de uma classe de objetos e à maneira como os objetos cooperam para resolver problemas. Este capítulo também apresenta dois aplicativos contemporâneos de computação, gráficos e processamento de imagens — áreas nas quais a programação baseada em objetos é particularmente útil. O Capítulo 8 apresenta a definição de novas classes para construir interfaces gráficas com o usuário (GUIs). O capítulo compara o modelo orientado a eventos dos programas GUI ao modelo orientado a processos de programas baseados em terminal. A criação e o layout dos componentes GUI são explorados, bem como o projeto de aplicativos baseados em GUI utilizando o padrão modelo/visualização. A abordagem inicial à definição de novas classes neste capítulo não é comum em um livro introdutório: os alunos aprendem que a maneira mais fácil de definir uma nova classe é personalizar uma classe existente utilizando subclasses e herança. O Capítulo 9 continua a exploração do projeto orientado a objetos com a definição de classes inteiramente novas. Vários exemplos de definições de classes simples de diferentes domínios de aplicativo são apresentados. Alguns deles são então integrados a aplicativos mais realistas, para mostrar como os componentes de software orientados a objetos podem ser utilizados para construir sistemas complexos. A ênfase é projetar interfaces apropriadas para classes que exploram polimorfismo. O Capítulo 10 abrange material avançado relacionado a várias áreas importantes da computação: programação simultânea, redes e aplicativos cliente/servidor. Este capítulo, portanto, oferece aos alunos experiências desafiadoras perto do final do primeiro curso. Apresenta também programas multithread e a construção de simples aplicativos cliente/servidor com base na rede. O Capítulo 11 cobre alguns temas abordados no início de um curso tradicional de Ciência da computação. Este capítulo apresenta a análise de complexidade com notação big-O. Material suficiente é apresentado para permitir que você execute análises simples do tempo de execução e do uso da memória de algoritmos e estruturas de dados, usando algoritmos de pesquisa e classificação como exemplos.

Fundamentos_Python.indb 17

xvii

17/10/2022 10:47:55

Fundamentos do Python: primeiros programas

Recursos especiais

xviii

Este livro explica e desenvolve conceitos de forma cuidadosa, usando exemplos e diagramas frequentes. Novos conceitos são, então, aplicados a programas completos para mostrar como eles auxiliam na solução de problemas. Os capítulos colocam ênfase inicial e consistente em bons hábitos de escrita e documentação organizada e legível. Inclui ainda vários outros recursos importantes: • Estudos de caso — Apresentam programas Python completos que variam do simples ao substancial. Para enfatizar a importância e a utilidade do ciclo de vida do desenvolvimento de software, os estudos de caso são discutidos na estrutura de uma solicitação do usuário, seguidos por análise, design, implementação e sugestões de teste, com tarefas bem definidas realizadas em cada estágio. Alguns estudos de caso são estendidos em projetos de programação de fim de capítulo. • Objetivos e resumos dos capítulos — Cada capítulo começa com um conjunto de objetivos de aprendizagem e termina com um resumo dos principais conceitos abordados no capítulo. • Termos-chave e glossário — Quando um termo técnico é introduzido no texto, ele aparece em negrito. As definições dos termos-chave também são agrupadas em um glossário. • Exercícios — A maioria das seções principais de cada capítulo termina com exercícios em forma de perguntas que reforçam a leitura fazendo questões básicas sobre o material da seção. Cada capítulo termina com um conjunto de exercícios de revisão. • Projetos de programação — Cada capítulo termina com um conjunto de projetos de programação de dificuldade variada. • Um kit de ferramentas de software para processamento de imagens — Você pode baixar um kit de ferramentas Python de código aberto para o fácil processamento de imagens discutido no Capítulo 7. O kit de ferramentas pode ser obtido no site do autor, em http://kennethalambert.com/python/ cs1pythonv2/images.html. • Um kit de ferramentas de software para programação GUI — Você pode baixar um kit de ferramentas Python de código aberto para a programação GUI fácil apresentada no Capítulo 8. O kit de ferramentas pode ser obtido no site do autor, em http://kennethalambert.com/breezypythongui/index.html. • Apêndices — Quatro apêndices incluem informações sobre como obter recursos Python, instalar os kits de ferramentas e utilizar as interfaces deles.

Novidade nesta edição Várias novas figuras foram adicionadas para ilustrar conceitos e muitos exercícios e projetos de programação foram retrabalhados. A breve história da computação no Capítulo 1 foi atualizada. Uma discussão de um tipo Grid foi incluída para os alunos começarem a ter contato com estruturas de dados bidimensionais. O livro continua sendo o único texto introdutório do Python com uma introdução completa à programação GUI realista. O capítulo sobre GUIs (Capítulo 8) agora utiliza o kit de ferramentas breezypythongui para facilitar a introdução desse tópico. O capítulo sobre GUIs também foi colocado à frente do capítulo sobre projeto com classes (Capítulo 9). Esse arranjo permite que os alunos explorem a personalização das classes existentes com programação GUI antes de abordarem o projeto de classes inteiramente novas no capítulo seguinte. Por fim, uma nova seção sobre o problema dos leitores e gravadores foi adicionada ao Capítulo 10, para ilustrar o acesso seguro a recursos compartilhados.

Fundamentos_Python.indb 18

17/10/2022 10:47:55

Prefácio

Material de apoio As seguintes ferramentas de ensino estão disponíveis para download na página deste livro no site da Cengage. • Manual do instrutor: O manual do professor que acompanha este livro inclui material educacional adicional para auxiliar na preparação das aulas, incluindo itens como visão geral, objetivos do capítulo, testes rápidos, tópicos de discussão em sala de aula, projetos adicionais, recursos adicionais e termos-chave. Disponível, em inglês, para professores.

xix

• Apresentações em PowerPoint: Este livro fornece slides do PowerPoint para acompanhar cada capítulo. Os slides podem ser usados para orientar as apresentações em sala de aula, para os alunos estudarem como revisão do capítulo ou ser impressos como apostilas para uso em sala de aula. Disponível, em português, para professores e alunos. • Soluções: Soluções para todos os exercícios de programação estão disponíveis. Se um arquivo é necessário para executar um exercício de programação, ele é incluído no arquivo de solução. Disponível, em inglês, para professores e alunos. • Data sets: Se um arquivo é necessário para executar um programa, ele é incluído nos data sets. Disponível, em inglês, para professores e alunos.

Agradecimentos Quero agradecer a meu autor colaborador Martin Osborne por muitos anos de conselhos, críticas amigáveis e incentivo em vários de meus projetos de livro. Também sou grato aos muitos alunos e colegas da Washington and Lee University que utilizaram este livro e forneceram comentários úteis sobre ele durante a vida da primeira edição. Além disso, quero agradecer aos seguintes revisores pelo tempo e esforço que contribuíram para o Fundamentos de Python: Steven Robinett, Great Falls College Montana State University; Mark Williams, University of Maryland Eastern Shore; Andrew Danner, Swarthmore College; Susan Fox, Macalester College; Emily Shepard, Central Carolina Community College. Além disso, agradeço às pessoas da Cengage que ajudaram a garantir que o conteúdo de todos os arquivos de dados e soluções utilizados neste livro estivesse correto e preciso: John Freitas, líder do projeto MQA e Danielle Shaw, testador MQA. Por fim, agradeço a várias outras pessoas cujo trabalho tornou este livro possível: Kate Mason, gerente associada de produto, Cengage; Natalie Pashoukos, desenvolvedora de conteúdo sênior, Cengage; e Jennifer Feltri-George, gerente de projeto de conteúdo sênior, Cengage. Também quero agradecer a Scarlett Lindsay por sua excelente edição do livro e a Chandrasekar Subramanian pelo excelente trabalho gerenciando a paginação do projeto.

Dedicatória A meus bons amigos, Lesley e David Novack Kenneth A. Lambert Lexington, VA

Fundamentos_Python.indb 19

17/10/2022 10:47:56

Fundamentos_Python.indb 20

17/10/2022 10:47:56

CAPÍTULO

Introdução

Depois de concluir este capítulo, você será capaz de: • Descrever as características básicas de um gráfico • Explicar como hardware e software colaboram na arquitetura de um computador • Resumir uma breve história da computação • Compor e executar um programa Python simples

Fundamentos_Python.indb 1

17/10/2022 10:47:56

Fundamentos de Python: primeiros programas

Como leitor deste livro, você quase certamente já jogou videogame e ouviu música digital. É provável que você tenha assistido a um filme digital depois de preparar um lanche no micro-ondas. É bem possível que hoje você faça uma ligação, envie ou receba uma mensagem de texto, tire uma foto ou consulte sua rede social favorita no celular. Você e seus amigos provavelmente utilizaram um computador de mesa ou um laptop para fazer algum curso significativo no ensino médio ou na faculdade. Essas atividades contam com algo em comum: a informática. A informática está em quase toda parte, não apenas em nossas casas, mas também em nossas escolas e nos lugares onde trabalhamos e nos divertimos. A tecnologia da computação desempenha um papel importante no entretenimento, na educação, medicina, manufatura, nas comunicações, no governo e comércio. Já foi dito que temos estilos de vida digitais e que vivemos na era da informação com uma economia baseada na informação. Algumas pessoas chegam a afirmar que a própria natureza realiza cálculos sobre estruturas de informação presentes no DNA e nas relações entre partículas subatômicas. É dif ícil imaginar nosso mundo sem computação, embora não pensemos muito nos computadores reais. Também é dif ícil imaginar que a raça humana tenha existido sem a tecnologia da computação por milhares de anos e que esta permeou o mundo como o conhecemos apenas nos últimos 30 anos. Nos capítulos a seguir, você aprenderá sobre ciência da computação, que é o estudo da computação que tornou possível essa nova tecnologia e esse novo mundo. Você também aprenderá a utilizar computadores de forma eficaz e adequada para melhorar sua própria vida e a vida de outras pessoas.

Duas ideias fundamentais da ciência da computação: algoritmos e processamento de informações Como a maioria das áreas de estudo, a ciência da computação focaliza um amplo conjunto de ideias inter-relacionadas. Duas das mais básicas são algoritmos e processamento de informações. Nesta seção, apresentaremos essas ideias de maneira informal. Vamos examiná-las em mais detalhes nos capítulos posteriores.

Algoritmos As pessoas faziam cálculos muito antes da invenção dos dispositivos de computação modernos e muitas continuam a utilizar dispositivos de computação que podemos considerar primitivos. Por exemplo, pense em como os comerciantes davam trocado para os clientes nos mercados antes da existência de cartões de crédito, calculadoras de bolso ou caixas registradoras. Dar o troco pode ser uma atividade complexa. É provável que você levou algum tempo para aprender como fazer isso e é preciso algum esforço mental para sempre fazer o cálculo certo. Vamos considerar o que está envolvido nesse processo. De acordo com um dos métodos, o primeiro passo é calcular a diferença entre o preço de compra e a quantidade de dinheiro que o cliente dá ao comerciante. O resultado desse cálculo é o valor total que o lojista deve devolver ao comprador. Por exemplo, se você comprar uma dúzia de ovos no mercado de um agricultor por $ 2,39 e der-lhe uma nota de $ 10, ele deve devolver $ 7,61 para você. Para gerar essa quantia, o comerciante seleciona as moedas e notas apropriadas que, quando somadas a $ 2,39, totalizam $ 10,00. De acordo com outro método, o comerciante começa com o preço de compra e chega ao valor dado. Primeiro, as moedas são selecionadas para aproximar o preço até o valor em reais (neste caso, $ 0,61 = 2 moedas de 25 centavos, 10 centavos e 1 centavo), então os valores são selecionados para aproximar o preço até o valor de 5 (neste caso, $ 2) e então, nesse caso, uma nota de $ 5 completa a transação. Como veremos neste livro, pode haver muitos métodos ou algoritmos possíveis que resolvem o mesmo problema e a escolha do melhor é uma habilidade que você adquirirá com a prática. Poucas pessoas conseguem subtrair números de três dígitos sem recorrer a algumas ferramentas manuais, como lápis e papel. Como aprendeu na escola primária, você pode realizar a subtração com lápis e papel seguindo uma sequência de passos bem definidos. Você provavelmente já fez isso muitas vezes, mas nunca fez uma lista dos passos específicos envolvidos. Criar essas listas para resolver problemas é algo que os cientistas da computação fazem o tempo todo. Por exemplo, a lista de passos a seguir descreve o processo de subtração de dois números utilizando lápis e papel:

Fundamentos_Python.indb 2

17/10/2022 10:47:56

Introdução

Etapa 1 Anote os dois números, com o número maior acima do número menor e os dígitos alinhados em colunas a partir da direita. Etapa 2 Então, você começará com a coluna de dígitos mais à direita e prosseguirá daí para a esquerda passando por cada coluna. Etapa 3 Anote a diferença entre os dois dígitos na coluna de dígitos atual, emprestando um da próxima coluna do número de cima à esquerda, se necessário.

Etapa 4 Se não houver uma próxima coluna à esquerda, pare. Caso contrário, passe para a próxima coluna à esquerda e volte ao passo 3. Se o agente computacional (neste caso, um ser humano) seguir cada um desses passos simples corretamente, todo o processo resulta em uma solução correta para o problema dado. Assumimos no passo 3 que o agente já sabe calcular a diferença entre os dois dígitos em qualquer coluna dada, emprestando se necessário. Para dar o troco, a maioria das pessoas pode selecionar a combinação de moedas e notas que representam o valor correto do troco sem nenhum auxílio manual, além de moedas e notas. Mas os cálculos mentais envolvidos ainda podem ser descritos de maneira semelhante aos passos anteriores e podemos anotá-los no papel se houver uma diferença quanto à exatidão do troco. A sequência de passos que descreve cada um desses processos computacionais chama-se algoritmo. Informalmente, um algoritmo é como uma receita. Ele fornece um conjunto de instruções que informa como fazer algo, como calcular o troco, assar pão ou montar um móvel. Mais precisamente, um algoritmo descreve um processo que termina com uma solução para um problema. O algoritmo também é uma das ideias fundamentais da ciência da computação. Um algoritmo tem as seguintes características: 1. Um algoritmo consiste em um número finito de instruções. 2. Cada instrução individual em um algoritmo está bem definida. Isso significa que a ação descrita pela instrução pode ser realizada de forma eficaz ou ser executada por um agente de computação. Por exemplo, qualquer agente de computação capaz de aritmética pode calcular a diferença entre dois dígitos. Portanto, um passo algorítmico que diz “calcule a diferença entre dois dígitos” estaria bem definido. Caso contrário, um passo que diz “divida um número por 0” não está bem definido, porque nenhum agente computacional poderia realizá-lo. 3. Um algoritmo descreve um processo que termina ao chegar a uma solução para um problema. Por exemplo, o processo de subtração termina depois que o agente de computação anota a diferença entre os dois dígitos na coluna de dígitos mais à esquerda. 4. Um algoritmo resolve uma classe geral de problemas. Por exemplo, um algoritmo que descreve como fazer o troco deve funcionar para quaisquer dois valores monetários cuja diferença é maior ou igual a $ 0,00. Criar uma lista de passos que descrevem como fazer o troco pode não parecer uma grande conquista para você. Mas a capacidade de dividir uma tarefa em suas partes componentes é uma das principais tarefas de um programador de computador. Depois de escrever um algoritmo para descrever um tipo particular de cálculo, podemos construir uma máquina para fazer esse cálculo. Dito de outra forma, se conseguimos desenvolver um algoritmo para resolver um problema, podemos automatizar a tarefa para resolver o problema. Você pode não se sentir compelido a escrever um programa de computador para automatizar a tarefa de fazer o troco, porque você mesmo provavelmente já consegue calcular o troco com bastante facilidade. Mas suponha que você precise fazer uma tarefa mais complicada, como classificar uma lista de 100 nomes. Nesse caso, um programa de computador é muito útil. Os computadores podem ser projetados para executar um pequeno conjunto de algoritmos para realizar tarefas especializadas, como operar um micro-ondas. Mas também podemos construir computadores, como o seu desktop, que são capazes de realizar uma tarefa descrita por meio de qualquer algoritmo. Esses computadores são máquinas de solução de problemas de uso geral. Eles são diferentes de todas as máquinas já construídas e formaram a base do mundo completamente novo em que vivemos.

Fundamentos_Python.indb 3

17/10/2022 10:47:56

Fundamentos de Python: primeiros programas

Mais adiante neste livro, apresentaremos uma notação para expressar algoritmos e algumas sugestões para projetar algoritmos. Veremos que algoritmos e pensamento algorítmico são cruciais para qualquer sistema de computador.

Processamento de informações Desde que os seres humanos aprenderam a escrever há vários milhares de anos, eles processaram informações. A própria informação assumiu muitas formas em sua história, desde as marcas impressas em tábuas de argila na antiga Mesopotâmia aos primeiros textos escritos na Grécia antiga; às palavras impressas em livros, jornais e revistas produzidos em massa desde o Renascimento europeu aos símbolos abstratos da matemática e ciência modernas utilizados durante os últimos 350 anos. Só recentemente, porém, os seres humanos desenvolveram a capacidade de automatizar o processamento de informações construindo computadores. No mundo moderno dos computadores, as informações também são comumente chamadas dados. Mas o que é informação? Assim como os cálculos matemáticos, o processamento de informações pode ser descrito com algoritmos. Em nosso exemplo anterior de fazer troco, as etapas de subtração envolviam a manipulação de símbolos utilizados para representar números e dinheiro. Ao executar as instruções de qualquer algoritmo, um agente de computação manipula as informações. O agente de computação começa com algumas informações fornecidas (conhecidas como entrada), transforma essas informações de acordo com regras bem definidas e produz novas informações, conhecidas como saída. É importante reconhecer que os algoritmos que descrevem o processamento de informações também podem ser representados como informações. Os cientistas da computação conseguiram representar algoritmos de uma forma que podem ser executados de forma eficaz e eficiente por máquinas. Eles também projetaram máquinas reais, chamadas computadores digitais eletrônicos, que são capazes de executar algoritmos. Os cientistas da computação descobriram mais recentemente como representar muitas outras coisas, imagens, música, fala humana e vídeo, como informações. Muitos dos meios e dispositivos de comunicação que agora consideramos corriqueiros seriam impossíveis sem esse novo tipo de processamento de informações. Examinamos muitas dessas realizações em mais detalhes nos capítulos posteriores.

Exercícios Esses exercícios curtos de fim de seção visam estimular seu pensamento sobre computação. 1. 2. 3. 4. 5. 6.

Liste três tipos comuns de agentes computacionais. Escreva um algoritmo que descreva a segunda parte do processo de fazer o troco (contando as moedas e notas). Escreva um algoritmo que descreva uma tarefa comum, como assar um bolo ou operar um DVD player. Descreva uma instrução que não esteja bem definida e, portanto, não possa ser incluída como uma etapa em um algoritmo. Forneça um exemplo. Em que sentido um laptop é uma máquina de resolução de problemas de uso geral? Liste quatro dispositivos que utilizem computadores e descreva as informações que eles processam. (Dica: Pense nas entradas e saídas dos dispositivos.)

A estrutura de um sistema de computador moderno Faremos agora uma breve introdução geral à estrutura dos sistemas computacionais modernos. Um sistema computacional moderno consiste em hardware e software. O hardware consiste nos dispositivos físicos necessários para executar algoritmos. Software é o conjunto desses algoritmos, representados como programas, em

Fundamentos_Python.indb 4

17/10/2022 10:47:56

Introdução

particular linguagens de programação. Na discussão a seguir, focalizaremos o hardware e software encontrados em um sistema de computador desktop típico, embora componentes semelhantes também sejam encontrados em outros sistemas de computador, como dispositivos portáteis e caixas eletrônicos.

Hardware Os componentes básicos de hardware de um computador são memória, uma unidade de processamento central (CPU) e um conjunto de dispositivos de entrada/saída, como mostrado na Figura 1-1.

Dispositivo de entrada

Dispositivo de saída

Memória CPU

Figura 1-1 Componentes de hardware de um sistema de computador moderno

Os usuários humanos interagem principalmente com os dispositivos de entrada e saída. Os dispositivos de entrada incluem teclado, mouse, trackpad, microfone e tela sensível ao toque. Dispositivos de saída comuns são monitor e alto-falantes. Os computadores também podem se comunicar com o mundo externo por meio de várias portas que os conectam a redes e a outros dispositivos como smartphones e câmeras digitais. O objetivo da maioria dos dispositivos de entrada é converter informações com as quais os seres humanos lidam, como texto, imagens e sons, em informações para processamento computacional. O objetivo da maioria dos dispositivos de saída é converter os resultados desse processamento de volta para a forma utilizável por seres humanos. A memória do computador é configurada para representar e armazenar informações em formato eletrônico. Especificamente, as informações são armazenadas como padrões de dígitos binários (1s e 0s). Para entender como isso funciona, considere um dispositivo básico como um interruptor de luz, que só pode estar em um de dois estados, ligado ou desligado. Agora suponha que haja um banco de interruptores que controlam 16 pequenas luzes consecutivas. Desligando ou ligando os interruptores, podemos representar qualquer padrão de 16 dígitos binários (1s e 0s) como padrões de luzes que estão ligadas ou desligadas. Como veremos mais adiante neste livro, os cientistas da computação descobriram como representar qualquer informação, incluindo texto, imagens e som, em forma binária. Agora, suponha que existam 8 desses grupos de 16 luzes. Podemos selecionar qualquer grupo de luzes e examinar ou alterar o estado de cada luz dentro dessa coleção. Acabamos de desenvolver um pequeno modelo de memória de computador. A memória tem 8 células, cada uma pode armazenar 16 bits de informação binária. Um diagrama desse modelo, no qual as células de memória são preenchidas com dígitos binários, é mostrado na Figura 1-2. Essa memória também é às vezes chamada primária ou interna ou memória de acesso aleatório (RAM). As informações armazenadas na memória podem representar qualquer tipo de dado, como números, texto, imagens ou som, ou as instruções de um programa. Também podemos armazenar na memória um algoritmo codificado como instruções binárias para o computador. Depois que a informação é armazenada na memória, normalmente queremos fazer algo com ela — isto é, queremos processá-la. A parte de um computador responsável pelo processamento de dados é a unidade central de processamento (CPU). Esse dispositivo, que às vezes também é chamado processador, consiste em chaves eletrônicas organizadas para realizar operações lógicas, aritméticas e de controle simples. A CPU executa um algoritmo buscando suas

Fundamentos_Python.indb 5

17/10/2022 10:47:56

Fundamentos de Python: primeiros programas

Célula 7 Célula 6 Célula 5 Célula 4 Célula 3 Célula 2 Célula 1 Célula 0

1 1 1 1 1 0 1 1

1 0 1 0 1 0 1 1

0 1 1 1 1 1 1 1

1 1 1 1 0 1 0 0

1 0 1 1 1 1 1 1

1 1 1 0 1 1 1 1

1 1 1 1 1 0 1 0

0 1 1 1 1 1 1 1

1 1 0 1 1 1 1 1

1 1 1 1 0 1 1 1

1 1 1 1 1 0 1 1

1 0 1 1 1 1 1 1

1 1 1 0 1 1 1 1

1 1 0 1 1 1 0 1

0 1 1 1 1 0 1 1 1 0

Figura 1-2 Modelo de memória de computador

instruções binárias na memória, decodificando-as e executando-as. A execução de uma instrução também pode envolver a busca de outras informações binárias — os dados — da memória. O processador pode localizar dados na memória principal de um computador muito rapidamente. Entretanto, esses dados só existem enquanto o computador estiver ligado. Se a energia falhar ou for desligada, os dados na memória primária serão perdidos. Claramente, um tipo mais permanente de memória é necessário para preservar os dados. Esse tipo mais permanente de memória chama-se memória externa ou secundária e tem várias formas. Mídias de armazenamento magnético, como fitas e discos rígidos, permitem que padrões de bits sejam armazenados como padrões em um campo magnético. Dispositivos semicondutores, como cartões de memória flash, desempenham praticamente a mesma função com uma tecnologia diferente, assim como as mídias de armazenamento óptico, como CDs e DVDs. Algumas dessas mídias de armazenamento secundárias podem conter quantidades muito maiores de informações que a memória interna de um computador.

Software Vimos que um computador é uma máquina de solução de problemas de uso geral. Para resolver qualquer problema calculável, um computador deve ser capaz de executar qualquer algoritmo. Como é impossível prever todos os problemas para os quais existem soluções algorítmicas, não há como “conectar” todos os potenciais algoritmos ao hardware de um computador. Em vez disso, incorporamos algumas operações básicas no processador do hardware e recorremos a qualquer algoritmo para usá-las. Os algoritmos são convertidos em formato binário e então carregados, com seus dados, na memória do computador. O processador pode então executar as instruções dos algoritmos realizando as operações mais básicas do hardware. Quaisquer programas armazenados na memória para que possam ser executados posteriormente são chamados software. Um programa armazenado na memória do computador deve ser representado em dígitos binários, também conhecido como código – ou linguagem – de máquina. Carregar código de máquina na memória do computador um dígito por vez seria uma tarefa entediante e propensa a erros para os seres humanos. Seria conveniente se pudéssemos automatizar esse processo para sempre produzir um resultado correto. Por essa razão, os cientistas da computação desenvolveram outro programa, chamado carregador (loader), para realizar essa tarefa. Um carregador recebe um conjunto de instruções de linguagem de máquina como entrada e as carrega nos locais de memória apropriados. Quando o carregador termina, o programa em linguagem de máquina estará pronto para ser executado. Obviamente, o carregador não pode se carregar na memória, então isso é um daqueles algoritmos que devem ser conectados ao computador. Agora que existe um carregador, podemos carregar e executar outros programas que facilitam o desenvolvimento, execução e gerenciamento de programas. Esse tipo de software chama-se software de sistema. O exemplo mais importante de software de sistema é um sistema operacional do computador. Você provavelmente já conhece pelo menos um dos sistemas operacionais mais populares, como Linux, macOS da Apple e Windows da Microsoft. Um sistema operacional é responsável por gerenciar e agendar vários programas em execução simultânea. Ele também gerencia a memória do computador, incluindo o

Fundamentos_Python.indb 6

17/10/2022 10:47:56

Introdução

armazenamento externo e gerencia a comunicação entre a CPU, os dispositivos de entrada/saída e outros computadores em uma rede. Uma parte importante de qualquer sistema operacional é o sistema de arquivos, que permite que usuários humanos organizem seus dados e programas em um armazenamento permanente. Outra função importante de um sistema operacional é fornecer interfaces com o usuário — isto é, maneiras de o usuário humano interagir com o software do computador. Uma interface baseada em terminal aceita entradas de um teclado e exibe a saída de texto na tela do monitor. Uma interface gráfica com o usuário (GUI) organiza a tela do monitor em torno da metáfora de uma área de trabalho, com janelas contendo ícones para pastas, arquivos e aplicativos. Esse tipo de interface com o usuário também permite que ele manipule imagens com um dispositivo apontador como um mouse. Uma interface de tela sensível ao toque suporta manipulação mais direta desses elementos visuais com gestos como pinçar e deslizar com os dedos. Dispositivos que respondem verbalmente e de outras maneiras a comandos de voz também estão se difundindo. Outro tipo importante de software chama-se software de aplicativos, ou simplesmente aplicativos. Um aplicativo é um programa projetado para uma tarefa específica, como editar um documento ou exibir uma página da Web. Os aplicativos incluem navegadores da Web, processadores de texto, planilhas, gerenciadores de banco de dados, pacotes de design gráfico, sistemas de produção musical e jogos, entre milhões de outros. À medida que você começa a aprender a escrever programas de computador, você se concentrará em escrever aplicativos simples. Como vimos, o hardware do computador só pode executar instruções escritas em formato binário, ou seja, em linguagem de máquina. Mas escrever um programa em linguagem de máquina seria uma tarefa extremamente entediante e propensa a erros. Para facilitar o processo de escrever programas de computador, os cientistas da computação desenvolveram linguagens de programação de alto nível para expressar algoritmos. Esses idiomas se assemelham ao inglês e permitem que o autor expresse algoritmos de uma forma que outras pessoas possam entender. Um programador normalmente começa escrevendo instruções de linguagem de alto nível em um editor de texto. O programador então executa outro programa chamado tradutor para converter o código de programa de alto nível em código executável. Como é possível que um programador cometa erros gramaticais mesmo ao escrever código de alto nível, o tradutor verifica erros de sintaxe antes de concluir o processo de tradução. Se detectar algum desses erros, o tradutor alerta o programador por meio de mensagens de erro. O programador então tem de revisar o programa. Se o processo de tradução for bem-sucedido sem um erro de sintaxe, o programa pode ser executado pelo sistema em tempo de execução. O sistema de tempo de execução pode executar o programa diretamente no hardware ou executar outro programa chamado interpretador ou máquina virtual para executar o programa. A Figura 1-3 mostra as etapas e o software utilizado no processo de codificação.

Editor de texto

Tradutor

Mensagens de erro de sintaxe

Cria programa de linguagem de alto nível

Entradas do usuário

Sistema de Outras mensagens de erro tempo de execução Saídas do programa

Figura 1-3 Software utilizado no processo de codificação

Fundamentos_Python.indb 7

17/10/2022 10:47:56

Fundamentos de Python: primeiros programas

Exercícios

1. 2. 3. 4. 5.

Cite dois exemplos de dispositivos de entrada e dois exemplos de dispositivos de saída. O que a unidade central de processamento (CPU) faz? Como as informações são representadas na memória do hardware? Qual é a diferença entre uma interface com base em terminal e uma interface gráfica com o usuário? Que papel os conversores desempenham no processo de programação?

Uma história não tão breve dos sistemas de computação Agora que temos em mente algumas das ideias básicas da computação e dos sistemas computacionais, vamos examinar como elas tomaram forma na história. A Figura 1-4 resume alguns dos principais avanços na história da computação. A discussão a seguir fornece detalhes adicionais sobre esses avanços. Datas aproximadas

Principais desenvolvimentos

Antes de 1800

• Matemáticos descobrem e utilizam algoritmos • Ábaco utilizado como ferramenta de cálculo • Primeiras calculadoras mecânicas construídas por Pascal e Leibniz

Século XIX

• Tear de Jacquard • Máquina analítica de Babbage • Sistema lógico de Boole • Máquina de cartão perfurado de Hollerith

Anos 1930

• Turing publica resultados sobre computabilidade • A teoria da informação e comutação digital de Shannon

Anos 1940

• Primeiros computadores digitais eletrônicos

Anos 1950

• Primeiras linguagens de programação simbólicas • Transistores tornam os computadores menores, mais rápidos, mais duráveis e menos caros • Surgimento de aplicativos de processamento de dados

1960-1975

• Circuitos integrados aceleram a miniaturização do hardware • Primeiros minicomputadores • Sistemas operacionais de tempo compartilhado • Interfaces com o usuário interativas com teclado e monitor • Proliferação de linguagens de programação de alto nível • O surgimento de uma indústria de software e o estudo acadêmico da ciência da computação

1975-1990

• Primeiros microcomputadores e computadores pessoais produzidos em massa • As interfaces gráficas com o usuário tornam-se generalizadas • Redes e Internet

1990-2000

• Armazenamento óptico para aplicativos multimídia, imagens, som e vídeo • World Wide Web, aplicativos Web e comércio eletrônico • Laptops

2000-presente

• Computação sem fio, smartphones e aplicativos móveis • Computadores integrados e conectados em rede em uma enorme variedade de carros, eletrodomésticos e equipamentos industriais • Redes sociais, uso de big data em finanças e comércio • Transmissão digital de música e vídeo

Figura 1-4 Resumo dos principais avanços na história da computação

Fundamentos_Python.indb 8

17/10/2022 10:47:56

Introdução

Antes dos computadores digitais eletrônicos

[b] Imagem da calculadora de Pascal © Mary Evans/Photo Researchers, Inc.

[a] Imagem do ábaco © Lim ChewHow, 2008. Usado sob licença da Shutterstock.com.

Os matemáticos antigos desenvolveram os primeiros algoritmos. A palavra “algoritmo” vem do nome de um matemático persa, Muhammad ibn Musa al-Khwarizmi, que escreveu vários livros didáticos de matemática no século IX. Cerca de 2.300 anos atrás, o matemático grego Euclides, o inventor da geometria, desenvolveu um algoritmo para calcular o máximo divisor comum de dois números. Um dispositivo conhecido como ábaco também apareceu nos tempos antigos. O ábaco ajudava as pessoas a realizar aritmética simples. Os usuários calculavam somas e diferenças deslizando contas em uma grade de fios (ver Figura 1-5a). A configuração das contas no ábaco funcionava como os dados.

Figura 1-5 Alguns dos primeiros dispositivos de computação

Fundamentos_Python.indb 9

17/10/2022 10:47:57

Fundamentos de Python: primeiros programas

[c] Imagem do tear de Jacquard © Roger Viollet/Getty Images

Figura 1-5 (Continuação)

No século XVII, o matemático francês Blaise Pascal (1623-1662) construiu um dos primeiros dispositivos mecânicos para automatizar o processo de adição (ver Figura 1-5b). A operação de adição foi incorporada à configuração das engrenagens dentro da máquina. O usuário digitava os dois números a serem somados girando algumas rodas. A soma ou número de saída aparecia em outra roda giratória. O matemático alemão Gottfried Wilhelm Leibniz (1646-1716) construiu outra calculadora mecânica que incluía outras funções aritméticas como a multiplicação. Leibniz, que com Newton também inventou o cálculo infinitesimal, passou a propor a ideia de cálculo com símbolos como uma de nossas atividades intelectuais mais básicas e gerais. Ele defendia uma linguagem universal na qual se poderia resolver qualquer problema por meio de cálculo No início do século XIX, o engenheiro francês Joseph-Marie Jacquard (1752-1834) projetou e construiu uma máquina que automatizava o processo de tecelagem (ver Figura 1-5c). Até então, cada linha em um padrão de tecelagem tinha que ser configurada manualmente, um processo bastante entediante e propenso a erros. O tear de Jacquard foi projetado para aceitar entrada na forma de um conjunto de cartões perfurados. Cada cartão descrevia uma linha em um padrão de tecelagem. Embora ainda fosse um dispositivo totalmente mecânico, o tear de Jacquard possuía algo que os dispositivos anteriores não tinham: a capacidade de executar um algoritmo automaticamente. O conjunto de cartões expressava o algoritmo ou conjunto de instruções que controlavam o comportamento do tear. Se o operador do tear quisesse produzir uma padronagem diferente, ele apenas teria que configurar a máquina como um conjunto diferente de cartões. O matemático britânico Charles Babbage (1792-1871) levou o conceito de computador programável um passo além projetando um modelo de máquina que, conceitualmente, tinha uma notável semelhança com um computador moderno de uso geral. Babbage concebeu sua máquina, que chamou de Máquina Analítica, como um dispositivo mecânico. Seu projeto exigia quatro partes funcionais: um sistema de engrenagens para realizar operações aritméticas, um armazenamento de dados e um programa, um operador para executar as instruções de cartões perfurados e uma saída para produzir os resultados nos cartões. Infelizmente, o computador de Babbage nunca foi construído. O projeto pereceu por falta de fundos quase na mesma época em que o próprio Babbage faleceu.

Fundamentos_Python.indb 10

17/10/2022 10:47:57

Introdução

Nas duas últimas décadas do século XIX, um estatístico do US Census Bureau chamado Herman Hollerith (1860-1929) desenvolveu uma máquina que automatizou o processamento de dados para o censo norte-americano. A máquina de Hollerith, que tinha os mesmos componentes que a máquina analítica de Babbage, simplesmente aceitava um conjunto de cartões perfurados como entrada e então contava e classificava os cartões. Sua máquina encurtou significativamente o tempo necessário para produzir resultados estatísticos sobre a população dos EUA. Organizações governamentais e empresariais que procuram automatizar o processamento de dados adotaram rapidamente as máquinas de cartões perfurados de Hollerith. Hollerith também foi um dos fundadores de uma empresa que acabou se tornando a IBM (International Business Machines). Também no século XIX, o professor de escola secundária britânico George Boole (1815-1864) desenvolveu um sistema de lógica. Esse sistema consistia em um par de valores, TRUE e FALSE e um conjunto de três operações primitivas sobre esses valores, AND, OR e NOT. A lógica booleana acabou se tornando a base para projetar os circuitos eletrônicos para processar informações binárias. Meio século mais tarde, na década de 1930, o matemático britânico Alan Turing (1912-1954) explorou os fundamentos teóricos e os limites dos algoritmos e da computação. As contribuições essenciais de Turing foram desenvolver o conceito de uma máquina universal que poderia ser especializada para resolver quaisquer problemas computáveis e demonstrar que alguns problemas não podem ser solucionados por computadores.

Os primeiros computadores digitais eletrônicos (1940-1950) No final da década de 1930, Claude Shannon (1916-2001), matemático e engenheiro elétrico do MIT, escreveu um artigo clássico intitulado “A Symbolic Analysis of Relay and Switching Circuits”. Nesse artigo, ele mostrou como operações e informações em outros sistemas, como aritmética, poderiam ser reduzidas à lógica booleana e então ao hardware. Por exemplo, se os valores booleanos TRUE e FALSE fossem escritos como os dígitos binários 1 e 0, seria possível escrever uma sequência de operações lógicas que calcularia a soma de duas strings de dígitos binários. Tudo o que era necessário para construir um computador digital eletrônico era a capacidade de representar dígitos binários como interruptores do tipo liga/desliga e representar as operações lógicas em outros circuitos. As necessidades dos combatentes na Segunda Guerra Mundial aceleraram o desenvolvimento de hardware de computador. Várias equipes de cientistas e engenheiros nos Estados Unidos, Inglaterra e Alemanha criaram de maneira independente a primeira geração de computadores eletrônicos digitais de uso geral durante a década de 1940. Todos esses cientistas e engenheiros utilizaram a inovação de Shannon de expressar dígitos binários e operações lógicas em termos de dispositivos de comutação eletrônica. Entre esses grupos estava uma equipe da Universidade de Harvard sob a direção de Howard Aiken. O computador, chamado Mark I, tornou-se operacional em 1944 e fez trabalhos matemáticos para a Marinha dos Estados Unidos durante a guerra. O Mark I era considerado um dispositivo eletromecânico porque utilizava uma combinação de ímãs, relés e engrenagens para armazenar e processar dados. Outra equipe liderada por J. Presper Eckert e John Mauchly, da Universidade da Pensilvânia, produziu um computador chamado ENIAC (Electronic Numerical Integrator and Calculator). O ENIAC calculava tabelas balísticas para a artilharia do Exército dos EUA no final da guerra. Como o ENIAC utilizava componentes inteiramente eletrônicos, era quase mil vezes mais rápido que o Mark I. Dois outros computadores digitais eletrônicos foram concluídos um pouco antes do ENIAC. Eram o ABC (Atanasoff-Berry Computer), construído por John Atanasoff e Clifford Berry na Iowa State University em 1942 e o Colossus, construído por um grupo que trabalhou com Alan Turing na Inglaterra em 1943. O ABC foi criado para resolver sistemas de equações lineares simultâneas. Embora a função do ABC fosse muito mais restrita que a do ENIAC, o ABC é hoje considerado o primeiro computador digital eletrônico. O Colossus, cuja existência foi mantida supersecreta até recentemente, foi utilizado para decifrar o poderoso código alemão Enigma durante a guerra. Os primeiros computadores digitais eletrônicos, às vezes chamados computadores mainframe, consistiam em válvulas termiônicas, fios e conectores elétricos, e ocupavam salas inteiras. Embora fossem muito mais rápidos que os cálculos feitos por pessoas, de acordo com nossos próprios padrões atuais, eram

Fundamentos_Python.indb 11

17/10/2022 10:47:57

Fundamentos de Python: primeiros programas

extraordinariamente lentos e propensos a falhas. Além disso, os primeiros computadores eram extremamente dif íceis de programar. Para inserir ou modificar um programa, uma equipe de trabalhadores precisava reorganizar as conexões entre válvulas desconectando e reconectando os fios. Cada programa era carregado conectando-o fisicamente ao computador. Com milhares de fios envolvidos, era fácil cometer um erro. A memória desses primeiros computadores armazenava apenas dados, não o programa que processava os dados. Como vimos, a ideia de um programa armazenado apareceu pela primeira vez 100 anos antes no tear de Jacquard e no projeto de Babbage para a máquina analítica. Em 1946, John von Neumann percebeu que as instruções dos programas também poderiam ser armazenadas em formato binário na memória de um computador digital eletrônico. Seu grupo de pesquisa em Princeton desenvolveu um dos primeiros computadores modernos com programas armazenados. Embora o tamanho, a velocidade e os aplicativos dos computadores tenham mudado drasticamente desde aqueles primeiros dias, a arquitetura básica e o design do computador digital eletrônico permaneceram notavelmente estáveis.

As primeiras linguagens de programação (1950-1965) O usuário típico de computador agora executa muitos programas, compostos de milhões de linhas de código, que realizam o que pareciam tarefas mágicas 30 ou 40 anos atrás. Mas os primeiros computadores eletrônicos digitais não tinham software como pensamos hoje. O código de máquina para alguns aplicativos relativamente simples e pequenos tinha de ser carregado manualmente. À medida que crescia a demanda por aplicativos maiores e mais complexos, crescia também a necessidade de ferramentas para agilizar o processo de programação. No início da década de 1950, cientistas da computação perceberam que uma notação simbólica poderia ser utilizada em vez de código de máquina e as primeiras linguagens assembly (montadoras) apareceram. Os programadores inseriam códigos mnemônicos para operações, como ADD e OUTPUT e para variáveis de dados, como SALARY e RATE, em uma máquina perfuradora de cartões. O pressionamento de teclas criava um conjunto de furos em um pequeno cartão para cada instrução. Os programadores então levavam as pilhas de cartões para um operador de sistema, que os inseriam em um dispositivo chamado leitor de cartão. Este dispositivo convertia os furos nos cartões em padrões na memória do computador. Um programa chamado assembler, em seguida, convertia os programas aplicativos na memória em código de máquina, e eram executados. A programação em linguagem assembly foi uma melhoria definitiva em relação à programação em código de máquina. A notação simbólica utilizada em linguagens assembly era mais fácil para as pessoas lerem e entenderem. Outra vantagem era que o assembler podia detectar alguns erros de programação antes que o programa fosse realmente executado. Mas a notação simbólica ainda parecia um pouco misteriosa em comparação às notações da matemática convencional. Para remediar esse problema, John Backus, programador da IBM, desenvolveu o FORTRAN (Formula Translation Language) em 1954. Os programadores, muitos dos quais eram matemáticos, cientistas e engenheiros, agora podiam utilizar a notação algébrica convencional. Programadores de FORTRAN ainda inseriam seus programas em uma máquina perfuradora de cartões, mas o computador executava-os depois que eram convertidos em código de máquina por um compilador. O FORTRAN foi considerado ideal para aplicações numéricas e científicas. Mas expressar o tipo de dados utilizados no processamento de dados — em particular, informações textuais — era dif ícil. Por exemplo, não era prático para processar informações que incluíam nomes, endereços, números de previdência social das pessoas e os dados financeiros de empresas e outras instituições. No início da década de 1960, uma equipe liderada pela contra-almirante Grace Murray Hopper desenvolveu o COBOL (Common Business Oriented Language) para processamento de dados no governo dos EUA. Bancos, seguradoras e outras instituições rapidamente adotaram seu uso em aplicativos de processamento de dados. Também no final dos anos 1950 e início dos anos 1960, John McCarthy, cientista da computação do MIT, desenvolveu uma notação poderosa e elegante chamada LISP (List Processing) para expressar cálculos. Com base em uma teoria de funções recursivas (um tema abordado no Capítulo 6), o LISP capturou a essência do processamento de informações simbólicas. Um aluno de McCarthy, Steve “Slug” Russell, codificou o

Fundamentos_Python.indb 12

17/10/2022 10:47:57

Introdução

primeiro interpretador para LISP em 1960. O interpretador aceitava as expressões LISP diretamente como entradas, as avaliava e imprimia seus resultados. Em seus primeiros dias, o LISP foi utilizado principalmente para experimentos laboratoriais em uma área de pesquisa conhecida como inteligência artificial. Mais recentemente, o LISP foi apontado como uma linguagem ideal para resolver quaisquer problemas dif íceis ou complexos. Embora estivessem entre as primeiras linguagens de programação de alto nível, FORTRAN e LISP sobreviveram por décadas. Eles passaram por muitas modificações para melhorar suas capacidades e serviram como modelos para o desenvolvimento de muitas outras linguagens de programação. O COBOL, por outro lado, não está mais em uso ativo, mas sobreviveu principalmente na forma de programas legados que ainda precisam ser mantidos. Essas novas linguagens de programação de alto nível tinham um recurso em comum: abstração. Na ciência ou em qualquer outra área de pesquisa, uma abstração permite que os seres humanos reduzam ideias ou entidades complexas a outras mais simples. Por exemplo, um conjunto de dez instruções em linguagem assembly pode ser substituído por uma expressão algébrica equivalente que consiste em apenas cinco símbolos em FORTRAN. Dito de outra forma, sempre que se pode dizer mais com menos, está sendo utilizada uma abstração. O uso da abstração também é encontrado em outras áreas da computação, como design de hardware e arquitetura da informação. As complexidades na verdade não desaparecem, mas as abstrações as ocultam. A supressão da complexidade perturbadora com abstrações permite que os cientistas da computação conceituem, projetem e construam sistemas cada vez mais sofisticados e complexos.

Circuitos integrados, interação e compartilhamento de tempo (1965-1975) No final da década de 1950, a válvula deu lugar ao transistor como o mecanismo para implementar os interruptores eletrônicos no hardware de computador. Como um dispositivo de estado sólido, o transistor era muito menor, mais confiável, mais durável e menos caro de fabricar do que uma válvula termiônica. Consequentemente, em geral, os dos componentes de hardware dos computadores diminuiu e eles se tornaram menores, mais confiáveis e menos caros. Quanto menores e mais numerosos os interruptores se tornavam, mais rápido o processamento e maior a capacidade da memória para armazenar informações. O desenvolvimento do circuito integrado no início da década de 1960 permitiu que os engenheiros de computação construíssem componentes de hardware de computador cada vez menores, mais rápidos e menos caros. Eles aperfeiçoaram um processo de gravação fotográfica de transistores e outros componentes de estado sólido em pastilhas muito finas de silício, montando todo o processador e a memória em um único chip. Em 1965, Gordon Moore, um dos fundadores da fabricante de chips de computador Intel, fez uma previsão que ficou conhecida como lei de Moore. Essa previsão afirma que a velocidade de processamento e a capacidade de armazenamento do hardware aumentarão e seu custo se reduzirá à metade a cada 18 meses. Essa tendência se mantém há mais de 50 anos. Por exemplo, em 1965 havia cerca de 50 componentes elétricos em um chip, enquanto em 2000 um chip poderia conter mais de 40 milhões de componentes. Sem o circuito integrado, os homens não teriam ido à lua em 1969 e não teríamos os dispositivos portáteis poderosos e baratos que hoje utilizamos diariamente. Minicomputadores do tamanho de uma grande mesa de escritório surgiram na década de 1960. Os meios de desenvolver e executar programas também estavam mudando. Até então, um computador costumava estar localizado em uma área restrita com um único operador humano. Os programadores compunham seus programas em máquinas perfuradoras de cartão em outra sala ou prédio. Eles então entregavam as pilhas de cartões ao operador do computador, que os carregava em um leitor de cartões, compilava e executava os programas em sequência no computador. Os programadores então voltavam para pegar os resultados da saída, na forma de novas pilhas de cartões ou listagens. Esse modo de operação, também chamado processamento em lote, poderia fazer que um programador esperasse dias pelos resultados, incluindo mensagens de erro. A maior velocidade de processamento e capacidade de memória permitiu que os cientistas da computação desenvolvessem o primeiro sistema operacional de compartilhamento de tempo. John McCarthy, o criador da linguagem de programação LISP, reconheceu que um programa poderia automatizar muitas das funções executadas pelo operador humano do sistema. Quando a memória, incluindo o armazenamento

Fundamentos_Python.indb 13

17/10/2022 10:47:57

Fundamentos de Python: primeiros programas

secundário magnético, tornou-se grande o suficiente para armazenar vários programas dos usuários ao mesmo tempo, eles poderiam ser agendados para processamento concorrente. Cada processo associado a um programa seria executado por uma fatia de tempo e, em seguida, entregaria a CPU a outro processo. Todos os processos ativos rodariam repetidamente para um turno com a CPU até terminarem. Vários usuários agora poderiam executar seus próprios programas simultaneamente digitando comandos em terminais separados conectados a um único computador. À medida que as velocidades dos processadores continuavam a aumentar, cada usuário ganhava a ilusão de que um sistema de computador de compartilhamento de tempo pertencia inteiramente a ele. No final da década de 1960, os programadores podiam inserir a entrada do programa em um terminal e também ver a saída do programa exibida imediatamente em um monitor CRT (Cathode Ray Tube). Comparado com seus antecessores, esse novo sistema de computador era altamente interativo e muito mais acessível aos usuários. Muitas instituições relativamente pequenas e médias, como universidades, agora podiam arcar com o custo da aquisição de computadores. Essas máquinas foram utilizadas não apenas para processamento de dados e aplicações de engenharia, mas também para ensino e pesquisa no novo e crescente campo da ciência da computação.

Computadores pessoais e redes (1975-1990) Em meados da década de 1960, Douglas Engelbart, cientista da computação que trabalhava no Stanford Research Institute (SRI), viu pela primeira vez uma das implicações derradeiras da Lei de Moore: com o tempo, talvez em uma geração, os componentes de hardware se tornariam pequenos e acessíveis o suficiente para produzir em massa um computador individual para cada ser humano. Que forma esses computadores pessoais teriam, e como seus proprietários os utilizariam? Duas décadas antes, em 1945, Engelbart havia lido um artigo no The Atlantic Monthly intitulado “As We May Think” que já havia feito essa pergunta e oferecia algumas respostas. O autor, Vannevar Bush, cientista do MIT, previu que os dispositivos de computação funcionariam como repositórios de informações e, em última análise, de todo o conhecimento humano. Os proprietários de dispositivos de computação consultariam essas informações navegando por elas com dispositivos apontadores e contribuiriam com informações para a base de conhecimento com quase total liberdade. Engelbart concordou que o principal objetivo do computador pessoal seria aumentar o intelecto humano e passou o resto de sua carreira projetando sistemas de computador que alcançariam esse objetivo. Durante o final da década de 1960, Engelbart construiu o primeiro dispositivo apontador, ou mouse. Ele também projetou software para representar janelas, ícones e menus suspensos em um monitor de mapa de bits. Ele demonstrou que um usuário de computador poderia não apenas digitar texto no teclado, mas também manipular diretamente os ícones que representavam arquivos, pastas e aplicativos de computador na tela. Para Engelbart, computação pessoal não significava computação isolada. Ele participou do primeiro experimento para conectar computadores a uma rede e acreditava que em breve as pessoas utilizariam computadores para se comunicar, compartilhar informações e colaborar em projetos em equipe. Engelbart desenvolveu seu primeiro sistema experimental, que ele chamou NLS (oNLine System) Augment, em um minicomputador no SRI. No início da década de 1970, mudou-se para o Xerox PARC (Palo Alto Research Center) e trabalhou com uma equipe de Alan Kay para desenvolver o primeiro sistema de computador desktop. Chamado de Alto, esse sistema tinha muitos dos recursos do Augment de Engelbart, bem como e-mail e hipertexto funcional (um precursor da World Wide Web). O grupo de Kay também desenvolveu uma linguagem de programação chamada Smalltalk, projetada para criar programas para o novo computador e ensinar programação para crianças. O objetivo de Kay era desenvolver um computador pessoal do tamanho de um notebook grande, que ele chamou Dynabook. Infelizmente para a Xerox, a administração da empresa tinha mais interesse em fotocopiadoras do que no trabalho do visionário grupo de pesquisa de Kay. Entretanto, um jovem empresário chamado Steve Jobs visitou o laboratório da Xerox e viu o Alto em ação. Quase uma década mais tarde, em 1984, a Apple Computer, a agora famosa empresa fundada por Steve Jobs, lançou o Macintosh, o primeiro computador pessoal bem-sucedido produzido em massa com uma interface gráfica com o usuário.

Fundamentos_Python.indb 14

17/10/2022 10:47:57

Introdução

Enquanto o grupo de Kay estava ocupado construindo o sistema de computador do futuro em seu laboratório de pesquisa, dezenas de amadores se reuniram perto de São Francisco para fundar o Homebrew Computer Club, o primeiro grupo de usuários de computadores pessoais. Eles se reuniam para compartilhar ideias, programas, hardware e aplicativos para computação pessoal. O primeiro computador pessoal produzido em massa, o Altair, apareceu em 1975. O Altair continha o processador 8080 da Intel, o primeiro chip microprocessador. Mas do lado de fora, o Altair parecia e se comportava mais como uma versão em miniatura dos primeiros computadores do que como o Alto. Os programas e as entradas tinham de ser inseridos por meio de interruptores e a saída era exibida por um conjunto de luzes. Mas o Altair era pequeno o suficiente para os entusiastas da computação pessoal levarem para casa e os dispositivos de entrada/saída acabaram sendo inventados para suportar o processamento de texto e som. O Osborne e o Kaypro estavam entre os primeiros computadores pessoais interativos produzidos em massa. Eles ostentavam telas e teclados minúsculos, com unidades de disquete para carregar o software do sistema, software de aplicativos e arquivos de dados dos usuários. Os primeiros aplicativos de computação pessoal eram processadores de texto, planilhas e jogos como Pac-Man e Spacewar!. Esses computadores também rodavam o CP/M (programa de controle para microcomputadores), o primeiro sistema operacional baseado em PC. No início da década de 1980, um estudante que tinha abandonado a faculdade chamado Bill Gates e seu parceiro Paul Allen construíram seu próprio software de sistema operacional, que chamaram MS-DOS (Microsoft Disk Operating System). Eles então fizeram um acordo com a gigante fabricante de computadores IBM para fornecer o MS-DOS para a nova linha de PCs que a empresa pretendia produzir em massa. O acordo revelou-se muito vantajoso para a empresa de Gates, a Microsoft. A Microsoft não apenas recebia uma taxa por computador vendido, mas também tinha uma vantagem competitiva para fornecer softwares aplicativos que seriam executados em seu sistema operacional. As vendas rápidas do IBM PC e seus “clones” para indivíduos e instituições rapidamente tornaram o MS-DOS o sistema operacional mais utilizado no mundo. Em poucos anos, Gates e Allen se tornaram bilionários e, em uma década, Gates se tornou o homem mais rico do mundo, posição que ocupou por 13 anos consecutivos. Também na década de 1970, o governo norte-americano passou a apoiar o desenvolvimento de uma rede que conectaria computadores em instalações militares e universidades de pesquisa. A primeira dessas redes, chamada ARPANET (Advanced Research Projects Agency Network), conectava quatro computadores no SRI, UCLA (Universidade da Califórnia em Los Angeles), UC Santa Barbara e na Universidade de Utah. Bob Metcalfe, pesquisador associado ao grupo de Kay na Xerox, desenvolveu um protocolo de software chamado Ethernet para operar uma rede de computadores. A Ethernet permitia que os computadores se comunicassem em uma rede local (LAN) dentro de uma organização e também com computadores em outras organizações através de uma rede de longa distância (WAN). Em meados da década de 1980, a ARPANET havia se tornado o que hoje conhecemos como Internet, conectando computadores pertencentes a grandes instituições, pequenas organizações e pessoas em todo o mundo.

Consulta, comunicação e comércio eletrônico (1990-2000) Na década de 1990, os custos de hardware continuaram a cair e a velocidade de processamento e a capacidade de memória dispararam. Meios de armazenamento óptico, como discos compactos (CDs) e discos de vídeo digital (DVDs), foram desenvolvidos para armazenamento em massa. Digitalização e processamento computacional de imagens, som e vídeo tornaram-se viáveis e difundidos. No final da década, filmes inteiros estavam sendo produzidos ou construídos e reproduzidos utilizando dispositivos digitais. Toy Story, o primeiro longa-metragem de animação produzido inteiramente por computador, foi lançado em 1995. A capacidade de criar animações tridimensionais realistas de ambientes inteiros levou a uma nova tecnologia chamada realidade virtual. Surgiram novos dispositivos, como scanners de mesa e câmeras digitais, que podiam ser utilizados com os microfones e alto-falantes mais tradicionais para dar suporte à entrada, digitalização e saída de quase qualquer tipo de informação. Computadores de mesa e laptops agora não apenas realizam um trabalho útil, mas também oferecem aos usuários novos meios de expressão pessoal. A década viu o surgimento dos computadores como ferramentas de comunicação, com e-mail, mensagens instantâneas, quadros de avisos, salas de bate-papo e a World Wide Web.

Fundamentos_Python.indb 15

17/10/2022 10:47:58

Fundamentos de Python: primeiros programas

Talvez a história mais interessante desse período seja a de Tim Berners-Lee, o criador da World Wide Web. No final da década de 1980, Berners-Lee, um f ísico teórico que fazia pesquisas no Instituto CERN em Genebra, Suíça, começou a desenvolver algumas ideias para utilizar computadores a fim de compartilhar informações. Engenheiros de computação conectavam computadores a redes havia vários anos e já era comum em comunidades de pesquisa trocar arquivos e enviar e receber e-mails em todo o mundo. Mas as amplas diferenças de hardware, sistemas operacionais, formatos de arquivo e aplicativos ainda dificultavam o acesso e o compartilhamento dessas informações para usuários não adeptos da programação. Berners-Lee estava interessado em criar um meio comum de compartilhamento de informações que fosse fácil de utilizar, não apenas para cientistas, mas também para qualquer outra pessoa capaz de manipular um teclado e mouse e visualizar as informações em um monitor. Berners-Lee estava familiarizado com a visão de Vannevar Bush de um sistema de consulta semelhante a uma teia, o trabalho de Engelbart no NLS Augment e também com os primeiros sistemas de hipertexto amplamente disponíveis. Um desses sistemas, o HyperCard da Apple Computer, ampliou o escopo do hipertexto para hipermídia. O HyperCard permitia que os autores organizassem não apenas texto, mas também imagens, som, vídeo e aplicativos executáveis em redes de informações vinculadas. Entretanto, um banco de dados HyperCard só era utilizado em computadores autônomos; os links não podiam transportar dados do HyperCard de um computador para outro. Além disso, o software de suporte funcionava apenas nos computadores da Apple. Berners-Lee percebeu que as redes poderiam estender o alcance de um sistema de hipermídia a qualquer computador conectado à rede, disponibilizando suas informações em todo o mundo. Para preservar sua independência de sistemas operacionais específicos, o novo meio precisaria ter padrões universais para distribuir e apresentar as informações. Para garantir essa neutralidade e independência, nenhuma corporação privada ou governo individual poderia possuir o meio ou ditar os padrões. Berners-Lee construiu o software para esse novo meio, que agora chamamos World Wide Web, em 1992. O software utilizava muitos dos mecanismos existentes para transmitir informações pela Internet. As pessoas contribuem com informações para a Web publicando arquivos em computadores conhecidos como servidores Web. O software do servidor Web nesses computadores é responsável por responder às solicitações de visualização das informações armazenadas no servidor Web. Para visualizar informações na Web, as pessoas utilizam um software chamado navegador Web. Em resposta aos comandos de um usuário, um navegador Web envia uma solicitação de informações pela Internet para o servidor Web apropriado. O servidor responde enviando as informações de volta ao computador do navegador, chamado cliente Web, onde é exibido ou renderizado no navegador. Embora Berners-Lee tenha escrito o primeiro software de servidor e navegador da Web, ele fez duas outras contribuições ainda mais importantes. Primeiro, ele projetou um conjunto de regras, chamado HTTP (Hypertext Transfer Protocol), que permite que qualquer servidor e navegador conversem entre si. Depois, ele projetou uma linguagem, HTML (Hypertext Markup Language), que permite que os navegadores estruturem as informações a serem exibidas nas páginas da Web. Ele então disponibilizou todos esses recursos gratuitamente para qualquer pessoa. A invenção e a contribuição de Berners-Lee desse meio de informação universal é uma conquista verdadeiramente notável. Hoje existem milhões de servidores Web em operação em todo o mundo. Qualquer pessoa com treinamento e recursos apropriados — empresas, governo, organizações sem fins lucrativos e indivíduos — pode iniciar um novo servidor Web ou obter espaço em um. O software do navegador Web agora é executado não apenas em computadores de mesa e laptops, mas também em dispositivos portáteis, como telefones celulares. O crescimento da Internet, da Web e das tecnologias de software relacionadas também transformaram a indústria, o comércio e as finanças na segunda metade desta década. A automação suportada por computador aumentou drasticamente a produtividade (ao mesmo tempo em que eliminou empregos com altos salários para muitas pessoas). As empresas estabeleceram e refinaram as cadeias de produção e distribuição de mercadorias, de matérias-primas a produtos acabados e vendas no varejo, que eram cada vez mais eficazes em termos de custo e alcance global. A tecnologia computacional facilitou em grande parte a disseminação de grandes lojas gigantes como o Walmart e o surgimento de lojas on-line como a Amazon

Fundamentos_Python.indb 16

17/10/2022 10:47:58

Introdução

(ao mesmo tempo que tirava muitos varejistas locais do negócio, criava uma força de trabalho em tempo parcial sem benef ícios). A tecnologia que tornou as lojas on-line difundidas, chamada aplicativos Web, apresentou uma revolução na forma como os serviços de software eram entregues às pessoas. Em vez de comprar e executar software para aplicativos específicos que seriam executados no próprio computador, tornou-se possível obter acesso a um serviço específico por meio de um navegador Web. O aplicativo Web que fornece esse serviço era executado em um computador remoto ou servidor localizado na empresa do fornecedor. O navegador Web desempenhava o papel do cliente, front-end ou interface com o usuário para que milhões de usuários acessassem o mesmo aplicativo de servidor para determinado serviço. Aplicativos cliente/servidor já estavam em uso para e-mail, boletins eletrônicos e salas de bate-papo na Internet, então essa tecnologia foi simplesmente implantada na Web quando esta tornou-se disponível. O grande avanço final desta década ocorreu em um laboratório de informática da Universidade de Stanford, onde dois estudantes de pós-graduação, Sergey Brin e Larry Page, desenvolveram algoritmos para indexação e pesquisa na Web. O resultado de seu trabalho acrescentou um novo verbo ao dicionário: “googlar”. Hoje, grande parte da economia e pesquisa do mundo depende das várias plataformas de pesquisa do Google.

Aplicativos móveis e computação onipresente (2000-presente) À medida que o final do milênio anterior se aproximava, o hardware de computador continuava a diminuir em termos de tamanho e custo, além de fornecer mais memória e maior velocidade de processamento. Laptops tornaram-se menores, mais rápidos e mais acessíveis para milhões de pessoas. Os primeiros dispositivos de computação de mão, chamados assistentes digitais pessoais (PDAs) começaram a aparecer. Os aplicativos para esses dispositivos limitavam-se a videogames simples, catálogos de endereços, listas de tarefas e anotações e precisavam ser conectados via cabo a um laptop ou computador de mesa para transferir informações. Enquanto isso, a tecnologia celular se generalizou, com milhões de pessoas começando a utilizar os primeiros telefones celulares. Esses dispositivos, que permitiam fazer chamadas a partir de um simples teclado mecânico, eram “burros” em comparação aos smartphones atuais. Mas a tecnologia celular forneceu a base para o que estava por vir. Mais ou menos na mesma época, a tecnologia sem fio começou a permitir que os computadores se comunicassem pelo ar com uma estação base utilizando uma conexão com a Internet. As condições para a computação móvel e onipresente estavam agora estabelecidas, aguardando apenas os tipos de dispositivos e aplicativos que os tornariam úteis e populares. Ninguém previu os tipos de dispositivos e aplicativos que a computação móvel tornaria possível melhor que Steve Jobs (o fundador da Apple Computer, mencionado anteriormente). Nos últimos 12 anos de vida, Jobs trouxe da Apple vários dispositivos e tecnologias que revolucionaram não apenas a computação, mas também a maneira como as pessoas se envolviam com atividades culturais. Os dispositivos eram o iPod, que começou como um tocador de música digital, mas evoluiu para um dispositivo de computação portátil de uso geral; o iPhone, que adicionou tecnologia de telefonia celular às capacidades do iPod; e o iPad, que realizou os sonhos de Alan Kay de um notebook pessoal. Todos esses dispositivos utilizavam tela sensível ao toque e tecnologia de reconhecimento de voz, o que eliminou a necessidade de teclados mecânicos volumosos. As tecnologias de software associadas vieram na forma do pacote iLife da Apple, um conjunto de aplicativos que permitia aos usuários organizar vários tipos de mídia (música, fotos, vídeos e livros); e iTunes, iBooks e App Stores da Apple, sites de fornecedores que permitiam aos desenvolvedores comercializar mídia e aplicativos móveis. O navegador Web que durante uma década deu aos usuários acesso a aplicativos Web tornou-se apenas mais um tipo de aplicativo no mundo maior da computação móvel. O novo milênio viu outra importante adição ao cenário digital: aplicativos de rede social. Embora vários fóruns da Internet, como salas de bate-papo e sistemas de quadro de avisos (BBSs), estivessem em uso por algumas décadas, seu uso não era generalizado. Em 2004, Mark Zuckerberg, um estudante da Universidade de Harvard, mudou tudo isso quando lançou o Facebook a partir do seu dormitório na faculdade. O aplicativo permitia que os alunos participassem de uma rede para compartilhar seus perfis, postar mensagens, fotos e vídeos e, geralmente, se comunicar como “amigos”. A participação nessa rede se disseminou

Fundamentos_Python.indb 17

17/10/2022 10:47:58

Fundamentos de Python: primeiros programas

rapidamente para incluir mais de um bilhão de usuários. A tecnologia de rede social agora inclui muitas outras variações, como exemplificado pelo LinkedIn, Twitter, Tumblr, Flickr e Instagram. Concluímos esta não tão breve visão geral mencionando o surgimento de uma tecnologia conhecida como big data. Governos, empresas e hackers monitoram continuamente o tráfego da Internet com diversos propósitos. Esse “fluxo de cliques” pode ser “minerado” para conhecer as preferências e interesses dos usuários, para melhor atendê-los, explorá-los ou espioná-los. Por exemplo, uma loja on-line pode anunciar um produto na página do Facebook de uma pessoa imediatamente após essa pessoa visualizar um produto semelhante enquanto faz compras on-line. Pesquisadores da área de ciência de dados criaram algoritmos que processam grandes quantidades de dados para descobrir tendências e prever resultados. Para resumir essa história não tão breve, uma tendência une as últimas décadas da computação: o progresso rápido. Processos e coisas tornaram-se automatizados, programáveis, menores, mais rápidos, altamente interconectados e facilmente visualizados e interpretados. Se você quer saber mais sobre a história da computação, consulte as fontes listadas no final deste capítulo. Passamos agora a uma introdução à programação no Python.

Introdução à programação em Python Guido van Rossum inventou a linguagem de programação Python no início dos anos 1990. Python é uma linguagem de programação de alto nível e de uso geral para resolver problemas em sistemas de computadores modernos. A linguagem e muitas ferramentas de suporte são gratuitas e os programas Python podem ser executados em qualquer sistema operacional. Você pode baixar o Python, sua documentação e materiais relacionados em www.python.org. As instruções para baixar e instalar o Python estão no Apêndice A. Nesta seção, mostramos como criar e executar programas Python simples.

Execução do código no shell interativo Python é uma linguagem interpretada e você pode executar expressões e instruções Python simples em um ambiente de programação interativo chamado shell. A maneira mais fácil de abrir um shell do Python é iniciar o IDLE (Integrated DeveLopment Environment). É um ambiente de desenvolvimento integrado de programas que vem com a instalação do Python. Ao fazer isso, uma janela chamada Shell Python se abre. A Figura 1-6 mostra uma janela de shell no macOS. Uma janela de shell em execução em um sistema Windows ou Linux deve ser semelhante, se não idêntica, a essa. Observe que a versão do Python que aparece nesta captura de tela é 3.6.1. Este livro pressupõe que você utilizará o Python 3 em vez do Python 2. Há diferenças substanciais entre as duas versões e muitos exemplos utilizados neste livro não funcionarão com o Python 2.

Figura 1-6 Janela de shell do Python

Uma janela de shell contém uma mensagem de abertura seguida pelo símbolo especial >>>, chamado prompt do shell. O cursor no prompt do shell espera que você digite um comando Python. Observe que você pode obter ajuda imediata digitando help no prompt de shell ou selecionando Help no menu suspenso da janela.

Fundamentos_Python.indb 18

17/10/2022 10:47:58

Introdução

Quando você insere uma expressão ou instrução, o Python a avalia e exibe o resultado, se houver algum, seguido por um novo prompt. As próximas linhas mostram a avaliação de várias expressões e instruções. >>> 3 + 4 7 >>> 3 3 >>> "Python is really cool!" 'Python is really cool!' >>> name = "Ken Lambert" >>> name 'Ken Lambert' >>> "Hi there, " + name 'Hi there, Ken Lambert' >>> print('Hi there') Hi there >>> print("Hi there,", name) Hi there, Ken Lambert

# Aritmética simples # O valor de 3 é # Usa uma string para texto

# Dá um valor a uma variável # O valor name é # Cria um novo texto # Saída de algum texto # Saída de dois valores

Observe os diferentes tons de cinza no código Python. O ambiente de programação IDLE utiliza codificação em cores – aqui representadas por diferentes tonalidades de cinza – para ajudar o leitor a escolher diferentes elementos no código. Neste exemplo, os itens entre aspas aparecem, no ambiente de programação IDLE, em verde, os nomes das funções padrão aparecem em roxo, os comentários do programa aparecem em vermelho e as respostas do IDLE aos comandos do usuário aparecem em azul. O código restante aparece em preto. A Tabela 1-1 lista o esquema de codificação em cores utilizado em todos os códigos de programa em IDLE, representadas por diferentes tons de cinza neste livro. Cor

Tipo de elemento

Exemplos

Preto

Entradas no shell IDLE Números Símbolos de operador Referências de variáveis, funções e métodos Sinais de pontuação

67, +, name, y = factorial(x)

Azul

Saídas no shell IDLE Nomes de funções, classes e métodos nas definições

'Ken Lambert', def factorial(n)

Verde

Strings

"Ken Lambert"

Laranja

Palavras-chave

def, if, while

Roxo

Nomes de funções integrados

abs, round, int

Vermelho

Comentários do programa Mensagens de erro no shell IDLE

# Gera a saída dos resultados ZeroDivisionError: division by zero

Tabela 1-1

Codificação em cores dos elementos de programa Python no IDLE

O shell do Python é útil ao experimentar expressões ou instruções curtas para entender novos recursos da linguagem, bem como para consultar a documentação da linguagem. Para sair do shell Python, você pode selecionar a caixa de fechamento da janela ou pressionar a combinação de teclas Control1D. Os meios de desenvolver programas mais complexos e interessantes são examinados no restante desta seção.

Fundamentos_Python.indb 19

17/10/2022 10:47:58

Fundamentos de Python: primeiros programas

Entrada, processamento e saída

A maioria dos programas úteis aceita entradas de alguma fonte, processa essas entradas e, por fim, envia os resultados para algum destino. Em programas interativos baseados em terminal, a fonte de entrada é o teclado e o destino de saída é a tela do terminal. O próprio shell do Python é um desses programas; as entradas são expressões ou instruções Python. O processamento avalia esses itens. As saídas são os resultados exibidos no shell. O programador também pode forçar a saída de um valor utilizando a função print. A forma mais simples para utilizar essa função é a seguinte: print(<expressão>)

O exemplo mostra a sintaxe (ou regra gramatical) básica para utilizar a função print. Os colchetes angulares (os símbolos < e >) incluem um tipo de sentença. No código Python real, você substituiria essa forma sintática, incluindo os colchetes angulares, por um exemplo desse tipo de sentença. Nesse caso, <expressão> é uma abreviação para qualquer expressão Python, 3 + 4. Ao executar a função print, o Python primeiro avalia a expressão e, em seguida, exibe o valor. No exemplo mostrado anteriormente, print foi utilizada para exibir algum texto. Eis outro exemplo: >>> print ("Hi there") Hi there

Nesse exemplo, o texto "Hi there" é o texto que queremos que o Python exiba. Na terminologia de programação, esse fragmento de texto chama-se string. No código Python, uma string é sempre colocada entre aspas. Mas a função print exibe uma string sem as aspas. Você também pode escrever uma função print que inclui duas ou mais expressões separadas por vírgulas. Nesse caso, a função print avalia as expressões e exibe os resultados, separados por espaços simples, em uma única linha. A sintaxe de uma instrução print com duas ou mais expressões se parece com isto: print(<expressão>,..., <expressão>)

Observe as reticências (...) nesse exemplo de sintaxe. As reticências indicam que você pode incluir várias expressões após a primeira. Qualquer que seja a saída, com uma ou várias expressões, a função print sempre a termina com uma nova linha. Em outras palavras, ela exibe os valores das expressões e, em seguida, move o cursor para a próxima linha na janela de console. Para iniciar a próxima saída na mesma linha da anterior, você pode colocar a expressão end= "", que instrui “terminar a linha com uma string vazia em vez de uma nova linha”, no final da lista de expressões, como a seguir: print(<expression>, end = "")

À medida que você cria programas em Python, muitas vezes quer que seus programas solicitem a entrada do usuário. Você pode fazer isso utilizando a função input. Essa função faz o programa parar e esperar que o usuário insira um valor no teclado. Quando o usuário pressiona a tecla Return ou Enter, a função aceita o valor de entrada e o disponibiliza para o programa. Um programa que recebe um valor de entrada dessa maneira normalmente o salva para processamento adicional. O exemplo a seguir recebe uma string de entrada do usuário e a salva para processamento adicional. A entrada do usuário está em preto. >>> name = input("Enter your name: ") Enter your name: Ken Lambert >>> name Ken Lambert' >>> print(name) Ken Lambert >>>

Fundamentos_Python.indb 20

17/10/2022 10:47:58

Introdução

A função input faz o seguinte: 1. Exibe um prompt para a entrada. Neste exemplo, o prompt é "Enter your name: ". 2. Recebe uma sequência de pressionamentos de tecla, chamados caracteres, inseridos no teclado e retorna a sequência ao shell. Como a função input sabe o que utilizar como prompt? O texto entre parênteses, "Enter your name:", é um argumento para a função input que informa o que utilizar para o prompt. Um argumento são informações necessárias para que uma função realize seu trabalho. A string retornada pela função no nosso exemplo é salva atribuindo-a à variável name. A forma de uma instrução de atribuição com a função input é a seguinte:

<variable identifier> = input(<a string prompt>)

Um identificador de variável, ou variável para abreviar, é apenas um nome para um valor. Quando uma variável recebe o valor em uma instrução de entrada, a variável então referencia esse valor. Se o usuário digitar o nome "Ken Lambert" em nosso último exemplo, o valor da variável name pode ser visualizado como a seguir: >>> name Ken Lambert'

A função input sempre constrói uma string a partir dos pressionamentos de tecla do usuário e a retorna ao programa. Depois de inserir strings que representam números, o programador deve convertê-las de strings para os tipos numéricos apropriados. No Python, existem duas funções de conversão de tipo para esse propósito, chamadas int (para números inteiros) e float (para números de ponto flutuante). A próxima sessão insere dois números inteiros e exibe sua soma: >>> first = int(input("Enter the first number: ")) Enter the first number: 23 >>> second = int(input("Enter the second number: ")) Enter the second number: 44 >>> print("The sum is", first + second) The sum is 67

Observe que a função int é chamada com cada resultado retornado pela função input. Os dois números são adicionados e, em seguida, a soma é enviada para a saída. A Tabela 1-2 resume as funções introduzidas nesta subseção. Função

O que ele faz

float(<uma string de dígitos>)

Converte uma string de dígitos em um valor de ponto flutuante.

int(<uma string de dígitos>)

Converte uma string de dígitos em um valor de número inteiro.

input(<um prompt de string>)

Exibe o prompt de string e espera a entrada do teclado. Retorna a string de caracteres inseridos pelo usuário.

print(<expressão>, ..., <expressão>)

Avalia as expressões e as exibe, separadas por um espaço, na janela de console.

Concatena as duas strings e retorna o resultado.

Tabela 1-2

Fundamentos_Python.indb 21

Funções básicas do Python para entrada e saída

17/10/2022 10:47:58

Fundamentos de Python: primeiros programas

Edição, gravação e execução de um script

Embora seja fácil testar expressões e instruções Python curtas interativamente em um prompt de shell, é mais conveniente compor, editar e salvar programas mais longos e complexos em arquivos. Podemos então executar esses arquivos de programa ou scripts no IDLE ou no prompt de comando do sistema operacional sem abrir o IDLE. Arquivos de script também são o meio pelo qual os programas Python são distribuídos para outras pessoas. Mais importante, como você sabe ao escrever trabalhos de conclusão de curso, os arquivos permitem guardar, de forma segura e permanente, muitas horas de trabalho. Para compor e executar programas dessa maneira, siga os passos a seguir: 1. Selecione a opção New Window do menu File da janela de shell. 2. Na nova janela, insira expressões ou instruções Python em linhas separadas, na ordem em que você deseja que o Python as execute. 3. A qualquer momento, você pode salvar o arquivo selecionando File/Save. Ao fazer isso, você deve utilizar uma extensão . py. Por exemplo, seu primeiro arquivo de programa pode ser nomeado meuprograma.py. 4. Para executar esse arquivo de código como um script Python, selecione Run Module no menu Run ou pressione a tecla F5. O comando no passo 4 lê o código do arquivo salvo e o executa. Se o Python executar qualquer função print no código, você verá a saída como de costume na janela do shell. Se o código solicitar qualquer entrada, o interpretador fará uma pausa para permitir que você as insira. Caso contrário, a execução do programa continua invisível nos bastidores. Ao terminar de executar a última instrução, o interpretador fecha e volta ao prompt do shell. A Figura 1-7 mostra uma janela IDLE contendo um script completo que solicita ao usuário a largura e a altura de um retângulo, calcula a área e gera o resultado:

Figura 1-7 Script Python em uma janela IDLE

Quando o script é executado a partir da janela IDLE, ele produz a interação com o usuário na janela de shell mostrada na Figura 1-8. Essa pode ser uma maneira um pouco menos interativa de executar programas do que inseri-los diretamente no prompt do interpretador do Python. Mas executar o script da janela IDLE permite construir alguns programas complexos, testá-los e salvá-los em bibliotecas de programas que você pode reutilizar ou compartilhar com outras pessoas.

Fundamentos_Python.indb 22

17/10/2022 10:47:58

Introdução

Figura 1-8 Interação com um script em uma janela de shell

Nos bastidores: como funciona o Python Se executar o código Python como um script ou interativamente em um shell, o interpretador Python faz muito trabalho para executar as instruções em seu programa. Esse trabalho pode ser dividido em uma série de etapas, como mostrado na Figura 1-9.

Código Python

Mensagens de erro de sintaxe Verificador e tradutor de sintaxe Código de bytes

Entradas do usuário Máquina Virtual Python (PVM)

Outras mensagens de erro

Saídas do programa

Figura 1-9 Etapas na interpretação de um programa Python

1. O interpretador lê uma expressão ou instrução Python, também chamada código-fonte e verifica se está bem formada. Nesta etapa, o interpretador se comporta como um professor de inglês rigoroso que rejeita qualquer sentença que não esteja de acordo com as regras gramaticais, ou sintaxe, do idioma. Assim que o interpretador encontrar um erro assim, ele interrompe a conversão com uma mensagem de erro. 2. Se uma expressão Python estiver bem formada, o interpretador a converterá em um formato equivalente em uma linguagem de baixo nível chamada código de bytes. Quando o interpretador executa um script, ele o converte completamente em código de bytes. 3. O código de bytes é então enviado para outro componente de software, chamado máquina virtual Python (PVM), onde ele é executado. Se ocorrer outro erro durante essa etapa, a execução também será interrompida com uma mensagem de erro.

Fundamentos_Python.indb 23

17/10/2022 10:47:58

Fundamentos de Python: primeiros programas

Exercícios

Descreva o que acontece quando o programador insere a string "Greetings!" no shell do Python.

Escreva uma linha de código que solicita ao usuário o nome e salva a entrada do usuário em uma variável chamada name.

Responda à pergunta: o que é um script Python?

Explique o que acontece nos bastidores quando seu computador executa um programa Python.

Detecção e correção de erros de sintaxe Os programadores inevitavelmente cometem erros tipográficos ao editar programas, e o interpretador Python quase sempre os detecta. Esses erros são chamados de erros de sintaxe. O termo sintaxe refere-se às regras para formar frases em uma linguagem. Quando o Python encontra um erro de sintaxe em um programa, ele interrompe a execução com uma mensagem de erro. As sessões a seguir com o shell do Python mostram vários tipos de erros de sintaxe e as mensagens de erro correspondentes: >>> length = int(input("Enter the length: ")) Enter the length: 44 >>> print(lenth) Traceback (most recent call last): File "<pyshell#l>", line 1, in <module> NameError: name 'lenth' is not defined

A primeira instrução atribui um valor de entrada à variável length. A próxima instrução tenta imprimir o valor da variável lenth. O Python responde que o nome não está definido. Embora o programador possa ter tido em mente escrever a variável length, o Python só pode ler o que o programador realmente inseriu. Esse é um bom exemplo da regra de que um computador pode ler apenas as instruções que recebe, não as instruções que pretendemos fornecer. A próxima instrução tenta imprimir o valor da variável escrita corretamente. Mas o Python ainda gera uma mensagem de erro. >>> print(length) SyntaxError: unexpected indent

Na mensagem de erro, o Python explica que essa linha de código está inesperadamente recuada. Na verdade, há um espaço extra antes da palavra print. O recuo é significativo no código Python. Cada linha de código inserida em um prompt de shell ou em um script deve começar na coluna mais à esquerda, sem espaços. A única exceção a essa regra ocorre em instruções e definições de controle, em que instruções aninhadas devem ser recuadas um ou mais espaços. Você pode pensar que é trabalhoso e maçante manter todos os recuos perfeitamente alinhados em um programa. Mas em compensação, a linguagem Python é muito mais simples que outras linguagens de programação. Consequentemente, há menos tipos de erros de sintaxe para encontrar e corrigir, e muito menos sintaxe para você aprender! No nosso exemplo final, o programador tenta somar dois números, mas se esquece de incluir o segundo: >>> 3 + SyntaxError: invalid syntax

Nos capítulos seguintes, analisaremos outros tipos de erros de programa e como reparar o código que os gera.

Fundamentos_Python.indb 24

17/10/2022 10:47:58

Introdução

Exercícios 1.

Suponha que seu script tente imprimir o valor de uma variável à qual ainda não foi atribuído um valor. Como o interpretador Python reage?

Miranda esqueceu de completar uma expressão aritmética antes do final de uma linha de código. Como o interpretador Python reagirá?

Por que o código Python gera menos tipos de erros de sintaxe que o código em outras linguagens de programação?

Sugestões para leitura adicional BATTELLE, John. The Search: How Google and Its Rivals Rewrote the Rules of Business and Transformed Our Culture. New York: Portfolio Trade, 2006. BERNERS-LEE, Tim. Weaving the Web: The Original Design and Ultimate Destiny of the World Wide Web. New York: HarperCollins, 2000. GRAHAM, Paul. Hackers and Painters: Big Ideas from the Computer Age. Sebastopol, CA: O’Reilly, 2004. HAFNER, Katie; LYON, Matthew. Where Wizards Stay Up Late: The Origins of the Internet. New York: Simon and Schuster, 1996. HOBART, Michael E.; SCHIFFMAN, Zachary S. Information Ages: Literacy, Numeracy, and the Computer Revolution. Baltimore: The Johns Hopkins University Press, 1998. IFRAH, Georges. The Universal History of Computing: From the Abacus to the Quantum Computer. New York: John Wiley & Sons, Inc., 2001. ISSACSON, Walter. Steve Jobs. New York: Simon & Schuster, 2011. MARKOFF, John. What the Doormouse Said: How the Sixties Counterculture Shaped the Personal Computer Industry. New York: Viking, -2005. MARTÍNEZ, Antonio García. Chaos Monkeys: Obscene Fortune and Random Failure in Silicon Valley. New York: HarperCollins, 2016. O’NEIL, Cathy. Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown, 2016. WHITE, Curtis. We, Robots: Staying Human in the Age of Big Data. New York: Melville House, 2016.

Resumo • Uma das ideias mais fundamentais da ciência da computação é o algoritmo. Um algoritmo é uma sequência de instruções para resolver um problema. Um agente de computação pode executar essas instruções para resolver um problema em um período finito de tempo. • Outra ideia fundamental da ciência da computação é o processamento de informações. Praticamente qualquer relacionamento entre objetos do mundo real pode ser representado como informações ou dados. Os agentes computacionais manipulam as informações e as transformam seguindo os passos descritos nos algoritmos. • Agentes computacionais reais podem ser construídos a partir de dispositivos de hardware. Eles consistem em uma unidade central de processamento (CPU), uma memória e dispositivos de entrada e saída. A CPU contém circuitos que executam as instruções descritas por algoritmos. A memória contém chaves que representam dígitos binários. Todas as informações armazenadas na memória são representadas em formato binário. Dispositivos de entrada, como teclado e scanner de mesa e dispositivos de saída, como monitor e alto-falantes, transmitem informações entre a memória do computador e o mundo externo. Esses dispositivos também transferem informações entre um formato binário e um formato que os seres humanos podem utilizar.

Fundamentos_Python.indb 25

17/10/2022 10:47:58

Fundamentos de Python: primeiros programas

• Alguns computadores reais, como aqueles em relógios de pulso e celulares, são especializados para um pequeno conjunto de tarefas, enquanto um computador desktop ou laptop é uma máquina de solução de problemas de uso geral. • O software fornece os meios pelos quais diferentes algoritmos podem ser executados em um dispositivo de hardware de uso geral. O termo software pode se referir a editores e interpretadores para desenvolvimento de programas; um sistema operacional para gerenciar dispositivos de hardware; interfaces com o usuário para comunicação com usuários humanos; e aplicativos como processadores de texto, planilhas, gerenciadores de banco de dados, jogos e programas de processamento de mídia. • O software é escrito em linguagens de programação. Linguagens como Python são de alto nível; elas se assemelham ao inglês e permitem que os autores expressem seus algoritmos de maneira clara para outras pessoas. Um programa chamado interpretador converte um programa Python em uma forma de nível inferior que pode ser executado em um computador real. • O shell do Python fornece um prompt de comando para avaliar e visualizar os resultados das expressões e instruções do Python. O IDLE é um ambiente de desenvolvimento integrado que permite ao programador salvar programas em arquivos e carregá-los em um shell para teste. • Scripts Python são programas salvos em arquivos e executados a partir de um prompt de comando do terminal. Um script interativo consiste em um conjunto de instruções de entrada, instruções que processam essas entradas e instruções que geram os resultados. • Quando um programa Python é executado, ele é convertido em código de bytes. Esse código de bytes é então enviado para a máquina virtual Python (PVM) para interpretação e execução adicionais. • Sintaxe é o conjunto de regras para formar expressões e instruções corretas em uma linguagem de programação. Quando o interpretador encontra um erro de sintaxe em um programa Python, ele interrompe a execução com uma mensagem de erro. Dois exemplos de erros de sintaxe são uma referência a uma variável que ainda não possui um valor e um recuo inesperado.

Perguntas de revisão

Fundamentos_Python.indb 26

Quais dos seguintes itens são exemplos de algoritmos? a. Um dicionário b. Uma receita c. Um conjunto de instruções para montar um galpão utilitário d. O verificador ortográfico de um processador de texto

Qual dos seguintes itens contém informações? a. O armário de porcelana chinesa da minha avó b. Um CD de áudio

c. Uma geladeira d. Um livro e. Um computador em execução

Quais dos seguintes itens são dispositivos de computação de uso geral? a. Um telefone celular c. Um computador portátil b. Um reprodutor de música portátil d. Um termostato programável

Quais dos seguintes itens são dispositivos de entrada? a. Alto-falante c. Impressora b. Microfone d. Mouse

Quais dos seguintes itens são dispositivos de saída? a. Uma câmera digital c. Um scanner de mesa b. Um teclado d. Um monitor

17/10/2022 10:47:59

Introdução

Qual é a finalidade da CPU? a. Armazenar informações b. Receber entradas do usuário humano

c. Decodificar e executar instruções d. Enviar saída para o usuário humano

Qual das seguintes opções converte e executa instruções em uma linguagem de programação? a. Um compilador c. Um carregador b. Um editor de texto d. Um intérprete

Qual dos seguintes itens gera saída de dados em um programa Python? a. A instrução de entrada c. A função print b. A instrução de atribuição d. A função main

Para que serve o IDLE? a. Editar programas Python b. Salvar programas Python em arquivos

10.

c. Executar programas Python d. Todas as alternativas acima

Como se chama o conjunto de regras para formar frases em uma linguagem? a. Semântica c. Sintaxe b. Pragmática d. Lógica

Projetos 1.

Abra um shell Python, insira as seguintes expressões e observe os resultados: a. 8 d. 8/12 e. 8 // 12 b. 8 * 2 c. 8 ** 2 f. 8/0 Escreva um programa Python que imprime (exibe) seu nome, endereço e número de telefone.

Avalie o seguinte código em um prompt de shell: print ("Your name is", nome). Em seguida, atribua a name um valor apropriado e avalie a instrução novamente.

Abra uma janela IDLE e abra o programa da Figura 1-7 que calcula a área de um retângulo. Carregue o programa no shell pressionando a tecla F5 e corrija os erros que ocorrerem. Teste o programa com diferentes entradas executando-o pelo menos três vezes.

Modifique o programa do Projeto 4 para calcular a área de um triângulo. Emita os prompts apropriados para a base e a altura do triângulo, e altere os nomes das variáveis de acordo. Em seguida, utilize a fórmula .5 * base * height para calcular a área. Teste o programa a partir de uma janela IDLE.

Escreva e teste um programa que calcula a área de um círculo. Esse programa deve solicitar um número representando um raio como entrada do usuário. Ele deve utilizar a fórmula 3.14 * radius ** 2 para calcular a área e, em seguida, produzir o resultado devidamente rotulado.

Escreva e teste um programa que aceite o nome do usuário (como texto) e a idade (como um número) como entrada. O programa deve produzir uma sentença contendo o nome e a idade do usuário.

Insira uma instrução de entrada utilizando a função input no prompt de shell. Quando o prompt solicitar a entrada, digite um número. Em seguida, tente adicionar 1 a esse número, observe os resultados e explique o que aconteceu.

Insira uma instrução de entrada utilizando a função input no prompt de shell. Quando o prompt solicitar a entrada, digite seu primeiro nome, observe os resultados e explique o que aconteceu.

10.

Digite a expressão help() no prompt de shell. Siga as instruções para navegar pelos tópicos e módulos.

Fundamentos_Python.indb 27

17/10/2022 10:47:59