Konverzija formata u Pythonu, format (ispunjavanje nule, eksponencijalni zapis, heksadecimalni itd.)

Poslovanje

Da biste pretvorili (formatirali) broj ili niz u različite formate u Pythonu, koristite ugrađenu funkciju format() ili metodu stringa str.format().

U ovom ćemo odjeljku objasniti kako koristiti sljedeće funkcije.

  • ugrađena funkcija (npr. u programskom jeziku)format()
  • metoda nizastr.format()

Osim toga, niz specifikacije formata za pretvaranje u sljedeći format objašnjen je uz primjer koda.

  • Poravnano lijevo, po sredini, desno
  • nula popunjavanja
  • Znak (plus ili minus)
  • Razdjelnik znamenki (zarez, podvlaka)
  • Binarni, oktalni i heksadecimalni brojevi
  • Odredite broj znamenki iza decimalne točke
  • Značajne brojke (broj značajnih znamenki)
  • eksponencijalni zapis
  • Postotni prikaz

Imajte na umu da su od Pythona 3.6 f-strings (f-strings) dodani metodi stringova str.format() kako bi bila sažetija.

Ugrađena funkcija: format()

format() pruža se kao standardna ugrađena funkcija Pythona.

Nacrt je sljedeći.

  • format(value, format_spec)
    • Prvi argument:value
      Izvorna vrijednost. String str, broj int, float itd.
    • Drugi argumentformat_spec
      Niz specifikacije formata. String str
    • Povratna vrijednost: formatirani string str

Primjeri su prikazani u nastavku. Vrste nizova formata i način njihovog pisanja opisani su kasnije.

U ovom primjeru koristili smo numeričke literale i literale niza kao prvi argument, ali naravno možete koristiti varijable koje sadrže te vrijednosti.

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

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

Metoda niza str.format()

Postoji i metoda format() za tip string stringa.

{} u stringu str koji poziva metodu format() naziva se zamjensko polje i zamjenjuje se argumentom metode format().

Niz specifikacije formata treba biti upisan u zamjensko polje {} nakon čega slijedi “:”.

Povratna vrijednost je formatirani string str.

Ekvivalentni proces za ugrađenu funkciju format() opisan je kako slijedi.

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

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

Opet, kao argumente koristimo numeričke literale i literale niza, ali naravno i varijable su prihvatljive.

Određivanje argumenata za zamjenska polja

Navedite argumente redom (zadano)

Može postojati više polja zamjene {}, a prema zadanim postavkama, argumenti metode se obrađuju redom. Ako je niz specifikacije formata u {} izostavljen, str(() će ga samo pretvoriti u niz.

Korisno za umetanje vrijednosti varijabli u niz i njihovo ispisivanje.

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

Navedite pozicijski argument za cjelobrojne vrijednosti

Ako je cjelobrojna vrijednost navedena u {}, kao što je {0} ili {1}, izlaz će ovisiti o redoslijedu argumenata. Isti broj se može koristiti više puta. Ovo je korisno kada želite umetnuti istu vrijednost u niz.

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

Odredite argumente ključne riječi za proizvoljne nazive (nizove)

Također možete odrediti bilo koje ime u {} i unijeti ga kao argument ključne riječi.

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

Navedite popis ili rječnik kao argument

Popisi i rječnici mogu se navesti kao argumenti.

Koristite [] za određivanje indeksa popisa ili ključa rječnika u polju zamjene. Imajte na umu da se navodnici “‘” i “” ne koriste za određivanje ključeva rječnika.

Ako želite više puta koristiti isti argument, morate navesti cjelobrojnu vrijednost ili niz (ime) kao što je gore opisano.

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že se proširiti kao pozicijski argument dodavanjem * na popis i specificiranjem kao argumentom, ili kao argument ključne riječi dodavanjem ** u rječnik i navođenjem kao argumenta.

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.

Opis vitičastih zagrada {}

Ako želite napisati vitičaste zagrade {,} u metodi format(), ponovite to dvaput kao {{,}}. Imajte na umu da se obrnute kose crte ne mogu izbjeći.

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

formatirani niz

U oba slučaja, da biste naveli format, napišite “:format string” iza cjelobrojne vrijednosti ili niza naziva u {}.

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

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

U nastavku ćemo objasniti kako odrediti format pomoću niza formata. Primjer koda koristi metodu stringa str.format(), ali isti niz formata može se koristiti s ugrađenom funkcijom format(). U ugrađenoj funkciji format(), niz specifikacije formata naveden je kao drugi argument.

Poravnano lijevo, po sredini, desno

U nastavku možete poravnati poravnato lijevo, poravnano po sredini, desno itd. Navedite ukupan broj znakova kao broj.

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

Također možete odrediti znak koji treba popuniti. Ako se izostavi, kao u gornjem primjeru, to je razmak.

Možete koristiti dvobajtne znakove sve dok je riječ o jednom znaku.

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

Desno poravnanje s > ne uzima u obzir znak (-,+). Ako koristite =, iza znaka slijedi navedeni znak. Ako želite odrediti +, napišite + iza =. Detalji obrade znakova opisani su kasnije.

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

<, ^ i > može se navesti za nizove, ali = će rezultirati pogreškom ValueError. Ako želite koristiti = za niz, trebate ga pretvoriti u broj pomoću int().

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

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

Isto vrijedi i za brojeve s pomičnim zarezom. Decimalne točke se također računaju kao 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

Popisi, torke itd. uzrokovat će pogrešku ako su navedeni takvi kakvi jesu, a mogu se pretvoriti u nizove pomoću 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]*****

Za poravnanje lijevo, centrirano i desno, također postoje namjenske metode niza koje se nazivaju ljust(), center() i rjust().

