Formatação de strings¶

Na seção anterior vimos como formatar imprimir textos simples na tela através da função markdown() e da função display(). Nesta seção aprenderamos os 3 métodos de formatação de strings em Python:

1. f-strings
2. Operador %
3. Método .format()

Método format¶

Métodos são funções aplicadas à um determinado dado que pertence à uma determinada classe de dados.

Observação:

O "dado" citado é também chamado de objeto. Classes e objetos são conceitos abstratos da programação orientada a objeto. Não chegaremos à abordar com detalhes a programação orientada à objeto, mas como o Python é uma linguagem orientada à objeto, teremos que trabalhar com alguns conceitos dessa abordagem de programação.

Você pode pensar que tudo que eu falei é complicado, contudo tudo vai ficar mais claro com exemplos. Considere o seguinte exemplo:

O meu nome é [nome] e minha data de aniversário é [dia] de [mês].

Com o método .format() podemos reescrever o exemplo da seguinte forma:

In [2]:

nome = "Lucas"
dia = 19
mês = "abril"
'O meu nome é {} e minha data de aniversário é {} de {}.'.format(nome,dia,mês)

nome = "Lucas" dia = 19 mês = "abril" 'O meu nome é {} e minha data de aniversário é {} de {}.'.format(nome,dia,mês)

Out[2]:

'O meu nome é Lucas e minha data de aniversário é 19 de abril.'

Tarefa:

Crie um programa capaz de somar dois números a e b e retorne como saída:

A soma de [a] e [b] vale [resultado].

Utilize o método .format().

Numerando os argumentos¶

Podemos especificar manualmente a ordem em que os argumentos devem ser impressos, para isto basta colocar a ordem dentro da numeração da máscara {}. Tente executar o exemplo abaixo:

In [3]:

nome = "Lucas"
dia = 19
mês = "abril"
#.format(dia,mês,nome)
#Máscara: {0} {1} {2}
print('O meu nome é {2} e minha data de aniversário é {0} de {1}.'.format(dia,mês,nome))

nome = "Lucas" dia = 19 mês = "abril" #.format(dia,mês,nome) #Máscara: {0} {1} {2} print('O meu nome é {2} e minha data de aniversário é {0} de {1}.'.format(dia,mês,nome))

O meu nome é Lucas e minha data de aniversário é 19 de abril.

Verá que mesmo trocando a ordem dos argumentos a saída continua a mesma, pois numeramos as máscaras e desta forma ficamos livres para escolher qualquer ordem que os argumentos apareçam.

Tarefa:

Repita a tarefa do exemplo anterior colocando os parâmetros da seguinte ordem .format(resultado,b,a). Relembrando:

A soma de [a] e [b] vale [resultado].

Nomeando argumentos¶

Além de numerar os argumentos, podemos nomear os argumentos tornando muito mais fácil utilização do método .format() com vários argumentos. Para isso basta colocar o nome do argumento dentro da máscara (Ex: {peso}) e indicar o parâmetro com este nome (Ex: .format(peso=valor)).

Veja o exemplo abaixo:

In [4]:

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0")
a=1
b=-5
c=6
delta=b**2-4*a*c
x1=(-b+delta**(1/2))/(2*a)
x2=(-b-delta**(1/2))/(2*a)
print("As soluções da equação {a}x²+{b}x+{c}=0 são: x1={x_1} e x2={x_2}.".format(a=a,b=b,c=c,x_1=x1,x_2=x2))
# Exemplos:
# 1) a=1, b=-10 e c=24 
# 2) a=2, b=8 e c=-24 

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0") a=1 b=-5 c=6 delta=b**2-4*a*c x1=(-b+delta**(1/2))/(2*a) x2=(-b-delta**(1/2))/(2*a) print("As soluções da equação {a}x²+{b}x+{c}=0 são: x1={x_1} e x2={x_2}.".format(a=a,b=b,c=c,x_1=x1,x_2=x2)) # Exemplos: # 1) a=1, b=-10 e c=24 # 2) a=2, b=8 e c=-24

Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0
As soluções da equação 1x²+-5x+6=0 são: x1=3.0 e x2=2.0.

