Conversión de formato en Python, formato (recheo cero, notación exponencial, hexadecimal, etc.)

Negocios

Para converter (formatar) un número ou cadea en varios formatos en Python, use a función integrada format() ou o método de cadea str.format().

Nesta sección, explicaremos como usar as seguintes funcións.

  • función integrada (por exemplo, en linguaxe de programación)format()
  • método de cadeastr.format()

Ademais, a cadea de especificación do formato para converter ao seguinte formato explícase cun código de mostra.

  • Xustificación á esquerda, Xustificación ao centro, Xustificación á dereita
  • recheo cero
  • Asinar (máis ou menos)
  • Separador de díxitos (coma, guión baixo)
  • Números binarios, octais e hexadecimais
  • Especifique o número de díxitos despois do punto decimal
  • Cifras significativas (número de díxitos significativos)
  • notación exponencial
  • Visualización porcentual

Teña en conta que desde Python 3.6, engadíronse cadeas f (cadeas f) ao método de cadeas str.format() para facelo máis conciso.

Función integrada: format()

format() ofrécese como unha función integrada estándar de Python.

O esquema é o seguinte.

  • format(value, format_spec)
    • O primeiro argumento: ovalue
      O valor orixinal. Cadena str, número int, float, etc.
    • O segundo argumentoformat_spec
      Cadea de especificación de formato. Cadena str
    • Valor de retorno: unha cadea formateada str

A continuación móstranse exemplos. Os tipos de cadeas de formato e como escribilas descríbense máis adiante.

Neste exemplo, usamos literais numéricos e literais de cadea como primeiro argumento, pero por suposto que podes usar variables que conteñan estes valores.

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

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

Método de cadea str.format()

Tamén hai un método format() para o tipo de cadea str.

O {} da cadea str que chama ao método format() chámase campo de substitución e substitúese polo argumento do método format().

A cadea de especificación do formato debe escribirse no campo de substitución {} seguido de “:”.

O valor de retorno é unha cadea de formato str.

O proceso equivalente á función integrada format() descrita anteriormente é o seguinte.

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

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

De novo, estamos a usar literais numéricos e literais de cadea como argumentos, pero, por suposto, tamén se aceptan variables.

Especificación de argumentos para campos de substitución

Especifique os argumentos en orde (predeterminado)

Pode haber varios campos de substitución {} e, de xeito predeterminado, os argumentos do método procédanse en orde. Se se omite a cadea de especificación de formato en {}, só se converterá nunha cadea mediante str().

Útil para inserir valores variables nunha cadea e imprimilos.

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

Especifique un argumento posicional para valores enteiros

Se se especifica un valor enteiro en {}, como {0} ou {1}, a saída dependerá da orde dos argumentos. O mesmo número pódese usar repetidamente. Isto é útil cando quere inserir o mesmo valor nunha cadea.

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

Especifique argumentos de palabras clave para nomes arbitrarios (cadeas)

Tamén pode especificar calquera nome en {} e introducilo como argumento de palabra clave.

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

Especifique unha lista ou dicionario como argumento

As listas e os dicionarios pódense especificar como argumentos.

Use [] para especificar o índice dunha lista ou a clave dun dicionario nun campo de substitución. Teña en conta que as comiñas “‘” e “” non se usan para especificar chaves de dicionario.

Se queres usar o mesmo argumento repetidamente, debes especificar un valor enteiro ou unha cadea (nome) como se describe anteriormente.

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.

Pódese expandir como argumento posicional engadindo * á lista e especificándoo como argumento, ou como argumento de palabra clave engadindo ** ao dicionario e especificándoo 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.

Descrición dos corchetes {}

Se queres escribir corchetes {,} no método format(), repíteo dúas veces como {{,}}. Teña en conta que as barras invertidas non se poden escapar.

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

cadea formateada

En ambos casos, para especificar o formato, escriba “:cadea de formato” despois do valor enteiro ou da cadea de nome en {}.

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

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

A continuación, explicaremos como especificar o formato mediante unha cadea de formato. O código de mostra usa o método de cadea str.format(), pero pódese usar a mesma cadea de formato coa función integrada format(). Na función integrada format(), a cadea de especificación de formato especifícase como segundo argumento.

Xustificación á esquerda, Xustificación ao centro, Xustificación á dereita

Podes aliñar abaixo xustificado á esquerda, ao centro, á dereita, etc. Especifique o número total de caracteres como un número.

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

Tamén pode especificar un carácter a encher. Se se omite, como no exemplo anterior, é un espazo.

Podes usar caracteres de dobre byte sempre que sexa un só carácter.

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

Xustificación á dereita con > non ten en conta o signo (-,+). Se usa =, o signo vai seguido do carácter especificado. Se queres especificar +, escribe + despois de =. Os detalles do procesamento de sinais descríbense máis adiante.

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 > pódese especificar para as cadeas, pero = producirá un erro ValueError. Se queres usar = para unha cadea, necesitas convertela nun 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 aplícase aos números de coma flotante. Os decimais tamén se contan como un 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

