Muodon muuntaminen Pythonissa, muoto (nollatäyttö, eksponentiaalinen merkintätapa, heksadesimaalinen merkintätapa jne.).

liiketoiminta

Voit muuntaa (muotoilla) numeron tai merkkijonon eri muotoihin Pythonissa käyttämällä sisäänrakennettua funktiota format() tai merkkijonomenetelmää str.format().

Tässä osassa selitetään, miten seuraavia toimintoja käytetään.

  • sisäänrakennettu funktio (esim. ohjelmointikielessä)format()
  • merkkijonomenetelmästr.format()

Lisäksi selitetään seuraavaan muotoon muuntamista varten tarvittava muotomäärittelymerkkijono esimerkkikoodin avulla.

  • Vasemmalle tasattu, Keskelle tasattu, Oikealle tasattu.
  • nollatäyttö
  • Merkki (plus tai miinus)
  • Numeronerotin (pilkku, alleviivaus)
  • Binääri-, oktaali- ja heksadesimaaliluvut
  • Määritä desimaalipisteen jälkeisten numeroiden määrä.
  • Merkitsevät luvut (merkitsevien numeroiden määrä)
  • eksponentiaalinen merkintätapa
  • Prosenttinäyttö

Huomaa, että Python 3.6:sta lähtien merkkijonomenetelmään str.format() on lisätty f-merkkijonot (f-strings), jotta se olisi tiiviimpi.

Sisäänrakennettu toiminto: format()

format() on Pythonin sisäänrakennettu standardifunktio.

Hahmotelma on seuraava.

  • format(value, format_spec)
    • Ensimmäinen argumentti:value
      Alkuperäinen arvo. Merkkijono str, luku int, float jne.
    • Toinen argumenttiformat_spec
      Formaattimäärittelyn merkkijono. Merkkijono str
    • Paluuarvo: muotoiltu merkkijono str

Alla on esimerkkejä. Muotoilujonojen tyypit ja niiden kirjoittaminen kuvataan myöhemmin.

Tässä esimerkissä olemme käyttäneet ensimmäisenä argumenttina numeerisia literaaleja ja merkkijonoja, mutta voit tietysti käyttää muuttujia, jotka sisältävät näitä arvoja.

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

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

String-menetelmä str.format()

Myös merkkijonotyypille str on olemassa format()-metodi.

{} merkkijonossa str, joka kutsuu format()-metodia, on nimeltään korvauskenttä, ja se korvataan format()-metodin argumentilla.

Muotomäärittelymerkkijono on kirjoitettava korvauskenttään {}, jota seuraa ”:”.

Paluuarvo on muotoiltu merkkijono str.

Edellä kuvattua sisäänrakennettua funktiota format() vastaava prosessi on seuraava.

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

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

Jälleen kerran käytämme argumentteina numeerisia kirjaimia ja merkkijonoja, mutta tietysti myös muuttujat ovat hyväksyttäviä.

Korvaavien kenttien argumenttien määrittäminen

Määritä argumentit järjestyksessä (oletus)

Korvauskenttiä {} voi olla useita, ja oletusarvoisesti metodin argumentit käsitellään järjestyksessä. Jos {}:ssä oleva formaattimäärittelymerkkijono jätetään pois, se vain muunnetaan merkkijonoksi str():lla.

Hyödyllinen muuttujien arvojen lisäämiseen merkkijonoon ja niiden tulostamiseen.

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

Määritä sijaintiargumentti kokonaislukuarvoja varten.

Jos {}-kentässä on annettu kokonaislukuarvo, kuten {0} tai {1}, tuloste riippuu argumenttien järjestyksestä. Samaa lukua voidaan käyttää toistuvasti. Tämä on hyödyllistä, kun haluat lisätä saman arvon merkkijonoon.

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

Määritä avainsana-argumentit mielivaltaisia nimiä (merkkijonoja) varten.

Voit myös määrittää minkä tahansa nimen {}-kentässä ja syöttää sen avainsana-argumenttina.

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

Luettelon tai sanakirjan määrittäminen argumenttina

Luettelot ja sanakirjat voidaan määrittää argumentteina.

Käytä [] määrittääksesi luettelon indeksin tai sanakirjan avaimen korvauskentässä. Huomaa, että lainausmerkkejä ”'” ja ”” ei käytetä sanakirjan avainten määrittämiseen.

Jos haluat käyttää samaa argumenttia toistuvasti, sinun on määritettävä kokonaislukuarvo tai merkkijono (nimi) edellä kuvatulla tavalla.

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.

