Conversió de format en Python, format (emplenament zero, notació exponencial, hexadecimal, etc.)

Negocis

Per convertir (formatar) un nombre o cadena en diversos formats a Python, utilitzeu la funció integrada format() o el mètode de cadena str.format().

En aquesta secció, explicarem com utilitzar les funcions següents.

  • funció integrada (per exemple, en llenguatge de programació)format()
  • mètode de cadenastr.format()

A més, la cadena d’especificació de format per convertir al format següent s’explica amb el codi d’exemple.

  • Justificada a l’esquerra, Justificada al centre, Justificada a la dreta
  • farciment zero
  • Signe (més o menys)
  • Separador de dígits (coma, guió baix)
  • Nombres binaris, octals i hexadecimals
  • Especifiqueu el nombre de dígits després del punt decimal
  • Xifres significatives (nombre de dígits significatius)
  • notació exponencial
  • Visualització de percentatges

Tingueu en compte que des de Python 3.6, s’han afegit cadenes f (cadenes f) al mètode de cadena str.format() per fer-lo més concís.

Funció integrada: format()

format() es proporciona com a funció integrada estàndard de Python.

L’esquema és el següent.

  • format(value, format_spec)
    • El primer argument: elvalue
      El valor original. String str, number int, float, etc.
    • El segon argumentformat_spec
      Cadena d’especificació de format. String Str
    • Valor de retorn: una cadena formatada str

A continuació es mostren exemples. Els tipus de cadenes de format i com escriure’ls es descriuen més endavant.

En aquest exemple, hem utilitzat literals numèrics i literals de cadena com a primer argument, però, per descomptat, podeu utilitzar variables que continguin aquests valors.

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

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

Mètode de cadena str.format()

També hi ha un mètode format() per al tipus string str.

El {} de la cadena str que crida al mètode format() s’anomena camp de substitució i se substitueix per l’argument del mètode format().

La cadena d’especificació de format s’ha d’escriure al camp de substitució {} seguit de “:”.

El valor de retorn és una cadena formatada str.

El procés equivalent a la funció integrada format() descrita anteriorment és el següent.

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

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

De nou, estem utilitzant literals numèrics i literals de cadena com a arguments, però, per descomptat, les variables també són acceptables.

Especificació d’arguments per als camps de substitució

Especifiqueu els arguments en ordre (per defecte)

Hi pot haver diversos camps de substitució {} i, per defecte, els arguments del mètode es processen en ordre. Si s’omet la cadena d’especificació de format a {}, només es convertirà en una cadena mitjançant str().

Útil per inserir valors variables en una cadena i imprimir-los.

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

Especifiqueu un argument posicional per als valors enters

Si s’especifica un valor enter a {}, com ara {0} o {1}, la sortida dependrà de l’ordre dels arguments. El mateix número es pot utilitzar repetidament. Això és útil quan voleu inserir el mateix valor en una cadena.

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

Especifiqueu arguments de paraula clau per a noms arbitraris (cadenes)

També podeu especificar qualsevol nom a {} i introduir-lo com a argument de paraula clau.

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

Especifiqueu una llista o diccionari com a argument

Les llistes i els diccionaris es poden especificar com a arguments.

Utilitzeu [] per especificar l’índex d’una llista o la clau d’un diccionari en un camp de substitució. Tingueu en compte que les cometes “‘” i “” no s’utilitzen per especificar claus de diccionari.

Si voleu utilitzar el mateix argument repetidament, heu d’especificar un valor enter o una cadena (nom) tal com es descriu anteriorment.

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.

Es pot ampliar com a argument posicional afegint * a la llista i especificant-lo com a argument, o com a argument de paraula clau afegint ** al diccionari i especificant-lo com a argument.

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ó dels claudàtors {}

Si voleu escriure claudàtors {,} amb el mètode format(), repetiu-ho dues vegades com {{,}}. Tingueu en compte que les barres invertides no es poden escapar.

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

cadena formatada

En ambdós casos, per especificar el format, escriviu “:format string” després del valor enter o de la cadena de nom a {}.

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ó, explicarem com especificar el format mitjançant una cadena de format. El codi d’exemple utilitza el mètode de cadena str.format(), però es pot utilitzar la mateixa cadena de format amb la funció integrada format(). A la funció integrada format(), la cadena d’especificació de format s’especifica com a segon argument.

Justificada a l’esquerra, Justificada al centre, Justificada a la dreta

Podeu alinear a continuació justificat a l’esquerra, al centre, a la dreta, etc. Especifiqueu el nombre total de caràcters com a nombre.

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

També podeu especificar un caràcter que cal omplir. Si s’omet, com a l’exemple anterior, és un espai.

Podeu utilitzar caràcters de doble byte sempre que sigui un sol caràcter.

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

Justificació dreta amb > no té en compte el signe (-,+). Si utilitzeu =, el signe va seguit del caràcter especificat. Si voleu especificar +, escriviu + després de =. Els detalls del processament de signes es descriuen més endavant.

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

<, ^ i > es pot especificar per a les cadenes, però = donarà lloc a un error ValueError. Si voleu utilitzar = per a una cadena, haureu de convertir-la en un nombre mitjançant int().

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

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

El mateix s’aplica als nombres de coma flotant. Els punts decimals també es compten com a 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

Les llistes, tuples, etc. provocaran un error si s’especifiquen tal com estan, i es poden convertir en cadenes mitjançant 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]*****

