Пераўтварэнне фармату ў Python, фармат (запаўненне нуля, экспанентны запіс, шаснаццатковы і г.д.)

Бізнэс

Каб пераўтварыць (фарматаваць) лік або радок у розныя фарматы ў Python, выкарыстоўвайце ўбудаваную функцыю format() або метад радка str.format().

У гэтым раздзеле мы растлумачым, як выкарыстоўваць наступныя функцыі.

  • убудаваная функцыя (напрыклад, на мове праграмавання)format()
  • метад радкаstr.format()

Акрамя таго, радок спецыфікацыі фармату для пераўтварэння ў наступны фармат тлумачыцца з прыкладам кода.

  • Выраўнавана па левым краі, па цэнтры, па правым краі
  • нулявое запаўненне
  • Знак (плюс ці мінус)
  • Раздзяляльнік лічбаў (коска, падкрэсліванне)
  • Двайковыя, васьмярковыя і шаснаццатковыя лікі
  • Укажыце колькасць лічбаў пасля коскі
  • Значныя лічбы (колькасць значных лічбаў)
  • экспанентны запіс
  • Працэнтнае адлюстраванне

Звярніце ўвагу, што пачынаючы з Python 3.6, f-радкі (f-strings) былі дададзены ў метад радка str.format(), каб зрабіць яго больш кароткім.

Убудаваная функцыя: format()

format() прадастаўляецца ў якасці стандартнай убудаванай функцыі Python.

Схема наступная.

  • format(value, format_spec)
    • Першы аргумент: стvalue
      Першапачатковае значэнне. Радок str, лік int, float і г.д.
    • Другі аргументformat_spec
      Радок спецыфікацыі фармату. Струнная вул
    • Вяртанае значэнне: адфарматаваны радок str

Прыклады паказаны ніжэй. Тыпы радкоў фармату і іх запіс апісаны пазней.

У гэтым прыкладзе мы выкарыстоўвалі лікавыя і радковыя літаралы ў якасці першага аргумента, але, вядома, вы можаце выкарыстоўваць зменныя, якія ўтрымліваюць гэтыя значэнні.

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

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

Радковы метад str.format()

Існуе таксама метад format() для радка str.

{} у радку str, які выклікае метад format(), называецца полем падстаноўкі і замяняецца аргументам метаду format().

Радок спецыфікацыі фармату павінен быць запісаны ў поле замены {}, а затым “:”.

Вяртанае значэнне ўяўляе сабой адфарматаваны радок str.

Працэс, эквівалентны апісанай вышэй убудаванай функцыі format(), выглядае наступным чынам.

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

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

Зноў жа, мы выкарыстоўваем лікавыя і радковыя літаралы ў якасці аргументаў, але, вядома, зменныя таксама прымальныя.

Указанне аргументаў для палёў замены

Пакажыце аргументы па парадку (па змаўчанні)

Можа быць некалькі палёў замены {}, і па змаўчанні аргументы метаду апрацоўваюцца ў парадку. Калі радок спецыфікацыі фармату ў {} апушчаны, ён будзе проста ператвораны ў радок з дапамогай str().

Карысна для ўстаўкі значэнняў зменных у радок і іх друку.

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

Задайце пазіцыйны аргумент для цэлых значэнняў

Калі ў {} зададзена цэлае значэнне, напрыклад {0} або {1}, вынік будзе залежаць ад парадку аргументаў. Адна і тая ж лічба можа выкарыстоўвацца неаднаразова. Гэта карысна, калі вы хочаце ўставіць тое ж значэнне ў радок.

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

Указаць аргументы ключавых слоў для адвольных імёнаў (радкоў)

Вы таксама можаце паказаць любое імя ў {} і ўвесці яго ў якасці аргумента ключавога слова.

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

Пакажыце спіс або слоўнік у якасці аргумента

У якасці аргументаў могуць быць паказаны спісы і слоўнікі.

Выкарыстоўвайце [], каб паказаць індэкс спісу або ключ слоўніка ў полі падстаноўкі. Звярніце ўвагу, што двукоссі «’» і «» не выкарыстоўваюцца для пазначэння ключоў слоўніка.

Калі вы хочаце выкарыстоўваць адзін і той жа аргумент паўторна, вам трэба паказаць цэлае значэнне або радок (імя), як апісана вышэй.

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.

Яго можна разгарнуць у якасці пазіцыйнага аргумента, дадаўшы * да спісу і ўказаўшы яго ў якасці аргументу, або ў якасці аргумента ключавога слова, дадаўшы ** да слоўніка і ўказаўшы яго ў якасці аргумента.

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.

