Převod formátu v jazyce Python, formát (vyplňování nulou, exponenciální zápis, hexadecimální zápis atd.)

Podnikání

Chcete-li v jazyce Python převést (formátovat) číslo nebo řetězec do různých formátů, použijte vestavěnou funkci format() nebo řetězcovou metodu str.format().

V této části vysvětlíme, jak používat následující funkce.

  • vestavěná funkce (např. v programovacím jazyce)format()
  • metoda řetězcestr.format()

Kromě toho je vysvětlen řetězec specifikace formátu pro převod do následujícího formátu s ukázkovým kódem.

  • Srovnané vlevo, Srovnané uprostřed, Srovnané vpravo
  • nulové plnění
  • Znaménko (plus nebo minus)
  • Oddělovač číslic (čárka, podtržítko)
  • Binární, osmičková a šestnáctková čísla
  • Zadejte počet číslic za desetinnou čárkou.
  • Významná čísla (počet významných číslic)
  • exponenciální zápis
  • Zobrazení procent

Všimněte si, že od verze Python 3.6 byly do řetězcové metody str.format() přidány f-řetězce (f-strings), aby byla stručnější.

Vestavěná funkce: format()

format() je k dispozici jako standardní vestavěná funkce jazyka Python.

Osnova je následující.

  • format(value, format_spec)
    • První argument:value
      Původní hodnota. String str, číslo int, float atd.
    • Druhý argumentformat_spec
      Řetězec specifikace formátu. String str
    • Návratová hodnota: formátovaný řetězec str

Příklady jsou uvedeny níže. Typy formátovacích řetězců a způsob jejich zápisu jsou popsány později.

V tomto příkladu jsme jako první argument použili číselné a řetězcové literály, ale samozřejmě můžete použít i proměnné, které tyto hodnoty obsahují.

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

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

Metoda String str.format()

Pro typ string str existuje také metoda format().

Pole {} v řetězci str, který volá metodu format(), se nazývá substituční pole a je nahrazeno argumentem metody format().

Řetězec specifikace formátu by měl být zapsán v substitučním poli {}, za kterým následuje „:“.

Návratovou hodnotou je formátovaný řetězec str.

Ekvivalentní postup k výše popsané vestavěné funkci format() je následující.

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

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

Jako argumenty opět používáme číselné literály a řetězcové literály, ale samozřejmě jsou přípustné i proměnné.

Zadávání argumentů pro substituční pole

Zadejte argumenty v pořadí (výchozí)

Může existovat více substitučních polí {} a ve výchozím nastavení se argumenty metody zpracovávají v pořadí. Pokud je řetězec specifikace formátu v {} vynechán, bude pouze převeden na řetězec pomocí funkce str().

Užitečné pro vkládání hodnot proměnných do řetězce a jejich tisk.

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

Zadání pozičního argumentu pro celočíselné hodnoty

Pokud je v {} zadána celočíselná hodnota, například {0} nebo {1}, bude výstup záviset na pořadí argumentů. Stejné číslo lze použít opakovaně. To je užitečné, když chcete do řetězce vložit stejnou hodnotu.

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

Zadání argumentů klíčových slov pro libovolné názvy (řetězce)

Můžete také zadat libovolný název v {} a zadat jej jako argument klíčového slova.

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

Jako argument zadejte seznam nebo slovník

Jako argumenty lze zadat seznamy a slovníky.

K zadání indexu seznamu nebo klíče slovníku v substitučním poli použijte []. Všimněte si, že uvozovky „'“ a „“ se pro zadání klíčů slovníků nepoužívají.

Pokud chcete opakovaně použít stejný argument, musíte zadat celočíselnou hodnotu nebo řetězec (název), jak je popsáno výše.

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.

Lze jej rozšířit jako poziční argument připojením * k seznamu a jeho uvedením jako argumentu nebo jako argument klíčového slova připojením ** ke slovníku a jeho uvedením jako 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 kudrnatých závorek {}

Pokud chcete v metodě format() zapsat kudrnaté závorky {,}, zopakujte je dvakrát jako {{,}}. Všimněte si, že zpětná lomítka nelze escapovat.

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

formátovaný řetězec

V obou případech zadejte formát tak, že za celočíselnou hodnotu nebo jmenný řetězec v {} napíšete „:format string“.

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

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

V následujícím textu vysvětlíme, jak zadat formát pomocí formátovacího řetězce. Ukázkový kód používá řetězcovou metodu str.format(), ale stejný formátovací řetězec lze použít i pomocí vestavěné funkce format(). Ve vestavěné funkci format() je jako druhý argument uveden řetězec pro specifikaci formátu.

Srovnané vlevo, Srovnané uprostřed, Srovnané vpravo

Níže můžete zarovnávat vlevo zarovnané, na střed zarovnané, vpravo zarovnané atd. Celkový počet znaků zadejte jako číslo.

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

Můžete také zadat znak, který se má vyplnit. Pokud je vynechán, jako ve výše uvedeném příkladu, je to mezera.

Můžete použít dvoubajtové znaky, pokud se jedná 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

Pravé ospravedlnění pomocí > nebere v úvahu znaménko (-,+). Pokud použijete =, za znaménkem následuje zadaný znak. Pokud chcete zadat +, napište + za =. Podrobnosti o zpracování znaku jsou popsány později.

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

Pro řetězce lze zadat <, ^ a >, ale = způsobí chybu ValueError. Pokud chcete použít = pro řetězec, musíte jej převést na číslo pomocí funkce int().

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

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

Totéž platí pro čísla s pohyblivou řádovou čárkou. Desetinná čárka se také počítá jako 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

