Konverzia formátu v jazyku Python, formát (vyplnenie nulou, exponenciálny zápis, hexadecimálny zápis atď.)

obchodné

Na prevod (formátovanie) čísla alebo reťazca do rôznych formátov v jazyku Python použite vstavanú funkciu format() alebo reťazcovú metódu str.format().

V tejto časti vysvetlíme, ako používať nasledujúce funkcie.

  • vstavaná funkcia (napr. v programovacom jazyku)format()
  • metóda reťazcastr.format()

Okrem toho je vysvetlený reťazec špecifikácie formátu na konverziu do nasledujúceho formátu so vzorovým kódom.

  • Zarovnané naľavo, Zarovnané na stred, Zarovnané napravo
  • nulová náplň
  • Znamienko (plus alebo mínus)
  • Oddeľovač číslic (čiarka, podčiarkovník)
  • Binárne, oktálne a hexadecimálne čísla
  • Zadajte počet číslic za desatinnou čiarkou
  • Významné čísla (počet významných číslic)
  • exponenciálny zápis
  • Zobrazenie percent

Všimnite si, že od verzie Python 3.6 boli do reťazcovej metódy str.format() pridané reťazce f (f-strings), aby bola stručnejšia.

Zabudovaná funkcia: format()

format() je k dispozícii ako štandardná vstavaná funkcia jazyka Python.

Osnova je nasledovná.

  • format(value, format_spec)
    • Prvý argument:value
      Pôvodná hodnota. String str, číslo int, float atď.
    • Druhý argumentformat_spec
      Reťazec špecifikácie formátu. Reťazec str
    • Vrátená hodnota: formátovaný reťazec str

Príklady sú uvedené nižšie. Typy formátovacích reťazcov a spôsob ich zápisu sú opísané neskôr.

V tomto príklade sme ako prvý argument použili číselné literály a reťazcové literály, ale samozrejme môžete použiť aj premenné, ktoré tieto hodnoty obsahujú.

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

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

String metóda str.format()

Pre typ string str existuje aj metóda format().

Pole {} v reťazci str, ktorý volá metódu format(), sa nazýva substitučné pole a je nahradené argumentom metódy format().

Reťazec špecifikácie formátu by sa mal zapísať do substitučného poľa {}, za ktorým nasleduje „:“.

Návratová hodnota je formátovaný reťazec str.

Proces ekvivalentný vyššie opísanej vstavanej funkcii format() je nasledovný.

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

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

Ako argumenty opäť používame číselné literály a reťazcové literály, ale prijateľné sú samozrejme aj premenné.

Zadávanie argumentov pre substitučné polia

Zadajte argumenty v poradí (predvolené)

Môže existovať viacero substitučných polí {} a štandardne sa argumenty metódy spracúvajú v poradí. Ak je reťazec špecifikácie formátu v {} vynechaný, bude len prevedený na reťazec funkciou str().

Užitočné na vkladanie hodnôt premenných do reťazca a ich tlač.

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

Zadanie pozičného argumentu pre celočíselné hodnoty

Ak je v {} zadaná celočíselná hodnota, napríklad {0} alebo {1}, výstup bude závisieť od poradia argumentov. To isté číslo sa môže použiť opakovane. To je užitočné, keď chcete vložiť rovnakú hodnotu do reťazca.

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

Zadávanie argumentov kľúčových slov pre ľubovoľné názvy (reťazce)

Môžete tiež zadať ľubovoľný názov v {} a zadať ho ako argument kľúčového slova.

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

Zadanie zoznamu alebo slovníka ako argumentu

Ako argumenty možno uviesť zoznamy a slovníky.

Na zadanie indexu zoznamu alebo kľúča slovníka v substitučnom poli použite []. Všimnite si, že úvodzovky „'“ a „“ sa nepoužívajú na zadanie kľúčov slovníka.

Ak chcete opakovane použiť rovnaký argument, musíte zadať celočíselnú hodnotu alebo reťazec (názov), ako je opísané vyššie.

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.

Možno ho rozšíriť ako pozičný argument pripojením * k zoznamu a uvedením ako argumentu alebo ako argument kľúčového slova pripojením ** k slovníku a uvedením ako argumentu.

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.

