Apostila Python Básico

Prévia do material em texto

GERSON GROTH
APOSTILA PYTHON BÁSICO
ERECHIM - RS
2020
SUMÁRIO
1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1 Introdução à programação? . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Sequência de Instruções . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.2 Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.3 Laços de Repetição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Por que Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Programar permite você fazer mais . . . . . . . . . . . . . . . . . . . . . 3
1.4 Vamos analisar um simples jogo escrito em Python. . . . . . . . . . . . . 4
1.4.1 Solução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 Jornada de Aprendizagem . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 PYTHON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1 Meu Primeiro Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Escrevendo no console - Print . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Valores e Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Declarações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6 Operadores e Operandos . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.7 Expressões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.8 Ordem dos Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.9 Operador de Módulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.10 Solicitando entrada de dados para o usuário . . . . . . . . . . . . . . . . 11
2.11 Convertendo Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.11.1 Conversão Implícita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.11.2 Conversão Explícita . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.11.3 Conversão de Inteiros e Números Reais . . . . . . . . . . . . . . . . . . . . 12
2.11.4 Conversão de números para string . . . . . . . . . . . . . . . . . . . . . . . 13
2.11.5 Conversão de string para números . . . . . . . . . . . . . . . . . . . . . . . 15
2.12 Entrada com múltiplos valores por linha . . . . . . . . . . . . . . . . . . 16
2.12.1 Entrada com valores separados por outros caracteres . . . . . . . . . . . . . 17
2.13 Formatar a Saída . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.14 Fórmulas matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.14.1 Abs - Valor absoluto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.14.2 Raiz Quadrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3 CONDICIONAIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.1 Introdução Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3 Identação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.4 Operadores Booleanos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.4.1 Múltiplas Condições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5 Ordenação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4 LAÇOS DE REPETIÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.2 Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.3 Laço for (Para) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.4 Laço while (Enquanto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.5 Dicas Repetição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5 LISTAS DE EXERCÍCIOS - DICAS . . . . . . . . . . . . . . . . . . . . 32
5.1 Lista 1 - Algoritmos Sequenciais - Parte 1 . . . . . . . . . . . . . . . . . 32
5.1.1 1001 - Extremamente Básico . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.1.2 1002 - Área do Círculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.3 1003 - Soma Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.4 1004 - Produto Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.5 1005 - Média 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.6 1006 - Média 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.7 1007 - Diferença . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.8 1008 - Salário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.9 1009 - Salário com Bônus . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.10 1010 - Cálculo Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.1.11 1011 - Esfera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.1.12 1012 - Área . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2 Lista 2 - Algoritmos Sequenciais - Parte 2 . . . . . . . . . . . . . . . . . 34
5.2.1 1013 - O Maior . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2.2 1014 - Consumo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2.3 1015 - Distância Entre Dois Pontos . . . . . . . . . . . . . . . . . . . . . . 34
5.2.4 1016 - Distância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2.5 1017 - Gasto de Combustível . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2.6 1018 - Cédulas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.7 1019 - Conversão de Tempo . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.8 1020 - Idade em Dias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.9 1021 - Notas e Moedas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3 Lista 3 - Algoritmos Condicionais - Parte 1 . . . . . . . . . . . . . . . . . 35
5.3.1 1035 - Teste de Seleção 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3.2 1036 - Fórmula de Bhaskara . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3.3 1037 - Intervalo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3.4 1038 - Lanche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.5 1040 - Média 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.6 1041 - Coordenadas de um Ponto . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.7 1042 - Sort Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.8 1043 - Triângulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.9 1044 - Múltiplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.10 1045 - Tipos de Triângulos . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.11 1046 - Tempo de Jogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.12 1047 - Tempo de Jogo com Minutos . . . . . . . . . . . . . . . . . . . . . . 37
5.4 Lista 5 - Algoritmos de Repetição - Parte 1 . . . . . . . . . . . . . . . . . 37
5.4.1 1059 - Números Pares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.4.2 1060 - Números Positivos . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.4.3 1064 - Positivos e Média . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.4.4 1065 - Pares entre Cinco Números . . . . . . . . . . . . . . . . . . . . . . 38
5.4.5 1066 - Pares, Ímpares, Positivos e Negativos . . . . . . . . . . . . . . . . . 38
5.4.6 1067 - Números Ímpares . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4.7 1070 - Seis Números Ímpares . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4.8 1071 - Soma de Impares Consecutivos I . . . . . . . . . . . . . . . . . . . .38
5.4.9 1072 - Intervalo 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4.10 1073 - Quadrado de Pares . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4.11 1074 - Par ou Ímpar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.4.12 1075 - Resto 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.4.13 1078 - Tabuada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1
1 INTRODUÇÃO
1.1 Introdução à programação?
Podemos dizer que programação de computadores "é a arte de fazer um computador
fazer o que queremos que ele faça"(??).
De uma maneira bem simples, programação consiste de uma sequência de comandos
(instruções) dadas a um computador para chegar a um objetivo. Para chegar a esse objetivo,
usaremos programação estruturada de 3 formas que se complementam:
1.1.1 Sequência de Instruções
O programa irá fluir de um passo a outro em uma sequência pré-definida. A Imagem 1
mostra a execução de um programa passando por diversas etapas em sequência.
1.1.2 Condicionais
Nesta situação, o programa atinge um ’ponto de decisão’ e, SE (if) o resultado do teste
for verdadeiro, então o programa executa as instruções do Caminho 1, SENÃO (else), caso o
resultado do teste for falso, o programa executa o Caminho 2. É conhecido como condicional
pois, dada uma condição, o fluxo do programa pode tomar um caminho ou outro (Figura 2).
2
1.1.3 Laços de Repetição
Para esse tipo de fluxo, o programa fica repetindo uma mesma sequência de instruções
até que uma condição de teste passe a ser falsa, como número de iterações executadas é maior
que 100. Depois que acaba a repetição, o programa segue o restante do fluxo normalmente
(Figura 3).
3
1.2 Por que Python?
Para aprendermos programação, precisamos aprender uma linguagem de programação.
O objetivo não é mostrar como se programa em uma linguagem específica apenas, mas ensinar
a base da programação de forma geral. Pense na linguagem como um veículo, e não um destino;
vamos aprender como chegar a qualquer destino com esse veículo.
Mas por que Python? Especialmente pela sintaxe simples e clara comparado à outras
linguagens, como C++. Enquanto que em C++, ou mesmo Java, precisamos nos ater à diversos
detalhes específicos da linguagem, como lembrar de colocar um ; (ponto e vírgula) ao final de
cada comando e trechos obrigatórios em todo programa, em python conseguimos abstrair muito
mais coisas e nos ater mais à lógica de programação do que à linguagem em si.
Além da simplicidade e clareza, Python também é muito versátil; não é uma linguagem
de "brinquedo", usada apenas para ensinar programação. Python é usada para desenvolvimento
Web, linguagem preferida por cientistas de dados para trabalhar com Big Data, usada para
processamento de imagens, entre diversas outras áreas. É também usada por grandes empresas
como Google, Youtube, NASA.
1.3 Programar permite você fazer mais
Você tem problemas para resolver e trabalhos para fazer, mas os programas não per-
mitem fazer isso direito? Mesmo com todos esses programas, você ainda precisa fazer coisas
específicas para você?
Você deseja fazer mais com seu computador. Voce deseja tomar o controle.
4
Aprender a programar lhe dá o poder de criar e resolver. Aprender a programar coloca
você no controle.
Mas, como programação funciona?
1.4 Vamos analisar um simples jogo escrito em Python.
O código abaixo é um jogo de adivinhação. Olhe-o atentamente e, ao lado de cada
linha, escreva o que você acha que ele faz. Se você não souber, não se preocupe, mas tente
adivinhar de qualquer forma. Uma linha já está preenchida:
print("Bem vindo!")
print("Adivinhe o número: ")
valor = input()
chute = int(valor)
if chute == 5:
print("Você ganhou!")
else:
print("Você perdeu!")
print("Game over!")
..................................................................................................
..................................................................................................
..................................................................................................
Converte a entrada em um número inteiro...................................................................................................
..................................................................................................
..................................................................................................
..................................................................................................
..................................................................................................
..................................................................................................
1.4.1 Solução
OBS: Não olhe esta parte se ainda não tentou responder o que cada linha faz
Não se preocupe se as respostas estão diferentes. Se estão parecidas, está ok. Senão, não faz
diferença agora; você irá aprender durante o semestre.
print("Bem vindo!")
print("Adivinhe o número: ")
valor = input()
chute = int(valor)
if chute == 5:
print("Você ganhou!")
else:
print("Você perdeu!")
print("Game over!")
Escreve uma mensagem de boas vindas...................................................................................................
Pede ao usuário que faça um chute (informe um número)...................................................................................................
Espera o usuário informar o número e ’salva’ em valor..................................................................................................
Converte a entrada em um número inteiro...................................................................................................
O número chutado é igual à 5?..................................................................................................
Informa ao usuário "Você ganhou!"...................................................................................................
Caso contrário (senão).....................................................................................................
... informa ao usuário "Você perdeu!"...................................................................................................
Encerra o programa...................................................................................................
Segue abaixo um exemplo do ’jogo’ funcionando:
5
Bem vindo!
Adivinhe o número:
5
Você ganhou!
Game over!
Mas o que são valor e chute?
Você deve estar se perguntando o que valor e chute estão fazendo no código. Eles são chamados
de variáveis e, de uma forma abstrata, são usados para acompanhar os dados na memória do computador.
Uma variável é somente um rótulo/apelido para os dados.
Dessa forma, se um usuário digita "3"no teclado, então chute
será atribuída com o valor 3 e, em qualquer lugar do código
que precisar usar a variável chute, será ’lido’ com valor 3.
Cuidado com os sinais de =
no código.
Linguagens de programação
usam sinais de = para diferen-
tes propósitos. Na maioria das
linguagens (inclusive Python),
dois sinais de igual (==) indi-
cam um teste de igualdade. Sig-
nifica algo como, "estas duas
coisas são iguais?". Em contra-
partida, um único sinal de igual
(=) é uma instrução (conhecida
como atribuição) que significa
"atribuir o valor para...".
1.5 Jornada de Aprendizagem
Como você irá ver nas primeiras aulas e exercícios, nossos primeiros programas serão bem
simples: fazer a soma de números; calcular a média; calcular a área... São todos exercícios que parecem
muito mais simples fazer na mão do que desenvolver um programa para isso. Entretanto, quando você
estava aprendendo a falar, as palavras eram simples e, palavra por palavra, foram formando frases. Como
é algo totalmente novo, também precisamos começar com coisas simples a fim de aprender os conceitos
básicos e, pouco a pouco, evoluir. De forma similar, não se assuste com alguns conceitos que possam
nãofazer muito sentido, ou estarem desconexos no momento. Você demorou anos para formar frases,
sentenças, parágrafos. Nesse semestre iremos evoluir do básico de programação até uma compreensão
de estruturas comuns à todas as linguagens de programação.
6
2 Python
2.1 Meu Primeiro Programa
Após abrir o PyCharm, criar um projeto, iremos criar o arquivo que irá armazenar o código do
nosso primeiro programa. Para isso, clique com o botão direito em cima do nome do projeto, ou em File
-> new, e selecione Python File (Figura 7 esquerda) e, depois, informe um nome para seu arquivo (Figura
7 direita). OBS: evite colocar acentuações ou espaços no nome do arquivo.
Figura 7 – Criando um novo arquivo Python
Após criado o arquivo, vamos criar o "Hello, World"; como tradição quando se aprende uma
nova linguagem, o primeiro programa escrevemos a mensagem "Olá, Mundo". Para fazer isso em Python,
digite o seguinte comando:
print("Olá, Mundo!")
Após isso, salve seu programa, vá no menu Run -> run (Figura 8 esquerda) e selecione o
arquivo que criou (Figura 8 direita).
Figura 8 – Executando seu primeiro programa em Python
Como resultado, irá aparecer no console o seguinte texto:
Olá, Mundo!
Feito! Seu primeiro programa em Python.
7
2.2 Escrevendo no console - Print
Conforme vimos, o comando/função print() serve para escrevermos coisas no console. Mas não
necessariamente somente texto; podemos escrever números também. Obs: Os sinais de »> nos exemplos
são apenas para mostrar que é um código executado e, logo abaixo, o resultado dele.
>>> print(5)
5
ou
>>> print(2.1)
2.1
Obs: Valores reais são representados como . (ponto) e não , (vírgula)
2.3 Valores e Tipos
Um valor é uma das coisas básicas que um programa deve lidar, como uma letra ou um número.
Os valores que vimos até agora foram 5, 2.1, e "Olá, Mundo".
Estes valores são de diferentes tipos: 5 é um inteiro, 2.1 é um número real, e "Olá, Mundo" é o
que chamamos de string, porque consiste de uma sequência de caracteres/letras. Você (e o interpretador
python) podem identificar que é uma string devido às aspas duplas.
Se você não tem certeza qual é o tipo do dado, o interpretador pode lhe dizer.
>>> type(’Olá, Mundo’)
str
>>> type(5)
int
Como você pode ver, string são do tipo str, inteiros são do tipo int. Menos óbvio são os números
reais. Eles pertecem ao tipo float, porque os números são representados no formato de ponto flutuante.
>>> type(2.1)
float
E "17"ou "3.2"? Eles se parecem números, mas estão representados por aspas, ou seja, são
considerados strings.
>>>print("17")
str
>>> print("3.2")
str
8
2.4 Variáveis
A habilidade de manipular variáveis é uma das características mais poderosa de uma linguagem
de programação. Uma variável é um nome que referencia um valor.
Uma declaração de atribuição cria uma nova variável e lhe dá valores:
>>> mensagem = "Mensagem que iremos exibir pro usuário"
>>> x = 10
>>> pi = 3.14159
Neste exemplo, temos três atribuições. A primeira atribui uma string para uma nova variável
chamada mensagem; a segunda atribui o inteiro 10 para x; e, a terceira, atribui o valor (aproximado) de
π para pi.
Para exibir o valor de uma varíavel, podemos simplesmente utilizar a função/comando print:
>>> print (x)
10
>>> print (pi)
3.14159
O tipo de uma variável é o tipo do valor que ela referencia.
>>> type(mensagem)
str
>>> type(x)
int
>>> type(pi)
float
2.5 Declarações
Uma declaração é uma unidade de código que o interpretador Python pode executar. Nós vimos
dois tipos de declarações até agora: print como uma declaração de expressão e atribuição.
Um código normalmente contém uma sequência de declarações. Se há mais de uma, o resultado
aparece uma por vez enquanto as declarações são executadas linha a linha.
Por exemplo, o código abaixo
9
>>>
print(1)
y = 5
print(y)
produz a saída
1
5
Uma declaração de atribuição não produz nenhuma saída.
2.6 Operadores e Operandos
Operadores são símbolos especiais que representam cálculos como adição e multiplicação. O
valor do operador é aplicado para os chamados operandos.
Os operadores +, -, *, /, e ** efetuam adição, subtração, multiplicação, divisão, e exponencia-
ção, respectivamente. Exemplo:
>>>
1 + 2
1 - 5
2 * 7
9 / 2
2 ** 3
Para obter o valor inteiro de uma divisão, utilize //
>>> 59 // 60
0
2.7 Expressões
Uma expressão é uma combinação de valores, variáveis, e operadores. Um valor por si próprio é
considerado uma expressão, assim como uma variável. Dessa forma, são expressões corretas (assumindo
que a variável x tenha um valor atribuído anteriormente):
>>>
17
x
x + 17
Em um código, uma expressão por si própria não faz gera nenhuma saída! Isto pode ser uma
fonte de confusão no início. Para validar isso, execute o seguinte código
10
5
x = 5
x + 1
2.8 Ordem dos Operadores
Quando mais de um operador aparece em uma mesma expressão, a ordem de execução depende
das regras de precedência. Python segue as convensões matemáticas. Dessa forma, as regras são as
seguintes 1:
1. Parênteses possuem a maior prioridade, podendo ser usados para forçar uma expressão ser avaliada
na ordem que você quiser. Como expressões entre parênteses são avaliadas primeiro, 2 ∗ (3 − 1)
é 4, e (1 + 1) ∗ ∗(5− 2) é 8. Você também pode usar parênteses para facilitar a leitura, como em
(minuto ∗ 100)/60, mesmo que não altere o resultado.
2. Exponenciação possue a próxima precedência, ou seja, 2 ∗ ∗1 + 1 é 3, e não 4, e 3 ∗ 1 ∗ ∗3 é 3, e
não 27.
3. Multiplicação e Divisão possuem a mesma precedência. 2 ∗ 3− 1 é 5, e não 4, e 6 + 4/2 é 8.0, e
não 5.0.
4. Adição e Subtração também possuem a mesma precedência, vindo após de multiplicaçaõ e divisão.
5. Operadores com a mesma precedência são avaliados da esquerda para direita. Ou seja, 5 − 3 − 1
é 1, e não 3, porque 5− 3 vem primeiro e depois 1 é subtraído por 2.
Quando estiver em dúvidas, sinta-se à vontade para colocar parênteses na expressão para garantir
que os cálculos são feitos do jeito que você deseja.
2.9 Operador de Módulo
O operador de módulo trabalha com inteiros e armazena o resto da divisão de um número por
outro. Em Python, o operador de módulo é %. A sintaxe é a mesma de outros operadores.
>>>
inteiro = 7 // 3
print(inteiro)
2
>>>
resto = 7 % 3
print(resto)
1
1Para lembrar melhor a ordem, use o acrônimo PEMDAS
11
Então, 7 dividido por 3 é 2 e sobra 1.
O módulo se torna muito útil. Por exemplo, você pode testar se um número é divisível por
outro: se x % y é zero, então x é divisível por y.
Você também pode usar para extrair o dígito mais a direita de um número. Por exemplo, x %
10 retorna o dígito mais a direita de x (na base 10). De forma similar, x % 100 retorna os dois últimos
dígitos.
2.10 Solicitando entrada de dados para o usuário
De vez em quando, precisamos obter o valor de uma varíavel do usuário através do teclado.
Python provê um comando/função chamado input que obtém a entrada do teclado. Quando essa função
é chamada, o programa para e aguarda o usuário informar alguma coisa. Quando o usuário pressiona
Enter, o programa continua e input retorna o que o usuário digitou como uma string.
>>> entrada = input()
qualquer coisa
>>> print(entrada)
qualquer coisa
>>> nome = input("Qual é o seu nome?")
Qual é o seu nome?Gerson
>>> print(nome)
Gerson
2.11 Convertendo Dados
Todo valor em Python possui um tipo. Tipos de dados são classificações dos dados que dizem
ao compilador/interpretador como você quer usar o dado. O tipo define as operações que podem ser
feitas sobre os dados. Em computação, é bem normal ser necessário converter um tipo de dados para
outro, como strings para inteiro, float para int, e assim por diante.
Conversões de dados podem ocorrer de duas formas: ou você informa ao compilador para
converter um valor de um tipo para outro (conversão explícita), ou o compilador entende isto e converte
o valor para você (conversão implícita).
12
2.11.1 Conversão Implícita
Conversão implícitaé quando a conversão dos dados é feita diretamente pelo Python para você.
Exemplo:
>>>
a_int = 1
b_float = 1.0
c_soma = a_int + b_float
print(c_soma)
print(type(c_soma))
2.0
<class 'float'>
No exemplo, um valor inteiro aint foi adicionado com um valor float bf loat, e o resultado foi
automaticamente convertido para um float csoma sem precisar especificar isso para o compilador. Isto é
o que chamamoso de conversão implícita de dados.
Mas por que o valor não foi convertido para um inteiro, ao invés de float?
Em resumo, é um mecanismo de segurança que o Python possui para que não haja perda de
informação. Se convertêssemos para inteiro, os valores após o ponto seriam perdidos. Dessa forma, con-
seguimos manter a informação com a precisão correta.
2.11.2 Conversão Explícita
Também chamado de cast de tipo, é quando uma conversão de tipo ocorre porque você explici-
tamente disse para o Python fazer isso. Você basicamente força que a expressão seja do tipo que deseja.
A forma geral de converter explicitamente um tipo de dado é a seguinte:
tipo_dado_desejado(expressao)
Como você deve imaginar, ao forçar uma conversão, há um risco de perda de dados, como
converter 3.40 para o inteiro 3.
2.11.3 Conversão de Inteiros e Números Reais
Inteiros e floats são tipos que trabalham com números. Para converter um inteiro para float, use
a função float(). De forma similar, se você quiser converter um float para um inteiro, você pode usar a
função int().
>>>
a_int = 3
b_int = 2
# Convers~ao explı́cita de int para float
13
c_float_soma = float(a_int + b_int)
print(c_float_soma)
5.0
>>>
a_float = 3.3
b_float = 2.0
# Convers~ao explı́cita de float para int
c_int_soma = int(a_float + b_float)
print(c_int_soma)
c_float_soma = a_float + b_float
print(c_float_soma)
5
5.3
2.11.4 Conversão de números para string
Nós também podemos converter um número, seja inteiro ou float, para string. Para isso, basta
usarmos o método str(). Passamos tanto um número quanto uma variável dentro dos parênteses e, o
método irá converter o valor número para um texto (string).
>>>
a = str(12)
b = 10.0
c = str(b)
print(a)
print(b)
print(c)
print(type(a))
print(type(b))
print(type(c))
12
10.0
10.0
<class 'str'>
14
<class 'float'>
<class 'str'>
Apesar de serem escritos do mesmo jeito na saída, olhando para o tipo podemos perceber que
eles são do tipo string, e não mais int ou float. Essa conversão é útil quando precisamos escrever um texto
contendo números entre eles. Exemplo:
>>>
a = 10
b = 5.0
total = a * b
print("O valor total é " + total + " reais.")
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-45-aafe0f444654> in <module>()
2 b = 5.0
3 total = a * b
----> 4 print("O valor total é " + total + " reais.")
TypeError: must be str, not float
Como podemos ver, isso gera um erro, informando que total precisa ser uma string e não um
float. Temos algumas opções para resolver isso sendo, a primeira delas, converter o valor de total para
string (veja Seção 2.13 para maiores explicações sobre formatação na escrita).
>>> print("O valor total é " + str(total) + " reais.")
O valor total é 50.0 reais.
>>> print("O valor total é", total, "reais.")
O valor total é 50.0 reais.
>>> print("O valor total é %.2f reais" % total)
O valor total é 50.00 reais
15
2.11.5 Conversão de string para números
Eventualmente, também precisamos converter strings (texto) para números, especialmente quando
usamos o comando input() para ler informações do teclado. Para converter string para texto, podemos
usar as funções int() e float().
No exemplo abaixo, estamos lendo dois valores do teclado e somando os mesmos.
>>>
a = input()
b = input()
c = a + b
print (c)
Vamos supor que o usuário tenha digitado 10 e 20, qual será o resultado?
10
20
1020
Se você pensou em 30, está errado. Mas por que 1020? Quando lemos um valor do teclado
(usando input()), estamos lendo o valor como uma string, por que o Python não tem como saber que o
valor deve ser usado como um número. Dessa forma, ele apenas concatena (junta) os dois valores, lado a
lado, colocando o segundo ’texto’ ao lado do primeiro.
Para corrigirmos isso, precisamos usar a função int(), uma vez que nossos números são inteiros.
Podemos usar em apenas uma linha, passando o texto da entrada direto para a função de conversão
a = int(input())
ou em duas linhas separadas, primeiro lendo o texto e atribuindo a b e, depois, convertendo o
valor de b para inteiro e atribuindo novamente a ele mesmo.
b = input()
b = int(b)
Dessa forma, podemos alterar nosso programa para, agora sim, realizar a soma dos dois valores
>>>
a = int(input())
b = input()
b = int(b)
c = a + b
print (c)
16
10
20
30
Para converter para números reais (float), seguimos a mesma lógica. Basta usar a função float()
e, o conteúdo que queremos converter para float dentro dos parênteses.
>>>
a = float("10.0")
b = float("21.0")
c = a + b
print (c)
31.0
2.12 Entrada com múltiplos valores por linha
Ao usar input(), estamos lendo a linha inteira. Dessa forma, para os exercícios em que as
entradas estão todas em uma mesma linha, precisamos de uma forma de ’separar’ esses valores. Para
isso, podemos usar um método chamado split() disponível para uso por qualquer string. Esse método
separa os valores e pode ser atribuído a mais de uma variável. O exemplo a seguir espera que 2 valores
sejam lidos, separados por um espaço.
>>>
a, b = input().split()
a = int(a)
b = int(b)
print (a + b)
Vamos considerar que o usuário tenha digitadado os valores 10 e 25
10 25
35
Caso os valores fossem números reais, bastaria converter de string (texto) para float (Seção
2.11). Caso tenhamos mais valores em uma mesma linha, simplesmente precisamos adicionar outra va-
riável (o nome é indiferente, desde que mantidas as regras de definição dos nomes).
17
>>>
x, y, z = input().split()
x = float(x)
y = float(y)
z = float(z)
print (x + y + z)
2.12.1 Entrada com valores separados por outros caracteres
Através do método split, podemos dizer qual é o caractere que separa nossos valores. No exem-
plo anterior, não informamos isso. Dessa forma, é usado o valor padrão de espaço . Caso queiramos
modificar, precisamos passar isso dentro do método split. No próximo exemplo, consideramos como
entrada "10,20,30"(as aspas são apenas para informar que é uma string)
>>>
a, b, c = input().split(",")
a = int(a)
b = int(b)
c = int(c)
print (a + b + c)
10,20,30
60
2.13 Formatar a Saída
Ao longo do capítulo, já vimos algumas formas de formatar a escrita dos dados. Por exemplo,
podemos colocar uma variável ou valor no print, e será impresso o conteúdo da varíavel e o valor.
>>>
variavel = 10
print(variavel)
print(10)
print("texto")
10
10
texto
Entretanto, há situações que precisamos escrever mais de uma variável/valor. A forma mais fá-
cil é separá-los por ’,’ (vírgula). Assim, cada vírgula irá escrever um espaço e depois o valor subsequente
18
>>>
variavel_int = 10
variavel_float = 20.0
print("O inteiro tem valor",variavel_int,", o float tem valor",variavel_float,"e também podemos escrever direto no print, como o valor", 50)
O inteiro tem valor 10 , o float tem valor 20.0 e também podemos escrever direto no print, como o valor 50
Para situações simples, pode ser uma solução. Entretanto, não temos muito controle sobre
quantas casas decimais a variável flutuante vai imprimir, e sempre irá escrever um espaço a cada vírgula.
O Python permite um controle melhor sobre como formatar nossas saídas; utilizando o próprio print,
podemos informar como queremos formatar a nossa saída, utilizando caracteres especiais dentro do
texto.
>>>
print("O inteiro tem valor %i" % 10)
print("O float tem valor %f" % 20.3)
print("A string tem valor %s" % "minha string")
O inteiro tem valor 10
O float tem valor 20.300000
A string tem valor minha string
Aocolocar um caractere de % dentro da string, estamos informando ao python que queremos
formatar ela em um tipo de dado específico, através do valor informado fora da string.
Mas como funciona? O python identifica esse caractere especial %, além do tipo de dado (i -
inteiro, f - float, s - string), ’olha’ para o conteúdo fora da string (após outro %), e substitui o conteúdo
dentro da string pelo conteúdo de fora.
Imagine uma situação em que precisamos informar exatamente o número de casas decimais
depois da vírgula. Para isso, podemos alterar ligeiramente o print do exemplo, adicionando um ’.2’,
dizendo que, após a casa decimal, queremos escrever dois dígitos apenas.
>>>
valor = 15.7777777
print("Float %.2f com 2 casas decimais depois da vı́rgula" % valor)
print("Float %.3f com 3 casas decimais depois da vı́rgula" % valor)
Float 15.78 com 2 casas decimais depois da vı́rgula
Float 15.778 com 3 casas decimais depois da vı́rgula
Como podem ver no exemplo anterior, conseguimos controlar melhor como escrever nossos
valores. O valor é arredondado para 2 e 2 casas decimais, respectivamente.
19
E o que acontece se precisamos escrever mais de um valor ao mesmo tempo? Basta infor-
marmos mais caracteres especiais de substituição dentro da string e, mais um valor à direita (repare na
necessidade de colocar entre parênteses).
>>>
a = 15
b = 12.567
print("Escrevendo um inteiro %i e um float %.2f" % (a, b))
Escrevendo um inteiro 15 e um float 12.57
Existe outra forma de escrever o mesmo texto utilizando o comando format. Para isso, preci-
samos colocar entre chaves o índice do valor (começando sempre em 0). Depois do índice, podemos
adicionar ’:’ e a formatação que queremos ’.2f’ para duas casas decimais.
>>> print("Escrevendo um inteiro {0} e um float {1:.2f}".format(a,b))
Escrevendo um inteiro 15 e um float 12.57
2.14 Fórmulas matemáticas
2.14.1 Abs - Valor absoluto
Em algumas situações, precisamos utilizar o valor absoluto, ou seja, positivo. Para isso, utiliza-
mos a função abs() que retorna o valor absoluto do valor passado entre parênteses.
>>>
f = -54.26
print("Valor absoluto do float é:", abs(f))
i = -94
print("Valor absoluto do inteiro é:", abs(i))
Valor absoluto do float é: 54.26
Valor absoluto do inteiro é: 94
2.14.2 Raiz Quadrada
Para usarmos raiz quadrada, podemos utilizar um truque simples através da exponenciação.
Para isso, eleve o número à 1/2 ou 0.5
20
>>>
raiz = 9 ** (1/2)
print(raiz)
raiz = 144 ** (0.5 )
print(raiz)
3.0
12.0
A forma mais ’natural’ é utilizando a função sqrt(). Entretanto, não conseguimos acessar di-
retamente sqrt. Para utilizá-la, precisamos importar a função de uma biblioteca (conjunto de funções)
chamado math.
Nota: A raiz quadrada funciona para valores maiores que 0.
>>>
from math import sqrt
raiz = sqrt(9)
print(raiz)
raiz = sqrt(144)
print(raiz)
3.0
12.0
21
3 Condicionais
3.1 Introdução Condicionais
Até agora, todos os programas que vimos consistiam de uma lista de comandos (sequência de
passos). Pense nesses programas como um carro andando por uma única rua; a cada nova placa, a cada
trecho do caminho, executamos um comando específico (Figura 1)
Entretanto, as estradas não consistem de apenas uma rua ou levam a apenas um lugar; temos
caminhos diferentes que levam ao mesmo lugar, caminhos que levam à lugares distintos, caminhos que
podem ficar se repetindo...
Se continuarmos apenas programando como uma lista de comandos, nosso programas sempre
farão somente uma coisa, ou seja, estaremos sempre ’dirigindo’ em uma rua reta, sem nunca tomar
qualquer desvio.
Programas precisam fazer coisas diferentes em diferentes circunstâncias. No jogo da adivinha-
ção (Seção 1.4), o código mostrava "Você ganhou"se o número chutado estava correto, ou "Você perdeu",
caso contrário. Isto quer dizer que programas, mesmo os mais simples, possuem múltiplos caminhos
através deles.
22
Um caminho referencia um conjunto de instruções que o computador irá executar (seguir).
Seu código é como uma rede de ruas, com muita seções de código conectadas juntos, assim como as
ruas de uma cidade. Quando você dirige através de uma cidade, você toma decisões, como para qual rua
seguir, virar à esquerda ou à direita em diferentes intersecções. Em um programa, a ideia é a mesma. Um
programa precisa tomar decisões de tempos em tempos, como para qual caminho seguir. Entretanto, ao
contrário de dirigir, aonde você anda ao longo de uma rua, um programa executa o caminho que decide
tomar.
3.2 Condicionais
Dirigir em uma mesma rua é simples. Você precisa tomar decisões somente quando encontra
uma intersecção. É o mesmo para seu programa. Quando um programa possui uma lista de comandos, ele
simplesmente vai executando cegamente esses comandos um após o outro. Mas, em alguns momentos,
seu programa necessita tomar uma decisão. Ele irá executar este ou aquele pedaço de código?
Estes pontos de decisão são como intersecções no seu código.
23
Cada vez que seu programa precisa tomar uma decisão, ele avalia uma série de condições.
Essas condições sempre retornam True (verdadeiro) ou False (falso). Se a avaliação der verdadeiro, o
programa irá executar o caminho verdadeiro (True), senão, ele irá executar o caminho falso (False).
Python, assim como inúmeras outras linguagens, possuem if/else (se/senão). No exemplo do
jogo da adivinhação, a condição para o caminho verdadeiro seria o pedaço de código if guess == 5. Ele
é um teste de igualdade e, seu resultado, será sempre True ou False.
O código do ’caminho verdadeiro’ está identado para informar que ele está dentro do teste do
if (caminho verdadeiro). Da mesma forma, o ’caminho falso’ também está identado, para informar que
será executado com o else (caminho falso).
24
3.3 Identação
Python utiliza identação para conectar caminhos. Diferentemente de outras linguagens, essa
formatação não é só pra deixar o código ’bonito’. Em Python, identação é importante. Imagine uma
situação em que seja necessário decidir se você irá para a cidade. Python usa identação para conectar
sequência de comandos juntos para formar caminhos.
if combustivel > 5:
print("Temos combustível.")
print("Vamos à cidade")
else:
print("Sinto muito.")
print("Sem combustível.")
print("O que fazer agora?")
No código acima, caso o valor do combustivel seja maior do que 5, então iremos executar o
caminho verdadeiro. Caso contrário, iremos executar o caminho falso. Por último, indiferente do caminho
seguido, o último print sempre será executado, uma vez que ele não está identado com o caminho falso.
Vimos até agora como criar um caminho alternativo, dependendo do valor da condição. E como
conectamos mais de uma caminho? Precisamos simplesmente identar o segundo caminho mais um nível.
Note a identação extra para informar o trecho que vai ser executado dentro do if do caminho falso.
if combustivel > 5:
print("Temos combustível.")
print("Vamos à cidade")
else:
if dinheiro > 10:
print("Voce deveria comprar gasolina.")
else:
print("Melhor ficar em casa.")
print("O que fazer agora?")
3.4 Operadores Booleanos
As linguagens de programação proporcionam operadores booleanos para que possamos traba-
lhar com mais de uma condição ao mesmo tempo. Imagine que voce precise garantir que o usuário digite
um número entre 1 e 10. Se utilizarmos apenas uma condição (valor >= 1), o usuário ainda pode digitar
25
um valor inválido. Dessa forma, podemos usar o operador booleano and (e) e ’juntar’ as duas expressões
da seguinte forma:
valor = int(input())
if valor >= 1 and valor <= 10:
print("Valor válido.")
else:
print("Valor inválido.")
O exemplo combina duas condições (que retornar True ou False). Podemos usar os operadores
and (e), or (out) e not (não) para combinar qualquer condição booleana. Eles funcionam assim como os
nomes sugerem:
• A expressão A and B é verdadeira somente se ambos A e B forem verdadeiros. Se qualquer um de-
les for falso, a expressão é falsa. (Por exemplo, vocêse molhar quando está chovendo E esqueceu
o guarda-chuva em casa).
• A expressão A or B é verdadeira (True) se qualquer um dos dois for verdadeiro. Somente será
falsa, se ambas as condições forem falsas. (Por exemplo, a escola está fechada se for feriado OU
se é final de semana)
• A expressão not A é verdadeira se A for falso, e falsa se A for verdadeiro. (Por exemplo, você está
com fome se você NÃO comeu).
As expressões A e B citadas anteriormente, podem ser qualquer condição de teste, como valor
> 0, i % 2 == 0...
3.4.1 Múltiplas Condições
Através dos operadores and e or, conseguimos juntar diversas condições em apenas um teste
condicional (if). Dessa forma, considere que queiramos validar se um número lido é positivo, par e
múltiplo de 3:
valor = int(input())
if valor > 0 and valor % 2 == 0 and valor %3 == 0:
print("Positivo.")
print("Par.")
print("Múltiplo de 3")
3.5 Ordenação
Em algumas situações, precisamos garantir que umm número é maior ou igual ao outro para
podermos continuar com os testes. Por exemplo, dividir um número pelo outro (sempre usando o maior
por primeiro). Uma das formas seria duplicar os testes:
26
valor1 = int(input())
valor2 = int(input())
resultado = 0
if valor1 >= valor2:
resultado = valor1 / valor2
else:
resultado = valor2 / valor1
print(resultado)
Esse exemplo funciona corretamente. Entretando, tivemos que duplicar o código e, além disso,
se precisarmos fazer inúmeros testes, o número de linhas duplicadas iria aumentar, tornando mais fácil
esquecermos de atualizar no if ou no else.
Uma solução para isso é tornar o valor1 o maior valor e o valor2, o menor. Como ordernar eles?
A forma trivial, seria utilizando uma variável auxiliar para armazenar temporariamente o valor para não
’perdermos’ ele. Exemplo:
valor1 = int(input())
valor2 = int(input())
resultado = 0
if valor1 < valor2:
auxiliar = valor1
valor1 = valor2
valor2 = auxiliar
resultado = valor1 / valor2
print(resultado)
O Python possui uma forma mais simples de fazer essa ’troca’ de dados entre duas variáveis.
Basta inverter as variáveis da seguinte forma:
valor1,valor2=valor2,valor1
Dessa forma, conseguimos trocar os dados entre as duas variáveis sem a necessidade de utilizar
uma variável auxiliar.
Quando houver necessidade de ordenar mais de 2 variáveis, todas as variáveis precisam ser
testadas. Um exemplo com 3 variáveis A, B e C:
• Comparar A com B
• Comparar A com C
• Comparar B com C
Com essas comparações, consguimos garantir a ordem dos valores das 3 variáveis.
27
4 Laços de Repetição
4.1 Introdução
Programas normalmente precisam ficar rodando o mesmo pedaço de código inúmeras vezes,
seja para ler um número específico de valores, encontrar o n-esimo termo de uma sequência, dentre
tantos outros motivos. Para isso, as linguagens de programação oferecem o que chamamoso de laços de
repetição.
Laços se parecem um pouco com condicionais. Assim como eles, laços possuem uma condição
(a condição do laço de repetição) que pode ser tanto verdadeira (True) ou falsa (False). Além disso,
assim como o if das condições, se a condição do laço for verdadeira (True), então o código será executado.
Para a condição (if), esse código pode ser executado apenas uma vez (ou nenhuma, caso for falso).
Entretanto, para o laço de repetição, ele irá executar sempre que a expressão for verdadeira.
A grande diferença entre condicionais e laços de repetição é essa diferença entre quantas vezes
o código irá executar
Até agora, todos os programas que vimos consistiam de uma lista de comandos (sequência de
passos). Pense nesses programas como um carro andando por uma única rua; a cada nova placa, a cada
trecho do caminho, executamos um comando específico (Figura 1)
Entretanto, as estradas não consistem de apenas uma rua ou levam a apenas um lugar; temos
caminhos diferentes que levam ao mesmo lugar, caminhos que levam à lugares distintos, caminhos que
podem ficar se repetindo...
Se continuarmos apenas programando como uma lista de comandos, nosso programas sempre
farão somente uma coisa, ou seja, estaremos sempre ’dirigindo’ em uma rua reta, sem nunca tomar
qualquer desvio.
Programas precisam fazer coisas diferentes em diferentes circunstâncias. No jogo da adivinha-
ção (Seção 1.4), o código mostrava "Você ganhou"se o número chutado estava correto, ou "Você perdeu",
caso contrário. Isto quer dizer que programas, mesmo os mais simples, possuem múltiplos caminhos
através deles.
28
Um caminho referencia um conjunto de instruções que o computador irá executar (seguir).
Seu código é como uma rede de ruas, com muita seções de código conectadas juntos, assim como as
ruas de uma cidade. Quando você dirige através de uma cidade, você toma decisões, como para qual rua
seguir, virar à esquerda ou à direita em diferentes intersecções. Em um programa, a ideia é a mesma. Um
programa precisa tomar decisões de tempos em tempos, como para qual caminho seguir. Entretanto, ao
contrário de dirigir, aonde você anda ao longo de uma rua, um programa executa o caminho que decide
tomar.
4.2 Condicionais
Dirigir em uma mesma rua é simples. Você precisa tomar decisões somente quando encontra
uma intersecção. É o mesmo para seu programa. Quando um programa possui uma lista de comandos, ele
simplesmente vai executando cegamente esses comandos um após o outro. Mas, em alguns momentos,
seu programa necessita tomar uma decisão. Ele irá executar este ou aquele pedaço de código?
Estes pontos de decisão são como intersecções no seu código.
29
Cada vez que seu programa precisa tomar uma decisão, ele avalia uma série de condições.
Essas condições sempre retornam True (verdadeiro) ou False (falso). Se a avaliação der verdadeiro, o
programa irá executar o caminho verdadeiro (True), senão, ele irá executar o caminho falso (False).
Python, assim como inúmeras outras linguagens, possuem if/else (se/senão). No exemplo do
jogo da adivinhação, a condição para o caminho verdadeiro seria o pedaço de código if guess == 5. Ele
é um teste de igualdade e, seu resultado, será sempre True ou False.
O código do ’caminho verdadeiro’ está identado para informar que ele está dentro do teste do
if (caminho verdadeiro). Da mesma forma, o ’caminho falso’ também está identado, para informar que
será executado com o else (caminho falso).
30
4.3 Laço for (Para)
É muito normal precisarmos executar a mesma coisa diversas vezes. O Pyhon oferece o laço
for como uma forma de solucionar isso. O laço for é muito utilizado quando temos que iterar sobre o
mesmo código um número pré-definido de vezes como, por exemplo, ler a nota de 10 alunos. Ao invés de
criar 10 variáveis, podemos criar apenas 1 para leitura (e possivelmente 1 para soma), e repetir o mesmo
trecho de código 10 vezes.
Executar somente 10 vezes pode não ser tão vantajoso. Mas imagine que seja necessário exe-
cutar o mesmo código 1000000 de vezes. Criando variáveis para tantos valores é impossível. Com o laço
for, apenas precisamos informar quantas vezes executar, sem a necessidade de replicar o código tantas
vezes...
A sintaxe é a seguinte:
for variavel in range(0,10,1):
onde variavel é o nome da variável criada e que vai receber cada um dos índices da interação
(conforme definidos do lado direito). Nesse exemplo, a variável vai receber valores de 0 até 9 (10 não é
incluído). Para verificar isso, coloque print(variavel) dentro do laço for (alinhado assim como fazemos
com o if/else.
A função range serve para informar o alcance/extensão do nosso código. O primeiro valor
dentro dos parênteses informa qual é o valor inicial, o segundo até onde vai (sempre < que esse valor,
assim como se fosse if variavel < 10) e, o terceiro, serve para informar o ’salto’, ou seja, quanto iremos
incrementar a variável a cada iteração.
No exemplo, colocando um print na variável, teríamos o seguinte resultado:
0
1
2
3
4
5
6
7
8
9
4.4 Laço while (Enquanto)
Outra forma de executar o mesmo trecho de código inúmeras vezes é utilizandoo laço while.
Ele consegue proporcionar os mesmos resultados que o laço for. Então, por que temos duas estruturas?
Enquanto para o laço for dizemos o range e quantidade de vezes que vamos executar, com o laço while,
podemos executar enquanto alguma condição qualquer não for satisfeita. Imagine o mesmo cenário de ler
10 notas mas, no entanto, tem que ser 10 notas válidas. Como faríamos isso com o for se não conseguimos
saber quantas vezes exatas iremos executar? Essa situação é facilmente resolvida com o laço while.
Para demonstrar a diferença, iremos desenvolver um trecho de código que é equivalente ao
31
primeiro apresentado pelo laço for (iterar de 0 até 9). No laço for, o terceiro parâmetro do range informa
qual é o valor a ser somado. No while, precisamos fazer isso explicitamente.
contador = 0
while contador < 10:
print(contador)
contador = contador + 1
Perceba que dentro do while (assim como no if), temos uma condição. Enquanto ela for satis-
feita, iremos executar (diferentemente do if que executaremos no máximo 1 vez). A segunda linha dentro
do while incrementa nosso contador (caso não fazemos esse passo, nosso contador ficará para sempre
em 0 e nunca sairá do laço).
Agora voltemos ao caso de ler 10 notas válidas. Como podemos garantir isso? Meu contador
ainda terá que ir até 10 (porque são 10 notas que eu preciso ler). Mas como garantir que ele não incre-
mente toda vez que executar?
contador = 0
while contador < 10:
nota = float(input())
if nota >= 0.0 and nota <= 10.0:
contador = contador + 1
else:
print("Nota invalida. Por favor di-
gite novamente")
Perceba que incrementamos nosso contador apenas quando o usuário digitou uma nota válida.
Assim, conseguimos garantir que exatamente 10 notas válidas sejam digitadas.
4.5 Dicas Repetição
A dica mais importante a ser dada quando usamos repetição é desenvolver nosso código para
que funcione com um caso de teste (a lógica que irá depois para dentro do while ou for). Depois que funci-
onar para apenas uma ’repetição’, iremos ’envolver’ esse código dentro de um for ou while, dependendo
da preferência ou necessidade.
Quando você sabe de antemão quantos valores ler, quantas vezes executar (mesmo que o nú-
mero de iterações seja lido da entrada do usuário), prefira usar o laço for. Ele é mais simples e já incre-
menta o ’contador’ automaticamente.
Já, quando o número de repetições depender de uma estrutura mais complexa, opte pelo while.
32
5 Listas de Exercícios - Dicas
5.1 Lista 1 - Algoritmos Sequenciais - Parte 1
5.1.1 1001 - Extremamente Básico
Conforme enunciado do problema, precisamos ler dois inteiros, ou seja, precisaremos usar o
comando input (Seção 2.10). Após ler os dois valores, iremos convertê-los para inteiros (Seção 2.11). Na
sequência, precisamos somar os dois valores (Seções 2.6 e 2.7) e, por fim, escrever o resultado na tela
(Seção 2.13). Segue abaixo o código para solução desse problema, juntamente com explicações linha a
linha.
>>>
a = int(input())
# Aguarda o usuário informar o valor e, após isso, converte
# o número para inteiro, armazenando seu valor na varı́avel ’a’
b = input()
# Aguarda o usuário informar o valor, armazenando-o na variável ’b’
b = int(b)
# Converte o valor de ’b’ (que era texto) para inteiro.
# Após isso, atribui novamente à ’b’ o inteiro, substituindo o texto
# que ele armazenava anteriormente
# Tanto a primeira linha, quanto a segunda e terça linhas, fazem o mesmo
# processo. Única diferença é que, para ’a’, fizemos os dois processos
# em uma mesma linha e, para ’b’, separamos em duas linhas.
# Pode optar pela forma que sentir-se mais confortável
soma = a + b
# Soma os valores inteiros armazenados em ’a’ e ’b’ e, após isso,
# armazena a soma na variável ’soma’.
print ("X = %i" % soma)
# Por fim, conforme o problema solicitava, escrevemos na tela
# o texto "X = " e o valor resultante da soma dos dois números lidos
Segue um exemplo da execução do programa (os valores 10 e 19 foram inseridos pelo usuário)
10
19
X = 29
33
5.1.2 1002 - Área do Círculo
Para esse problema, precisamos usar exponenciação (Seção 2.6) e formatar a saída para 4 casas
decimais (Seção 2.13). No mais, basta calcular a área conforme pede o problema.
5.1.3 1003 - Soma Simples
Muito similar ao problema 1001.
5.1.4 1004 - Produto Simples
Ver Seção 2.6 para operação de multiplicação.
5.1.5 1005 - Média 1
Cálculo de média ponderada. Lembre-se que
media = (a + b) / 2
é igual a:
media = (a*5+b*5) / 10
Obs: Tome cuidado com a prioridade de operadores (ver Seção ??)
5.1.6 1006 - Média 2
Similar ao problema 1005. A maior diferença consiste da média ser baseada agora em 3 valores.
5.1.7 1007 - Diferença
Nenhuma informação nova nesse problema para resolvê-lo. Utilizar operadores de subtração e
multiplicação, e escrever a saída conforme o problema pede
5.1.8 1008 - Salário
Nenhuma informação nova nesse problema para resolvê-lo. Utilizar operador de multiplicação,
e escrever a saída conforme o problema pede
5.1.9 1009 - Salário com Bônus
Lembre-se que precisa ler todos os valores que o problema informa. Mesmo que não venha a
usá-los, é necessário que sejam lidos, uma vez que o problema especifica isso
34
5.1.10 1010 - Cálculo Simples
A entrada desse problema é um pouco mais complexa, uma vez que, em Python, o comando
input lê toda a linha. Consulte a Seção 2.12 para maiores informações.
Para o restante do problema, apenas calcule o valor das peças conforme solicitado. Lembre-se
que precisa ler 6 valores; 3 na primeira linha, e mais 3 na segunda linha.
5.1.11 1011 - Esfera
Para a exponenciação, veja a Seção 2.6. Ademais, lembre-se de usar o valor 3.14159 para o π .
5.1.12 1012 - Área
Este problema é um pouco mais extenso mas, mesmo assim, não é complexo. Basta calcular as
áreas conforme o problema pede. Para ajudar, segue as fórmulas:
Área do Triângulo Retângulo: A∗C2
Área do Círculo: 3.14159 ∗ C2
Área do Trapézio: (A+B)∗C2
Área do Quadrado: B2
Área do Retângulo: A ∗B
5.2 Lista 2 - Algoritmos Sequenciais - Parte 2
5.2.1 1013 - O Maior
Para o método abs(), pode usar exatamente como mostra na fórmula.
O problema apresenta uma fórmula para calcular o maior valor dentre 2 valores. Entretanto, o
problema pede que sejam lidos 3 valores. Como podemos resolver essa situação?
5.2.2 1014 - Consumo
Dado quantidade de quilômetros e litros gastos, basta calcular a média de km/l. Além disso,
ver Seção 2.13 para formatar a saída.
5.2.3 1015 - Distância Entre Dois Pontos
Para utilizar raiz quadrada, veja a Seção 2.14.
Nota: Lembre-se das prioridades de operadores (Seção 2.8)
5.2.4 1016 - Distância
Leia atentamente o problema e faça os cálculos necessários.
5.2.5 1017 - Gasto de Combustível
Apenas seguir o que o problema pode ; )
35
5.2.6 1018 - Cédulas
Para esse problema, utilize o operador de módulo (Seção 2.9) e o valor inteiro da divisão (Seção
2.6) para cada uma das notas.
5.2.7 1019 - Conversão de Tempo
Assim como o problema anterior, utilize o operador de módulo (Seção 2.9) e o valor inteiro da
divisão (Seção 2.6) para calcular horas, minutos e segundos.
5.2.8 1020 - Idade em Dias
Utilize o operador de módulo (Seção 2.9) e o valor inteiro da divisão (Seção 2.6) para calcular
anos, meses e dias.
5.2.9 1021 - Notas e Moedas
Lembre-se que o operador de módulo/resto funciona apenas para inteiros. Dessa forma, antes
de usá-lo, converta a parte após a vírgula para inteiro, e trabalhe somente com inteiros.
5.3 Lista 3 - Algoritmos Condicionais - Parte 1
5.3.1 1035 - Teste de Seleção 1
O capítulo 3 exemplifica o básico dos comandos if, elif e else.
O problema pede que várias condições sejam satisfeitas (verdadeiras) para que os valores sejam
aceitos. A seção 3.4.1 mostra como utilizar várias condições dentro do if.
5.3.2 1036 - Fórmula de Bhaskara
A fórmula de Bhaskara é dada por:
x =
−b±
√
b2 − 4ac
2a
(1)
Como não é possível calcular as duas raízes em apenas um cálculo, vai ser necessário calculá-las separadamente. Para evitar recalcular o delta várias vezes, pode armazenar o seu valor em uma variá-
vel e reaproveitá-lo onde for necessário.
Obs: Os cálculos da raiz só podem ser executados se for possível calcular. Caso contrário, não
deve ser calculado.
Obs2: Cuide com as prioridades dos operandos
5.3.3 1037 - Intervalo
Como identificar se um número está dentro do intervalo? Por que 12 está no intervalor [0, 25]?
Obs: Cuide se o intervalor é aberto ou fechado
36
5.3.4 1038 - Lanche
Qual é o valor total se o cliente chegar e solicitar 2 unidades do código 3?
Como cada produto possui um código diferente, os cálculos precisam ser diferenciados para
cada produto. Qual dado o usuário informa para que possamos diferenciar os produtos?
5.3.5 1040 - Média 3
Calcule a média ponderada conforme especifica o problema. Apenas tomar cuidado com os
testes se o aluno está ou não em exame, ou reprovado (4.999 > 4.9, assim como 6.9999 > 6.9).
Obs: Lembre-se que a nota do exame só pode ser lida SE o aluno estiver em exame Obs2: É
possível utilizar outros if/else dentro de um if ou else (Seção 3.3)
5.3.6 1041 - Coordenadas de um Ponto
Testar o quadrante conforme o exemplo. Teste com os exemplos 0 2 e 4 0. Desenhe esses pontos
no plano cartesiano. Em qual eixo eles estão?
5.3.7 1042 - Sort Simples
Para a ordenação, veja a seção 3.5. Com relação à escrever os valores na ordem lida, lembre-se
que uma variável pode receber o valor de outra, como abaixo x recebendo o mesmo valor que a:
a = input() x = a
5.3.8 1043 - Triângulo
Validar se forma um triângulo e calcular a área ou perímetro, conforme resultado da da condi-
ção.
Obs: Para validar se forma triângulo: | b - c | < a < b + c | a - c | < b < a + c | a - b | < c < a + b
5.3.9 1044 - Múltiplos
Validar se os números lidos são múltiplos um do outro.
Obs: Não há garantia que o primeiro número seja sempre menor que o segundo.
5.3.10 1045 - Tipos de Triângulos
De acordo com as regras, verificar quais tipos de triângulos podem ser formados.
Obs: os valores podem não estar ordenados
5.3.11 1046 - Tempo de Jogo
Temos três situações:
• Hora inicial é menor que a hora final
• Hora inicial é igual à hora final
37
• Hora inicial é menor que a hora final
Pense em como resolver cada uma delas.
5.3.12 1047 - Tempo de Jogo com Minutos
Parecida com a 1046. Entretanto, devemos considerar os minutos também. Caso queira estender
a ideia do problema anterior, vai ter que tomar cuidado com o início e fim dos minutos para cada situação
levantada anteriormente para horas.
A forma mais simples de resolver esse problema é trabalhar nele com os valores ’normalizados’,
ou seja, usando uma base em comum (no caso, minutos).
5.4 Lista 5 - Algoritmos de Repetição - Parte 1
5.4.1 1059 - Números Pares
Nosso laço tem um intervalo bem definido. Utilize o laço for (lembre-se que o segundo valor
do range é exclusivo). Último detalhe do problema é que podemos imprimir apenas os números pares.
Como fazemos isso? Procure utilizar % como resto de divisão para isso...
5.4.2 1060 - Números Positivos
O problema quer saber quantos números positivos existem entre 6 valores a serem lidos. Como
contamos quantas vezes algo aconteceu? Pense que toda nova ocorrência de número positivo é o soma-
tório das ocorrências anteriores mais 1 (o valor que acabou de ser testado)
Para as entradas do problema:
Antes de ler qualquer valor:
quantidade de números positivos = 0
após ler 7
quantidade de números positivos = 1
após ler -5
quantidade de números positivos = 1
após ler 6
quantidade de números positivos = 2
...
5.4.3 1064 - Positivos e Média
Parecido com o problema anterior. A diferença é a necessidade de calcular a média dos valo-
res positivos. Para saber quantos positivos, contamos 1 a cada positivo. E para saber qual é a média?
Primeiros somamos, para só no fim poder dividir.
Para as entradas do problema:
Antes de ler qualquer valor:
quantidade de números positivos = 0 soma dos números positivos = 0
após ler 7
38
quantidade de números positivos = 1 soma dos números positivos = 7
após ler -5
quantidade de números positivos = 1 soma dos números positivos = 7
após ler 6
quantidade de números positivos = 2 soma dos números positivos = 13
e assim por diante, para os 6 números...
5.4.4 1065 - Pares entre Cinco Números
Semelhante ao 1060 mas, dessa vez, precisamos contar apenas os valores pares (como sabemos
se um número é par?)
5.4.5 1066 - Pares, Ímpares, Positivos e Negativos
Dessa vez precisamos contar mais coisas. Segue a mesma lógica, mas não há como fazer isso
com apenas uma variável...
5.4.6 1067 - Números Ímpares
Praticamente igual ao 1059, com exceção de serem os números ímpares e que o valor máximo
é fornecido pelo usuário. Lembre-se que toda variável armazena um valor, ou seja, podemos usar ela pra
delimitar início/fim do laço.
5.4.7 1070 - Seis Números Ímpares
O problema fornece o primeiro valor. A partir dele, conte 6 ímpares (escrevendo cada um na
tela)
5.4.8 1071 - Soma de Impares Consecutivos I
Precisa iterar de um valor até o outro, somando os ímpares. Caso o primeiro seja maior que o
segundo, pode invertê-los ou colocar o passo de incremento em -1 ao invés de 1.
5.4.9 1072 - Intervalo 2
Após ler o primeiro valor, você possui a informação de quantos valores devem ser lidos. Por
fim, precisa comparar quais estão dentro e quais estão fora, registrando isso em contadores distintos.
5.4.10 1073 - Quadrado de Pares
Iterar entre dois valores utilizando apenas pares já foi visto em outros problemas. Para este, é
acrescentado a necessidade de elevar o número ao quadrado (utilize **)
39
5.4.11 1074 - Par ou Ímpar
Após ler o primeiro valor, você possui a informação de quantos valores devem ser lidos. Após
isso, comparar o valor lido e mostrar se ele é par/ímpar, positivo/negativo, ou nulo (conforme exemplo).
5.4.12 1075 - Resto 2
Os valores da iteração são apresentados e o valor a ser dividido precisa ser lido. Utilize o resto
da divisão (%) para calcular o que o problema pede.
5.4.13 1078 - Tabuada
Parecido com o 1073. No entando, deve-se mostrar a tabuada de 1 até 10 do número lido
	SUMÁRIO
	INTRODUÇÃO
	Introdução à programação?
	Sequência de Instruções
	Condicionais
	Laços de Repetição
	Por que Python?
	Programar permite você fazer mais
	Vamos analisar um simples jogo escrito em Python.
	Solução
	Jornada de Aprendizagem
	Python
	Meu Primeiro Programa
	Escrevendo no console - Print
	Valores e Tipos
	Variáveis
	Declarações
	Operadores e Operandos
	Expressões
	Ordem dos Operadores
	Operador de Módulo
	Solicitando entrada de dados para o usuário
	Convertendo Dados
	Conversão Implícita
	Conversão Explícita
	Conversão de Inteiros e Números Reais
	Conversão de números para string
	Conversão de string para números
	Entrada com múltiplos valores por linha
	Entrada com valores separados por outros caracteres
	Formatar a Saída
	Fórmulas matemáticas
	Abs - Valor absoluto
	Raiz Quadrada
	Condicionais
	Introdução Condicionais
	Condicionais
	Identação
	Operadores Booleanos
	Múltiplas Condições
	Ordenação
	Laços de Repetição
	Introdução
	Condicionais
	Laço for (Para)
	Laço while (Enquanto)
	Dicas Repetição
	Listas de Exercícios - Dicas
	Lista 1 - Algoritmos Sequenciais - Parte 1
	1001 - Extremamente Básico
	1002 - Área do Círculo
	1003 - Soma Simples
	1004 - Produto Simples
	1005 - Média 1
	1006 - Média 2
	1007 - Diferença
	1008 - Salário
	1009 - Salário com Bônus
	1010 - Cálculo Simples
	1011 - Esfera
	1012 - Área
	Lista 2 - Algoritmos Sequenciais - Parte 2
	1013 - O Maior
	1014 - Consumo
	1015 - Distância Entre Dois Pontos
	1016 - Distância
	1017 - Gasto de Combustível
	1018 - Cédulas
	1019 - Conversão de Tempo
	1020 - Idade em Dias
	1021 - Notas e Moedas
	Lista 3 - Algoritmos Condicionais - Parte 1
	1035 - Teste de Seleção 1
	1036 - Fórmula de Bhaskara
	1037 - Intervalo
	1038 - Lanche
	1040 - Média 3
	1041 - Coordenadas de um Ponto
	1042 - Sort Simples
	1043 - Triângulo
	1044 - Múltiplos1045 - Tipos de Triângulos
	1046 - Tempo de Jogo
	1047 - Tempo de Jogo com Minutos
	Lista 5 - Algoritmos de Repetição - Parte 1
	1059 - Números Pares
	1060 - Números Positivos
	1064 - Positivos e Média
	1065 - Pares entre Cinco Números
	1066 - Pares, Ímpares, Positivos e Negativos
	1067 - Números Ímpares
	1070 - Seis Números Ímpares
	1071 - Soma de Impares Consecutivos I
	1072 - Intervalo 2
	1073 - Quadrado de Pares
	1074 - Par ou Ímpar
	1075 - Resto 2
	1078 - Tabuada