Se voidaan laajentaa positionaalisena argumenttina liittämällä * luetteloon ja antamalla se argumenttina, tai avainsana-argumenttina liittämällä ** sanakirjaan ja antamalla se argumenttina.

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.

Kaarisulkeiden kuvaus {}

Jos haluat kirjoittaa kaarisulkeet {,} format()-metodissa, toista se kahdesti muodossa {{,}}. Huomaa, että vinoviivoja ei voi poistaa.

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

muotoiltu merkkijono

Molemmissa tapauksissa määritä muoto kirjoittamalla ”:format string” kokonaislukuarvon tai nimijonon perään {}.

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

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

Seuraavassa kerrotaan, miten muotoilu määritetään muotoilujonon avulla. Esimerkkikoodissa käytetään merkkijonomenetelmää str.format(), mutta samaa muotoilujonoa voidaan käyttää myös sisäänrakennetulla funktiolla format(). Sisäänrakennetussa funktiossa format() formaatin määrittelymerkkijono määritetään toisena argumenttina.

Vasemmalle tasattu, Keskelle tasattu, Oikealle tasattu.

Voit kohdistaa vasemmalle tasattuna, keskelle tasattuna, oikealle tasattuna jne. alla. Määritä merkkien kokonaismäärä numerona.

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

Voit myös määrittää täytettävän merkin. Jos se jätetään pois, kuten yllä olevassa esimerkissä, se on välilyönti.

Voit käyttää kaksitavuisia merkkejä, kunhan kyseessä on yksittäinen merkki.

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

Oikeaoppinen oikaisu >:llä ei ota huomioon merkkiä (-,+). Jos käytät =-merkkiä, merkin jälkeen seuraa määritetty merkki. Jos haluat määrittää +:n, kirjoita + =:n jälkeen. Merkkien käsittelyn yksityiskohdat kuvataan myöhemmin.

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 > voidaan määrittää merkkijonoille, mutta = johtaa virheeseen ValueError. Jos haluat käyttää =-arvoa merkkijonolle, sinun on muunnettava se luvuksi käyttämällä int()-ohjelmaa.

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

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

Sama pätee liukulukuihin. Myös desimaalipisteet lasketaan merkiksi.

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

Luettelot, tuplet jne. aiheuttavat virheen, jos ne määritetään sellaisenaan, ja ne voidaan muuntaa merkkijonoiksi komennolla 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]*****

Vasemmalle tasatulle, keskelle tasatulle ja oikealle tasatulle on myös omat merkkijonometodit nimeltään ljust(), center() ja rjust().

0 täyttöä

Jos haluat säätää numeroiden lukumäärää nollatäytöllä, aseta täytettävän merkin arvoksi 0 ja kohdista se oikealle.

Nollatäytön tapauksessa, jos kohdistussymboli jätetään pois, sitä käsitellään ikään kuin = olisi annettu.

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

=Jos määrität merkkijonon argumentiksi, kuten edellä on kuvattu, saat virheen. Ollaan varovaisia.

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

Nollatäyttöä varten on myös oma merkkijonometodi zfill().

Merkki (plus tai miinus)

Oletusarvoisesti vain negatiiviset luvut merkitään merkillä (miinus-).

Kun muotoilumäärittelymerkkijonoon lisätään +, positiivisten lukujen kohdalla näytetään myös merkki (plus +). Jos lisätään välilyönti, positiivisen luvun alussa näkyy välilyönti, ja numeroiden määrä kohdistetaan negatiivisen luvun kanssa.

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

Ole varovainen, kun täytät mielivaltaisilla merkeillä, kuten edellä mainitulla nollatäytöllä. Oletusarvo, jossa ei ole +-merkkiä eikä välilyöntejä, täyttää positiiviset luvut yhdellä lisämerkillä.

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

Jos käytetään kohdistussymbolia, merkin nimeämissymboli on kirjoitettava kohdistussymbolin jälkeen.

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

Numeronerotin (pilkku, alleviivaus)

Lisää pilkku tai alaviiva _ erotin kolmen numeron välein. Tämä helpottaa suurten numeroiden lukemista. Huomaa, että underscore_ on Python 3.6:ssa lisätty vaihtoehto, joten sitä ei voi käyttää aiemmissa versioissa.

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

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

Kun kyseessä on liukulukutyyppinen liukuluku, vain kokonaislukuosa rajataan.

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

Binääri-, oktaali- ja heksadesimaaliluvut

Muuntaa numeeriset arvot binääri-, oktaali- ja heksadesimaaliluvuiksi tulostusta varten.

  • b: Binary
  • o: Octal
  • d: Desimaaliluku
  • x,X: Heksadesimaalinen (isot kirjaimet kirjoitetaan isolla)
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

