Formaadi teisendamine Pythonis, formaat (nulltäitmine, eksponentsiaalne märkimine, heksadekaalarvud jne).

Äri

Arvude või stringide konverteerimiseks (vormindamiseks) erinevatesse vormingutesse Pythonis kasutage sisseehitatud funktsiooni format() või stringi meetodit str.format().

Selles jaotises selgitame, kuidas kasutada järgmisi funktsioone.

  • sisseehitatud funktsioon (nt programmeerimiskeeles)format()
  • string meetodstr.format()

Lisaks selgitatakse koos näidiskoodiga järgmisesse vormingusse teisendamiseks vajalikku vormingustringi.

  • Vasakpoolselt joondatud, keskelt joondatud, parempoolselt joondatud
  • nulltäitmine
  • Märk (pluss või miinus)
  • Numbrite eraldaja (koma, alajaotusjoon)
  • Binaar-, oktaal- ja heksadekaalarvud
  • Määrake numbrite arv pärast komakohta.
  • Olulised arvud (oluliste numbrite arv)
  • eksponentsiaalne märkimine
  • Protsentide kuvamine

Pange tähele, et alates Python 3.6 on stringi meetodile str.format() lisatud f-strings (f-strings), et muuta see ülevaatlikumaks.

Sisseehitatud funktsioon: format()

format() on Pythoni standardne sisseehitatud funktsioon.

Ülesehitus on järgmine.

  • format(value, format_spec)
    • Esimene argumendiks onvalue
      Algne väärtus. String str, number int, float jne.
    • Teine argumentformat_spec
      Vormingu spetsifikatsiooni string. String str
    • Tagastatav väärtus: vormindatud string str

Näited on esitatud allpool. Vormingusõnumite tüüpe ja nende kirjutamist kirjeldatakse hiljem.

Selles näites kasutasime esimese argumendina numbrilisi literaale ja string literaale, kuid loomulikult võite kasutada muutujaid, mis sisaldavad neid väärtusi.

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

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

String meetod str.format()

Samuti on olemas meetod format() string str-tüübi jaoks.

{} stringis str, mis kutsub meetodit format(), nimetatakse asendusväljaks ja see asendatakse meetodi format() argumendiga.

Vormingu spetsifikatsiooni string tuleks kirjutada asendusväljale {}, millele järgneb “:”.

Tagastusväärtus on vormindatud string str.

Eespool kirjeldatud sisseehitatud funktsiooniga format() samaväärne protsess on järgmine.

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

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

Jällegi kasutame argumentidena numbrilisi literaale ja string literaale, kuid loomulikult on vastuvõetavad ka muutujad.

Asendusväljade argumentide määramine

Määrake argumendid järjekorras (vaikimisi)

Asendusvälju võib olla mitu {} ja vaikimisi töödeldakse meetodi argumente järjekorras. Kui formaadispetsifitseerimise string {} on välja jäetud, teisendatakse see str() abil lihtsalt stringiks.

Kasulik muutuja väärtuste sisestamiseks stringi ja nende printimiseks.

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

Määrake täisarvuliste väärtuste jaoks positsiooniline argument

Kui {}-s on määratud täisarvuline väärtus, näiteks {0} või {1}, sõltub väljund argumentide järjekorrast. Sama arvu võib kasutada korduvalt. See on kasulik, kui soovite sama väärtust sisestada stringi.

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

Märksõna argumentide määramine suvalistele nimedele (stringid)

Võite ka määrata mis tahes nime {} ja sisestada selle märksõna argumendina.

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

Nimekirja või sõnastiku määramine argumendina

Argumentidena saab esitada nimekirju ja sõnastikke.

Kasutage [], et määrata loendi indeks või sõnastiku võti asendusväljas. Pange tähele, et jutumärke “'” ja “” ei kasutata sõnastiku võtmete määramiseks.

Kui soovite kasutada sama argumenti korduvalt, tuleb määrata täisarvuline väärtus või string (nimi), nagu eespool kirjeldatud.

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.

Seda saab laiendada positsioonilise argumendina, lisades loetelule * ja määrates selle argumendina, või märksõnaargumendina, lisades ** sõnastikule ja määrates selle argumendina.

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.