Tarefa:

Crie um programa que determine o antecessor e o sucessor de um número. A saída deve ser:

O número escolhido foi {número}, seu antencessor é {antecessor} e seu sucessor é {sucessor}.

Você deve nomear as máscaras.

O número escolhido é [número], seu antecessor é [antecessor] e seu sucessor é [sucessor].

Formatando a saída¶

Veja o que acontece ao executar o exemplo anterior considerando a=1,b=2,c=-10.

In [5]:

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0")
a=1
b=2
c=-10
delta=b**2-4*a*c
x1=(-b+delta**(1/2))/(2*a)
x2=(-b-delta**(1/2))/(2*a)
print("As soluções da equação {a}x²+{b}x+{c}=0 são: x1={x_1} e x2={x_2}.".format(a=a,b=b,c=c,x_1=x1,x_2=x2))

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0") a=1 b=2 c=-10 delta=b**2-4*a*c x1=(-b+delta**(1/2))/(2*a) x2=(-b-delta**(1/2))/(2*a) print("As soluções da equação {a}x²+{b}x+{c}=0 são: x1={x_1} e x2={x_2}.".format(a=a,b=b,c=c,x_1=x1,x_2=x2))

Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0
As soluções da equação 1x²+2x+-10=0 são: x1=2.3166247903554 e x2=-4.3166247903554.

Observe que a string de x1 e x2 apresenta muitas casas decimais e isto pode dificultar a leitura. Contudo podemos deixar a saída mais bonita através do método .format(). Na tabela abaixo mostra alguns especificadores:

Tipo	Significado
d	Mostra o argumento como um int
c	Mostra o argumento como caractere (Código unicode)
b	Mostra o argumento como binário
o	Mostra o argumento como octal
X	Mostra o argumento como hexadecimal
f	Mostra o argumento como float
e	Mostra o argumento no formato de notação científica
g	Arredonda o argumento em p números significativos (Valor padrão 6 significativos)
%	Mostra o argumento como porcentagem (Multiplica por 100 e coloca % no final)

Por exemplo, podemos modificar a saída de x1 e x2 para arredondar para 6 algoritmos significativos. E mostrar os argumentos a, b e c como float.

In [6]:

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0")
a=1
b=2
c=-10
delta=b**2-4*a*c
x1=(-b+delta**(1/2))/(2*a)
x2=(-b-delta**(1/2))/(2*a)
print("As soluções da equação {a:f}x²+{b:f}x+{c:f}=0 são: x1={x_1:g} e x2={x_2:g}".format(a=a,b=b,c=c,x_1=x1,x_2=x2))

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0") a=1 b=2 c=-10 delta=b**2-4*a*c x1=(-b+delta**(1/2))/(2*a) x2=(-b-delta**(1/2))/(2*a) print("As soluções da equação {a:f}x²+{b:f}x+{c:f}=0 são: x1={x_1:g} e x2={x_2:g}".format(a=a,b=b,c=c,x_1=x1,x_2=x2))

Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0
As soluções da equação 1.000000x²+2.000000x+-10.000000=0 são: x1=2.31662 e x2=-4.31662

Observe que a sintaxe de formatação de string é independente da sintaxe de numeração ou nomeação. Veja o mesmo exemplo anterior sem essa sintaxe:

In [8]:

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0")
a, b, c = 1, 3, -10
delta=b**2-4*a*c
x1=(-b+delta**(1/2))/(2*a)
x2=(-b-delta**(1/2))/(2*a)
print("As soluções da equação {:f}x²+{:f}x+{:f}=0 são: x1={:g} e x2={:g}".format(a,b,c,x1,x2))

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0") a, b, c = 1, 3, -10 delta=b**2-4*a*c x1=(-b+delta**(1/2))/(2*a) x2=(-b-delta**(1/2))/(2*a) print("As soluções da equação {:f}x²+{:f}x+{:f}=0 são: x1={:g} e x2={:g}".format(a,b,c,x1,x2))

Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0
As soluções da equação 1.000000x²+3.000000x+-10.000000=0 são: x1=2 e x2=-5

