I-format ang conversion sa Python, format (zero-filling, exponential notation, hexadecimal, atbp.)

Negosyo

Upang i-convert (format) ang isang numero o string sa iba’t ibang format sa Python, gamitin ang built-in na function na format() o ang string method str.format().

Sa seksyong ito, ipapaliwanag namin kung paano gamitin ang mga sumusunod na function.

  • built-in na function (hal. sa programming language)format()
  • paraan ng stringstr.format()

Bilang karagdagan, ang string ng detalye ng format para sa pag-convert sa sumusunod na format ay ipinaliwanag kasama ng sample code.

  • Kaliwa-makatwiran, Center-makatwiran, Kanan-makatwiran
  • zero fill
  • Sign (plus o minus)
  • Digit separator (kuwit, underscore)
  • Binary, octal, at hexadecimal na mga numero
  • Tukuyin ang bilang ng mga digit pagkatapos ng decimal point
  • Mga makabuluhang numero (bilang ng mga makabuluhang digit)
  • exponential notation
  • Pagpapakita ng porsyento

Tandaan na mula noong Python 3.6, idinagdag ang f-strings (f-strings) sa string method str.format() para gawin itong mas maigsi.

Built-in na function: format()

format() ay ibinigay bilang isang karaniwang Python built-in na function.

Ang balangkas ay ang mga sumusunod.

  • format(value, format_spec)
    • Ang unang argumento: angvalue
      Ang orihinal na halaga. String str, number int, float, atbp.
    • Ang pangalawang argumentoformat_spec
      I-format ang string ng detalye. String str
    • Return value: isang naka-format na string str

Ang mga halimbawa ay ipinapakita sa ibaba. Ang mga uri ng mga string ng format at kung paano isulat ang mga ito ay inilarawan sa ibang pagkakataon.

Sa halimbawang ito, gumamit kami ng mga numeric literal at string literal bilang unang argumento, ngunit siyempre maaari kang gumamit ng mga variable na naglalaman ng mga halagang ito.

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

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

String method str.format()

Mayroon ding format() na paraan para sa uri ng string str.

Ang {} sa string str na tumatawag sa format() method ay tinatawag na substitution field, at pinapalitan ng argumento ng format() method.

Ang string ng detalye ng format ay dapat na nakasulat sa field ng pagpapalit {} na sinusundan ng “:”.

Ang return value ay isang naka-format na string str.

Ang katumbas na proseso sa built-in na format ng function() na inilarawan sa itaas ay ang mga sumusunod.

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

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

Muli, gumagamit kami ng mga numeric literal at string literal bilang mga argumento, ngunit siyempre ang mga variable ay katanggap-tanggap din.

Pagtukoy ng mga argumento para sa mga patlang ng pagpapalit

Tukuyin ang mga argumento sa pagkakasunud-sunod (default)

Maaaring magkaroon ng maramihang mga patlang ng pagpapalit {}, at bilang default, ang mga argumento ng pamamaraan ay pinoproseso sa pagkakasunud-sunod. Kung aalisin ang string ng detalye ng format sa {}, iko-convert lang ito sa isang string ng str().

Kapaki-pakinabang para sa pagpasok ng mga variable na halaga sa isang string at pag-print ng mga ito.

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

Tumukoy ng positional argument para sa mga integer value

Kung ang isang integer na halaga ay tinukoy sa {}, gaya ng {0} o {1}, ang output ay depende sa pagkakasunud-sunod ng mga argumento. Ang parehong numero ay maaaring gamitin nang paulit-ulit. Ito ay kapaki-pakinabang kapag gusto mong ipasok ang parehong halaga sa isang string.

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

Tukuyin ang mga argumento ng keyword para sa mga arbitrary na pangalan (mga string)

Maaari mo ring tukuyin ang anumang pangalan sa {} at ilagay ito bilang argumento ng keyword.

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

Tumukoy ng listahan o diksyunaryo bilang argumento

Maaaring tukuyin ang mga listahan at diksyunaryo bilang mga argumento.

Gamitin ang [] upang tukuyin ang index ng isang listahan o ang susi ng isang diksyunaryo sa isang substitution field. Tandaan na ang mga panipi na “‘” at “” ay hindi ginagamit upang tukuyin ang mga key ng diksyunaryo.

Kung gusto mong gamitin ang parehong argument nang paulit-ulit, kailangan mong tumukoy ng integer value o isang string (pangalan) tulad ng inilarawan sa itaas.

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.

