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 meetod
str.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()
- String meetod str.format()
- Vasakpoolselt joondatud, keskelt joondatud, parempoolselt joondatud
- 0 täitmine
- Märk (pluss või miinus)
- Numbrite eraldaja (koma, alajaotusjoon)
- Binaar-, oktaal- ja heksadekaalarvud
- Määrake numbrite arv pärast komakohta.
- eksponentsiaalne märkimine
- Olulised arvud (oluliste numbrite arv)
- Protsentide kuvamine
Sisseehitatud funktsioon: format()
format() on Pythoni standardne sisseehitatud funktsioon.
Ülesehitus on järgmine.
format(value, format_spec)
- Esimene argumendiks on
value
Algne väärtus. String str, number int, float jne. - Teine argument
format_spec
Vormingu spetsifikatsiooni string. String str - Tagastatav väärtus: vormindatud string str
- Esimene argumendiks on
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
: Binaryo
: Octald
: Decimalx
,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%