Formátumkonverzió Pythonban, formátum (nullfeltöltés, exponenciális jelölés, hexadecimális, stb.)

Üzleti

A Pythonban egy szám vagy egy karakterlánc különböző formátumokba történő átalakításához (formázásához) használja a beépített format() függvényt vagy a str.format() karakterlánc-módszert.

Ebben a szakaszban a következő funkciók használatát ismertetjük.

  • beépített függvény (pl. programozási nyelvben)format()
  • string módszerstr.format()

Ezenkívül a következő formátumba való konvertáláshoz szükséges formátum-specifikációs karakterláncot is ismertetjük a mintakóddal.

  • Balra igazított, Középre igazított, Jobbra igazított
  • nulla töltés
  • Jel (plusz vagy mínusz)
  • Számválasztó (vessző, aláhúzás)
  • Bináris, oktális és hexadecimális számok
  • A tizedesvessző utáni számjegyek számának megadása
  • Jelölőszámok (a szignifikáns számjegyek száma)
  • exponenciális jelölés
  • Százalékos kijelzés

Megjegyezzük, hogy a Python 3.6 óta az f-stringek (f-strings) hozzáadódtak a string módszerhez str.format(), hogy tömörebbé tegyék azt.

Beépített funkció: format()

A format() egy szabványos Python beépített függvény.

A vázlat a következő.

  • format(value, format_spec)
    • Az első érv: avalue
      Az eredeti érték. String str, number int, float stb.
    • A második érvformat_spec
      Formátum-specifikációs karakterlánc. String str
    • Visszatérési érték: egy formázott string str

Példák az alábbiakban láthatók. A formázott karakterláncok típusait és megírását később ismertetjük.

Ebben a példában numerikus literálokat és string literálokat használtunk első argumentumként, de természetesen használhatunk olyan változókat is, amelyek tartalmazzák ezeket az értékeket.

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

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

String módszer str.format()

Van egy format() metódus a string str típushoz is.

A format() metódust hívó str karakterláncban lévő {}-t helyettesítő mezőnek nevezzük, és azt a format() metódus argumentuma helyettesíti.

A formátum-specifikációs karakterláncot a {} helyettesítési mezőbe kell írni, amelyet a “:” követ.

A visszatérési érték egy formázott str karakterlánc.

A fent leírt format() beépített függvénnyel egyenértékű folyamat a következő.

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

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

Ismét numerikus literálokat és string literálokat használunk argumentumként, de természetesen a változók is elfogadhatók.

Érvek megadása a helyettesítési mezőkhöz

Az argumentumok sorrendben történő megadása (alapértelmezett)

Több helyettesítő mező is lehet {}, és alapértelmezés szerint a módszer argumentumai sorrendben kerülnek feldolgozásra. Ha a formátum specifikációs karakterláncot a {}-ben elhagyjuk, akkor az str() egyszerűen karakterlánccá konvertálja.

Hasznos a változó értékek stringbe való beillesztéséhez és kinyomtatásához.

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

Pozicionális argumentum megadása egész értékek esetén

Ha egy egész számérték van megadva a {} sorban, például {0} vagy {1}, a kimenet az argumentumok sorrendjétől függ. Ugyanaz a szám többször is használható. Ez akkor hasznos, ha ugyanazt az értéket akarja beilleszteni egy karakterláncba.

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

Kulcsszóargumentumok megadása tetszőleges nevekhez (karakterláncok)

Bármilyen nevet megadhat a {} mezőben, és megadhatja kulcsszó-argumentumként is.

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

Egy lista vagy szótár megadása argumentumként

A listák és szótárak megadhatók argumentumként.

A [] használatával megadhatja egy lista indexét vagy egy szótár kulcsát egy helyettesítési mezőben. Vegye figyelembe, hogy a “'” és “” idézőjelek nem használhatók szótárkulcsok megadására.

Ha ugyanazt az argumentumot többször szeretné használni, akkor egy egész számértéket vagy egy karakterláncot (nevet) kell megadnia a fent leírtak szerint.

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.

Kiterjeszthető pozicionális argumentumként a listához * hozzáadásával és argumentumként való megadásával, vagy kulcsszó argumentumként a szótárhoz ** hozzáadásával és argumentumként való megadásával.

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.