Se voidaan myös yhdistää 0-täyttöön, ja sitä käytetään usein numeroiden kohdistamiseen binääri- ja heksadesimaalimerkinnöissä.

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

Huomaa, että nollatäytemerkkien määrä on määritettävä ottaen huomioon etuliite.

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

Binääri- ja heksadesimaaliluvuille voidaan lisätä vain alaviiva _ numeronerotin (Python 3.6 tai uudempi). Käytetään 4-numeroista erotinta; nollatäytteisten merkkien määrässä on otettava huomioon myös alaviivojen määrä.

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

Vain kokonaislukutyyppi int voi muuntaa muodon binääri- tai heksadesimaalimuodoksi. Voit käyttää int()-toimintoa sen muuntamiseen numeroksi.

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

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

Määritä desimaalipisteen jälkeisten numeroiden määrä.

Voit määrittää desimaalipisteen jälkeisten numeroiden määrän seuraavasti: n on numeroiden määrä. Desimaalipisteen jälkeisten numeroiden määrä tulee määritettyyn numeroiden määrään riippumatta kokonaislukuosan numeroiden määrästä.
.[n]f

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

Desimaalipisteen vasen puoli voidaan määrittää vasemmalle tasatuksi, keskelle tasatuksi, oikealle tasatuksi tai nollatäytteiseksi, kuten edellä on kuvattu. Jos tavoitearvon numeroiden määrä on suurempi kuin määritetty määrä, mitään ei tehdä. Jos tavoitearvon numeroiden määrä on suurempi kuin määritetty numeroiden määrä, mitään ei tehdä.

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

Jos määrität numeroiden lukumäärän, joka on pienempi kuin alkuperäinen desimaalipisteen jälkeinen numeroiden lukumäärä, arvo pyöristetään. Huomaa, että tämä ei ole pyöristämistä lähimpään kokonaislukuun vaan parilliseen lukuun, esimerkiksi 0,5 pyöristetään arvoon 0.

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

Jos haluat käyttää yleistä pyöristystä, voit käyttää standardikirjaston decimal-menetelmää quantize().

eksponentiaalinen merkintätapa

Kun liukuluku muunnetaan merkkijonoksi str, se kirjoitetaan automaattisesti eksponenttimerkinnällä numeroiden lukumäärästä riippuen. Kokonaislukutyyppi int ei tee niin.

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

Jos määrittelet e tai E muotoilun määrittelymerkkijonossa, voit aina muuntaa eksponentiaaliseen merkintätapaan. Tulosteessa käytettävät merkit ovat vastaavasti e ja E.

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

On myös mahdollista määrittää desimaalipisteen jälkeisten numeroiden määrä. Kokonaislukuosa on aina yksi numero ja desimaalipiste on määritetty määrä numeroita.

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

Huomaa, että jos määrität vasemmalle tasatun, keskelle tasatun, oikealle tasatun tai nollatäytteisen, e-, E+ jne. lasketaan myös numeroiksi (merkeiksi).

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

Merkitsevät luvut (merkitsevien numeroiden määrä)

Voit määrittää numeroiden kokonaismäärän seuraavasti Tuloksesta riippuen käytetään automaattisesti eksponentiaalista merkintätapaa. Huomaa, että desimaalipisteen jälkeiset nollat jätetään pois.
.[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

Jos jätät g:n pois, tuloste ei ole kokonaisluku. g on sama useimmissa tapauksissa, mutta vain tapauksissa, joissa tuloste on kokonaisluku.

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

Jos käsittelemme samaa arvoa, saamme seuraavat tulokset.

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

Kun kyseessä on g tai jos se jätetään pois, desimaalipisteen jälkeiset nollat jätetään pois, joten jos haluat tulostaa saman määrän merkitseviä numeroita (merkitsevien numeroiden määrä), käytä eksponentiaalista merkintätapaa e tai E. Kokonaislukuosa on aina yksi numero ja desimaalipiste on määritetty määrä numeroita, joten jos haluat tulostaa n merkitsevää numeroa, määritä vain 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

Prosenttinäyttö

Jos muotoilun määrittelymerkkijonossa on määritetty %, numeerisen float- tai int-arvon arvo kerrotaan 100:lla ja muunnetaan merkkijonoksi %:n avulla.

On myös mahdollista määrittää desimaalipisteen jälkeisten numeroiden määrä. Oletusarvo on kuusi numeroa desimaalipisteen jälkeen. Käytettävissä ovat myös vasemmanpuoleinen oikaisu, keskipisteen oikaisu, oikeanpuoleinen oikaisu ja nollatäyttö. Myös % lasketaan merkiksi.

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%