Pretvorba formata v Pythonu, format (polnjenje z ničlo, eksponentni zapis, šestnajstiški zapis itd.)

Posel

Za pretvorbo (formatiranje) števila ali niza v različne oblike v Pythonu uporabite vgrajeno funkcijo format() ali metodo str.format().

V tem razdelku bomo razložili, kako uporabljati naslednje funkcije.

  • vgrajena funkcija (npr. v programskem jeziku)format()
  • metoda nizovstr.format()

Poleg tega je z vzorčno kodo pojasnjen niz specifikacije formata za pretvorbo v naslednji format.

  • Levo poravnano, Sredinsko poravnano, Desno poravnano
  • ničelno polnjenje
  • Znak (plus ali minus)
  • ločevalnik številk (vejica, podčrtaj)
  • Binarna, oktalna in heksadecimalna števila
  • Določite število številk za decimalno vejico
  • Pomembne številke (število pomembnih številk)
  • eksponentni zapis
  • Prikaz odstotkov

Upoštevajte, da so od različice Python 3.6 metodi str.format() dodani nizi f (f-strings), da je bolj jedrnata.

Vgrajena funkcija: format()

format() je na voljo kot standardna vgrajena funkcija Pythona.

Osnutek je naslednji.

  • format(value, format_spec)
    • Prvi argument:value
      Izvirna vrednost. String str, število int, float itd.
    • Drugi argumentformat_spec
      Niz specifikacije formata. String str
    • Vrnjena vrednost: oblikovan niz str

Primeri so prikazani v nadaljevanju. Vrste oblikovnih nizov in način njihovega zapisa so opisani pozneje.

V tem primeru smo kot prvi argument uporabili številske literale in literale nizov, seveda pa lahko uporabite tudi spremenljivke, ki vsebujejo te vrednosti.

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

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

Metoda nizov str.format()

Za vrsto string str obstaja tudi metoda format().

Polje {} v nizu str, ki kliče metodo format(), se imenuje nadomestno polje in se nadomesti z argumentom metode format().

Niz za specifikacijo formata je treba zapisati v nadomestno polje {}, ki mu sledi “:”.

Vrnjena vrednost je oblikovan niz str.

Postopek, enakovreden zgoraj opisani vgrajeni funkciji format(), je naslednji.

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

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

Kot argumente ponovno uporabljamo številske literale in literale nizov, seveda pa so sprejemljive tudi spremenljivke.

Navajanje argumentov za nadomestna polja

Navedite argumente po vrstnem redu (privzeto)

Obstaja lahko več nadomestnih polj {}, privzeto pa so argumenti metode obdelani po vrstnem redu. Če je niz za specifikacijo formata v {} izpuščen, ga bo str() pretvoril v niz.

Uporabno za vstavljanje vrednosti spremenljivk v niz in njihovo tiskanje.

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

Navedite pozicijski argument za celoštevilske vrednosti

Če je v {} navedena celoštevilska vrednost, na primer {0} ali {1}, je izpis odvisen od vrstnega reda argumentov. Isto število se lahko uporabi večkrat. To je uporabno, kadar želite isto vrednost vstaviti v niz.

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

Navedite argumente ključne besede za poljubna imena (nizi)

V {} lahko navedete tudi poljubno ime in ga vnesete kot argument za ključno besedo.

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

kot argument navedite seznam ali slovar

Seznami in slovarji so lahko navedeni kot argumenti.

Uporabite [] za določitev indeksa seznama ali ključa slovarja v nadomestnem polju. Upoštevajte, da se narekovaji “'” in “” ne uporabljajo za določanje ključev slovarjev.

Če želite večkrat uporabiti isti argument, morate navesti celoštevilsko vrednost ali niz (ime), kot je opisano zgoraj.

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.

Razširite ga lahko kot pozicijski argument tako, da seznamu dodate * in ga navedete kot argument, ali kot argument s ključno besedo tako, da slovarju dodate ** in ga navedete kot argument.

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 oglatih oklepajev {}

Če želite v metodi format() zapisati oglate oklepaje {,}, jih ponovite dvakrat, kot je {{,}}. Upoštevajte, da povratnih lomk ni mogoče pobegniti.

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

formatiran niz

V obeh primerih, če želite določiti obliko, za celoštevilsko vrednostjo ali nizom imen v {} zapišite “: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 nadaljevanju bomo razložili, kako določiti obliko z oblikovnim nizom. V vzorčni kodi je uporabljena metoda str.format(), vendar lahko enak oblikovni niz uporabimo tudi z vgrajeno funkcijo format(). V vgrajeni funkciji format() je niz za določanje formata naveden kot drugi argument.

Levo poravnano, Sredinsko poravnano, Desno poravnano

Spodaj lahko poravnate levo poravnano, sredinsko poravnano, desno poravnano itd. Skupno število znakov določite kot število.

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

Navedete lahko tudi znak, ki ga je treba izpolniti. Če ga izpustite, kot v zgornjem primeru, je to presledek.

Uporabite lahko dvobajtne znake, če gre za en sam znak.

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

Pri desni utemeljitvi z > se ne upošteva znak (-,+). Če uporabite =, znaku sledi določen znak. Če želite navesti +, za = napišite +. Podrobnosti obdelave znaka so opisane pozneje.

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

<, ^ in > lahko določite za nize, vendar bo = povzročilo napako ValueError. Če želite uporabiti = za niz, ga morate pretvoriti v število z uporabo funkcije int().

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

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

Enako velja za števila s plavajočo vejico. Tudi decimalke se štejejo kot 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

Če so seznami, kuple itd. navedeni v takšni obliki, bodo povzročili napako, v nize pa jih je mogoče pretvoriti z uporabo funkcije 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 levo poravnano, sredinsko poravnano in desno poravnano obstajajo tudi namenske metode nizov, imenovane ljust(), center() in rjust().