Veja mais um exemplo:

In [9]:

#Código do emoji em decimal
código=int('1F602',16) #Função converte uma string hexadecimal em um inteiro

# Mostra o código em hexadecimal e o emoji resultante
print("O código unicode em hexadecimal '{0:X}' resulta no caractere {0:c}.".format(código))

#Código do emoji em decimal código=int('1F602',16) #Função converte uma string hexadecimal em um inteiro # Mostra o código em hexadecimal e o emoji resultante print("O código unicode em hexadecimal '{0:X}' resulta no caractere {0:c}.".format(código))

O código unicode em hexadecimal '1F602' resulta no caractere 😂.

Tarefa:

Crie um programa capaz de analisar um código hexadecimal digitado pelo usuário e mostrar os seguintes dados:

• Valor em decimal do código
• Valor em binário do código
• Valor em octal do código
• Caractere equivalente

A saída do programa deve ser:

Analisando o código '[hexadecimal]'...

DEC: [decimal] | BIN: [binário] |OCT: [octal] | Caractere: [Caractere]

Teste os seguintes valores

• 2702
• 26BD
• 1F64C
• 0041
• 0169

Customização avançada¶

Além dos especificadores de tipo é possível customizar uma série de outros detalhes na saída do argumento. Veja a estrutura base:

:[preencher][alinhar][sinal][largura][precisão][tipo]

Campo	Função $\rightarrow$Notação
preencher	Preenche com o caractere escolhido (0 no caso de números)
alinhar	< $\rightarrow$ esquerda > $\rightarrow$ direita ^ $\rightarrow$ centro
sinal	+ $\rightarrow$ Sinal para positivo e negativo - $\rightarrow$ Sinal apenas em negativos
largura	Largura mínima do campo (Um número)
precisão	Largura máxima do campo (Deve ser iniciada com o .)
tipo	Especificador citado anteriormente

Largura mínima¶

O campo de largura define a largura mínima do argumento (incluindo o ponto decimal). Veja o exemplo abaixo:

In [10]:

print("{:d}".format(12))
# Inteiro com largura mínima (5 dígitos)
print("{:5d}".format(12))
# Preenchendo com zeros
print("{:05d}".format(12))
# Preenchendo com "underlines"
print("{:_>5d}".format(12)) #Neste caso deve-se usar o alinhamento

print("{:d}".format(12)) # Inteiro com largura mínima (5 dígitos) print("{:5d}".format(12)) # Preenchendo com zeros print("{:05d}".format(12)) # Preenchendo com "underlines" print("{:_>5d}".format(12)) #Neste caso deve-se usar o alinhamento

12
   12
00012
___12

Precisão¶

O campo de precisão varia de acordo com o tipo de dado. Mas de uma forma geral ele determina o número máximo de dígitos de um número.

• No tipo f precisão determina o número de casas decimais
• No tipo g precisão determina o número total de dígitos.

Observação:

Tanto o tipo g vem de "Geral", portanto, dependendo da precisão ele pode mostrar o número como inteiro como decimal ou em notação científica (Equivalente ao tipo e).

Veja o exemplo abaixo:

In [12]:

# O número tem largura mínima de 8 espaços (incluindo o ponto)
# E 3 casas decimais de "precisão" 
# Neste caso há um arredondamento
print("{:8.3f}".format(12.2346)) 
print("{:08.3f}".format(12.2346)) #Preenchendo com '0'

# O número tem largura mínima de 8 espaços (incluindo o ponto) # E 3 casas decimais de "precisão" # Neste caso há um arredondamento print("{:8.3f}".format(12.2346)) print("{:08.3f}".format(12.2346)) #Preenchendo com '0'

  12.235
0012.235

Tarefa:

Modifique o exemplo acima para mostrar todos os dígitos, sem arredondamentos.

Tarefa:

Modifique o exemplo acima utilizando o tipo g. Explique o que aconteceu.

Outras customizações¶

Podemos fazer outras customizações utilizando o método .format() Como:

1. Customização em relação ao sinal:

In [13]:

# Mostre o sinal +
print("Mostre o sinal '+'")
print("{:+6.2f} | {:+6.2f}".format(12.23, -12.23))
print("{:+6.5g} | {:+6.5g}".format(12.23, -12.23))

# Mostre apenas o sinal -
print("Mostre apenas o sinal '-'")
print("{:-6.2f} | {:-6.2f}".format(12.23, -12.23))
print("{:-6.5g} | {:-6.5g}".format(12.23, -12.23))

# Mostre o sinal + print("Mostre o sinal '+'") print("{:+6.2f} | {:+6.2f}".format(12.23, -12.23)) print("{:+6.5g} | {:+6.5g}".format(12.23, -12.23)) # Mostre apenas o sinal - print("Mostre apenas o sinal '-'") print("{:-6.2f} | {:-6.2f}".format(12.23, -12.23)) print("{:-6.5g} | {:-6.5g}".format(12.23, -12.23))

Mostre o sinal '+'
+12.23 | -12.23
+12.23 | -12.23
Mostre apenas o sinal '-'
 12.23 | -12.23
 12.23 | -12.23

2. Customização em relação ao alinhamento:

In [14]:

# Inteiro com alinhamento à direita
print("{:5d}".format(12))

# Ponto flutuante com alinhamento ao centro
print("{:^10.3f}".format(12.2346))

# Inteiro preenchido com underline com alinhamento à esquerda
print("{:*<5d}".format(12))

# Inteiro preenchido com 0 com alinhamento à direita
print("{:0>5d}".format(12))
print("{:05d}".format(12))

# Inteiro com alinhamento à direita print("{:5d}".format(12)) # Ponto flutuante com alinhamento ao centro print("{:^10.3f}".format(12.2346)) # Inteiro preenchido com underline com alinhamento à esquerda print("{:*<5d}".format(12)) # Inteiro preenchido com 0 com alinhamento à direita print("{:0>5d}".format(12)) print("{:05d}".format(12))

   12
  12.235  
12***
00012
00012

3. Aplicação em strings

In [15]:

# Preenchendo o espaço vazio com ___
print("Formatando o número á direita:")
print("A palavra é:'{:_>8}'".format('Casa'))
print("Formatando o número á esquerda:")
print("O palavra é: '{:_<8}".format('Casa'))
print("Formatando o número no centro:")
print("O palavra é: '{:_^8}".format('Casa'))

# Preenchendo o espaço vazio com ___ print("Formatando o número á direita:") print("A palavra é:'{:_>8}'".format('Casa')) print("Formatando o número á esquerda:") print("O palavra é: '{:_<8}".format('Casa')) print("Formatando o número no centro:") print("O palavra é: '{:_^8}".format('Casa'))

Formatando o número á direita:
A palavra é:'____Casa'
Formatando o número á esquerda:
O palavra é: 'Casa____
Formatando o número no centro:
O palavra é: '__Casa__

Além dessa customização existem muitas outras. Para se aprofundar um pouco mais você pode ler aqui.

F-strings¶

F-strings (formatted string literals) são a forma moderna de formatar strings em Python. Introduzidas na versão Python 3.6, permitem inserir expressões diretamente dentro das strings, simplificando a construção de textos que combinam variáveis e expressões.

A sintaxe geral é colocar um f ou F antes da abertura das aspas:

In [16]:

nome = "Lucas"
dia = 19
mês = "abril"

print(f'O meu nome é {nome} e minha data de aniversário é {dia} de {mês}.')

nome = "Lucas" dia = 19 mês = "abril" print(f'O meu nome é {nome} e minha data de aniversário é {dia} de {mês}.')

O meu nome é Lucas e minha data de aniversário é 19 de abril.

