Formaat conversie in Python, formaat (nul-vulling, exponentiële notatie, hexadecimaal, etc.)

Bedrijf

Om een getal of string om te zetten (formatteren) in verschillende formaten in Python, gebruik je de ingebouwde functie format() of de string methode str.format().

In deze sectie wordt uitgelegd hoe de volgende functies gebruikt kunnen worden.

  • ingebouwde functie (bv. in een programmeertaal)format()
  • tekenreeksmethodestr.format()

Bovendien wordt de formaatspecificatiestring voor de conversie naar het volgende formaat toegelicht met voorbeeldcode.

  • Links uitgelijnd, Midden uitgelijnd, Rechts uitgelijnd
  • nulvulling
  • Teken (plus of min)
  • Cijferscheidingsteken (komma, underscore)
  • Binaire, octale, en hexadecimale getallen
  • Geef het aantal cijfers achter de komma aan
  • Significante cijfers (aantal significante cijfers)
  • exponentiële notatie
  • Percentage weergave

Merk op dat sinds Python 3.6, f-teksten (f-strings) zijn toegevoegd aan de string methode str.format() om het beknopter te maken.

Ingebouwde functie: format()

format() wordt geleverd als een standaard ingebouwde Python-functie.

Het schema is als volgt.

  • format(value, format_spec)
    • Het eerste argument: devalue
      De oorspronkelijke waarde. String str, getal int, float, enz.
    • Het tweede argumentformat_spec
      Formaat specificatie string. String str
    • Terugkeerwaarde: een geformatteerde string str

Voorbeelden worden hieronder getoond. De types van format strings en hoe ze te schrijven worden later beschreven.

In dit voorbeeld hebben we numerieke literalen en string-literalen als eerste argument gebruikt, maar u kunt natuurlijk variabelen gebruiken die deze waarden bevatten.

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

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

Tekenreeksmethode str.format()

Er is ook een format() methode voor het string str type.

De {} in de string str die de format() methode aanroept wordt het substitutieveld genoemd, en wordt vervangen door het argument van de format() methode.

De formaatspecificatiestring moet in het substitutieveld {} worden geschreven, gevolgd door “:”.

De terugkeerwaarde is een geformatteerde string str.

Het equivalent van de hierboven beschreven ingebouwde functie format() is als volgt.

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

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

Ook hier gebruiken we numerieke literalen en string-literalen als argumenten, maar variabelen zijn natuurlijk ook aanvaardbaar.

Specificeren van argumenten voor substitutievelden

Geef de argumenten in volgorde op (standaard)

Er kunnen meerdere substitutievelden {} zijn, en standaard worden de methode-argumenten in volgorde verwerkt. Als de format specificatie string in {} wordt weggelaten, zal het gewoon worden geconverteerd naar een string door str().

Nuttig voor het invoegen van variabele waarden in een string en het afdrukken ervan.

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

Geef een positioneel argument voor gehele waarden

Indien een gehele waarde wordt opgegeven in {}, zoals {0} of {1}, zal de uitvoer afhangen van de volgorde van de argumenten. Hetzelfde getal kan herhaaldelijk worden gebruikt. Dit is handig wanneer u dezelfde waarde in een string wilt invoegen.

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

Geef trefwoordargumenten voor willekeurige namen (strings)

U kunt ook een willekeurige naam opgeven in {} en deze als trefwoordargument invoeren.

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

Geef een lijst of woordenboek als argument

Lijsten en woordenboeken kunnen als argumenten worden opgegeven.

Gebruik [] om de index van een lijst of de sleutel van een woordenboek in een substitutieveld op te geven. Merk op dat aanhalingstekens “'” en “” niet gebruikt worden om woordenboeksleutels te specificeren.

Indien u hetzelfde argument herhaaldelijk wilt gebruiken, moet u een integer waarde of een string (naam) specificeren zoals hierboven beschreven.

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.

Het kan worden uitgebreid als een positioneel argument door * aan de lijst toe te voegen en het als argument te specificeren, of als een trefwoordargument door ** aan het woordenboek toe te voegen en het als argument te specificeren.

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.

Beschrijving van accolades {}

