Formatkonvertering i Python, format (nollfylla, exponentiell notation, hexadecimalt, etc.)

Företag

Om du vill konvertera (formatera) ett tal eller en sträng till olika format i Python använder du den inbyggda funktionen format() eller strängmetoden str.format().

I det här avsnittet förklarar vi hur du använder följande funktioner.

  • inbyggd funktion (t.ex. i ett programmeringsspråk)format()
  • strängmetodstr.format()

Dessutom förklaras formatspecifikationssträngen för konvertering till följande format med exempelkod.

  • Vänster-justerad, Center-justerad, Höger-justerad
  • nollfyllning
  • Tecken (plus eller minus)
  • Sifferseparator (kommatecken, understreck)
  • Binära, oktala och hexadecimala tal
  • Ange antalet siffror efter decimaltecknet.
  • Signifikanta siffror (antal signifikanta siffror)
  • exponentiell notation
  • Procentuell visning

Observera att sedan Python 3.6 har f-strings (f-strings) lagts till strängmetoden str.format() för att göra den mer kortfattad.

Inbyggd funktion: format()

format() är en inbyggd standardfunktion i Python.

Översikten är följande.

  • format(value, format_spec)
    • Det första argumentet: denvalue
      Det ursprungliga värdet. Sträng str, tal int, float osv.
    • Det andra argumentetformat_spec
      Sträng med formatspecifikation. Sträng str
    • Returvärde: en formaterad sträng str

Exempel visas nedan. Typerna av formatsträngar och hur man skriver dem beskrivs senare.

I det här exemplet har vi använt numeriska bokstäver och strängbokstäver som första argument, men du kan naturligtvis använda variabler som innehåller dessa värden.

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

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

Strängmetod str.format()

Det finns också en format()-metod för typen sträng str.

{} i strängen str som anropar format()-metoden kallas substitutionsfältet och ersätts av argumentet för format()-metoden.

Formatspecifikationssträngen ska skrivas i ersättningsfältet {} följt av ”:”.

Returvärdet är en formaterad sträng str.

Den motsvarande processen för den inbyggda funktionen format() som beskrivs ovan är följande.

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

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

Återigen använder vi numeriska bokstäver och strängbokstäver som argument, men variabler är naturligtvis också acceptabla.

Specificering av argument för ersättningsfält

Ange argumenten i ordning (standard)

Det kan finnas flera ersättningsfält {}, och som standard behandlas metodargumenten i turordning. Om formatspecifikationssträngen i {} utelämnas kommer den bara att konverteras till en sträng med str().

Användbart för att infoga variabla värden i en sträng och skriva ut dem.

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

Ange ett positionsargument för heltalsvärden.

Om ett heltalsvärde anges i {}, t.ex. {0} eller {1}, beror resultatet på argumentens ordning. Samma tal kan användas upprepade gånger. Detta är användbart när du vill infoga samma värde i en sträng.

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

Ange nyckelordsargument för godtyckliga namn (strängar)

Du kan också ange ett namn i {} och ange det som ett nyckelordsargument.

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

Ange en lista eller ett lexikon som argument

Listor och ordlistor kan anges som argument.

Använd [] för att ange indexet i en lista eller nyckeln i en ordbok i ett substitutionsfält. Observera att citattecken ”'” och ”” inte används för att ange ordboksnycklar.

Om du vill använda samma argument flera gånger måste du ange ett heltalsvärde eller en sträng (namn) enligt beskrivningen ovan.

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.

Det kan utökas som ett positionsargument genom att lägga till * i listan och ange det som ett argument, eller som ett nyckelordsargument genom att lägga till ** i ordlistan och ange det som ett 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.

Beskrivning av krusade parenteser {}

Om du vill skriva krusade parenteser {,} i format()-metoden upprepar du det två gånger som {{,}}. Observera att backslashes inte kan undvikas.

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

formaterad sträng

I båda fallen anger du formatet genom att skriva ”:formatsträng” efter heltalsvärdet eller namnsträngen i {}.

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

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

I det följande förklarar vi hur du anger formatet med hjälp av en formatsträng. I exempelkoden används strängmetoden str.format(), men samma formatsträng kan användas med den inbyggda funktionen format(). I den inbyggda funktionen format() anges formatspecifikationssträngen som det andra argumentet.

Vänster-justerad, Center-justerad, Höger-justerad

Du kan justera vänsterjusterat, mittjusterat, högerjusterat osv. nedan. Ange det totala antalet tecken som ett nummer.

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

Du kan också ange ett tecken som ska fyllas i. Om det utelämnas, som i exemplet ovan, är det ett mellanslag.

Du kan använda dubbel-byte-tecken så länge det är ett enda tecken.

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

Vid rättvisande med > tas inte hänsyn till tecknet (-,+). Om du använder = följs tecknet av det angivna tecknet. Om du vill ange + skriver du + efter =. Detaljerna för teckenbehandling beskrivs senare.

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

<, ^ och > kan anges för strängar, men = resulterar i ett fel ValueError. Om du vill använda = för en sträng måste du konvertera den till ett tal med int().

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

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

Samma sak gäller för flyttalstal. Även decimaltal räknas som ett tecken.

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

Listor, tupler etc. orsakar ett fel om de anges som de är, och kan konverteras till strängar med 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]*****

