Conversión de formatos en Python, formato (llenado de ceros, notación exponencial, hexadecimal, etc.)

Negocio

Para convertir (formatear) un número o una cadena en varios formatos en Python, utilice la función incorporada format() o el método de cadena str.format().

En esta sección, explicaremos cómo utilizar las siguientes funciones.

  • función integrada (por ejemplo, en el lenguaje de programación)format()
  • método de cadenastr.format()

Además, la cadena de especificación de formato para convertir al siguiente formato se explica con un código de ejemplo.

  • Justificado a la izquierda, justificado al centro, justificado a la derecha
  • relleno cero
  • Signo (más o menos)
  • Separador de dígitos (coma, guión bajo)
  • Números binarios, octales y hexadecimales
  • Especifique el número de dígitos después del punto decimal
  • Cifras significativas (número de dígitos significativos)
  • notación exponencial
  • Visualización del porcentaje

Tenga en cuenta que desde Python 3.6, se han añadido cadenas f (f-strings) al método de cadena str.format() para hacerlo más conciso.

Función incorporada: format()

format() se proporciona como una función estándar integrada en Python.

El esquema es el siguiente.

  • format(value, format_spec)
    • El primer argumento: elvalue
      El valor original. Cadena str, número int, float, etc.
    • El segundo argumentoformat_spec
      Cadena de especificación de formato. Cadena de caracteres
    • Valor de retorno: una cadena formateada str

A continuación se muestran ejemplos. Los tipos de cadenas de formato y la forma de escribirlas se describen más adelante.

En este ejemplo, hemos utilizado literales numéricos y literales de cadena como primer argumento, pero por supuesto puede utilizar variables que contengan estos valores.

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

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

Método String str.format()

También hay un método format() para el tipo de cadena str.

El {} en la cadena str que llama al método format() se llama campo de sustitución, y es reemplazado por el argumento del método format().

La cadena de especificación del formato debe escribirse en el campo de sustitución {} seguido de «:».

El valor de retorno es una cadena formateada str.

El proceso equivalente a la función incorporada format() descrita anteriormente es el siguiente.

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

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

Una vez más, estamos utilizando literales numéricos y literales de cadena como argumentos, pero por supuesto las variables también son aceptables.

Especificación de argumentos para los campos de sustitución

Especificar los argumentos en orden (por defecto)

Puede haber múltiples campos de sustitución {}, y por defecto, los argumentos del método se procesan en orden. Si se omite la cadena de especificación de formato en {}, sólo se convertirá en una cadena mediante str().

Útil para insertar valores variables en una cadena e imprimirlos.

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

Especificar un argumento posicional para valores enteros

Si se especifica un valor entero en {}, como {0} o {1}, la salida dependerá del orden de los argumentos. El mismo número puede utilizarse repetidamente. Esto es útil cuando se quiere insertar el mismo valor en una cadena.

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

Especificar argumentos de palabras clave para nombres arbitrarios (cadenas)

También puede especificar cualquier nombre en {} e introducirlo como argumento de palabra clave.

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

Especificar una lista o un diccionario como argumento

Se pueden especificar listas y diccionarios como argumentos.

Utilice [] para especificar el índice de una lista o la clave de un diccionario en un campo de sustitución. Tenga en cuenta que las comillas «'» y «» no se utilizan para especificar claves de diccionario.

Si desea utilizar el mismo argumento repetidamente, debe especificar un valor entero o una cadena (nombre) como se ha descrito 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.

Puede ampliarse como argumento posicional añadiendo * a la lista y especificándolo como argumento, o como argumento de palabra clave añadiendo ** al diccionario y especificándolo 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.

Descripción de las llaves {}

Si quiere escribir llaves {,} en el método format(), repítalo dos veces como {{,}}. Tenga en cuenta que las barras invertidas no se pueden escapar.

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

cadena formateada

En ambos casos, para especificar el formato, escriba «:cadena de formato» después del valor entero o de la cadena de nombre 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 cómo especificar el formato utilizando una cadena de formato. El código de ejemplo utiliza el método de cadena str.format(), pero la misma cadena de formato puede utilizarse con la función incorporada format(). En la función incorporada format(), la cadena de especificación de formato se especifica como segundo argumento.

Justificado a la izquierda, justificado al centro, justificado a la derecha

Puede alinear a la izquierda, al centro, a la derecha, etc. Especifique el 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

También se puede especificar un carácter para rellenar. Si se omite, como en el ejemplo anterior, es un espacio.

Puede utilizar caracteres de doble byte siempre que se trate de un solo carácter.

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

La justificación a la derecha con > no tiene en cuenta el signo (-,+). Si utiliza =, el signo va seguido del carácter especificado. Si desea especificar +, escriba + después de =. Los detalles del procesamiento de signos se describen más adelante.

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

<, ^ y > pueden especificarse para cadenas, pero = dará lugar a un error ValueError. Si desea utilizar = para una cadena, debe convertirla en un número utilizando int().

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

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

Lo mismo ocurre con los números de punto flotante. Los puntos decimales también se cuentan 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

Las listas, tuplas, etc. causarán un error si se especifican tal cual, y se pueden convertir en cadenas utilizando 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 el justificado a la izquierda, el justificado al centro y el justificado a la derecha, también hay métodos de cadena dedicados llamados ljust(), center() y rjust().

