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(ouF) antes das aspas da string e coloque as expressões entre chaves{}. - Vantagens principais: sintaxe curta e legível; evita concatenar com
+; evita chamarstr()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ávelname.{age}é substituído pelo valor atual da variávelage.- Não é preciso usar
+nemstr(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 usalocale— mas para a prova, o importante é saber:.2fe:,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 importemath).
Exemplo:
a = 5
b = 7
print(f"{a} + {b} = {a + b}")
- Cuidado: não coloque declarações (como
ifoufor) 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))porprint(f"x = {x}"). - Substitua
print("valor: {:.3f}".format(v))porprint(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)
- 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}")
- 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}")
- 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 usard['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"..."ourf"..."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)
- Identifique prints que usam concatenação,
%ouformat(). - Troque pela string prefixada com
f. - Coloque as variáveis/expressões entre
{}. - Use
:formatopara controlar casas decimais, largura e alinhamento. - 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.