Popis kučeravých zátvoriek {}

Ak chcete v metóde format() napísať kučeravé zátvorky {,}, zopakujte ich dvakrát ako {{,}}. Všimnite si, že spätné lomítka nemožno escapovať.

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

formátovaný reťazec

V oboch prípadoch, ak chcete určiť formát, napíšte „:format string“ za celočíselnú hodnotu alebo reťazec názvov v {}.

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

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

V nasledujúcom texte vysvetlíme, ako určiť formát pomocou formátovacieho reťazca. V ukážke kódu je použitá metóda str.format(), ale rovnaký formátovací reťazec možno použiť aj pomocou vstavanej funkcie format(). Vo vstavanej funkcii format() sa reťazec špecifikujúci formát zadáva ako druhý argument.

Zarovnané naľavo, Zarovnané na stred, Zarovnané napravo

Nižšie môžete zarovnávať naľavo, na stred, napravo atď. Celkový počet znakov zadajte ako číslo.

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

Môžete tiež zadať znak, ktorý sa má vyplniť. Ak je vynechaný, ako vo vyššie uvedenom príklade, je to medzera.

Môžete používať dvojbajtové znaky, pokiaľ ide o jeden znak.

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

Pri pravom ospravedlnení pomocou > sa nezohľadňuje znamienko (-,+). Ak použijete =, za znamienkom nasleduje uvedený znak. Ak chcete zadať +, napíšte + za =. Podrobnosti o spracovaní znamienka sú opísané neskôr.

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 > môžu byť zadané pre reťazce, ale = spôsobí chybu ValueError. Ak chcete použiť = pre reťazec, musíte ho previesť na číslo pomocou funkcie int().

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

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

To isté platí aj pre čísla s pohyblivou rádovou čiarkou. Desatinná čiarka sa tiež počíta ako znak.

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

Zoznamy, tuply atď. spôsobia chybu, ak sú zadané tak, ako sú, a môžu byť prevedené na reťazce pomocou funkcie 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]*****

Pre ľavé zarovnanie, stredové zarovnanie a pravé zarovnanie existujú aj špeciálne metódy pre reťazce s názvami ljust(), center() a rjust().

0 náplň

Ak chcete upraviť počet číslic vyplnením nulou, nastavte znak, ktorý sa má vyplniť, na hodnotu 0 a zarovnajte ho doprava.

V prípade nulového plnenia, ak je symbol zarovnania vynechaný, spracuje sa, ako keby bolo uvedené =.

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

=Ak zadáte ako argument reťazec, ako je popísané vyššie, zobrazí sa chyba. Buďme opatrní.

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

Na vyplnenie nulou existuje aj špeciálna metóda pre reťazce s názvom zfill().

Znamienko (plus alebo mínus)

Predvolene sú znamienkom (mínus-) označené len záporné čísla.

Ak sa do reťazca špecifikácie formátovania pridá znak +, zobrazí sa znamienko (plus +) aj pre kladné čísla. Ak sa pridá medzera, na začiatku kladného čísla sa zobrazí medzera a počet číslic sa zarovná so záporným číslom.

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

Pri vypĺňaní ľubovoľnými znakmi, ako je napríklad vyššie uvedené vypĺňanie nulou, buďte opatrní. Predvolené nastavenie bez + a bez medzier vyplní kladné čísla o jeden znak viac.

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

Ak sa používa symbol zarovnania, symbol označenia značky by sa mal napísať za symbol zarovnania.

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

Oddeľovač číslic (čiarka, podčiarkovník)

Každé tri číslice oddeľte čiarkou alebo podčiarkovníkom _. Tým sa uľahčí čítanie veľkých čísel. Všimnite si, že podčiarkovník_ je voľba pridaná v Pythone 3.6, takže ju nemožno použiť v predchádzajúcich verziách.

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

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

V prípade typu čísla s pohyblivou rádovou čiarkou float je ohraničená len celočíselná časť.

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

Binárne, oktálne a hexadecimálne čísla

Konvertuje číselné hodnoty na binárne, oktálové a hexadecimálne čísla na výstup.

  • b: Binárne
  • o: Osmičkový
  • d: Desatinné číslo
  • x,X: Hexadecimálne (veľké písmená sú veľké)
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

