NÃO PODE SER VENDIDO

I��������� �
P���������� ��� P�����

EXERCÍCIOS RESOLVIDOS

4� ediçã o - atualizaçã o do 23 de novembro de 2024

Nilo Ney Coutinho Menezes

livro_de_python@[Link]
Telegram: [Link]
2 Exercı́cios resolvidos — 4� ediçã o

Exercício 04-12 ................................ 43

Í����� Exercício 04-13 ................................ 44

Sobre o livro .............................................6 Exercício 04-14 ................................ 45

Introdução ................................................9 Exercício 04-15 ................................ 46

Exercício 02-01 ......................................10 Exercício 04-16 ................................ 47

Exercício 02-02 ......................................11 Exercício 05-01 ................................ 48

Exercício 02-03 ......................................12 Exercício 05-02 ................................ 49

Exercício 02-04 ......................................13 Exercício 05-03 ................................ 50

Exercício 02-05 ......................................14 Exercício 05-04 ................................ 51

Exercício 02-06 ......................................15 Exercício 05-05 ................................ 52

Exercício 02-07 ......................................16 Exercício 05-06 ................................ 53

Exercício 03-01 ......................................17 Exercício 05-07 ................................ 54

Exercício 03-02 ......................................18 Exercício 05-08 ................................ 55

Exercício 03-03 ......................................19 Exercício 05-09 ................................ 56

Exercício 03-04 ......................................20 Exercício 05-10 ................................ 57

Exercício 03-05 ......................................21 Exercício 05-11 ................................. 58

Exercício 03-06 ......................................22 Exercício 05-12 ................................ 59

Exercício 03-07 ......................................23 Exercício 05-13 ................................ 60

Exercício 03-08 ......................................24 Exercício 05-14 ................................ 61

Exercício 03-09 ......................................25 Exercício 05-15 ................................ 62

Exercício 03-10 ......................................26 Exercício 05-16 ................................ 63

Exercício 03-11 .......................................27 Exercício 05-17 ................................ 64

Exercício 03-12 ......................................28 Exercício 05-18 ................................ 65

Exercício 03-13 ......................................29 Exercício 05-19 ................................ 66

Exercício 03-14 ......................................30 Exercício 05-20 ................................ 67

Exercício 03-15 ......................................31 Exercício 05-21 ................................ 68

Exercício 04-01 ......................................32 Exercício 05-22 ................................ 69

Exercício 04-02 ......................................33 Exercício 05-23 ................................ 70

Exercício 04-03 ......................................34 Exercício 05-24 ................................ 71

Exercício 04-04 ......................................35 Exercício 05-25 ................................ 72

Exercício 04-05 ......................................36 Exercício 05-26 ................................ 73

Exercício 04-06 ......................................37 Exercício 05-27-a ............................. 74

Exercício 04-07 ......................................38 Exercício 05-27-b ............................. 75

Exercício 04-08 ......................................39 Exercício 06-01 ................................ 76

Exercício 04-09 ......................................40 Exercício 06-02 ................................ 77

Exercício 04-10 ......................................41 Exercício 06-03 ................................ 78

Exercício 04-11 .......................................42 Exercício 06-04 ................................ 79

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 3

Exercício 06-05 ................................... 80 Exercício 08-07 ................................. 122

Exercício 06-06 ................................... 81 Exercício 08-08 ................................. 123
Exercício 06-07 ................................... 82 Exercício 08-09 ................................. 124
Exercício 06-08 ................................... 83 Exercício 08-10 ................................. 125
Exercício 06-09 ................................... 84 Exercício 08-11 .................................. 126
Exercício 06-10 ................................... 85 Exercício 08-12 ................................. 127
Exercício 06-11 .................................... 86 Exercício 08-13-a .............................. 128
Exercício 06-12 ................................... 87 Exercício 08-13-b .............................. 129
Exercício 06-13 ................................... 88 Exercício 08-14 ................................. 130
Exercício 06-14 ................................... 89 Exercício 08-15 ................................. 131
Exercício 06-15 ................................... 90 Exercício 08-16 ................................. 133
Exercício 06-16 ................................... 91 Exercício 08-17 ................................. 134
Exercício 06-17 ................................... 92 Exercício 08-18 ................................. 136
Exercício 06-18 ................................... 93 Exercício 08-19 ................................. 137
Exercício 06-19 ................................... 94 Exercício 08-20 ................................. 138
Exercício 06-20-a ................................ 95 Exercício 08-21 ................................. 139
Exercício 06-20-b ................................ 96 Exercício 08-22 ................................. 140
Exercício 06-21 ................................... 97 Exercício 08-99 ................................. 141
Exercício 06-22 ................................... 98 Exercício 08-991 ............................... 143
Exercício 07-01 ................................... 99 Exercício 09-01 ................................. 145
Exercício 07-02 ................................. 100 Exercício 09-02 ................................. 146
Exercício 07-03 ................................. 101 Exercício 09-03 ................................. 147
Exercício 07-04 ................................. 102 Exercício 09-04 ................................. 148
Exercício 07-05 ................................. 103 Exercício 09-05 ................................. 149
Exercício 07-06 ................................. 104 Exercício 09-06 ................................. 150
Exercício 07-07 ................................. 105 Exercício 09-07 ................................. 151
Exercício 07-08 ................................. 106 Exercício 09-08 ................................. 153
Exercício 07-09 ................................. 107 Exercício 09-09 ................................. 155
Exercício 07-10 ................................. 109 Exercício 09-10 ................................. 156
Exercício 07-11 .................................. 111 Exercício 09-11 .................................. 157
Exercício 07-12 ................................. 113 Exercício 09-12 ................................. 158
Exercício 08-01 ................................. 116 Exercício 09-13 ................................. 159
Exercício 08-02 ................................. 117 Exercício 09-14 ................................. 160
Exercício 08-03 ................................. 118 Exercício 09-15 ................................. 161
Exercício 08-04 ................................. 119 Exercício 09-16 ................................. 164
Exercício 08-05 ................................. 120 Exercício 09-17 ................................. 165
Exercício 08-06 ................................. 121 Exercício 09-18 ................................. 168

Atualização do 23 de novembro de 2024 [Link]

4 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-19 ................................. 169 Exercício 10-12 ................................. 253
Exercício 09-20 ................................. 172 Exercício 10-13 ................................. 255
Exercício 09-21 ................................. 176 Exercício 10-14 ................................. 257
Exercício 09-22 ................................. 180 Exercício 10-15 ................................. 259
Exercício 09-23 ................................. 184 Exercício 11-01 .................................. 260
Exercício 09-24 ................................. 189 Exercício 11-02 .................................. 261
Exercício 09-25 ................................. 190 Exercício 11-03 .................................. 262
Exercício 09-26 ................................. 195 Exercício 11-04 .................................. 263
Exercício 09-27 ................................. 200 Exercício 11-05 .................................. 264
Exercício 09-28 ................................. 205 Exercício 11-06 .................................. 265
Exercício 09-29 ................................. 211 Exercício 12-01 ................................. 266
Exercício 09-30 ................................. 212 Exercício 12-02 ................................. 267
Exercício 09-31 ................................. 213 Exercício 12-03 ................................. 268
Exercício 09-32 ................................. 214 Exercício 12-04 ................................. 270
Exercício 09-33 ................................. 215 Exercício 12-05 ................................. 272
Exercício 09-34 ................................. 216 Exercício 12-06 ................................. 274
Exercício 09-35 ................................. 218 Exercício 12-07 ................................. 276
Exercício 09-36 ................................. 220 Exercício 12-08 ................................. 277
Exercício 09-37 ................................. 223 Exercício 12-09 ................................. 278
Exercício 09-38 ................................. 224 Exercício 12-10 ................................. 279
Exercício 09-39 ................................. 226 Exercício 13-01 ................................. 281
Exercício 09-40 ................................. 229 Exercício 13-02 ................................. 282
Exercício 09-41 ................................. 230 Exercício 13-03 ................................. 283
Exercício 09-42 ................................. 231 Exercício 13-04 ................................. 284
Exercício 09-43 ................................. 234 Exercício 13-05 ................................. 285
Exercício 09-44 ................................. 237 Exercício 13-06 ................................. 286
Exercício 10-01 ................................. 241
Exercício 10-02 ................................. 242
Exercício 10-03 ................................. 243
Exercício 10-04 ................................. 244
Exercício 10-05 ................................. 245
Exercício 10-06 ................................. 246
Exercício 10-07 ................................. 247
Exercício 10-08 ................................. 248
Exercício 10-09 ................................. 249
Exercício 10-10 ................................. 250
Exercício 10-11 .................................. 251

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 5

Atualização do 23 de novembro de 2024 [Link]

6 Exercı́cios resolvidos — 4� ediçã o
Sobre o livro
Este livro é orientado ao iniciante em programação. Os conceitos básicos de programação,
como expressões, variáveis, repe�ções, decisões, listas, dicionários, conjuntos, funções,
arquivos, classes, objetos, banco de dados com SQLite 3, expressões regulares e interfaces
gráficas com tkinter são apresentados um a um com exemplos e exercícios. A obra visa a
explorar a programação de computadores como ferramenta do dia a dia. Ela pode ser lida
durante um curso de introdução à programação de computadores e usada como guia de
estudo para autodidatas. Para aproveitamento pleno do conteúdo, apenas conhecimentos
básicos de informá�ca, como digitar textos, abrir e salvar arquivos, são suficientes. Todo
so�ware u�lizado no livro pode ser baixado gratuitamente, sendo executado em Windows,
Linux e Mac OS X.
Embora a linguagem Python (versão +3.12) seja muito poderosa e repleta de recursos
modernos de programação, este livro não pretende ensinar a linguagem em si, mas ensinar a
programar. Alguns recursos da linguagem não foram u�lizados para privilegiar os exercícios
de lógica de programação e oferecer uma preparação mais ampla ao leitor para outras
linguagens. Essa escolha não impediu a apresentação de recursos poderosos da linguagem,
e, embora o livro não seja fundamentalmente uma obra de referência, o leitor encontrará

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 7
várias notas e explicações de caracterís�cas específicas do Python, além da lógica de
programação.

Título: Introdução à Programação com Python

Autor: Nilo Ney Cou�nho Menezes
Edição: Quarta
ISBN: 978-8575228869
Editora: Novatec
Ano: 2024
Páginas: 552
Para comprar o livro na Amazon, visite o link ou escaneie o qr-code com seu celular:

Na Amazon: h�ps://[Link]/3Pjg4MZ

Atualização do 23 de novembro de 2024 [Link]

8 Exercı́cios resolvidos — 4� ediçã o

Para comprar o livro na Editora Novatec, visite o link ou escaneie o qrcode com seu celular:

Na Editora Novatec: h�p://[Link]/livros/introducao-python-4ed/

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 9
Introdução
Este documento foi criado para disponibilizar todos os exercícios resolvidos do livro em um
só arquivo. O site do livro pode ser acessado em h�ps://[Link] ou pelo qr-code
abaixo:

Site do livro
Se você não conhece o livro, visite o site web e tenha aceso às listagens, exercícios
resolvidos, dúvidas e correções (errata). Para comprar o livro na Amazon, visite o link ou
escaneie o qrcode com seu celular:
Lembre-se que os exercícios foram feitos para que você aprenda sozinho. Não olhe a
resposta antes de tentar sozinho algumas vezes ;-D.
Não pode ser vendido.

Atualização do 23 de novembro de 2024 [Link]

10 Exercı́cios resolvidos — 4� ediçã o
Exercício 02-01
Converta as seguintes expressões matemá�cas para que possam ser calculadas usando o
interpretador Python. 10 + 20 × 30 42 ÷ 30 (94 + 2) × 6 - 1

# Para executar o cálculo e visualizar a resposta,

# copie e cole as linhas abaixo para a janela do interpretador,
# uma de cada vez.
# As respostas do exercício são as linhas abaixo:
10 + 20 * 30
4**2 / 30
(9**4 + 2) * 6 - 1

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 11
Exercício 02-02
Digite a seguinte expressão no interpretador: 10 % 3 * 10 ** 2 + 1 - 10 * 4 / 2 Tente resolver
o mesmo cálculo, usando apenas lápis e papel. Observe como a prioridade das operações é
importante.

# O resultado da expressão:
# 10 % 3 * 10 ** 2 + 1 - 10 * 4 / 2
# é 81.0
#
# Realizando o cálculo com as prioridades da página 39,
# efetuando apenas uma operação por linha,
# temos a seguinte ordem de cálculo:
# 0 --> 10 % 3 * 10 ** 2 + 1 - 10 * 4 / 2
# 1 --> 10 % 3 * 100 + 1 - 10 * 4 / 2
# 2 --> 1 * 100 + 1 - 10 * 4 / 2
# 3 --> 100 + 1 - 10 * 4 / 2
# 4 --> 100 + 1 - 40 / 2
# 5 --> 100 + 1 - 20
# 6 --> 101 - 20
# 7 --> 81
#
# Se você estiver curioso(a) para saber por que o resultado
# é 81.0 e não 81, leia a seção 3.2, página 45.
# A operação de divisão sempre resulta em um número de ponto flutuante.

Atualização do 23 de novembro de 2024 [Link]

12 Exercı́cios resolvidos — 4� ediçã o
Exercício 02-03
Faça um programa que exiba seu nome na tela.

print("Escreva seu nome entre as aspas")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 13
Exercício 02-04
Escreva um programa que exiba o resultado de 2a × 3b, em que a vale 3 e b vale 5.

a = 3
b = 5
print(2 * a * 3 * b)

Atualização do 23 de novembro de 2024 [Link]

14 Exercı́cios resolvidos — 4� ediçã o
Exercício 02-05
Escreva um programa que calcule a soma de três variáveis e imprima o resultado na tela.

a = 2
b = 3
c = 4
print(a + b + c)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 15
Exercício 02-06
Modifique o Programa 2.2, de forma que ele calcule um aumento de 15% para um salário de
R$ 750.

salário = 750
aumento = 15
print(salário + (salário * aumento / 100))

Atualização do 23 de novembro de 2024 [Link]

16 Exercı́cios resolvidos — 4� ediçã o
Exercício 02-07
Usando as propriedades da divisão e da mul�plicação, tente entender como estes resultados
são iguais: 0.2 * 6 + 8 * 0.3 + 7 * 0.5 = (20 * 6 + 8 * 30 + 7 * 50) / 100

# 0.2 * 6 + 8 * 0.3 + 7 * 0.5 = (20 * 6 + 8 * 30 + 7 * 50) / 100

# Podemos distribuir a divisão do lado esquerdo:
# 20 / 100 * 6 + 8 * 30 / 100 + 7 * 50 / 100
# reagrupando o elemento comum (100):
# ((20 * 6) + (8 * 30) + 7 * 50) / 100
# Todas estas expressões resultam em 7.1

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 17
Exercício 03-01
Complete a tabela a seguir, marcando inteiro ou ponto flutuante dependendo do número
apresentado.

Número Tipo numérico

5 [ ] inteiro [ ] ponto flutuante
5.0 [ ] inteiro [ ] ponto flutuante
4.3 [ ] inteiro [ ] ponto flutuante
-2 [ ] inteiro [ ] ponto flutuante
100 [ ] inteiro [ ] ponto flutuante
1.333 [ ] inteiro [ ] ponto flutuante

# inteiro
# ponto flutuante
# ponto flutuante
# inteiro
# inteiro
# ponto flutuante

Atualização do 23 de novembro de 2024 [Link]

18 Exercı́cios resolvidos — 4� ediçã o
Exercício 03-02
Complete a tabela a seguir, respondendo True ou False. Considere a = 4, b = 10, c = 5.0, d = 1
e f = 5.

Expressão Resultado Expressão Resultado

a == c [ ] True [ ] False b > a [ ] True [ ] False
a < b [ ] True [ ] False c >= f [ ] True [ ] False
d > b [ ] True [ ] False f >= c [ ] True [ ] False
c != f [ ] True [ ] False c <= c [ ] True [ ] False
a == b [ ] True [ ] False c <= f [ ] True [ ] False
c < d [ ] True [ ] False

# False (a==c)
# True (a<b)
# False (d>b)
# False (c!=f)
# False (a==b)
# False (c<d)
# True (b>a)
# True (c>=f)
# True (f>=c)
# True (c<=c)
# True (c<=f)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 19
Exercício 03-03
Complete a tabela a seguir u�lizando a = True, b = False e c = True.

Expressão Resultado Expressão Resultado

a and a [ ] True [ ] False a or c [ ] True [ ] False
b and b [ ] True [ ] False b or c [ ] True [ ] False
not c [ ] True [ ] False c or a [ ] True [ ] False
not b [ ] True [ ] False c or b [ ] True [ ] False
not a [ ] True [ ] False c or c [ ] True [ ] False
a and b [ ] True [ ] False b or b [ ] True [ ] False
b and c [ ] True [ ] False

# True (a and a)
# False (b and b)
# False (not c)
# True (not b)
# False (not a)
# False (a and b)
# False (b and c)
# True (a or c)
# True (b or c)
# True (a or c)
# True (b or c)
# True (c or a)
# True (c or b)
# True (c or c)
# False (b or b)

Atualização do 23 de novembro de 2024 [Link]

20 Exercı́cios resolvidos — 4� ediçã o
Exercício 03-04
Escreva uma expressão para determinar se uma pessoa deve ou não pagar imposto.
Considere que pagam imposto pessoas cujo salário é maior que R$ 1.200,00.

salário > 1200

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 21
Exercício 03-05
Calcule o resultado da expressão A > B and C or D, u�lizando os valores da tabela a seguir.

A B C D Resultado
1 2 True False
10 3 False False
5 1 True True

# False
# False
# True

Atualização do 23 de novembro de 2024 [Link]

22 Exercı́cios resolvidos — 4� ediçã o
Exercício 03-06
Escreva uma expressão que será u�lizada para decidir se um aluno foi ou não aprovado. Para
ser aprovado, todas as médias do aluno devem ser maiores que 7. Considere que o aluno
cursa apenas três matérias, e que a nota de cada uma está armazenada nas seguintes
variáveis: matéria1, matéria2 e matéria3.

# Pelo enunciado:
matéria1 > 7 and matéria2 > 7 and matéria3 > 7
# Na prática, o aluno é aprovado se obtiver nota maior ou igual a média,
logo:
matéria1 >= 7 and matéria2 >= 7 and matéria3 >= 7

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 23
Exercício 03-07
Faça um programa que peça dois números inteiros. Imprima a soma desses dois números na
tela.

a = int(input("Digite o primeiro número:"))

b = int(input("Digite o segundo número:"))
print(a + b)

Atualização do 23 de novembro de 2024 [Link]

24 Exercı́cios resolvidos — 4� ediçã o
Exercício 03-08
Escreva um programa que leia um valor em metros e o exiba conver�do em milímetros.

metros = float(input("Digite o valor em metros: "))

milímetros = metros * 1000
print("%10.3f metros equivalem a %10.3f milímetros." % (metros,
milímetros))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 25
Exercício 03-09
Escreva um programa que leia a quan�dade de dias, horas, minutos e segundos do usuário.
Calcule o total em segundos.

dias = int(input("Dias:"))
horas = int(input("Horas:"))
minutos = int(input("Minutos:"))
segundos = int(input("Segundos:"))
# Um minuto tem 60 segundos
# Uma hora tem 3600 (60 * 60) segundos
# Um dia tem 24 horas, logo 24 * 3600 segundos
total_em_segundos = dias * 24 * 3600 + horas * 3600 + minutos * 60 +
segundos
print("Convertido em segundos é igual a %10d segundos." % total_em_
segundos)

Atualização do 23 de novembro de 2024 [Link]

26 Exercı́cios resolvidos — 4� ediçã o
Exercício 03-10
Faça um programa que calcule o aumento de um salário. Ele deve solicitar o valor do salário
e a porcentagem do aumento. Exiba o valor do aumento e do novo salário.

salário = float(input("Digite o salário atual:"))

p_aumento = float(input("Digite a porcentagem de aumento:"))
aumento = salário * p_aumento / 100
novo_salário = salário + aumento
print("Um aumento de %5.2f %% em um salário de R$ %7.2f" % (p_aumento,
salário))
print("é igual a um aumento de R$ %7.2f" % aumento)
print("Resultando em um novo salário de R$ %7.2f" % novo_salário)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 27
Exercício 03-11
Faça um programa que solicite o preço de uma mercadoria e o percentual de desconto. Exiba
o valor do desconto e o preço a pagar.

preço = float(input("Digite o preço da mercadoria:"))

desconto = float(input("Digite o percentual de desconto:"))
valor_do_desconto = preço * desconto / 100
a_pagar = preço - valor_do_desconto
print("Um desconto de %5.2f %% em uma mercadoria de R$ %7.2f" % (desconto,
preço))
print("vale R$ %7.2f." % valor_do_desconto)
print("O valor a pagar é de R$ %7.2f" % a_pagar)

Atualização do 23 de novembro de 2024 [Link]

28 Exercı́cios resolvidos — 4� ediçã o
Exercício 03-12
Escreva um programa que calcule o tempo de uma viagem de carro. Pergunte a distância a
percorrer e a velocidade média esperada para a viagem.

distância = float(input("Digite a distância em km:"))

velocidade_média = float(input("Digite a velocidade média em km/h:"))
tempo = distância / velocidade_média
print("O tempo estimado é de %5.2f horas" % tempo)
# Opcional: imprimir o tempo em horas, minutos e segundos
tempo_s = int(tempo * 3600) # convertemos de horas para segundos
horas = int(tempo_s / 3600) # parte inteira
tempo_s = int(tempo_s % 3600) # o resto
minutos = int(tempo_s / 60)
segundos = int(tempo_s % 60)
print("%05d:%02d:%02d" % (horas, minutos, segundos))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 29
Exercício 03-13
Escreva um programa que converta uma temperatura digitada em °C em °F. A fórmula para
essa conversão é:

9 × C
F = ----- + 32
5

C = float(input("Digite a temperatura em °C:"))

F = (9 * C / 5) + 32
print("%5.2f°C é igual a %5.2f°F" % (C, F))

Atualização do 23 de novembro de 2024 [Link]

30 Exercı́cios resolvidos — 4� ediçã o
Exercício 03-14
Escreva um programa que pergunte a quan�dade de km percorridos por um carro alugado
pelo usuário, assim como a quan�dade de dias pelos quais o carro foi alugado. Calcule o
preço a pagar, sabendo que o carro custa R$ 60 por dia e R$ 0,15 por km rodado.

km = int(input("Digite a quantidade de quilômetros percorridos:"))

dias = int(input("Digite quantos dias você ficou com o carro:"))
preço_por_dia = 60
preço_por_km = 0.15
preço_a_pagar = km * preço_por_km + dias * preço_por_dia
print("Total a pagar: R$ %7.2f" % preço_a_pagar)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 31
Exercício 03-15
Escreva um programa para calcular a redução do tempo de vida de um fumante. Pergunte a
quan�dade de cigarros fumados por dia e quantos anos ele já fumou. Considere que um
fumante perde 10 minutos de vida a cada cigarro, e calcule quantos dias de vida um fumante
perderá. Exiba o total em dias.

cigarros_por_dia = int(input("Quantidade de cigarros por dia:"))

anos_fumando = float(input("Quantidade de anos fumando:"))
redução_em_minutos = anos_fumando * 365 * cigarros_por_dia * 10
# Um dia tem 24 x 60 minutos
redução_em_dias = redução_em_minutos / (24 * 60)
print("Redução do tempo de vida %8.2f dias." % redução_em_dias)

Atualização do 23 de novembro de 2024 [Link]

32 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-01
Analise o Programa 4.1. Responda o que acontece se o primeiro e o segundo valores forem
iguais? Explique.

# Se os valores forem iguais, nada será impresso.

# Isso acontece porque a > b e b > a são falsas quando a = b.
# Assim, nem o print de 2, nem o print de 3 serão executados, logo nada
será impresso.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 33
Exercício 04-02
Escreva um programa que pergunte a velocidade do carro de um usuário. Caso ultrapasse 80
km/h, exiba uma mensagem dizendo que o usuário foi multado. Nesse caso, exiba o valor da
multa, cobrando R$ 5 por km acima de 80 km/h.

velocidade = float(input("Digite a velocidade do seu carro:"))

if velocidade > 80:
multa = (velocidade - 80) * 5
print(f"Você foi multado em R$ {multa:7.2f}!")
if velocidade <= 80:
print("Sua velocidade está ok, boa viagem!")

Atualização do 23 de novembro de 2024 [Link]

34 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-03
Escreva um programa que leia três números e que imprima o maior e o menor.

a = int(input("Digite o primeiro valor:"))