A görbe zárójelek leírása {}

Ha a format() metódusban {,} szögletes zárójeleket akarsz írni, ismételd meg kétszer, mint {{,}}}. Vegye figyelembe, hogy a backslashek nem szedhetők ki.

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

formázott karakterlánc

Mindkét esetben a formátum megadásához írjon “:format string” az egész érték vagy a névsor után {}.

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

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

A következőkben elmagyarázzuk, hogyan adhatjuk meg a formátumot egy formázó karakterlánc segítségével. A mintakód az str.format() karakterlánc-módszert használja, de ugyanez a formázó karakterlánc használható a beépített format() függvénnyel is. A beépített format() függvényben a formátum specifikációs karakterláncot második argumentumként adjuk meg.

Balra igazított, Középre igazított, Jobbra igazított

Az alábbiakban balra igazított, középre igazított, jobbra igazított stb. igazítást végezhet. Adja meg a karakterek teljes számát számként.

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

Megadhat egy kitöltendő karaktert is. Ha kihagyja, mint a fenti példában, akkor szóköz lesz.

Használhat kétbájtos karaktereket is, amíg az egy karakter.

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

A jobbra igazítás a > segítségével nem veszi figyelembe a (-,+) előjelet. Az = használata esetén a jelet a megadott karakter követi. Ha a + jelet akarja megadni, akkor az = után írjon +-t. Az előjelek feldolgozásának részleteit később ismertetjük.

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

A <, ^ és > karakterláncok esetében megadható, de az = hibát eredményez ValueError. Ha = értéket akarsz használni egy karakterláncra, akkor azt az int() segítségével számmá kell konvertálnod.

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

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

Ugyanez vonatkozik a lebegőpontos számokra is. A tizedespontok is karakterként számítanak.

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

A listák, tuple-ok stb. hibát okoznak, ha úgy adjuk meg őket, ahogy vannak, és a str() segítségével konvertálhatók karakterláncokká.

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]*****

A balra igazított, középre igazított és jobbra igazított karakterláncokhoz is vannak külön karakterlánc-módszerek, az ljust(), center() és rjust().

0 töltés

Ha a számjegyek számát nullás kitöltéssel kívánja beállítani, állítsa a kitöltendő karaktert 0-ra, és igazítsa jobbra.

Nulla kitöltés esetén, ha az igazítási szimbólum kimarad, akkor úgy kell feldolgozni, mintha = lenne megadva.

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

=Ha a fent leírtak szerint egy karakterláncot adsz meg argumentumként, hibaüzenetet kapsz. Legyünk óvatosak.

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

A nullfeltöltéshez van egy külön string metódus is, a zfill().

Jel (plusz vagy mínusz)

Alapértelmezés szerint csak a negatív számokat jelöli előjellel (mínusz-).

Ha a formázási specifikációs karakterlánchoz hozzáadjuk a + jelet, akkor a pozitív számok esetében egy jel (plusz +) is megjelenik. Ha szóköz kerül hozzáadásra, akkor a pozitív szám elején egy szóköz jelenik meg, és a számjegyek száma a negatív számhoz igazodik.

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

Legyen óvatos, amikor tetszőleges karakterekkel tölti ki a karaktereket, mint például a fent említett nullás kitöltés. Az alapértelmezett, + és szóköz nélküli, pozitív számokat eggyel több karakterrel tölt ki.

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

Igazítási szimbólum használata esetén a jelkijelölő szimbólumot az igazítási szimbólum után kell írni.

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

Számválasztó (vessző, aláhúzás)

Minden három számjegy után vesszőt vagy aláhúzást _ válasszon el. Ez megkönnyíti a nagy számok olvasását. Vegye figyelembe, hogy az underscore_ a Python 3.6-ban hozzáadott opció, így a korábbi verziókban nem használható.

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

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

A lebegőpontos lebegőpontos számok esetében csak az egészértékű rész van körülhatárolva.

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

Bináris, oktális és hexadecimális számok

A numerikus értékeket bináris, oktális és hexadecimális számokká konvertálja a kimenethez.

  • b: Bináris
  • o: Octal
  • d: Decimal
  • x,X: Hexadecimális (a nagybetűket nagybetűvel írjuk)
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