Kõverate sulgude kirjeldus {}

Kui soovid formaat()-meetodisse kirjutada kõverad sulgud {,}, siis korda seda kaks korda nagu {{,}}. Pange tähele, et kaldkriipsu ei saa põgeneda.

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

vormindatud string

Mõlemal juhul tuleb vormingu täpsustamiseks kirjutada “:format string” pärast täisarvu väärtust või nimestringi {}.

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

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

Järgnevalt selgitame, kuidas määrata formaat, kasutades vormingustringi. Näidiskoodis kasutatakse stringi meetodit str.format(), kuid sama formaat stringi saab kasutada ka sisseehitatud funktsiooniga format(). Sisseehitatud funktsioonis format() on formaadispetsifitseerimise string määratud teise argumendina.

Vasakpoolselt joondatud, keskelt joondatud, parempoolselt joondatud

Allpool saate joondada vasakule joondatud, keskele joondatud, paremale joondatud jne. Määrake tähemärkide koguarv numbrina.

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

Võite määrata ka tähe, mida täidetakse. Kui see jäetakse ära, nagu ülaltoodud näites, on see tühik.

Võite kasutada kahebaidilisi märke, kui tegemist on ühe tähemärgiga.

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

Parempoolne õigustamine >-ga ei võta arvesse märki (-,+). Kui kasutate =, järgneb märgile määratud märk. Kui soovite määrata +, kirjutage + pärast =. Märgitöötluse üksikasju kirjeldatakse hiljem.

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

<, ^ ja > võib määrata stringide jaoks, kuid = annab vea ValueError. Kui soovite kasutada = stringi jaoks, peate selle teisendama arvuks, kasutades int().

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

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

Sama kehtib ka ujukomaarvude kohta. Kümnendmärgid loetakse samuti tähemärgiks.

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

Loetelud, tuplid jne põhjustavad vea, kui need on esitatud sellisena, ja neid saab teisendada stringideks, kasutades 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]*****

Vasak-, kesk- ja parempoolse korrigeerimise jaoks on olemas ka spetsiaalsed stringimeetodid nimega ljust(), center() ja rjust().

0 täitmine

Kui soovite numbrite arvu reguleerida nulltäitmise abil, määrake täidetavale märgile 0 ja joondage see paremale.

Nulliga täitmise korral, kui joondussümbol on välja jäetud, töödeldakse seda nii, nagu oleks määratud =.

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

=Kui annate argumendina stringi, nagu eespool kirjeldatud, saate vea. Olgem ettevaatlikud.

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

Nulltäitmiseks on olemas ka spetsiaalne stringi meetod nimega zfill().

Märk (pluss või miinus)

Vaikimisi on ainult negatiivsed arvud tähistatud märgiga (miinus-).

Kui vormindusmärkide stringile lisatakse +, kuvatakse positiivsete arvude puhul ka märk (pluss +). Kui lisatakse tühik, kuvatakse positiivse arvu alguses tühik ja numbrite arv joondatakse negatiivse arvu järgi.

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

Olge ettevaatlik, kui täidate suvalisi märke, nagu näiteks eespool mainitud nulli täitmine. Vaikimisi, ilma + ja tühikuta, täidab positiivseid numbreid ühe tähemärgiga rohkem.

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

Kui kasutatakse joondussümbolit, tuleb tähise tähis kirjutada joondussümboli järele.

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

Numbrite eraldaja (koma, alajaotusjoon)

Lisage koma või eraldusjoon _ iga kolme numbri järel. See muudab suured numbrid kergemini loetavaks. Pange tähele, et underscore_ on Python 3.6-s lisatud valik, nii et seda ei saa kasutada varasemates versioonides.

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

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

Ujukomaarvu libiseva arvu tüübi puhul piiritletakse ainult täisarvuline osa.

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

Binaar-, oktaal- ja heksadekaalarvud

Teisendab numbrilised väärtused binaarseteks, kaheksakohalisteks ja kuuekohalisteks numbriteks.

  • b: Binary
  • o: Octal
  • d: Decimal
  • x,X: Kuueksajoonis (suurtähed on suurtähtedega)
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