Expressões embutidas¶

F-strings aceitam qualquer expressão válida de Python, incluindo operações matemáticas, chamadas de função, métodos de objetos, etc.

Veja o exemplo abaixo:

In [17]:

num = 10

print(f"O quadrado de {num} é {num ** 2}.")

num = 10 print(f"O quadrado de {num} é {num ** 2}.")

O quadrado de 10 é 100.

Especificação de formato¶

Todas as especificações de formato do método format estão disponíveis para as f-strings:

In [ ]:

pi = 3.14159265

print(f"Valor de pi: {pi:.2f}")

pi = 3.14159265 print(f"Valor de pi: {pi:.2f}")

Valor de pi: 3.14

Tarefa:

Refaça o exemplo abaixo feito com o método format usando f-strings:

print("Este programa resolve uma equação de segundo grau do tipo ax²+bx+c=0")
a=1
b=3.4
c=-10
delta=b**2-4*a*c
x1=(-b+delta**(1/2))/(2*a)
x2=(-b-delta**(1/2))/(2*a)
print("As soluções da equação {a:g}x²+{b:g}x+{c:g}=0 são: x1={x_1:.4f} e x2={x_2:.4f}".format(a=a,b=b,c=c,x_1=x1,x_2=x2))

Prefixos literais de strings¶

Além do prefixo f, existem também r e b. Veja o resumo de todas elas:

Prefixo	Nome	Significado
r	Raw string	Não interpreta sequências de escape (\n, \t, etc)
b	Byte strings	Sequências de bytes (valores binários)
f	f-strings	String formatada que permite expressões embutidas

Por exemplo, raw strings interpreta caracteres especiais como \n, \t, tornando útil quando utiliza-se muitas \, como expressões em MathJax (ou LaTeX):

In [20]:

r'x_{1,2}=\frac{-b\pm\sqrt{b^2-4ac}}{2a}'

r'x_{1,2}=\frac{-b\pm\sqrt{b^2-4ac}}{2a}'

Out[20]:

'x_{1,2}=\\frac{-b\\pm\\sqrt{b^2-4ac}}{2a}'

Tarefa:

Crie uma string que represente o seguinte endereço de arquivo no Windows:

C:\novo\teste\arquivo.txt

Use raw strings para obter esse resultado.

Tarefa:

Como seria para imprimir a fórmula de Báskara sem raw strings?

Combinando prefixos¶

Você pode combinar prefixos quando necessário (Prefixo rf ou fr):

In [23]:

nome = "Lucas"
print(rf"C:\Users\{nome}\pasta")

nome = "Lucas" print(rf"C:\Users\{nome}\pasta")

C:\Users\Lucas\pasta

Operador %¶

O método de formatação usando %, também chamado de formatação estilo printf, é uma forma mais antiga (oriunda da linguagem C) para inserir valores em uma string.

Não iremos entrar em tantos detalhes pois esta forma é pouco usada, mas pode ser útil em expressões escritas em MathJax pois tem muitos { ou }.

Veja um exemplo:

In [ ]:

# Exemplo com operador %
produto = "Caneta"
preco = 4.5999
print("Produto: %s | Preço: R$ %.2f" % (produto, preco))

# Exemplo com operador % produto = "Caneta" preco = 4.5999 print("Produto: %s | Preço: R$ %.2f" % (produto, preco))

Produto: Caneta | Preço: R$ 4.60

Agora outro exemplo de uma fração escrita em MathJax:

In [ ]:

a = 2
b = 5

print(r"\frac{%d}{%d}" % (a, b))

a = 2 b = 5 print(r"\frac{%d}{%d}" % (a, b))

\frac{2}{5}

The Kernel crashed while executing code in the current cell or a previous cell. 

Please review the code in the cell(s) to identify a possible cause of the failure. 

Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. 

View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details.

Tarefa:

Imprima a fórmula do $\Delta$ na fómula de Báskara em MathJax:

\delta=b^2-4ac

Use raw strings e o operador % para isso.