Embed Size (px)
Citation preview
UENP - UNIVERSIDADE ESTADUAL DO NORTE DO PARANÁCAMPUS LUIZ MENEGHEL
Centro de Ciências Tecnológicas
Programação INotas de Aula
Prof. José Reinaldo MerlinProf. Fábio de Sordi Junior
Bandeirantes – 2017
Sumário
1 Introdução à Programação 41.1 Ementa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2 Livros recomendados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3 Lógica de Programação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.1 Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.3.2 Passos para construção de um algoritmo . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Computadores: Hardware e Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.5 Tipos de Linguagens de Programação . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2 A Linguagem Python 82.1 Instalando Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.2 Operações e Operadores Aritiméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1 Precedência dos operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.3 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.1 Tipos de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.4 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.5 Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.6 Entrada e Saída . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.6.1 Função input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.6.2 Função print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.7 Comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.8 Considerações Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 Estruturas de Seleção 163.1 Estrutura de Seleção if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.1.1 Indentação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.2 Estrutura if/else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.3 Estruturas aninhadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.4 Estrutura elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.5 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4 Estrutura de Repetição 224.1 Repetições controladas por contador . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.2 Repetições controladas por sentinela . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.3 Acumuladores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.4 O comando break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.5 Escopo de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.6 Considerações Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2
5 Listas 305.1 Declarando Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.2 Percorrendo Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.3 Listas dinâmicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.3.1 Descobrindo o tamanho da lista . . . . . . . . . . . . . . . . . . . . . . . . . . 315.4 Remoção de Elementos da Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.5 Percorrendo listas por meio de for . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.6 Ordenando Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
6 Strings 366.1 Declaração de strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366.2 Operações com strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6.2.1 Funções internas do tipo string . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
7 Funções 407.1 Utilizando Funções da Linguagem Python . . . . . . . . . . . . . . . . . . . . . . . . . 407.2 Conceitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417.3 Criando Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
7.3.1 Funções que não recebem parâmetros e não retornam valor . . . . . . . . . . . . 427.3.2 Funções que recebem parâmetros e não retornam valor . . . . . . . . . . . . . . 427.3.3 Funções que recebem parâmetros e retornam valor . . . . . . . . . . . . . . . . 43
7.4 Funções Recursivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437.4.1 Cálculo do fatorial por recursividade . . . . . . . . . . . . . . . . . . . . . . . . 44
7.5 Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447.6 Considerações Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
8 Classes o Objetos 488.1 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488.2 Instanciando Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488.3 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498.4 Considerações Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508.5 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
9 Arquivos 529.1 Acessando Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529.2 Arquivos Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
9.2.1 Escrevendo em um arquivo texto . . . . . . . . . . . . . . . . . . . . . . . . . . 539.2.2 Lendo de um Arquivo Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
9.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Referências Bibliográficas 57
Capítulo 1
Introdução à Programação
O objetivo desta disciplina é introduzir o estudo de algoritmos e lógica de programação.
1.1 Ementa
Resolução de problemas e desenvolvimento de algoritmos. Análise do problema. Estratégias de solução.
Representação e documentação. Programação de algoritmos usando uma linguagem de programação.
Estruturação de programas. Tipos e estruturas elementares de dados. Conceito de recursão e sua aplica-
ção. Manipulação de Arquivos.
1.2 Livros recomendados
Estes são alguns dos livros úteis para a disciplina:
MENEZES, Nilo N. C. Introdução à Programação com Python. Algoritmos e lógica de programação
para iniciantes. São Paulo: Novatec, 2014.
FORBELLONE, A. L. V.; EBERPACHER, H. F. Lógica de Programação: a construção de algoritmos
e estrutura de dados. São Paulo: Pearson Education do Brasil, 2000.
1.3 Lógica de Programação
Geralmente, inicia–se o estudo de programação com o conceito de “lógica de programação”. Mas o
que é lógica? Usamos o termo lógica cotidianamente, por exemplo, quando dizemos a um amigo: “seu
raciocínio não tem lógica”. Uma das definições do iDicionário Aulete é “modo coerente pelo qual coisas
ou acontecimentos se encadeiam” 1. Vamos imaginar que precisemos pegar o dinheiro que está no cofre
fechado. “Pela lógica”, precisamos antes abrir o cofre para pegar o dinheiro.
Programas de computadores são criados (ainda) por seres humanos, que utilizam a capacidade de
raciocínio para gerar soluções para os problemas propostos. No entanto, o raciocínio é algo intangível.
Neste sentido, a lógica de programação é uma ferramenta para transformar esse raciocínio abstrato em
algo que possa ser transformado em programa de computador.1aulete.uol.com.br.
4
Um computador só entende o que deve fazer se receber instruções claras, bem definidas e em ordem
correta. Computadores (ainda) não são programáveis em linguagem natural, pois esta é sujeita a ambi-
guidades e imprecisões. A lógica de programação tem o objetivo de estabelecer uma sequência lógica de
passos que devem ser executados por um programa de computador.
Essa sequência costuma ser chamada de algoritmo.
1.3.1 Algoritmos
Na definição de Cormen et al. (2002), um algoritmo é um procedimento computacional bem definido que
toma algum valor ou conjunto de valores como entrada e produz algum valor ou conjunto de valores como
saída. Dito de outra forma, “um algoritmo é uma sequência de passos computacionais que transformam
a entrada na saída”.
Geralmente computadores são utilizados para resolver problemas. Um algoritmo, neste sentido, é um
conjunto de passos para a solução de um problema. Um exemplo de problema computacional é como
ordenar um conjunto de valores em ordem crescente.
Para Forbellone and Eberspacher (2005), o algoritmo deve especificar ações claras e precisas que, a
partir de um estado inicial, após um período de tempo finito, produzem um estado final previsível e bem
definido.
Um exemplo clássico de algoritmo é o processo de troca de uma lâmpada queimada, cujos passos
seriam:
1. pegar a escada;
2. posicionar a escada embaixo da lâmpada;
3. buscar a lâmpada nova;
4. subir na escada;
5. retirar a lâmpada velha;
6. colocar a lâmpada nova.
1.3.2 Passos para construção de um algoritmo
Para construir um algoritmo, o problema deve ser dividido em três partes fundamentais:
entrada → processamento → saída.
onde:
Entrada: são os dados necessários para se resolver o problema
Processamento: é a manipulação dos dados de entrada
Saída: é a resposta para o problema
Considere o problema de se calcular a média final de três provas de um determinado aluno. Analisando
em termos das três partes fundamentais de um algoritmo, tem-se:
Entrada:as notas das três provas
Processamento: o cálculo da média
Saída: a média final
5
Representando como uma sequência de passos:
1. Ler a nota da primeira prova
2. Ler a nota da segunda prova
3. Ler a nota da terceira prova
4. Somar as três notas
5. Dividir a soma por três
6. Mostrar o valor da divisão
1.4 Computadores: Hardware e Software
Um computador é um dispositivo que processa dados sob o controle de conjunto de instruções chamado
programa. Os programas orientam o computador a executar um conjunto de ações especificado pelo pro-
gramador. Apesar das diferenças na aparência física, todo computador (com raras exceções) é constituído
por seis unidades lógicas:
Unidade de entrada: é responsável por receber dados dos dispositivos de entrada (teclado, mouse, mi-
crofone) e colocá-los à disposição de outras unidades;
Unidade de saída: é o componente que “pega” os dados processados e disponibiliza através dos dispo-
sitivos de saída (alto-falante, impressora, tela);
Unidade de memória: atua como “depósito” guardando informações que chegaram pela unidade de
entrada, tornando-as acessíveis ao processador. Também retém informações processadas até que
sejam colocadas em dispositivos de saída;
Unidade lógico-aritmética (ULA): unidade que realiza cálculos e executa as tomadas de decisões, tais
como comparar dois números e decidir qual deles é o maior;
Unidade central de processamento (CPU): é a seção “administrativa” que coordena e supervisiona as
outras unidades. Determina quando a unidade de entrada vai ler informação para a memória, diz
para a ULA quando a informação da memória deve ser usada para um cálculo e diz para a unidade
de saída quando enviar informação da memória para algum dispositivo de saída; e
Unidade de memória secundária: “depósito” de informação de alta capacidade e longa duração. In-
formação guardada na memória secundária é chamada de persistente, pois é preservada mesmo
quando o computador é desligado.
Quando um programador escreve um programa, ele está escrevendo instruções para utilização destas
unidades.
1.5 Tipos de Linguagens de Programação
Instruções ou programas são escritos utilizando-se de linguagens de programação, que são um conjunto
de vocábulos e regras para sua utilização. Existem centenas de linguagens sendo utilizadas atualmente.
No entanto, elas podem ser agrupadas em três tipos genéricos:
6
Linguagens de máquina: as instruções são escritas com cadeias de números que instruem o compu-
tador a executar as ações. Cada processador possui sua própria linguagem de máquina, o que
significa que a linguagem de um tipo de processador não é entendida por outro processador. As
instruções abaixo ilustram um programa que adiciona o valor de horas-extras ao salário base e
armazena o resultado em salário bruto:
+1300042774
+1400593419
+1200274027
Linguagens assembly: escrever programas em linguagem de máquina é pouco produtivo e muito sujeito
a erros. As linguagens assembly utilizam abreviações de termos em inglês para representar as
operações elementares. Um programa tradutor (assembler) precisa ser usado para converter estas
“palavras” em linguagem de máquina. O código a seguir executa a mesma ação descrita no item
anterior:
load salarioBase
add horasExtras
store salarioBruto
Linguagens de alto nível: as linguagens assembly tornaram o processo de escrever programas menos
complexo. No entanto, os programadores ainda tinham que escrever várias instruções para executar
uma única ação. O código a seguir executa a mesma operação em linguagem de alto nível:
salarioBruto = salarioBase + horasExtras;
Programas especiais chamados compiladores convertem a linguagem de alto nível em linguagem
de máquina. Programas compilados são muitas vezes chamados de código objeto. Um programa
compilado adicionado de funções de bibliotecas produz um programa executável, que pode ser
executado pelo processador.
O processo de compilação é mostrado simplificadamente na Figura 1.12.
Figura 1.1: Processo de compilação.
2Fonte: K19 Treinamentos. www.k19.com.br. Uso autorizado.
7
Capítulo 2
A Linguagem Python
Programar computadores é combinar um conjunto de instruções específicas, respeitando regras formais, a
fim de produzir o resultado esperado. Como vimos no Capítulo 1, o resultado esperado é a transformação
da(s) entrada(s) em uma saída útil. Para programar, é necessário utilizar uma linguagem de programação.
Nesta disciplina será utilizada a linguagem de programação Python em sua versão 3.5.
No presente capítulo serão mostrados alguns conceitos básicos da linguagem.
2.1 Instalando Python
Faça o download da última versão de Python adequada ao seu sistema operacional em www.python.org.
A instalação inclui o interpretador Python e o ambiente de desenvolvimento integrado IDLE. O Integra-
ted Development and Learning Environment (IDLE) é um ambiente simples para iniciantes em progra-
mação.
Um ambiente mais completo é o PyCharm, desenvolvido pela JetBrains. O programa possui uma
versão livre além da versão paga e pode ser baixado em https://www.jetbrains.com/pycharm/.
2.2 Operações e Operadores Aritiméticos
Operadores são símbolos que representam operações com valores. Os valores são chamados de operan-
dos. Os principais operadores aritiméticos em Python são mostrados na Tebela 2.1.
Operador Operação Exemplo+ adição 7+4 = 11- subtração 2-3 = -1* multiplicação 2*3 = 6/ divisão 8/4 = 2
** exponenciação 2**3 = 8// quociente inteiro 7//3 = 2% resto da divisão 7%3 = 1
Tabela 2.1: Principais operadores aritméticos.
O operador de divisão (barra) sempre produz uma resultado decimal. Por exemplo, a operação 10
/ 2 resulta em 5.0 e não 5.
8
2.2.1 Precedência dos operadores
Algumas expressões possuem várias operações. Por exemplo: 2+5*3/4+2**2. Nestes casos, a ex-
pressão é avaliada em Python da mesma maneira que na matemática:
1. Operações de expressões contidas em parênteses são avaliadas primeiro;
2. Exponenciação é avaliada em seguida;
3. Multiplicação, divisão e resto são avaliadas em seguida, da esquerda para direita; e
4. Adição e subtração são avaliadas por último, da esquerda para direita.
Exemplos:
2+3*4 = 14
(2+3)*4 = 20
2/3-1 = -0.333
2//3-1 = -1
7%3+1 = 2
7%(3+1) = 3
2.3 Variáveis
Basicamente, o que todo programa faz é manipular dados. Esses dados são armazenados em variáveis
na memória. Variáveis são elementos fundamentais em qualquer programa. Uma variável representa um
espaço reservado na memória que é capaz de armazenar um dado. Exemplos de dados que podem ser
manipulados por um programa são o salário de uma pessoa, a nota de um aluno, a medida de um lado de
um quadrado.
Uma variável tem um nome para referenciar o seu conteúdo em outras partes do programa. Existem
algumas regras para se dar nomes às variáveis:
1. O nome deve começar com uma letra.
2. Deve ser formado apenas por letras e números.
3. Não podem conter espaços em branco.
4. Podem conter o caractere sublinhado (_).
Alguns exemplos de nomes de variáveis válidos e inválidos são mostrados na Tabela 2.2.
Embora em Python seja possível declarar variáveis com acentos e cedilha, recomendamos não utilizar
esta prática por questões de legibilidade.
XUtilize nomes significativos para as variáveis.
Um detalhe importante é atentar–se ao “case” da variável, pois Python diferencia maiúsculas e minús-
culas (case sensitive). Assim, uma variável chamada aluno é distinta de uma variável chamada Aluno.
Por padrão, vamos utilizar os nomes de variáveis sempre em minúsculas ou utilizando a “convenção do
camelo” quando o nome for composto por mais de uma palavra (nomeDoAluno).
9
Nome Válido Explicaçãocarro sim Contém apenas letrascarro1 sim Contém números mas começa com letra1carro não Começa com númerosalario_mes sim Contém letras e caractere sublinhadonome aluno não Contém espaçor$ não Contém caractere especialprint não Palavra reservada
Tabela 2.2: Exemplos de nomes válidos e inválidos.
Para se criar uma variável, dá–se o nome a ela e atribui–se um valor por meio do comando de
atribuição (=). O operador de atribuição “atribui” o que está do lado direito ao lado esquerdo do operador.
Exemplo:
x = 10
Um valor atribuído a uma variável permanece o mesmo até que seja explicitamente alterado. Também
é possível atribuir o resultado de uma expressão a variável. Exemplo:
x = 10
y = x * 2
Neste caso, o valor da variável x foi multiplicado por 2 e depois atribuído a variável y.
2.3.1 Tipos de variáveis
Os principais tipos de variáveis são: numéricas,strings e lógicas.
Variáveis numéricas
Variáveis numéricas representam números inteiros ou de ponto flutuante. Números de ponto flutuante
são os números com parte decimal, por exemplo 7.2. Em Python, o separador de casas decimais é o
ponto e não a vírgula. Observe que 7.0 é um número do tipo ponto flutuante e não um inteiro, embora
não tenha valor significativo depois do ponto.
Variáveis do tipo string
Variáveis do tipo string armazenam textos, também chamados de cadeia de caracteres. Um texto pode
conter letras, números, espaços e caracteres especiais. Exemplo:
Python é legal!
Strings serão tratadas no Capítulo6.
Variáveis do tipo lógico
Variáveis do tipo lógico armazenam dois valores possíveis: verdadeiro ou falso. Também são chamadas
de variáveis booleanas. Em Python, escrevemos True e False para verdadeiro e falso. Exemplo:
10
aprovado = True
retido = False
Valores lógicos são especialmente aplicáveis quando fazemos operações com operadores relacionais.
2.4 Operadores Relacionais
Operadores relacionais comparam dois valores ou variáveis, resultando em verdadeiro ou falso. Os
operadores relacionais são:
Operador Significado> maior que< menor que>= maior que ou igual<= menor que ou igual== igual!= diferente
Exemplo:
x = 5
y = 4
resultado = x > 4
Ao executar este trecho de programa a variável resultado terá o valor True.
2.5 Operadores lógicos
Operadores lógicos executam operações com operandos lógicos. Os principais operadores lógicos são:
not (negação), and (e) e or (ou).
O operador not é um operador unário, pois age sobre um operando apenas. O operador produz a
inversão, ou negação, do valor lógico ao qual é aplicado. Exemplo:
resultado = True
not resultado
agora a variável resultado está com o valor False.
A análise dos operadores and e or geralmente é feita por meio de uma estrutura conhecida como
tabela verdade, que é uma tabela que mostra o resultado de todas as combinações possíveis entre valores
lógicos.
O operador and (E) resulta no valor lógico verdadeiro quando ambos os operandos são verdadei-
ros. Considerando que A e B são duas expressões lógicas, os resultados relativos ao operador and são
mostrados na Tabela 2.3.
O operador or (OU) resulta no valor lógico verdadeiro quando pelo menos um dos operandos é
verdadeiro. Considerando que A e B são duas expressões lógicas, os resultados relativos ao operador or
são mostrados na Tabela 2.4.
11
A B ResultadoV V verdadeiroV F falsoF V falsoF F falso
Tabela 2.3: Tabela Verdade do operador E.
A B ResultadoV V verdadeiroV F verdadeiroF V verdadeiroF F falso
Tabela 2.4: Tabela Verdade do operador OU.
Os operadores lógicos são muito utilizados em estruturas de decisão e seleção, que são assunto dos
próximos capítulos.
XOs operadores lógicos são os últimos a serem avaliados em uma expressão.
Expressões lógicas
Expressões lógicas podem conter mais de um operador lógico. Neste caso, a precedência é a seguinte:
primeiro avalia–se o operador not , em seguida o operador and e por último o operador or.
Considere a expressão:
x < 10 or y == 2 and not y==4
em que são combinados operadores relacionais e operadores lógicos. Primeiramente, são avaliadas
as operações relacionais, o que resultaria em:
True or False and not True
Agora que só temos operadores lógicos, primeiramente avalia–se o not, resultando em:
True or False and False
O passo seguinte é avaliar o operador and:
True or False and False
cujo resultado é:
True or Falso
Finalmente, o operador or é avaliado, resultando em:
True
12
2.6 Entrada e Saída
A maior parte dos programas envolve algum tipo de entrada de dados e algum tipo de apresentação de
resultados. Esses tipos de operações são chamadas de operações de entrada e saída. Nas operações
de entrada, os bytes recebidos de algum dispositivo (teclado, pen drive, internet...) para a memória
principal. Nas operações de saída, os dados são enviados da memória principal para algum dispositivo
de saída (tela, impressora, disco). Por padrão, o dispositivo de entrada é o teclado e o de saída é o
terminal de vídeo.
A operação de entrada de dados é geralmente chamada de “leitura” e a operação de saída, de “escrita”.
Para entrada de dados, em Python, é utilizada a função input. Para saída (exibição) utiliza–se a função
print.
2.6.1 Função input
A função input recebe dados do teclado e armazenam estes dados em uma variável. Por exemplo:
x = input()
atribui à variável x o que o usuário digitou. No entanto, a função input sempre retorna os dados
no formato de texto. Quando quisermos ler um dado numérico, é necessário fazer a conversão (casting).
Por exemplo, se quisermos ler a idade de uma pessoa, que é inteiro, fazemos a conversão para inteiro:
x = int(input())
A função input espera que o usuário digite algo no teclado. É possível acrescentar uma mensagem
para instruir o usuário sobre o que fazer, da seguinte forma:
idade = int(input("Informe a idade: "))
Observe que textos são escritos no programa dentro de aspas, simples ou duplas.
2.6.2 Função print
Para saída de dados é utilizada a função print. Esta função exibe uma representação textual de alguma
variável ou constante na tela.
Constantes são valores que permanecem os mesmos não importando quantas vezes o programa seja
executado. No exemplo a seguir o número 2 e o texto “Python é massa” são exemplos de constantes.
print(2)
print(‘‘Python é massa!’’)
Os argumentos 1 para a função print podem combinar constantes e variáveis. No próximo exemplo
é exibida uma mensagem “A soma é: ” (constante) seguida da soma de duas variáveis. Observe a vírgula
separando os argumentos.
1Argumentos são os valores que são passados dentro dos parênteses.
13
x = int(input ("Digite um número: "))y = int(input ("Digite outro número: "))print ("A soma é: ",(x+y))
Os argumentos passados para a função print são concatenados no momento da exibição. O trecho
de código a seguir concatena textos e variáveis.
x = 10y = 5print (x, " + ", y, " é igual a: ", x+y)
Formatando a saída
Em alguns casos podemos querer formatar a saída. Por exemplo, para exibir números do tipo ponto
flutuante com uma quantidade exata de dígitos depois do ponto. Uma forma de fazer isso é como no
exemplo a seguir, em que um número é exibido com duas casas decimais.
x = 9.987654321print("x com duas casas decimais: %.2f" %x)
A forma mais moderna de se fazer o mesmo (Python 3) é por meio de {} que “marcam” o lugar em
que a variável formatada vai ser inserida. Exemplo:
x = 9.987654321print("A saída é {0:.2f} com duas casas. \Com três casas: {1:.3f} ".format(x, x))
2.7 Comentários
Comentários são anotações feitas pelo programador para explicar algum trecho de código. Comentários
de uma linha são precedidos de “#”. O que estiver após o caractere até o final da linha será ignorado.
Exemplo:
# esta linha será ignorada durante a execução
nascimento = 0 #ano de nascimento da pessoa
Comentários que se estendem por mais de uma linha são iniciados com ”’ e terminados por ”’ (3
aspas simples). Exemplo de comentário de múltiplas linhas:
‘ ‘ ‘
Três lados formam um triângulo quando um dos seus lados
deve ser maior que a diferença dos outros dois lados
e menor que a soma dos outros dois lados.
‘ ‘ ‘
14
2.8 Considerações Finais
Uma linguagem de programação é constituída de um conjunto de operadores e funções bem como por
regras para se utilizar esses elementos. Embora uma linguagem seja diferente de outra, alguns conceitos
são universais. Por exemplo, Python utiliza a função input para entrada de dados, C utiliza a função
scanf, mas ambos representam a mesma coisa, que é a entrada de um dado e armazenamento em uma
variável. No próximo capítulo são apresentadas as estruturas básicas de seleção da linguagem Python.
15
Capítulo 3
Estruturas de Seleção
Estruturas de controle permitem controlar a sequência das ações lógicas de um programa. Basicamente,
existem dois tipos de estruturas de controle: estruturas de seleção (ou decisão) e estruturas de repetição.
As estruturas de decisão permitem executar um entre dois ou mais blocos de instruções. As estruturas de
repetição permitem que um bloco de instruções seja executado uma quantidade controlada de vezes. A
seguir são mostradas as estruturas de Python que permitem implementar estruturas de seleção.
3.1 Estrutura de Seleção if
Nem sempre os programas devem executar todas as instruções em sequência. Em alguns casos é ne-
cessário executar algum trecho apenas se uma condição for verdadeira. A decisão de executar ou não é
tomada com base em um teste de condição, ou expressão condicional. Uma expressão condicional é uma
expressão que, ao ser avaliada, resulta em um valor verdadeiro ou falso.
Na Figura 3.1 é ilustrada, por meio de fluxograma, a estrutura de seleção.
Figura 3.1: Representação da estrutura if.
A estrutura de seleção if realiza um teste lógico em uma condição. Se o teste lógico resultar
em “verdadeiro”, o bloco de comandos (corpo do if) é executado; se resultar em “falso”, a execução
continua a partir da primeira instrução após o bloco. A forma geral da estrutura if é:
if <condição>:<bloco de código para condição verdadeira>
16
Um bloco de código é um conjunto de uma ou mais linhas que serão executadas em sequência.
Quando o programa “entra” no bloco, todas as linhas deste bloco são executadas.
No exemplo a seguir é mostrado um caso de if. O programa solicita a entrada de um número. Caso
o número seja negativo, o programa converte para positivo. Observe que a multiplicação por -1 só ocorre
se a condição for verdadeira (número < 0).
x = int(input())if x < 0:
x = x * -1print(x)
3.1.1 Indentação
Programas são compostos por vários blocos. Python utiliza o recuo do texto à direita para indicar um
bloco. O deslocamento é constituído por alguns espaços em branco (geralmente 4) para indicar o início
e fim do bloco. Na Figura 3.2 é mostrado um exemplo de bloco indentado, destacado pela linha vertical.
As linhas 3 e 4 fazem parte do bloco “verdadeiro”.
Figura 3.2: Exemplo de indentação.
3.2 Estrutura if/else
Em algumas situações, o programa deve executar uma ação se a condição for verdadeira e outra ação
caso a condição seja falsa. Nestes casos, podemos empregar e estrutura else. Considere o caso em que
um programa leia um número e diga se é negativo ou positivo. Podemos resolver com duas estruturas
if:
x = int(input())if x < 0:
print("x é negativo")if x >= 0:
print("x é positivo")
Como neste caso resolvemos com dois testes de condição, sendo que o segundo é o inverso do
primeiro, podemos escrever o programa utilizando else. Observe que neste caso há apenas um teste de
condição ao invés de dois, o que melhora o desempenho do programa.
17
x = int(input())if x < 0:
print("x é negativo")else:
print("x é positivo")
Na Figura 3.3 é mostrada a representação gráfica da estrutura if/else.
Figura 3.3: Representação da estrutura if/else.
3.3 Estruturas aninhadas
Muitas vezes precisamos realizar testes dentro de blocos internos. Considere que seja necessário classi-
ficar um atleta de acordo com sua faixa etária conforme a tabela:
Operador OperaçãoMenor de 11 anos infantilde 11 a 21 anos juvenilmaior de 21 anos adulto
Neste caso não temos simplesmente duas condições opostas: o fato de a primeira condição ser falsa
nos obriga a testar outra condição. Isto é feito por meio de uma estrutura aninhada, conforme o código a
seguir:
idade = int(input())if idade < 11:
print("infantil")else:
if idade <= 21:print("juvenil")
else:print("adulto")
XLembre–se de como o recuo do texto é importante!
18
3.4 Estrutura elif
Quando temos muitos ifs aninhados a legibilidade do programa fica comprometida. Em Python existe
a estrutura elif que substitui um else if de forma mais elegante, sem criar novos deslocamentos.
O programa a seguir realiza a mesma classificação dos atletas por idade, porém utilizando elif.
idade = int(input())if idade < 11:
print("infantil")elif idade <= 21:
print("juvenil")else:
print("adulto")
XLembre–se que o else nunca tem um teste de condição associado.
3.5 Exercícios
1. Considere o programa mostrado na Figura 3.4 cujos números à esquerda representam o número da
linha. Diga quais linhas são executadas quando forem digitadas as seguintes entradas:
Figura 3.4: Comparando números.
(a) 4 e 4:
(b) 2 e 9:
(c) 8 e 7:
2. O valor da conta de água é calculado progressivamente conforme a faixa de consumo (valores no
quadro abaixo). Faça um programa que leia o quanto o consumidor gastou emm3 e mostre o valor
a ser pago.
Consumo em m3 Tarifa por m3
menor ou igual a 10 2.55acima de 10 e menor ou igual a 20 3.44maior que 20 5.25
3. Uma loja vende 5 produtos, cujos códigos e preços estão na tabela. Faça um programa que leia
o código do produto, a quantidade comprada pelo cliente e diga o quanto ele tem que pagar,
utilizando a estrutura if/else.
19
Código Preço1 5.782 9.993 5.254 18.905 22.60
4. Reescreva o programa do exercício anterior utilizando elif.
5. Um automóvel percorre 10 km com um litro de álcool e 15 km com um litro de gasolina. Faça
um programa que leia o preço do álcool, o preço da gasolina e a distância da viagem. Calcule e
exiba o quanto o motorista gastaria se abastecer com álcool e o quanto gastaria se abastecer com
gasolina. Exiba ao final se compensa usar álcool ou gasolina.
6. Faça um programa para calcular o volume de uma esfera de raio R, sendo R um dado fornecido
pelo usuário. O volume de uma esfera é dado por V = 43πR
3 .
7. Escreva um programa que leia três valores inteiros e diferentes e mostre-os em ordem decrescente.
Utilize uma seleção encadeada.
8. Elabore um programa que leia a altura (h) e o sexo (m ou f) de uma pessoa e calcule seu peso ideal,
utilizando as seguintes fórmulas:
- para homens: (72.7 * h) - 58;
- para mulheres: (62.1 * h) - 44.7
9. Sabendo-se que uma aula tem 50 minutos e que a carga-horária das disciplinas é definida em horas,
escreva um programa que leia a carga-horária de uma disciplina, calcule e mostre a quantidade de
aulas da disciplina.
10. Sabendo-se que a frequência mínima exigida é de 75%, escreva um programa que leia a quantidade
total de aulas de uma disciplina e calcule o máximo de faltas que um aluno pode ter. Apresente o
resultado como número inteiro.
11. Escreva um programa que leia um código numérico inteiro correspondente à região e escreva o
nome da região por extenso, utilizando uma estrutura do tipo switch. As regiões estão assim
classificadas:
Código Descrição1 Sul2 Sudeste3 Centro-Oeste4 Nordeste5 Norte
12. Escreva um programa que leia três valores inteiros: A, B e C. A seguir, substitua o valor de B pelo
valor de A, o valor de C pelo valor de B e o valor de A pelo valor de C.
20
13. Crie um algoritmo em que sejam lidas 2 notas, seja calculada a média e seja mostrado “Aprovado”,
caso a média seja maior ou igual a 7, e “Reprovado” caso seja menor.
14. Refaça o exercício anterior, adicionando o conceito de sexo do aluno (variável tipo texto), alterando
o resultado final para “Aprovada” e “Reprovada” quando a aluna for do sexo feminino.
15. Elabore um programa que leia o preço de venda e calcule o valor a ser pago por um produto, de
acordo com a condição de pagamento. Utilize os códigos e condições:
Código Condição1 à vista, em dinheiro: 10% de desconto2 à vista, cartão de crédito: 5% de desconto3 cheque para 30 dias: preço normal
16. Elabore um programa que leia a idade de um nadador. A seguir, classifique em uma das seguintes
categorias:
Idade Categoria5 até 7 Infantil A8 até 10 Infantil B11 até 13 Juvenil A14 até 17 Juvenil Bmaiores de 18 adulto
17. Faça um programa que leia um caractere e diga se a letra digitada é uma vogal ou não.
18. João Papo-de-Pescador, homem de bem, comprou um microcomputador para controlar o rendi-
mento diário de seu trabalho. Toda vez que ele traz um peso de peixes maior que o estabelecido
pelo regulamento de pesca do estado de São Paulo (50 quilos) deve pagar um multa de R$ 4,00
por quilo excedente. João precisa que você faça um algoritmo que leia a variável peso (peso de
peixes) e verifique se há excesso. Se houver, calcular e mostrar o valor da multa.
19. Um caixa eletrônico trabalha com cédulas de R$ 50.00, R$ 20.00, R$ 10.00 e R$ 5.00. Faça um
programa que tenha como entrada o valor que o cliente quer retirar e mostre quantas cédulas de
cada valor vão ser entregues. A máquina sempre paga com as cédulas de maior valor. Exemplo:
Valor do saque: R$75.00
Serão entregues: 1 nota de R$ 50.00, 1 nota de R$ 20.00 e uma nota de R$ 5.00
Caso o cliente queira sacar um valor que não seja múltiplo de 5, não é possível completar o saque.
21
Capítulo 4
Estrutura de Repetição
Nos programas anteriores uma ação era executada e o programa terminava. No entanto, muitos pro-
gramas envolvem repetição (loop). Um loop é um conjunto de uma ou mais ações que são executadas
repetidamente enquanto a condição de continuação permanecer verdadeira. Considere, por exemplo, o
programa que lê os códigos de barras dos produtos comprados em um supermercado. Cada produto é
passado na leitora que realiza um processamento e o processo se repete até que não haja mais produtos
para serem lidos.
Em Python, a estrutura que controla repetições é while (enquanto). Podemos entender da seguinte
maneira: enquanto a condição for verdadeira, execute; quando se tornar falsa, pare.
A forma geral da estrutura while é:
while <condição>:<bloco de código para condição verdadeira>
A estrutura while pode ser representada graficamente como mostrado na Figura 4.1.
Figura 4.1: Estrutura de repetição.
Repetições podem ser controladas por contador ou por sentinela.
22
4.1 Repetições controladas por contador
Em repetições controladas por contador sabe-se exatamente quantas vezes o loop vai ser executado. Uma
variável de controle, ou contador, é utilizada. Esta variável é incrementada (ou decrementada) cada vez
que o bloco é executado. Quando o valor da variável de controle atinge o número definido de repetições,
o loop termina e a execução prossegue na primeira instrução depois do bloco.
O programa apresentado na Figura 4.2 mostra na tela os números de 1 a 10.
Figura 4.2: Repetição controlada por contador.
Na linha 1 foi criada uma variável com o sugestivo nome de contador para controlar a repetição.
Na linha 2 uma condição é testada (contador <= 10). Enquanto a condição for verdadeira, o corpo do
while será executado. No momento em que se tornar falsa, a execução prossegue na primeira linha
após o fim do bloco (linha 5).
XLembre–se de incrementar o contador (linha 4)1, pois caso contrário o programa entra em loop
infinito.
4.2 Repetições controladas por sentinela
Repetições controladas por sentinela são utilizadas quando não se sabe com antecedência quantas vezes
o bloco deverá ser executado. A condição de parada vai depender de alguma entrada fornecida pelo
usuário que indique o fim da repetição. Por exemplo, o caixa do supermercado deve pressionar alguma
tecla dizendo que não há mais produtos a serem lidos.
Considere um programa para calcular a raiz quadrada. Queremos que o programa calcule a raiz de
muitos números e pare de executar quando o usuário decidir. Vamos estabelecer que o programa deve
parar quando o usuário digitar um número negativo. O programa apresentado na Figura4.3 executa esta
tarefa.
Figura 4.3: Repetição controlada por sentinela.1A expressão contador += 1 é a forma reduzida de contador = contador + 1.
23
O programa inicialmente lê um número (linha 1). Na linha 2 há um teste de condição em que o
programa verifica se a variável n1 é menor que 0. Caso a condição seja verdadeira, o bloco interno do
while é executado. Na linha 5 novamente é lido um número. Como esta linha é a última do bloco, a
execução continua a partir da linha 2 e a condição é novamente testada. No momento em que o número
informado for menor que 0, a condição torna–se falsa e a execução continua a partir da primeira linha
depois do corpo do while (linha 6).
4.3 Acumuladores
Considere a seguinte situação. Uma prova contém 10 questões e cada questão tem um valor. Um pro-
grama deve ler a nota obtida em cada questão e, ao final, dizer a nota da prova. Neste caso, além de
utilizar um contador para controlar quantas notas parciais foram lidas e parar quando atingir 10 questões,
vamos precisar de um “acumulador” para totalizar as notas. Observe o programa da Figura 4.4.
Figura 4.4: Exemplo de acumulador.
Na linha 1 do programa declaramos uma variável contador para controlar a quantidade de repeti-
ções. Na linha 2, criamos a variável total para acumular os pontos de cada questão. Na linha 5 há um
exemplo típico de acumulador, em que um valor é somado ao valor anterior.
XAtente–se para a diferença que há entre total = total + questao e total = questao.
4.4 O comando break
O comando break é utilizado dentro de uma estrutura para causar a interrupção em sua execução.
Observe o programa mostrado na Figura 4.5.
Figura 4.5: Exemplo de break.
24
A condição do while é True, o que ocasionaria a repetição infinita do bloco. No entanto, na linha 5
é realizado um teste de condição em que é verificado se o valor digitado é menor que 0. Caso a condição
seja verdadeira, a linha 6 é executada. O comando break faz com que o loop seja interrompido e a
execução prossegue na linha 8, que é a primeira linha após o corpo do while.
4.5 Escopo de variáveis
Variáveis declaradas em um bloco só “existem” (podem ser referenciadas) dentro deste bloco. No pro-
grama apresentado na Figura 4.6, a variável n foi declarada na linha 1, enquanto a variável y foi declarada
na linha 4 que esta dentro do bloco do while.
Figura 4.6: Escopo de variáveis.
Quando o programa é executado o seguinte erro é gerado ao ser executada a linha 6:
NameError: name ’y’ is not defined
Isto ocorre porque a linha 6 está fora do corpo do while e tenta referenciar uma variável declarada
no corpo do while. Em outras palavras, a variável y está fora do escopo. O mesmo não ocorre com a
variável n na linha 5, uma vez que foi declarada no bloco principal do programa e pode ser referenciada
tanto no bloco principal como em qualquer bloco interno (linhas 3 e 4).
4.6 Considerações Finais
Neste capítulo foi apresentada a estrutura de repetição while, muito utilizada em programas. As estru-
turas de repetição e seleção podem ser combinadas e aninhadas livremente a fim de produzir o resultado
esperado.
4.7 Exercícios
1. Elabore um programa que leia 10 números inteiros. Ao final, mostre a soma de todos os números
lidos utilizando while.
2. Faça um programa que some os números ímpares entre 0 e 100 utilizando while.
3. Faça um programa em que sejam lidos números inteiros maiores que zero (encerre a digitação
quando for informado o número zero). Ao final, mostre a média dos números lidos.
4. Faça um programa que leia as notas de vários alunos em uma prova de Programação I (encerre a
digitação quando for informada uma nota menor que zero). Ao final, mostre:
25
(a) A média da sala
(b) A maior nota
(c) A menor nota
(d) Quantas notas foram menores que 7.0
5. Utilizando a estrutura while, escreva os comandos para gerar as seguintes sequências de valores:
(a) 3, 8, 13, 18, 23
(b) 20, 14, 8, 2, -4, -10
(c) 19, 27, 35, 43, 51
6. Escreva um programa que some uma sequência de inteiros. Assuma que o primeiro número infor-
mado especifique a quantidade de números que devam ser lidos. Exemplo:
5 40 80 97 23 44
o primeiro número lido (5) indica que devem ser lidos mais 5 números. Ao final, exiba a soma.
7. Escreva um programa em que o usuário informe dois valores inteiros: inicio e fim. O programa
deve exibir todos os números entre o inicio e fim.
Exemplo : ENTRADAs→ 8 e 14
SAIDA→ 8, 9, 10, 11, 12, 13, 14
8. Faça um programa em que o usuário digite um valor, e o programa gere a sequência de Fibonacci
com uma quantidade de elementos igual ao fornecido pelo usuário.
Exemplo : ENTRADA→ 8
SAIDA→ 1, 1, 2, 3, 5, 8, 13, 21
9. Faça um programa para calcular o fatorial de um número informado pelo usuário.
10. Faça um programa que leia um número e diga se ele é primo ou não.
11. Elabore um programa que calcule o somatório:
soma = 11 + 3
2 + 53 + ...+ 99
50
12. Elabore um programa que calcule o somatório:
soma = 11 −
24 + 3
9 −416 + 5
25 ...−10100
13. Faça um programa em que seja declarado um número inteiro entre 1 a 100. O usuário (que não
sabe qual o número) deverá tentar adivinhá–lo. Para cada tentativa, o programa deve dizer se o
número digitado é maior ou menor que o número correto. Quando o usuário acertar, o programa
deve dizer quantas tentativas foram feitas até a adivinhação.
14. Faça um programa que realize as operações básicas de uma calculadora. O programa deve fornecer
um menu com as seguintes opções:
1 - Somar
2 - Subtrair
3 - Multiplicar
4 - Dividir
26
5 - Sair
O usuário deverá escolher qual a operação desejada, e somente depois disso o programa solicita os
2 números da operações. Depois de calculado e mostrado o resultado, o programa deve mostrar o
menu novamente. O programa só deverá finalizar caso o usuário escolha a opção 5.
15. Faça um programa que mostre a tabuada de um número fornecido pelo usuário.
16. (Pedágio) Em uma praça de pedágio passam diversos tipos de veículos: carros (c), motos (m) e
caminhões (h). A tarifa para carros é de R$ 8,00, para motos R$ 4,00 e para caminhões R$ 20,00.
Faça um programa, utilizando a estrutura de repetição while combinada com a estrutura de seleção
switch, em que sejam inseridos os códigos dos veículos que passam pelo pedágio (c, m ou h). Não
se sabe com antecedência quantos veículos vão passar, assim, encerre a entrada de dados quando
for digitado um código igual a ‘x’. Para cada veículo, mostre o quanto vai pagar. Ao final, o
programa deve mostrar o total arrecadado pela benevolente concessionária.
17. (Quem será premiado) Um professor deseja premiar o aluno com a maior nota com um livro de
Linguagem C. Como são muitos os alunos, faça um programa para automatizar a apuração. O
programa deve ler a nota e o número de cada aluno. Ao final, deve mostrar o número do aluno a
ser premiado e a nota que ele obteve. (Para simplificar, admita que nenhuma nota é igual à outra.)
18. (República) Alguns alunos de Sistemas de Informação e de Ciência da Computação resolveram
montar uma república, a qual foi batizada de “RepThon”. As despesas comuns, como de costume,
são divididas entre os membros. Assim, eles fizeram um programa de computador em que são
inseridos os valores das despesas (água, luz, telefone, etc). Não se sabe com antecedência quantos
valores serão inseridos, então encerre a repetição quando for digitado o valor -1. Não é necessário
especificar a despesa, o programa deve receber apenas o valor. Faça um programa que leia os
valores das despesas e mostre o quanto cada um tem de pagar. Note que é necessário entrar com
a quantidade de moradores. Detalhe: como os alunos são precavidos, eles acrescentam 10% como
fundo de reserva para eventuais imprevistos.
19. (Jogo de dados) Elabore um programa que simule um jogo de dados. O dado deve ser jogado 787
vezes. Ao final, deve ser exibido a porcentagem que cada lado saiu. Faça um histograma para
exibir a porcentagem.
20. (Adega) O dono de um restaurante deseja saber quantas garrafas de vinho de cada tipo há na adega.
Escreva um algoritmo para contar as garrafas e classificar os vinhos pelos tipos ‘T’ para tinto, ‘R’
para rosê e ‘B’ para branco. O algoritmo deverá escrever no final:
(a) o total de garrafas de vinho tinto
(b) o total de garrafas de vinho rosê
(c) o total de garrafas de vinho branco
(d) o total geral de garrafas
A quantidade de garrafas é desconhecida, por isso utilize uma estrutura de repetição com teste
no final. O final da digitação ocorre quando é informado o tipo ‘X’. O algoritmo deverá tratar
respostas erradas (diferentes de ‘T’, ‘R’, ‘B’ ou ‘X’) mostrando uma mensagem “Tipo inválido”.
27
21. Tanque de combustível A destilaria de álcool Destila S/A deseja controlar o carregamento de
caminhões tanque. Considere que há uma fila de caminhões para serem carregados e que os cami-
nhões podem ter capacidades diferentes. Faça um programa que, inicialmente, leia a quantidade
de álcool no tanque (existe um único tanque). A seguir, faça uma estrutura de repetição que leia
a capacidade do caminhão e, para cada caminhão carregado, subtraia a quantidade carregada da
quantidade existente no tanque. Encerre a leitura quando não houver mais caminhão para ser car-
regado (digite -1 para encerrar) ou quando não houver mais combustível no tanque. Ao final, exiba
quanto de combustível restou no tanque.
Exemplos:
Entradas Saída100, 30, 30, 30, 10 Restou no tanque: 0200, 100, 150 Restou no tanque: 0200, 100, -1 Restou no tanque: 100200, 100, 20, -1 Restou no tanque: 80
22. Escreva um programa que imprima os triângulos da figura usando for. Imprima separadamente,
um após o outro. Dica: os dois últimos exigem que cada linha comece com uma quantidade
apropriada de espaços.
(A) (B) (C) (D)
* ********** ********** *** ********* ********* ***** ******** ******** ******* ******* ******* ********* ****** ****** *********** ***** ***** ************* **** **** *************** *** *** ***************** ** ** ******************* * * **********
23. Faça um programa em que seja lido um número inteiro. Gere a figura seguinte com base nesse
número. Exemplo: 4. Será gerada a figura:
****************
24. Faça um programa em que sejam lidos um número inteiro e um caractere. Gere a figura seguinte
com base nos dados fornecidos. Exemplo: 3, #. Será gerada a figura:
28
#########
29
Capítulo 5
Listas
As variáveis utilizadas nos programas até agora armazenavam um único valor. Neste capítulo veremos
um tipo de variável que é, na verdade, uma estrutura de dados: a lista.
Listas são estruturas que permitem o armazenamento de vários dados. Em Python, listas podem
conter elementos do mesmo tipo ou de tipos diferentes. O tamanho de uma lista é igual à quantidade de
elementos que ela contém. Uma lista sem elementos é uma lista vazia.
Cada elemento da lista é acessado por meio de um índice que representa sua posição na lista. O
primeiro elemento está na posição 0, o segundo na posição 1 e assim por diante.
Listas são estruturas dinâmicas, assim chamadas porque podem crescer ou diminuir ao longo da
execução do programa.
5.1 Declarando Listas
Uma lista é criada por meio de declaração de uma variável do tipo lista:
lista = [ ]
O que determina que a variável lista seja o tipo lista é a colocação dos colchetes após o operador
de atribuição. Na declaração anterior a lista foi criada vazia. Listas, no entanto, podem ser criadas com
seus elementos.
vogais = ["a", "e", "i", "o", "u"]
Neste exemplo, criamos uma lista chamada vogais de tamanho 5. Os elementos de uma lista podem
ser acessados individualmente, indicando–se seu índice. Assim, se executarmos a instrução:
print(vogais[1])
será exibida a letra e.
XLembre–se: o primeiro elemento de uma lista está na posição 0 e o último na posição tamanho - 1.
5.2 Percorrendo Listas
Para percorrermos listas (acessarmos seus elementos um a um em sequência) utilizamos, geralmente,
estruturas de repetição. Por exemplo, vamos supor que queremos ler as respostas de uma prova de
múltipla escolha com 10 questões, podemos ter o seguinte programa mostrado na Figura 5.1.
30
Figura 5.1: Lendo os elementos de uma lista.
No programa utilizamos a variável i para acessar a posição da lista em que o valor digitado deve ser
inserido.
XTentar acessar uma posição fora da lista causa erro em tempo de execução.
5.3 Listas dinâmicas
Ao contrário do exemplo apresentado na Figura 5.1, em que uma lista foi declarada com tamanho 10,
podemos ter casos em que não sabemos o tamanho que a lista terá. Nestes casos, podemos criar uma
lista vazia e adicionar elementos conforme for necessário.
Listas são objetos que podem crescer. Não importa no momento o que são objetos, basta saber
que eles possuem métodos que são como que subprogramas que agem sobre os objetos nos quais estão
contidos. Assim, toda lista possui o método append que adiciona um elemento a ela.
No programa mostrado na Figura 5.2 uma lista vazia é criada (linha 1). Uma estrutura de repetição
foi utilizada para ler diversos nomes até que a palavra “fim” for digitada. Sempre que o texto digitado
for diferente de “fim” ele é adicionado ao final da lista por meio do método append (linha 7).
Figura 5.2: Adicionando elementos a uma lista.
5.3.1 Descobrindo o tamanho da lista
Especialmente no caso de listas dinâmicas, em que o tamanho muda durante a execução do programa,
pode ser necessário conhecer seu tamanho em determinado momento. Isto pode ser feito facilmente por
meio da função len(). A instrução:
print(len(nomes))
irá mostrar quantos elementos tem a lista chamada nomes.
31
Em uma lista dinâmica saber a quantidade de elementos pode ser útil para, por exemplo, percorrer
uma lista do primeiro ao último elemento. O programa da Figura 5.3 percorre uma lista de nomes para
saber se existe o nome “Python”. É necessário saber o tamanho da lista para determinar a condição de
parada do while (linha 5).
Figura 5.3: Percorrendo uma lista em busca de um elemento.
5.4 Remoção de Elementos da Lista
Por sua natureza dinâmica (capacidade de aumentar e diminuir durante a execução do programa), ele-
mentos podem ser retirados da lista. Há duas formas de remover um elemento: por meio da função del
(delete) ou por meio do método remove().
A função del recebe como argumento a posição da lista que deve ser removida. Por exemplo, para
removermos o segundo elemento de uma lista (elemento de índice 1):
del lista[1]
XTentar remover uma posição que não existe causa erro em tempo de execução.
O método remove() é chamado por meio do operador de ponto e remove um elemento específico
da lista, ao contrário da função del que remove uma posição.
lista = ["cebola", "alho", "pimenta", "mostarda"]
lista.remove("alho")
XTentar remover um objeto que não está na lista causa erro em tempo de execução.
Em resumo, del remove uma posição, não importando o conteúdo, enquanto remove() remove
um conteúdo, sem importar a posição em que ele está.
5.5 Percorrendo listas por meio de for
Entre as operações típicas com listas podemos citar: buscar se um determinado elemento está na lista,
buscar a posição de um elemento, ordenar a lista. Para realizar estas operações é necessário utilizar
32
estruturas de repetição. Python possui uma estrutura especialmente criada para percorrer listas: for. No
exemplo a seguir os elementos da lista são mostrados por meio da estrutura for.
lista = ["cebola", "alho", "pimenta", "mostarda"]for elemento in lista:
print(elemento)
O mesmo trecho de programa pode ser escrito por meio de while, no entanto, com um pouco mais
de código. Observe que precisamos verificar explicitamente o tamanho da lista e utilizar uma variável
para controlar o índice do elemento a ser acessado.
lista = ["cebola", "alho", "pimenta", "mostarda"]i = 0while i < len(lista):
print(lista[i])i += 1
5.6 Ordenando Listas
Ordenação é uma operação muito comum com listas. Podemos querer, por exemplo, ordenar uma lista
de alunos por ordem alfabética, uma lista de candidatos por ordem de pontuação do maior para o menor,
e assim por diante.
Existem algoritmos prontos para realizar ordenação de listas. Um dos mais simples é conhecido
como método bolha. Este algoritmo não é considerado eficiente, mas para pequenas listas pode ser
utilizado sem problemas.
No programa mostrado na Figura 5.4 é realizada a ordenação de uma lista de strings. O código entre
as linhas 2 e 13 é o algoritmo do método bolha e serve, praticamente, para ordenar qualquer coleção de
objetos.
33
Figura 5.4: Ordenando pelo método bolha.
5.7 Exercícios
1. (Invertendo)Faça um programa em que o usuário insira uma quantidade qualquer de números e,
em seguida, o programa mostre os números na ordem inversa da qual foram inseridos.
2. (Elementos duplicados) Escreva um programa utilizando uma lista para resolver o seguinte pro-
blema. Leia 20 números. Para cada número lido, armazene na lista apenas se ele ainda não estiver
nela.
3. (Provas) Faça um programa para correção de provas. O programa deve armazenar em uma lista
chamada gabarito as alternativas corretas das questões. A seguir, armazene em outra lista chamada
resp as respostas do aluno. Ao final, mostre quantos pontos o aluno fez, considerando que cada
questão vale um ponto.
4. (Compras) Faça um programa que peça ao usuário inserir 5 itens comprados em uma loja. Para
cada item, deve ser informado seu código, quantidade e seu valor unitário. Depois disso, montar
na tela um “demonstrativo” contendo a informação do código, quantidade, valor unitário e valor
total de cada item, e um valor total geral. Exemplo:
34
Código Qtde Val. Unit. Val. Tot.------------------------------------------------------0001 10 0,50 5,000007 2 7,50 15,000158 1 100,00 100,000021 7 7,00 49,000008 2 1,00 2,00------------------------------------------------------Valor Final: 171,00
5. (Vestibular) Faça um programa que gerencie o resultado do vestibular. Para sua felicidade, só
existe um curso e o curso tem 10 vagas. O programa deve manter a lista dos 10 classificados.
O programa também mantém, em outra lista (de 20 posições), a lista de espera, que contém os
candidatos aprovados, mas excedentes ao número de vagas (caso algum candidato classificado
desista, será chamado um da lista de espera). A lista de espera pode ter até 20 candidatos.
O programa deve solicitar o número do candidato e dizer:
(a) se ele foi classificado, ou
(b) se ele está na lista de espera, neste caso, indicar em que lugar da fila de espera ele está, ou
(c) se ele não foi aprovado.
Exemplo. Sejam os classificados:
20 32 01 14 99 34 21 02 15 07
Seja a lista de espera (valor -1 significa que não há candidato):
08 04 10 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
Exemplos de consultas:
Entrada Saída01 “classificado”04 “número 2 na lista de espera97 “não aprovado”
35
Capítulo 6
Strings
Já falamos um pouco sobre strings no Capítulo 2. São variáveis que armazenam texto, ou, em outras
palavras, cadeia de caracteres. Neste capítulo aprofundaremos um pouco mais o assunto.
6.1 Declaração de strings
Para se declarar uma string atribui–se texto à variável por meio de aspas. Em Python, aspas simples e
aspas duplas são equivalentes: indicam que o que está entre aspas é texto. Exemplos:
s1 = “”
s2 = “Um texto qualquer”
A variável s1 é do tipo string e seu tamanho é 0. A variável s2 também é uma string de tamanho 17.
Os elementos de uma string podem ser acessados individualmente. A instrução:
print(s2[0])
irá exibir o conteúdo da posição 0 da string, no caso, a letra U.
No entanto, strings são imutáveis. Tentar alterar o conteúdo de uma string como no trecho a seguir
resulta em erro:
s[0] = “x”
6.2 Operações com strings
Existem várias operações que podem ser realizadas com strings bem como várias funções para manipulá–
las. A seguir são comentadas apenas algumas delas.
Conversão de string em lista
Para converter uma string em lista:
s1 = “Um texto qualquer”
s2 = list(s1)
Para converter uma lista em string:
s1 = “”.join(s2)
36
Concatenação
Pode–se concatenar strings por meio do operador de adição:
s = “Um texto ” + “qualquer”
Agora o conteúdo da variável s é “Um texto qualquer”.
Pesquisa cadeia dentro da string
Para pesquisarmos se um texto está contido dentro de uma string utilizamos a cláusula in. No exemplo
a seguir queremos saber se a string s contém o texto “Uenp”.
“Uenp” in s
Na verdade in funciona como um teste lógico que retorna verdadeiro se s contém o texto pesquisado ou
falso se não contém.
Outra forma de utilizar in é com o operador de negação not que faz o inverso: retorna verdadeiro se
o texto pesquisado não está contido em s.
“Uenp” not in s
XLembre–se que a correspondência deve ser exata no que se refere a maiúsculas e minúsculas.
6.2.1 Funções internas do tipo string
Na Tabela 6.1 estão listadas algumas funções úteis para manipulação de strings. Considere que s é uma
variável do tipo string.
Função Exemplo Explicaçãocount() s.count(“xt”) Retorna a quantidade de vezes que “xt” aparece em sendswith s.endswith(“fim”) Retorna True se s termina com “fim”find() s.find(“xt”) Retorna o índice da primeira letra da cadeia procurada ou -1 caso
ela não existaisnumeric() s.isnumeric() Retorna True se todos os caracteres da string são numéricoslower() s.lower() Converte s para minúsculasrelace() s.replace(s1, s2) Substitui todas as ocorrências em s iguais a s1 por s2upper() s.upper() Converte s para maiúsculas
Tabela 6.1: Principais funções do tipo string.
É importante lembrar que funções como upper() criam uma cópia da string com todas as letras
maiúsculas, em nada alterando a string original.
6.3 Exercícios
1. (Misturando) Escreva um programa que leia dois textos. O programa deve gerar um terceiro texto
em que a primeira letra seja a primeira letra do primeiro texto. A segunda letra deve ser a primeira
letra do segundo texto e assim por diante. Exiba o texto final.
37
2. (Dieta) Falafel está com problemas de excesso de peso, então ele foi ao médico e este lhe pres-
creveu uma dieta. A dieta é muito simples: dada uma lista de alimentos, ele só pode comer se o
alimento estiver na lista e se ainda não foi consumido no dia. Faça um programa que controle a
dieta de Falafel. Inicialmente, o programa deve pedir a dieta recomendada pelo médico, na forma
de uma lista de até 26 caracteres. A seguir, cada vez que Falafel desejar comer, ele informa ao pro-
grama o alimento. O programa deve dizer “pode comer”, se o alimento estiver na lista e ainda não
tiver sido comido, ou ‘‘não pode comer”, caso contrário. Encerre a digitação quando for digitado
‘#’ para o código do alimento.
Exemplos:
Seja a dieta: ABFGHIK
Casos de teste:
B→ “pode comer”
F→ “pode comer”
I→ “pode comer”
R→ “não pode comer”
B→ “não pode comer”
#
3. Escreva um programa que leia um caractere e diga se ele é uma letra. Se for letra, diga se é
minúscula ou maiúscula.
4. Faça um programa em que o usuário digite uma letra e um número inteiro. Caso a letra seja vogal e
o número for par, ou a letra for consoante e o número ímpar, mostre “BAZINGA!”. Caso contrário,
mostre “SHAZAM!”.
5. Escreva um programa que leia uma caractere e leia uma string. O programa deve mostrar se o
caractere é igual à primeira letra da string.
6. Escreva um programa que leia uma caractere e leia uma string. O programa deve mostrar quantas
vezes o caractere aparece na string.
7. Faça um programa que leia um texto. O programa deve contar e exibir quantas vogais há no texto.
8. Faça um programa que leia um texto. O programa deve contar e exibir quantas vogais há no texto,
sem contar vogais repetidas. Exemplo:
Entrada: “Este texto tem vogais”
Saída: 4
9. (Vogais) Faça um programa que, dada uma frase, retire todas as vogais da frase. Assim, a frase:
borboletas amarelas
seria transformada em
brblts mrls
Importante: não é para apenas exibir a frase sem as vogais, é para modificar a string (retirar as
vogais) ou criar uma nova string sem elas.
38
10. Faça um programa que converta todas as letras de uma frase para maiúsculas. Exemplo:
Entrada: esTA É uMa frasE
Saída: ESTA É UMA FRASE
11. Faça um programa que converta a primeira letra de cada palavra para maiúscula e as demais para
minúsculas. Exemplo:
Entrada: esTA É uMa frasE
Saída: Esta É Uma Frase
12. (Telefone) Jordoel é muito paquerador, porém muito supersticioso. Quando ele conhece uma
garota, ele pede o celular dela, mas só vai em frente se for um número de sorte. De acordo com
seus cálculos numerológicos, um número traz sorte quando:
(a) não possui o dígito 6
(b) o último dígito é menor que 3
(c) possui o dígito 2 ou 8
Faça um programa que ajude ao Jordoel a determinar se um número é de sorte ou não.
Entrada: um array de char com o número de telefone
Saída: uma mensagem dizendo se é um número de sorte ou não.
Exemplos:
9745-8222→ “número de sorte”
9745-6322→ “não é um número de sorte”
9788-8227→ “não é um número de sorte”
9834-9991→ “número de sorte”
39
Capítulo 7
Funções
Até agora utilizamos várias funções da linguagem Python, como input() e print(). Funções são
“pequenos módulos” que realizam uma tarefa específica. Por exemplo, a função print() realiza a
tarefa de exibir os dados passados como argumento na tela do computador.
Quando escrevemos programas combinamos funções prontas da linguagem com funções escritas por
nós. Para pequenos programas, não é necessário dividi–los em partes menores (funções). No entanto,
para programas com muitas linhas de código, torna–se impraticável construi–lo como um único bloco.
Assim, o comum é que um programa seja constituído de vários módulos, relativamente pequenos, de
forma que cada bloco seja responsável por uma funcionalidade específica.
Há diversas razões para se dividir um programa em funções, entre elas:
1. Não é necessário repetir trechos de código;
2. É mais fácil alterar funcionalidades;
3. É mais prático encontrar e corrigir erros; e
4. Pode–se criar bibliotecas de funções reutilizáveis.
7.1 Utilizando Funções da Linguagem Python
As linguagens de programação possuem centenas de funções prontas. Algumas delas, como input()
fazem parte do núcleo da linguagem e não precisamos fazer nada para utilizá–las. No entanto, algumas
funções mais específicas, como para calcular o seno e cosseno, por exemplo, devem ser “importadas”
quando formos utilizar. Devemos informar ao interpretador que utilizaremos certas funções que não
pertencem ao núcleo da linguagem.
Por exemplo, para calcular a raiz quadrada de um número existe a função sqrt(). Para utilizar
esta função, devemos importá–la para nosso programa por meio do comando import. Acontece que
sqrt( ) está “empacotada” em uma biblioteca chamada math, juntamente com dezenas de outras
funções matemáticas. A instrução:
import math
torna a biblioteca disponível ao programa. Para utilizar a função sqrt():
raiz = math.sqrt(25)
40
Observe que utilizamos o nome da biblioteca + operador de ponto + nome da função. Outra forma
de se fazer isso é:
from math import sqrt
Neste caso, para utilizar a função, basta:
raiz = sqrt(25)
A diferença entre as duas formas é que na primeira importamos a biblioteca math inteira e na segunda,
apenas a função sqrt().
7.2 Conceitos
Para ilustrar alguns conceitos sobre funções, observe o programa mostrado na Figura 7.1.
Figura 7.1: Exemplo de função.
Como já dissemos, a função sqrt() pertence à biblioteca math. Por isso, é necessário o import
na linha 1. Na linha 3 sqrt() foi utilizada. Dizemos que o programa “chamou” a função. Por seu lado,
a função sqrt() foi “chamada” pelo programa.
A constante entre parênteses é chamada de argumento e é “passada” para a função. Argumentos são
valores (constantes, variáveis, expressões) dos quais a função precisa para realizar sua tarefa. Na função
os valores passados são “recebidos”. Os valores recebidos são chamados de parâmetros.
Deve haver a correspondência entre o que a função recebe e o que é passado. A função sqrt()
espera um número como parâmetro, então, não podemos passar um texto (tipo inválido) ou mais de um
número (quantidade de argumentos inválida).
Ainda na linha 3, a variável raiz recebe o retorno da função. Uma função que recebe um número e
calcula sua raiz quadrada devolve (retorna) o resultado. Portanto, deve haver uma variável para receber
o retorno da função. É importante lembrar que nem todas as funções retornam valor e que nem sempre o
retorno precisa ser atribuído à uma variável.
A seguinte construção é válida:
print(sqrt(25))
O retorno da função é passado para a função print(). O importante é tratar o retorno das funções que
retornam valor.
7.3 Criando Funções
Além de saber usar as funções da linguagem, o programador deve saber escrever suas próprias funções.
Uma função tem a seguinte forma:
41
def <nome da função> (<parâmetros>):<corpo da função>
7.3.1 Funções que não recebem parâmetros e não retornam valor
Vamos criar uma função que escreva “Python” na tela, mostrado na Figura 7.2.
Figura 7.2: Exemplo de função.
A função foi chamada na linha 5. Para chamar uma função, basta escrever seu nome, sem esquecer
os parênteses. Observe que não foram passados argumentos para a função. As linhas 1 e 2 fazem
parte da função escrevePython(). Não há nada entre os parênteses porque esta função não recebe
parâmetros.
7.3.2 Funções que recebem parâmetros e não retornam valor
Vamos modificar nossa função, agora passando a quantidade de vezes que a palavra “Python” deve ser
exibida na tela. A nova versão da função é mostrada na Figura 7.3.
Figura 7.3: Exemplo de função com parâmetros.
Agora a função possui um parâmetro (no cabeçalho, linha 1) que corresponde à quantidade de vezes
que a palavra “Python” deve ser escrita. Ao ser chamada, na linha 7, é passado um argumento (o número
3), que será recebido pela variável vezes.
Vamos modificar novamente o programa, Agora a função possui dois parâmetros: um texto e a
quantidade de vezes que deve ser escrito. O programa é mostrado na Figura 7.4.
É importante observar a ordem dos valores. A função espera um texto e um número (linha 1),
portanto, ao chamá–la, devemos passar um texto e um número (linha 7).
42
Figura 7.4: Exemplo de função com dois parâmetros.
7.3.3 Funções que recebem parâmetros e retornam valor
Na maioria das vezes, as funções recebem parâmetros, realizam algum processamento com eles e retor-
nam algum resultado. Considere um programa que precisa calcular a área de um círculo. Sabemos que a
área é igual a PI multiplicado pelo quadrado do raio. Podemos isolar o cálculo da área em uma função,
como a mostrada na Figura 7.5. A função recebe a medida do raio, realiza o cálculo e retorna o resultado.
Figura 7.5: Exemplo de função com dois parâmetros.
Observe que utilizamos a constante simbólica math.pi na linha 4. Constantes simbólicas são
nomes para referenciar alguma constante predefinida, no caso, PI.
7.4 Funções Recursivas
Os programas que vimos até agora são constituídos de funções que chamam outras funções, de maneira
hierárquica. Para alguns tipos de problemas, como algoritmos de busca e classificação, existe o que
chamamos de função recursiva.
Função recursiva é um tipo de função que chama a si mesma. Há dois elementos essenciais em uma
função recursiva:
Caso base: a parte do problema que a função sabe resolver. Se a função é chamada com o caso base,
simplesmente retorna o resultado.
Caso recursivo: situação em que ainda não se chegou à solução e é necessário chamar novamente a
função, agora com uma parte “menor” do problema.
As chamadas recursivas, uma vez que dividem o problema em um problema menor, em um dado mo-
mento chegam ao caso base.
43
7.4.1 Cálculo do fatorial por recursividade
O fatorial de um número inteiro não negativo n, ou n! (n fatorial), é o produto:
n * (n-1) * (n-2) * ... * 1
1! é igual a 1 e 0!, por definição, é 1. O fatorial pode ser calculado de maneira iterativa (estrutura de
repetição) como mostrado na Figura 7.6.
Figura 7.6: Cálculo de fatorial por iteração.
Embora este problema seja simples de resolver de forma iterativa, ele serve de exemplo para ilustrar
o conceito de recursão. A solução recursiva para o cálculo do fatorial é:
n! = n * (n-1)!
A função para cálculo recursivo do fatorial é mostrada na Figura 7.7.
Figura 7.7: Cálculo de fatorial recursivamente.
Observe que o caso base é testado na linha 2 (n <= 1). Se o caso base não foi alcançado, a função é
chamada novamente com n-1 (linha 5).
7.5 Módulos
Até agora estamos escrevendo nossas funções em um único arquivo. Isto tende a deixar os programas
com muitas linhas de código e difíceis de dar manutenção posteriormente. Além disso, fica difícil para
outros programas utilizarem as funções criadas. A solução é armazenar as funções em arquivos separa-
dos. Em Python, todo arquivo com a extensão .py pode ser considerado um módulo. Para utilizar uma
função que está em outro módulo utilizamos o comando import.
44
Considere que estamos desenvolvendo um sistema que trabalhe com datas, nomes dos dias da se-
mana, calcule dias entre uma data e outra... Podemos criar funções específicas para cada coisa em um
arquivo chamado tempo.py. Na Figura 7.8 é mostrado um trecho do possível arquivo.
Figura 7.8: Um arquivo com funções.
Neste arquivo há a função obterDiaDaSemana() que nos retorna o dia por extenso. Quando, em
um programa, precisarmos desta funcionalidade, basta chamar a função, como é mostrado na Figura 7.9
em que a função é chamada na linha 3. Observe que tivemos que importar a função (linha 1), pois está
em outro arquivo.
Figura 7.9: Um arquivo com funções.
7.6 Considerações Finais
A modularização de programas é uma das melhores práticas para torná–los fáceis de manter. A divisão
de um programa em funções ou de uma aplicação em módulos torna os programas mais fáceis de serem
escritos, corrigidos, melhorados.
7.7 Exercícios
1. (Chamada de função) Escreva uma função que, ao ser chamada pelo programa principal, exiba a
mensagem “Olá pessoal”.
45
2. (Passagem de parâmetro) Escreva um programa em que seja lido um número inteiro. Passe este
número para a função exibe( ) que deve mostrar o valor na tela.
3. (Passagem com retorno) Escreva um programa em que sejam lidos dois números. Passe estes
números para a função somar( ) que deve somar os dois números. O resultado da soma deve ser
retornado ao programa principal, que deve exibir este valor.
4. (Quadrado) Faça um programa em que sejam lidos um inteiro n e um caractere c. Chame uma
função desenhar( ) que deve mostrar um quadrado com n linhas e n colunas com o caractere dado.
Exemplo:
Entrada: 3, #
Saída:
###
###
###
5. (Estacionamento) Um estacionamento cobra a taxa mínima de R$ 5,00 por até 3 horas de per-
manência. A partir da terceira hora, cobra R$ 3,00 por hora. O máximo que o cliente paga, no
entanto, é o valor da diária, que é de R$ 20,00. (Assuma que nenhum carro fique estacionado por
mais de 24 horas). Escreva um programa em que seja informada a quantidade de horas que o carro
ficou estacionado. Chame a função calcula( ), que deve retornar o quanto o cliente tem que pagar.
6. (Inversão) Escreva uma função que receba um inteiro e retorne o número com os dígitos inverti-
dos. Exemplo:
Entrada: 7631
Saída: 1367
7. (Idade) Crie um programa em que seja informada a sua data de nascimento. A data deve ser pas-
sada para a função calculaIdade( ). A função calculaIdade( ) deve chamar a função obterAnoCor-
rente( ) para pegar o ano atual com base no relógio do sistema operacional. A sua idade calculada
deve ser mostrada na função principal. Considere apenas o ano de nascimento, ignorando mês e
dia.
8. (Somando intervalo) Faça um programa em que sejam lidos 2 inteiros. Passe esses valores para a
função calcularIntervalo( ) que deve retornar a soma de todos os números informados, excetuando-
se os números recebidos. Exiba o resultado. Exemplo:
Entrada: 2, 7
Saída: 18
(Saída = 3 + 4 + 5 + 6)
9. (Convertendo horas) Faça uma função que receba um valor representando horas e retorne a quan-
tidade de minutos correspondentes. Exemplo:
Entrada: 3.5
Saída: 210 minutos
46
10. (Comuns) Escreva um programa que tenha a função listarComuns( ). Esta função recebe duas
listas de inteiros e exibe os elementos comuns a ambos. Exemplo:
a= { 2, 5, 8, 3} e b= { 3, 9, 2, 7}
saída: 2, 3
11. Lista Faça um programa que tenha um menu com as opções:
1) Preencher lista
2) Exibir lista
3) Exibir lista invertida
4) Sair
Uma lista deve ser declarada no programa principal. A opção 1 chama uma função que lê os
elementos da lista (prenche a lista), a opção 2, chama uma função que exibe a lista na tela e a
opção 3 chama uma função que exibe do último elemento para o primeiro.
12. Lista 2 Faça um programa em que seja declarada uma lista de 10 posições. Leia, ainda no pro-
grama principal, um número inteiro. Passe a lista e o número lido para uma função que deve
colocar o número lido na primeira posição da lista e em seguida preencher as demais posições com
o dobro do valor contido na posição anterior.
47
Capítulo 8
Classes o Objetos
Até agora utilizamos tipos de dados presentes na linguagem Python, como inteiros e strings. No entanto,
é possível criar nossos próprios tipos de dados por meio da construção de classes.
8.1 Classes
Na definição de Horstmann and Cornell (2011), uma classe é “o modelo ou esquema a partir do qual
objetos são criados”. Por exemplo, podemos ter a classe Carro, que é um novo tipo, e criar variáveis
deste tipo.
Classes, ao contrário de tipos primitivos, associam dados e operações em uma única estrutura. Os
dados de uma classe são chamados de atributos ou campos. As operações de uma classe (funções) são
chamadas de métodos.
Para ilustrar, vamos criar a classe Carro simplificada, com os atributos ligado e velocidade.
class Carro: # 1def __init__(self): # 2
self.ligado = false # 3self.velocidade = 0 # 4
Utilizamos a palavra reservada class para definir uma nova classe (linha 1). Uma classe possui
um método especial (__init__(self)), que é conhecido como construtor da classe (linha 2). Um
construtor é o método que é chamado quando criamos um objeto do tipo Carro. O construtor “constrói”
objetos, inicializando os atributos com os valores definidos pelo programador. No exemplo acima, todo
carro é criado com o atributo ligado como False e com o atributo velociadade igual a zero.
Ainda com base neste exemplo, observe que na linha 3 a declaração da “variável” ligado é antece-
dida pela palavra reservada self. Isto indica que ligado não é uma variável local, e sim um atributo
da classe. O mesmo ocorre com o atributo velocidade.
8.2 Instanciando Objetos
Instanciar um objeto é declarar uma variável do tipo da classe. Para instanciar um objeto da classe
Carro, declaramos a variável e chamamos o construtor da classe:
48
c = Carro( )
Observe que o construtor é chamado por meio do nome da classe e os parênteses. Para acessar os
campos do objetos, utilizamos o nome da variável seguido do operador de ponto:
print(c.velocidade)
8.3 Métodos
Métodos são como funções internas ao objeto e definem seu comportamento. Continuando o exemplo,
um carro pode executar as ações ligar motor, desligar motor, acelerar, frear... Logicamente um carro
real faz muito mais que isso, mas em programação praticamos o que é chamado de abstração: represen-
tamos apenas um subconjunto de características que interessa ao programa.
Vamos incrementar a classe Carro adicionando o método ligarMotor( ).
class Carro: # 1def __init__(self): # 2
self.ligado = false # 3self.velocidade = 0 # 4
def ligarMotor(self): # 5self.ligado = True # 6
Na linha 5 foi definido o método ligarMotor(), que altera o atributo ligado para True. Mé-
todos sempre possuem a palavra reserva self como primeiro parâmetro, podendo possuir outros parâ-
metros.
A seguir é mostrada a classe Carro com outros métodos. O método acelerar( ) incrementa a
velocidade em 10 unidades e o método frear( ) realiza a ação inversa.
class Carro:def __init__(self):
self.ligado = Falseself.velocidade = 0
def ligarMotor(self):self.ligado = True
def desligarMotor(self):self.ligado = False
def acelerar(self):self.velocidade += 10
def frear(self):self.velocidade -= 10
49
Os métodos podem ser escritos de maneira a garantir que os objetos não atinjam estados inválidos.
Por exemplo, não é admissível que um carro tenha velocidade negativa. Assim, podemos alterar nosso
método como segue:
def frear(self):if self.velocidade == 0:
returnself.velocidade -= 10
8.4 Considerações Finais
A utilização de classes e objetos faz parte de um paradigma de programação chamado de “Orientação a
Objetos”. Neste capítulo foi dada apenas uma introdução ao paradigma, estudos mais profundos serão
realizados em outras disciplinas.
8.5 Exercícios
1. Robô. Crie uma classe chamada Robô com os atributos x e y que indicam os pontos no plano
cartesiano. O construtor deve inicializar estes atributos com 0 e 0. Crie o método andar( ) que
recebe como parâmetros os novos pontos x e y para onde o robô deve se posicionar.
2. Clientes. Crie um programa que gerencie uma lista de clientes. Os dados de cliente são:
código (inteiro)
nome (cadeia de caracteres)
endereço (cadeia de caracteres)
O programa deve ter um menu com as opções:
(a) Cadastrar
(b) Consultar por código
(c) Consultar por nome
(d) Exibir em ordem
(e) Excluir cliente
Não deve haver mais de um cliente com o mesmo código.
3. Alunos. Um professor de estatística costuma sortear alunos para que resolvam exercícios. Para
isso, ele diz o número do aluno e este deve ir até o quadro e resolver um exercício proposto. No
entanto, como são muitos exercícios, o professor nem sempre se lembra se um aluno já foi sorteado
ou não. Assim, ele limitou a quantidade de vezes que um mesmo aluno pode ser premiado na
mesma semana, para que os outros também possam ter oportunidade. O problema é que é difícil
controlar quem já foi e quantas vezes já foi.
Faça um programa para auxiliar os envolvidos. O programa deve:
(a) Para cada aluno sorteado, verificar se ele já foi 3 vezes ou não
50
(b) Se ele já foi 3 vezes, exibir uma mensagem dizendo “O aluno Fulano de Tal já foi 3 vezes” e
solicitar novamente o número do aluno
(c) Se ele ainda não foi 3 vezes:
i. Caso seja a primeira vez, criar um objeto com o número, nome e a quantidade 1
ii. Caso ele já tenha ido alguma vez, alterar o aluno incrementando a quantidade de vezes
que ele foi
(d) Sempre que solicitado, exibir uma lista completa dos alunos que já foram, com número, nome
e a quantidade de vezes que foram.
Faça o programa com um menu:
1 - Informar número do aluno
2 - Mostrar lista completa
3 - Limpar arquivo
4 - Sair
Utilize a classe Aluno para manter os dados dos alunos. A classe deve ter, no mínimo, os atributos
número, nome e vezes.
Utilize funções específicas para cada tarefa do programa.
51
Capítulo 9
Arquivos
Os dados armazenados em variáveis são temporários, pois são perdidos quando o programa termina.
Arquivos em memória secundária, tais como hd’s e pen drives, são usados para retenção permanente de
dados1. Arquivos são definidos pelo iDicionário Aulete como um conjunto de dados (textos, imagens,
sons, animações, rotinas, programas etc.) gravados e armazenados como uma unidade independente e
identificável.
Neste capítulo será visto o processo de criação de arquivos, bem como leitura e escrita.
9.1 Acessando Arquivos
Podemos entender arquivo como sendo um espaço na memória permanente onde podemos gravar e ler
dados. Existem dois tipos principais de arquivos: arquivos de texto e arquivos binários. Para acessar um
arquivo é necessário abri–lo. A abertura do arquivo associa a variável do programa ao arquivo externo.
Em Python, abrimos arquivos com a função open() da seguinte forma:
<variável> = open(<nome do arquivo>, <modo de abertura>)
Exemplo:
arquivo = open("texto.txt", "a")
No exemplo:
• arquivo: nome da variável no programa
• texto.txt: nome do arquivo em disco
• a: modo de abertura
O modo de abertura determina o tipo de operação que pode ser feita com o arquivo e pode ser uma ou a
combinação de mais de uma das opções mostradas na Tabela 9.1.
Abrir um arquivo é uma operação em que o programa “toma posse” de um recurso do sistema.
Após ler do arquivo ou escrever nele, é importante fechá–lo, liberando o recurso. Para fechar o arquivo,
utilizamos a função close().1Evidentemente, se a mídia se corromper, os dados poderão ser perdidos também.
52
Modo Descriçãor Leitura (read).w Escrita (write). Apaga o conteúdo anterior, se existir.a Escrita (append). Preserva o conteúdo, se existir.b Modo binário.+ Atualização (leitura e escrita).
Tabela 9.1: Modos de abertura de arquivo.
9.2 Arquivos Texto
O tipo mais simples de arquivo é o arquivo de texto. As informações são guardadas na forma de caracteres
e podem ser lidas por qualquer editor de texto. Geralmente, são mantidos na forma de linhas de texto,
com um caractere de fim de arquivo (EOF - end of file) no final.
9.2.1 Escrevendo em um arquivo texto
Escrever em um arquivo texto é transferir dados da memória principal para o arquivo. A seguir é mos-
trado um exemplo em que se escreve uma frase em um arquivo.
arquivo = open("arquivo.txt", "a") # 1arquivo.write("Uma linha de texto") # 2arquivo.close() # 3
Na linha 1, abrimos o arquivo chamado arquivo.txt e associamos à variável arquivo. O modo de
abertura a abre o arquivo existente para adicionar informação. Caso o arquivo não exista, ele é criado.
Na linha 2 escrevemos um texto por meio da função write. Por fim, na linha 3, fechamos o arquivo com
a função close() e garantimos a integridade dos dados e liberação do recurso.
Uma observação sobre a gravação de dados: muitas vezes o sistema operacional não grava os dados
no disco imediatamente. Para economizar acessos ao disco, ele espera acumular uma certa quantidade
de dados para depois enviar ao disco. Ao fechar o arquivo, se existirem dados pendentes, estes serão
gravados.
O programa a seguir mostra como gravar diversas linhas de texto lidas a partir do teclado.
arquivo = open("arquivo.txt", "a")texto = ""while True:
texto = input("Digite o texto para ser gravadoou #fim para encerrar: ")
if texto == "#fim":break
arquivo.write(texto)arquivo.write("\n")
arquivo.close()
53
9.2.2 Lendo de um Arquivo Texto
A leitura (recuperação dos dados) de um arquivo texto pode ser feita por meio da função readlines(). É
necessário abrir o arquivo no modo leitura e fechar ao final. No exemplo a seguir, as linhas de texto no
arquivo são lidas e armazenadas na variável linhas, que é uma lista. Utilizando a estrutura de repetição
for, percorremos a lista e exibimos cada elemento por meio da função print().
arquivo = open("arquivo.txt", "r")linhas = arquivo.readlines()for linha in linhas:
print(linha, end="")arquivo.close()
9.3 Exercícios
1. Gravatas. Falafel trabalha em uma empresa em que a aparência é muito importante. Por exemplo,
não é elegante usar uma mesma cor de gravata duas vezes na semana. Como Falafel ocupa um
cargo importante, ele quer evitar gafes, mas ele é muito esquecido. Ao escolher uma gravata, ele
não lembra se já usou aquela cor na semana. Por isso, ele quer um programa de computador que
armazene as cores das gravatas já usadas. Cada vez que ele vai escolher uma gravata, ele informa
ao programa a cor escolhida e o programa deve dizer “Pode usar” caso a cor não tenha sido usada
na semana. Neste caso, o programa salva em arquivo a cor selecionada. Caso ele tente repetir a
cor, o programa deve informar “Não pode usar” e solicitar uma nova escolha.
Faça o programa com um menu:
1 - Escolher gravata
2 - Mostrar as usadas na semana
3 - Sair
Exemplos:
Entrada Saídabranca “pode usar”florida “pode usar”vermelha “pode usar”branca “não pode usar”amarela “pode usar”florida “não pode usar”
Utilize funções separadas para cada tarefa necessária, por exemplo, buscar se já foi usada, salvar,
etc.
2. Criptografia. Huguinho e Luizinho tiveram uma ideia genial para abrir um novo negócio e fi-
carem milionários. Eles agora estão finalizando o projeto, mas existe um problema. Como eles
residem em cidades diferentes, precisam conversar pela internet para acertar os detalhes. O medo
deles é que os arquivos trocados sejam interceptados por alguém e a ideia seja roubada. Por isso,
inventaram um algoritmo para codificar os arquivos de forma que ninguém possa entendê-las. A
codificação do arquivo funciona da seguinte maneira:
54
- o texto é “quebrado” ao meio
- um novo texto é produzido combinando uma letra da primeira parte e uma letra da segunda parte,
alternadamente
Exemplo:
“armazenar o time de futebol do usuário”
dividindo-se ao meio:
armazenar o time de
futebol do usuario
produziria o seguinte texto criptografado:
afrumtaezbeonla rd oo tuismuea rdieo
Faça o programa com um menu:
1 - Gravar texto
2 - Codificar texto
3 - Decodificar texto
4 - Exibir texto
5 - Sair
A opção 1 lê um texto a partir do teclado e salva em arquivo. A opção 2 lê o texto do arquivo,
codifica conforme descrito e salva novamente no mesmo arquivo, codificado. A opção 3 lê o
arquivo codificado, decodifica e salva novamente o texto. A opção 4 lê do arquivo e exibe na tela.
Utilize funções específicas para cada tarefa do programa.
3. Alunos.Um professor de estatística costuma sortear alunos para que resolvam exercícios. Para isso,
ele diz o número do aluno e este deve ir até o quadro e resolver um exercício proposto. No entanto,
como são muitos exercícios, o professor nem sempre se lembra se um aluno já foi sorteado ou
não. Assim, ele limitou a quantidade de vezes que um mesmo aluno pode ser premiado na mesma
semana, para que os outros também possam ter oportunidade. O problema é que é difícil controlar
quem já foi e quantas vezes já foi.
Faça um programa para auxiliar os envolvidos. O programa deve:
(a) Para cada aluno sorteado, verificar se ele já foi 3 vezes ou não
(b) Se ele já foi 3 vezes, exibir uma mensagem dizendo “O aluno Fulano de Tal já foi 3 vezes” e
solicitar novamente o número do aluno
(c) Se ele ainda não foi 3 vezes, acrescentar uma linha no arquivo com o nome do aluno.
(d) Sempre que solicitado, exibir uma lista completa dos alunos que já foram, com nome e a
quantidade de vezes que foram.
Faça o programa com um menu:
1 - Informar número do aluno
2 - Mostrar lista completa
3 - Limpar arquivo
4 - Sair
55
Armazene apenas o nome do aluno.
Utilize funções específicas para cada tarefa do programa.
56
Referências Bibliográficas
Cormen, T. H., Leiserson, C. E., and Stein, C. (2002). Algoritmos Teoria e Pratica. Elsevier, Sao Paulo.
Forbellone, A. L. V. and Eberspacher, H. E. (2005). Logica de Programacao. Pearson, Sao Paulo.
Horstmann, C. S. and Cornell, G. (2011). Core Java, volume I: fundamentos. Pearson Education, SãoPaulo.
57