Апісанне фігурных дужак {}

Калі вы хочаце напісаць фігурныя дужкі {,} у метадзе format(), паўтарыце гэта двойчы, як {{,}}. Звярніце ўвагу, што зваротную косую рысу нельга экранаваць.

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

адфарматаваны радок

У абодвух выпадках, каб паказаць фармат, напішыце «: радок фармату» пасля цэлага значэння або радка імя ў {}.

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

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

Далей мы растлумачым, як задаць фармат з дапамогай радка фармату. У прыкладзе кода выкарыстоўваецца метад радка str.format(), але той жа радок фармату можа быць выкарыстаны з убудаванай функцыяй format(). Ва ўбудаванай функцыі format() радок спецыфікацыі фармату паказваецца ў якасці другога аргумента.

Выраўнавана па левым краі, па цэнтры, па правым краі

Вы можаце выраўнаваць па левым краі, па цэнтры, па правым краі і г.д. ніжэй. Пакажыце агульную колькасць сімвалаў у выглядзе ліку.

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

Вы таксама можаце ўказаць сімвал, які трэба запоўніць. Калі яго апусціць, як у прыкладзе вышэй, гэта прабел.

Вы можаце выкарыстоўваць двухбайтавыя сімвалы, пакуль гэта адзін сімвал.

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

Выраўноўванне па правым краі з > не ўлічвае знак (-,+). Калі вы выкарыстоўваеце =, пасля знака ідзе паказаны сімвал. Калі вы хочаце пазначыць +, напішыце + пасля =. Падрабязнасці апрацоўкі знакаў апісаны пазней.

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

<, ^ і > можа быць вызначаны для радкоў, але = прывядзе да памылкі ValueError. Калі вы хочаце выкарыстоўваць = для радка, вам трэба пераўтварыць яго ў лік з дапамогай int().

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

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

Тое ж самае тычыцца лікаў з плаваючай кропкай. Дзесятковыя коскі таксама ўлічваюцца як сімвал.

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

Спісы, картэжы і г.д. прывядуць да памылкі, калі зададзены як ёсць, і могуць быць пераўтвораны ў радкі з дапамогай 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]*****

Для выраўноўвання па левым краі, па цэнтры і па правым краі таксама існуюць спецыяльныя метады радка, якія называюцца ljust(), center() і rjust().

0 запоўніць

Калі вы хочаце наладзіць колькасць лічбаў шляхам запаўнення нуля, усталюйце сімвал, які трэба запоўніць, у 0 і выраўняйце яго па правым краі.

У выпадку запаўнення нулям, калі сімвал выраўноўвання апушчаны, ён апрацоўваецца так, як калі б быў вызначаны =.

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

#ПАМЫЛКА!

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

Для запаўнення нулям таксама існуе спецыяльны метад радка, які называецца zfill().

Знак (плюс ці мінус)

Па змаўчанні знакам (мінус-) пазначаюцца толькі адмоўныя лікі.

Калі + дадаецца да радка спецыфікацыі фарматавання, знак (плюс +) таксама адлюстроўваецца для станоўчых лікаў. Калі дададзены прабел, у пачатку станоўчага ліку адлюстроўваецца прабел, а колькасць лічбаў выраўноўваецца з адмоўным лікам.

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

Будзьце ўважлівыя пры запаўненні адвольнымі сімваламі, напрыклад, нулявым запаўненнем, згаданым вышэй. Па змаўчанні, без + і без прабелаў, станоўчыя лікі запаўняюцца яшчэ адным сімвалам.

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

Калі выкарыстоўваецца сімвал выраўноўвання, сімвал абазначэння знака павінен быць напісаны пасля сімвала выраўноўвання.

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

Раздзяляльнік лічбаў (коска, падкрэсліванне)

Дадайце коску або падкрэсліванне _ падзельнік кожныя тры лічбы. Гэта робіць вялікія лічбы лягчэй чытаць. Звярніце ўвагу, што падкрэсліванне_ – гэта параметр, дададзены ў Python 3.6, таму яго нельга выкарыстоўваць у больш ранніх версіях.

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

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

У выпадку з плаваючай кропкай тыпаў з плаваючай кропкай, толькі цэлая частка размяжоўваецца.

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

Двайковыя, васьмярковыя і шаснаццатковыя лікі

Пераўтварае лікавыя значэнні ў двайковыя, васьмярковыя і шаснаццатковыя лікі для вываду.

  • b: Двайковы
  • o: васьмярковая
  • d: Дзесятковы
  • x,X: шаснаццатковы (загалоўныя літары)
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