Seznamy, tuply atd. způsobí chybu, pokud jsou zadány tak, jak jsou, a lze je převést na řetězce pomocí funkce 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]*****

Pro metody left-justified, center-justified a right-justified existují také speciální řetězcové metody ljust(), center() a rjust().

0 náplň

Pokud chcete upravit počet číslic vyplněním nulou, nastavte znak, který má být vyplněn, na hodnotu 0 a zarovnejte jej doprava.

V případě nulového vyplnění, pokud je symbol zarovnání vynechán, se zpracovává, jako by bylo uvedeno =.

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

=Pokud jako argument zadáte řetězec, jak je popsáno výše, dojde k chybě. Buďme opatrní.

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

Pro vyplnění nulou existuje také speciální řetězcová metoda zfill().

Znaménko (plus nebo minus)

Ve výchozím nastavení jsou znaménkem (minus-) označena pouze záporná čísla.

Pokud je do řetězce specifikace formátování přidáno znaménko +, zobrazí se znaménko (plus +) také pro kladná čísla. Je-li přidána mezera, zobrazí se mezera na začátku kladného čísla a počet číslic se zarovná se záporným číslem.

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

Buďte opatrní při vyplňování libovolnými znaky, například při výše zmíněném vyplňování nulou. Výchozí nastavení bez + a bez mezer vyplňuje kladná čísla o jeden znak navíc.

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

Pokud je použit symbol zarovnání, měl by být symbol označení značky napsán za symbolem zarovnání.

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

Oddělovač číslic (čárka, podtržítko)

Každé tři číslice oddělte čárkou nebo podtržítkem _. Díky tomu jsou velká čísla lépe čitelná. Všimněte si, že podtržítko_ je volba přidaná v Pythonu 3.6, takže ji nelze použít v dřívějších verzích.

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

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

V případě typů čísel s pohyblivou řádovou čárkou float je ohraničena pouze celočíselná část.

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

Binární, osmičková a šestnáctková čísla

Převádí číselné hodnoty na binární, osmičková a šestnáctková čísla pro výstup.

  • b: Binární
  • o: Osmičkové
  • d: Desetinné číslo
  • x,X: Šestnáctkové (velká písmena jsou velká)
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 být také kombinován s 0-fill a často se používá k zarovnání číslic v binárním a hexadecimálním zápisu.

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šimněte si, že počet znaků nulové výplně musí být zadán s ohledem 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

Pro binární a hexadecimální čísla lze vložit pouze oddělovač číslic podtržítko _ (Python 3.6 nebo novější). Používá se čtyřmístný oddělovač; počet znaků vyplněných nulou musí zohledňovat i počet podtržítek.

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

Pouze celočíselný typ int může převést formát na binární nebo hexadecimální. Pro převod na číslo můžete použít funkci int().

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

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

Zadejte počet číslic za desetinnou čárkou.

Chcete-li zadat počet číslic za desetinnou čárkou, postupujte takto: n je počet číslic. Počet číslic za desetinnou čárkou se stane zadaným počtem číslic bez ohledu na počet číslic v celočíselné části.
.[n]f

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

Levou stranu desetinné čárky lze zadat jako levostrannou, středovou, pravostrannou nebo vyplněnou nulou, jak je popsáno výše. Pokud je počet číslic cílové hodnoty větší než zadaný počet, neprovede se nic. Pokud je počet číslic cílové hodnoty větší než zadaný počet číslic, neprovede se nic.

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

Pokud zadáte menší počet číslic, než je původní počet číslic za desetinnou čárkou, hodnota se zaokrouhlí. Všimněte si, že se nejedná o zaokrouhlení na nejbližší celé číslo, ale na sudé číslo, např. 0,5 se zaokrouhlí na 0.

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

Pokud chcete použít obecné zaokrouhlování, můžete použít metodu quantize() standardní knihovny decimal.

exponenciální zápis

Při převodu čísla s plovoucí desetinnou čárkou na řetězec str se číslo automaticky zapíše v exponenciální notaci v závislosti na počtu číslic. U celočíselného typu int tomu tak není.

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

Pokud v řetězci specifikace formátování zadáte e nebo E, můžete vždy převést na exponenciální zápis. Ve výstupu budou použity znaky e, resp. e.

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

Lze také zadat počet číslic za desetinnou čárkou. Celočíselná část bude vždy jednociferná a za desetinnou čárkou 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šimněte si, že pokud zadáte pole se zvýrazněním vlevo, uprostřed, vpravo nebo s nulovou výplní, budou e-, E+ atd. rovněž počítány jako čí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 zadat následujícím způsobem V závislosti na výsledku se automaticky použije exponenciální zápis. Všimněte si, že se vynechají koncové nuly za desetinnou čárkou.
.[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

Pokud g vynecháte, výstupem nebude celé číslo. g je stejné ve většině případů, ale pouze v případech, kdy je výstupem 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

Pokud zpracujeme stejnou hodnotu, dostaneme následující 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 případě g nebo při jeho vynechání se vynechávají koncové nuly za desetinnou čárkou, takže pokud chcete vypsat stejný počet významných čísel (počet významných číslic), použijte exponenciální zápis e nebo E. Celočíselná část je vždy jedna číslice a desetinná čárka je zadaný počet číslic, takže pokud chcete vypsat n významných číslic, stačí zadat 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

Zobrazení procent

Pokud je v řetězci specifikace formátování zadáno %, je hodnota číselného údaje float nebo int vynásobena 100 a převedena na řetězec pomocí %.

Lze také zadat počet číslic za desetinnou čárkou. Výchozí hodnota je šest číslic za desetinnou čárkou. K dispozici jsou také funkce left-justify, center-justify, right-justify a zero-fill. Znak % se rovněž počítá jako 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%