Môže sa tiež kombinovať s 0-fill a často sa používa na zarovnanie číslic v binárnom a hexadecimálnom zápise.

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

Všimnite si, že počet znakov s nulovou výplňou sa musí určiť s prihliadnutím na prefix.

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

V prípade binárnych a hexadecimálnych čísel je možné vložiť iba oddeľovač číslic _ (Python 3.6 alebo novší). Používa sa 4-miestny oddeľovač; počet znakov vyplnených nulou musí zohľadňovať aj počet podčiarkovníkov.

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

Iba celočíselný typ int môže konvertovať formát na binárny alebo hexadecimálny. Na prevod na číslo môžete použiť funkciu int().

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

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

Zadajte počet číslic za desatinnou čiarkou

Ak chcete určiť počet číslic za desatinnou čiarkou, postupujte takto: n je počet číslic. Počet číslic za desatinnou čiarkou sa stane zadaným počtom číslic bez ohľadu na počet číslic v celočíselnej časti.
.[n]f

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

Ľavú stranu desatinnej čiarky možno určiť ako ľavostrannú, stredovú, pravostrannú alebo vyplnenú nulou, ako je opísané vyššie. Ak je počet číslic cieľovej hodnoty väčší ako zadaný počet, nič sa nevykoná. Ak je počet číslic cieľovej hodnoty väčší ako zadaný počet číslic, nevykoná sa nič.

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

Ak zadáte počet číslic menší ako pôvodný počet číslic za desatinnou čiarkou, hodnota sa zaokrúhli. Všimnite si, že sa nezaokrúhľuje na najbližšie celé číslo, ale na párne číslo, napr. 0,5 sa zaokrúhli na 0.

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

Ak chcete použiť všeobecné zaokrúhľovanie, môžete použiť metódu quantize() štandardnej knižnice decimal.

exponenciálny zápis

Keď sa číslo s pohyblivou rádovou čiarkou konvertuje na reťazec str, automaticky sa zapíše v exponenciálnom zápise v závislosti od počtu číslic. Celočíselný typ int to nerobí.

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

Ak v reťazci špecifikácie formátovania zadáte e alebo E, môžete vždy previesť na exponenciálny zápis. Vo výstupe sa použijú znaky e, resp. e.

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

Je možné určiť aj počet číslic za desatinnou čiarkou. Celočíselná časť bude vždy jedna číslica a za desatinnou čiarkou bude zadaný počet číslic.

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

Všimnite si, že ak zadáte ľavé zarovnanie, stredové zarovnanie, pravé zarovnanie alebo vyplnenie nulou, e-, E+ atď. sa tiež budú počítať ako číslice (znaky).

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

Významné čísla (počet významných číslic)

Celkový počet číslic môžete určiť nasledujúcim spôsobom V závislosti od výsledku sa automaticky použije exponenciálny zápis. Všimnite si, že koncové nuly za desatinnou čiarkou budú vynechané.
.[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

Ak vynecháte g, výstupom nebude celé číslo. g je rovnaké vo väčšine prípadov, ale len v prípadoch, keď je výstupom celé číslo.

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

Ak spracujeme rovnakú hodnotu, dostaneme nasledujúce hodnoty.

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

V prípade g alebo ak sa vynechá, vynechajú sa koncové nuly za desatinnou čiarkou, takže ak chcete vypisovať rovnaký počet významných čísel (počet významných číslic), použite exponenciálny zápis e alebo E. Celočíselná časť je vždy jedna číslica a desatinná čiarka je zadaný počet číslic, takže ak chcete vypisovať n významných číslic, stačí zadať 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

Zobrazenie percent

Ak je v reťazci špecifikácie formátovania uvedené %, číselná hodnota float alebo int sa vynásobí 100 a prevedie na reťazec s %.

Je možné určiť aj počet číslic za desatinnou čiarkou. Predvolená hodnota je šesť číslic za desatinnou čiarkou. K dispozícii sú aj možnosti ľavého vyrovnania, vyrovnania na stred, pravého vyrovnania a vyplnenia nulou. Znak % sa tiež počíta ako znak.

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