Formatkonvertering i Python, format (nuludfyldning, eksponentiel notation, hexadecimalt osv.)

Forretning

Hvis du vil konvertere (formatere) et tal eller en streng til forskellige formater i Python, kan du bruge den indbyggede funktion format() eller strengmetoden str.format().

I dette afsnit forklarer vi, hvordan du bruger følgende funktioner.

  • indbygget funktion (f.eks. i et programmeringssprog)format()
  • strengmetodestr.format()

Desuden forklares formatspecifikationsstrengen til konvertering til følgende format med en kodeeksempel.

  • Venstre-justeret, Center-justeret, Højre-justeret
  • nulfyldning
  • Tegn (plus eller minus)
  • Cifferadskillelse (komma, understregning)
  • Binære, oktale og hexadecimale tal
  • Angiv antallet af cifre efter decimalkommaet
  • Signifikante tal (antal signifikante cifre)
  • eksponentiel notation
  • Visning af procentdel

Bemærk, at siden Python 3.6 er f-strings (f-strings) blevet tilføjet til strengmetoden str.format() for at gøre den mere kortfattet.

Indbygget funktion: format()

format() leveres som en indbygget Python-standardfunktion.

Det er som følger.

  • format(value, format_spec)
    • Det første argument: denvalue
      Den oprindelige værdi. String str, tal int, float osv.
    • Det andet argumentformat_spec
      Formatspecifikationsstreng. String str
    • Returværdi: en formateret streng str

Nedenfor er vist eksempler. Typerne af formatstrenge, og hvordan de skrives, beskrives senere.

I dette eksempel har vi brugt numeriske bogstaver og strengbogstaver som det første argument, men du kan naturligvis også bruge variabler, der indeholder disse værdier.

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

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

String-metode str.format()

Der findes også en format()-metode til stringtypen str.

{} i strengen str, der kalder format()-metoden, kaldes erstatningsfeltet og erstattes af argumentet for format()-metoden.

Formatspecifikationsstrengen skal skrives i erstatningsfeltet {} efterfulgt af “:”.

Den returnerede værdi er en formateret streng str.

Den tilsvarende proces til den indbyggede funktion format(), som er beskrevet ovenfor, er som følger.

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

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

Igen bruger vi numeriske bogstaver og string-bogstaver som argumenter, men variabler er naturligvis også acceptable.

Angivelse af argumenter for substitutionsfelter

Angiv argumenter i rækkefølge (standard)

Der kan være flere erstatningsfelter {}, og som standard behandles metodeargumenterne i rækkefølge. Hvis formatspecifikationsstrengen i {} udelades, vil den blot blive konverteret til en streng med str().

Nyttig til at indsætte variable værdier i en streng og udskrive dem.

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

Angiv et positionelt argument for heltalsværdier

Hvis der er angivet en heltalsværdi i {}, f.eks. {0} eller {1}, afhænger output af rækkefølgen af argumenterne. Det samme tal kan bruges gentagne gange. Dette er nyttigt, når du ønsker at indsætte den samme værdi i en streng.

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

Angiv nøgleordsargumenter for vilkårlige navne (strenge)

Du kan også angive et hvilket som helst navn i {} og indtaste det som et nøgleord som argument.

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

Angiv en liste eller ordbog som et argument

Lister og ordbøger kan angives som argumenter.

Brug [] til at angive indekset i en liste eller nøglen i en ordbog i et erstatningsfelt. Bemærk, at citationstegn “'” og “” ikke bruges til at angive ordbogsnøgler.

Hvis du vil bruge det samme argument gentagne gange, skal du angive en heltalsværdi eller en streng (navn) som beskrevet ovenfor.

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 udvides som et positionelt argument ved at tilføje * til listen og angive det som et argument, eller som et nøgleordsargument ved at tilføje ** til ordbogen og angive det som et 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.

Beskrivelse af de krøllede parenteser {}

Hvis du vil skrive parenteser {,} i format()-metoden, skal du gentage det to gange som {{,}}. Bemærk, at backslashes ikke kan undviges.

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

formateret streng

I begge tilfælde skal du angive formatet ved at skrive “:format string” efter den hele talværdi eller navnestrengen 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ølgende forklarer vi, hvordan du kan angive formatet ved hjælp af en formatstreng. Eksempelkoden anvender strings-metoden str.format(), men den samme formatstreng kan anvendes med den indbyggede funktion format(). I den indbyggede funktion format() angives formatspecifikationsstrengen som det andet argument.

Venstre-justeret, Center-justeret, Højre-justeret

Du kan justere venstrejusteret, centerjusteret, højrejusteret osv. nedenfor. Angiv det samlede antal tegn som et tal.

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

Du kan også angive et tegn, der skal udfyldes. Hvis det udelades, som i eksemplet ovenfor, er det et mellemrum.

Du kan bruge dobbelt-byte-tegn, så længe det er et enkelt tegn.

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

Retskrivning med > tager ikke hensyn til tegnet (-,+). Hvis du bruger =, bliver tegnet efterfulgt af det angivne tegn. Hvis du ønsker at angive +, skal du skrive + efter =. Detaljerne om behandling af tegn beskrives senere.

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

<, ^ og > kan angives for strenge, men = vil resultere i en fejl ValueError. Hvis du vil bruge = til en streng, skal du konvertere den til et tal ved hjælp af int().

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

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

Det samme gælder for flydende tal. Decimaltal tæller også som et tegn.

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

Lister, tupler osv. vil forårsage en fejl, hvis de angives som de er, og de kan konverteres til strenge ved hjælp af 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]*****