0 polnjenje

Če želite število številk prilagoditi z izpolnitvijo z ničlo, nastavite znak, ki ga želite izpolniti, na 0 in ga desno poravnajte.

Če je simbol za poravnavo izpuščen, se v primeru ničelnega izpolnjevanja obdela, kot da bi bil naveden simbol =.

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

=Če kot argument navedete niz, kot je opisano zgoraj, se pojavi napaka. Bodimo previdni.

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

Za ničelno zapolnitev je na voljo tudi posebna metoda za niz z imenom zfill().

Znak (plus ali minus)

Privzeto so samo negativna števila označena z znakom (minus-).

Če je nizu za specifikacijo oblikovanja dodan znak +, se za pozitivna števila prikaže tudi znak (plus +). Če je dodan presledek, se presledek prikaže na začetku pozitivnega števila, število števk pa se poravna z negativnim številom.

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

Bodite previdni pri izpolnjevanju s poljubnimi znaki, kot je zgoraj omenjeno izpolnjevanje z ničlo. Privzeto, brez + in brez presledkov, se pozitivna števila zapolnijo z enim dodatnim 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

Če se uporablja simbol za poravnavo, je treba za simbolom za poravnavo zapisati simbol za oznako znaka.

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

ločevalnik številk (vejica, podčrtaj)

Na vsake tri številke dodajte vejico ali podčrtanko _. Tako boste lažje brali velike številke. Upoštevajte, da je podčrtaj_ možnost, dodana v Pythonu 3.6, zato je v prejšnjih različicah ni mogoče uporabiti.

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

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

Pri vrstah števil s plavajočo vejico float je razmejen samo celoštevilski del.

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

Binarna, oktalna in heksadecimalna števila

Pretvarja numerične vrednosti v binarna, osmiška in šestnajstiška števila za izhod.

  • b: Binarni
  • o: Oktal
  • d: Decimalna številka
  • x,X: Šestnajstiško (velike črke so velike)
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

Uporablja se lahko tudi v kombinaciji z 0-fill in se pogosto uporablja za poravnavo številk v binarnem in šestnajstiškem 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

Upoštevajte, da je treba število znakov za ničelno izpolnitev določiti ob upoštevanju predpone.

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

Pri binarnih in šestnajstiških številih lahko vstavite samo podčrtaj _ ločilo številk (Python 3.6 ali novejši). Uporablja se 4-številčno ločilo; pri številu ničelno izpolnjenih znakov je treba upoštevati tudi število podčrtank.

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 celoštevilski tip int lahko pretvori obliko v binarno ali heksadecimalno. Za pretvorbo v število lahko uporabite int().

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

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

Določite število številk za decimalno vejico

Če želite določiti število števk za decimalno vejico, naredite naslednje: n je število števk. Število številk za decimalno vejico postane določeno število številk ne glede na število številk v celoštevilskem delu.
.[n]f

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

Levo stran decimalke lahko določite kot levo poravnano, sredinsko poravnano, desno poravnano ali zapolnjeno z ničlo, kot je opisano zgoraj. Če je število števk ciljne vrednosti večje od navedenega števila, se ne stori nič. Če je število števk ciljne vrednosti večje od navedenega števila števk, se ne stori nič.

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

Če določite število števk, ki je manjše od prvotnega števila števk za decimalno vejico, se vrednost zaokroži. Upoštevajte, da pri tem ne gre za zaokroževanje na najbližje celo število, temveč na sodo število, npr. 0,5 se zaokroži na 0.

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

Če želite uporabiti splošno zaokroževanje, lahko uporabite metodo quantize() standardne knjižnice decimal.

eksponentni zapis

Ko se število s plavajočo vejico pretvori v niz str, se samodejno zapiše v eksponentnem zapisu glede na število števk. Celoštevilski tip int pa 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

Če v nizu za določanje oblikovanja navedete e ali E, lahko vedno pretvorite v eksponentni zapis. Znaki, uporabljeni v izpisu, bodo e oziroma E.

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

Določiti je mogoče tudi število številk za decimalno vejico. Celoštevilski del bo vedno ena številka, za decimalno vejico pa bo navedeno število številk.

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

Če določite levo poravnano, sredinsko poravnano, desno poravnano ali ničelno zapolnjeno, se tudi e-, E+ itd. štejejo kot številke (znaki).

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

Pomembne številke (število pomembnih številk)

Skupno število števk lahko določite z naslednjim Glede na rezultat se samodejno uporabi eksponentni zapis. Upoštevajte, da bodo zadnje ničle za decimalno vejico izpuščene.
.[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

Če izpustite g, rezultat ne bo celo število. g je enak v večini primerov, vendar le v primerih, ko je rezultat celo število.

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

Če obdelamo isto vrednost, dobimo naslednje vrednosti.

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 primeru g ali če je izpuščen, se izpustijo zadnje ničle za decimalno vejico, zato če želite izpisati enako število pomembnih številk, uporabite eksponentni zapis e ali E. Celoštevilski del je vedno ena številka, decimalna vejica pa je določeno število številk, zato če želite izpisati n pomembnih številk, 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

Prikaz odstotkov

Če je v nizu za specifikacijo oblikovanja navedeno %, se vrednost številskega podatka float ali int pomnoži s 100 in pretvori v niz z %.

Določiti je mogoče tudi število številk za decimalno vejico. Privzeto je šest številk za decimalno vejico. Na voljo so tudi levo poravnavanje, sredinsko poravnavanje, desno poravnavanje in zapolnitev z ničlo. Tudi % se šteje kot 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%
Copied title and URL