Seda saab kombineerida ka 0-tähega ja seda kasutatakse sageli numbrite joondamiseks binaarses ja heksadetsimaalses märkimises.

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

Pange tähele, et nulltäite tähemärkide arv tuleb määrata, võttes arvesse eesliidet.

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

Binaarsete ja heksadetsimaalsete numbrite puhul saab sisestada ainult alajaotuse _ (Python 3.6 või uuem). Kasutatakse 4-kohalist eraldajat; nulliga täidetud märkide arvu puhul tuleb arvestada ka allkriipsude arvu.

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

Ainult täisarvu tüüpi int saab teisendada formaadi binaarseks või heksadetsimaalseks. Selle teisendamiseks arvuks saab kasutada funktsiooni int().

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

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

Määrake numbrite arv pärast komakohta.

Pärast koma järgsete numbrite arvu määramiseks tehke järgmist: n on numbrite arv. Kümnendmurru järgsete numbrite arv saab määratud numbrite arvu, olenemata täisarvu osa numbrite arvust.
.[n]f

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

Kümnendmärgi vasakpoolse osa saab määrata vasakpoolselt, keskelt, paremalt või nulliga täidetud, nagu eespool kirjeldatud. Kui sihtväärtuse numbrite arv on suurem kui määratud arv, ei tehta midagi. Kui sihtväärtuse numbrite arv on suurem kui määratud numbrite arv, ei tehta midagi.

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

Kui määrate numbrite arvu, mis on väiksem kui esialgne arv numbreid pärast koma, ümardatakse väärtus. Pange tähele, et see ei ole ümardamine lähima täisarvuni, vaid paarisarvuni, nt 0,5 ümardatakse 0-ks.

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

Kui soovite kasutada üldist ümardamist, võite kasutada standardraamatukogu decimal meetodit quantize().

eksponentsiaalne märkimine

Kui ujukomaarvu teisendatakse stringiks str, kirjutatakse see automaatselt eksponentsiaalses märkimisviisis sõltuvalt numbrite arvust. Tervikutüüpi int ei ole.

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

Kui te määrate e või E vormingu spetsifikatsiooni stringis, saate alati konverteerida eksponentsiaalsesse märkimisviisi. Väljundis kasutatavad märgid on vastavalt e ja E.

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

Samuti on võimalik määrata numbrite arvu pärast koma lõppu. Tervikosa on alati ühekohaline ja kümnendkoht on määratud arvu numbreid.

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

Pange tähele, et kui te määrate vasakule joondatud, keskele joondatud, paremale joondatud või nulliga täidetud, loetakse ka e-, E+ jne. numbriteks (märkideks).

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

Olulised arvud (oluliste numbrite arv)

Saate täpsustada numbrite üldarvu, tehes järgmist Sõltuvalt tulemusest kasutatakse automaatselt eksponentsiaalset märkimist. Pange tähele, et kümnendmärgi järel olevad nullid jäetakse ära.
.[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

Kui jätate g vahele, ei ole väljund täisarv. g on enamikul juhtudel sama, kuid ainult juhul, kui väljund on täisarv.

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

Kui töötleme sama väärtust, saame vastavalt järgmise tulemuse.

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

Juhul kui g või kui see jäetakse ära, jäetakse tagumised nullid pärast komakohta ära, nii et kui soovite väljastada sama arvu olulisi numbreid (oluliste numbrite arvu), kasutage eksponentsiaalset märkimist e või E. täisarvuline osa on alati üks number ja kümnendkoht on määratud arv numbreid, nii et kui soovite väljastada n olulist numbrit, siis märkige lihtsalt 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

Protsentide kuvamine

Kui vormingu spetsifikatsiooni stringis on määratud %, korrutatakse numbriline float- või int-väärtus 100-ga ja teisendatakse stringiks koos %ga.

Samuti on võimalik määrata numbrite arvu pärast koma lõppu. Vaikimisi on kuus numbrit pärast koma. Võimalikud on ka vasakpoolne korrigeerimine, keskkohandamine, parempoolne korrigeerimine ja nulltäitmine. % loetakse samuti tähemärgiks.

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%