For venstre-justeret, center-justeret og højre-justeret er der også dedikerede strengmetoder kaldet ljust(), center() og rjust().

0 fyld

Hvis du vil justere antallet af cifre ved at udfylde med nul, skal du indstille det tegn, der skal udfyldes, til 0 og justere det til højre.

I tilfælde af nulopfyldning, hvis justeringssymbolet er udeladt, behandles det, som om = var angivet.

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

=Hvis du angiver en streng som argument, som beskrevet ovenfor, får du en fejl. Lad os være forsigtige.

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

Der er også en dedikeret strengmetode til nuludfyldning, der hedder zfill().

Tegn (plus eller minus)

Som standard er kun negative tal markeret med et tegn (minus-).

Når + tilføjes til formateringsspecifikationsstrengen, vises der også et tegn (plus +) for positive tal. Hvis der tilføjes et mellemrum, vises der et mellemrum i begyndelsen af det positive tal, og antallet af cifre tilpasses det negative tal.

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

Vær forsigtig, når du udfylder med vilkårlige tegn, som f.eks. den ovenfor nævnte nuludfyldning. Standardindstillingen, uden + og uden mellemrum, udfylder positive tal med endnu et tegn.

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

Hvis der anvendes et justeringssymbol, skal symbolet for tegnbetegnelsen skrives efter justeringssymbolet.

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

Cifferadskillelse (komma, understregning)

Tilføj et komma eller en understregning _ som separator for hvert tredje ciffer. Dette gør store tal lettere at læse. Bemærk, at underscore_ er en indstilling, der er tilføjet i Python 3.6, så den kan ikke bruges i tidligere versioner.

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

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

I tilfælde af floating-point tal float-typer er det kun den hele del afgrænset.

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

Binære, oktale og hexadecimale tal

Konverterer numeriske værdier til binære, oktale og hexadecimale tal til output.

  • b: Binary
  • o: oktal
  • d: Decimal
  • x,X: Hexadecimalt (store bogstaver skrives med stort)
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 også kombineres med 0-fill og bruges ofte til at justere cifre i binær og 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

Bemærk, at antallet af nul-udfyldningstegn skal angives under hensyntagen til præfikset.

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

For binære og hexadecimale tal kan kun understregningen _ cifferadskilleren indsættes (Python 3.6 eller senere). Der anvendes 4-cifret separator; antallet af nul-tegn skal også tage højde for antallet af understregninger.

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

Kun heltalstypen int kan konvertere formatet til binært eller hexadecimalt format. Du kan bruge int() til at konvertere det til et tal.

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

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

Angiv antallet af cifre efter decimalkommaet

Du kan angive antallet af cifre efter decimalkommaet ved at gøre følgende: n er antallet af cifre. Antallet af cifre efter decimalkommaet bliver det angivne antal cifre uanset antallet af cifre i den hele taldel.
.[n]f

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

Venstre side af decimalpunktet kan angives som venstrejusteret, midterjusteret, højrejusteret eller nuludfyldt som beskrevet ovenfor. Hvis antallet af cifre i målværdien er større end det angivne antal, gøres der intet. Hvis antallet af cifre i målværdien er større end det angivne antal cifre, sker der intet.

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

Hvis du angiver et antal cifre mindre end det oprindelige antal cifre efter decimalkommaet, afrundes værdien. Bemærk, at dette ikke er afrunding til det nærmeste hele tal, men til et lige tal, f.eks. 0,5 afrundes til 0.

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

Hvis du ønsker at bruge generel afrunding, kan du bruge metoden quantize() i standardbiblioteket decimal.

eksponentiel notation

Når et floating-point float-tal konverteres til en streng str, skrives det automatisk i eksponentiel notation afhængigt af antallet af cifre. Det gør den hele taltype int ikke.

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

Hvis du angiver e eller E i formateringsspecifikationsstrengen, kan du altid konvertere til eksponentiel notation. De tegn, der anvendes i output, vil være henholdsvis e og E.

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

Det er også muligt at angive antallet af cifre efter decimalkommaet. Hele taldelen vil altid være ét ciffer, og decimalkommaet vil være det angivne antal cifre.

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

Bemærk, at hvis du angiver venstrejusteret, midterjusteret, højrejusteret eller nuludfyldt, vil e-, E+ osv. også blive regnet som cifre (tegn).

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

Signifikante tal (antal signifikante cifre)

Du kan angive det samlede antal cifre ved at gøre følgende Afhængigt af resultatet anvendes eksponentiel notation automatisk. Bemærk, at de afsluttende nuller efter decimalkommaet udelades.
.[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

Hvis du udelader g, vil resultatet ikke være et heltal. g er det samme i de fleste tilfælde, men kun i de tilfælde, hvor resultatet er et 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

Hvis vi behandler den samme værdi, får vi henholdsvis følgende.

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 tilfælde af g eller hvis det udelades, udelades de efterfølgende nuller efter decimalkommaet, så hvis du vil have det samme antal signifikante cifre (antal signifikante cifre), skal du bruge den eksponentielle notation e eller E. Hele taldelen er altid ét ciffer, og decimalkommaet er det angivne antal cifre, så hvis du vil have n signifikante cifre, skal du blot angive 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

Visning af procentdel

Hvis % er angivet i formateringsspecifikationsstrengen, multipliceres værdien af den numeriske float- eller int-værdi med 100 og konverteres til en streng med %.

Det er også muligt at angive antallet af cifre efter decimalkommaet. Standardværdien er seks cifre efter decimalkommaet. Venstre-justering, midter-justering, højre-justering og nuludfyldning er også tilgængelige. % tæller også som et tegn.

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