Conversão de formato em Python, formato (preenchimento zero, notação exponencial, hexadecimal, etc.)

O negócio

Para converter (formatar) um número ou string em vários formatos em Python, usar o formato da função integrada() ou o método string str.format().

Nesta secção, explicaremos como utilizar as seguintes funções.

  • função incorporada (por exemplo, em linguagem de programação)format()
  • método de cordasstr.format()

Além disso, a cadeia de especificação de formato para conversão para o seguinte formato é explicada com o código da amostra.

  • Justificada à esquerda, Justificada ao centro, Justificada à direita
  • preenchimento zero
  • Sinal (mais ou menos)
  • Separador de dígitos (vírgula, sublinhado)
  • Números binário, octal e hexadecimal
  • Especificar o número de dígitos após a vírgula decimal
  • Números significativos (número de dígitos significativos)
  • notação exponencial
  • Apresentação das percentagens

Note-se que desde Python 3.6, as cordas f (f-strings) foram adicionadas ao método str.format() para o tornar mais conciso.

Função embutida: formato()

formato() é fornecido como uma função padrão Python incorporada.

O esboço é o seguinte.

  • format(value, format_spec)
    • O primeiro argumento: ovalue
      O valor original. String string, número int, flutuar, etc.
    • O segundo argumentoformat_spec
      Cadeia de especificação de formato. Cordão de corda
    • Valor de retorno: uma cadeia de caracteres formatada

Apresentam-se a seguir exemplos. Os tipos de formato de cordas e a forma de as escrever são descritos mais tarde.

Neste exemplo, utilizámos literais numéricos e literais de cordel como primeiro argumento, mas é claro que se pode utilizar variáveis que contenham estes valores.

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

Método string str.format()

Existe também um método de formato() para o tipo de cordas.

O {} na cadeia de caracteres que chama o método format() chama-se campo de substituição, e é substituído pelo argumento do método format().

A cadeia de especificação do formato deve ser escrita no campo de substituição {} seguido de “:”.

O valor de retorno é uma cadeia de caracteres formatada.

O processo equivalente ao formato da função incorporada() descrito acima é o seguinte.

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

Mais uma vez, estamos a usar literais numéricos e literais de cordel como argumentos, mas é claro que as variáveis também são aceitáveis.

Especificação de argumentos para campos de substituição

Especificar os argumentos por ordem (por defeito)

Pode haver múltiplos campos de substituição {}, e, por defeito, os argumentos do método são processados por ordem. Se a string de especificação de formato em {} for omitida, será apenas convertida para uma string por str().

Útil para inserir valores variáveis numa cadeia e imprimi-los.

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

Especificar um argumento posicional para valores inteiros

Se um valor inteiro for especificado em {}, tal como {0} ou {1}, a saída dependerá da ordem dos argumentos. O mesmo número pode ser usado repetidamente. Isto é útil quando se pretende inserir o mesmo valor numa cadeia.

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

Especificar argumentos de palavras-chave para nomes arbitrários (strings)

Pode também especificar qualquer nome em {} e introduzi-lo como um argumento de palavra-chave.

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

Especificar uma lista ou dicionário como argumento

Listas e dicionários podem ser especificados como argumentos.

Utilizar [] para especificar o índice de uma lista ou a chave de um dicionário num campo de substituição. Note-se que as aspas “'” e “” não são utilizadas para especificar chaves de dicionário.

Se quiser utilizar o mesmo argumento repetidamente, é necessário especificar um valor inteiro ou uma cadeia (nome), como descrito acima.

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

Pode ser expandido como argumento posicional anexando * à lista e especificando-o como argumento, ou como argumento por palavra-chave anexando ** ao dicionário e especificando-o como argumento.

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

Descrição dos parênteses encaracolados {}

Se quiser escrever entre parênteses rectos {,} no método format(), repita duas vezes como {{,}}. Note-se que não é possível escapar às barras invertidas.

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

corda formatada

Em ambos os casos, para especificar o formato, escrever “:formatar cadeia” após o valor inteiro ou cadeia de nomes em {}.

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

Em seguida, explicaremos como especificar o formato utilizando uma cadeia de formatos. O código de amostra utiliza o método str.format(), mas a mesma string de formato pode ser utilizada com a função format() incorporada. No formato da função integrada(), a string de especificação de formato é especificada como o segundo argumento.

Justificada à esquerda, Justificada ao centro, Justificada à direita

Pode alinhar esquerda-justificada, centro-justificada, direita-justificada, etc. abaixo. Especificar o número total de caracteres como um número.

  • <
  • ^
  • >
print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

Pode também especificar um carácter a ser preenchido. Se omitido, como no exemplo acima, trata-se de um espaço.

Pode usar caracteres de byte duplo desde que seja um único carácter.

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

A justificação à direita com > não tem em conta o sinal (-,+). Se utilizar =, o sinal é seguido do carácter especificado. Se quiser especificar +, escreva + depois de =. Os detalhes do processamento do sinal são descritos mais tarde.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

<, ^, e > pode ser especificado para cordas, mas = resultará num erro ValueError. Se quiser usar = para uma cadeia de caracteres, precisa de convertê-la para um número usando int().

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

O mesmo se aplica aos números de ponto flutuante. Os pontos decimais também são contados como um carácter.

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

Listas, tuplos, etc. causarão um erro se especificado as-is, e podem ser convertidos em str().

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

Para a esquerda-justificada, centro-justificada, e direita-justificada, há também métodos de cordas dedicados chamados ljust(), centro(), e rjust().

