Desafios Python 001–005

# Desafio 001
print("Olá, Mundo!")
# Desafio 002
nome = input("Digite seu nome: ")
print(f"É um prazer te conhecer, {nome}!")
# Desafio 003
try:
n1 = int(input("Digite o primeiro número: "))
n2 = int(input("Digite o segundo número: "))
soma = n1 + n2
print(f"A soma entre {n1} e {n2} é igual a {soma}.")
except ValueError:
print("Entrada inválida.")
# Desafio 004
valor = input("Digite algo: ")
print("-" * 30)
print("Analisando...")
print(f"Tipo: {type(valor)}")
print(f"Só tem espaços? {[Link]()}")
print(f"É número? {[Link]()}")
print(f"É alfabético? {[Link]()}")
print(f"É alfanumérico? {[Link]()}")
print(f"Maiúsculas? {[Link]()}")
print(f"Minúsculas? {[Link]()}")
print(f"Capitalizada? {[Link]()}")
print("-" * 30)
# Desafio 005
try:
numero = int(input("Digite um número inteiro: "))
antecessor = numero - 1
sucessor = numero + 1
print(f"O número digitado foi {numero}.")
print(f"Seu antecessor é {antecessor}.")
print(f"Seu sucessor é {sucessor}.")
except ValueError:
print("Entrada inválida.")
Desafios e Exercícios Python
# Desafio 005
Lê um número inteiro, calcula e exibe seu sucessor e antecessor.
try:
numero = int(input("Digite um número inteiro: "))
antecessor = numero - 1
sucessor = numero + 1
print(f"O número digitado foi {numero}.")
print(f"Seu antecessor é {antecessor}.")
print(f"Seu sucessor é {sucessor}.")
except ValueError:
print("Entrada inválida. Por favor, digite um número inteiro.")
# Desafio 007
Lê as duas notas de um aluno, calcula e exibe a média.
try:
nota1 = float(input("Digite a primeira nota do aluno: "))
nota2 = float(input("Digite a segunda nota do aluno: "))
 media = (nota1 + nota2) / 2