A 0 kitöltéssel is kombinálható, és gyakran használják a bináris és hexadecimális jelölésekben a számjegyek igazítására.

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

Vegye figyelembe, hogy a nulladik karakterek számát az előtag figyelembevételével kell megadni.

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

A bináris és hexadecimális számok esetében csak az aláhúzás _ számjegy elválasztójelet lehet beilleszteni (Python 3.6 vagy újabb). 4 számjegyű elválasztójelet használunk; a nullával kitöltött karakterek számánál figyelembe kell venni az aláhúzások számát is.

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

Csak az int egész szám típus képes a formátumot bináris vagy hexadecimális formátumra konvertálni. Az int() segítségével számmá konvertálhatjuk.

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

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

A tizedesvessző utáni számjegyek számának megadása

A tizedesvessző utáni számjegyek számának megadásához tegye a következőket: n a számjegyek száma. A tizedesvessző utáni számjegyek száma a megadott számjegyek száma lesz, függetlenül az egész rész számjegyeinek számától.
.[n]f

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

A tizedesvessző bal oldala a fent leírtak szerint balra igazított, középre igazított, jobbra igazított vagy nullával kitöltött lehet. Ha a célérték számjegyeinek száma több, mint a megadott szám, akkor nem történik semmi. Ha a célérték számjegyeinek száma nagyobb, mint a megadott számjegyek száma, akkor nem történik semmi.

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

Ha a tizedesvessző utáni számjegyek eredeti számánál kevesebbet ad meg, az értéket kerekíteni fogja. Vegye figyelembe, hogy ez nem a legközelebbi egész számra, hanem páros számra kerekít, például a 0,5 0-ra lesz kerekítve.

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

Ha általános kerekítést akarsz használni, használhatod a standard könyvtár decimal quantize() metódusát.

exponenciális jelölés

Amikor egy lebegőpontos lebegőpontos számot str karakterlánccá alakítunk, akkor az automatikusan exponenciális jelöléssel íródik a számjegyek számától függően. Az int típusú egész számok esetében ez nem így van.

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

Ha a formázási specifikációs karakterláncban e vagy E értéket ad meg, akkor mindig átkonvertálhatja az exponenciális jelölést. A kimeneten használt karakterek e, illetve E lesznek.

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

Lehetőség van a tizedesvessző utáni számjegyek számának megadására is. Az egész szám része mindig egy számjegy lesz, a tizedesvessző pedig a megadott számjegyek száma.

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

Vegye figyelembe, hogy ha balra igazított, középre igazított, jobbra igazított vagy nullával kitöltött karaktert ad meg, akkor az e-, E+ stb. is számjegyeknek (karaktereknek) számítanak.

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

Jelölőszámok (a szignifikáns számjegyek száma)

A számjegyek teljes számát a következőkkel adhatja meg Az eredménytől függően automatikusan exponenciális jelölés kerül alkalmazásra. Vegye figyelembe, hogy a tizedesvessző utáni utolsó nullák kimaradnak.
.[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

Ha kihagyja a g-t, a kimenet nem egész szám lesz. g a legtöbb esetben ugyanaz, de csak abban az esetben, ha a kimenet egész szám.

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

Ha ugyanazt az értéket feldolgozzuk, akkor a következőket kapjuk.

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

A g esetében, vagy ha elhagyjuk, a tizedespont utáni utolsó nullák kimaradnak, így ha ugyanannyi szignifikáns számjegyet (szignifikáns számjegyek számát) szeretnénk kiadni, használjuk az e vagy E exponenciális jelölést. Az egész szám része mindig egy számjegy, a tizedespont pedig a megadott számjegyek száma, így ha n szignifikáns számjegyet szeretnénk kiadni, csak n-1-et kell megadni.

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

Százalékos kijelzés

Ha a formázási specifikációs karakterláncban % van megadva, a numerikus float vagy int értékét megszorozza 100-zal, és a % értékkel karakterlánccá alakítja.

Lehetőség van a tizedesvessző utáni számjegyek számának megadására is. Az alapértelmezett érték hat számjegy a tizedesvessző után. A balra igazítás, középre igazítás, jobbra igazítás és a nulla kitöltése is elérhető. A % szintén karakterként számít.

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%