0 preenchimento

Se quiser ajustar o número de dígitos por preenchimento zero, defina o carácter a ser preenchido a 0 e justifique à direita.

No caso de preenchimento zero, se o símbolo de alinhamento for omitido, é processado como se = tivessem sido especificados.

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

=Se especificar um fio como argumento, como descrito acima, receberá um erro. Vamos ter cuidado.

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

Para o preenchimento zero, existe também um método de cordas dedicado chamado zfill().

Sinal (mais ou menos)

Por defeito, apenas números negativos são marcados com um sinal (menos-).

Quando se adiciona + à cadeia de especificação de formatação, é também exibido um sinal (mais +) para números positivos. Se for adicionado um espaço, é exibido um espaço no início do número positivo, e o número de dígitos é alinhado com o número negativo.

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

Tenha cuidado ao preencher com caracteres arbitrários, tais como o preenchimento zero acima mencionado. O preenchimento por defeito, sem + e sem espaços, preenche números positivos com mais um carácter.

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

Se for utilizado um símbolo de alinhamento, o símbolo de designação do sinal deve ser escrito após o símbolo de alinhamento.

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

Separador de dígitos (vírgula, sublinhado)

Adicionar uma vírgula ou sublinhado _ separador a cada três dígitos. Isto torna os números grandes mais fáceis de ler. Note-se que o underscore_ é uma opção adicionada em Python 3.6, pelo que não pode ser utilizado em versões anteriores.

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

No caso de tipos de flutuadores com número de pontos flutuantes, apenas a parte inteira é delimitada.

print('{:,}'.format(1234.56789))
# 1,234.56789

Números binário, octal e hexadecimal

Converte valores numéricos em números binários, octais e hexadecimais para saída.

  • b: Binário
  • o: Octal
  • d: Decimal
  • x,X: Hexadecimal (letras maiúsculas são maiúsculas)
print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

Também pode ser combinado com o preenchimento 0, e é frequentemente utilizado para alinhar dígitos em notação binária e hexadecimal.

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

Note-se que o número de caracteres de preenchimento zero deve ser especificado tendo em conta o prefixo.

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

Para números binários e hexadecimais, apenas o separador de _dígitos pode ser inserido (Python 3.6 ou posterior). É utilizado um separador de 4 dígitos; o número de caracteres com preenchimento zero deve também ter em conta o número de sublinhados.

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

Apenas o tipo inteiro int pode converter o formato para binário ou hexadecimal. Pode usar int() para o converter para um número.

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

Especificar o número de dígitos após a vírgula decimal

Para especificar o número de dígitos após o ponto decimal, faça o seguinte: n é o número de dígitos. O número de dígitos após o ponto decimal torna-se o número de dígitos especificado, independentemente do número de dígitos na parte inteira.
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

O lado esquerdo da vírgula decimal pode ser especificado como justificado à esquerda, justificado ao centro, justificado à direita, ou preenchido a zero, como descrito acima. Se o número de dígitos do valor-alvo for superior ao número especificado, nada é feito. Se o número de dígitos do valor-alvo for superior ao número de dígitos especificado, nada é feito.

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

Se especificar um número de dígitos inferior ao número original de dígitos após a vírgula decimal, o valor será arredondado. Note que isto não é arredondar para o número inteiro mais próximo, mas para um número par, por exemplo, 0,5 é arredondado para 0.

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

Se quiser usar arredondamento geral, pode usar o método quantize() da biblioteca padrão decimal.

notação exponencial

Quando um número flutuante de ponto flutuante é convertido para uma cadeia de caracteres, será automaticamente escrito em notação exponencial, dependendo do número de dígitos. O tipo inteiro int não.

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

Se especificar e ou E na cadeia de especificação de formatação, pode sempre converter para notação exponencial. Os caracteres utilizados na saída serão e e, respectivamente.

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

Também é possível especificar o número de dígitos após a vírgula decimal. A parte inteira será sempre de um dígito e o ponto decimal será o número de dígitos especificado.

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

Note que se especificar justificado à esquerda, justificado ao centro, justificado à direita, ou preenchido a zero, e-, E+, etc., também serão contados como dígitos (caracteres).

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

Números significativos (número de dígitos significativos)

É possível especificar o número total de dígitos fazendo o seguinte Dependendo do resultado, a notação exponencial será utilizada automaticamente. Note-se que serão omitidos os zeros decimais após o ponto decimal.
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

Se omitir g, a saída não será um número inteiro. g é o mesmo na maioria dos casos, mas apenas nos casos em que a saída é um número inteiro.

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

Se processarmos o mesmo valor, obtemos o seguinte, respectivamente.

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

No caso de g ou se for omitido, são omitidos os zeros de fuga após o ponto decimal, por isso, se quiser produzir o mesmo número de algarismos significativos (número de algarismos significativos), utilize a notação exponencial de e ou E. A parte inteira é sempre um dígito e o ponto decimal é o número de dígitos especificado, por isso, se quiser produzir n dígitos significativos, basta especificar n-1.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

Apresentação das percentagens

Se a % for especificada na cadeia de especificação de formatação, o valor do flutuador numérico ou int é multiplicado por 100 e convertido para uma cadeia com %.

Também é possível especificar o número de dígitos após a vírgula decimal. O padrão é de seis dígitos após a vírgula decimal. Estão também disponíveis justificação à esquerda, justificação ao centro, justificação à direita, e preenchimento zero. A % é também contada como um caracter.

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%