b = int(input("Digite o segundo valor:"))
c = int(input("Digite o terceiro valor:"))
maior = a
if b > a and b > c:
maior = b
if c > a and c >= b:
maior = c
menor = a
if b < c and b < a:
menor = b
if c <= b and c < a:
menor = c
print(f"O menor número digitado foi {menor}")
print(f"O maior número digitado foi {maior}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 35
Exercício 04-04
Escreva um programa que pergunte o salário do funcionário e calcule o valor do aumento.
Para salários superiores a R$ 1.250,00, calcule um aumento de 10%. Para os inferiores ou
iguais, de 15%.

salário = float(input("Digite seu salário: "))

pc_aumento = 0.15
if salário > 1250:
pc_aumento = 0.10
aumento = salário * pc_aumento
print(f"Seu aumento será de: R$ {aumento:7.2f}")

Atualização do 23 de novembro de 2024 [Link]

36 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-05
Execute o Programa 4.5 e experimente alguns valores. Verifique se os resultados foram os
mesmos do Programa 4.2.

# Sim, os resultados são os mesmos.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 37
Exercício 04-06
Escreva um programa que pergunte a distância que um passageiro deseja percorrer em km.
Calcule o preço da passagem, cobrando R$ 0,50 por km para viagens de até de 200 km, e R$
0,45 para viagens mais longas.

distância = float(input("Digite a distância a percorrer: "))

if distância <= 200:
passagem = 0.5 * distância
else:
passagem = 0.45 * distância
print(f"Preço da passagem: R$ {passagem:7.2f}")

Atualização do 23 de novembro de 2024 [Link]

38 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-07
Analise o Programa 4.3. Faz sen�do usar o else nesse programa? Explique sua resposta.

# Analisando o programando 4.3, onde temos dois ifs,

# fica claro que não faz sentido usar o else neste programa.
# Como o programa calcula o imposto em faixas e modifica
# a base no primeiro if, o segundo if precisa ser avaliado
# de qualquer forma. Desta forma, o uso do else
# não fas sentido neste programa.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 39
Exercício 04-08
Reescreva o Programa 4.4 e calcule a conta da operadora Tchau usando else.

plano = input("Qual é o seu plano de celular? ")

if plano != "falopouco" and plano != "falomuito":
print("Não conheço este plano")
else:
if plano == "falopouco":
minutos_no_plano = 100
extra = 0.20
preço = 50
else:
minutos_no_plano = 500
extra = 0.15
preço = 99

minutos_consumidos = int(input("Quantos minutos você consumiu? "))

print("Você vai pagar:")
print(f"Preço do plano R${preço:10.2f}")
suplemento = 0
if minutos_consumidos > minutos_no_plano:
suplemento = extra * (minutos_consumidos - minutos_no_plano)
print(f"Suplemento R${suplemento:10.2f}")
print(f"Total R${preço + suplemento:10.2f}")

Atualização do 23 de novembro de 2024 [Link]

40 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-09
Rastreie o Programa 4.8. Compare seu resultado ao apresentado na Tabela 4.2.

# O exercício consiste em rastrear o programa da listagem 4.8.

# O resultado deve ser o mesmo do apresentado na tabela 4.2.
# A técnica de rastreamento é apresentada na página 110,
# seção 3.6 Rastreamento.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 41
Exercício 04-10
Escreva um programa que leia dois números e que pergunte qual operação você deseja
realizar. Você deve poder calcular soma (+), subtração (-), mul�plicação (*) e divisão (/). Exiba
o resultado da operação solicitada.

a = float(input("Primeiro número:"))
b = float(input("Segundo número:"))
operação = input("Digite a operação a realizar (+, -, * ou /):")
if operação == "+":
resultado = a + b
elif operação == "-":
resultado = a - b
elif operação == "*":
resultado = a * b
elif operação == "/":
resultado = a / b
else:
print("Operação inválida!")
resultado = 0
print("Resultado: ", resultado)

Atualização do 23 de novembro de 2024 [Link]

42 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-11
Escreva um programa para aprovar o emprés�mo bancário para compra de uma casa. O
programa deve perguntar o valor da casa a comprar, o salário e a quan�dade de anos a
pagar. O valor da prestação mensal não pode ser superior a 30% do salário. Calcule o valor da
prestação como sendo o valor da casa a comprar dividido pelo número de meses a pagar.

valor = float(input("Digite o valor da casa: "))

salário = float(input("Digite o salário: "))
anos = int(input("Quantos anos para pagar: "))
meses = anos * 12
prestacao = valor / meses
if prestacao > salário * 0.3:
print("Infelizmente você não pode obter o empréstimo")
else:
print(f"Valor da prestação: R$ {prestacao:7.2f} Empréstimo OK")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 43
Exercício 04-12
Escreva um programa que calcule o preço a pagar pelo fornecimento de energia elétrica.
Pergunte a quan�dade de kWh consumida e o �po de instalação: R para residências, I para
indústrias e C para comércios. Calcule o preço a pagar de acordo com a tabela a seguir.

+---------------------------------------+
| Preço por tipo e faixa de consumo |
+---------------------------------------+
| Tipo | Faixa (kWh) | Preço |
+=======================================+
| Residencial | Até 500 | R$ 0,40 |
| | Acima de 500 | R$ 0,65 |
+---------------------------------------+
| Comercial | Até 1000 | R$ 0,55 |
| | Acima de 1000 | R$ 0,60 |
+---------------------------------------+
| Industrial | Até 5000 | R$ 0,55 |
| | Acima de 5000 | R$ 0,60 |
+---------------------------------------+

consumo = int(input("Consumo em kWh: "))

tipo = input("Tipo da instalação (R, C ou I): ")
if tipo == "R":
if consumo <= 500:
preço = 0.40
else:
preço = 0.65
elif tipo == "I":
if consumo <= 5000:
preço = 0.55
else:
preço = 0.60
elif tipo == "C":
if consumo <= 1000:
preço = 0.55
else:
preço = 0.60
else:
preço = 0
print("Erro ! Tipo de instalação desconhecido!")
custo = consumo * preço
print(f"Valor a pagar: R$ {custo:7.2f}")

Atualização do 23 de novembro de 2024 [Link]

44 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-13
No programa a seguir, inverta as linhas do if e else, negando a condição. Adicione as linhas
necessárias para fazê-lo funcionar em Python.

if a > b:
print("a é maior que b")
else:
print("b é maior que a")

a = int(input("a: "))
b = int(input("b: "))
if a <= b:
print("b é maior que a")
else:
print("a é maior que b")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 45
Exercício 04-14
Reescreva o programa a seguir com if-elif-else. Adicione as linhas necessárias para fazê-lo
funcionar em Python.

if a < 10:
print("a é menor que 10")
if a >= 10 and a < 20:
print("a é maior que 10 e menor que 20")
if a >= 20:
print("a é maior que 20")

a = int(input("a: "))
if a < 10:
print("a é menor que 10")
elif a < 20:
print("a é maior ou igual a 10 e menor que 20")
else:
print("a é maior ou igual a 20")

Atualização do 23 de novembro de 2024 [Link]

46 Exercı́cios resolvidos — 4� ediçã o
Exercício 04-15
Reescreva o programa a seguir com if-elif-else.

hora = int(input("Digite a hora atual:"))

if hora < 12:
print("Bom dia!")
if hora >=12 and hora <=18:
print("Boa tarde!")
if hora >=18:
print("Boa noite!")

hora = int(input("Digite a hora atual:"))

if hora < 12:
print("Bom dia!")
elif hora < 18:
print("Boa tarde!")
else:
print("Boa noite!")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 47
Exercício 04-16
Corrija o programa a seguir:

média = input("Digite sua média:")

if média < 4:
print("Infelizmente você reprovou")
if média < 7:
print("Você ficou de recuperação")
if média > 7:
print("Você passou de ano")

média = float(input("Digite sua média: "))

if média < 4:
print("Infelizmente você reprovou")
elif média < 7:
print("Você ficou de recuperação")
else:
print("Você passou de ano")

Atualização do 23 de novembro de 2024 [Link]

48 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-01
Modifique o programa para exibir os números de 1 a 100.

x = 1
while x <= 100:
print(x)
x = x + 1

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 49
Exercício 05-02
Modifique o programa para exibir os números de 50 a 100.

x = 50
while x <= 100:
print(x)
x = x + 1

Atualização do 23 de novembro de 2024 [Link]

50 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-03
Faça um programa para escrever a contagem regressiva do lançamento de um foguete. O
programa deve imprimir 10, 9, 8, …, 1, 0 e Fogo! na tela.

x = 10
while x >= 0:
print(x)
x = x - 1
print("Fogo!")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 51
Exercício 05-04
Modifique o programa anterior para imprimir de 1 até o número digitado pelo usuário, mas,
dessa vez, apenas os números ímpares.

fim = int(input("Digite o último número a imprimir:"))

x = 1
while x <= fim:
print(x)
x = x + 2

Atualização do 23 de novembro de 2024 [Link]

52 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-05
Reescreva o programa anterior para escrever os 10 primeiros múl�plos de 3.

fim = 30
x = 3
while x <= fim:
print(x)
x = x + 3

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 53
Exercício 05-06
Altere o programa anterior para exibir os resultados no mesmo formato de uma tabuada: 2x1
= 2, 2x2 = 4, …

n = int(input("Tabuada de:"))
x = 1
while x <= 10:
print(f"{n} x {x} = {n * x}")
x = x + 1

Atualização do 23 de novembro de 2024 [Link]

54 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-07
Modifique o programa anterior de forma que o usuário também digite o início e o fim da
tabuada, em vez de começar com 1 e 10.

n = int(input("Tabuada de: "))

inicio = int(input("De: "))
fim = int(input("Até: "))
x = inicio
while x <= fim:
print(f"{n} x {x} = {n * x}")
x = x + 1

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 55
Exercício 05-08
Escreva um programa que leia dois números. Imprima o resultado da mul�plicação do
primeiro pelo segundo. U�lize apenas os operadores de soma e subtração para calcular o
resultado. Lembre-se de que podemos entender a mul�plicação de dois números como
somas sucessivas de um deles. Assim, 4 × 5 = 5 + 5 + 5 + 5 = 4 + 4 + 4 + 4 + 4.

p = int(input("Primeiro número: "))

s = int(input("Segundo número: "))
x = 1
r = 0
while x <= s:
r = r + p
x = x + 1
print(f"{p} x {s} = {r}")

Atualização do 23 de novembro de 2024 [Link]

56 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-09
Escreva um programa que leia dois números. Imprima a divisão inteira do primeiro pelo
segundo, assim como o resto da divisão. U�lize apenas os operadores de soma e subtração
para calcular o resultado. Lembre-se de que podemos entender o quociente da divisão de
dois números como a quan�dade de vezes que podemos re�rar o divisor do dividendo. Logo,
20 ÷ 4 = 5, uma vez que podemos subtrair 4 cinco vezes de 20.

dividendo = int(input("Dividendo: "))

divisor = int(input("Divisor: "))
quociente = 0
x = dividendo
while x >= divisor:
x = x - divisor
quociente = quociente + 1
resto = x
print(f"{dividendo} / {divisor} = {quociente} (quociente) {resto}
(resto)")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 57
Exercício 05-10
Modifique o programa anterior para que aceite respostas com letras maiúsculas e
minúsculas em todas as questões.

pontos = 0
questão = 1
while questão <= 3:
resposta = input(f"Resposta da questão {questão}: ")
if questão == 1 and (resposta == "b" or resposta == "B"):
pontos = pontos + 1
if questão == 2 and (resposta == "a" or resposta == "A"):
pontos = pontos + 1
if questão == 3 and (resposta == "d" or resposta == "D"):
pontos = pontos + 1
questão += 1
print(f"O aluno fez {pontos} ponto(s)")

Atualização do 23 de novembro de 2024 [Link]

58 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-11
Escreva um programa que pergunte o depósito inicial e a taxa de juros de uma poupança.
Exiba os valores mês a mês para os 24 primeiros meses. Escreva o total ganho com juros no
período.

depósito = float(input("Depósito inicial: "))

taxa = float(input("Taxa de juros (Ex.: 3 para 3%): "))
mês = 1
saldo = depósito
while mês <= 24:
saldo = saldo + (saldo * (taxa / 100))
print(f"Saldo do mês {mês} é de R${saldo:5.2f}.")
mês = mês + 1
print(f"O ganho obtido com os juros foi de R${saldo-depósito:8.2f}.")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 59
Exercício 05-12
Altere o programa anterior de forma a perguntar também o valor depositado mensalmente.
Esse valor será depositado no início de cada mês, e você deve considerá-lo para o cálculo de
juros do mês seguinte.

depósito = float(input("Depósito inicial: "))

taxa = float(input("Taxa de juros (Ex.: 3 para 3%): "))
investimento = float(input("Depósito mensal: "))
mês = 1
saldo = depósito
while mês <= 24:
saldo = saldo + (saldo * (taxa / 100)) + investimento
print(f"Saldo do mês {mês} é de R${saldo:5.2f}.")
mês = mês + 1
print(f"O ganho obtido com os juros foi de R${saldo-depósito:8.2f}.")

Atualização do 23 de novembro de 2024 [Link]

60 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-13
Escreva um programa que pergunte o valor inicial de uma dívida e o juro mensal. Pergunte
também o valor mensal que será pago. Imprima o número de meses para que a dívida seja
paga, o total pago e o total de juros pago.

dívida = float(input("Dívida: "))

taxa = float(input("Juros (Ex.: 3 para 3%): "))
pagamento = float(input("Pagamento mensal:"))
mês = 1
if dívida * (taxa / 100) > pagamento:
print(
"Sua dívida não será paga nunca, pois os juros são superiores ao
pagamento mensal."
)
else:
saldo = dívida
juros_pago = 0
while saldo > pagamento:
juros = saldo * taxa / 100
saldo = saldo + juros - pagamento
juros_pago = juros_pago + juros
print(f"Saldo da dívida no mês {mês} é de R${saldo:6.2f}.")
mês = mês + 1
print(f"Para pagar uma dívida de R${dívida:8.2f}, a {taxa:5.2f} % de
juros,")
print(
f"você precisará de {mês - 1} meses, pagando um total de R${juros_
pago:8.2f} de juros."
)
print(f"No último mês, você teria um saldo residual de R${saldo:8.2f}
a pagar.")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 61
Exercício 05-14
Escreva um programa que leia números inteiros do teclado. O programa deve ler os números
até que o usuário digite 0 (zero). No final da execução, exiba a quan�dade de números
digitados, assim como a soma e a média aritmé�ca.

soma = 0
quantidade = 0
while True:
n = int(input("Digite um número inteiro: "))
if n == 0:
break
soma = soma + n
quantidade = quantidade + 1
print("Quantidade de números digitados:", quantidade)
print("Soma: ", soma)
print(f"Média: {soma/quantidade:10.2f}")

Atualização do 23 de novembro de 2024 [Link]

62 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-15
Escreva um programa para controlar uma pequena máquina registradora. Você deve solicitar
ao usuário que digite o código do produto e a quan�dade comprada. U�lize a tabela de
códigos a seguir para obter o preço de cada produto:

Código Preço
1 0,50
2 1,00
3 4,00
5 7,00
9 8,00

Seu programa deve exibir o total das compras depois que o usuário digitar 0. Qualquer outro
código deve gerar a mensagem de erro “Código inválido”.

apagar = 0
while True:
código = int(input("Código da mercadoria (0 para sair): "))
preço = 0
if código == 0:
break
elif código == 1:
preço = 0.50
elif código == 2:
preço = 1.00
elif código == 3:
preço = 4.00
elif código == 5:
preço = 7.00
elif código == 9:
preço = 8.00
else:
print("Código inválido!")
if preço != 0:
quantidade = int(input("Quantidade: "))
apagar = apagar + (preço * quantidade)
print(f"Total a pagar R${apagar:8.2f}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 63
Exercício 05-16
Execute o Programa 5.1 para os seguintes valores: 501, 745, 384, 2, 7 e 1.

# O programa deve funcionar normalmente com os valores solicitados pelo

exercício.

Atualização do 23 de novembro de 2024 [Link]

64 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-17
O que acontece se digitarmos 0 (zero) no valor a pagar?

# O programa pára logo após imprimir a quantidade de cédulas de R$50,00

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 65
Exercício 05-18
Modifique o programa para também trabalhar com notas de R$ 100.

valor = int(input("Digite o valor a pagar:"))

cédulas = 0
atual = 100
apagar = valor
while True:
if atual <= apagar:
apagar -= atual
cédulas += 1
else:
print(f"{cédulas} cédula(s) de R${atual}")
if apagar == 0:
break
elif atual == 100:
atual = 50
elif atual == 50:
atual = 20
elif atual == 20:
atual = 10
elif atual == 10:
atual = 5
elif atual == 5:
atual = 1
cédulas = 0

Atualização do 23 de novembro de 2024 [Link]

66 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-19
Modifique o programa para aceitar valores decimais, ou seja, também contar moedas de
0,01, 0,02, 0,05, 0,10 e 0,50

# Atenção: alguns valores não serão calculados corretamente

# devido a problemas com arredondamento e da representação de 0.01
# em ponto flutuante. Uma alternativa é multiplicar todos os valores
# por 100 e realizar todos os cálculos com números inteiros.

valor = float(input("Digite o valor a pagar:"))

cédulas = 0
atual = 100
apagar = valor
while True:
if atual <= apagar:
apagar -= atual
cédulas += 1
else:
if atual >= 1:
print(f"{cédulas} cédula(s) de R${atual}")
else:
print(f"{cédulas} moeda(s) de R${atual:5.2f}")
if apagar < 0.01:
break
elif atual == 100:
atual = 50
elif atual == 50:
atual = 20
elif atual == 20:
atual = 10
elif atual == 10:
atual = 5
elif atual == 5:
atual = 1
elif atual == 1:
atual = 0.50
elif atual == 0.50:
atual = 0.10
elif atual == 0.10:
atual = 0.05
elif atual == 0.05:
atual = 0.02
elif atual == 0.02:
atual = 0.01
cédulas = 0

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 67
Exercício 05-20
O que acontece se digitarmos 0,001 no programa anterior? Caso ele não funcione, altere-o
de forma a corrigir o problema.

# Como preparamos o programa para valores menores que 0.01,

# este pára de executar após imprimir 0 cédula(s) de R$100.
# Ver também a nota do exercício 05.19 para compreender
# melhor este problema.

Atualização do 23 de novembro de 2024 [Link]

68 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-21
Reescreva o Programa 5.1 de forma a con�nuar executando até que o valor digitado seja 0.
U�lize repe�ções aninhadas.

while True:
valor = int(input("Digite o valor a pagar:"))
if valor == 0:
break
cédulas = 0
atual = 50
apagar = valor
while True:
if atual <= apagar:
apagar -= atual
cédulas += 1
else:
print(f"{cédulas} cédula(s) de R${atual}")
if apagar == 0:
break
if atual == 50:
atual = 20
elif atual == 20:
atual = 10
elif atual == 10:
atual = 5
elif atual == 5:
atual = 1
cédulas = 0

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 69
Exercício 05-22
Escreva um programa que exiba uma lista de opções (menu): adição, subtração, divisão,
mul�plicação e sair. Imprima a tabuada da operação escolhida. Repita até que a opção saída
seja escolhida.

while True:
print("""

Menu
\----
1 - Adição
2 - Subtração
3 - Divisão
4 - Multiplicação
5 - Sair

""")
opção = int(input("Escolha uma opção:"))
if opção == 5:
break
elif opção >= 1 and opção < 5:
n = int(input("Tabuada de:"))
x = 1
while x <= 10:
if opção == 1:
print(f"{n} + {x} = {n + x}")
elif opção == 2:
print(f"{n} - {x} = {n - x}")
elif opção == 3:
print(f"{n} / {x} = {n / x:5.4f}")
elif opção == 4:
print(f"{n} x {x} = {n * x}")
x = x + 1
else:
print("Opção inválida!")

Atualização do 23 de novembro de 2024 [Link]

70 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-23
Escreva um programa que leia um número e verifique se é ou não um número primo. Para
fazer essa verificação, calcule o resto da divisão do número por 2 e depois por todos os
números ímpares até o número lido. Se o resto de uma dessas divisões for igual a zero, o
número não é primo. Observe que 0 e 1 não são primos e que 2 é o único número primo que
é par.

n = int(input("Digite um número:"))
if n < 0:
print("Número inválido. Digite apenas valores positivos")
if n == 0 or n == 1:
print(f"{n} é um caso especial.")
else:
if n == 2:
print("2 é primo")
elif n % 2 == 0:
print(f"{n} não é primo, pois 2 é o único número par primo.")
else:
x = 3
while x < n:
if n % x == 0:
break
x = x + 2
if x == n:
print(f"{n} é primo")
else:
print(f"{n} não é primo, pois é divisível por {x}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 71
Exercício 05-24
Modifique o programa anterior de forma a ler um número n. Imprima os n primeiros
números primos.

quantidade_de_primos = int(input("Digite a quantidade de números primos a

gerar: "))
if quantidade_de_primos < 0:
print("Número inválido. Digite apenas valores positivos")
else:
if quantidade_de_primos >= 1:
print("2") # 2 é o único número que é primo e par ao mesmo tempo
primos_gerados = 1 # logo é o primeiro número primo gerado
próximo_primo = 3 # o próximo primo começa então com 3
while primos_gerados < quantidade_de_primos:
# Como todos os primos seguintes são ímpares
divisor = 3
while divisor < próximo_primo:
# Se o resto for zero, o número é divisível
if próximo_primo % divisor == 0:
break
# Incrementa o divisor
divisor = divisor + 2
# Quando o número é primo, ele é divisível apenas por ele mesmo
if divisor == próximo_primo:
print(próximo_primo)
primos_gerados = primos_gerados + 1
# passa para o próximo número ímpar,
# pois os pares não são primos, salvo 2
próximo_primo = próximo_primo + 2

Atualização do 23 de novembro de 2024 [Link]

72 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-25
Escreva um programa que calcule a raiz quadrada de um número. U�lize o método de
Newton para obter um resultado aproximado. Sendo n o número a obter a raiz quadrada,
considere a base b=2. Calcule p usando a fórmula p=(b+(n/b))/2. Agora, calcule o quadrado
de p. A cada passo, faça b=p e recalcule p usando a fórmula apresentada. Pare quando a
diferença absoluta entre n e o quadrado de p for menor que 0,0001.

# Atenção: na primeira edição do livro, a fórmula foi publicada errada.

# A fórmula correta é p = ( b + ( n / b ) ) / 2
# A função abs foi utilizada para calcular o valor absoluto de um número,
# ou seja, seu valor sem sinal.
# Exemplos: abs(1) retorna 1 e abs(-1) retorna 1

n = float(input("Digite um número para encontrar a sua raiz quadrada: "))

b = 2
while abs(n - (b * b)) > 0.00001:
p = (b + (n / b)) / 2
b = p
print(f"A raiz quadrada de {n} é aproximadamente {p:8.4f}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 73
Exercício 05-26
Escreva um programa que calcule o resto da divisão inteira entre dois números. U�lize
apenas as operações de soma e subtração para calcular o resultado.

# Atenção: este exercício é muito semelhante a exercício 5.08

dividendo = int(input("Dividendo: "))
divisor = int(input("Divisor: "))
quociente = 0
x = dividendo
while x >= divisor:
x = x - divisor
quociente = quociente + 1
resto = x
print(f"O resto de {dividendo} / {divisor} é {resto}")

Atualização do 23 de novembro de 2024 [Link]

74 Exercı́cios resolvidos — 4� ediçã o
Exercício 05-27-a
Escreva um programa que verifique se um número é palíndromo. Um número é palíndromo
se con�nua o mesmo caso seus dígitos sejam inver�dos. Exemplos: 454, 10501

# Para resolver este problema, podemos usar strings, apresentadas na seção

3.4 do livro
# Veja que estamos lendo o número sem convertê-lo para int ou float,
# desta forma o valor de s será uma string
s = input("Digite o número a verificar, sem espaços:")
i = 0
f = len(s) - 1 # posição do último caracter da string
while f > i and s[i] == s[f]:
f = f - 1
i = i + 1
if s[i] == s[f]:
print(f"{s} é palíndromo")
else:
print(f"{s} não é palíndromo")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 75
Exercício 05-27-b
Escreva um programa que verifique se um número é palíndromo. Um número é palíndromo
se con�nua o mesmo caso seus dígitos sejam inver�dos. Exemplos: 454, 10501

# Exercício 5.27
# Solução alternativa, usando apenas inteiros
n = int(input("Digite o número a verificar:"))
# Com n é um número inteiro, vamos calcular sua
# quantidade de dígitos, encontrado a primeira
# potência de 10, superior a n.
# Exemplo: 341 - primeira potência de 10 maior: 1000 = 10 ^ 4
# Utilizaremos 4 e não 3 para possibilitar o tratamento de números
# com um só dígito. O ajuste é feito nas fórmulas abaixo
q = 0
while 10**q < n:
q = q + 1
i = q
f = 0
nf = ni = n # Aqui nós copiamos n para ni e nf
pi = pf = 0 # e fazemos pi = pf (para casos especiais)
while i > f:
pi = int(ni / (10 ** (i - 1))) # Dígito mais à direita
pf = nf % 10 # Dígito mais à esquerda
if pi != pf: # Se são diferentes, saímos
break
f = f + 1 # Passamos para o próximo dígito a esqueda
i = i - 1 # Passamos para o dígito a direita seguinte
ni = ni - (pi * (10**i)) # Ajustamos ni de forma a retirar o dígito
anterior
nf = int(nf / 10) # Ajustamos nf para retirar o último dígito

if pi == pf:
print(f"{n} é palíndromo")
else:
print(f"{n} não é palíndromo")

Atualização do 23 de novembro de 2024 [Link]

76 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-01
Modifique o Programa 6.2 para ler 7 notas em vez de 5.

notas = [0, 0, 0, 0, 0, 0, 0] # Ou [0] * 7

soma = 0
x = 0
while x < 7:
notas[x] = float(input(f"Nota {x}:"))
soma += notas[x]
x += 1
x = 0
while x < 7:
print(f"Nota {x}: {notas[x]:6.2f}")
x += 1
print(f"Média: {soma/x:5.2f}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 77
Exercício 06-02
Faça um programa que leia duas listas e que gere uma terceira com os elementos das duas
primeiras.

primeira = []
segunda = []
while True:
e = int(input("Digite um valor para a primeira lista (0 para
terminar): "))
if e == 0:
break
[Link](e)
while True:
e = int(input("Digite um valor para a segunda lista (0 para terminar):
"))
if e == 0:
break
[Link](e)
terceira = primeira[:] # Copia os elementos da primeira lista
[Link](segunda)
x = 0
while x < len(terceira):
print(f"{x}: {terceira[x]}")
x = x + 1

Atualização do 23 de novembro de 2024 [Link]

78 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-03
Faça um programa que percorra duas listas e gere uma terceira sem elementos repe�dos.

primeira = []
segunda = []
while True:
e = int(input("Digite um valor para a primeira lista (0 para
terminar):"))
if e == 0:
break
[Link](e)
while True:
e = int(input("Digite um valor para a segunda lista (0 para
terminar):"))
if e == 0:
break
[Link](e)
terceira = []
# Aqui vamos criar uma outra lista, com os elementos da primeira
# e da segunda. Existem várias formas de resolver este exercício.
# Nesta solução, vamos pesquisar os valores a inserir na terceira
# lista. Se não existirem, adicionaremos à terceira. Caso contrário,
# não copiaremos, evitando assim os repetidos.
duas_listas = primeira[:]
duas_listas.extend(segunda)
x = 0
while x < len(duas_listas):
y = 0
while y < len(terceira):
if duas_listas[x] == terceira[y]:
break
y = y + 1
if y == len(terceira):
[Link](duas_listas[x])
x = x + 1
x = 0
while x < len(terceira):
print(f"{x}: {terceira[x]}")
x = x + 1

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 79
Exercício 06-04
O que acontece quando não verificamos se a lista está vazia antes de chamarmos o método
pop?

# Se não verificarmos que a lista está vazia antes de charmos pop(),

# o programa pára com uma mensagem de erro, informando que tentamos
# retirar um elemento de uma lista vazia.
# A verificação é necessária para controlar este erro e assegurar
# o bom funcionamento do programa.

Atualização do 23 de novembro de 2024 [Link]

80 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-05
Altere o Programa 6.7 de forma a poder trabalhar com vários comandos digitados de uma só
vez. Atualmente, apenas um comando pode ser inserido por vez. Altere-o de forma a
considerar operação como uma string.
Exemplo: FFFAAAS significaria três chegadas de novos clientes, três atendimentos e,
finalmente, a saída do programa.

último = 10
fila = list(range(1, último + 1))
while True:
print(f"\nExistem {len(fila)} clientes na fila")
print("Fila atual:", fila)
print("Digite F para adicionar um cliente ao fim da fila,")
print("ou A para realizar o atendimento. S para sair.")
operação = input("Operação (F, A ou S):")
x = 0
sair = False
while x < len(operação):
if operação[x] == "A":
if len(fila) > 0:
atendido = [Link](0)
print(f"Cliente {atendido} atendido")
else:
print("Fila vazia! Ninguém para atender.")
elif operação[x] == "F":
último += 1 # Incrementa o ticket do novo cliente
[Link](último)
elif operação[x] == "S":
sair = True
break
else:
print(
f"Operação inválida: {operação[x]} na posição {x}! Digite
apenas F, A ou S!"
)
x = x + 1
if sair:
break

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 81
Exercício 06-06
Modifique o programa para trabalhar com duas filas. Para facilitar seu trabalho, considere o
comando A para atendimento da fila 1; e B, para atendimento da fila 2. O mesmo para a
chegada de clientes: F para fila 1; e G, para fila 2.

último = 0
fila1 = []
fila2 = []
while True:
print(f"\nExistem {len(fila1)} clientes na fila 1 e {len(fila2)} na fila
2.")
print("Fila 1 atual:", fila1)
print("Fila 2 autal:", fila2)
print("Digite F para adicionar um cliente ao fim da fila 1 (ou G para
fila 2),")
print("ou A para realizar o atendimento a fila 1 (ou B para fila 2")
print("S para sair.")
operação = input("Operação (F, G, A, B ou S):")
x = 0
sair = False
while x < len(operação):
# Aqui vamos usar fila como referência a fila 1
# ou a fila 2, dependendo da operação.
if operação[x] == "A" or operação[x] == "F":
fila = fila1
else:
fila = fila2
if operação[x] == "A" or operação[x] == "B":
if len(fila) > 0:
atendido = [Link](0)
print(f"Cliente {atendido} atendido")
else:
print("Fila vazia! Ninguém para atender.")
elif operação[x] == "F" or operação[x] == "G":
último += 1 # Incrementa o ticket do novo cliente
[Link](último)
elif operação[x] == "S":
sair = True
break
else:
print(
f"Operação inválida: {operação[x]} na posição {x}! Digite
apenas F, A ou S!"
)
x = x + 1
if sair:
break

Atualização do 23 de novembro de 2024 [Link]

82 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-07
Faça um programa que leia uma expressão com parênteses. Usando pilhas, verifique se os
parênteses foram abertos e fechados na ordem correta.
Exemplo:

(()) OK
()()(()()) OK
()) Erro

Você pode adicionar elementos à pilha sempre que encontrar abre parênteses e desempilhá-
la a cada fecha parênteses. Ao desempilhar, verifique se o topo da pilha é um abre
parênteses. Se a expressão es�ver correta, sua pilha estará vazia no final.

expressão = input("Digite a sequência de parênteses a validar:")

x = 0
pilha = []
while x < len(expressão):
if expressão[x] == "(":
[Link]("(")
if expressão[x] == ")":
if len(pilha) > 0:
topo = [Link](-1)
else:
[Link](")") # Força a mensagem de erro
break
x = x + 1
if len(pilha) == 0:
print("OK")
else:
print("Erro")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 83
Exercício 06-08
Modifique o primeiro exemplo (Programa 6.9) de forma a realizar a mesma tarefa, mas sem
u�lizar a variável achou. Dica: observe a condição de saída do while.

L = [15, 7, 27, 39]

p = int(input("Digite o valor a procurar:"))
x = 0
while x < len(L):
if L[x] == p:
break
x += 1
if x < len(L):
print(f"{p} achado na posição {x}")
else:
print(f"{p} não encontrado")

Atualização do 23 de novembro de 2024 [Link]

84 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-09
Modifique o exemplo para pesquisar dois valores. Em vez de apenas p, leia outro valor v que
também será procurado. Na impressão, indique qual dos dois valores foi achado primeiro.

L = [15, 7, 27, 39]

p = int(input("Digite o valor a procurar (p): "))
v = int(input("Digite o outro valor a procurar (v): "))
x = 0
achouP = False
achouV = False
primeiro = 0
while x < len(L):
if L[x] == p:
achouP = True
if not achouV:
primeiro = 1
if L[x] == v:
achouV = True
if not achouP:
primeiro = 2
x += 1
if achouP:
print(f"p: {p} encontrado")
else:
print(f"p: {p} não encontrado")
if achouV:
print(f"v: {v} encontrado")
else:
print(f"v: {v} não encontrado")
if primeiro == 1:
print("p foi achado antes de v")
elif primeiro == 2:
print("v foi achado antes de p")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 85
Exercício 06-10
Modifique o programa do Exercício 6.9 de forma a pesquisar p e v em toda a lista e
informando o usuário a posição onde p e a posição onde v foram encontrados.

L = [15, 7, 27, 39]

p = int(input("Digite o valor a procurar (p):"))
v = int(input("Digite o outro valor a procurar (v):"))
x = 0
achouP = -1 # Aqui -1 indica que ainda não encontramos o valor procurado
achouV = -1
primeiro = 0
while x < len(L):
if L[x] == p:
achouP = x
if L[x] == v:
achouV = x
x += 1
if achouP != -1:
print(f"p: {p} encontrado na posição {achouP}")
else:
print(f"p: {p} não encontrado")
if achouV != -1:
print(f"v: {v} encontrado na posição {achouV}")
else:
print(f"v: {v} não encontrado")
# Verifica se ambos foram encontrados
if achouP != -1 and achouV != -1:
# como achouP e achouV guardam a posição onde foram encontrados
if achouP <= achouV:
print("p foi achado antes de v")
else:
print("v foi achado antes de p")

Atualização do 23 de novembro de 2024 [Link]

86 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-11
Modifique o Programa 6.6 usando for. Explique por que nem todos os while podem ser
transformados em for.

L = []
while True:
n = int(input("Digite um número (0 sai):"))
if n == 0:
break
[Link](n)
for e in L:
print(e)
# O primeiro while não pôde ser convertido em for porque
# o número de repetições é desconhecido no início.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 87
Exercício 06-12
Altere o Programa 6.11 de forma a imprimir o menor elemento da lista.

L = [4, 2, 1, 7]
mínimo = L[0]
for e in L:
if e < mínimo:
mínimo = e
print(mínimo)

Atualização do 23 de novembro de 2024 [Link]

88 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-13
A lista de temperaturas de Mons, na Bélgica, foi armazenada na lista T = [ -10, -8, 0, 1, 2, 5, -
2, -4]. Faça um programa que imprima a menor e a maior temperatura, assim como a
temperatura média.

T = [-10, -8, 0, 1, 2, 5, -2, -4]

mínima = T[
0
] # A escolha do primeiro elemento é arbitrária, poderia ser qualquer
elemento válido
máxima = T[0]
soma = 0
for e in T:
if e < mínima:
mínima = e
if e > máxima:
máxima = e
soma = soma + e
print(f"Temperatura máxima: {máxima} °C")
print(f"Temperatura mínima: {mínima} °C")
print(f"Temperatura média: {soma / len(T)} °C")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 89
Exercício 06-14
Modifique o Programa 6.13 de forma a mostrar quantos ingressos foram vendidos em cada
sala. U�lize uma lista do mesmo tamanho da quan�dade de salas e u�lize seus elementos
para contar quantos ingressos foram vendidos em cada sala. Imprima na tela o total das
vendas no fim do programa.

lugares_vagos = [10, 2, 1, 3, 0]
vendidos = [0] * len(lugares_vagos)
while True:
sala = int(input("Sala (0 sai): "))
if sala == 0:
print("Fim")
break
if sala > len(lugares_vagos) or sala < 1:
print("Sala inválida")
elif lugares_vagos[sala - 1] == 0:
print("Desculpe, sala lotada!")
else:
lugares = int(
input(f"Quantos lugares você deseja ({lugares_vagos[sala - 1]}
vagos):")
)
if lugares > lugares_vagos[sala - 1]:
print("Esse número de lugares não está disponível.")
elif lugares < 0:
print("Número inválido")
else:
lugares_vagos[sala - 1] -= lugares
vendidos[sala - 1] += lugares
print(f"{lugares} lugares vendidos")
print("\nUtilização das salas")
for sala, vagos in enumerate(lugares_vagos):
print(f"Sala {sala + 1} – {vagos} lugar(es) vazio(s)")
print("\nVendas por sala")
total_vendido = 0
for sala, vendas in enumerate(vendidos):
print(f"Sala {sala + 1} – {vendas} ingressos vendido(s)")
total_vendido += vendas
print(f"Total de ingressos vendidos: {total_vendido}")

Atualização do 23 de novembro de 2024 [Link]

90 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-15
Modifique o Programa 6.13 de forma a perguntar o número de salas disponíveis no cinema,
assim como a quan�dade de lugares em cada uma delas.

n_salas = int(input("Número de salas: "))

lugares_vagos = []
for sala in range(n_salas):
lugares_vagos.append(int(input(f"Lugares vagos na sala {sala + 1}:
")))

vendidos = [0] * len(lugares_vagos)

while True:
sala = int(input("Sala (0 sai): "))
if sala == 0:
print("Fim")
break
if sala > len(lugares_vagos) or sala < 1:
print("Sala inválida")
elif lugares_vagos[sala - 1] == 0:
print("Desculpe, sala lotada!")
else:
lugares = int(
input(f"Quantos lugares você deseja ({lugares_vagos[sala - 1]}
vagos):")
)
if lugares > lugares_vagos[sala - 1]:
print("Esse número de lugares não está disponível.")
elif lugares < 0:
print("Número inválido")
else:
lugares_vagos[sala - 1] -= lugares
vendidos[sala - 1] += lugares
print(f"{lugares} lugares vendidos")
print("\nUtilização das salas")
for sala, vagos in enumerate(lugares_vagos):
print(f"Sala {sala + 1} – {vagos} lugar(es) vazio(s)")
print("\nVendas por sala")
total_vendido = 0
for sala, vendas in enumerate(vendidos):
print(f"Sala {sala + 1} – {vendas} ingressos vendido(s)")
total_vendido += vendas
print(f"Total de ingressos vendidos: {total_vendido}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 91
Exercício 06-16
O que acontece quando a lista já está ordenada? Rastreie o Programa 6.20, mas com a lista L
= [1, 2, 3, 4, 5].

# Se a lista já estiver ordenada, nenhum elemento é maior que o elemento

seguinte.
# Desta forma, após a primeira verificação de todos os elementos,
# o loop interno é interrompido pela condição de (9).

Atualização do 23 de novembro de 2024 [Link]

92 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-17
O que acontece quando dois valores são iguais? Rastreie o Programa 6.20, mas com a lista L
= [3, 3, 1, 5, 4].

# Como utilizamos o método de bolhas, na primeira verificação, 3, 3 são

considerados como na ordem correta.
# Quanto verificamos o segundo 3 com 1, ocorre uma troca.
# O mesmo vai ocorrer com o primeiro 3, mas apenas na próxima repetição.
Veja que o 1 subiu para a primeira posição
# como uma bolha de ar dentro d'água.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 93
Exercício 06-18
Modifique o Programa 6.20 para ordenar a lista em ordem decrescente. L = [1, 2, 3, 4, 5]
deve ser ordenada como L = [5, 4, 3, 2, 1].

L = [1, 2, 3, 4, 5]
fim = 5
while fim > 1:
trocou = False
x = 0
while x < (fim - 1):
if L[x] < L[x + 1]: # Apenas a condição de verificação foi
alterada
trocou = True
temp = L[x]
L[x] = L[x + 1]
L[x + 1] = temp
x += 1
if not trocou:
break
fim -= 1
for e in L:
print(e)

Atualização do 23 de novembro de 2024 [Link]

94 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-19
Altere o Programa 6.22 de forma a solicitar ao usuário o produto e a quan�dade vendida.
Verifique se o nome do produto digitado existe no dicionário, e só então efetue a baixa em
estoque.

estoque = {
"tomate": [1000, 2.30],
"alface": [500, 0.45],
"batata": [2001, 1.20],
"feijão": [100, 1.50],
}
total = 0
print("Vendas:\n")
while True:
produto = input("Nome do produto (fim para sair):")
if produto == "fim":
break
if produto in estoque:
quantidade = int(input("Quantidade:"))
if quantidade <= estoque[produto][0]:
preço = estoque[produto][1]
custo = preço * quantidade
print(f"{produto:12s}: {quantidade:3d} x {preço:6.2f} =
{custo:6.2f}")
estoque[produto][0] -= quantidade
total += custo
else:
print("Quantidade solicitada não disponível")
else:
print("Nome de produto inválido")
print(f" Custo total: {total:21.2f}\n")
print("Estoque:\n")
for chave, dados in [Link]():
print("Descrição: ", chave)
print("Quantidade: ", dados[0])
print(f"Preço: {dados[1]:6.2f}\n")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 95
Exercício 06-20-a
Escreva um programa que gere um dicionário, em que cada chave seja um caractere, e seu
valor seja o número desse caractere encontrado em uma frase lida. Exemplo: O rato → {
“O”:1, “r”:1, “a”:1, “t”:1, “o”:1}

frase = input("Digite uma frase para contar as letras:")

d = {}
for letra in frase:
if letra in d:
d[letra] = d[letra] + 1
else:
d[letra] = 1
print(d)

Atualização do 23 de novembro de 2024 [Link]

96 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-20-b
Escreva um programa que gere um dicionário, em que cada chave seja um caractere, e seu
valor seja o número desse caractere encontrado em uma frase lida. Exemplo: O rato → {
“O”:1, “r”:1, “a”:1, “t”:1, “o”:1}

# Solução alternativa, usando o método get do dicionário

frase = input("Digite uma frase para contar as letras:")

d = {}
for letra in frase:
# Se letra não existir no dicionário, retorna 0
# se existir, retorna o valor anterior
d[letra] = [Link](letra, 0) + 1
print(d)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 97
Exercício 06-21
Escreva um programa que compare duas listas. U�lizando operações com conjuntos,
imprima: • os valores comuns às duas listas • os valores que só existem na primeira • os
valores que existem apenas na segunda • uma lista com os elementos não repe�dos das
duas listas. • a primeira lista sem os elementos repe�dos na segunda

L1 = [1, 2, 6, 8]
L2 = [3, 6, 8, 9]

print(f"Lista 1: {L1}")
print(f"Lista 2: {L2}")

conjunto_1 = set(L1)
conjunto_2 = set(L2)

# Conjuntos suportam o operador & para realizar a interseção, ou seja,

# A & B resulta no conjunto de elementos presentes em A e B
print("Valores comuns às duas listas:", conjunto_1 & conjunto_2)
print("Valores que só existem na primeira:", conjunto_1 - conjunto_2)
print("Valores que só existem na segunda:", conjunto_2 - conjunto_1)

# Conjuntos suportam o operador ^ que realiza a subtração simétrica.

# A ^ B resulta nos elementos de A não presentes em B unidos
# com os elementos de B não presentes em A
# A ^ B = A - B | B - A
print("Elementos não repetidos nas duas listas:", conjunto_1 ^ conjunto_2)

# Repetido:
print("Primeira lista, sem os elementos repetidos na segunda:", conjunto_1
- conjunto_2)

Atualização do 23 de novembro de 2024 [Link]

98 Exercı́cios resolvidos — 4� ediçã o
Exercício 06-22
Escreva um programa que compare duas listas. Considere a primeira lista como a versão
inicial e a segunda como a versão após alterações. U�lizando operações com conjuntos, seu
programa deverá imprimir a lista de modificações entre essas duas versões, listando: • os
elementos que não mudaram • os novos elementos • os elementos que foram removidos

ANTES = [1, 2, 5, 6, 9]
DEPOIS = [1, 2, 8, 10]

conjunto_antes = set(ANTES)
conjunto_depois = set(DEPOIS)

# Conjuntos suportam o operador & para realizar a interseção, ou seja,

# A & B resulta no conjunto de elementos presentes em A e B
print("Antes:", ANTES)
print("Depois:", DEPOIS)
print("Elementos que não mudaram: ", conjunto_antes & conjunto_depois)
print("Elementos novos", conjunto_depois - conjunto_antes)
print("Elementos que foram removidos", conjunto_antes - conjunto_depois)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 99
Exercício 07-01
Escreva um programa que leia duas strings. Verifique se a segunda ocorre dentro da primeira
e imprima a posição de início. 1ª string: AABBEFAATT 2ª string: BE Resultado: BE encontrado
na posição 3 de AABBEFAATT

primeira = input("Digite a primeira string: ")

segunda = input("Digite a segunda string: ")

posição = [Link](segunda)

if posição == -1:
print(f"'{segunda}' não encontrada em '{primeira}'")
else:
print(f"{segunda} encontrada na posição {posição} de {primeira}")

Atualização do 23 de novembro de 2024 [Link]

100 Exercı́cios resolvidos — 4� ediçã o
Exercício 07-02
Escreva um programa que leia duas strings e gere uma terceira com os caracteres comuns às
duas strings lidas. 1ª string: AAACTBF 2ª string: CBT Resultado: CBT A ordem dos caracteres
da string gerada não é importante, mas deve conter todas as letras comuns a ambas.

primeira = input("Digite a primeira string: ")

segunda = input("Digite a segunda string: ")

terceira = ""

# Para cada letra na primeira string

for letra in primeira:
# Se a letra está na segunda string (comum a ambas)
# Para evitar repetidas, não deve estar na terceira.
if letra in segunda and letra not in terceira:
terceira += letra

if terceira == "":
print("Caracteres comuns não encontrados.")
else:
print(f"Caracteres em comum: {terceira}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 101
Exercício 07-03
Escreva um programa que leia duas strings e gere uma terceira apenas com os caracteres que
aparecem em uma delas. 1ª string: CTA 2ª string: ABC 3ª string: BT A ordem dos caracteres
da terceira string não é importante.

primeira = input("Digite a primeira string: ")

segunda = input("Digite a segunda string: ")

terceira = ""

# Para cada letra na primeira string

for letra in primeira:
# Verifica se a letra não aparece dentro da segunda string
# e também se já não está listada na terceira
if letra not in segunda and letra not in terceira:
terceira += letra

# Para cada letra na segunda string

for letra in segunda:
# Além de não estar na primeira string,
# verifica se já não está na terceira (evitar repetições)
if letra not in primeira and letra not in terceira:
terceira += letra

if terceira == "":
print("Caracteres incomuns não encontrados.")
else:
print(f"Caracteres incomuns: {terceira}")

Atualização do 23 de novembro de 2024 [Link]

102 Exercı́cios resolvidos — 4� ediçã o
Exercício 07-04
Escreva um programa que leia uma string e imprima quantas vezes cada caractere aparece
nessa string. String: TTAAC Resultado: T: 2x A: 2x C: 1x

sequencia = input("Digite a string: ")

contador = {}

for letra in sequencia:

contador[letra] = [Link](letra, 0) + 1

for chave, valor in [Link]():

print(f"{chave}: {valor}x")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 103
Exercício 07-05
Escreva um programa que leia duas strings e gere uma terceira, na qual os caracteres da
segunda foram re�rados da primeira. 1ª string: AATTGGAA 2ª string: TG 3ª string: AAAA

primeira = input("Digite a primeira string: ")

segunda = input("Digite a segunda string: ")

terceira = ""

for letra in primeira:

if letra not in segunda:
terceira += letra

if terceira == "":
print("Todos os caracteres foram removidos.")
else:
print(f"Os caracteres {segunda} foram removidos de {primeira},
gerando: {terceira}")

Atualização do 23 de novembro de 2024 [Link]

104 Exercı́cios resolvidos — 4� ediçã o
Exercício 07-06
Escreva um programa que leia três strings. Imprima o resultado da subs�tuição na primeira,
dos caracteres da segunda pelos da terceira. 1ª string: AATTCGAA 2ª string: TG 3ª string: AC
Resultado: AAAACCAA

primeira = input("Digite a primeira string: ")

segunda = input("Digite a segunda string: ")
terceira = input("Digite a terceira string: ")

if len(segunda) == len(terceira):
resultado = ""
for letra in primeira:
posição = [Link](letra)
if posição != -1:
resultado += terceira[posição]
else:
resultado += letra

if resultado == "":
print("Todos os caracteres foram removidos.")
else:
print(
f"Os caracteres {segunda} foram substituidos por "
f"{terceira} em {primeira}, gerando: {resultado}"
)
else:
print("ERRO: A segunda e a terceira string devem ter o mesmo
tamanho.")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 105
Exercício 07-07
Escreva um programa que peça ao usuário que digite uma frase e imprima quantas vogais ela
contém. Não considere maiúsculas e minúsculas como diferentes. Exemplo: uma frase como
“A casa” deve imprimir três “as”.

vogais = "aeiou"
frase = input("Digite uma frase: ")
frase_minúscula = [Link]()
for vogal in vogais:
ocorrência_vogal = frase_minú[Link](vogal)
if ocorrência_vogal > 0:
print(f"{vogal} aparece {ocorrência_vogal} vez(es)")

Atualização do 23 de novembro de 2024 [Link]

106 Exercı́cios resolvidos — 4� ediçã o
Exercício 07-08
Escreva um programa para exibir todas as palavras de uma frase. Considere que uma palavra
termina com um espaço em branco ou quando a string terminar. Exemplo: “O rato roeu a
roupa” deve imprimir 5.

frase = input("Digite uma frase: ")

palavras = [Link]()
for palavra in palavras:
print(palavra)
print("Número de palavras:", len(palavras))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 107
Exercício 07-09
Modifique o o jogo da forca (Programa 7.2) de forma a escrever a palavra secreta caso o
jogador perca.

palavra = input("Digite a palavra secreta:").lower().strip()

for x in range(100):
print()
digitadas = []
acertos = []
erros = 0
while True:
senha = ""
for letra in palavra:
senha += letra if letra in acertos else "."
print(senha)
if senha == palavra:
print("Você acertou!")
break
tentativa = input("\nDigite uma letra:").lower().strip()
if tentativa in digitadas:
print("Você já tentou esta letra!")
continue
else:
digitadas += tentativa
if tentativa in palavra:
acertos += tentativa
else:
erros += 1
print("Você errou!")
print("X==:==\nX : ")
print("X O " if erros >= 1 else "X")
linha2 = ""
if erros == 2:
# O r antes da string indica que seu conteúdo não deve ser
processado
# Desta forma, podemos usar os caracteres de \ e / sem confundi-
los
# com máscaras como \n e \t
linha2 = r" | "
elif erros == 3:
linha2 = r" \| "
elif erros >= 4:
linha2 = r" \|/ "
print(f"X{linha2}")
linha3 = ""
if erros == 5:
linha3 += r" / "
elif erros >= 6:
linha3 += r" / \ "
print(f"X{linha3}")
print("X\n===========")

Atualização do 23 de novembro de 2024 [Link]

108 Exercı́cios resolvidos — 4� ediçã o
if erros == 6:
print("Enforcado!")
print(f"A palavra secreta era: {palavra}")
break

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 109
Exercício 07-10
Modifique o Programa 7.2 de forma a u�lizar uma lista de palavras. No início, pergunte um
número e calcule o índice da palavra a u�lizar pela fórmula: índice = (número * 776) %
len(lista_de_palavras).

palavras = [
"casa",
"bola",
"mangueira",
"uva",
"quiabo",
"computador",
"cobra",
"lentilha",
"arroz",
]

índice = int(input("Digite um numero:"))

palavra = palavras[(índice * 776) % len(palavras)]
for x in range(100):
print()
digitadas = []
acertos = []
erros = 0
while True:
senha = ""
for letra in palavra:
senha += letra if letra in acertos else "."
print(senha)
if senha == palavra:
print("Você acertou!")
break
tentativa = input("\nDigite uma letra:").lower().strip()
if tentativa in digitadas:
print("Você já tentou esta letra!")
continue
else:
digitadas += tentativa
if tentativa in palavra:
acertos += tentativa
else:
erros += 1
print("Você errou!")
print("X==:==\nX : ")
print("X O " if erros >= 1 else "X")
linha2 = ""
if erros == 2:
linha2 = r" | "
elif erros == 3:
linha2 = r" \| "
elif erros >= 4:

Atualização do 23 de novembro de 2024 [Link]

110 Exercı́cios resolvidos — 4� ediçã o
linha2 = r" \|/ "
print(f"X{linha2}")
linha3 = ""
if erros == 5:
linha3 += r" / "
elif erros >= 6:
linha3 += r" / \ "
print(f"X{linha3}")
print("X\n===========")
if erros == 6:
print("Enforcado!")
print(f"A palavra secreta era: {palavra}")
break

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 111
Exercício 07-11
Modifique o Programa 7.2 para u�lizar listas de strings para desenhar o boneco da forca.
Você pode u�lizar uma lista para cada linha e organizá-las em uma lista de listas. Em vez de
controlar quando imprimir cada parte, desenhe nessas listas, subs�tuindo o elemento a
desenhar.
Exemplo:

>>> linha = list("X------")

>>> linha
['X', '-', '-', '-', '-', '-', '-']
>>> linha[6] = "|"
>>> linha
['X', '-', '-', '-', '-', '-', '|']
>>> "".join(linha)
'X-----|'

palavras = [
"casa",
"bola",
"mangueira",
"uva",
"quiabo",
"computador",
"cobra",
"lentilha",
"arroz",
]

índice = int(input("Digite um numero:"))

palavra = palavras[(índice * 776) % len(palavras)]
for x in range(100):
print()
digitadas = []
acertos = []
erros = 0

linhas_txt = """
X==:==
X :
X
X
X
X
=======

"""

linhas = []

Atualização do 23 de novembro de 2024 [Link]

112 Exercı́cios resolvidos — 4� ediçã o

for linha in linhas_txt.splitlines():

[Link](list(linha))

while True:
senha = ""
for letra in palavra:
senha += letra if letra in acertos else "."
print(senha)
if senha == palavra:
print("Você acertou!")
break
tentativa = input("\nDigite uma letra:").lower().strip()
if tentativa in digitadas:
print("Você já tentou esta letra!")
continue
else:
digitadas += tentativa
if tentativa in palavra:
acertos += tentativa
else:
erros += 1
print("Você errou!")
if erros == 1:
linhas[3][3] = "O"
elif erros == 2:
linhas[4][3] = "|"
elif erros == 3:
linhas[4][2] = "\\"
elif erros == 4:
linhas[4][4] = "/"
elif erros == 5:
linhas[5][2] = "/"
elif erros == 6:
linhas[5][4] = "\\"

for l in linhas:
print("".join(l))
if erros == 6:
print("Enforcado!")
print(f"A palavra secreta era: {palavra}")
break

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 113
Exercício 07-12
Escreva um jogo da velha para dois jogadores. O jogo deve perguntar onde você quer jogar e
alternar entre os jogadores. A cada jogada, verifique se a posição está livre. Verifique
também quando um jogador venceu a par�da. Um jogo da velha pode ser visto como uma
lista de 3 elementos, na qual cada elemento é outra lista, também com três elementos.
Exemplo do jogo:

X | O |
---+---+---
| X | X
---+---+---
| | O

Em que cada posição pode ser vista como um número. Confira a seguir um exemplo das
posições mapeadas para a mesma posição de seu teclado numérico.

7 | 8 | 9
---+---+---
4 | 5 | 6
---+---+---
1 | 2 | 3

#
# Jogo da Velha
#

# O tabuleiro
velha = """ Posições
| | 7 | 8 | 9
---+---+--- ---+---+---
| | 4 | 5 | 6
---+---+--- ---+---+---
| | 1 | 2 | 3
"""
# Uma lista de posições (linha e coluna) para cada posição válida do jogo
# Um elemento extra foi adicionado para facilitar a manipulação
# dos índices e para que estes tenham o mesmo valor da posição
#
# 7 | 8 | 9
# ---+---+---
# 4 | 5 | 6
# ---+---+---
# 1 | 2 | 3

posições = [
None, # Elemento adicionado para facilitar índices
(5, 1), # 1
(5, 5), # 2

Atualização do 23 de novembro de 2024 [Link]

114 Exercı́cios resolvidos — 4� ediçã o
(5, 9), # 3
(3, 1), # 4
(3, 5), # 5
(3, 9), # 6
(1, 1), # 7
(1, 5), # 8
(1, 9), # 9
]

# Posições que levam ao ganho do jogo

# Jogadas fazendo uma linha, um coluna ou as diagonais ganham
# Os números representam as posições ganhadoras
ganho = [
[1, 2, 3], # Linhas
[4, 5, 6],
[7, 8, 9],
[7, 4, 1], # Colunas
[8, 5, 2],
[9, 6, 3],
[7, 5, 3], # Diagonais
[1, 5, 9],
]

# Constroi o tabuleiro a partir das strings

# gerando uma lista de listas que pode ser modificada
tabuleiro = []
for linha in [Link]():
[Link](list(linha))

jogador = "X" # Começa jogando com X

jogando = True
jogadas = 0 # Contador de jogadas - usado para saber se velhou
while True:
for t in tabuleiro: # Imprime o tabuleiro
print("".join(t))
if not jogando: # Termina após imprimir o último tabuleiro
break
if (
jogadas == 9
): # Se 9 jogadas foram feitas, todas as posições já foram
preenchidas
print("Deu velha! Ninguém ganhou.")
break
jogada = int(input(f"Digite a posição a jogar 1-9 (jogador
{jogador}):"))
if jogada < 1 or jogada > 9:
print("Posição inválida")
continue
# Verifica se a posição está livre
if tabuleiro[posições[jogada][0]][posições[jogada][1]] != " ":
print("Posição ocupada.")
continue
# Marca a jogada para o jogador
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 115
tabuleiro[posições[jogada][0]][posições[jogada][1]] = jogador
# Verfica se ganhou
for p in ganho:
for x in p:
if tabuleiro[posições[x][0]][posições[x][1]] != jogador:
break
else: # Se o for terminar sem break, todas as posicoes de p
pertencem ao mesmo jogador
print(f"O jogador {jogador} ganhou ({p}): ")
jogando = False
break
jogador = "X" if jogador == "O" else "O" # Alterna jogador
jogadas += 1 # Contador de jogadas

# Sobre a conversão de coordenadas:

# tabuleiro[posições[x][0]][posições[x][1]]
#
# Como tabuleiro é uma lista de listas, podemos acessar cada caracter
# especificando uma linha e uma coluna. Para obter a linha e a coluna, com
base
# na posição jogada, usamos a lista de posições que retorna uma tupla com
2 elementos:
# linha e coluna. Sendo linha o elemento [0] e coluna o elemento [1].
# O que estas linhas realizam é a conversão de uma posição de jogo (1-9)
# em linhas e colunas do tabuleiro. Veja que neste exemplo usamos o
tabuleiro como
# memória de jogadas, além da exibição do estado atual do jogo.

Atualização do 23 de novembro de 2024 [Link]

116 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-01
Escreva uma função que retorne o maior de dois números. Valores esperados: máximo(5, 6)
== 6 máximo(2, 1) == 2 máximo(7, 7) == 7

def máximo(a, b):

if a > b:
return a
else:
return b

print(f"máximo(5,6) == 6 -> obtido: {máximo(5,6)}")

print(f"máximo(2,1) == 2 -> obtido: {máximo(2,1)}")
print(f"máximo(7,7) == 7 -> obtido: {máximo(7,7)}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 117
Exercício 08-02
Escreva uma função que receba dois números e retorne True se o primeiro número for
múl�plo do segundo. Valores esperados: múl�plo(8, 4) == True múl�plo(7, 3) == False
múl�plo(5, 5) == True

def múltiplo(a, b):

return a % b == 0

print(f"múltiplo(8,4) == True -> obtido: {múltiplo(8,4)}")

print(f"múltiplo(7,3) == False -> obtido: {múltiplo(7,3)}")
print(f"múltiplo(5,5) == True -> obtido: {múltiplo(5,5)}")

Atualização do 23 de novembro de 2024 [Link]

118 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-03
Escreva uma função que receba o lado de um quadrado e retorne sua área (A = lado²).
Valores esperados: área_quadrado(4) == 16 área_quadrado(9) == 81

def área_quadrado(l):
return l**2

print(f"área_quadrado(4) == 16 -> obtido: {área_quadrado(4)}")

print(f"área_quadrado(9) == 81 -> obtido: {área_quadrado(9)}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 119
Exercício 08-04
Escreva uma função que receba a base e a altura de um triângulo e retorne sua área (A =
(base x altura) / 2). Valores esperados: área_triângulo(6, 9) == 27 área_triângulo(5, 8) == 20

def área_triângulo(b, h):

return (b * h) / 2

print(f"área_triângulo(6, 9) == 27 -> obtido: {área_triângulo(6,9)}")

print(f"área_triângulo(5, 8) == 20 -> obtido: {área_triângulo(5,8)}")

Atualização do 23 de novembro de 2024 [Link]

120 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-05
Reescreva a função do Programa 8.1 de forma a u�lizar os métodos de pesquisa em lista,
vistos no Capítulo 7.

def pesquise(lista, valor):

if valor in lista:
return [Link](valor)
return None

L = [10, 20, 25, 30]

print(pesquise(L, 25))
print(pesquise(L, 27))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 121
Exercício 08-06
Reescreva o Programa 8.2 de forma a u�lizar for em vez de while.

def soma(L):
total = 0
for e in L:
total += e
return total

L = [1, 7, 2, 9, 15]
print(soma(L))
print(soma([7, 9, 12, 3, 100, 20, 4]))

Atualização do 23 de novembro de 2024 [Link]

122 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-07
Defina uma função recursiva que calcule o maior divisor comum (M.D.C.) entre dois números
a e b, em que a > b. Ver representação no livro

def mdc(a, b):

if b == 0:
return a
return mdc(b, a % b)

print(f"MDC 10 e 5 --> {mdc(10,5)}")

print(f"MDC 32 e 24 --> {mdc(32,24)}")
print(f"MDC 5 e 3 --> {mdc(5,3)}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 123
Exercício 08-08
Usando a função mdc definida no exercício anterior, defina uma função para calcular o
menor múl�plo comum (M.M.C.) entre dois números. mmc(a, b) = |a × b| / mdc(a, b) Em
que |a × b| pode ser escrito em Python como: abs(a * b).

def mdc(a, b):

if b == 0:
return a
return mdc(b, a % b)

def mmc(a, b):

return abs(a * b) / mdc(a, b)

print(f"MMC 10 e 5 --> {mmc(10, 5)}")

print(f"MMC 32 e 24 --> {mmc(32, 24)}")
print(f"MMC 5 e 3 --> {mmc(5, 3)}")

Atualização do 23 de novembro de 2024 [Link]

124 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-09
Rastreie o Programa 8.6 e compare o seu resultado com o apresentado

# O programa calcula o fatorial de 4

# Pelas mensagens de saída impressas e pelo rastreamento do programa,
# podemos concluir que o fatorial de 4 é calculado com chamadas recursivas
# na linha: fat = n * fatorial(n-1)
#
# Como a chamada do fatorial precede a impressão da linha Fatorial de,
# podemos visualizar a sequencia em forma de pilha, onde o cálculo é feito
de fora
# para dentro: Cálculo do fatorial de 4, 3 , 2 e 1
# para então prosseguir na linha seguinte, que faz a impressão dos
resultados:
# fatorial de 1,2,3,4

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 125
Exercício 08-10
Reescreva a função para cálculo da sequência de Fibonacci, sem u�lizar recursão.

def fibonacci(n):
p = 0
s = 1
while n > 0:
p, s = s, s + p
n -= 1
return p

for x in range(10):
print(f"fibonacci({x}) = {fibonacci(x)}")

Atualização do 23 de novembro de 2024 [Link]

126 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-11
Escreva uma função para validar uma variável string. Essa função recebe como parâmetro a
string, o número mínimo e máximo de caracteres. Retorne verdadeiro se o tamanho da string
es�ver entre os valores de máximo e mínimo, e falso, caso contrário.

def valida_string(s, mín, máx):

tamanho = len(s)
return mín <= tamanho <= máx

print(valida_string("", 1, 5))
print(valida_string("ABC", 2, 5))
print(valida_string("ABCEFG", 3, 5))
print(valida_string("ABCEFG", 1, 10))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 127
Exercício 08-12
Escreva uma função que receba uma string e uma lista. A função deve comparar a string
passada com os elementos da lista, também passada como parâmetro. Retorne verdadeiro
se a string for encontrada dentro da lista, e falso, caso contrário.

def procura_string(s, lista):

return s in lista

L = ["AB", "CD", "EF", "FG"]

print(procura_string("AB", L))
print(procura_string("CD", L))
print(procura_string("EF", L))
print(procura_string("FG", L))
print(procura_string("XYZ", L))

Atualização do 23 de novembro de 2024 [Link]

128 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-13-a
Escreva uma função que receba uma string com as opções válidas a aceitar (cada opção é
uma letra). Converta as opções válidas para letras minúsculas. U�lize input para ler uma
opção, converter o valor para letras minúsculas e verificar se a opção é válida. Em caso de
opção inválida, a função deve pedir ao usuário que digite novamente outra opção.

def valida_entrada(mensagem, opções_válidas):

opções = opções_vá[Link]()
while True:
escolha = input(mensagem)
if [Link]() in opções:
break
print("Erro: opção inválida. Redigite.\n")
return escolha

# Exemplo:print(valida_entrada("Escolha uma opção:", "abcde"))

#
# Questão extra: o que acontece se o usuário digitar mais de uma opção?
# Por exemplo, ab.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 129
Exercício 08-13-b
Escreva uma função que receba uma string com as opções válidas a aceitar (cada opção é
uma letra). Converta as opções válidas para letras minúsculas. U�lize input para ler uma
opção, converter o valor para letras minúsculas e verificar se a opção é válida. Em caso de
opção inválida, a função deve pedir ao usuário que digite novamente outra opção.

def valida_opções(validas):
validas = [Link]()
while True:
opção = input("Digite uma opção:").lower()
if opção in validas:
return opção
print("Opção inválida, por favor escolha novamente.")

Atualização do 23 de novembro de 2024 [Link]

130 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-14
Altere o Programa 8.22 de forma que o usuário tenha três chances de acertar o número. O
programa termina se o usuário acertar ou errar três vezes.

import random

n = [Link](1, 10)
tentativas = 0
while tentativas < 3:
x = int(input("Escolha um número entre 1 e 10: "))
if x == n:
print("Você acertou!")
break
else:
print("Você errou.")
tentativas += 1

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 131
Exercício 08-15
Altere o Programa 7.2, o jogo da forca. Escolha a palavra a adivinhar u�lizando números
aleatórios.

import random

palavras = [
"casa",
"bola",
"mangueira",
"uva",
"quiabo",
"computador",
"cobra",
"lentilha",
"arroz",
]
# Escolhe uma palavra aleatoriamente
palavra = palavras[[Link](0, len(palavras) - 1)]

digitadas = []
acertos = []
erros = 0

linhas_txt = """
X==:==
X :
X
X
X
X
=======

"""

linhas = []

for linha in linhas_txt.splitlines():

[Link](list(linha))

while True:
senha = ""
for letra in palavra:
senha += letra if letra in acertos else "."
print(senha)
if senha == palavra:
print("Você acertou!")
break
tentativa = input("\nDigite uma letra:").lower().strip()
if tentativa in digitadas:

Atualização do 23 de novembro de 2024 [Link]

132 Exercı́cios resolvidos — 4� ediçã o
print("Você já tentou esta letra!")
continue
else:
digitadas += tentativa
if tentativa in palavra:
acertos += tentativa
else:
erros += 1
print("Você errou!")
if erros == 1:
linhas[3][3] = "O"
elif erros == 2:
linhas[4][3] = "|"
elif erros == 3:
linhas[4][2] = "\\"
elif erros == 4:
linhas[4][4] = "/"
elif erros == 5:
linhas[5][2] = "/"
elif erros == 6:
linhas[5][4] = "\\"

for l in linhas:
print("".join(l))
if erros == 6:
print("Enforcado!")
print(f"A palavra secreta era: {palavra}")
break

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 133
Exercício 08-16
Modifique o jogo do alienígena (Programa 8.23). Crie uma variável que represente a vida do
jogador, começando com 100. A par�da termina quando você encontrar o alienígena ou
quando a vida acabar (⇐0). A cada erro, diminua a vida por um valor aleatório entre 5 e 20,
representando um ataque do alienígena. Você pode re�rar a parte do jogo que limita o
número de tenta�vas e deixar apenas a vida do jogador ou do alienígena decidirem quando a
par�da termina. Exiba a vida do jogador antes de perguntar a próxima árvore.

import random

vida_jogador = 100
árvore = [Link](1, 100)
print("Um alienígena está escondido atrás de uma árvore")
print("Cada árvore foi numerada de 1 a 100.")
print("Você tem 3 tentativas para adivinhar em que árvore")
print("o alienígena se esconde.")

while vida_jogador > 0:

print(f"Pontos de vida: {vida_jogador}")
palpite = int(input(f"Escolha uma árvore [1-100]: "))
if palpite == árvore:
print(f"Você acertou! O alienígena foi encontrado!")
break
elif palpite > árvore:
print("Muito alto")
else:
print("Muito baixo")
dano = [Link](5, 20)
vida_jogador -= dano

if vida_jogador <= 0:
print("Você não conseguiu sobreviver. O alienígena venceu.")
print(f"O alienígena estava na árvore {árvore}.")

Atualização do 23 de novembro de 2024 [Link]

134 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-17
Melhore o programa do exercício anterior perguntando ao jogador o nível de dificuldade
desejado. No modo fácil, a vida começa com 100 e o alienígena pode causar entre 5 e 20 de
dano, como anteriormente. No modo médio, a vida começa com 80 e o alienígena pode
causar danos entre 10 e 25. Já no modo di�cil, a vida começa com 75 e o alienígena causa
danos entre 20 e 30. Adicione mensagens e caracteres para deixar o jogo mais diver�do.

import random

print(" Bem-vindo ao Caça Alienígenas! ")

print("\nEscolha o nível de dificuldade:")
print("1 - Fácil ( 100 HP | Dano: 5-20)")
print("2 - Médio ( 80 HP | Dano: 10-25)")
print("3 - Difícil ( 75 HP | Dano: 20-30)")

while True:
nivel = input("\nDigite o número do nível (1-3): ")
if nivel in ["1", "2", "3"]:
break
print(" Opção inválida! Escolha 1, 2 ou 3.")

if nivel == "1":
vida_jogador = 100
dano_min, dano_max = 5, 20
elif nivel == "2":
vida_jogador = 80
dano_min, dano_max = 10, 25
else:
vida_jogador = 75
dano_min, dano_max = 20, 30

árvore = [Link](1, 100)

print("\n Um alienígena está escondido atrás de uma árvore!")
print(" Cada árvore foi numerada de 1 a 100.")
print(" Você tem que adivinhar em que árvore o alienígena se esconde.")
print(" Cuidado! O alienígena vai te atacar a cada tentativa errada!
\n")

while vida_jogador > 0:

print(f" Pontos de vida: {vida_jogador}")
palpite = int(input(" Escolha uma árvore [1-100]: "))
if palpite == árvore:
print("\n PARABÉNS! Você acertou! O alienígena foi encontrado!
")
break
elif palpite > árvore:
print(" Muito alto! Tente um número menor.")
else:
print(" Muito baixo! Tente um número maior.")
dano = [Link](dano_min, dano_max)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 135
vida_jogador -= dano
print(f" O alienígena te atacou! Dano: {dano}\n")

if vida_jogador <= 0:
print("\n Game Over! Você não conseguiu sobreviver.")
print(f" O alienígena estava na árvore {árvore}.")

Atualização do 23 de novembro de 2024 [Link]

136 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-18
Modifique o Programa 8.26 para que receba dois parâmetros opcionais. Um para indicar o
caractere a imprimir antes do número, sendo o espaço em branco o valor padrão, caso este
não seja passado. O segundo parâmetro opcional é quantos caracteres adicionar por nível,
tendo 2 como valor padrão.

def imprime_listas(lista, nível=0, caractere=" ", incremento=2):

for x in lista:
if isinstance(x, int):
print(f"{caractere * (nível * incremento)}{x}")
else:
imprime_listas(x, nível + 1, caractere, incremento)

# Exemplo de uso:
# imprime_listas([1, 2, 3, [4, 5, 6, [7, 8, 9]], 10], caractere="*",
incremento=4)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 137
Exercício 08-19
Escreva um generator capaz de gerar a sequência dos números primos.

def primos(n):
p = 1 # Posição na sequencia
yield 2 # 2 é o único primo que é par
d = 3 # divisor começa com 3
b = 3 # dividendo começa com 3, é o número que testaremos ser primo
ou não
while p < n:
# print(d, b, d % b, p, n)
if b % d == 0: # Se b é divisível por d, o resto será 0
if b == d: # Se b igual a d, todos os valores d já foram
testados
yield b # b é primo
p += 1 # incrementa a sequencia
b += 2 # Passa para o próximo número ímpar
d = 3 # Recomeça a dividir por 3
elif d < b: # Continua tentando?
d += 2 # Incrementa o divisor para o próximo ímpar
else:
b += 2 # Tenta outro número ímpar

for primo in primos(10):

print(primo)

Atualização do 23 de novembro de 2024 [Link]

138 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-20
Escreva um generator capaz de gerar uma sequência com o fatorial de 1 até n, em que n é
passado como parâmetro para o gerador.

def gerador_fatorial(n):
p = 1
for v in range(1, n + 1):
p *= v
yield p

# Exemplo de uso:
# Gerar fatoriais de 1 a 5
for n, fatorial in enumerate(gerador_fatorial(5), 1):
print(f"{n}! = {fatorial}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 139
Exercício 08-21
Escreva uma função que gere os números como a função range do Python. Essa função
recebe três parâmetros e seu comportamento muda se passarmos um, dois ou três
parâmetros. Chame-a de faixa.
Exemplos:

list(faixa(1))
[0, 1]
list(faixa(1, 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list(faixa(0, 10, 2))
[0, 2, 4, 6, 8, 10]

Você deve ter percebido que, diferente de range, a função faixa considera o fim do intervalo
fechado, ou seja, o úl�mo número faz parte da faixa.

def faixa(inicio, fim=None, passo=1):

if fim is None:
inicio, fim = 0, inicio

atual = inicio
while atual <= fim: # Observe o <= para incluir o último valor
yield atual
atual += passo

# Casos de teste
print(list(faixa(1))) # [0, 1]
print(list(faixa(1, 10))) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(faixa(0, 10, 2))) # [0, 2, 4, 6, 8, 10]

Atualização do 23 de novembro de 2024 [Link]

140 Exercı́cios resolvidos — 4� ediçã o
Exercício 08-22
Modifique o programa da calculadora que usa par�al (Programa 8.28) para suportar mais
duas operações: raiz para raiz quadrada e potência para exponenciação.

import math
import operator
from functools import partial

def executa_unário(operação, símbolo, operando1):

resultado = operação(float(operando1))
print(f"{símbolo} {operando1} = {resultado}")

def executa(operação, símbolo, operando1, operando2):

resultado = operação(float(operando1), float(operando2))
print(f"{operando1} {símbolo} {operando2} = {resultado}")

operações = {
"+": partial(executa, [Link], "+"),
"-": partial(executa, [Link], "-"),
"*": partial(executa, [Link], "×"),
"/": partial(executa, [Link], "÷"),
"raiz": partial(executa_unário, [Link], "raiz quadrada de "),
"potência": partial(executa, [Link], "potência"),
}
operando1 = input("Operador 1: ")
operação = input("Operação: ").strip().lower()
if operação in operações:
if operação == "raiz": # Raiz tem apenas um operador
operações[operação](operando1)
else:
operando2 = input("Operador 2: ")
operações[operação](operando1, operando2)
else:
print("Operação inválida!")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 141
Exercício 08-99
Escreva um generator capaz de gerar a série de Fibonacci.

import random

print(" Bem-vindo ao Caça Alienígenas! ")

print("\nEscolha o nível de dificuldade:")
print("1 - Fácil ( 100 HP | Dano: 5-20)")
print("2 - Médio ( 80 HP | Dano: 10-25)")
print("3 - Difícil ( 75 HP | Dano: 20-30)")

while True:
nivel = input("\nDigite o número do nível (1-3): ")
if nivel in ["1", "2", "3"]:
break
print(" Opção inválida! Escolha 1, 2 ou 3.")

if nivel == "1":
vida_jogador = 100
dano_min, dano_max = 5, 20
elif nivel == "2":
vida_jogador = 80
dano_min, dano_max = 10, 25
else:
vida_jogador = 75
dano_min, dano_max = 20, 30

árvore = [Link](1, 100)

print("\n Um alienígena está escondido atrás de uma árvore!")
print(" Cada árvore foi numerada de 1 a 100.")
print(" Você tem que adivinhar em que árvore o alienígena se esconde.")
print(" Cuidado! O alienígena vai te atacar a cada tentativa errada!
\n")

while vida_jogador > 0:

print(f" Pontos de vida: {vida_jogador}")
palpite = int(input(" Escolha uma árvore [1-100]: "))
if palpite == árvore:
print("\n PARABÉNS! Você acertou! O alienígena foi encontrado!
")
break
elif palpite > árvore:
print(" Muito alto! Tente um número menor.")
else:
print(" Muito baixo! Tente um número maior.")
dano = [Link](dano_min, dano_max)
vida_jogador -= dano
print(f" O alienígena te atacou! Dano: {dano}\n")

if vida_jogador <= 0:

Atualização do 23 de novembro de 2024 [Link]

142 Exercı́cios resolvidos — 4� ediçã o
print("\n Game Over! Você não conseguiu sobreviver.")
print(f" O alienígena estava na árvore {árvore}.")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 143
Exercício 08-991
U�lizando a função type, escreva uma função recursiva que imprima os elementos de uma
lista. Cada elemento deve ser impresso separadamente, um por linha. Considere o caso de
listas dentro de listas, como L = [1, [2, 3, 4, [5, 6, 7]]]. A cada nível, imprima a lista mais à
direita, como fazemos ao indentar blocos em Python. Dica: envie o nível atual como
parâmetro e u�lize-o para calcular a quan�dade de espaços em branco à esquerda de cada
elemento.

import random

palavras = [
"casa",
"bola",
"mangueira",
"uva",
"quiabo",
"computador",
"cobra",
"lentilha",
"arroz",
]
# Escolhe uma palavra aleatoriamente
palavra = palavras[[Link](0, len(palavras) - 1)]

digitadas = []
acertos = []
erros = 0

linhas_txt = """
X==:==
X :
X
X
X
X
=======

"""

linhas = []

for linha in linhas_txt.splitlines():

[Link](list(linha))

while True:
senha = ""
for letra in palavra:
senha += letra if letra in acertos else "."
print(senha)
if senha == palavra:
Atualização do 23 de novembro de 2024 [Link]
144 Exercı́cios resolvidos — 4� ediçã o
print("Você acertou!")
break
tentativa = input("\nDigite uma letra:").lower().strip()
if tentativa in digitadas:
print("Você já tentou esta letra!")
continue
else:
digitadas += tentativa
if tentativa in palavra:
acertos += tentativa
else:
erros += 1
print("Você errou!")
if erros == 1:
linhas[3][3] = "O"
elif erros == 2:
linhas[4][3] = "|"
elif erros == 3:
linhas[4][2] = "\\"
elif erros == 4:
linhas[4][4] = "/"
elif erros == 5:
linhas[5][2] = "/"
elif erros == 6:
linhas[5][4] = "\\"

for l in linhas:
print("".join(l))
if erros == 6:
print("Enforcado!")
print(f"A palavra secreta era: {palavra}")
break

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 145
Exercício 09-01
Escreva um programa que receba o nome de um arquivo pela linha de comando e que
imprima todas as linhas desse arquivo.

import sys

# Verifica se o parâmetro foi passado

if len([Link]) != 2: # Lembre-se que o nome do programa é o primeiro da
lista
print("\nUso: [Link] nome_do_arquivo\n\n")
else:
nome = [Link][1]
arquivo = open(nome, "r")
for linha in [Link]():
# Como a linha termina com ENTER,
# retiramos o último caractere antes de imprimir
print(linha[:-1])
[Link]()

# Não esqueça de ler sobre encodings

# Dependendo do tipo de arquivo e de seu sistema operacional,
# ele pode não imprimir corretamente na tela.

Atualização do 23 de novembro de 2024 [Link]

146 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-02
Modifique o programa do Exercício 9.1 para que receba mais dois parâmetros: a linha de
início e a de fim para impressão. O programa deve imprimir apenas as linhas entre esses dois
valores (incluindo as linhas de início e fim).

import sys

# Verifica se os parâmetros foram passados

if len([Link]) != 4: # Lembre-se que o nome do programa é o primeiro da
lista
print("\nUso: [Link] nome_do_arquivo inicio fim\n\n")
else:
nome = [Link][1]
inicio = int([Link][2])
fim = int([Link][3])
arquivo = open(nome, "r")
for linha in [Link]()[inicio - 1 : fim]:
# Como a linha termina com ENTER,
# retiramos o último caractere antes de imprimir
print(linha[:-1])
[Link]()

# Não esqueça de ler sobre encodings

# Dependendo do tipo de arquivo e de seu sistema operacional,
# ele pode não imprimir corretamente na tela.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 147
Exercício 09-03
Crie um programa que leia os arquivos [Link] e í[Link] e que crie um só arquivo
[Link] com todas as linhas dos outros dois arquivos, de forma a preservar a
ordem numérica.

# Assume que pares e ímpares contém apenas números inteiros

# Assume que os valores em cada arquivo estão ordenados
# Os valores não precisam ser sequenciais
# Tolera linhas em branco
# Pares e ímpares podem ter número de linhas diferentes

def lê_número(arquivo):
while True:
número = [Link]()
# Verifica se conseguiu ler algo
if número == "":
return None
# Ignora linhas em branco
if nú[Link]() != "":
return int(número)

def escreve_número(arquivo, n):

[Link](f"{n}\n")

pares = open("[Link]", "r")

ímpares = open("í[Link]", "r")
pares_ímpares = open("[Link]", "w")
npar = lê_número(pares)
nímpar = lê_número(ímpares)
while True:
if npar is None and nímpar is None: # Termina se ambos forem None
break
if npar is not None and (nímpar is None or npar <= nímpar):
escreve_número(pares_ímpares, npar)
npar = lê_número(pares)
if nímpar is not None and (npar is None or nímpar <= npar):
escreve_número(pares_ímpares, nímpar)
nímpar = lê_número(ímpares)

pares_í[Link]()
[Link]()
í[Link]()

Atualização do 23 de novembro de 2024 [Link]

148 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-04
Crie um programa que receba o nome de dois arquivos como parâmetros da linha de
comando e que gere um arquivo de saída com as linhas do primeiro e do segundo arquivo. O
nome do arquivo de saída também pode ser passado como parâmetro na linha de
comandos.

import sys

# Verifica se os parâmetros foram passados

if len([Link]) != 4: # Lembre-se que o nome do programa é o primeiro da
lista
print("\nUso: [Link] primeiro segundo saída\n\n")
else:
primeiro = open([Link][1], "r")
segundo = open([Link][2], "r")
saída = open([Link][3], "w")

# Funciona de forma similar ao readlines

for l1 in primeiro:
saí[Link](l1)
for l2 in segundo:
saí[Link](l2)

[Link]()
[Link]()
saí[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 149
Exercício 09-05
Crie um programa que inverta a ordem das linhas do arquivo [Link]. A primeira linha deve
conter o maior número; e a úl�ma, o menor.

pares = open("[Link]", "r")

saída = open("pares_invertido.txt", "w")

L = [Link]()
[Link]()
for l in L:
saí[Link](l)

[Link]()
saí[Link]()

# Observe que lemos todas as linhas antes de fazer a inversão

# Esta abordagem não funciona com arquivos grandes
# Alternativa usando with:
#
##with open("[Link]","r") as pares, open("pares_invertido.txt","w") as
saída:
## L = [Link]()
## [Link]()
## for l in L:
## saí[Link](l)

Atualização do 23 de novembro de 2024 [Link]

150 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-06
Modifique o Programa 9.5 para imprimir 40 vezes o símbolo de = se este for o primeiro
caractere da linha. Adicione também a opção para parar de imprimir até que se pressione a
tecla Enter cada vez que uma linha iniciar com . (ponto) como primeiro caractere.

LARGURA = 79
entrada = open("[Link]")
for linha in [Link]():
if linha[0] == ";":
continue
elif linha[0] == ">":
print(linha[1:].rjust(LARGURA))
elif linha[0] == "*":
print(linha[1:].center(LARGURA))
elif linha[0] == "=":
print("=" * 40)
elif linha[0] == ".":
input("Digite algo para continuar")
print()
else:
print(linha)
[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 151
Exercício 09-07
Crie um programa que leia um arquivo-texto e gere um arquivo de saída paginado. Cada
linha não deve conter mais de 76 caracteres. Cada página terá no máximo 60 linhas. Adicione
na úl�ma linha de cada página o número da página atual e o nome do arquivo original.

# Uma boa fonte de textos para teste é o projeto Gutemberg

# [Link]
# Não esqueça de configurar o encoding do arquivo.
#
# Este programa foi testado com Moby Dick
# [Link]
# Gravado com o nome de [Link]
#
LARGURA = 76
LINHAS = 60
NOME_DO_ARQUIVO = "[Link]"

def verifica_pagina(arquivo, linha, pagina):

if linha == LINHAS:
rodapé = f"= {NOME_DO_ARQUIVO} - Página: {pagina} ="
[Link](rodapé.center(LARGURA - 1) + "\n")
pagina += 1
linha = 1
return linha, pagina

def escreve(arquivo, linha, nlinhas, pagina):

[Link](linha + "\n")
return verifica_pagina(arquivo, nlinhas + 1, pagina)

entrada = open(NOME_DO_ARQUIVO, encoding="utf-8")

saída = open("saida_paginada.txt", "w", encoding="utf-8")

pagina = 1
linhas = 1

for linha in [Link]():

palavras = [Link]().split(" ")
linha = ""
for p in palavras:
p = [Link]()
if len(linha) + len(p) + 1 > LARGURA:
linhas, pagina = escreve(saída, linha, linhas, pagina)
linha = ""
linha += p + " "
if linha != "":
linhas, pagina = escreve(saída, linha, linhas, pagina)

Atualização do 23 de novembro de 2024 [Link]

152 Exercı́cios resolvidos — 4� ediçã o
# Para imprimir o número na última página
while linhas != 1:
linhas, pagina = escreve(saída, "", linhas, pagina)

[Link]()
saí[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 153
Exercício 09-08
Modifique o programa do Exercício 9.7 para também receber o número de caracteres por
linha e o número de linhas por página pela linha de comando.

import sys

def verifica_pagina(arquivo, linha, pagina):

if linha == LINHAS:
rodapé = f"= {NOME_DO_ARQUIVO} - Página: {pagina} ="
[Link](rodapé.center(LARGURA - 1) + "\n")
pagina += 1
linha = 1
return linha, pagina

def escreve(arquivo, linha, nlinhas, pagina):

[Link](linha + "\n")
return verifica_pagina(arquivo, nlinhas + 1, pagina)

if len([Link]) != 4:
print("\nUso: [Link] arquivo largura linhas\n\n")
[Link](1)

NOME_DO_ARQUIVO = [Link][1]
LARGURA = int([Link][2])
LINHAS = int([Link][3])

entrada = open(NOME_DO_ARQUIVO, encoding="utf-8")

saída = open("saida_paginada.txt", "w", encoding="utf-8")

pagina = 1
linhas = 1

for linha in [Link]():

palavras = [Link]().split(" ")
linha = ""
for p in palavras:
p = [Link]()
if len(linha) + len(p) + 1 > LARGURA:
linhas, pagina = escreve(saída, linha, linhas, pagina)
linha = ""
linha += p + " "
if linha != "":
linhas, pagina = escreve(saída, linha, linhas, pagina)

# Para imprimir o número na última página

while linhas != 1:
linhas, pagina = escreve(saída, "", linhas, pagina)
Atualização do 23 de novembro de 2024 [Link]
154 Exercı́cios resolvidos — 4� ediçã o

[Link]()
saí[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 155
Exercício 09-09
Crie um programa que receba uma lista de nomes de arquivo e os imprima, um por um.

import sys

if len([Link]) < 2:
print("\nUso: [Link] arquivo1 [arquivo2 arquivo3 arquivoN]\n\n\n")
[Link](1)

for nome in [Link][1:]:

arquivo = open(nome, "r")
for linha in arquivo:
print(linha, end="")
[Link]()

Atualização do 23 de novembro de 2024 [Link]

156 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-10
Crie um programa que receba uma lista de nomes de arquivo e que gere apenas um grande
arquivo de saída.

import sys

if len([Link]) < 2:
print("\nUso: [Link] arquivo1 [arquivo2 arquivo3 arquivoN]\n\n\n")
[Link](1)

saída = open("saida_unica.txt", "w", encoding="utf-8")

for nome in [Link][1:]:
arquivo = open(nome, "r", encoding="utf-8")
for linha in arquivo:
saí[Link](linha)
[Link]()
saí[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 157
Exercício 09-11
Crie um programa que leia um arquivo e crie um dicionário em que cada chave é uma
palavra e cada valor é o número de ocorrências no arquivo.

# Atenção ao encoding no Windows

import sys

if len([Link]) != 2:
print("\nUso: [Link] arquivo1\n\n\n")
[Link](1)

nome = [Link][1]
contador = {}

arquivo = open(nome, "r", encoding="utf-8")

for linha in arquivo:
linha = [Link]().lower()
palavras = [Link]()
for p in palavras:
if p in contador:
contador[p] += 1
else:
contador[p] = 1
[Link]()

for chave in contador:

print(f"{chave} = {contador[chave]}")

Atualização do 23 de novembro de 2024 [Link]

158 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-12
Modifique o programa do Exercício 9.11 para também registrar a linha e a coluna de cada
ocorrência da palavra no arquivo. Para isso, u�lize listas nos valores de cada palavra,
guardando a linha e a coluna de cada ocorrência.

# Atenção ao encoding no Windows

# A contagem de colunas não é tão precisa

import sys

if len([Link]) != 2:
print("\nUso: [Link] arquivo1\n\n\n")
[Link](1)

nome = [Link][1]
contador = {}
clinha = 1
coluna = 1

arquivo = open(nome, "r", encoding="utf-8")

for linha in arquivo:
linha = [Link]().lower()
palavras = [Link](" ") # Com parâmetro considera os espaços
repetidos
for p in palavras:
if p == "":
coluna += 1
continue
if p in contador:
contador[p].append((clinha, coluna))
else:
contador[p] = [(clinha, coluna)]
coluna += len(p) + 1
clinha += 1
coluna = 1
[Link]()

for chave in contador:

print(f"{chave} = {contador[chave]}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 159
Exercício 09-13
Crie um programa que imprima as linhas de um arquivo. Esse programa deve receber três
parâmetros pela linha de comando: o nome do arquivo, a linha inicial e a úl�ma linha a
imprimir

# Idêntico ao exercício 9.02

import sys

# Verifica se os parâmetros foram passados

if len([Link]) != 4: # Lembre-se que o nome do programa é o primeiro da
lista
print("\nUso: [Link] nome_do_arquivo inicio fim\n\n")
else:
nome = [Link][1]
inicio = int([Link][2])
fim = int([Link][3])
arquivo = open(nome, "r")
for linha in [Link]()[inicio - 1 : fim]:
# Como a linha termina com ENTER,
# retiramos o último caractere antes de imprimir
print(linha[:-1])
[Link]()

# Não esqueça de ler sobre encodings

# Dependendo do tipo de arquivo e de seu sistema operacional,
# ele pode não imprimir corretamente na tela.

Atualização do 23 de novembro de 2024 [Link]

160 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-14
Crie um programa que leia um arquivo-texto e elimine os espaços repe�dos entre as palavras
e no fim das linhas. O arquivo de saída também não deve ter mais de uma linha em branco
repe�da.

# Atenção ao encoding no Windows

import sys

if len([Link]) != 3:
print("\nUso: [Link] entrada saida\n\n\n")
[Link](1)

entrada = [Link][1]
saida = [Link][2]

arquivo = open(entrada, "r", encoding="utf-8")

arq_saida = open(saida, "w", encoding="utf-8")
branco = 0

for linha in arquivo:

# Elimina espaços a direita
# Substitua por strip se também
# quiser eliminar espaços a esquerda
linha = [Link]()
linha = [Link](" ", "") # Elimina espaços repetidos
if linha == "":
branco += 1 # Conta linhas em branco
else:
branco = 0 # Se a linha não está em branco, zera o contador
if branco < 2: # Não escreve a partir da segunda linha em branco
arq_saida.write(linha + "\n")

[Link]()
arq_saida.close()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 161
Exercício 09-15
Altere o Programa 7.2, o jogo da forca. U�lize um arquivo em que uma palavra seja gravada a
cada linha. Use um editor de textos para gerar o arquivo. Ao iniciar o programa, u�lize esse
arquivo para carregar (ler) a lista de palavras. Experimente também perguntar o nome do
jogador e gerar um arquivo com o número de acertos dos cinco melhores.

# Modificado para ler a lista de palavras de um arquivo

# Lê um arquivo [Link] com o número de acertos por jogador
# Lê um arquivo [Link] com a lista de palavras
#
# Antes de executar:
#
# Crie um arquivo vazio com o nome [Link]
# Crie um arquivo de palavras com nome [Link]
# contendo uma palavra por linha.
#
# O jogo escolhe aleatoriamente uma palavra deste arquivo
import sys
import random

palavras = []
placar = {}

def carrega_palavras():
arquivo = open("[Link]", "r", encoding="utf-8")
for palavra in [Link]():
palavra = [Link]().lower()
if palavra != "":
[Link](palavra)
[Link]()

def carrega_placar():
arquivo = open("[Link]", "r", encoding="utf-8")
for linha in [Link]():
linha = [Link]()
if linha != "":
usuario, contador = [Link](";")
placar[usuario] = int(contador)
[Link]()

def salva_placar():
arquivo = open("[Link]", "w", encoding="utf-8")
for usuario in [Link]():
[Link]("{usuario};{placar[usuario]}\n")
[Link]()

Atualização do 23 de novembro de 2024 [Link]

162 Exercı́cios resolvidos — 4� ediçã o
def atualize_placar(nome):
if nome in placar:
placar[nome] += 1
else:
placar[nome] = 1
salva_placar()

def exibe_placar():
placar_ordenado = []
for usuario, score in [Link]():
placar_ordenado.append([usuario, score])
placar_ordenado.sort(key=lambda score: score[1])
print("\n\nMelhores jogadores por número de acertos:")
placar_ordenado.reverse()
for up in placar_ordenado:
print(f"{up[0]:30s} {up[1]:10d}")

carrega_palavras()
carrega_placar()

palavra = palavras[[Link](0, len(palavras) - 1)]

digitadas = []
acertos = []
erros = 0
while True:
senha = ""
for letra in palavra:
senha += letra if letra in acertos else "."
print(senha)
if senha == palavra:
print("Você acertou!")
nome = input("Digite seu nome: ")
atualize_placar(nome)
break
tentativa = input("\nDigite uma letra:").lower().strip()
if tentativa in digitadas:
print("Você já tentou esta letra!")
continue
else:
digitadas += tentativa
if tentativa in palavra:
acertos += tentativa
else:
erros += 1
print("Você errou!")
print("X==:==\nX : ")
print("X O " if erros >= 1 else "X")
linha2 = ""
if erros == 2:

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 163
linha2 = " | "
elif erros == 3:
linha2 = r" \| "
elif erros >= 4:
linha2 = r" \|/ "
print(f"X{linha2}")
linha3 = ""
if erros == 5:
linha3 += r" / "
elif erros >= 6:
linha3 += r" / \ "
print(f"X{linha3}")
print("X\n===========")
if erros == 6:
print("Enforcado!")
break

exibe_placar()

Atualização do 23 de novembro de 2024 [Link]

164 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-16
Explique como os campos nome e telefone são armazenados no arquivo de saída.

# Cada registro da agenda é gravado em uma linha do arquivo.

# Os campos são separados pelo símbolo # (Cerquilha)
# por exemplo:
# Duas entradas, Nilo e João são gravadas em 2 linhas de texto.
# O nome da entrada fica a esquerda do # e o número de telefone a direita
#
# Nilo#1234
# João#5678

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 165
Exercício 09-17
Altere o Programa 9.6 para exibir o tamanho da agenda no menu principal.

agenda = []

def pede_nome():
return input("Nome: ")

def pede_telefone():
return input("Telefone: ")

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])

def apaga():
global agenda
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
del agenda[p]
else:
print("Nome não encontrado.")

def altera():
p = pesquisa(pede_nome())

Atualização do 23 de novembro de 2024 [Link]

166 Exercı́cios resolvidos — 4� ediçã o
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome()
telefone = pede_telefone()
agenda[p] = [nome, telefone]
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
for e in agenda:
mostra_dados(e[0], e[1])
print("\------\n")

def lê():
global agenda
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()

def grava():
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 167
3 - Apaga
4 - Lista
5 - Grava
6 - Lê

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 6)

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()

Atualização do 23 de novembro de 2024 [Link]

168 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-18
O que acontece se nome ou telefone con�verem o caractere usado como separador em seus
conteúdos? Explique o problema e proponha uma solução.

# Se o # aparecer no nome ou telefone de uma entrada na agenda,

# ocorrerá um erro ao ler o arquivo.
# Este erro ocorre pois o número de campos esperados na linha será
diferente
# de 2 (nome e telefone).
# O programa não tem como saber que o caracter faz parte de um campo ou de
outro.
# Uma solução para este problema é substituir o # dentro de um campo antes
de salvá-lo.
# Desta forma, o separador de campos no arquivo não seria confundido com o
conteúdo.
# Durante a leitura a substituição tem que ser revertida, de forma a obter
o mesmo conteúdo.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 169
Exercício 09-19
Altere a função lista para que exiba também a posição de cada elemento.

agenda = []

def pede_nome():
return input("Nome: ")

def pede_telefone():
return input("Telefone: ")

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])

def apaga():
global agenda
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
del agenda[p]
else:
print("Nome não encontrado.")

def altera():
p = pesquisa(pede_nome())

Atualização do 23 de novembro de 2024 [Link]

170 Exercı́cios resolvidos — 4� ediçã o
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome()
telefone = pede_telefone()
agenda[p] = [nome, telefone]
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição, sem saltar linha
print(f"Posição: {posição}", end="")
mostra_dados(e[0], e[1])
print("\------\n")

def lê():
global agenda
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()

def grava():
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 171
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 6)

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()

Atualização do 23 de novembro de 2024 [Link]

172 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-20
Adicione a opção de ordenar a lista por nome no menu principal.

agenda = []

def pede_nome():
return input("Nome: ")

def pede_telefone():
return input("Telefone: ")

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])

def apaga():
global agenda
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
del agenda[p]
else:
print("Nome não encontrado.")

def altera():
p = pesquisa(pede_nome())

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 173
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome()
telefone = pede_telefone()
agenda[p] = [nome, telefone]
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição, sem saltar linha
print(f"Posição: {posição} ", end="")
mostra_dados(e[0], e[1])
print("\------\n")

def lê():
global agenda
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()

def ordena():
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista
# [Link](key=lambda e: return e[0])
fim = len(agenda)
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:

Atualização do 23 de novembro de 2024 [Link]

174 Exercı́cios resolvidos — 4� ediçã o
break

def grava():
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê
7 - Ordena por nome

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 175
lê()
elif opção == 7:
ordena()

Atualização do 23 de novembro de 2024 [Link]

176 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-21
Nas funções de altera e apaga, peça que o usuário confirme a alteração e exclusão do nome
antes de realizar a operação em si.

agenda = []

def pede_nome():
return input("Nome: ")

def pede_telefone():
return input("Telefone: ")

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])

def confirma(operação):
while True:
opção = input(f"Confirma {operação} (S/N)? ").upper()
if opção in "SN":
return opção
else:
print("Resposta inválida. Escolha S ou N.")

def apaga():
global agenda

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 177
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
if confirma("apagamento") == "S":
del agenda[p]
else:
print("Nome não encontrado.")

def altera():
p = pesquisa(pede_nome())
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome()
telefone = pede_telefone()
if confirma("alteração") == "S":
agenda[p] = [nome, telefone]
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição, sem saltar linha
print(f"Posição: {posição} ", end="")
mostra_dados(e[0], e[1])
print("\------\n")

def lê():
global agenda
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()

def ordena():
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista
# [Link](key=lambda e: return e[0])
fim = len(agenda)

Atualização do 23 de novembro de 2024 [Link]

178 Exercı́cios resolvidos — 4� ediçã o
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:
break

def grava():
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê
7 - Ordena por nome

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

while True:
opção = menu()
if opção == 0:

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 179
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()
elif opção == 7:
ordena()

Atualização do 23 de novembro de 2024 [Link]

180 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-22
Ao ler ou gravar uma nova lista, verifique se a agenda atual já foi gravada. Você pode usar
uma variável para controlar quando a lista foi alterada (novo, altera, apaga) e reinicializar
esse valor quando ela for lida ou gravada.

agenda = []

# Variável para marcar uma alteração na agenda

alterada = False

def pede_nome():
return input("Nome: ")

def pede_telefone():
return input("Telefone: ")

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda, alterada
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])
alterada = True

def confirma(operação):
while True:
opção = input(f"Confirma {operação} (S/N)? ").upper()
if opção in "SN":
return opção
else:

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 181
print("Resposta inválida. Escolha S ou N.")

def apaga():
global agenda, alterada
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
if confirma("apagamento") == "S":
del agenda[p]
alterada = True
else:
print("Nome não encontrado.")

def altera():
global alterada
p = pesquisa(pede_nome())
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome()
telefone = pede_telefone()
if confirma("alteração") == "S":
agenda[p] = [nome, telefone]
alterada = True
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição, sem saltar linha
print(f"Posição: {posição} ", end="")
mostra_dados(e[0], e[1])
print("\------\n")

def lê():
global agenda, alterada
if alterada:
print(
"Você não salvou a lista desde a última alteração. Deseja
gravá-la agora?"
)
if confirma("gravação") == "S":
grava()
print("Ler\n---")

Atualização do 23 de novembro de 2024 [Link]

182 Exercı́cios resolvidos — 4� ediçã o
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()
alterada = False

def ordena():
global alterada
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista
# [Link](key=lambda e: return e[0])
fim = len(agenda)
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:
break
alterada = True

def grava():
global alterada
if not alterada:
print("Você não alterou a lista. Deseja gravá-la mesmo assim?")
if confirma("gravação") == "N":
return
print("Gravar\n\------")
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()
alterada = False

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 183
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê
7 - Ordena por nome

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)} Alterada: {alterada}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()
elif opção == 7:
ordena()

Atualização do 23 de novembro de 2024 [Link]

184 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-23
Altere o programa para ler a úl�ma agenda lida ou gravada ao inicializar. Dica: u�lize outro
arquivo para armazenar o nome.

agenda = []

# Variável para marcar uma alteração na agenda

alterada = False

def pede_nome():
return input("Nome: ")

def pede_telefone():
return input("Telefone: ")

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda, alterada
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])
alterada = True

def confirma(operação):
while True:
opção = input(f"Confirma {operação} (S/N)? ").upper()
if opção in "SN":
return opção
else:
print("Resposta inválida. Escolha S ou N.")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 185

def apaga():
global agenda, alterada
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
if confirma("apagamento") == "S":
del agenda[p]
alterada = True
else:
print("Nome não encontrado.")

def altera():
global alterada
p = pesquisa(pede_nome())
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome()
telefone = pede_telefone()
if confirma("alteração") == "S":
agenda[p] = [nome, telefone]
alterada = True
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição, sem saltar linha
print(f"Posição: {posição} ", end="")
mostra_dados(e[0], e[1])
print("\------\n")

def lê_última_agenda_gravada():
última = última_agenda()
if última is not None:
leia_arquivo(última)

def última_agenda():
try:
arquivo = open("ultima [Link]", "r", encoding="utf-8")
última = [Link]()[:-1]
[Link]()

Atualização do 23 de novembro de 2024 [Link]

186 Exercı́cios resolvidos — 4� ediçã o
except FileNotFoundError:
return None
return última

def atualiza_última(nome):
arquivo = open("ultima [Link]", "w", encoding="utf-8")
[Link](f"{nome}\n")
[Link]()

def leia_arquivo(nome_arquivo):
global agenda, alterada
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()
alterada = False

def lê():
global alterada
if alterada:
print(
"Você não salvou a lista desde a última alteração. Deseja
gravá-la agora?"
)
if confirma("gravação") == "S":
grava()
print("Ler\n---")
nome_arquivo = pede_nome_arquivo()
leia_arquivo(nome_arquivo)
atualiza_última(nome_arquivo)

def ordena():
global alterada
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista
# [Link](key=lambda e: return e[0])
fim = len(agenda)
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 187
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:
break
alterada = True

def grava():
global alterada
if not alterada:
print("Você não alterou a lista. Deseja gravá-la mesmo assim?")
if confirma("gravação") == "N":
return
print("Gravar\n\------")
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()
atualiza_última(nome_arquivo)
alterada = False

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê
7 - Ordena por nome

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)} Alterada: {alterada}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

lê_última_agenda_gravada()

Atualização do 23 de novembro de 2024 [Link]

188 Exercı́cios resolvidos — 4� ediçã o

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()
elif opção == 7:
ordena()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 189
Exercício 09-24
O que acontece com a agenda se ocorrer um erro de leitura ou gravação? Explique.

# Em caso de erro de leitura, o programa pára de executar.

# Se o erro ocorrer durante a gravação, os dados não gravados
# serão perdidos.
# Estes problemas podem ser resolvidos com a alteração das
# funções de leitura e gravação, adicionando-se blocos try/except
# O ideal é que o programa exiba a mensagem de erro e continue rodando.
# No caso da gravação, os dados não devem ser perdidos e o usuário deve
poder
# tentar novamente.

Atualização do 23 de novembro de 2024 [Link]

190 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-25
Altere as funções pede\_nome e pede\_telefone de forma a receberem um parâmetro
opcional. Caso esse parâmetro seja passado, u�lize-o como retorno caso a entrada de dados
seja vazia.

agenda = []

# Variável para marcar uma alteração na agenda

alterada = False

def pede_nome(padrão=""):
nome = input("Nome: ")
if nome == "":
nome = padrão
return nome

def pede_telefone(padrão=""):
telefone = input("Telefone: ")
if telefone == "":
telefone = padrão
return telefone

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda, alterada
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])
alterada = True

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 191
def confirma(operação):
while True:
opção = input(f"Confirma {operação} (S/N)? ").upper()
if opção in "SN":
return opção
else:
print("Resposta inválida. Escolha S ou N.")

def apaga():
global agenda, alterada
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
if confirma("apagamento") == "S":
del agenda[p]
alterada = True
else:
print("Nome não encontrado.")

def altera():
global alterada
p = pesquisa(pede_nome())
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome(nome) # Se nada for digitado, mantém o valor
telefone = pede_telefone(telefone)
if confirma("alteração") == "S":
agenda[p] = [nome, telefone]
alterada = True
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição, sem saltar linha
print(f"Posição: {posição} ", end="")
mostra_dados(e[0], e[1])
print("\------\n")

def lê_última_agenda_gravada():
última = última_agenda()
if última is not None:
leia_arquivo(última)

Atualização do 23 de novembro de 2024 [Link]

192 Exercı́cios resolvidos — 4� ediçã o

def última_agenda():
try:
arquivo = open("ultima [Link]", "r", encoding="utf-8")
última = [Link]()[:-1]
[Link]()
except FileNotFoundError:
return None
return última

def atualiza_última(nome):
arquivo = open("ultima [Link]", "w", encoding="utf-8")
[Link](f"{nome}\n")
[Link]()

def leia_arquivo(nome_arquivo):
global agenda, alterada
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()
alterada = False

def lê():
global alterada
if alterada:
print(
"Você não salvou a lista desde a última alteração. Deseja
gravá-la agora?"
)
if confirma("gravação") == "S":
grava()
print("Ler\n---")
nome_arquivo = pede_nome_arquivo()
leia_arquivo(nome_arquivo)
atualiza_última(nome_arquivo)

def ordena():
global alterada
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista
# [Link](key=lambda e: return e[0])
fim = len(agenda)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 193
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:
break
alterada = True

def grava():
global alterada
if not alterada:
print("Você não alterou a lista. Deseja gravá-la mesmo assim?")
if confirma("gravação") == "N":
return
print("Gravar\n\------")
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()
atualiza_última(nome_arquivo)
alterada = False

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê
7 - Ordena por nome

Atualização do 23 de novembro de 2024 [Link]

194 Exercı́cios resolvidos — 4� ediçã o
0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)} Alterada: {alterada}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

lê_última_agenda_gravada()

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()
elif opção == 7:
ordena()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 195
Exercício 09-26
Altere o programa de forma a verificar a repe�ção de nomes. Gere uma mensagem de erro
caso duas entradas na agenda tenham o mesmo nome

agenda = []

# Variável para marcar uma alteração na agenda

alterada = False

def pede_nome(padrão=""):
nome = input("Nome: ")
if nome == "":
nome = padrão
return nome

def pede_telefone(padrão=""):
telefone = input("Telefone: ")
if telefone == "":
telefone = padrão
return telefone

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda, alterada
nome = pede_nome()
if pesquisa(nome) is not None:
print("Nome já existe!")
return
telefone = pede_telefone()
[Link]([nome, telefone])
alterada = True

Atualização do 23 de novembro de 2024 [Link]

196 Exercı́cios resolvidos — 4� ediçã o

def confirma(operação):
while True:
opção = input(f"Confirma {operação} (S/N)? ").upper()
if opção in "SN":
return opção
else:
print("Resposta inválida. Escolha S ou N.")

def apaga():
global agenda, alterada
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
if confirma("apagamento") == "S":
del agenda[p]
alterada = True
else:
print("Nome não encontrado.")

def altera():
global alterada
p = pesquisa(pede_nome())
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome(nome) # Se nada for digitado, mantém o valor
telefone = pede_telefone(telefone)
if confirma("alteração") == "S":
agenda[p] = [nome, telefone]
alterada = True
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição, sem saltar linha
print(f"Posição: {posição} ", end="")
mostra_dados(e[0], e[1])
print("\------\n")

def lê_última_agenda_gravada():
última = última_agenda()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 197
if última is not None:
leia_arquivo(última)

def última_agenda():
try:
arquivo = open("ultima [Link]", "r", encoding="utf-8")
última = [Link]()[:-1]
[Link]()
except FileNotFoundError:
return None
return última

def atualiza_última(nome):
arquivo = open("ultima [Link]", "w", encoding="utf-8")
[Link](f"{nome}\n")
[Link]()

def leia_arquivo(nome_arquivo):
global agenda, alterada
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone = [Link]().split("#")
[Link]([nome, telefone])
[Link]()
alterada = False

def lê():
global alterada
if alterada:
print(
"Você não salvou a lista desde a última alteração. Deseja
gravá-la agora?"
)
if confirma("gravação") == "S":
grava()
print("Ler\n---")
nome_arquivo = pede_nome_arquivo()
leia_arquivo(nome_arquivo)
atualiza_última(nome_arquivo)

def ordena():
global alterada
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista

Atualização do 23 de novembro de 2024 [Link]

198 Exercı́cios resolvidos — 4� ediçã o
# [Link](key=lambda e: return e[0])
fim = len(agenda)
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:
break
alterada = True

def grava():
global alterada
if not alterada:
print("Você não alterou a lista. Deseja gravá-la mesmo assim?")
if confirma("gravação") == "N":
return
print("Gravar\n\------")
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}\n")
[Link]()
atualiza_última(nome_arquivo)
alterada = False

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 199
7 - Ordena por nome

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)} Alterada: {alterada}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

lê_última_agenda_gravada()

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()
elif opção == 7:
ordena()

Atualização do 23 de novembro de 2024 [Link]

200 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-27
Modifique o programa para também controlar a data de aniversário e o email de cada
pessoa.

agenda = []

# Variável para marcar uma alteração na agenda

alterada = False

def pede_nome(padrão=""):
nome = input("Nome: ")
if nome == "":
nome = padrão
return nome

def pede_telefone(padrão=""):
telefone = input("Telefone: ")
if telefone == "":
telefone = padrão
return telefone

def pede_email(padrão=""):
email = input("Email: ")
if email == "":
email = padrão
return email

def pede_aniversário(padrão=""):
aniversário = input("Data de aniversário: ")
if aniversário == "":
aniversário = padrão
return aniversário

def mostra_dados(nome, telefone, email, aniversário):

print(
f"Nome: {nome}\nTelefone: {telefone}\n"
f"Email: {email}\nAniversário: {aniversário}\n"
)

def pede_nome_arquivo():
return input("Nome do arquivo: ")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 201
def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda, alterada
nome = pede_nome()
if pesquisa(nome) is not None:
print("Nome já existe!")
return
telefone = pede_telefone()
email = pede_email()
aniversário = pede_aniversário()
[Link]([nome, telefone, email, aniversário])
alterada = True

def confirma(operação):
while True:
opção = input(f"Confirma {operação} (S/N)? ").upper()
if opção in "SN":
return opção
else:
print("Resposta inválida. Escolha S ou N.")

def apaga():
global agenda, alterada
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
if confirma("apagamento") == "S":
del agenda[p]
alterada = True
else:
print("Nome não encontrado.")

def altera():
global alterada
p = pesquisa(pede_nome())
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
email = agenda[p][2]
aniversário = agenda[p][3]
print("Encontrado:")
mostra_dados(nome, telefone, email, aniversário)

Atualização do 23 de novembro de 2024 [Link]

202 Exercı́cios resolvidos — 4� ediçã o
nome = pede_nome(nome) # Se nada for digitado, mantém o valor
telefone = pede_telefone(telefone)
email = pede_email(email)
aniversário = pede_aniversário(aniversário)
if confirma("alteração") == "S":
agenda[p] = [nome, telefone, email, aniversário]
alterada = True
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição
print(f"\nPosição: {posição}")
mostra_dados(e[0], e[1], e[2], e[3])
print("\------\n")

def lê_última_agenda_gravada():
última = última_agenda()
if última is not None:
leia_arquivo(última)

def última_agenda():
try:
arquivo = open("ultima [Link]", "r", encoding="utf-8")
última = [Link]()[:-1]
[Link]()
except FileNotFoundError:
return None
return última

def atualiza_última(nome):
arquivo = open("ultima [Link]", "w", encoding="utf-8")
[Link](f"{nome}\n")
[Link]()

def leia_arquivo(nome_arquivo):
global agenda, alterada
arquivo = open(nome_arquivo, "r", encoding="utf-8")
agenda = []
for l in [Link]():
nome, telefone, email, aniversário = [Link]().split("#")
[Link]([nome, telefone, email, aniversário])
[Link]()
alterada = False
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 203

def lê():
global alterada
if alterada:
print(
"Você não salvou a lista desde a última alteração. Deseja
gravá-la agora?"
)
if confirma("gravação") == "S":
grava()
print("Ler\n---")
nome_arquivo = pede_nome_arquivo()
leia_arquivo(nome_arquivo)
atualiza_última(nome_arquivo)

def ordena():
global alterada
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista
# [Link](key=lambda e: return e[0])
fim = len(agenda)
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:
break
alterada = True

def grava():
global alterada
if not alterada:
print("Você não alterou a lista. Deseja gravá-la mesmo assim?")
if confirma("gravação") == "N":
return
print("Gravar\n\------")
nome_arquivo = pede_nome_arquivo()
arquivo = open(nome_arquivo, "w", encoding="utf-8")
for e in agenda:
[Link](f"{e[0]}#{e[1]}#{e[2]}#{e[3]}\n")

Atualização do 23 de novembro de 2024 [Link]

204 Exercı́cios resolvidos — 4� ediçã o
[Link]()
atualiza_última(nome_arquivo)
alterada = False

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print("Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê
7 - Ordena por nome

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)} Alterada: {alterada}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

lê_última_agenda_gravada()

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()
elif opção == 7:
ordena()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 205
Exercício 09-28
Modifique o programa de forma a poder registrar vários telefones para a mesma pessoa.
Permita também cadastrar o �po de telefone: celular, fixo, residência ou trabalho.

# Como o formato do arquivo se torna cada vez mais complicado,

# vamos usar o módulo pickle do Python para gravar e ler a agenda.
#
# Desafio extra:
# Modifique o programa para exibir um submenu de gerência de telefones.
# Este sub menu seria exibido na hora de adicionar e alterar telefones.
# Operações: adicionar novo telefone, apagar telefone, alterar telefone
import pickle

agenda = []

# Variável para marcar uma alteração na agenda

alterada = False

tipos_de_telefone = ["celular", "fixo", "residência", "trabalho", "fax"]

def pede_nome(padrão=""):
nome = input("Nome: ")
if nome == "":
nome = padrão
return nome

def pede_telefone(padrão=""):
telefone = input("Telefone: ")
if telefone == "":
telefone = padrão
return telefone

def pede_tipo_telefone(padrão=""):
while True:
tipo = input("Tipo de telefone [%s]: " % ",".join(tipos_de_
telefone)).lower()
if tipo == "":
tipo = padrão
for t in tipos_de_telefone:
if [Link](tipo):
return t # Retorna o nome completo
else:
print("Tipo de telefone inválido!")

def pede_email(padrão=""):
email = input("Email: ")
Atualização do 23 de novembro de 2024 [Link]
206 Exercı́cios resolvidos — 4� ediçã o
if email == "":
email = padrão
return email

def pede_aniversário(padrão=""):
aniversário = input("Data de aniversário: ")
if aniversário == "":
aniversário = padrão
return aniversário

def mostra_dados(nome, telefones, email, aniversário):

print(f"Nome: {[Link]()}")
print("Telefone(s):")
for telefone in telefones:
print(f"\tNúmero: {telefone[0]:15s} Tipo: {telefone[1].
capitalize()}")
print(f"Email: {email}\nAniversário: {aniversário}\n")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
global agenda, alterada
nome = pede_nome()
if pesquisa(nome) is not None:
print("Nome já existe!")
return
telefones = []
while True:
numero = pede_telefone()
tipo = pede_tipo_telefone()
[Link]([numero, tipo])
if confirma("que deseja cadastrar outro telefone") == "N":
break
email = pede_email()
aniversário = pede_aniversário()
[Link]([nome, telefones, email, aniversário])
alterada = True

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 207
def confirma(operação):
while True:
opção = input(f"Confirma {operação} (S/N)? ").upper()
if opção in "SN":
return opção
else:
print("Resposta inválida. Escolha S ou N.")

def apaga():
global agenda, alterada
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
if confirma("apagamento") == "S":
del agenda[p]
alterada = True
else:
print("Nome não encontrado.")

def altera():
global alterada
p = pesquisa(pede_nome())
if p is not None:
nome, telefones, email, aniversário = agenda[p]
print("Encontrado:")
mostra_dados(nome, telefones, email, aniversário)
nome = pede_nome(nome) # Se nada for digitado, mantém o valor
for telefone in telefones:
numero, tipo = telefone
telefone[0] = pede_telefone(numero)
telefone[1] = pede_tipo_telefone(tipo)
email = pede_email(email)
aniversário = pede_aniversário(aniversário)
if confirma("alteração") == "S":
agenda[p] = [nome, telefones, email, aniversário]
alterada = True
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
# Usamos a função enumerate para obter a posição na agenda
for posição, e in enumerate(agenda):
# Imprimimos a posição
print(f"\nPosição: {posição}")
mostra_dados(e[0], e[1], e[2], e[3])
print("\------\n")

Atualização do 23 de novembro de 2024 [Link]

208 Exercı́cios resolvidos — 4� ediçã o
def lê_última_agenda_gravada():
última = última_agenda()
if última is not None:
leia_arquivo(última)

def última_agenda():
try:
arquivo = open("ultima agenda [Link]", "r", encoding="utf-8")
última = [Link]()[:-1]
[Link]()
except FileNotFoundError:
return None
return última

def atualiza_última(nome):
arquivo = open("ultima agenda [Link]", "w", encoding="utf-8")
[Link](f"{nome}\n")
[Link]()

def leia_arquivo(nome_arquivo):
global agenda, alterada
arquivo = open(nome_arquivo, "rb")
agenda = [Link](arquivo)
[Link]()
alterada = False

def lê():
global alterada
if alterada:
print(
"Você não salvou a lista desde a última alteração. Deseja
gravá-la agora?"
)
if confirma("gravação") == "S":
grava()
print("Ler\n---")
nome_arquivo = pede_nome_arquivo()
leia_arquivo(nome_arquivo)
atualiza_última(nome_arquivo)

def ordena():
global alterada
# Você pode ordenar a lista como mostrado no livro
# com o método de bolhas (bubble sort)
# Ou combinar o método sort do Python com lambdas para
# definir a chave da lista
# [Link](key=lambda e: return e[0])
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 209
fim = len(agenda)
while fim > 1:
i = 0
trocou = False
while i < (fim - 1):
if agenda[i] > agenda[i + 1]:
# Opção: agenda[i], agenda[i+1] = agenda[i+1], agenda[i]
temp = agenda[i + 1]
agenda[i + 1] = agenda[i]
agenda[i] = temp
trocou = True
i += 1
if not trocou:
break
alterada = True

def grava():
global alterada
if not alterada:
print("Você não alterou a lista. Deseja gravá-la mesmo assim?")
if confirma("gravação") == "N":
return
print("Gravar\n\------")
nome_arquivo = pede_nome_arquivo()

arquivo = open(nome_arquivo, "wb")

[Link](agenda, arquivo)
[Link]()
atualiza_última(nome_arquivo)
alterada = False

def valida_faixa_inteiro(pergunta, inicio, fim):

while True:
try:
valor = int(input(pergunta))
if inicio <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {inicio} e {fim}")

def menu():
print("""
1 - Novo
2 - Altera
3 - Apaga
4 - Lista
5 - Grava
6 - Lê
7 - Ordena por nome

Atualização do 23 de novembro de 2024 [Link]

210 Exercı́cios resolvidos — 4� ediçã o

0 - Sai
""")
print(f"\nNomes na agenda: {len(agenda)} Alterada: {alterada}\n")
return valida_faixa_inteiro("Escolha uma opção: ", 0, 7)

lê_última_agenda_gravada()

while True:
opção = menu()
if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()
elif opção == 7:
ordena()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 211
Exercício 09-29
Modifique o Programa 9.8 para u�lizar o elemento p em vez de h2 nos filmes.

filmes = {
"drama": ["Cidadão Kane", "O Poderoso Chefão"],
"comédia": ["Tempos Modernos", "American Pie", "Dr. Dolittle"],
"policial": ["Chuva Negra", "Desejo de Matar", "Difícil de Matar"],
"guerra": ["Rambo", "Platoon", "Tora!Tora!Tora!"],
}

pagina = open("[Link]", "w", encoding="utf-8")

[Link]("""
<!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<title>Filmes</title>
</head>
<body>
""")
for c, v in [Link]():
[Link](f"<h1>{c}</h1>")
for e in v:
[Link](f"<p>{e}</p>")
[Link]("""
</body>
</html>
""")
[Link]()

Atualização do 23 de novembro de 2024 [Link]

212 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-30
Modifique o Programa 9.8 para gerar uma lista HTML, usando os elementos ul e li. Todos os
elementos da lista devem estar dentro do elemento ul, e cada item dentro de um elemento
li. Exemplo: <ul><li>Item1</li><li>Item2</li><li>Item3</li></ul>V

filmes = {
"drama": ["Cidadão Kane", "O Poderoso Chefão"],
"comédia": ["Tempos Modernos", "American Pie", "Dr. Dolittle"],
"policial": ["Chuva Negra", "Desejo de Matar", "Difícil de Matar"],
"guerra": ["Rambo", "Platoon", "Tora!Tora!Tora!"],
}

pagina = open("[Link]", "w", encoding="utf-8")

[Link]("""
<!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<title>Filmes</title>
</head>
<body>
""")
for c, v in [Link]():
[Link](f"<h1>{[Link]()}</h1>")
[Link]("<ul>")
for e in v:
[Link](f"<li>{e}</li>")
[Link]("</ul>")
[Link]("""
</body>
</html>
""")
[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 213
Exercício 09-31
Crie um programa que corrija o Programa 9.9 de forma a verificar se z existe e é um diretório.

import [Link]

if [Link]("z"):
print("O diretório z existe.")
elif [Link]("z"):
print("z existe, mas é um arquivo e não um diretório.")
else:
print("O diretório z não existe.")

Atualização do 23 de novembro de 2024 [Link]

214 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-32
Modifique o Programa 9.9 de forma a receber o nome do arquivo ou diretório a verificar pela
linha de comando. Imprima se exis�r e se for um arquivo ou um diretório.

import sys
import [Link]

if len([Link]) < 2:
print("Digite o nome do arquivo ou diretório a verificar como
parâmatro!")
[Link](1)

nome = [Link][1]
if [Link](nome):
print(f"O diretório {nome} existe.")
elif [Link](nome):
print(f"O arquivo {nome} existe.")
else:
print(f"{nome} não existe.")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 215
Exercício 09-33
Crie um programa que gere uma página HTML com links para todos os arquivos jpg e png
encontrados a par�r de um diretório informado na linha de comando.

# Esta exercício pode ser realizado também com o módulo glob

# Consulte a documentação do Python para mais informações
import sys
import os
import [Link]

# este módulo ajuda com a conversão de nomes de arquivos para links

# válidos em HTML
import [Link]

if len([Link]) < 2:
print("Digite o nome do diretório para coletar os arquivos jpg e
png!")
[Link](1)

diretório = [Link][1]

pagina = open("[Link]", "w", encoding="utf-8")

[Link]("""
<!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<title>Imagens PNG e JPG</title>
</head>
<body>
""")
[Link](f"Imagens encontradas no diretório: {diretório}")
for entrada in [Link](diretório):
nome, extensão = [Link](entrada)
if extensão in [".jpg", ".png"]:
caminho_completo = [Link](diretório, entrada)
link = [Link].pathname2url(caminho_completo)
[Link](f"<p><a href='{link}'>{entrada}</a></p>")

[Link]("""
</body>
</html>
""")
[Link]()

Atualização do 23 de novembro de 2024 [Link]

216 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-34
Altere o Programa 7.2, o jogo da forca. Dessa vez, u�lize as funções de tempo para
cronometrar a duração das par�das.

import time

palavra = input("Digite a palavra secreta:").lower().strip()

for x in range(100):
print()
digitadas = []
acertos = []
erros = 0

inicio = [Link]() # Registra o início da partida

while True:
senha = ""
for letra in palavra:
senha += letra if letra in acertos else "."
print(senha)
if senha == palavra:
print("Você acertou!")
break
tentativa = input("\nDigite uma letra:").lower().strip()
if tentativa in digitadas:
print("Você já tentou esta letra!")
continue
else:
digitadas += tentativa
if tentativa in palavra:
acertos += tentativa
else:
erros += 1
print("Você errou!")
print("X==:==\nX : ")
print("X O " if erros >= 1 else "X")
linha2 = ""
if erros == 2:
linha2 = " | "
elif erros == 3:
linha2 = r" \| "
elif erros >= 4:
linha2 = r" \|/ "
print(f"X{linha2}")
linha3 = ""
if erros == 5:
linha3 += " / "
elif erros >= 6:
linha3 += r" / \ "
print(f"X{linha3}")
print("X\n===========")
if erros == 6:
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 217
print("Enforcado!")
break
fim = [Link]() # tempo no fim da partida
print(f"Duração da partida {fim - inicio} segundos")

Atualização do 23 de novembro de 2024 [Link]

218 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-35
U�lizando a função [Link], crie uma página HTML com o nome e tamanho de cada arquivo
de um diretório passado e de seus subdiretórios.

import sys
import os
import [Link]

# este módulo ajuda com a conversão de nomes de arquivos para links

# válidos em HTML
import [Link]

mascara_do_estilo = "'margin: 5px 0px 5px %dpx;'"

def gera_estilo(nível):
return mascara_do_estilo % (nível * 20)

def gera_listagem(página, diretório):

nraiz = [Link](diretório).count([Link])
for raiz, diretórios, arquivos in [Link](diretório):
nível = [Link]([Link]) - nraiz
pá[Link](f"<p style={gera_estilo(nível)}>{raiz}</p>")
estilo = gera_estilo(nível + 1)
for a in arquivos:
caminho_completo = [Link](raiz, a)
tamanho = [Link](caminho_completo)
link = [Link].pathname2url(caminho_completo)
pá[Link](
f"<p style={estilo}><a href='{link}'>{a}</a> ({tamanho}
bytes)</p>"
)

if len([Link]) < 2:
print("Digite o nome do diretório para coletar os arquivos!")
[Link](1)

diretório = [Link][1]

página = open("[Link]", "w", encoding="utf-8")

pá[Link]("""
<!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<title>Arquivos</title>
</head>
<body>
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 219
""")
pá[Link](f"Arquivos encontrados a partir do diretório: {diretório}")
gera_listagem(página, diretório)
pá[Link]("""
</body>
</html>
""")
pá[Link]()

Atualização do 23 de novembro de 2024 [Link]

220 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-36
U�lizando a função [Link], crie um programa que calcule o espaço ocupado por cada
diretório e subdiretório, gerando uma página HTML com os resultados.

import sys
import os
import [Link]
import math

# Esta função converte o tamanho

# em unidades mais legíveis, evitando
# retornar e imprimir valores muito grandes.
def tamanho_para_humanos(tamanho):
if tamanho == 0:
return "0 byte"
grandeza = [Link](tamanho, 10)
if grandeza < 3:
return f"{tamanho} bytes"
elif grandeza < 6:
return f"{tamanho / 1024.0:7.3f} KB"
elif grandeza < 9:
return f"{tamanho / pow(1024, 2)} MB"
elif grandeza < 12:
return f"{tamanho / pow(1024, 3)} GB"

mascara_do_estilo = "'margin: 5px 0px 5px %dpx;'"

def gera_estilo(nível):
return mascara_do_estilo % (nível * 30)

# Retorna uma função, onde o parâmetro nraiz é utilizado

# para calcular o nível da identação
def gera_nível_e_estilo(raiz):
def nivel(caminho):
xnivel = [Link]([Link]) - nraiz
return gera_estilo(xnivel)

nraiz = [Link]([Link])
return nivel

# Usa a [Link] para percorrer os diretórios

# E uma pilha para armazenar o tamanho de cada diretório
def gera_listagem(página, diretório):
diretório = [Link](diretório)
# identador é uma função que calcula quantos níveis
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 221
# a partir do nível de diretório um caminho deve possuir.
identador = gera_nível_e_estilo(diretório)
pilha = [[diretório, 0]] # Elemento de guarda, para evitar pilha
vazia
for raiz, diretórios, arquivos in [Link](diretório):
# Se o diretório atual: raiz
# Não for um subdiretório do último percorrido
# Desempilha até achar um pai comum
while not [Link](pilha[-1][0]):
último = [Link]()
pá[Link](
f"<p style={identador(último[0])}>Tamanho: (tamanho_para_
humanos(último[1]))</p>"
)
pilha[-1][1] += último[1]
pá[Link](f"<p style={identador(raiz)}>{raiz}</p>")
d_tamanho = 0
for a in arquivos:
caminho_completo = [Link](raiz, a)
d_tamanho += [Link](caminho_completo)
[Link]([raiz, d_tamanho])
# Se a pilha tem mais de um elemento
# os desempilha
while len(pilha) > 1:
último = [Link]()
pá[Link](
f"<p style={identador(último[0])}>Tamanho: ({tamanho_para_
humanos(último[1])})</p>"
)
pilha[-1][1] += último[1]

if len([Link]) < 2:
print("Digite o nome do diretório para coletar os arquivos!")
[Link](1)

diretório = [Link][1]

página = open("[Link]", "w", encoding="utf-8")

pá[Link]("""
<!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<title>Arquivos</title>
</head>
<body>
""")
pá[Link](f"Arquivos encontrados a partir do diretório: {diretório}")
gera_listagem(página, diretório)
pá[Link]("""
</body>
</html>
Atualização do 23 de novembro de 2024 [Link]
222 Exercı́cios resolvidos — 4� ediçã o
""")
pá[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 223
Exercício 09-37
Escreva um programa que leia o nome do aluno e quatro notas. No final, o programa deve
gravar os dados lidos em um arquivo em disco, usando o formato JSON.

import json

# Função para ler as notas do aluno

def ler_notas():
notas = []
for i in range(4):
nota = float(input(f"Digite a {i+1}ª nota: "))
[Link](nota)
return notas

# Leitura dos dados do aluno

nome = input("Digite o nome do aluno: ")
notas = ler_notas()

# Criação do dicionário com os dados do aluno

aluno = {"nome": nome, "notas": notas}

# Salvando os dados em um arquivo JSON

with open("aluno_notas.json", "w") as arquivo:
[Link](aluno, arquivo, indent=4)

print("Dados do aluno salvos com sucesso no arquivo 'aluno_notas.json'.")

Atualização do 23 de novembro de 2024 [Link]

224 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-38
Modifique o programa anterior para que leia o mesmo arquivo, permi�ndo adicionar mais
dados ao arquivo. Se o mesmo nome for digitado duas vezes, altere os dados para a nova
entrada.

import json
import os

def ler_notas():
notas = []
for i in range(4):
nota = float(input(f"Digite a {i+1}ª nota: "))
[Link](nota)
return notas

def carregar_dados():
# Se o arquivo não existir, retorna uma lista vazia
if not [Link]("aluno_notas.json"):
return []

try:
with open("aluno_notas.json", "r") as arquivo:
return [Link](arquivo)
except [Link]:
return []

# Leitura dos dados existentes

alunos = carregar_dados()

# Leitura dos novos dados

nome = input("Digite o nome do aluno: ")
notas = ler_notas()

# Criação do dicionário com os novos dados

novo_aluno = {"nome": nome, "notas": notas}

# Verifica se o aluno já existe e atualiza, ou adiciona novo aluno

aluno_existente = False
for i, aluno in enumerate(alunos):
if aluno["nome"] == nome:
alunos[i] = novo_aluno
aluno_existente = True
break

if not aluno_existente:
[Link](novo_aluno)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 225

# Salvando todos os dados no arquivo JSON

with open("aluno_notas.json", "w") as arquivo:
[Link](alunos, arquivo, indent=4)

print("Dados do aluno salvos com sucesso no arquivo 'aluno_notas.json'.")

Atualização do 23 de novembro de 2024 [Link]

226 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-39
Modifique o Programa 9.6 da agenda. Faça-o ler e gravar um arquivo, mas no formato JSON.

import json

agenda = []

def pede_nome():
return input("Nome: ")

def pede_telefone():
return input("Telefone: ")

def mostra_dados(nome, telefone):

print(f"Nome: {nome} Telefone: {telefone}")

def pede_nome_arquivo():
return input("Nome do arquivo: ")

def pesquisa(nome):
mnome = [Link]()
for p, e in enumerate(agenda):
if e[0].lower() == mnome:
return p
return None

def novo():
nome = pede_nome()
telefone = pede_telefone()
[Link]([nome, telefone])

def apaga():
nome = pede_nome()
p = pesquisa(nome)
if p is not None:
del agenda[p]
else:
print("Nome não encontrado.")

def altera():
p = pesquisa(pede_nome())

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 227
if p is not None:
nome = agenda[p][0]
telefone = agenda[p][1]
print("Encontrado:")
mostra_dados(nome, telefone)
nome = pede_nome()
telefone = pede_telefone()
agenda[p] = [nome, telefone]
else:
print("Nome não encontrado.")

def lista():
print("\nAgenda\n\n\------")
for e in agenda:
mostra_dados(e[0], e[1])
print("\------\n")

def lê():
global agenda
nome_arquivo = pede_nome_arquivo()
try:
with open(nome_arquivo, "r", encoding="utf-8") as arquivo:
agenda = [Link](arquivo)
except FileNotFoundError:
print("Arquivo não encontrado")
except [Link]:
print("Erro ao ler o arquivo JSON")

def grava():
nome_arquivo = pede_nome_arquivo()
with open(nome_arquivo, "w", encoding="utf-8") as arquivo:
[Link](agenda, arquivo, ensure_ascii=False, indent=2)

def valida_faixa_inteiro(pergunta, início, fim):

while True:
try:
valor = int(input(pergunta))
if início <= valor <= fim:
return valor
except ValueError:
print(f"Valor inválido, favor digitar entre {início} e {fim}")

def menu():
print(
"""
1 – Novo
2 – Altera

Atualização do 23 de novembro de 2024 [Link]

228 Exercı́cios resolvidos — 4� ediçã o
3 – Apaga
4 – Lista
5 – Grava
6 – Lê

0 – Sai
"""
)
return valida_faixa_inteiro("Escolha uma opção: ", 0, 6)

while opção := menu():

if opção == 0:
break
elif opção == 1:
novo()
elif opção == 2:
altera()
elif opção == 3:
apaga()
elif opção == 4:
lista()
elif opção == 5:
grava()
elif opção == 6:
lê()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 229
Exercício 09-40
Modifique o programa [Link] para imprimir apenas os 512 primeiros bytes do arquivo.

import sys
import itertools

def imprime_bytes(imagem, bytes_por_linha=16):

for b in [Link](imagem, bytes_por_linha):
hex_view = " ".join([f"{v:02x}" for v in b])
tview = "".join([chr(v) if chr(v).isprintable() else "." for v in
b])
print(f"{hex_view} {" " * 3 * (bytes_por_linha - len(b))}{tview}")

if __name__ == "__main__":
with open([Link][1], "rb") as f:
imagem = [Link](512) # Não lê o arquivo inteiro, apenas os
primeiros 512 bytes
imprime_bytes(imagem)

Atualização do 23 de novembro de 2024 [Link]

230 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-41
Altere o programa [Link] para receber o número máximo de bytes a imprimir e quantos
bytes por linha pela linha de comando.

import sys
import itertools

def imprime_bytes(imagem, bytes_por_linha=16):

for b in [Link](imagem, bytes_por_linha):
hex_view = " ".join([f"{v:02x}" for v in b])
tview = "".join([chr(v) if chr(v).isprintable() else "." for v in
b])
print(f"{hex_view} {" " * 3 * (bytes_por_linha - len(b))}{tview}")

if __name__ == "__main__":
if len([Link]) != 4:
print("Uso: python [Link] arquivo max_bytes bytes_por_linha")
[Link](1)

arquivo = [Link][1]
max_bytes = int([Link][2])
bytes_por_linha = int([Link][3])

with open(arquivo, "rb") as f:

imagem = [Link](max_bytes)

imprime_bytes(imagem, bytes_por_linha)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 231
Exercício 09-42
Modifique o Programa 9.20 para que receba o nome da imagem a gerar pela linha de
comando.

import sys

# Check if filename was provided as argument

if len([Link]) != 2:
print("Uso: python [Link] nome_arquivo.bmp")
[Link](1)

nome_do_arquivo = [Link][1]

def bytes_little_endian(número, nbytes=4, sinal=False):

"""Converte um número inteiro para uma sequência de bytes usando a
codificação little endian.
Se sinal for passado, reserva um bit para representar o sinal."""
return número.to_bytes(nbytes, "little", signed=sinal)

def padding(valor, tamanho=4):

"""Calcula o próximo múltiplo para tamanho"""
if resto := valor % tamanho:
return valor + tamanho - resto
return valor

# Tabela de conversão de letra para cor

# no formato RGB (red, green, blue)
# Cada cor pode variar de 0 a 255.
letra_para_cor = {
" ": (0, 0, 0), # preto
"r": (255, 0, 0), # vermelho
"g": (0, 255, 0), # verde
"b": (0, 0, 255), # azul
}
# Desenho que vamos transformar em imagem
desenho = [
" rrrr r r bbbbb b b ggggg g g r",
" r r r r b b b g g gg g r",
" r r r r b b b g r r g g g g r",
" rrr r b bbbbbb g g g g g r",
" r r b b b gr b rg g g g ",
" r r b b b g rrr g g gg r",
" r r b b b ggggg g g r",
]
# Multiplicador de pontos
# Cada ponto será copiado multiplicador vezes na imagem
# Se igual a 4, cada ponto gera um bloco de 4x4 pontos

Atualização do 23 de novembro de 2024 [Link]

232 Exercı́cios resolvidos — 4� ediçã o
multiplicador = 32

# Checa se todas as linhas têm o mesmo tamanho

largura_desenho = len(desenho[0])

for linha, z in enumerate(desenho):

if len(z) != largura_desenho:
raise ValueError(
f"Linhas devem ter o mesmo tamanho. Linha com largura
diferente: {linha} em vez de {len(z)}"
)

# Calcula os dados com base no multiplicador

desenho_expandido = []
for linha in desenho:
nova_linha = []
for letra in linha:
nova_linha.append(letra * multiplicador)
for _ in range(multiplicador):
desenho_expandido.append("".join(nova_linha))

largura = len(desenho_expandido[0]) # Número de colunas na imagem

altura = len(desenho_expandido) # Número de linhas na imagem

# Checa se as letras representam as cores

dados_binário = []
for linha in desenho_expandido:
linha_binária = []
for caractere in linha:
# Inverte a ordem dos bytes para o formato RGB do bmp
linha_biná[Link](bytes(letra_para_cor[caractere][::-1]))
dados_biná[Link](b"".join(linha_binária))

# Adiciona o padding
largura_bytes = largura * 3
largura_com_padding = padding(largura_bytes)
if largura_bytes != largura_com_padding:
for p, d in enumerate(dados_binário):
dados_binário[p] = b"".join(
[dados_binário[p], bytes(largura_com_padding - largura_bytes)]
)

# Calcula o tamanho em bytes da imagem com o padding

tamanho = padding(largura * 3) * altura

cabeçalho_bmp = [
b"BM", # Identificador
bytes_little_endian(54 + tamanho), # Tamanho da imagem em bytes
bytes(4), # 4 bytes 0x00
bytes_little_endian(54), # Tamanho dos cabeçalhos
]

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 233

cabeçalho_dib = [
bytes_little_endian(40), # Tamanho do cabeçalho DIB
bytes_little_endian(largura),
bytes_little_endian(
-altura, sinal=True
), # Altura negativa para montar a imagem de cima para baixo
bytes_little_endian(1, 2), # Planos de cor
bytes_little_endian(24, 2), # Bits por ponto
bytes_little_endian(0), # Sem compressão
bytes_little_endian(tamanho),
bytes_little_endian(2835), # teto(72 dpi x 39.3701 pol/m) horizontal
bytes_little_endian(2835), # teto(72 dpi x 39.3701 pol/m) vertical
bytes_little_endian(0), # Número de cores na palete
bytes_little_endian(0), # Cores importantes
]

cabeçalho_bmp_binário = b"".join(cabeçalho_bmp)
cabeçalho_dib_binário = b"".join(cabeçalho_dib)
dados_binário = b"".join(dados_binário)

# Verifica o tamanho de cada cabeçalho binário

assert len(cabeçalho_bmp_binário) == 14
assert len(cabeçalho_dib_binário) == 40
assert len(dados_binário) == tamanho

# Grava a imagem
with open(nome_do_arquivo, "wb") as f:
[Link](cabeçalho_bmp_binário)
[Link](cabeçalho_dib_binário)
[Link](dados_binário)

print(f"Arquivo {nome_do_arquivo} gerado. {largura=} x {altura=}

{tamanho=} bytes")

Atualização do 23 de novembro de 2024 [Link]

234 Exercı́cios resolvidos — 4� ediçã o
Exercício 09-43
Modifique o programa do exercício anterior para receber um segundo parâmetro com o
nome do arquivo com o desenho. A ideia é ler o desenho desse arquivo.

import sys

# Verifica se o número de argumentos é válido

if len([Link]) != 3:
print(
"Uso: python [Link] nome_arquivo_saida.bmp nome_
arquivo_desenho.txt"
)
[Link](1)

arquivo_saida = [Link][1]
arquivo_desenho = [Link][2]

# Lê o desenho do arquivo
try:
with open(arquivo_desenho, "r") as f:
desenho = [[Link]() for line in [Link]()]
except FileNotFoundError:
print(f"Erro: O arquivo de desenho '{arquivo_desenho}' não foi
encontrado.")
[Link](1)
except IOError:
print(f"Erro: Não foi possível ler o arquivo de desenho '{arquivo_
desenho}'.")
[Link](1)

def bytes_little_endian(número, nbytes=4, sinal=False):

"""Converte um número inteiro para uma sequência de bytes usando a
codificação little endian.
Se sinal for passado, reserva um bit para representar o sinal."""
return número.to_bytes(nbytes, "little", signed=sinal)

def padding(valor, tamanho=4):

"""Calcula o próximo múltiplo para tamanho"""
if resto := valor % tamanho:
return valor + tamanho - resto
return valor

# Tabela de conversão de letra para cor

# no formato RGB (red, green, blue)
# Cada cor pode variar de 0 a 255.
letra_para_cor = {
" ": (0, 0, 0), # preto

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 235
"r": (255, 0, 0), # vermelho
"g": (0, 255, 0), # verde
"b": (0, 0, 255), # azul
}

# Multiplicador de pontos
# Cada ponto será copiado multiplicador vezes na imagem
# Se igual a 4, cada ponto gera um bloco de 4x4 pontos
multiplicador = 32

# Checa se todas as linhas têm o mesmo tamanho

largura_desenho = len(desenho[0])

for linha, z in enumerate(desenho):

if len(z) != largura_desenho:
raise ValueError(
f"Linhas devem ter o mesmo tamanho. Linha com largura
diferente: {linha} em vez de {len(z)}"
)

# Calcula os dados com base no multiplicador

desenho_expandido = []
for linha in desenho:
nova_linha = []
for letra in linha:
nova_linha.append(letra * multiplicador)
for _ in range(multiplicador):
desenho_expandido.append("".join(nova_linha))

largura = len(desenho_expandido[0]) # Número de colunas na imagem

altura = len(desenho_expandido) # Número de linhas na imagem

# Checa se as letras representam as cores

dados_binário = []
for linha in desenho_expandido:
linha_binária = []
for caractere in linha:
# Inverte a ordem dos bytes para o formato RGB do bmp
linha_biná[Link](bytes(letra_para_cor[caractere][::-1]))
dados_biná[Link](b"".join(linha_binária))

# Adiciona o padding
largura_bytes = largura * 3
largura_com_padding = padding(largura_bytes)
if largura_bytes != largura_com_padding:
for p, d in enumerate(dados_binário):
dados_binário[p] = b"".join(
[dados_binário[p], bytes(largura_com_padding - largura_bytes)]
)

# Calcula o tamanho em bytes da imagem com o padding

Atualização do 23 de novembro de 2024 [Link]

236 Exercı́cios resolvidos — 4� ediçã o
tamanho = padding(largura * 3) * altura

cabeçalho_bmp = [
b"BM", # Identificador
bytes_little_endian(54 + tamanho), # Tamanho da imagem em bytes
bytes(4), # 4 bytes 0x00
bytes_little_endian(54), # Tamanho dos cabeçalhos
]

cabeçalho_dib = [
bytes_little_endian(40), # Tamanho do cabeçalho DIB
bytes_little_endian(largura),
bytes_little_endian(
-altura, sinal=True
), # Altura negativa para montar a imagem de cima para baixo
bytes_little_endian(1, 2), # Planos de cor
bytes_little_endian(24, 2), # Bits por ponto
bytes_little_endian(0), # Sem compressão
bytes_little_endian(tamanho),
bytes_little_endian(2835), # teto(72 dpi x 39.3701 pol/m) horizontal
bytes_little_endian(2835), # teto(72 dpi x 39.3701 pol/m) vertical
bytes_little_endian(0), # Número de cores na palete
bytes_little_endian(0), # Cores importantes
]

cabeçalho_bmp_binário = b"".join(cabeçalho_bmp)
cabeçalho_dib_binário = b"".join(cabeçalho_dib)
dados_binário = b"".join(dados_binário)

# Verifica o tamanho de cada cabeçalho binário

assert len(cabeçalho_bmp_binário) == 14
assert len(cabeçalho_dib_binário) == 40
assert len(dados_binário) == tamanho

# Grava a imagem
with open(arquivo_saida, "wb") as f:
[Link](cabeçalho_bmp_binário)
[Link](cabeçalho_dib_binário)
[Link](dados_binário)

print(f"Arquivo {arquivo_saida} gerado. {largura=} x {altura=} {tamanho=}

bytes")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 237
Exercício 09-44
Modifique o programa anterior para receber um terceiro parâmetro com a tabela de
conversão de cores no formato JSON.

import sys
import json

# Check if both filenames were provided as arguments

if len([Link]) != 4:
print(
"Uso: python [Link] nome_arquivo_saida.bmp nome_
arquivo_desenho.txt tabela_cores.json"
)
[Link](1)

arquivo_saida = [Link][1]
arquivo_desenho = [Link][2]
arquivo_cores = [Link][3]

# Read the drawing from the file

try:
with open(arquivo_desenho, "r") as f:
desenho = [[Link]() for line in [Link]()]
except FileNotFoundError:
print(f"Erro: O arquivo de desenho '{arquivo_desenho}' não foi
encontrado.")
[Link](1)
except IOError:
print(f"Erro: Não foi possível ler o arquivo de desenho '{arquivo_
desenho}'.")
[Link](1)

# Load the color table from the JSON file

try:
with open(arquivo_cores, "r") as f:
letra_para_cor = [Link](f)
except FileNotFoundError:
print(f"Erro: O arquivo de cores '{arquivo_cores}' não foi
encontrado.")
[Link](1)
except [Link]:
print(f"Erro: O arquivo '{arquivo_cores}' não contém um JSON válido.")
[Link](1)

# Verifica constroi a tabela de cores

for caractere in letra_para_cor:
cor = letra_para_cor[caractere]
if len(cor) != 3 or not all(isinstance(x, int) and 0 <= x <= 255 for x
in cor):
print(f"Erro: Cor inválida para o caractere '{caractere}'")

Atualização do 23 de novembro de 2024 [Link]

238 Exercı́cios resolvidos — 4� ediçã o
[Link](1)

def bytes_little_endian(número, nbytes=4, sinal=False):

"""Converte um número inteiro para uma sequência de bytes usando a
codificação little endian.
Se sinal for passado, reserva um bit para representar o sinal."""
return número.to_bytes(nbytes, "little", signed=sinal)

def padding(valor, tamanho=4):

"""Calcula o próximo múltiplo para tamanho"""
if resto := valor % tamanho:
return valor + tamanho - resto
return valor

# Multiplicador de pontos
# Cada ponto será copiado multiplicador vezes na imagem
# Se igual a 4, cada ponto gera um bloco de 4x4 pontos
multiplicador = 32

# Checa se todas as linhas têm o mesmo tamanho

largura_desenho = len(desenho[0])

for linha, z in enumerate(desenho):

if len(z) != largura_desenho:
raise ValueError(
f"Linhas devem ter o mesmo tamanho. Linha com largura
diferente: {linha} em vez de {len(z)}"
)

# Calcula os dados com base no multiplicador

desenho_expandido = []
for linha in desenho:
nova_linha = []
for letra in linha:
nova_linha.append(letra * multiplicador)
for _ in range(multiplicador):
desenho_expandido.append("".join(nova_linha))

largura = len(desenho_expandido[0]) # Número de colunas na imagem

altura = len(desenho_expandido) # Número de linhas na imagem

# Checa se as letras representam as cores

dados_binário = []
for linha in desenho_expandido:
linha_binária = []
for caractere in linha:
# Inverte a ordem dos bytes para o formato RGB do bmp
linha_biná[Link](bytes(letra_para_cor[caractere][::-1]))
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 239
dados_biná[Link](b"".join(linha_binária))

# Adiciona o padding
largura_bytes = largura * 3
largura_com_padding = padding(largura_bytes)
if largura_bytes != largura_com_padding:
for p, d in enumerate(dados_binário):
dados_binário[p] = b"".join(
[dados_binário[p], bytes(largura_com_padding - largura_bytes)]
)

# Calcula o tamanho em bytes da imagem com o padding

tamanho = padding(largura * 3) * altura

cabeçalho_bmp = [
b"BM", # Identificador
bytes_little_endian(54 + tamanho), # Tamanho da imagem em bytes
bytes(4), # 4 bytes 0x00
bytes_little_endian(54), # Tamanho dos cabeçalhos
]

cabeçalho_dib = [
bytes_little_endian(40), # Tamanho do cabeçalho DIB
bytes_little_endian(largura),
bytes_little_endian(
-altura, sinal=True
), # Altura negativa para montar a imagem de cima para baixo
bytes_little_endian(1, 2), # Planos de cor
bytes_little_endian(24, 2), # Bits por ponto
bytes_little_endian(0), # Sem compressão
bytes_little_endian(tamanho),
bytes_little_endian(2835), # teto(72 dpi x 39.3701 pol/m) horizontal
bytes_little_endian(2835), # teto(72 dpi x 39.3701 pol/m) vertical
bytes_little_endian(0), # Número de cores na palete
bytes_little_endian(0), # Cores importantes
]

cabeçalho_bmp_binário = b"".join(cabeçalho_bmp)
cabeçalho_dib_binário = b"".join(cabeçalho_dib)
dados_binário = b"".join(dados_binário)

# Verifica o tamanho de cada cabeçalho binário

assert len(cabeçalho_bmp_binário) == 14
assert len(cabeçalho_dib_binário) == 40
assert len(dados_binário) == tamanho

# Grava a imagem
with open(arquivo_saida, "wb") as f:
[Link](cabeçalho_bmp_binário)
[Link](cabeçalho_dib_binário)
[Link](dados_binário)

Atualização do 23 de novembro de 2024 [Link]

240 Exercı́cios resolvidos — 4� ediçã o

print(f"Arquivo {arquivo_saida} gerado. {largura=} x {altura=} {tamanho=}

bytes")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 241
Exercício 10-01
Adicione os atributos tamanho e marca à classe Televisão. Crie dois objetos Televisão e
atribua tamanhos e marcas diferentes. Depois, imprima o valor desses atributos de forma a
confirmar a independência dos valores de cada instância (objeto).

class Televisão:
def __init__(self):
[Link] = False
[Link] = 2
[Link] = 20
[Link] = "Ching-Ling"

tv = Televisão()
[Link] = 27
[Link] = "LongDang"
tv_sala = Televisão()
tv_sala.tamanho = 52
tv_sala.marca = "XangLa"

print(f"tv tamanho={[Link]} marca={[Link]}")

print(f"tv_sala tamanho={tv_sala.tamanho} marca={tv_sala.marca}")

Atualização do 23 de novembro de 2024 [Link]

242 Exercı́cios resolvidos — 4� ediçã o
Exercício 10-02
Atualmente, a classe Televisão inicializa o canal com 2. Modifique a classe Televisão de forma
a receber o canal inicial em seu construtor como parâmetro opcional.

class Televisão:
def __init__(self, canal_inicial, min, max):
[Link] = False
[Link] = canal_inicial
[Link] = min
[Link] = max

def muda_canal_para_baixo(self):
if [Link] - 1 >= [Link]:
[Link] -= 1

def muda_canal_para_cima(self):
if [Link] + 1 <= [Link]:
[Link] += 1

tv = Televisão(5, 1, 99)

print([Link])

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 243
Exercício 10-03
Modifique a classe Televisão de forma que, se pedirmos para mudar o canal para baixo, além
do mínimo, ela vá para o canal máximo. Se mudarmos para cima, além do canal máximo, que
volte ao canal mínimo. Exemplo:

>>> tv = Televisão(2, 10)

>>> tv.muda_canal_para_baixo()
>>> [Link]
10
>>> tv.muda_canal_para_cima()
>>> [Link]
2

class Televisão:
def __init__(self, min, max):
[Link] = False
[Link] = min
[Link] = min
[Link] = max

def muda_canal_para_baixo(self):
if [Link] - 1 >= [Link]:
[Link] -= 1
else:
[Link] = [Link]

def muda_canal_para_cima(self):
if [Link] + 1 <= [Link]:
[Link] += 1
else:
[Link] = [Link]

tv = Televisão(2, 10)
tv.muda_canal_para_baixo()
print([Link])
tv.muda_canal_para_cima()
print([Link])

Atualização do 23 de novembro de 2024 [Link]

244 Exercı́cios resolvidos — 4� ediçã o
Exercício 10-04
U�lizando o que aprendemos com funções, modifique o construtor da classe Televisão de
forma que canal\_min e canal\_max sejam parâmetros opcionais, em que canal\_min vale 2
e canal\_max vale 14, caso outro valor não seja passado.

class Televisão:
def __init__(self, min=2, max=14):
[Link] = False
[Link] = min
[Link] = min
[Link] = max

def muda_canal_para_baixo(self):
if [Link] - 1 >= [Link]:
[Link] -= 1
else:
[Link] = [Link]

def muda_canal_para_cima(self):
if [Link] + 1 <= [Link]:
[Link] += 1
else:
[Link] = [Link]

tv = Televisão()
tv.muda_canal_para_baixo()
print([Link])
tv.muda_canal_para_cima()
print([Link])

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 245
Exercício 10-05
U�lizando a classe Televisão modificada no exercício anterior, crie duas instâncias (objetos),
especificando o valor de canal\_min e canal\_max por nome.

class Televisão:
def __init__(self, min=2, max=14):
[Link] = False
[Link] = min
[Link] = min
[Link] = max

def muda_canal_para_baixo(self):
if [Link] - 1 >= [Link]:
[Link] -= 1
else:
[Link] = [Link]

def muda_canal_para_cima(self):
if [Link] + 1 <= [Link]:
[Link] += 1
else:
[Link] = [Link]

tv = Televisão(min=1, max=22)
tv.muda_canal_para_baixo()
print([Link])
tv.muda_canal_para_cima()
print([Link])

tv2 = Televisão(min=2, max=64)

tv2.muda_canal_para_baixo()
print([Link])
tv2.muda_canal_para_cima()
print([Link])

Atualização do 23 de novembro de 2024 [Link]

246 Exercı́cios resolvidos — 4� ediçã o
Exercício 10-06
Modifique a classe Televisão de forma que os métodos muda\_canal\_para_cima e muda_
canal\_para_baixo retornem o canal após a mudança.

class Televisão:
def __init__(self, min=2, max=14):
[Link] = False
[Link] = min
[Link] = min
[Link] = max

def muda_canal_para_baixo(self):
if [Link] - 1 >= [Link]:
[Link] -= 1
else:
[Link] = [Link]
return [Link]

def muda_canal_para_cima(self):
if [Link] + 1 <= [Link]:
[Link] += 1
else:
[Link] = [Link]
return [Link]

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 247
Exercício 10-07
Altere a classe Televisão. Ela só deve aceitar os comandos de trocar de canal se es�ver ligada.

class Televisão:
def __init__(self, min=2, max=14):
[Link] = False
[Link] = min
[Link] = min
[Link] = max

def muda_canal_para_baixo(self):
if not [Link]:
return
if [Link] - 1 >= [Link]:
[Link] -= 1
else:
[Link] = [Link]

def muda_canal_para_cima(self):
if not [Link]:
return
if [Link] + 1 <= [Link]:
[Link] += 1
else:
[Link] = [Link]

Atualização do 23 de novembro de 2024 [Link]

248 Exercı́cios resolvidos — 4� ediçã o
Exercício 10-08
Altere o programa de forma que a mensagem saldo insuficiente seja exibida caso haja
tenta�va de sacar mais dinheiro que o saldo disponível.

# Modifique o arquivo [Link] das listagens

class Conta:
def __init__(self, clientes, número, saldo=0):
[Link] = 0
[Link] = clientes
self.número = número
[Link]ções = []
[Link](saldo)

def resumo(self):
print(f"CC N°{self.número} Saldo: {[Link].2f}")

def saque(self, valor):

if [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
else:
print("Saldo insuficiente!")

def deposito(self, valor):

[Link] += valor
[Link]çõ[Link](["DEPÓSITO", valor])

def extrato(self):
print(f"Extrato CC N° {self.número}\n")
for o in [Link]ções:
print(f"{o[0]:10s} {o[1]:10.2f}")
print(f"\n Saldo: {[Link].2f}\n")

class ContaEspecial(Conta):
def __init__(self, clientes, número, saldo=0, limite=0):
Conta.__init__(self, clientes, número, saldo)
[Link] = limite

def saque(self, valor):

if [Link] + [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
else:
[Link](self, valor)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 249
Exercício 10-09
Modifique o método resumo da classe Conta para exibir o nome e o telefone de cada cliente.

# Aqui [Link] e [Link] foram copiados para um só arquivo.

# Esta mudança serve apenas para facilitar a visualização
# da resposta deste exercício.

class Cliente:
def __init__(self, nome, telefone):
[Link] = nome
[Link] = telefone

class Conta:
def __init__(self, clientes, número, saldo=0):
[Link] = 0
[Link] = clientes
self.número = número
[Link]ções = []
[Link](saldo)

def resumo(self):
print(f"CC N°{self.número} Saldo: {[Link].2f}\n")
for cliente in [Link]:
print(f"Nome: {[Link]}\nTelefone: {[Link]}\n")

def saque(self, valor):

if [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
else:
print("Saldo insuficiente!")

def deposito(self, valor):

[Link] += valor
[Link]çõ[Link](["DEPÓSITO", valor])

def extrato(self):
print(f"Extrato CC N° {self.número}\n")
for o in [Link]ções:
print(f"{o[0]:10s} {o[1]:10.2f}")
print(f"\n Saldo: {[Link].2f}\n")

maria = Cliente("Maria", "1243-3321")

joão = Cliente("João", "5554-3322")

conta = Conta([maria, joão], 1234, 5000)

[Link]()
Atualização do 23 de novembro de 2024 [Link]
250 Exercı́cios resolvidos — 4� ediçã o
Exercício 10-10
Crie uma nova conta, agora tendo João e José como clientes e saldo igual a 500.

# Aqui [Link] e [Link] foram copiados para um só arquivo.

# Esta mudança serve apenas para facilitar a visualização
# da resposta deste exercício.

class Cliente:
def __init__(self, nome, telefone):
[Link] = nome
[Link] = telefone

class Conta:
def __init__(self, clientes, número, saldo=0):
[Link] = 0
[Link] = clientes
self.número = número
[Link]ções = []
[Link](saldo)

def resumo(self):
print(f"CC N°{self.número} Saldo: {[Link].2f}\n")
for cliente in [Link]:
print(f"Nome: {[Link]}\nTelefone: {[Link]}\n")

def saque(self, valor):

if [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
else:
print("Saldo insuficiente!")

def deposito(self, valor):

[Link] += valor
[Link]çõ[Link](["DEPÓSITO", valor])

def extrato(self):
print("fExtrato CC N° {self.número}\n")
for o in [Link]ções:
print(f"{o[0]:10s} {o[1]:10.2f}")
print(f"\n Saldo: {[Link].2f}\n")

joão = Cliente("João", "5554-3322")

josé = Cliente("José", "1243-3321")

conta = Conta([joão, josé], 2341, 500)

[Link]()
[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 251
Exercício 10-11
Crie classes para representar estados e cidades. Cada estado tem um nome, sigla e cidades.
Cada cidade tem nome e população. Escreva um programa de testes que crie três estados
com algumas cidades em cada um. Exiba a população de cada estado como a soma da
população de suas cidades.

class Estado:
def __init__(self, nome, sigla):
[Link] = nome
[Link] = sigla
[Link] = []

def adiciona_cidade(self, cidade):

[Link] = self
[Link](cidade)

def população(self):
return sum([[Link]ção for c in [Link]])

class Cidade:
def __init__(self, nome, população):
[Link] = nome
[Link]ção = população
[Link] = None

def __str__(self):
return f"Cidade (nome={[Link]}, população={[Link]ção},
estado={[Link]})"

# Populações obtidas no site da Wikipédia

# IBGE estimativa 2012
am = Estado("Amazonas", "AM")
am.adiciona_cidade(Cidade("Manaus", 1861838))
am.adiciona_cidade(Cidade("Parintins", 103828))
am.adiciona_cidade(Cidade("Itacoatiara", 89064))

sp = Estado("São Paulo", "SP")

sp.adiciona_cidade(Cidade("São Paulo", 11376685))
sp.adiciona_cidade(Cidade("Guarulhos", 1244518))
sp.adiciona_cidade(Cidade("Campinas", 1098630))

rj = Estado("Rio de Janeiro", "RJ")

rj.adiciona_cidade(Cidade("Rio de Janeiro", 6390290))
rj.adiciona_cidade(Cidade("São Gonçalo", 1016128))
rj.adiciona_cidade(Cidade("Duque de Caixias", 867067))

Atualização do 23 de novembro de 2024 [Link]

252 Exercı́cios resolvidos — 4� ediçã o
for estado in [am, sp, rj]:
print(f"Estado: {[Link]} Sigla: {[Link]}")
for cidade in [Link]:
print(f"Cidade: {[Link]} População: {[Link]ção}")
print(f"População do Estado: {[Link]ção()}\n")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 253
Exercício 10-12
Modifique as classes Conta e ContaEspecial para que a operação de saque retorne
verdadeiro se o saque foi efetuado e falso, caso contrário.

# Aqui [Link] e [Link] foram copiados para um só arquivo.

# Esta mudança serve apenas para facilitar a visualização
# da resposta deste exercício.

class Cliente:
def __init__(self, nome, telefone):
[Link] = nome
[Link] = telefone

# Modifiaque o arquivo [Link] das listagens

class Conta:
def __init__(self, clientes, número, saldo=0):
[Link] = 0
[Link] = clientes
self.número = número
[Link]ções = []
[Link](saldo)

def resumo(self):
print(f"CC N°{self.número} Saldo: {[Link].2f}")

def saque(self, valor):

if [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
return True
else:
print("Saldo insuficiente!")
return False

def deposito(self, valor):

[Link] += valor
[Link]çõ[Link](["DEPÓSITO", valor])

def extrato(self):
print(f"Extrato CC N° {self.número}\n")
for o in [Link]ções:
print("f{o[0]:%10s} {o[1]:10.2f}")
print(f"\n Saldo: {[Link]:%10.2f}\n")

Atualização do 23 de novembro de 2024 [Link]

254 Exercı́cios resolvidos — 4� ediçã o
class ContaEspecial(Conta):
def __init__(self, clientes, número, saldo=0, limite=0):
Conta.__init__(self, clientes, número, saldo)
[Link] = limite

def saque(self, valor):

if [Link] + [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
return True
else:
return [Link](self, valor)

joão = Cliente("João", "5554-3322")

josé = Cliente("José", "1243-3321")

conta = Conta([joão, josé], 2341, 500)

[Link]()
print([Link](1000))
print([Link](100))
[Link]()

conta2 = ContaEspecial([josé], 3432, 50000, 10000)

[Link]()
print([Link](100000))
print([Link](500))
[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 255
Exercício 10-13
Altere a classe ContaEspecial de forma que seu extrato exiba o limite e o total disponível para
saque.

# Aqui [Link] e [Link] foram copiados para um só arquivo.

# Esta mudança serve apenas para facilitar a visualização
# da resposta deste exercício.

class Cliente:
def __init__(self, nome, telefone):
[Link] = nome
[Link] = telefone

# Modifiaque o arquivo [Link] das listagens

class Conta:
def __init__(self, clientes, número, saldo=0):
[Link] = 0
[Link] = clientes
self.número = número
[Link]ções = []
[Link](saldo)

def resumo(self):
print(f"CC N°{self.número} Saldo: {[Link].2f}")

def saque(self, valor):

if [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
return True
else:
print("Saldo insuficiente!")
return False

def deposito(self, valor):

[Link] += valor
[Link]çõ[Link](["DEPÓSITO", valor])

def extrato(self):
print(f"Extrato CC N° {self.número}\n")
for o in [Link]ções:
print(f"{o[0]:10s} {o[1]:10.2f}")
print(f"\n Saldo: {[Link].2f}\n")

Atualização do 23 de novembro de 2024 [Link]

256 Exercı́cios resolvidos — 4� ediçã o
class ContaEspecial(Conta):
def __init__(self, clientes, número, saldo=0, limite=0):
Conta.__init__(self, clientes, número, saldo)
[Link] = limite

def saque(self, valor):

if [Link] + [Link] >= valor:
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
return True
else:
return [Link](self, valor)

def extrato(self):
[Link](self)
print(f"\n Limite: {[Link].2f}\n")
print(f"\n Disponivel: {[Link] + [Link].2f}\n")

josé = Cliente("José", "1243-3321")

conta = ContaEspecial([josé], 3432, 50000, 10000)

[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 257
Exercício 10-14
Observe o método saque das classes Conta e ContaEspecial. Modifique o método saque da
classe Conta de forma que a verificação da possibilidade de saque seja feita por um novo
método, subs�tuindo a condição atual. Esse novo método retornará verdadeiro se o saque
puder ser efetuado, e falso, caso contrário. Modifique a classe ContaEspecial de forma a
trabalhar com esse novo método. Verifique se você ainda precisa trocar o método saque de
ContaEspecial ou apenas o novo método criado para verificar a possibilidade de saque.

# Aqui [Link] e [Link] foram copiados para um só arquivo.

# Esta mudança serve apenas para facilitar a visualização
# da resposta deste exercício.

class Cliente:
def __init__(self, nome, telefone):
[Link] = nome
[Link] = telefone

# Modifiaque o arquivo [Link] das listagens

class Conta:
def __init__(self, clientes, número, saldo=0):
[Link] = 0
[Link] = clientes
self.número = número
[Link]ções = []
[Link](saldo)

def resumo(self):
print(f"CC N°{self.número} Saldo: {[Link].2f}")

def pode_sacar(self, valor):

return [Link] >= valor

def saque(self, valor):

if self.pode_sacar(valor):
[Link] -= valor
[Link]çõ[Link](["SAQUE", valor])
return True
else:
print("Saldo insuficiente!")
return False

def deposito(self, valor):

[Link] += valor
[Link]çõ[Link](["DEPÓSITO", valor])

Atualização do 23 de novembro de 2024 [Link]

258 Exercı́cios resolvidos — 4� ediçã o
def extrato(self):
print(f"Extrato CC N° {self.número}\n")
for o in [Link]ções:
print(f"{o[0]:10s} {o[1]:10.2f}")
print(f"\n Saldo: {[Link].2f}\n")

class ContaEspecial(Conta):
def __init__(self, clientes, número, saldo=0, limite=0):
Conta.__init__(self, clientes, número, saldo)
[Link] = limite

def pode_sacar(self, valor):

return [Link] + [Link] >= valor

def extrato(self):
[Link](self)
print(f"\n Limite: {[Link].2f}\n")
print(f"\n Disponivel: {[Link] + [Link]:%10.2f}\n")

# Veja que com o método pode_sacar de ContaEspecial

# nem precisamos escrever um método especial de saque!

josé = Cliente("José", "1243-3321")

conta = ContaEspecial([josé], 3432, 5000, 1000)

[Link]()
[Link](6000)
[Link](3000)
[Link](1000)
[Link]()

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 259
Exercício 10-15
Modifique a classe ListaÚnica para sobrescrever o método extend de UserList. extend
funciona como o append, mas recebe uma lista como parâmetro. Verifique o �po de cada
elemento na lista antes de adicioná-lo à lista.

from collections import UserList

class ListaÚnica(UserList):
def __init__(self, elem_classe, enumerable=None):
super().__init__(enumerable)
self.elem_classe = elem_classe

def append(self, elem):

self.verifica_tipo(elem)
if elem not in [Link]:
super().append(elem)

def extend(self, iteravel):

for elem in iteravel:
[Link](elem)

def __setitem__(self, posição, elem):

self.verifica_tipo(elem)
if elem not in [Link]:
super().__setitem__(posição, elem)

def verifica_tipo(self, elem):

if not isinstance(elem, self.elem_classe):
raise TypeError("Tipo inválido")

Atualização do 23 de novembro de 2024 [Link]

260 Exercı́cios resolvidos — 4� ediçã o
Exercício 11-01
Faça um programa que crie o banco de dados preç[Link] com a tabela preços para armazenar
uma lista de preços de venda de produtos. A tabela deve conter o nome do produto e seu
respec�vo preço. O programa também deve inserir alguns dados para teste.

import sqlite3
from contextlib import closing

with [Link]("[Link]") as conexao:

with closing([Link]()) as cursor:
[Link]("""
create table preços(
nome text,
preço numeric)
""")
[Link](
"""
insert into preços (nome, preço)
values(?, ?)
""",
("Batata", "3.20"),
)
[Link](
"""
insert into preços (nome, preço)
values(?, ?)
""",
("Pão", "1.20"),
)
[Link](
"""
insert into preços (nome, preço)
values(?, ?)
""",
("Mamão", "2.14"),
)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 261
Exercício 11-02
Faça um programa para listar todos os preços do banco preç[Link].

import sqlite3
from contextlib import closing

with [Link]("[Link]") as conexao:

with closing([Link]()) as cursor:
[Link]("""select * from preços""")
for resultado in [Link]():
print("Nome: {0:30s} Preço: {1:6.2f}".format(*resultado))

Atualização do 23 de novembro de 2024 [Link]

262 Exercı́cios resolvidos — 4� ediçã o
Exercício 11-03
Escreva um programa que realize consultas do banco de dados preços. db, criado no
Exercício 11.1. O programa deve perguntar o nome do produto e listar seu preço.

import sqlite3
from contextlib import closing

with [Link]("[Link]") as conexao:

with closing([Link]()) as cursor:
while True:
nome = input("Nome do produto a pesquisar [em branco sai]: ")
if not nome:
break
[Link]("""select * from preços where nome = ?""",
(nome,))
achados = 0
for resultado in [Link]():
print("Nome: {0:30s} Preço: {1:6.2f}".format(*resultado))
achados += 1
if achados == 0:
print("Não encontrado.")
else:
print("{} produto(s) encontrado(s).".format(achados))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 263
Exercício 11-04
Modifique o programa do Exercício 11.3 de forma a perguntar dois valores e listar todos os
produtos com preços entre esses dois valores.

import sqlite3
from contextlib import closing

with [Link]("[Link]") as conexao:

with closing([Link]()) as cursor:
preço1 = input("Digite o menor preço a listar: ")
preço2 = input("Digite o maior preço a listar: ")

[Link](
"""select * from preços
where preço >= ? and preço <= ?""",
(preço1, preço2),
)
achados = 0
for resultado in [Link]():
print("Nome: {0:30s} Preço: {1:6.2f}".format(*resultado))
achados += 1
if achados == 0:
print("Não encontrado.")
else:
print("{} produto(s) encontrado(s).".format(achados))

Atualização do 23 de novembro de 2024 [Link]

264 Exercı́cios resolvidos — 4� ediçã o
Exercício 11-05
Escreva um programa que aumente o preço de todos os produtos do banco preç[Link] em
10%.

import sqlite3
from contextlib import closing

with [Link]("[Link]") as conexao:

with closing([Link]()) as cursor:
[Link]("""update preços
set preço = preço * 1.1""")
# Mostra os novos preços
[Link]("""select * from preços""")
for resultado in [Link]():
print("Nome: {0:30s} Preço: {1:6.2f}".format(*resultado))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 265
Exercício 11-06
Escreva um programa que pergunte o nome do produto e um novo preço. Usando o banco
preç[Link], atualize o preço desse produto no banco de dados.

import sqlite3
from contextlib import closing

with [Link]("[Link]") as conexao:

with closing([Link]()) as cursor:
nome = input("Digite o nome do produto a alterar o preço: ")

[Link](
"""select * from preços
where nome = ?""",
(nome,),
)

resultado = [Link]()
if resultado:
print("Nome: {0:30s} Preço: {1:6.2f}".format(*resultado))
novo_preço = input("Digite o novo preço: ")
[Link](
"""update preços
set preço = ?
where nome = ?""",
(novo_preço, nome),
)
else:
print("Não encontrado.")

Atualização do 23 de novembro de 2024 [Link]

266 Exercı́cios resolvidos — 4� ediçã o
Exercício 12-01
Modifique o programa anterior para reconhecer sequências de letras. Uma letra é um
caractere entre A e Z ou entre a e z, considerando letras maiúsculas e minúsculas. Ignore
caracteres acentuados. Imprima uma lista com as sequências de letras encontradas.

entrada = "ABC431DEF901c431203FXEW9"
saída = []
número = []

for caractere in entrada:

if "a" <= [Link]() <= "z":
if not número:
saí[Link](número)
número += caractere
elif número:
número = []

for encontrado in saída:

print("".join(encontrado))

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 267
Exercício 12-02
Reescreva a função que mostra os números na entrada ABC431DEF-901c431203FXEW9, mas
usando a função verifica\_padrão.

entrada = "ABC431DEF901c431203FXEW9"
def verifica_padrão(entrada, padrões):
posição = 0
for padrão in padrões:
achou, _, fim = padrão(entrada[posição:])
if achou > 0:
posição += fim + 1
else:
return -1, -1, -1
return 1, 0, posição - 1

def números(entrada):
achados = 0
fim = -1
for i, caractere in enumerate(entrada):
if "0" <= caractere <= "9":
achados += 1
fim = i
else:
break
return achados, 0, fim

posição = 0
while posição < len(entrada):
achado, inicio, fim = verifica_padrão(entrada[posição:], [números])
if achado > 0:
print(entrada[posição : posição + fim + 1])
posição += fim + 1
else:
posição += 1

Atualização do 23 de novembro de 2024 [Link]

268 Exercı́cios resolvidos — 4� ediçã o
Exercício 12-03
U�lizando a função verifica_padrão, escreva uma função que detecte uma data no formato
dd/mm/aa em que dd é o dia, mm o mês e aa o ano. A função deve apenas detectar o
padrão da data e não precisa verificar se a data é válida.

# Funções número, sequência e verifica padrão da listagem 12.5

from functools import partial

def número(entrada, qmin, qmax):

num = 0
for caractere in entrada:
if [Link]():
num += 1
else:
break
if qmin <= num <= qmax:
return num, 0, num - 1
else:
return -1, -1, -1

def sequência(entrada, padrão):

posição, posição_max = 0, len(padrão)
for caractere in entrada:
if caractere == padrão[posição]:
posição += 1 # Caracteres iguais, testa o próximo caractere
else:
break # Saiu da sequência
if posição == posição_max: # Achou toda a sequência
return 1, 0, posição - 1
return -1, -1, -1

def verifica_padrão(entrada, padrões):

posição = 0
for padrão in padrões:
achou, _, fim = padrão(entrada[posição:])
if achou > 0:
posição += fim + 1
else:
return -1, -1, -1
return 1, 0, posição - 1

dois_números = partial(número, qmin=2, qmax=2)

barra = partial(sequência, padrão="/")
padrão = [dois_números, barra, dois_números, barra, dois_números]

# Aqui uma pequena lista de entradas para facilitar a visualização

[Link] Atualização do 23 de novembro de 2024
Exercı́cios resolvidos — 4� ediçã o 269
entradas = [
"12/03/24", # Padrão encontrado
"12/3/2024", # Padrão não encontrado
"Dia doze de março 12/03", # Padrão não encontrado
"12-03-24 12/03/2024 abc 21/30/24", # Padrão encontrado
"12/03/24 12/03/624 abc 21/30/24", # Padrão encontrado duas vezes
]
for entrada in entradas:
print("Entrada:", entrada)
achado = False
posição = 0
while posição < len(entrada):
achou, início, fim = verifica_padrão(entrada[posição:], padrão)
if achou > 0:
print(f"Data posições: {posição+início} a {posição+fim} ",
end="")
print("Data:", entrada[posição + início : posição + fim + 1])
achado = True
posição += fim + 1
else:
posição += 1
if not achado:
print("Nenhuma data encontrada na entrada")
print()

Atualização do 23 de novembro de 2024 [Link]

270 Exercı́cios resolvidos — 4� ediçã o
Exercício 12-04
U�lizando a função verifica_padrão, escreva uma função que detecte um valor em reais no
formato: R$999,99 em que 9 representa qualquer dígito. O primeiro número pode ter um ou
mais dígitos, mas a segunda parte (centavos) deve ter no máximo dois dígitos.

# Funções número, sequência e verifica padrão da listagem 12.5

from functools import partial

def número(entrada, qmin, qmax):

num = 0
for caractere in entrada:
if [Link]():
num += 1
else:
break
if qmin <= num <= qmax:
return num, 0, num - 1
else:
return -1, -1, -1

def sequência(entrada, padrão):

posição, posição_max = 0, len(padrão)
for caractere in entrada:
if caractere == padrão[posição]:
posição += 1 # Caracteres iguais, testa o próximo caractere
else:
break # Saiu da sequência
if posição == posição_max: # Achou toda a sequência
return 1, 0, posição - 1
return -1, -1, -1

def verifica_padrão(entrada, padrões):

posição = 0
for padrão in padrões:
achou, _, fim = padrão(entrada[posição:])
if achou > 0:
posição += fim + 1
else:
return -1, -1, -1
return 1, 0, posição - 1

# Bônus, como reconhecer um padrão opcional.

# Não faz parte do enunciado, mas é interessante.
def opcional(entrada, padrões):
achou, inicio, fim = verifica_padrão(entrada, padrões)
if achou > 0:

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 271
return achou, inicio, fim
else:
return 1, -1, -1

três_números = partial(número, qmin=1, qmax=3)

centavos = partial(número, qmin=1, qmax=2)
cifrão = partial(sequência, padrão="R$")
vírgula = partial(sequência, padrão=",")

# Apenas os valores citados no enunciado

padrão = [cifrão, três_números, vírgula, centavos]
# Usando a função opcional para aceitar valores sem centavos (bônus)
# padrão = [cifrão, três_números, partial(opcional, padrões=[vírgula,
centavos])]

# Aqui uma pequena lista de entradas para facilitar a visualização

entradas = [
"R$123,45", # Padrão encontrado
"R$123,450", # Padrão não encontrado
"$123,45", # Padrão não encontrado
"R$12,34", # Padrão encontrado
"R$123,45 R$12,34 R$1,23 R$1,0", # Padrão encontrado quatro vezes
"R$123 R$12 R$1 R$1,0", # Padrão encontrado quatro vezes (se bônus -
opcional ativado), uma vez caso contrário
]
for entrada in entradas:
print("Entrada:", entrada)
achado = False
posição = 0
while posição < len(entrada):
achou, início, fim = verifica_padrão(entrada[posição:], padrão)
if achou > 0:
print(f"Reais nas posições: {posição+início} a {posição+fim} ",
end="")
print("Reais:", entrada[posição + início : posição + fim + 1])
achado = True
posição += fim + 1
else:
posição += 1
if not achado:
print("Nenhum valor em reais encontrado na entrada")
print()

Atualização do 23 de novembro de 2024 [Link]

272 Exercı́cios resolvidos — 4� ediçã o
Exercício 12-05
Crie uma função sequências que recebe qmax e qmin. Ela deve funcionar de forma
semelhante a número, mas chamando a função sequência. Ela deve também funcionar
quando qmin é 0, ou seja, quando a sequência é opcional.

# Funções sequência e verifica padrão da listagem 12.5

from functools import partial

def sequência(entrada, padrão):

posição, posição_max = 0, len(padrão)
for caractere in entrada:
if caractere == padrão[posição]:
posição += 1 # Caracteres iguais, testa o próximo caractere
else:
break # Saiu da sequência
if posição == posição_max: # Achou toda a sequência
return 1, 0, posição - 1
return -1, -1, -1

def sequências(entrada, padrão, qmin=1, qmax=1):

posição = 0
fim = -1
achados = 0
while posição < len(entrada):
achou, _, ifim = sequência(entrada[posição:], padrão)
if achou > 0:
achados += 1
posição += ifim + 1
fim = posição - 1
else:
break
# Caso o padrão seja opcional, retorna achado 1, mas inicio e fim -1
# para que verifica_padrão continue procurando
if qmin == 0 and achados == 0:
return 1, -1, -1
# Verifica se o número de achos está entre qmain e qmax
elif qmin <= achados <= qmax:
return achados, 0, fim
else:
return -1, -1, -1

def verifica_padrão(entrada, padrões):

posição = 0
for padrão in padrões:
achou, _, fim = padrão(entrada[posição:])
if achou > 0:
posição += fim + 1

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 273
else:
return -1, -1, -1
return 1, 0, posição - 1

entradas = [
"(((---)))", # Padrão encontrado
"(((--)))", # Padrão não encontrado
"(\----)", # Padrão não encontrado
"\----", # Padrão não encontrado
"((--))", # Padrão não encontrado
"<(((--)))>", # Padrão encontrado
"<<(((--)))>>", # Padrão encontrado
"<<(((---)))>>", # Padrão encontrado
"<<((--))>> <(((---)))> (((---))) ((((\----))))", # Padrão encontrado
duas vezes
]
# O padrão é uma sequência de caracteres que podem ser opcionais
# < zero ou até duas vezes
# ( três ou até quatro vezes
# - duas ou até três vezes
# ) três ou até quatro vezes
# > zero ou até duas vezes
# Você pode criar outros padrões para testar a função sequências
padrão = [
partial(sequências, padrão="<", qmin=0, qmax=2),
partial(sequências, padrão="(", qmin=3, qmax=4),
partial(sequências, padrão="-", qmin=2, qmax=3),
partial(sequências, padrão=")", qmin=3, qmax=4),
partial(sequências, padrão=">", qmin=0, qmax=2),
]

for entrada in entradas:

print("Entrada:", entrada)
achado = False
posição = 0
while posição < len(entrada):
achou, início, fim = verifica_padrão(entrada[posição:], padrão)
if achou > 0:
print(f"Padrão nas posições: {posição+início} a {posição+fim}
", end="")
print("Padrão:", entrada[posição + início : posição + fim + 1])
achado = True
posição += fim + 1
else:
posição += 1
if not achado:
print("Nenhum padrão encontrado na entrada")
print()

Atualização do 23 de novembro de 2024 [Link]

274 Exercı́cios resolvidos — 4� ediçã o
Exercício 12-06
Crie uma função usando verifica_padrão que valide números de celulares. Um celular tem 9
dígitos depois do DDD. Por exemplo: (92)99812-1103.

# Funções número, sequência e verifica padrão da listagem 12.5

from functools import partial

def número(entrada, qmin, qmax):

num = 0
for caractere in entrada:
if [Link]():
num += 1
else:
break
if qmin <= num <= qmax:
return num, 0, num - 1
else:
return -1, -1, -1

def sequência(entrada, padrão):

posição, posição_max = 0, len(padrão)
for caractere in entrada:
if caractere == padrão[posição]:
posição += 1 # Caracteres iguais, testa o próximo caractere
else:
break # Saiu da sequência
if posição == posição_max: # Achou toda a sequência
return 1, 0, posição - 1
return -1, -1, -1

def verifica_padrão(entrada, padrões):

posição = 0
for padrão in padrões:
achou, _, fim = padrão(entrada[posição:])
if achou > 0:
posição += fim + 1
else:
return -1, -1, -1
return 1, 0, posição - 1

def numero_celular(entrada):
padrão = [
partial(sequência, padrão="("),
partial(número, qmin=2, qmax=3),
partial(sequência, padrão=")"),
partial(número, qmin=5, qmax=5),

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 275
partial(sequência, padrão="-"),
partial(número, qmin=4, qmax=4),
]
achou, _, _ = verifica_padrão(entrada, padrão)
return achou > 0

entradas = [
"(92)99999-9999", # Sim
"(11)99999-999", # Não
"(2)99999-9999", # Não
"(12)9999999999", # Não
"(312)9999999999", # Não
"(312)99999-9999", # Sim
]

for entrada in entradas:

print(f"{entrada}: é um celular? {'Sim' if numero_celular(entrada)
else 'Não'}")

Atualização do 23 de novembro de 2024 [Link]

276 Exercı́cios resolvidos — 4� ediçã o
Exercício 12-07
Escreva um programa que valide a entrada de dados do usuário. O programa deve aceitar
números de CPF no seguinte formato: 999.999.999-99, em que cada 9 representa um dígito.
Exija os pontos e o traço no final, verificando a correta quan�dade de dígitos.

# Verifica se entrada é um CPF válido, ou seja:

# Uma sequência no formato 999.999.999-99
# Esta função não faz validação de dígito verificador
import re

CPF_RE = r"^\d{3}\.\d{3}\.\d{3}-\d{2}$"

def cpf(entrada):
return bool([Link](CPF_RE, entrada))

entradas = [
"123.456.789-01", # Sim
"123456.789-01", # Não
"123.456.78901", # Não
"23.456.789-01", # Não
"123.456.78-01", # Não
"999.999.999-99", # Sim
]

for entrada in entradas:

print(f"{entrada}: é um CPF? {'Sim' if cpf(entrada) else 'Não'}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 277
Exercício 12-08
Escreva um programa que valide a entrada de dados do usuário. O programa deve aceitar
números de CNPJ no seguinte formato: 99.999.999/9999-99, em que cada 9 representa um
dígito. Exija os pontos e o traço no final, verificando a correta quan�dade de dígitos.

# Funções número, sequência e verifica padrão da listagem 12.5

import re

CNPJ_RE = r"^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$"

# Verifica se entrada é um CNPJ válido, ou seja:

# Uma sequência no formato 99.999.999/9999-99
def cnpj(entrada):
return bool([Link](CNPJ_RE, entrada))

entradas = [
"12.345.678/9012-34", # Sim
"12.345.678-9012-34", # Não
"12.345.678.9012-34", # Não
"2.345.678/9012-34", # Não
"12.345.678/9012-4", # Não
"99.999.999/9999-99", # Sim
]

for entrada in entradas:

print(f"{entrada}: é um CNPJ? {'Sim' if cnpj(entrada) else 'Não'}")

Atualização do 23 de novembro de 2024 [Link]

278 Exercı́cios resolvidos — 4� ediçã o
Exercício 12-09
Escreva um programa que valide a entrada de dados do usuário. Tente achar um número
válido de CPF ou de CNPJ como definido nos exercícios anteriores. Exiba uma mensagem
dizendo se o número é válido e se este é um CNPJ ou um CPF.

# Funções número, sequência e verifica padrão da listagem 12.5

# Função cpf do exercício 12.07
# Função cnpj do exercício 12.08
import re

CPF_RE = r"^\d{3}\.\d{3}\.\d{3}-\d{2}$"
CNPJ_RE = r"^\d{2}\.\d{3}\.\d{3}/\d{4}-\d{2}$"

def cpf(entrada):
return bool([Link](CPF_RE, entrada))

# Verifica se entrada é um CNPJ válido, ou seja:

# Uma sequência no formato 99.999.999/9999-99
def cnpj(entrada):
return bool([Link](CNPJ_RE, entrada))

entradas = [
"12.345.678/9012-34", # CNPJ válido
"12.345.678-9012-34", # Inválido
"99.999.999/9999-99", # CNPJ válido
"123.456.789-01", # CPF válido
"23.456.789-01", # Inválido
"999.456.789-01", # CPF válido
]

for entrada in entradas:

print(
f"{entrada}:\né um CNPJ? {'Sim' if cnpj(entrada) else 'Não'}\né um
CPF? {'Sim' if cpf(entrada) else 'Não'}\n"
)

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 279
Exercício 12-10
Escreva uma função que aceite preços em reais. O programa deve ignorar espaços em branco
e aceitar valores prefixados com R$ ou não (com r ou R). O usuário deve entrar valores
corretamente formatados com o ponto separando os milhares e a vírgula, os centavos. Se o
usuário digitar centavos, estes devem ter dois dígitos. Valores válidos:

R$500
R$500
R$500,10
R$7.312,10

import re
REAIS_RE = r"^(([rR]\$)?(((\d{1,3}\.)?(\d{3}\.)*?\d{3})|(\d{1,3}))(,
\d{2})?)$"
# ^ - Do começo da string
# ( - Grupo da parte direita da expressão, antes da vírgula
# ([rR]\$)? - Opcionalmente pode ter o R$
# ( - Grupo da parte inteira
# ((\d{1,3}\.)?(\d{3}\.)*?\d{3}) - Grupo da parte inteira com pontos
separando os milhares
# Necessária para garantir que as partes entre os pontos tem 3 dígitos,
salvo a primeira
# | - ou
# (\d{1,3}) - Grupo da parte inteira sem pontos
# ) - Grupo da parte direita
# (,\d{2})? - Opcionalmente pode ter a parte decimal
# )$ - Até o fim da string

def limpa_espacos(entrada):
return [Link](" ", "")

def reais(entrada):
# É mais fácil limpar os espaços antes de fazer a validação,
# pois a expressão regular já é bem complexa
# Lembre-se: você não precisa usar regex em tudo!
entrada = limpa_espacos(entrada)
return bool([Link](REAIS_RE, entrada))

entradas = [
"R$ 1.234,56", # Sim
"r$ 1.234,56", # Sim
"r$1.234,56", # Sim
"r$12.123.234,56", # Sim
"1.234,56", # Sim
"R$1.234,56", # Sim
"r$234,56", # Sim

Atualização do 23 de novembro de 2024 [Link]

280 Exercı́cios resolvidos — 4� ediçã o
"R$234,56", # Sim
"234,56", # Sim
"r$234", # Sim
"R$234", # Sim
"R$2", # Sim
"R$23", # Sim
"234", # Sim
"34", # Sim
"4", # Sim
"r$234,4", # Não - Centavos tem que ter 2 dígitos
"R$234,4", # Não - Centavos tem que ter 2 dígitos
"R$1234,4", # Não - Sem o . para separar os milhares
"r$1234,4", # Não- Sem o . para separar os milhares
"r$1234.12,4", # Não - Uso incorreto do separador de milhares (.)
"r$1.24,56", # Não - Irregular, apenas dois números depois do .
]

for entrada in entradas:

print(f"{entrada}: {reais(entrada)}")

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 281
Exercício 13-01
Modifique o programa 13.7 para gravar e carregar o desenho em formato JSON. Você pode
percorrer os objetos do canvas e guardar a forma, as coordenadas e as cores escolhidas.

Exercício sem resposta. Por favor aguarde.

Atualização do 23 de novembro de 2024 [Link]

282 Exercı́cios resolvidos — 4� ediçã o
Exercício 13-02
Modifique o programa anterior e grave a imagem no formato SVG. O formato SVG é um
arquivo texto, que segue um formato bem definido.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<svg width="190mm" height="63mm" viewBox="0 0 190 63" version="1.1"
id="svg1" xmlns="[Link] xmlns:svg="[Link]
2000/svg">
<g id="layer1">
<rect style="fi ll:#cccccc;stroke:#000000;stroke-width:0.264583"
id="rect1" width="42.451897" height="29.063223" x="14.858164"
y="16.001099" />
<ellipse style="fi ll:#cccccc;stroke:#000000;stroke-width:0.264583"
id="path1" cx="93.067612" cy="18.940079" rx="15.837823" ry="12.082462" />
<path style="fi ll:none;stroke:#000000;stroke-width:0.264583px;
strokelinecap:butt;stroke-linejoin:miter;stroke-opacity:1" d="m
172.90984,16.654206 -54.69763,37.5536" id="path2" />
</g>
</svg>

Que desenha a imagem mostrada na Figura 13.14.

Exercício sem resposta. Por favor aguarde.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 283
Exercício 13-03
Modifique o código de [Link] (programa 13.12) para validar as datas ao editar ou
adicionar novos links. Exiba uma mensagem de erro caso a data seja inválida.

Exercício sem resposta. Por favor aguarde.

Atualização do 23 de novembro de 2024 [Link]

284 Exercı́cios resolvidos — 4� ediçã o
Exercício 13-04
Modifique o código de [Link] (programa 13.12) para não aceitar URLs em branco. Exiba
uma mensagem de erro caso data seja inválida.

Exercício sem resposta. Por favor aguarde.

[Link] Atualização do 23 de novembro de 2024

Exercı́cios resolvidos — 4� ediçã o 285
Exercício 13-05
Modifique o código de [Link] (programa 13.12) para aceitar somente URLs iniciando por
h�p:// ou h�ps://.

Exercício sem resposta. Por favor aguarde.

Atualização do 23 de novembro de 2024 [Link]

286 Exercı́cios resolvidos — 4� ediçã o
Exercício 13-06
Modifique o programa 13.13 para ler e gravar dados de um banco de dados. Modificando a
classe GerenteDeSites ou criando outra, você deve facilmente poder trocar o
armazenamento de JSON para um banco de dados como o Sqlite.

Exercício sem resposta. Por favor aguarde.

[Link] Atualização do 23 de novembro de 2024