Als u accolades {,} in de format() methode wilt schrijven, herhaal het dan twee keer als {{,}}. Merk op dat backslashes niet kunnen worden ge-escaped.

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

geformatteerde string

In beide gevallen, om het formaat te specificeren, schrijf “:format string” na de integer waarde of naam string in {}.

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

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

In het volgende zullen we uitleggen hoe je het formaat specificeert met behulp van een format string. De voorbeeldcode gebruikt de string methode str.format(), maar dezelfde format string kan worden gebruikt met de ingebouwde functie format(). In de ingebouwde functie format(), wordt de format string gespecificeerd als het tweede argument.

Links uitgelijnd, Midden uitgelijnd, Rechts uitgelijnd

U kunt links uitgelijnd, gecentreerd uitgelijnd, rechts uitgelijnd, enz. hieronder. Geef het totaal aantal tekens op als een getal.

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

U kunt ook een teken opgeven dat moet worden ingevuld. Indien weggelaten, zoals in het voorbeeld hierboven, is het een spatie.

U kunt double-byte tekens gebruiken, zolang het maar één enkel teken is.

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

Rechts uitlijnen met > houdt geen rekening met het teken (-,+). Als u = gebruikt, wordt het teken gevolgd door het opgegeven teken. Als u + wilt specificeren, schrijf dan + na =. De details van de tekenverwerking worden later beschreven.

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

<, ^, en > kunnen worden opgegeven voor strings, maar = zal resulteren in een fout ValueError. Als je = wilt gebruiken voor een tekenreeks, moet je het omzetten naar een getal met int().

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

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

Hetzelfde geldt voor drijvende-kommagetallen. Decimale punten worden ook geteld als een teken.

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

Lijsten, tupels, enz. zullen een fout veroorzaken als ze als zodanig worden opgegeven, en kunnen worden geconverteerd naar strings met 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]*****

Voor links uitgelijnd, gecentreerd uitgelijnd, en rechts uitgelijnd zijn er ook speciale string methoden genaamd ljust(), center(), en rjust().

0 vulling

Als u het aantal cijfers wilt aanpassen door nulvulling, zet u het te vullen teken op 0 en maakt u het rechts uit.

In het geval van nulvulling, als het uitlijningssymbool is weggelaten, wordt het verwerkt alsof = was opgegeven.

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

=Als je een string als argument opgeeft, zoals hierboven beschreven, krijg je een foutmelding. Laten we voorzichtig zijn.

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

Voor nulvulling is er ook een speciale string-methode genaamd zfill().

Teken (plus of min)

Standaard worden alleen negatieve getallen gemarkeerd met een teken (min-).

Wanneer + wordt toegevoegd aan de opmaakspecificatiestring, wordt ook een teken (plus +) weergegeven voor positieve getallen. Als een spatie wordt toegevoegd, wordt een spatie weergegeven aan het begin van het positieve getal, en wordt het aantal cijfers uitgelijnd met het negatieve getal.

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

Wees voorzichtig bij het vullen met willekeurige tekens, zoals de nulvulling die hierboven werd vermeld. De standaardinstelling, zonder + en zonder spaties, vult positieve getallen met een extra teken.

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

Indien een uitlijningssymbool wordt gebruikt, moet het tekenaanduidingssymbool na het uitlijningssymbool worden geschreven.

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

Cijferscheidingsteken (komma, underscore)

Voeg een komma of underscore _ toe als scheidingsteken om de drie cijfers. Dit maakt grote getallen gemakkelijker te lezen. Merk op dat underscore_ een optie is die in Python 3.6 is toegevoegd, dus het kan niet in eerdere versies worden gebruikt.

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

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

In het geval van floating-point getal-types wordt alleen het gehele getaldeel begrensd.

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

Binaire, octale, en hexadecimale getallen

Converteert numerieke waarden naar binaire, octale en hexadecimale getallen voor uitvoer.

  • b: Binair
  • o: Octal
  • d: Decimal
  • x,X: Hexadecimaal (hoofdletters zijn hoofdletters)
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

Het kan ook worden gecombineerd met 0-fill, en wordt vaak gebruikt om cijfers in binaire en hexadecimale notatie uit te lijnen.

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

