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ódszer
str.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()
- String módszer str.format()
- Balra igazított, Középre igazított, Jobbra igazított
- 0 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
- exponenciális jelölés
- Jelölőszámok (a szignifikáns számjegyek száma)
- Százalékos kijelzés
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: a
value
Az eredeti érték. String str, number int, float stb. - A második érv
format_spec
Formátum-specifikációs karakterlánc. String str - Visszatérési érték: egy formázott string str
- Az első érv: a
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áriso: Octald: Decimalx,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%
