Caso ainda não tenha utilizado, pesquise o quê é e como usar f-strings para exibir mensagens no comando print. Altere seus códigos para utilizar essa técnica. Neste caso, e apenas neste, não é necessário duplicar as respostas, basta alterar os algoritmos.

Passo 1

Você pediu para eu pesquisar o que são e como usar f-strings para exibir mensagens com o comando print e alterar meus códigos/algoritmos para utilizar essa técnica. Informações relevantes que você deu:
  • Deseja que eu use f-strings nos códigos.
  • Nesta solicitação, não é necessário duplicar respostas; basta alterar os algoritmos para usar f-strings.
    A partir daqui eu vou explicar o que são f-strings, mostrar como usá-las passo a passo e apresentar vários exemplos de conversão (antes → depois) para que você possa aplicar rapidamente na prova ou em exercícios.

Passo 2

O que é uma f-string?
  • Uma f-string é uma forma de formatar strings em Python, introduzida em Python 3.6, que permite colocar expressões Python diretamente dentro de literais de string.
  • A sintaxe básica: anteponha a letra f (ou F) antes das aspas da string e coloque as expressões entre chaves {}.
  • Vantagens principais: sintaxe curta e legível; evita concatenar com +; evita chamar str() manualmente; permite formatação inline (números, casas decimais, larguras).
    Exigência de versão:
  • Para usar f-strings você precisa de Python 3.6 ou superior.

Passo 3

Sintaxe e exemplos simples (explicando cada parte)
  • Forma básica:
name = "Ana"
age = 21
print(f"Meu nome é {name} e tenho {age} anos")
Explanação:
  • f"..." diz ao Python para avaliar expressões entre {}.
  • {name} é substituído pelo valor atual da variável name.
  • {age} é substituído pelo valor atual da variável age.
  • Não é preciso usar + nem str(age).

Passo 4

Converter prints comuns para f-strings (cenários usuais)
  • Concatenacão com + → f-string:
    Antes:
name = "João"
age = 30
print("Nome: " + name + ", idade: " + str(age))
Depois:
print(f"Nome: {name}, idade: {age}")
  • % formatting → f-string:
    Antes:
value = 3.14159
print("Valor: %.2f" % value)
Depois:
print(f"Valor: {value:.2f}")
  • str.format() → f-string:
    Antes:
a = 2
b = 3
print("Soma de {} e {} é {}".format(a, b, a+b))
Depois:
print(f"Soma de {a} e {b} é {a+b}")
Explicação detalhada:
  • Em {value:.2f}, value é a variável; :.2f é um especificador de formato que pede 2 casas decimais (veja o passo seguinte).

Passo 5

Formatadores úteis (o que cada parte significa)
  • Estrutura geral: {expressão:formato}
  • Exemplos e interpretação:
    • {x:.2f} → número float com 2 casas decimais.
    • {n:,} → inteiro com separador de milhares (ex.: 1,234,567).
    • {s:>10} → string alinhada à direita com largura 10 (preenche com espaços à esquerda).
    • {s:<10} → alinhada à esquerda.
    • {num:^8.1f} → centralizada em largura 8 com 1 casa decimal.
  • Exemplos:
price = 1234.567
print(f"Preço: R\({price:,.2f}")   # "Preço: R\) 1,234.57" (ou com vírgula dependendo do locale, mas comportamento padrão usa vírgula para separador de milhares em algumas versões/locale)
Nota prática:
  • Para imprimir com , como separador decimal na saída brasileira, normalmente se faz um replace ou usa locale — mas para a prova, o importante é saber :.2f e :, para milhares.

Passo 6

Expressões dentro das chaves e limitações
  • Você pode colocar expressões: {a + b}, {len(name)}, {math.sqrt(x)} (desde que importe math).
    Exemplo:
a = 5
b = 7
print(f"{a} + {b} = {a + b}")
  • Cuidado: não coloque declarações (como if ou for) diretamente dentro de {}; apenas expressões.
  • Não use \ dentro da expressão nas chaves — causa erro de sintaxe.
  • Você pode chamar funções: {func(x)} — permitido desde que a função exista no escopo.

Passo 7

Casos práticos em algoritmos e dicas para migrar (checklist)
  • Substitua print("x = " + str(x)) por print(f"x = {x}").
  • Substitua print("valor: {:.3f}".format(v)) por print(f"valor: {v:.3f}").
  • Em loops, use f-strings para imprimir índices e valores:
    Antes:
for i, val in enumerate(lista):
    print("i=" + str(i) + " val=" + str(val))
Depois:
for i, val in enumerate(lista):
    print(f"i={i} val={val}")
  • Ao criar mensagens longas com muitas variáveis, f-strings deixam a leitura mais fácil.

Passo 8

Exemplos de conversões de trechos de algoritmo (vários casos típicos)
  1. Soma e resultado formatado:
    Antes:
a = 2.3456
b = 1.1
s = a + b
print("Soma: " + str(round(s, 2)))
Depois:
a = 2.3456
b = 1.1
s = a + b
print(f"Soma: {s:.2f}")
  1. Relatório em loop:
    Antes:
for i in range(1, 4):
    print("Iteração " + str(i) + ": valor = " + str(i*i))
Depois:
for i in range(1, 4):
    print(f"Iteração {i}: valor = {i*i}")
  1. Dicionário/keys:
    Antes:
d = {"nome": "Maria", "idade": 25}
print("Nome: " + d["nome"] + ", idade: " + str(d["idade"]))
Depois:
d = {"nome": "Maria", "idade": 25}
print(f"Nome: {d['nome']}, idade: {d['idade']}")
Explicação do último exemplo:
  • Note que dentro de {} você pode usar d['nome']. As aspas simples dentro das chaves são válidas desde que a string f esteja delimitada por aspas duplas (ou vice-versa).

Passo 9

Casos especiais, erros comuns e soluções rápidas
  • Erro: SyntaxError por usar versão antiga do Python → verifique python --version.
  • Erro: querer usar chaves literais { ou } → duplique-as {{ ou }} para imprimir { ou }.
  • Exemplo:
print(f"Mostra chaves: {{x}}")  # Imprime: Mostra chaves: {x}
  • Evite expressões muito complexas nas chaves — prefira calcular antes em variáveis para deixar a string legível.
  • Prefixos combinados: você pode usar fr"..." ou rf"..." para combinar raw string e f-string (útil para regex), mas cuidado com ordens de prefixos e com escapes.

Passo 10

Pequeno guia rápido para aplicar na prova (passo a passo prático)
  1. Identifique prints que usam concatenação, % ou format().
  2. Troque pela string prefixada com f.
  3. Coloque as variáveis/expressões entre {}.
  4. Use :formato para controlar casas decimais, largura e alinhamento.
  5. Teste localmente (ou mentalmente) com um exemplo simples para garantir saída correta.
    Exemplo final simples:
    Antes:
name = "Luiz"
grade = 8.756
print("Aluno " + name + " teve nota " + str(round(grade, 1)))
Depois (pronto para usar na prova):
print(f"Aluno {name} teve nota {grade:.1f}")

Resposta

Pronto — explicado o que são f-strings, como usá-las (sintaxe, formatação, exemplos e cuidados) e forneci diversos trechos de algoritmos convertidos para f-strings que você pode usar diretamente. A partir de agora, nos exemplos de código eu vou utilizar f-strings conforme mostrado.

Exercícios relacionados