Per als justificats a l’esquerra, al centre i a la dreta, també hi ha mètodes de cadena dedicats anomenats ljust(), center() i rjust().

0 omplir

Si voleu ajustar el nombre de dígits per omplir zero, configureu el caràcter que s’ha d’omplir a 0 i justifiqueu-lo a la dreta.

En el cas de l’emplenament zero, si s’omet el símbol d’alineació, es processa com si s’especificés =.

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

#ERROR!

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

Per a l’emplenament zero, també hi ha un mètode de cadena dedicat anomenat zfill().

Signe (més o menys)

Per defecte, només els nombres negatius estan marcats amb un signe (menys-).

Quan s’afegeix + a la cadena d’especificació de format, també es mostra un signe (més +) per als números positius. Si s’afegeix un espai, es mostra un espai al començament del nombre positiu i el nombre de dígits s’alinea amb el nombre negatiu.

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

Aneu amb compte quan ompliu caràcters arbitraris, com ara l’emplenament zero esmentat anteriorment. El valor predeterminat, sense + i sense espais, omple els números positius amb 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 s’utilitza un símbol d’alineació, el símbol de designació del signe s’ha d’escriure després del símbol d’alineació.

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ígits (coma, guió baix)

Afegiu un separador de coma o guió baix _ cada tres dígits. Això facilita la lectura de grans números. Tingueu en compte que el guió baix_ és una opció afegida a Python 3.6, de manera que no es pot utilitzar en versions anteriors.

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

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

En el cas dels tipus flotants de nombres de coma flotant, només es delimita la part sencera.

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

Nombres binaris, octals i hexadecimals

Converteix valors numèrics en nombres binaris, octals i hexadecimals per a la sortida.

  • b: binari
  • o: Octal
  • d: Decimal
  • x,X: Hexadecimal (les lletres majúscules s’escriuen en majú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

També es pot combinar amb l’emplenament 0 i sovint s’utilitza per alinear dígits en notació binària i 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

Tingueu en compte que el nombre de caràcters d’emplenament zero s’ha d’especificar tenint en compte el prefix.

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

Per als números binaris i hexadecimals, només es pot inserir el guió baix _ separador de dígits (Python 3.6 o posterior). s’utilitza un separador de 4 dígits; el nombre de caràcters plens de zero també ha de tenir en compte el nombre de guions 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

Només el tipus enter int pot convertir el format a binari o hexadecimal. Podeu utilitzar int() per convertir-lo en un nombre.

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

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

Especifiqueu el nombre de dígits després del punt decimal

Per especificar el nombre de dígits després del punt decimal, feu el següent: n és el nombre de dígits. El nombre de dígits després del punt decimal es converteix en el nombre especificat de dígits independentment del nombre de dígits de la part sencera.
.[n]f

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

El costat esquerre del punt decimal es pot especificar com a justificat a l’esquerra, al centre, a la dreta o amb zero com es descriu anteriorment. Si el nombre de dígits del valor objectiu és superior al nombre especificat, no es fa res. Si el nombre de dígits del valor objectiu és més gran que el nombre especificat de dígits, no es fa res.

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 especifiqueu un nombre de dígits inferior al nombre original de dígits després del punt decimal, el valor s’arrodonirà. Tingueu en compte que això no és arrodoniment al nombre sencer més proper, sinó a un nombre parell, p. 0,5 s’arrodoneix a 0.

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

Si voleu utilitzar l’arrodoniment general, podeu utilitzar el mètode quantize() del decimal estàndard de la biblioteca.

notació exponencial

Quan un nombre flotant de coma flotant es converteix en una cadena de cadena, s’escriurà automàticament en notació exponencial depenent del nombre de dígits. El tipus d’enter int no.

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 especifiqueu e o E a la cadena d’especificació de format, sempre podeu convertir a notació exponencial. Els caràcters utilitzats a la sortida seran e i E, respectivament.

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

També és possible especificar el nombre de dígits després del punt decimal. La part sencera sempre serà d’un dígit i el punt decimal serà el nombre especificat de dígits.

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

Tingueu en compte que si especifiqueu justificació a l’esquerra, justificada al centre, justificada a la dreta o completada amb zero, e-, E+, etc. també es comptaran com a dígits (caràcters).

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

Xifres significatives (nombre de dígits significatius)

Podeu especificar el nombre total de dígits fent el següent. Segons el resultat, la notació exponencial s’utilitzarà automàticament. Tingueu en compte que els zeros posteriors després del punt decimal s’ometran.
.[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 ometeu g, la sortida no serà un nombre enter. g és el mateix en la majoria dels casos, però només en els casos en què la sortida és un nombre enter.

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 processem el mateix valor, obtenim el següent respectivament.

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 cas de g o si s’omet, s’ometen els zeros posteriors després del punt decimal, de manera que si voleu generar el mateix nombre de xifres significatives (nombre de dígits significatius), utilitzeu la notació exponencial de e o E. La part entera és sempre un dígit i el punt decimal és el nombre especificat de dígits, de manera que si voleu treure n dígits significatius, només cal que especifiqueu 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

Visualització de percentatges

Si s’especifica % a la cadena d’especificació de format, el valor de la variable numèrica flotant o int es multiplica per 100 i es converteix en una cadena amb %.

També és possible especificar el nombre de dígits després del punt decimal. El valor predeterminat és sis dígits després del punt decimal. També estan disponibles la justificació a l’esquerra, la justificació al centre, la justificació a la dreta i l’emplenament zero. El % també es compta com a 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%