0 relleno

Si desea ajustar el número de dígitos mediante el relleno de cero, ponga el carácter a rellenar a 0 y justifíquelo a la derecha.

En el caso de llenado de cero, si se omite el símbolo de alineación, se procesa como si se especificara =.

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

=Si se especifica una cadena como argumento, como se ha descrito anteriormente, se obtendrá un error. Tengamos cuidado.

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

Para el llenado de ceros, también hay un método de cadena dedicado llamado zfill().

Signo (más o menos)

Por defecto, sólo los números negativos se marcan con un signo (menos-).

Cuando se añade + a la cadena de especificación de formato, también se muestra un signo (más +) para los números positivos. Si se añade un espacio, se muestra un espacio al principio del número positivo, y el número de dígitos se alinea con el 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

Tenga cuidado al rellenar con caracteres arbitrarios, como el relleno de ceros mencionado anteriormente. El valor por defecto, sin + y sin espacios, rellena los números positivos con un carácter más.

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

Si se utiliza un símbolo de alineación, el símbolo de designación del signo debe escribirse después del símbolo de alineación.

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 (coma, guión bajo)

Añada una coma o un guión bajo _ como separador cada tres dígitos. Esto hace que los números grandes sean más fáciles de leer. Tenga en cuenta que el guión bajo_ es una opción añadida en Python 3.6, por lo que no se puede utilizar en versiones anteriores.

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

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

En el caso de los tipos de números de punto flotante, sólo se delimita la parte entera.

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

Números binarios, octales y hexadecimales

Convierte valores numéricos a números binarios, octales y hexadecimales para su salida.

  • b: Binario
  • o: Octal
  • d: Decimal
  • x,X: Hexadecimal (las letras mayúsculas están en mayú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

También puede combinarse con el relleno 0, y suele utilizarse para alinear los dígitos en notación binaria y 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

Tenga en cuenta que el número de caracteres de relleno cero debe especificarse teniendo en cuenta el prefijo.

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 los números binarios y hexadecimales, sólo se puede insertar el separador de dígitos de subrayado _ (Python 3.6 o posterior). Se utiliza el separador de 4 dígitos; el número de caracteres rellenos de cero también debe tener en cuenta el número de guiones bajos.

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ólo el tipo entero int puede convertir el formato a binario o hexadecimal. Puede utilizar int() para convertirlo en un 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 el número de dígitos después del punto decimal

Para especificar el número de dígitos después del punto decimal, haga lo siguiente: n es el número de dígitos. El número de dígitos después del punto decimal se convierte en el número de dígitos especificado, independientemente del número de dígitos en la parte entera.
.[n]f

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

El lado izquierdo del punto decimal se puede especificar como justificado a la izquierda, justificado al centro, justificado a la derecha o relleno de cero, como se ha descrito anteriormente. Si el número de dígitos del valor objetivo es mayor que el número especificado, no se hace nada. Si el número de dígitos del valor objetivo es mayor que el número especificado, no se hace 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

Si especifica un número de dígitos menor que el número original de dígitos después del punto decimal, el valor será redondeado. Tenga en cuenta que no se redondea al número entero más cercano, sino a un número par, por ejemplo, 0,5 se redondea a 0.

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

Si desea utilizar el redondeo general, puede utilizar el método quantize() de la biblioteca estándar decimal.

notación exponencial

Cuando un número de punto flotante se convierte en una cadena de caracteres, se escribirá automáticamente en notación exponencial dependiendo del número de dígitos. El tipo entero int no lo hace.

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

Si se especifica e o E en la cadena de especificación de formato, siempre se puede convertir a notación exponencial. Los caracteres utilizados en la salida serán e y E, respectivamente.

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

También es posible especificar el número de dígitos después del punto decimal. La parte entera será siempre un dígito y el punto decimal será el 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

Tenga en cuenta que si especifica justificado a la izquierda, justificado al centro, justificado a la derecha o relleno de cero, e-, E+, etc. también se contarán como dígitos (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ígitos significativos)

Puede especificar el número total de dígitos haciendo lo siguiente Según el resultado, se utilizará automáticamente la notación exponencial. Tenga en cuenta que se omitirán los ceros finales después del 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

Si se omite g, la salida no será un entero. g es igual en la mayoría de los casos, pero sólo en los casos en que la salida es un entero.

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

Si procesamos el mismo valor, obtenemos lo siguiente 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

En el caso de g, o si se omite, se omiten los ceros finales después del punto decimal, por lo que si se desea obtener el mismo número de cifras significativas (número de dígitos significativos), utilice la notación exponencial de e o E. La parte entera es siempre un dígito y el punto decimal es el número especificado de dígitos, por lo que si desea obtener n dígitos significativos, sólo tiene que 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

Visualización del porcentaje

Si se especifica % en la cadena de especificación de formato, el valor del flotador numérico o int se multiplica por 100 y se convierte en una cadena con %.

También es posible especificar el número de dígitos después del punto decimal. El valor por defecto es de seis dígitos después del punto decimal. También están disponibles las opciones de justificación a la izquierda, justificación al centro, justificación a la derecha y relleno de cero. El % también se cuenta 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