print(f"A primeira nota foi {nota1} e a segunda nota foi {nota2}.")
print(f"A média do aluno é: {media}")
except ValueError:
print("Entrada inválida. Por favor, digite notas válidas.")
# Desafio 008
Lê um valor em metros e converte para centímetros e milímetros.
try:
metros = float(input("Digite um valor em metros: "))
centimetros = metros * 100
milimetros = metros * 1000
print(f"O valor digitado é {metros} metros.")
print(f"Isso equivale a {centimetros:.2f} centímetros.")
print(f"Isso equivale a {milimetros:.2f} milímetros.")
except ValueError:
print("Entrada inválida. Por favor, digite um valor numérico.")
# Exercício Python #009
Tabuada de 1 a 10.
try:
numero = int(input("Digite um número inteiro para ver a sua tabuada:
"))
print("-" * 15)
print(f"TABUADA DE {numero}")
print("-" * 15)
for i in range(1, 11):
resultado = numero * i
print(f"{numero} x {i:2} = {resultado}")
print("-" * 15)
except ValueError:
print("Entrada inválida. Por favor, digite um número inteiro.")
# Exercício Python #010
Converte Reais para Dólares.
COTAÇÃO_DOLAR = 5.00
try:
reais = float(input("Quanto dinheiro você tem na carteira (em R$)?
"))
dolares = reais / COTAÇÃO_DOLAR
print(f"Com R$ {reais:.2f} você pode comprar US$ {dolares:.2f}.")
except ValueError:
print("Entrada inválida. Por favor, digite um valor numérico.")
# Exercício Python #011
Calcula área da parede e quantidade de tinta.
RENDIMENTO_TINTA = 2.0
try:
largura = float(input("Digite a largura da parede em metros: "))
altura = float(input("Digite a altura da parede em metros: "))
area = largura * altura
tinta_necessaria = area / RENDIMENTO_TINTA
print(f"Sua parede tem área de {area:.2f}m².")
print(f"Será necessário {tinta_necessaria:.2f} litros de tinta.")
except ValueError:
print("Entrada inválida. Por favor, digite valores numéricos.")
# Exercício Python #012
Calcula preço com desconto de 5%.
 PERCENTUAL_DESCONTO = 0.05
try:
preco_original = float(input("Digite o preço original: "))
valor_desconto = preco_original * PERCENTUAL_DESCONTO
novo_preco = preco_original - valor_desconto
print(f"Novo preço: R$ {novo_preco:.2f}")
except ValueError:
print("Entrada inválida.")
# Exercício Python #013
Calcula aumento de 15%.
PERCENTUAL_AUMENTO = 0.15
try:
salario = float(input("Digite o salário: "))
novo_salario = salario * (1 + PERCENTUAL_AUMENTO)
print(f"Novo salário: R$ {novo_salario:.2f}")
except ValueError:
print("Entrada inválida.")
# Exercício Python #014
Converte Celsius para Fahrenheit.
try:
celsius = float(input("Digite a temperatura: "))
fahrenheit = (celsius * 9/5) + 32
print(f"{celsius:.1f}°C = {fahrenheit:.1f}°F")
except ValueError:
print("Entrada inválida."
: import random

def jogo_adivinhacao():
# O computador pensa em um número entre 0 e 5
numero_secreto = [Link](0, 5)

print("Bem-vindo ao Jogo da Adivinhação!")

print("O computador pensou em um número entre 0 e 5. Tente
adivinhar!")

# Pede ao usuário para tentar adivinhar

try:
palpite = int(input("Digite o seu palpite (entre 0 e 5): "))

# Verifica se o palpite está dentro do intervalo

if 0 <= palpite <= 5:
# Compara o palpite com o número secreto
if palpite == numero_secreto:
print(f"Parabéns! Você venceu! O número era realmente o
{numero_secreto}.")
else:
print(f"Que pena! Você perdeu! O número que o computador
pensou foi o {numero_secreto}, não o {palpite}.")
else:
print("Seu palpite não está no intervalo de 0 a 5. Tente
novamente.")

except ValueError:
print("Entrada inválida. Por favor, digite um número inteiro.")
if _name_ == "_main_":
jogo_adivinhacao()
velocidade = float(input('Qual é a velocidade atual do carro? '))
if velocidade > 80:
multa = (velocidade - 80) * 7
print(f'MULTADO! Você excedeu o limite permitido que é de 80Km/h')
print(f'Você deve pagar uma multa de R${multa:.2f}!')
else:
print('Tenha um bom dia! Dirija com segurança!')
numero = int(input("Digite um número inteiro: "))
if numero % 2 == 0:
print(f"O número {numero} é PAR.")
else:
print(f"O número {numero} é ÍMPAR.")
Obter o valor da casa, o salário do comprador e o número de anos de
pagamento. Estas são as variáveis iniciais necessárias para o cálculo.
.CM8kHf text{fill:var(--m3c11)}.CM8kHf{font-
size:1.15em}.j86kh{display:inline-block;max-width:100%} Step
2: Calcular a prestação mensal Calcular o número total
de meses (\(\text{meses}=\text{anos}\times 12\)) e, em seguida, a
prestação mensal (\(\text{prestacao}=\text{valor\_casa}/\text{meses}\)).
Step 3: Calcular o limite de 30% do salário Determinar o
valor máximo permitido para a prestação, que é de 30% do salário do
comprador (\(\text{limite}=\text{salario}\times 0.30\)).
Step 4: Avaliar a aprovação do empréstimo Comparar a
prestação mensal com o limite. Se \(\text{prestacao}\le \text{limite}\),
o empréstimo é aprovado. Caso contrário, é negado.
Answer: A lógica do programa envolve a entrada de dados,
cálculos matemáticos simples e uma estrutura condicional (if/else) para
determinar o resultado, com a mensagem final informando se o empréstimo
foi aprovado ou negado.
: num = int(input('Digite um número inteiro: '))
base = int(input('Escolha uma das bases para conversão:\n[ 1 ] converter
para BINÁRIO\n[ 2 ] converter para OCTAL\n[ 3 ] converter para
HEXADECIMAL\nSua opção: '))
num1 = int(input("Digite o primeiro número inteiro: "))
num2 = int(input("Digite o segundo número inteiro: "))
import random

opcoes = ["pedra", "papel", "tesoura"]

while True:
escolha_usuario = input("Escolha pedra, papel ou tesoura (ou 'sair'
para terminar): ").lower()
if escolha_usuario == 'sair':
break
if escolha_usuario not in opcoes:
print("Escolha inválida. Tente novamente.")
continue

escolha_computador = [Link](opcoes)

print(f"Você escolheu {escolha_usuario}.")

 print(f"O computador escolheu {escolha_computador}.")

if escolha_usuario == escolha_computador:
print("Resultado: Empate!")
elif (escolha_usuario == "pedra" and escolha_computador == "tesoura")
or \
(escolha_usuario == "tesoura" and escolha_computador == "papel")
or \
(escolha_usuario == "papel" and escolha_computador == "pedra"):
print("Resultado: Você venceu!")
else:
print("Resultado: O computador venceu!")
import time

for i in range(10, -1, -1):

print(i)
[Link](1)
print("🎆 BUM! POOOW! 🎆")
import time

for i in range(10, -1, -1):

print(i)
[Link](1)
print("🎆 BUM! POOOW! 🎆")
import time

for i in range(10, -1, -1):

print(i)
[Link](1)
for i in range(10, -1, -1):
print(i)
: Step 1: Iteração
Percorrer os números inteiros no intervalo de 1 a 50.
Step 2: Condição de paridade
Para cada número, verificar se é par usando o operador de módulo. Um
número é par se o resto da divisão por 2 for zero.
Step 3: Impressão condicional
Se a condição de paridade for verdadeira, imprimir o número.
Inicializa-se uma variável para armazenar a soma total.
\(\text{soma}=0\) .j86kh{display:inline-block;max-width:100%}
Step 2: Iterar pelos números no intervalo Percorre-se
cada número \(\text{c}\) no intervalo de 1 a 500 (inclusive).
\(\text{para\ c\ em\ intervalo}(1,501):\) Step 3:
Verificar se o número é ímpar e múltiplo de três Dentro
do loop, verifica-se se o número atual é ímpar (\(\text{c}\%2==1\)) e se
é múltiplo de três (\(\text{c}\%3==0\)). \(\text{se\
c}\%2==1\text{\ e\ c}\%3==0:\) Step 4: Adicionar o
número à soma Se ambas as condições forem verdadeiras, o
número é adicionado à variável de soma.
\(\text{soma}=\text{soma}+\text{c}\) Step 5: Exibir o
resultado final Após a conclusão do loop, o valor final
da soma é o resultado do exercício.
 Inicia-se um loop while True para garantir que a entrada seja solicitada
repetidamente até ser válida. Dentro do loop, solicita-se o sexo ('M' ou
'F') e converte-se para maiúsculo para facilitar a validação.
sexo = str(input('Informe seu sexo [M/F]: ')).strip().upper()
Step 2: Validar a entrada
Verifica-se se o sexo informado é 'M' ou 'F'. Se for, o loop é
interrompido com break. Caso contrário, uma mensagem de erro é exibida e
o loop continua.
while True:
sexo = str(input('Informe seu sexo [M/F]: ')).strip().upper()
if sexo in 'MF':
break
else:
print('Dados inválidos. Por favor, informe seu sexo: ')
Step 3: Exibir a resposta final
Após a validação e a saída do loop, exibe-se a mensagem de sucesso com o
sexo registrado.
print(f'Sexo {sexo} registrado com sucesso.')
: import random

numero_secreto = [Link](0, 10)

palpite = None
tentativas = 0

print("Bem-vindo ao Jogo da Adivinhação v2.0!")

print("Tente adivinhar o número que o computador pensou, entre 0 e 10.")

while palpite != numero_secreto:

try:
palpite = int(input("Qual é o seu palpite? "))
tentativas += 1
if palpite < numero_secreto:
print("Mais... Tente novamente.")
elif palpite > numero_secreto:
print("Menos... Tente novamente.")
except ValueError:
print("Entrada inválida. Por favor, digite um número inteiro.")

print(f"Parabéns! Você acertou em {tentativas} tentativas.")

numero = int(input("Digite um número para calcular o fatorial: "))
fatorial = 1
if numero < 0:
print("Fatorial não pode ser calculado para números negativos.")
elif numero == 0:
print("O fatorial de 0 é 1.")
else:
for i in range(1, numero + 1):
fatorial = fatorial * i
print(f"O fatorial de {numero} é {fatorial}.")
sequência de Fibonacci é uma série de números em que cada número é a
soma dos dois anteriores. Para este exercício, considera-se que a
sequência começa com 0 e 1. .CM8kHf text{fill:var(--
m3c11)}.CM8kHf{font-size:1.15em}.j86kh{display:inline-block;max-
width:100%} Step 2: Lendo a entrada O
programa deve solicitar ao usuário que insira um número inteiro \(N\),
que determinará quantos elementos da sequência serão exibidos.
Step 3: Implementando a lógica Variáveis de controle são
usadas para armazenar os dois termos anteriores e um contador para o
número de termos já exibidos. Um loop while é executado até que \(N\)
termos tenham sido mostrados. Dentro do loop, o próximo termo é
calculado, os termos anteriores são atualizados e o contador é
incrementado. Step 4: Exibindo o resultado
Cada termo é impresso sequencialmente, com uma formatação simples para
indicar a progressão da sequência.
Step 1: Inicialização de variáveis
Inicializar variáveis para armazenar a soma total, a contagem de números,
o maior valor e o menor valor.
Step 2: Loop de entrada e processamento
Usar um loop while para ler números, acumular a soma, contar os números e
atualizar os valores de maior e menor. O loop continua se o usuário
digitar 'S' ou 's'.
Step 3: Cálculo da média e exibição dos resultados
Após sair do loop, calcular a média e exibir todos os resultados.
Answer:
O código Python para resolver o exercício é:
soma = 0
quantidade = 0
maior = 0
menor = 0
continuar = 'S'
while continuar in 'Ss':
num = int(input('Digite um número inteiro: '))
soma += num
quantidade += 1
if quantidade == 1:
maior = menor = num
else:
if num > maior:
maior = num
if num < menor:
menor = num
continuar = str(input('Quer continuar? [S/N] ')).upper().strip()
media = soma / quantidade
print(f'Você digitou {quantidade} números e a média foi {media}')
print(f'O maior valor foi {maior} e o menor foi {menor}')
count = 0
sum_numbers = 0
while True:
number = int(input("Digite um número inteiro (999 para parar): "))
if number == 999:
break
sum_numbers += number
count += 1
print(f"Foram digitados {count} números.")
print(f"A soma entre eles é {sum_numbers}.")
import random

vitorias_consecutivas = 0
while True:
jogador_numero = int(input("Digite um número: "))
jogador_escolha = str(input("Par ou Ímpar? [P/I]
")).strip().upper()[0]
computador_numero = [Link](0, 10)
soma = jogador_numero + computador_numero
resultado = ""

if soma % 2 == 0:
resultado = "PAR"
else:
resultado = "ÍMPAR"

print("-" * 30)
print(f"Você jogou {jogador_numero} e o computador
{computador_numero}. Total de {soma} DEU {resultado}")
print("-" * 30)

if (jogador_escolha == 'P' and resultado == 'PAR') or

(jogador_escolha == 'I' and resultado == 'ÍMPAR'):
print("Você VENCEU!")
vitorias_consecutivas += 1
print("Vamos jogar novamente...")
print("=" * 30)
else:
print("Você PERDEU!")
break

print("=" * 30)
print(f"GAME OVER! Você conquistou {vitorias_consecutivas} vitórias
consecutivas.")
total_maiores_18 = 0
total_homens = 0
total_mulheres_menos_20 = 0

while True:
idade = int(input('Idade: '))
sexo = ' '
while sexo not in 'MF':
sexo = str(input('Sexo [M/F]: ')).strip().upper()[0]

if idade >= 18:

total_maiores_18 += 1
if sexo == 'M':
total_homens += 1
if sexo == 'F' and idade < 20:
total_mulheres_menos_20 += 1

continuar = ' '

while continuar not in 'SN':
continuar = str(input('Quer continuar? [S/N]
')).strip().upper()[0]
if continuar == 'N':
 break

print(f'Total de pessoas com mais de 18 anos: {total_maiores_18}')

print(f'Total de homens cadastrados: {total_homens}')
print(f'Total de mulheres com menos de 20 anos:
{total_mulheres_menos_20}')
[17/11, 22:22] +558197942553: nome_completo = input("Digite seu nome
completo: ")
[17/11, 22:22] +558197942553: numero = int(input("Informe um número entre
0 e 9999: "))

# Verificações básicas de entrada (opcional, mas recomendado)

if 0 <= numero <= 9999:
unidade = numero % 10
dezena = (numero // 10) % 10
centena = (numero // 100) % 10
milhar = (numero // 1000) % 10

print(f"Analisando o número {numero}:")

print(f"Unidade: {unidade}")
print(f"Dezena: {dezena}")
print(f"Centena: {centena}")
print(f"Milhar: {milhar}")
else:
print("Número fora do intervalo permitido.")
cidade = input('Digite o nome da cidade: ').strip()
print(cidade[:5].upper() == 'SANTO')
[17/11, 22:22] +558197942553: extenso = ('zero', 'um', 'dois', 'três',
'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove', 'dez', 'onze', 'doze',
'treze', 'catorze', 'quinze', 'dezasseis', 'dezassete', 'dezoito',
'dezanove', 'vinte')

while True:
num = int(input('Digite um número entre 0 e 20: '))
if 0 <= num <= 20:
break
print('Tente novamente. ', end='')

print(f'Você digitou o número {extenso[num]}.')

times = ('Flamengo', 'Palmeiras', 'Atlético-MG', 'Grêmio', 'São Paulo',
'Internacional', 'Fluminense', 'Santos', 'Corinthians', 'Bahia',
'Bragantino', 'Athletico-PR', 'Ceará', 'Cuiabá', 'Atlético-GO',
'Sport', 'Fortaleza', 'Vasco da Gama', 'Goiás', 'Coritiba') #
Definindo a tupla de palavras (sem acentos, conforme solicitado)
palavras = ('aprender', 'programar', 'linguagem', 'python', 'curso',
'gratis',
'estudar', 'praticar', 'trabalhar', 'mercado', 'programador',
'futuro')

# Iterando sobre cada palavra na tupla

for p in palavras:
print(f'\nNa palavra *{[Link]()}* temos as vogais:', end=' ')
# Iterando sobre cada letra da palavra para verificar se é vogal
for letra in p:
 if [Link]() in 'aeiou':
print(letra, end=' ')
programa deve usar um laço de repetição para solicitar ao usuário que
digite 5 valores numéricos, armazenando cada um em uma lista.
Step 2: Identificar maior e menor
Após a coleta, o programa deve determinar o maior e o menor valor
presentes na lista.
Step 3: Encontrar posições
Em seguida, o programa deve iterar pela lista novamente (ou usar métodos
integrados) para encontrar todos os índices (posições) onde o maior e o
menor valores ocorrem.
Step 4: Exibir resultado
Finalmente, o programa deve imprimir a lista completa de valores, o maior
valor com suas posições e o menor valor com suas posições.
Answer:
A resposta é o programa Python que implementa a lógica acima. Para a
entrada de valores como 5, 2, 9, 2, 5, a saída do programa seria:
Você digitou os valores
O maior valor digitado foi 9 nas posições
[17/11, 22:23] +558197942553: valores_unicos = []
while True:
### Step 2: Solicitar um valor numérico ao usuário
try:
valor = int(input("Digite um valor numérico (ou 'sair' para
terminar): "))

### Step 3: Verificar se o valor já existe na lista

if valor not in valores_unicos:
valores_unicos.append(valor)
print("Valor adicionado com sucesso!")
else:
print("Esse valor já foi adicionado anteriormente. Não será
incluído novamente.")
except ValueError:
### Step 4: Permitir que o usuário saia do loop
if input("Deseja sair do programa? (s/n): ").lower() == 's':
break
else:
print("Entrada inválida. Tente novamente com um número
inteiro.")

### Step 5: Ordenar a lista de valores únicos

valores_unicos.sort()

### Step 6: Exibir os valores únicos em ordem crescente

print("-" * 30)
print(f"Você digitou os valores únicos: {valores_unicos}")
[17/11, 22:23] +558197942553: Cria-se uma lista vazia para armazenar os
números e inicia-se um loop para entrada contínua de dados.
Step 2: Ler e validar a entrada
Dentro do loop, solicita-se um número ao usuário. Converte-se a entrada
para um valor numérico e adiciona-se à lista. Implementa-se uma condição
de parada, como digitar 'sair'.
Step 3: Exibir a lista final
Após o loop ser interrompido, a lista completa de números é exibida.
Answer:
numeros = []
while True:
try:
entrada = input("Digite um número (ou 'sair' para terminar): ")
if [Link]() == 'sair':
break
numero = float(entrada)
[Link](numero)
except ValueError:
print("Entrada inválida. Por favor, digite um número ou 'sair'.")
print(f"A lista de números é: {numeros}")
[17/11, 22:23] +558197942553: pessoas = []
dados_temporarios = []
while True:
dados_temporarios.append(str(input('Nome: ')))
dados_temporarios.append(float(input('Peso: ')))
[Link](dados_temporarios[:])
dados_temporarios.clear()
continuar = str(input('Deseja continuar? [S/N] ')).strip().upper()[0]
if continuar == 'N':
break
print('-=' * 30)
print(f'Os dados cadastrados foram: {pessoas}')
[17/11, 22:23] +558197942553: Cria-se a estrutura da matriz e preenche-se
com valores inteiros fornecidos pelo usuário via teclado.
matriz = [,,]
for i in range(3):
for j in range(3):
matriz[i][j] = int(input(f"Digite um valor para [{i}, {j}]: "))
Step 2: Mostrar a matriz formatada
Exibe-se a matriz na tela, garantindo a formatação correta com
alinhamento e separadores visuais.
print("-=" * 15)
for i in range(3):
for j in range(3):
print(f"[{matriz[i][j]:^5}]", end="")
print()
print("-=" * 15)
Answer:
**matriz = [,,]
for i in range(3):
for j in range(3):
matriz[i][j] = int(input(f"Digite um valor para [{i}, {j}]: "))
print("-=" * 15)
for i in range(3):
for j in range(3):
print(f"[{matriz[i][j]:^5}]", end="")
print()
print("-=" * 15)**
A imagem apresenta o título do exercício e uma breve descrição para
"aprimorar o desafio anterior". No entanto, o enunciado completo do
exercício, incluindo o "desafio anterior" e os requisitos específicos
para a criação da matriz correta, não está visível na imagem.
Step 2: Informação Faltante
Sem o enunciado completo, não é possível determinar a lógica exata ou os
passos necessários para a resolução do problema de programação em Python.
nome = input("Nome do aluno: ")
media = float(input(f"Média de {nome}: "))
aluno = {'nome': nome, 'media': media}

if media >= 7:
aluno['situacao'] = 'Aprovado'
elif media >= 5:
aluno['situacao'] = 'Recuperação'
else:
aluno['situacao'] = 'Reprovado'

print("-" * 30)
for chave, valor in [Link]():
print(f" - {[Link]()}: {valor}")
import random
import time

print("Valores sorteados:")
jogadores = {'jogador1': [Link](1, 6), 'jogador2':
[Link](1, 6), 'jogador3': [Link](1, 6), 'jogador4':
[Link](1, 6)}
for k, v in [Link]():
print(f"O {k} tirou {v}")
[Link](0.5)

ranking = sorted([Link](), key=lambda item: item[1],

reverse=True)

print("-=" * 30)
print(" == RANKING DOS JOGADORES ==")
for i, v in enumerate(ranking):
print(f" {i+1}º lugar: {v[0]} com {v[1]} pontos.")
[Link](0.5)

print(f"-=" * 30)
print(f"O vencedor foi o *{ranking[0][0]}* com *{ranking[0][1]}*
pontos!")
Um programa Python pode ser criado para ler o nome, ano de nascimento e
carteira de trabalho (CTPS) do usuário. A idade pode ser calculada como o
ano atual menos o ano de nascimento. Esses dados iniciais podem ser
armazenados em um dicionário. Step 2: Verificação da
CTPS e dados adicionais Se o número da CTPS for
diferente de zero, o programa deve solicitar o ano de contratação e o
salário. Esses novos dados também serão adicionados ao dicionário.
Step 3: Cálculo da aposentadoria Para calcular a idade
de aposentadoria, pode-se assumir que são necessários 35 anos de
contribuição. O ano de aposentadoria pode ser determinado adicionando 35
anos ao ano de contratação. A idade de aposentadoria é então o ano de
aposentadoria menos o ano de nascimento. .f5cPye .WaaZC:first-of-type
.rPeykc.uP58nb:first-child{font-size:var(--m3t3);line-height:var(--
m3t4);font-weight:400 !important;letter-spacing:normal;margin:0 0 10px
0}.rPeykc.uP58nb{font-size:var(--m3t5);font-weight:600;line-height:var(--
m3t6);margin:20px 0 10px 0}.f5cPye ul{font-size:var(--m3t7);line-
height:var(--m3t8);margin:10px 0 20px 0;padding-inline-start:16px}.f5cPye
.WaaZC:first-of-type ul:first-child{margin-top:0}.f5cPye ul.qh1nvc{font-
size:var(--m3t7);line-height:var(--m3t8)}.f5cPye li{padding-inline-
start:4px;margin-bottom:8px;list-style:inherit}.f5cPye li.K3KsMc{list-
style-type:none}.f5cPye ul>li:last-child,.f5cPye ol>li:last-child,.f5cPye
ul>.bsmXxe:last-child>li,.f5cPye ol>.bsmXxe:last-child>li{margin-
bottom:0}.CM8kHf text{fill:var(--m3c11)}.CM8kHf{font-
size:1.15em}.j86kh{display:inline-block;max-width:100%}
Exemplo de cálculo com dados hipotéticos (Ano atual: 2025): Ano de
Nascimento: 1990 Ano de Contratação: 2015 Idade atual: \(2025-1990=35\)
anos Ano de Aposentadoria: \(2015+35=2050\) Idade de Aposentadoria:
\(2050-1990=60\) anos
[17/11, 22:23] +558197942553: def area(largura, comprimento):
a = largura * comprimento
print(f'A área de um terreno {largura}x{comprimento} é de {a}m².')

# Programa principal
l = float(input('LARGURA (m): '))
c = float(input('COMPRIMENTO (m): '))
area(l, c)
[17/11, 22:23] +558197942553: def escreva(texto):
tamanho = len(texto) + 4
print('-' * tamanho)
print(f' {texto}')
print('-' * tamanho)

# Exemplos de uso:
escreva('Olá, Mundo!')
escreva('Python é incrível')
escreva('Um texto mais longo para testar o tamanho adaptável')
: def contador(inicio, fim, passo):
print(f'Contagem de {inicio} até {fim} de {passo} em {passo}:')
if passo < 0:
passo_ajustado = passo
elif passo == 0:
passo_ajustado = 1
else:
passo_ajustado = passo
if inicio < fim:
for i in range(inicio, fim + 1, passo_ajustado):
print(f'{i} ', end='')
elif inicio > fim:
for i in range(inicio, fim - 1, -passo_ajustado):
print(f'{i} ', end='')
else:
print(f'{inicio} ', end='')
print('FIM!')
# Três contagens através da função criada:
contador(1, 10, 1)
contador(10, 0, 2)
contador(0, 100, 10)
def maior(*num):
cont = 0
max_val = 0
print("-=" * 30)
print("Analisando os valores passados...")
for valor in num:
print(f"{valor} ", end="")
if cont == 0:
max_val = valor
else:
if valor > max_val:
max_val = valor
cont += 1
print(f"Foram informados {cont} valores.")
if cont == 0:
print(f"O maior valor informado é 0.")
else:
print(f"O maior valor informado foi {max_val}.")

# Programa principal com exemplos de uso

maior(2, 9, 4, 5, 7, 1)
maior(4, 7, 0)
maior(1, 2)
maior(6)
maior()
função fatorial() deve aceitar um número (n) e um parâmetro opcional
booleano show (padrão False). .CM8kHf text{fill:var(--
m3c11)}.CM8kHf{font-size:1.15em}.j86kh{display:inline-block;max-
width:100%} Passo 2: Calcular o fatorial
Usar um loop para calcular o fatorial de n (\(n!=n\times (n-1)\times
\dots \times 1\)). Passo 3: Exibir o processo (opcional)
Se show for True, imprimir a expressão do cálculo (\(n\times (n-1)\times
\dots \times 1=\text{resultado}\)) durante o loop. Passo
4: Retornar o resultado A função deve retornar o valor
final do fatorial. Answer: def
fatorial(n, show=False): """ Calcula o
Fatorial de um número. :param n: O número a ser
calculado. :param show: (Opcional) Mostrar ou não o
processo de cálculo. :return: O valor do Fatorial de um
número n. """ f = 1
for c in range(n, 0, -1): if show:
print(f'{c} x ' if c > 1 else f'{c} = ', end='') *
f = c return f # Exemplo de uso:
# print(fatorial(5, show=True)) # print(fatorial(5))
Define a função ficha que aceita dois parâmetros opcionais: nome e gols.
Atribui valores padrão ('<desconhecido>' e 0, respectivamente) para o
caso de nenhum valor ser fornecido.
Step 2: Tratamento de valores padrão
Dentro da função, usa-se uma f-string para formatar e imprimir a mensagem
com o nome e o número de gols do jogador, utilizando os valores recebidos
ou os padrões.
Step 3: Demonstração de uso
Abaixo da função, são mostrados exemplos de como chamar a função com
diferentes combinações de argumentos para demonstrar sua flexibilidade.
Answer:
def ficha(nome='<desconhecido>', gols=0):
print(f'O jogador {nome} marcou {gols} gol(s) no campeonato.')
Exemplos de uso:
ficha('Neymar', 30)
ficha(gols=10)
ficha(nome='Messi')
ficha()
def leiaInt(msg):
"""
-> Função para ler um número inteiro do console.
:param msg: A mensagem a ser exibida para o usuário.
:return: O valor inteiro digitado pelo usuário.
"""
while True:
try:
n = int(input(msg))
except (ValueError, TypeError):
print('\033[0;31mERRO: por favor, digite um número inteiro
válido.\033[m')
continue
except (KeyboardInterrupt):
print('\n\033[0;31mUsuário preferiu não digitar esse
número.\033[m')
return 0
else:
return n

# Programa principal
num = leiaInt('Digite um número: ')
print(f'O valor digitado foi {num}')
[17/11, 22:23] +558197942553: import moeda

p = 100
print(f'A metade de {p} é {[Link](p)}')
print(f'O dobro de {p} é {[Link](p)}')
print(f'Aumentando 10%, temos {[Link](p, 10)}')
print(f'Diminuindo 5%, temos {[Link](p, 5)}')
[17/11, 22:23] +558197942553: def aumentar(preco, taxa):
res = preco + (preco * taxa / 100)
return res

def diminuir(preco, taxa):

res = preco - (preco * taxa / 100)
return res

def dobro(preco):
res = preco * 2
return res

def metade(preco):
res = preco / 2
 return res

def moeda(preco, moeda='R$'):

return f'{moeda}{preco:.2f}'.replace('.', ',')

# Exemplo de uso:
# p = 100.50
# print(f'A metade de {moeda(p)} é {moeda(metade(p))}')
# print(f'O dobro de {moeda(p)} é {moeda(dobro(p))}')
# print(f'Aumentando 10% de {moeda(p)}, temos {moeda(aumentar(p, 10))}')
# print(f'Diminuindo 5% de {moeda(p)}, temos {moeda(diminuir(p, 5))}')
tarefa exige a modificação das funções previamente criadas no desafio
107 (como aumentar(), diminuir(), dobro() e metade()) para que aceitem um
parâmetro adicional opcional, por exemplo, formatar, com um valor padrão
de False.
Step 2: Implementando a Lógica de Formatação
Dentro de cada função, após a realização do cálculo matemático principal,
uma verificação condicional é necessária. Se o parâmetro formatar for
avaliado como True, o resultado calculado deve ser processado pela função
moeda() (assumida como existente a partir do desafio 108) antes de ser
retornado. Caso contrário, o valor numérico bruto é retornado
diretamente.
Step 3: Assumindo as Funções Auxiliares
Assume-se que a função moeda(valor) existe e retorna uma representação em
string do valor formatado como moeda (ex: R$ 10,00), e que as funções
originais do desafio 107 retornavam tipos numéricos (como float ou int).
def leiaInt(msg):
while True:
try:
n = int(input(msg))
except ValueError:
print('\033[0;31mERRO: por favor, digite um número inteiro
válido.\033[m')
continue
except KeyboardInterrupt:
print('\n\033[0;31mUsuário preferiu não digitar esse
número.\033[m')
return 0
else:
return n

def leiaFloat(msg):
while True:
try:
n = float(input(msg))
except ValueError:
print('\033[0;31mERRO: por favor, digite um número real
válido.\033[m')
continue
except KeyboardInterrupt:
print('\n\033[0;31mUsuário preferiu não digitar esse
número.\033[m')
return 0.0
else:
 return n

# Programa principal (exemplo de uso)

i = leiaInt('Digite um Inteiro: ')
f = leiaFloat('Digite um Real: ')
print(f'O valor inteiro digitado foi {i} e o real foi {f}')
import [Link]
import [Link]
def verificar_acessibilidade(url):
try:
[Link](url, timeout=5)
return True
except [Link]:
return False
import [Link]
import [Link]
def verificar_acessibilidade(url):
try:
[Link](url, timeout=5)
return True
except [Link]:
return False