As listas, tuplas, etc. provocarán un erro se se especifican tal e como están, e pódense converter en cadeas usando 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 os xustificados á esquerda, ao centro e á dereita, tamén hai métodos de cadea dedicados chamados ljust(), center() e rjust().

0 recheo

Se queres axustar o número de díxitos mediante o recheo de cero, configura o carácter que se quere encher en 0 e xustifiqueo coa dereita.

No caso de recheo cero, se se omite o símbolo de aliñamento, procédese coma se se especificase =.

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

#ERRO!

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

Para o recheo cero, tamén hai un método de cadea dedicado chamado zfill().

Asinar (máis ou menos)

Por defecto, só os números negativos están marcados cun signo (menos-).

Cando se engade + á cadea de especificación de formato, tamén se mostra un signo (máis +) para os números positivos. Se se engade un espazo, móstrase un espazo ao comezo do número positivo e o número de díxitos aliñarase co 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

Teña coidado ao encher caracteres arbitrarios, como o recheo cero mencionado anteriormente. O valor predeterminado, sen + e sen espazos, enche os números positivos cun carácter máis.

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 se utiliza un símbolo de aliñamento, o símbolo de designación do sinal debe escribirse despois do símbolo de aliñamento.

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íxitos (coma, guión baixo)

Engade un separador de coma ou guión baixo _ cada tres díxitos. Isto fai que os números grandes sexan máis fáciles de ler. Teña en conta que o underscore_ é unha opción engadida en Python 3.6, polo que non se pode usar en versións anteriores.

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

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

No caso dos tipos flotantes de números en coma flotante, só se delimita a parte enteira.

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

Números binarios, octais e hexadecimais

Converte valores numéricos en números binarios, octais e hexadecimais para a saída.

  • b: Binario
  • o: Octal
  • d: decimal
  • x,X: Hexadecimal (as maiúsculas están en maiúscula)
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

Tamén se pode combinar co recheo 0 e úsase a miúdo para aliñar díxitos en notación binaria 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

Teña en conta que o número de caracteres de recheo cero debe especificarse tendo en 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 binarios e hexadecimais, só se pode inserir o guión baixo _ separador de díxitos (Python 3.6 ou posterior). utilízase un separador de 4 díxitos; o número de caracteres cubertos con cero tamén debe ter en conta o número de guións baixos.

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

Só o tipo enteiro int pode converter o formato a binario ou hexadecimal. Podes usar int() para convertelo nun 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

Especifique o número de díxitos despois do punto decimal

Para especificar o número de díxitos despois do punto decimal, faga o seguinte: n é o número de díxitos. O número de díxitos despois do punto decimal convértese no número especificado de díxitos independentemente do número de díxitos da parte enteira.
.[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 do punto decimal pódese especificar como xustificado á esquerda, ao centro, á dereita ou a cero, como se describe anteriormente. Se o número de díxitos do valor obxectivo é superior ao número especificado, non se fai nada. Se o número de díxitos do valor obxectivo é maior que o número especificado de díxitos, non se fai nada.

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 especifica un número de díxitos inferior ao número orixinal de díxitos despois do punto decimal, o valor redondearase. Teña en conta que non se redondea ao número enteiro máis próximo, senón a un número par, p. ex. 0,5 redondéase a 0.

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

Se queres usar o redondeo xeral, podes usar o método quantize() do decimal estándar da biblioteca.

notación exponencial

Cando un número flotante de coma flotante se converte nunha cadea de caracteres, escribirase automaticamente en notación exponencial dependendo do número de díxitos. O tipo de enteiro int non.

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 especificas e ou E na cadea de especificación de formato, sempre podes converter a notación exponencial. Os caracteres utilizados na saída serán e e E, respectivamente.

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

Tamén é posible especificar o número de díxitos despois do punto decimal. A parte enteira será sempre un díxito e o punto decimal será o número especificado de díxitos.

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

Teña en conta que se especificas xustificado á esquerda, ao centro, á dereita ou ao cero, e-, E+, etc. tamén se contarán como díxitos (caracteres).

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

Cifras significativas (número de díxitos significativos)

Podes especificar o número total de díxitos facendo o seguinte. Dependendo do resultado, a notación exponencial empregarase automaticamente. Teña en conta que omitiranse os ceros finais despois do punto 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 omites g, a saída non será un número enteiro. g é o mesmo na maioría dos casos, pero só nos casos en que a saída é un número enteiro.

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 procesamos 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 se omite, omítense os ceros posteriores despois da coma decimal, polo que se quere producir o mesmo número de cifras significativas (número de díxitos significativos), use a notación exponencial de e ou E. A parte enteira é sempre un díxito e o punto decimal é o número especificado de díxitos, polo que se quere sacar n díxitos significativos, simplemente especifique 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

Visualización porcentual

Se % se especifica na cadea de especificación de formato, o valor do flotante numérico ou int multiplícase por 100 e convértese nunha cadea con %.

Tamén é posible especificar o número de díxitos despois do punto decimal. O valor predeterminado son seis díxitos despois do punto decimal. Tamén están dispoñibles a xustificación á esquerda, a xustificación ao centro, a xustificación á dereita e o recheo cero. O % tamén se conta como un carácter.

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%
Copied title and URL