Ён таксама можа спалучацца з запаўненнем 0 і часта выкарыстоўваецца для выраўноўвання лічбаў у двайковым і шаснаццатковым запісах.

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

Звярніце ўвагу, што колькасць сімвалаў нулявага запаўнення павінна быць указана з улікам прэфікса.

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

Для двайковых і шаснаццатковых лікаў можна ўставіць толькі падзельнік знакаў падкрэслівання _ (Python 3.6 або больш позняй версіі). выкарыстоўваецца 4-значны падзельнік; колькасць сімвалаў, запоўненых нулямі, павінна таксама ўлічваць колькасць знакаў падкрэслення.

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

Толькі цэлы тып int можа пераўтварыць фармат у двайковы або шаснаццатковы. Вы можаце выкарыстоўваць int(), каб пераўтварыць яго ў лік.

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

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

Укажыце колькасць лічбаў пасля коскі

Каб задаць колькасць лічбаў пасля коскі, зрабіце наступнае: n – гэта колькасць лічбаў. Колькасць лічбаў пасля коскі становіцца зададзенай колькасцю лічбаў незалежна ад колькасці лічбаў у цэлай частцы.
.[n]f

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

Левы бок дзесятковай коскі можа быць выраўнаваны па левым краі, па цэнтры, па правым краі або з нулявым запаўненнем, як апісана вышэй. Калі колькасць лічбаў мэтавага значэння больш за паказаную колькасць, нічога не робіцца. Калі колькасць лічбаў у мэтавым значэнні больш, чым зададзеная колькасць лічбаў, нічога не робіцца.

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

Калі пасля дзесятковай коскі ўказаць колькасць лічбаў, меншую за зыходную колькасць лічбаў, значэнне будзе акруглена. Звярніце ўвагу, што гэта акругленне не да цэлага ліку, а да цотнага ліку, напрыклад. 0,5 акругляецца да 0.

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

Калі вы хочаце выкарыстоўваць агульнае акругленне, вы можаце выкарыстоўваць метад quantize() стандартнай дзесятковай бібліятэкі.

экспанентны запіс

Калі лік з плаваючай кропкай пераўтворыцца ў радок str, ён будзе аўтаматычна запісвацца ў экспанентным абазначэнні ў залежнасці ад колькасці лічбаў. Цэлы тып int не робіць.

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 або E, вы заўсёды можаце пераўтварыць у экспанентны запіс. Сімвалы, якія выкарыстоўваюцца ў вывадзе, будуць e і E адпаведна.

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

Таксама можна ўказаць колькасць лічбаў пасля коскі. Цэлая частка заўсёды будзе адной лічбай, а дзесятковая коска будзе вызначанай колькасцю лічбаў.

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-, E+ і г.д. таксама будуць лічыцца лічбамі (сімваламі).

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

Значныя лічбы (колькасць значных лічбаў)

Вы можаце ўказаць агульную колькасць лічбаў, выканаўшы наступныя дзеянні. У залежнасці ад выніку, экспанентная запіс будзе выкарыстоўвацца аўтаматычна. Звярніце ўвагу, што нулі пасля дзесятковай коскі будуць апушчаны.
.[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

Калі вы апусціце g, вынік не будзе цэлым лікам. g у большасці выпадкаў аднолькавы, але толькі ў тых выпадках, калі вывад з’яўляецца цэлым лікам.

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

Калі мы апрацуем тое ж значэнне, мы атрымаем адпаведна наступнае.

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

У выпадку g або калі ён прапушчаны, нулі пасля дзесятковай коскі апускаюцца, таму, калі вы хочаце вывесці аднолькавую колькасць значных лічбаў (колькасць значных лічбаў), выкарыстоўвайце экспанентнае абазначэнне e або E. цэлая частка – гэта заўсёды адна лічба, а дзесятковая коска – гэта зададзеная колькасць лічбаў, таму, калі вы хочаце вывесці n значных лічбаў, проста ўкажыце 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

Працэнтнае адлюстраванне

Калі ў радку спецыфікацыі фарматавання зададзены %, значэнне лікавага float або int памнажаецца на 100 і пераўтворыцца ў радок з %.

Таксама можна ўказаць колькасць лічбаў пасля коскі. Па змаўчанні – шэсць лічбаў пасля коскі. Таксама даступныя выраўноўванне па левым краі, выраўноўванне па цэнтры, выраўноўванне па правым краі і запаўненне нулем. % таксама ўлічваецца як сімвал.

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