0 ispuniti

Ako želite podesiti broj znamenki popunjavanjem nule, postavite znak koji treba ispuniti na 0 i poravnajte ga udesno.

U slučaju popunjavanja nulom, ako je simbol poravnanja izostavljen, obrađuje se kao da je specificirano =.

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

#GREŠKA!

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

Za popunjavanje nule postoji i posebna metoda niza koja se zove zfill().

Znak (plus ili minus)

Prema zadanim postavkama, samo su negativni brojevi označeni znakom (minus-).

Kada se + doda nizu specifikacije oblikovanja, znak (plus +) se također prikazuje za pozitivne brojeve. Ako se doda razmak, razmak se prikazuje na početku pozitivnog broja, a broj znamenki je poravnat s negativnim brojem.

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

Budite oprezni kada ispunjavate proizvoljnim znakovima, kao što je gore spomenuto popunjavanje nule. Zadana vrijednost, bez + i bez razmaka, ispunjava pozitivne brojeve još jednim znakom.

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

Ako se koristi simbol poravnanja, simbol oznake znaka treba biti napisan iza simbola poravnanja.

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

Razdjelnik znamenki (zarez, podvlaka)

Dodajte zarez ili podvlaku _ razdjelnik svake tri znamenke. To olakšava čitanje velikih brojeva. Imajte na umu da je donja crta_ opcija dodana u Python 3.6, tako da se ne može koristiti u starijim verzijama.

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

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

U slučaju float tipova brojeva s pomičnim zarezom, ograničen je samo cijeli dio.

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

Binarni, oktalni i heksadecimalni brojevi

Pretvara numeričke vrijednosti u binarne, oktalne i heksadecimalne brojeve za izlaz.

  • b: Binarno
  • o: oktalni
  • d: Decimal
  • x,X: heksadecimalno (velika slova su velika)
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

Također se može kombinirati s 0-fill, a često se koristi za poravnavanje znamenki u binarnom i heksadecimalnom zapisu.

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

Imajte na umu da se broj znakova za popunjavanje nulom mora navesti uzimajući u obzir prefiks.

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

Za binarne i heksadecimalne brojeve može se umetnuti samo podvlaka _ separator znamenki (Python 3.6 ili noviji). koristi se 4-znamenkasti separator; broj znakova ispunjenih nulom također mora uzeti u obzir broj donjih crta.

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

Samo cjelobrojni tip int može pretvoriti format u binarni ili heksadecimalni. Možete koristiti int() da ga pretvorite u broj.

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

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

Odredite broj znamenki iza decimalne točke

Da biste odredili broj znamenki nakon decimalne točke, učinite sljedeće: n je broj znamenki. Broj znamenki nakon decimalne točke postaje određeni broj znamenki bez obzira na broj znamenki u cijelom dijelu.
.[n]f

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

Lijeva strana decimalne točke može se odrediti kao poravnata lijevo, centrirano, desno ili ispunjena nulom kao što je gore opisano. Ako je broj znamenki ciljne vrijednosti veći od navedenog broja, ništa se ne radi. Ako je broj znamenki u ciljnoj vrijednosti veći od navedenog broja znamenki, ništa se ne radi.

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

Ako navedete broj znamenki manji od izvornog broja znamenki nakon decimalne točke, vrijednost će biti zaokružena. Imajte na umu da ovo nije zaokruživanje na najbliži cijeli broj, već na paran broj, npr. 0,5 je zaokruženo na 0.

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

Ako želite koristiti opće zaokruživanje, možete koristiti quantize() metodu standardne decimale biblioteke.

eksponencijalni zapis

Kada se broj s pomičnim zarezom pretvori u string str, automatski će biti zapisan u eksponencijalnoj notaciji ovisno o broju znamenki. Integer tip int ne.

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

Ako navedete e ili E u nizu specifikacije oblikovanja, uvijek možete pretvoriti u eksponencijalni zapis. Znakovi korišteni u izlazu bit će e odnosno E.

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

Također je moguće odrediti broj znamenki iza decimalne točke. Cjelobrojni dio uvijek će biti jednoznamenkasti, a decimalna točka će biti određeni broj znamenki.

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

Imajte na umu da ako navedete lijevo poravnato, centrirano, desno ili popunjeno nulom, e-, E+ itd. također će se računati kao znamenke (znakovi).

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

Značajne brojke (broj značajnih znamenki)

Možete odrediti ukupan broj znamenki na sljedeći način. Ovisno o rezultatu, eksponencijalni zapis će se koristiti automatski. Imajte na umu da će zadnje nule nakon decimalne točke biti izostavljene.
.[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

Ako izostavite g, izlaz neće biti cijeli broj. g je isti u većini slučajeva, ali samo u slučajevima kada je izlaz cijeli broj.

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

Ako obradimo istu vrijednost, dobivamo sljedeće.

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

U slučaju g ili ako je izostavljen, zadnje nule iza decimalne točke se izostavljaju, pa ako želite ispisati isti broj značajnih znamenki (broj značajnih znamenki), koristite eksponencijalni zapis e ili E. cijeli dio je uvijek jedna znamenka, a decimalna točka je određeni broj znamenki, pa ako želite ispisati n značajnih znamenki, samo navedite 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

Postotni prikaz

Ako je % naveden u nizu specifikacije oblikovanja, vrijednost numeričkog float ili int se množi sa 100 i pretvara u niz s %.

Također je moguće odrediti broj znamenki iza decimalne točke. Zadana vrijednost je šest znamenki nakon decimalne točke. Dostupne su i poravnanje lijevo, poravnanje po sredini, poravnanje desno i nula-ispuna. % se također računa kao 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%