Merk op dat het aantal nulvultekens moet worden gespecificeerd rekening houdend met het voorvoegsel.

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

Voor binaire en hexadecimale getallen kan alleen de underscore _ cijfer scheidingsteken worden ingevoegd (Python 3.6 of later). Het scheidingsteken met 4 cijfers wordt gebruikt; bij het aantal met nul ingevulde tekens moet ook rekening worden gehouden met het aantal underscores.

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

Alleen het integer type int kan het formaat omzetten naar binair of hexadecimaal. Je kunt int() gebruiken om het om te zetten naar een getal.

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

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

Geef het aantal cijfers achter de komma aan

Om het aantal cijfers na de decimale komma te specificeren, doet u het volgende: n is het aantal cijfers. Het aantal cijfers na de decimale komma wordt het opgegeven aantal cijfers, ongeacht het aantal cijfers in het gehele getal.
.[n]f

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

De linkerkant van de decimale punt kan worden gespecificeerd als links uitgelijnd, in het midden uitgelijnd, rechts uitgelijnd, of met nul gevuld, zoals hierboven beschreven. Als het aantal cijfers van de doelwaarde groter is dan het gespecificeerde aantal, wordt niets gedaan. Indien het aantal cijfers in de doelwaarde groter is dan het gespecificeerde aantal cijfers, wordt niets gedaan.

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

Indien u een aantal cijfers kleiner dan het oorspronkelijke aantal cijfers achter de komma opgeeft, zal de waarde worden afgerond. Merk op dat hierbij niet wordt afgerond op het dichtstbijzijnde gehele getal, maar op een even getal, bv. 0,5 wordt afgerond op 0.

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

Als u algemene afronding wilt gebruiken, kunt u de methode quantize() van de standaardbibliotheek decimal gebruiken.

exponentiële notatie

Wanneer een drijvend-kommagetal wordt geconverteerd naar een string str, zal het automatisch worden geschreven in exponentiële notatie, afhankelijk van het aantal cijfers. Het integer type int doet dat niet.

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

Als je e of E specificeert in de opmaakspecificatiestring, kun je altijd converteren naar exponentiële notatie. De tekens die in de uitvoer worden gebruikt zijn dan respectievelijk e en E.

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

Het is ook mogelijk het aantal cijfers achter de komma op te geven. Het gehele getal zal altijd één cijfer zijn en de decimale punt zal het opgegeven aantal cijfers zijn.

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

Merk op dat indien u links uitgelijnd, gecentreerd uitgelijnd, rechts uitgelijnd, of met nul gevuld opgeeft, e-, E+, enz. ook als cijfers (karakters) zullen worden geteld.

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

Significante cijfers (aantal significante cijfers)

U kunt het totale aantal cijfers als volgt opgeven Afhankelijk van het resultaat wordt automatisch de exponentiële notatie gebruikt. Nullen achter de komma worden weggelaten.
.[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

Als je g weglaat, zal de uitvoer geen geheel getal zijn. g is hetzelfde in de meeste gevallen, maar alleen in gevallen waar de uitvoer een geheel getal is.

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

Als we dezelfde waarde verwerken, krijgen we respectievelijk het volgende.

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

In het geval van g of als het wordt weggelaten, worden de achterliggende nullen achter de komma weggelaten, dus als je hetzelfde aantal significante cijfers (aantal significante cijfers) wilt uitvoeren, gebruik dan de exponentiële notatie van e of E. Het gehele getal is altijd één cijfer en de komma is het opgegeven aantal cijfers, dus als je n significante cijfers wilt uitvoeren, geef je gewoon n-1 op.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

Percentage weergave

Als % is gespecificeerd in de opmaakspecificatie string, wordt de waarde van de numerieke float of int vermenigvuldigd met 100 en geconverteerd naar een string met %.

Het is ook mogelijk om het aantal cijfers achter de komma op te geven. De standaardinstelling is zes cijfers na de komma. Links uitlijnen, midden uitlijnen, rechts uitlijnen en nul invullen zijn ook beschikbaar. De % wordt ook geteld als een teken.

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