Конверзија формата у Питхон-у, формат (попуњавање нуле, експоненцијална нотација, хексадецимална итд.)

Бусинесс

Да бисте претворили (форматирали) број или стринг у различите формате у Питхон-у, користите уграђену функцију формат() или метод стринга стр.формат().

У овом одељку ћемо објаснити како да користите следеће функције.

  • уграђена функција (нпр. у програмском језику)format()
  • стринг методаstr.format()

Поред тога, низ спецификације формата за претварање у следећи формат је објашњен примером кода.

  • Поравнано лево, центрирано, десно
  • зеро филл
  • Знак (плус или минус)
  • Раздвајач цифара (зарез, доња црта)
  • Бинарни, октални и хексадецимални бројеви
  • Наведите број цифара после децималне запете
  • Значајне бројке (број значајних цифара)
  • експоненцијална нотација
  • Процентуални приказ

Имајте на уму да су од Питхон-а 3.6, ф-стрингови (ф-стрингови) додати методу стрингова стр.формат() да би био сажетији.

Уграђена функција: формат()

формат() је обезбеђена као стандардна уграђена функција Питхон-а.

Нацрт је следећи.

  • format(value, format_spec)
    • Први аргумент:value
      Оригинална вредност. Стринг стр, број инт, флоат итд.
    • Други аргументformat_spec
      Низ спецификације формата. Стринг стр
    • Повратна вредност: форматирани стринг стр

Примери су приказани у наставку. Типови стрингова формата и начин њиховог писања описани су касније.

У овом примеру смо користили нумеричке литерале и стрингове као први аргумент, али наравно можете користити променљиве које садрже ове вредности.

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

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

Стринг метод стр.формат()

Такође постоји метода формат() за стринг тип стр.

{} у стрингу стр који позива методу формат() назива се поље замене и замењује се аргументом методе формат().

Низ спецификације формата треба да буде уписан у поље за замену {} праћено „:“.

Повратна вредност је форматирани стринг стр.

Еквивалентни процес уграђеној функцији формат() описан горе је следећи.

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

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

Опет, користимо нумеричке литерале и стринг литерале као аргументе, али наравно и променљиве су прихватљиве.

Одређивање аргумената за поља замене

Наведите аргументе по редоследу (подразумевано)

Може постојати више поља за замену {}, а по подразумеваној вредности, аргументи метода се обрађују по редоследу. Ако је стринг спецификације формата у {} изостављен, само ће бити конвертован у стринг помоћу стр().

Корисно за уметање променљивих вредности у низ и њихово штампање.

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.

Опис витичастих заграда {}

Ако желите да напишете витичасте заграде {,} у методи формат(), поновите то двапут као {{,}}. Имајте на уму да се обрнуте косе црте не могу избећи.

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

У наставку ћемо објаснити како да наведете формат користећи стринг формата. Пример кода користи метод стринга стр.формат(), али исти низ формата се може користити са уграђеном функцијом формат(). У уграђеној функцији формат(), стринг спецификације формата је специфициран као други аргумент.

Поравнано лево, центрирано, десно

Испод можете да поравнате поравнато лево, поравнато по средини, десно итд. Наведите укупан број знакова као број.

  • <
  • ^
  • >
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

&лт;, ^ и &гт; може се навести за стрингове, али ће = резултирати грешком ВалуеЕррор. Ако желите да користите = за стринг, потребно је да га конвертујете у број помоћу инт().

# 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

Листе, торке итд. ће изазвати грешку ако је специфицирано као што јесу и могу се конвертовати у стрингове помоћу стр().

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]*****

За поравнање лево, центрирано и десно, такође постоје наменске методе стрингова који се зову љуст(), центер() и рјуст().

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

За попуњавање нуле, постоји и наменски метод стрингова који се зове зфилл().

Знак (плус или минус)

Подразумевано, само негативни бројеви су означени знаком (минус-).

Када се + дода низу спецификације форматирања, знак (плус +) се такође приказује за позитивне бројеве. Ако се дода размак, на почетку позитивног броја се приказује размак, а број цифара је поравнат са негативним бројем.

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

Раздвајач цифара (зарез, доња црта)

Додајте зарез или доњу црту _ сепаратор сваке три цифре. Ово олакшава читање великих бројева. Имајте на уму да је доња црта_ опција додата у Питхон 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

За бинарне и хексадецималне бројеве може се уметнути само доња црта _ сепаратор цифара (Питхон 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

Само целобројни тип инт може да конвертује формат у бинарни или хексадецимални. Можете користити инт() да га претворите у број.

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

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

Наведите број цифара после децималне запете

Да бисте одредили број цифара после децималног зареза, урадите следеће: н је број цифара. Број цифара после децималног зареза постаје одређени број цифара без обзира на број цифара у целом делу.
.[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

Ако желите да користите опште заокруживање, можете користити метод куантизе() стандардне децимале библиотеке.

експоненцијална нотација

Када се број са помичним зарезом конвертује у стринг стр, он ће аутоматски бити записан у експоненцијалној нотацији у зависности од броја цифара. Интегер тип инт не.

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

Ако наведете е или Е у низу спецификације форматирања, увек можете да конвертујете у експоненцијалну нотацију. Знакови који се користе у излазу биће е и Е, респективно.

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

Имајте на уму да ако наведете поравнато лево, поравнато по средини, десно или попуњено нулом, е-, Е+ итд. ће се такође рачунати као цифре (знакови).

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

Ако изоставите г, излаз неће бити цео број. г је исти у већини случајева, али само у случајевима када је излаз цео број.

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

У случају г или ако је изостављен, задње нуле иза децималне запете се изостављају, па ако желите да испишете исти број значајних цифара (број значајних цифара), користите експоненцијалну нотацију е или Е. цео део је увек једна цифра, а децимална запета је одређени број цифара, тако да ако желите да избаците н значајних цифара, само наведите н-1.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

Процентуални приказ

Ако је % наведен у стрингу спецификације форматирања, вредност нумеричког флоат-а или инт се множи са 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