Maaari itong palawakin bilang positional na argumento sa pamamagitan ng pagdaragdag ng * sa listahan at pagtukoy nito bilang argumento, o bilang argumento ng keyword sa pamamagitan ng pagdaragdag ng ** sa diksyunaryo at pagtukoy dito bilang argumento.

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.

Paglalarawan ng mga kulot na bracket {}

Kung gusto mong magsulat ng mga kulot na bracket {,} sa format() na paraan, ulitin ito nang dalawang beses tulad ng {{,}}. Tandaan na hindi matatakasan ang mga backslash.

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

na-format na string

Sa parehong mga kaso, upang tukuyin ang format, isulat ang “:format string” pagkatapos ng integer value o name string sa {}.

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

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

Sa sumusunod, ipapaliwanag namin kung paano tukuyin ang format gamit ang isang format na string. Ang sample code ay gumagamit ng string method str.format(), ngunit ang parehong format na string ay maaaring gamitin sa built-in na function na format(). Sa built-in na format ng function(), ang string ng detalye ng format ay tinukoy bilang pangalawang argumento.

Kaliwa-makatwiran, Center-makatwiran, Kanan-makatwiran

Maaari mong ihanay ang left-justified, center-justified, right-justified, atbp. sa ibaba. Tukuyin ang kabuuang bilang ng mga character bilang isang numero.

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

Maaari mo ring tukuyin ang isang character na pupunan. Kung aalisin, tulad ng sa halimbawa sa itaas, ito ay isang puwang.

Maaari kang gumamit ng mga double-byte na character hangga’t ito ay isang solong character.

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

Right-justification na may > hindi isinasaalang-alang ang tanda (-+). Kung gagamit ka ng =, ang tanda ay sinusundan ng tinukoy na karakter. Kung gusto mong tukuyin ang +, isulat ang + pagkatapos =. Ang mga detalye ng pagpoproseso ng sign ay inilarawan sa ibang pagkakataon.

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

<, ^, at > maaaring tukuyin para sa mga string, ngunit = ay magreresulta sa isang error na ValueError. Kung gusto mong gumamit ng = para sa isang string, kailangan mong i-convert ito sa isang numero gamit ang int().

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

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

Ang parehong naaangkop sa mga floating-point na numero. Ang mga desimal na puntos ay binibilang din bilang isang character.

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

Ang mga listahan, tuple, atbp. ay magdudulot ng error kung tinukoy bilang, at maaaring ma-convert sa mga string gamit ang 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]*****

Para sa left-justified, center-justified, at right-justified, mayroon ding mga nakalaang pamamaraan ng string na tinatawag na ljust(), center(), at rjust().

0 punan

Kung gusto mong ayusin ang bilang ng mga digit sa pamamagitan ng zero-filling, itakda ang character na pupunan sa 0 at i-right-justify ito.

Sa kaso ng zero-filling, kung ang simbolo ng alignment ay tinanggal, ito ay pinoproseso na parang = ay tinukoy.

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

#ERROR!

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

Para sa zero-filling, mayroon ding nakalaang pamamaraan ng string na tinatawag na zfill().

Sign (plus o minus)

Bilang default, ang mga negatibong numero lamang ang minarkahan ng sign (minus-).

Kapag ang + ay idinagdag sa string ng detalye ng pag-format, ang isang sign (plus +) ay ipinapakita din para sa mga positibong numero. Kung may idinagdag na espasyo, may ipapakitang espasyo sa simula ng positibong numero, at ang bilang ng mga digit ay nakahanay sa negatibong numero.

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

Mag-ingat sa pagpupuno ng mga arbitrary na character, tulad ng zero-filling na binanggit sa itaas. Ang default, na walang + at walang mga puwang, ay pumupuno sa mga positibong numero ng isa pang character.

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

Kung ginamit ang isang alignment symbol, ang sign designation symbol ay dapat na isulat pagkatapos ng alignment symbol.

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

Digit separator (kuwit, underscore)

Magdagdag ng kuwit o underscore _ separator bawat tatlong digit. Ginagawa nitong mas madaling basahin ang malalaking numero. Tandaan na ang underscore_ ay isang opsyon na idinagdag sa Python 3.6, kaya hindi ito magagamit sa mga naunang bersyon.

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

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

Sa kaso ng mga floating-point na mga uri ng float na numero, tanging ang integer na bahagi ang nade-delimited.

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

Binary, octal, at hexadecimal na mga numero

Kino-convert ang mga numerical value sa binary, octal, at hexadecimal na mga numero para sa output.

  • b: Binary
  • o: Octal
  • d: Decimal
  • x,X: Hexadecimal (naka-capitalize ang malalaking titik)
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