För vänsterjusterad, mittjusterad och högerjusterad finns det också särskilda strängmetoder som heter ljust(), center() och rjust().

0 fyllning

Om du vill justera antalet siffror genom att fylla ut noll, ställ in tecknet som ska fyllas till 0 och justera det till höger.

Vid nollfyllning, om justeringssymbolen utelämnas, behandlas det som om = hade angetts.

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

=Om du anger en sträng som argument, enligt beskrivningen ovan, får du ett fel. Låt oss vara försiktiga.

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

För att fylla ut noll finns det också en särskild strängmetod som heter zfill().

Tecken (plus eller minus)

Som standard markeras endast negativa tal med ett tecken (minus-).

När + läggs till i formateringsspecifikationssträngen visas också ett tecken (plus +) för positiva tal. Om ett mellanslag läggs till visas ett mellanslag i början av det positiva talet och antalet siffror anpassas till det negativa talet.

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

Var försiktig när du fyller med godtyckliga tecken, t.ex. nollfylla som nämns ovan. Standardinställningen, utan + och utan mellanslag, fyller positiva tal med ytterligare ett tecken.

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

Om en justeringssymbol används ska symbolen för teckenbeteckning skrivas efter justeringssymbolen.

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

Sifferseparator (kommatecken, understreck)

Lägg till ett kommatecken eller ett understreck _ som separator för varje tre siffror. Detta gör stora siffror lättare att läsa. Observera att underscore_ är ett alternativ som lades till i Python 3.6, så det kan inte användas i tidigare versioner.

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

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

När det gäller floating point-tal av typen float är det endast den heltaliga delen som avgränsas.

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

Binära, oktala och hexadecimala tal

Konverterar numeriska värden till binära, oktala och hexadecimala tal för utdata.

  • b: Binary
  • o: Oktal
  • d: Decimal
  • x,X: Hexadecimalt (stora bokstäver är stora bokstäver)
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

Det kan också kombineras med 0-fyllning och används ofta för att justera siffror i binär och hexadecimal notation.

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

Observera att antalet nollställda tecken måste anges med hänsyn till prefixet.

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

För binära och hexadecimala tal kan endast sifferseparatorn underscore _ sättas in (Python 3.6 eller senare). 4-siffrorsseparator används; antalet nollställda tecken måste också ta hänsyn till antalet understrykningar.

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

Endast heltalstypen int kan konvertera formatet till binärt eller hexadecimalt. Du kan använda int() för att konvertera det till ett tal.

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

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

Ange antalet siffror efter decimaltecknet.

Om du vill ange antalet siffror efter decimaltecknet gör du så här: n är antalet siffror. Antalet siffror efter decimalpunkten blir det angivna antalet siffror oavsett antalet siffror i heltalsdelen.
.[n]f

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

Den vänstra sidan av decimalpunkten kan specificeras som vänsterjusterad, mittjusterad, högerjusterad eller nollfylld enligt ovan. Om antalet siffror i målvärdet är fler än det angivna antalet görs ingenting. Om antalet siffror i målvärdet är större än det angivna antalet siffror görs ingenting.

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

Om du anger ett antal siffror som är mindre än det ursprungliga antalet siffror efter decimaltecknet avrundas värdet. Observera att detta inte är avrundning till närmaste heltal utan till ett jämnt tal, t.ex. 0,5 avrundas till 0.

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

Om du vill använda allmän avrundning kan du använda metoden quantize() i standardbiblioteket decimal.

exponentiell notation

När ett flyttal med flytande punkter konverteras till en sträng str skrivs det automatiskt i exponentiell notation beroende på antalet siffror. Integertypen int gör det inte.

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

Om du anger e eller E i formateringsspecifikationen kan du alltid konvertera till exponentiell notation. Tecknen som används i utmatningen kommer att vara e respektive E.

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

Det är också möjligt att ange antalet siffror efter decimaltecknet. Hela taldelen kommer alltid att vara en siffra och decimalpunkten kommer att vara det angivna antalet siffror.

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

Observera att om du anger vänsterjusterad, mittjusterad, högerjusterad eller nollfylld kommer e-, E+ etc. också att räknas som siffror (tecken).

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

Signifikanta siffror (antal signifikanta siffror)

Du kan ange det totala antalet siffror genom att göra följande Beroende på resultatet används exponentiell notation automatiskt. Observera att de avslutande nollorna efter decimaltecknet utelämnas.
.[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

Om du utelämnar g är resultatet inte ett heltal. g är detsamma i de flesta fall, men bara i de fall där resultatet är ett heltal.

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

Om vi bearbetar samma värde får vi följande resultat.

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

I fallet g eller om det utelämnas utelämnas de efterföljande nollorna efter decimalpunkten, så om du vill ha samma antal signifikanta siffror (antal signifikanta siffror) använder du exponentialnotationen e eller E. Hela taldelen är alltid en siffra och decimalpunkten är det angivna antalet siffror, så om du vill ha n signifikanta siffror anger du bara 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

Procentuell visning

Om % anges i formateringsspecifikationssträngen multipliceras värdet av det numeriska float- eller int-värdet med 100 och konverteras till en sträng med %.

Det är också möjligt att ange antalet siffror efter decimaltecknet. Standardvärdet är sex siffror efter decimalpunkten. Vänsterjustering, mittjustering, högerjustering och nollutfyllnad är också tillgängliga. % räknas också som ett tecken.

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%