Maaari rin itong isama sa 0-fill, at kadalasang ginagamit upang ihanay ang mga digit sa binary at hexadecimal notation.

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

Tandaan na dapat tukuyin ang bilang ng mga zero-fill na character na isinasaalang-alang ang prefix.

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

Para sa mga binary at hexadecimal na numero, tanging ang underscore _ digit na separator lamang ang maaaring ipasok (Python 3.6 o mas bago). 4-digit na separator ang ginagamit; ang bilang ng mga zero-filled na character ay dapat ding isaalang-alang ang bilang ng mga underscore.

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

Tanging ang uri ng integer na int ang makakapag-convert ng format sa binary o hexadecimal. Maaari mong gamitin ang int() upang i-convert ito sa isang numero.

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

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

Tukuyin ang bilang ng mga digit pagkatapos ng decimal point

Upang tukuyin ang bilang ng mga digit pagkatapos ng decimal point, gawin ang sumusunod: n ay ang bilang ng mga digit. Ang bilang ng mga digit pagkatapos ng decimal point ay nagiging tinukoy na bilang ng mga digit anuman ang bilang ng mga digit sa integer na bahagi.
.[n]f

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

Ang kaliwang bahagi ng decimal point ay maaaring tukuyin bilang left-justified, center-justified, right-justified, o zero-filled gaya ng inilarawan sa itaas. Kung ang bilang ng mga digit ng target na halaga ay higit sa tinukoy na numero, walang gagawin. Kung ang bilang ng mga digit sa target na halaga ay mas malaki kaysa sa tinukoy na bilang ng mga digit, walang gagawin.

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

Kung tumukoy ka ng bilang ng mga digit na mas mababa sa orihinal na bilang ng mga digit pagkatapos ng decimal point, ang halaga ay ibibilog. Tandaan na hindi ito pag-round sa pinakamalapit na buong numero, ngunit sa isang even na numero, hal. Ang 0.5 ay bilugan sa 0.

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

Kung gusto mong gumamit ng general rounding, maaari mong gamitin ang quantize() method ng standard library decimal.

exponential notation

Kapag ang floating-point float number ay na-convert sa string str, awtomatiko itong isusulat sa exponential notation depende sa bilang ng mga digit. Ang uri ng integer ay hindi.

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

Kung tutukuyin mo ang e o E sa string ng detalye ng pag-format, maaari kang palaging mag-convert sa exponential notation. Ang mga character na gagamitin sa output ay magiging e at E, ayon sa pagkakabanggit.

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

Posible ring tukuyin ang bilang ng mga digit pagkatapos ng decimal point. Ang bahagi ng integer ay palaging isang digit at ang decimal point ay ang tinukoy na bilang ng mga digit.

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

Tandaan na kung tinukoy mo ang left-justified, center-justified, right-justified, o zero-filled, ang e-, E+, atbp. ay mabibilang din bilang mga digit (mga character).

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

Mga makabuluhang numero (bilang ng mga makabuluhang digit)

Maaari mong tukuyin ang kabuuang bilang ng mga digit sa pamamagitan ng paggawa ng sumusunod Depende sa resulta, awtomatikong gagamitin ang exponential notation. Tandaan na ang mga sumusunod na zero pagkatapos ng decimal point ay aalisin.
.[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

Kung aalisin mo ang g, hindi magiging integer ang output. g ay pareho sa karamihan ng mga kaso, ngunit lamang sa mga kaso kung saan ang output ay isang integer.

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

Kung iproseso namin ang parehong halaga, makukuha namin ang sumusunod ayon sa pagkakabanggit.

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

Sa kaso ng g o kung ito ay tinanggal, ang mga trailing zero pagkatapos ng decimal point ay tinanggal, kaya kung gusto mong i-output ang parehong bilang ng mga makabuluhang numero (bilang ng mga makabuluhang digit), gamitin ang exponential notation ng e o E. Ang Ang bahagi ng integer ay palaging isang digit at ang decimal point ay ang tinukoy na bilang ng mga digit, kaya kung gusto mong mag-output ng mga n makabuluhang digit, tukuyin lamang ang 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

Pagpapakita ng porsyento

Kung ang % ay tinukoy sa string ng detalye ng pag-format, ang halaga ng numeric float o int ay i-multiply sa 100 at iko-convert sa isang string na may %.

Posible ring tukuyin ang bilang ng mga digit pagkatapos ng decimal point. Ang default ay anim na digit pagkatapos ng decimal point. Available din ang left-justify, center-justify, right-justify, at zero-fill. Ang % ay binibilang din bilang isang character.

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