Ubadilishaji wa umbizo katika Chatu, umbizo (kujaza sifuri, nukuu ya kielelezo, heksadesimali, n.k.)

Biashara

Ili kubadilisha (umbizo) nambari au mfuatano kuwa umbizo mbalimbali katika Python, tumia umbizo la kitendakazi lililojengewa ndani() au mbinu ya kamba str.format().

Katika sehemu hii, tutaelezea jinsi ya kutumia kazi zifuatazo.

  • kitendakazi kilichojumuishwa (k.m. katika lugha ya programu)format()
  • njia ya kambastr.format()

Kwa kuongeza, kamba ya vipimo vya umbizo la kugeuza kuwa umbizo lifuatalo inaelezewa na msimbo wa sampuli.

  • Imehesabiwa haki, yenye haki katikati, imehesabiwa haki
  • kujaza sifuri
  • Saini (pamoja na kuondoa)
  • Kitenganishi cha tarakimu (koma, kistari)
  • Nambari za binary, octal, na heksadesimali
  • Bainisha idadi ya tarakimu baada ya nukta ya desimali
  • Takwimu muhimu (idadi ya tarakimu muhimu)
  • nukuu ya kielelezo
  • Asilimia ya onyesho

Kumbuka kwamba tangu Python 3.6, f-strings (f-strings) zimeongezwa kwa njia ya kamba str.format() ili kuifanya iwe mafupi zaidi.

Chaguo za kukokotoa zilizojumuishwa: umbizo()

format() imetolewa kama kazi ya kawaida ya Python iliyojengwa ndani.

Muhtasari ni kama ifuatavyo.

  • format(value, format_spec)
    • Hoja ya kwanza:value
      Thamani asili. Kamba str, nambari int, kuelea, nk.
    • Hoja ya piliformat_spec
      Mfuatano wa vipimo vya umbizo. String str
    • Thamani ya kurudisha: mfuatano ulioumbizwa str

Mifano imeonyeshwa hapa chini. Aina za kamba za umbizo na jinsi ya kuziandika zitaelezewa baadaye.

Katika mfano huu, tumetumia herufi halisi za nambari na mfuatano halisi kama hoja ya kwanza, lakini bila shaka unaweza kutumia viambishi vilivyo na maadili haya.

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

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

Mbinu ya kamba str.format()

Pia kuna umbizo () njia ya aina ya kamba.

{} katika mfuatano wa mfuatano unaoita umbizo() mbinu inaitwa uga mbadala, na inabadilishwa na hoja ya umbizo() mbinu.

Mfuatano wa ubainishaji wa umbizo unapaswa kuandikwa katika sehemu ya ubadilishaji {} ikifuatiwa na “:”.

Thamani ya kurudi ni kamba iliyoumbizwa str.

Mchakato sawa na umbizo la kukokotoa lililojengwa ndani () lililoelezwa hapo juu ni kama ifuatavyo.

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

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

Tena, tunatumia maandishi halisi ya nambari na maandishi ya mfuatano kama hoja, lakini bila shaka vigeuzo pia vinakubalika.

Inabainisha hoja za sehemu za uingizwaji

Bainisha hoja kwa mpangilio (chaguo-msingi)

Kunaweza kuwa na sehemu nyingi mbadala {}, na kwa chaguo-msingi, hoja za mbinu huchakatwa kwa mpangilio. Ikiwa mfuatano wa maelezo ya umbizo katika {} umeachwa, utabadilishwa tu kuwa mfuatano kwa str().

Inafaa kwa kuingiza thamani zinazobadilika kwenye mfuatano na kuzichapisha.

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

Bainisha hoja ya msimamo kwa nambari kamili

Ikiwa thamani kamili imebainishwa katika {}, kama vile {0} au {1}, matokeo yatategemea mpangilio wa hoja. Nambari sawa inaweza kutumika mara kwa mara. Hii ni muhimu unapotaka kuingiza thamani sawa katika mfuatano.

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

Bainisha hoja za maneno muhimu kwa majina ya kiholela (kamba)

Unaweza pia kubainisha jina lolote katika {} na uliweke kama hoja ya neno msingi.

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

Bainisha orodha au kamusi kama hoja

Orodha na kamusi zinaweza kubainishwa kama hoja.

Tumia [] kubainisha faharasa ya orodha au ufunguo wa kamusi katika sehemu ya kubadilisha. Kumbuka kuwa alama za nukuu “‘” na “” hazitumiki kubainisha funguo za kamusi.

Ikiwa unataka kutumia hoja sawa mara kwa mara, unahitaji kutaja thamani kamili au kamba (jina) kama ilivyoelezwa hapo juu.

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.

Inaweza kupanuliwa kama hoja ya msimamo kwa kuambatanisha * kwenye orodha na kuibainisha kama hoja, au kama hoja ya neno msingi kwa kuambatanisha ** kwenye kamusi na kuibainisha kama hoja.

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.

Maelezo ya mabano yaliyopinda {}

Ikiwa ungependa kuandika mabano yaliyojipinda {,} katika umbizo() mbinu, rudia mara mbili kama {{,}}. Kumbuka kwamba mikwaruzo haiwezi kuepukika.

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

kamba iliyoumbizwa

Katika visa vyote viwili, ili kubainisha umbizo, andika “:mfuatano wa fomati” baada ya nambari kamili au mfuatano wa jina katika {}.

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

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

Katika zifuatazo, tutaelezea jinsi ya kutaja muundo kwa kutumia kamba ya muundo. Msimbo wa sampuli hutumia mbinu ya kamba str.format(), lakini mfuatano wa umbizo sawa unaweza kutumika pamoja na umbizo la kitendakazi lililojengewa ndani(). Katika umbizo la kitendakazi lililojengewa ndani(), kamba ya vipimo vya umbizo imebainishwa kama hoja ya pili.

Imehesabiwa haki, yenye haki katikati, imehesabiwa haki

Unaweza kupangilia kuhalalishwa kwa kushoto, kuhalalishwa katikati, kuhalalisha kulia, n.k. hapa chini. Bainisha jumla ya idadi ya wahusika kama nambari.

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

Unaweza pia kubainisha herufi ya kujazwa. Ikiwa imeachwa, kama katika mfano hapo juu, ni nafasi.

Unaweza kutumia herufi za baiti mbili mradi tu ni herufi moja.

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

Kuhesabiwa haki kwa > haizingatii ishara (-+). Ikiwa unatumia =, ishara inafuatiwa na tabia maalum. Ikiwa unataka kutaja +, andika + baada ya =. Maelezo ya usindikaji wa ishara yanaelezwa baadaye.

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

<, ^, na > inaweza kubainishwa kwa mifuatano, lakini = itasababisha kosa ValueError. Ikiwa unataka kutumia = kwa kamba, unahitaji kuibadilisha kuwa nambari kwa kutumia int().

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

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

Vile vile hutumika kwa nambari za sehemu zinazoelea. Pointi za decimal pia huhesabiwa kama mhusika.

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

Orodha, nakala, n.k. zitasababisha hitilafu ikiwa imebainishwa kama ilivyo, na inaweza kubadilishwa kuwa mifuatano kwa kutumia 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]*****

Kwa kuhalalishwa kwa kushoto, kuhesabiwa haki katikati, na kuhesabiwa haki, pia kuna mbinu maalum za kamba zinazoitwa ljust(), center(), na rjust().

0 kujaza

Ikiwa unataka kurekebisha nambari ya nambari kwa kujaza sifuri, weka herufi ijazwe hadi 0 na uithibitishe kulia.

Katika kesi ya kujaza sifuri, ikiwa ishara ya upatanishi imeachwa, inachakatwa kana kwamba = ilibainishwa.

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

#KOSA!

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

Kwa kujaza sifuri, pia kuna njia iliyojitolea ya kamba inayoitwa zfill().

Saini (pamoja na kuondoa)

Kwa chaguo-msingi, nambari hasi pekee ndizo zilizo na alama (minus-).

Wakati + inapoongezwa kwenye mfuatano wa uainishaji wa uumbizaji, ishara (pamoja na +) pia huonyeshwa kwa nambari chanya. Ikiwa nafasi imeongezwa, nafasi inaonyeshwa mwanzoni mwa nambari nzuri, na nambari ya nambari inalingana na nambari hasi.

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

Kuwa mwangalifu unapojaza herufi kiholela, kama vile kujaza sifuri iliyotajwa hapo juu. Chaguo-msingi, bila + na hakuna nafasi, hujaza nambari chanya na herufi moja zaidi.

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

Ikiwa ishara ya upatanishi inatumiwa, ishara ya alama inapaswa kuandikwa baada ya ishara ya upatanishi.

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

Kitenganishi cha tarakimu (koma, kistari)

Ongeza koma au sisitiza _ kitenganishi kila tarakimu tatu. Hii inafanya idadi kubwa iwe rahisi kusoma. Kumbuka kuwa underscore_ ni chaguo lililoongezwa kwenye Python 3.6, kwa hivyo haiwezi kutumika katika matoleo ya awali.

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

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

Kwa upande wa aina za kuelea za nambari za kuelea, sehemu kamili pekee ndiyo imetenganishwa.

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

Nambari za binary, octal, na heksadesimali

Hubadili thamani za nambari ziwe nambari za binary, oktali, na heksadesimali kwa pato.

  • b: Nambari
  • o: Oktali
  • d: Nukta
  • x,X: Hexadecimal (herufi kubwa ni kubwa)
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

Inaweza pia kuunganishwa na 0-fill, na mara nyingi hutumika kupanga tarakimu katika nukuu binary na hexadesimoli.

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

Kumbuka kwamba idadi ya vibambo vya kujaza sifuri lazima ibainishwe kwa kuzingatia kiambishi awali.

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

Kwa nambari za binary na heksadesimali, ni kitenganishi cha tarakimu chini ya msingi _ pekee ndicho kinaweza kuingizwa (Python 3.6 au baadaye). Kitenganishi cha tarakimu 4 kinatumika; idadi ya vibambo vilivyojazwa sifuri lazima pia izingatie idadi ya mistari chini.

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

Ni aina kamili tu ya int inayoweza kubadilisha umbizo kuwa jozi au hexadesimoli. Unaweza kutumia int() kuibadilisha kuwa nambari.

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

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

Bainisha idadi ya tarakimu baada ya nukta ya desimali

Ili kutaja idadi ya tarakimu baada ya uhakika wa decimal, fanya yafuatayo: n ni idadi ya tarakimu. Idadi ya tarakimu baada ya nukta ya desimali inakuwa nambari maalum ya tarakimu bila kujali idadi ya tarakimu katika sehemu kamili.
.[n]f

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

Upande wa kushoto wa nukta ya desimali unaweza kubainishwa kama kuhalalishwa kwa kushoto, kuhalalishwa katikati, kuhalalisha kulia, au kujazwa sifuri kama ilivyoelezwa hapo juu. Ikiwa nambari ya nambari ya thamani inayolengwa ni zaidi ya nambari maalum, hakuna kinachofanyika. Ikiwa idadi ya tarakimu katika thamani inayolengwa ni kubwa kuliko nambari maalum ya tarakimu, hakuna kinachofanyika.

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

Ukibainisha idadi ya tarakimu chini ya nambari asili ya tarakimu baada ya nukta ya desimali, thamani itazungushwa. Kumbuka kuwa hii haizungushi kwa nambari nzima iliyo karibu zaidi, lakini kwa nambari sawa, k.m. 0.5 imezungushwa hadi 0.

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

Ikiwa unataka kutumia mzunguko wa jumla, unaweza kutumia quantize() njia ya desimali ya kawaida ya maktaba.

nukuu ya kielelezo

Nambari ya kuelea ya sehemu inayoelea inapogeuzwa kuwa mfuatano, itaandikwa kiotomatiki kwa nukuu ya kielelezo kulingana na idadi ya tarakimu. Nambari ya aina int haifanyi.

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

Ukibainisha e au E katika mfuatano wa vipimo vya uumbizaji, unaweza kubadilisha kila wakati hadi nukuu ya kielelezo. Herufi zitakazotumika kwenye pato zitakuwa e na E, mtawalia.

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

Pia inawezekana kutaja idadi ya tarakimu baada ya uhakika wa decimal. Sehemu kamili itakuwa tarakimu moja kila wakati na nukta ya desimali itakuwa nambari maalum ya tarakimu.

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

Kumbuka kwamba ukibainisha kuhalalishwa kwa kushoto, kuhalalishwa katikati, kuhalalishwa kwa kulia, au kujazwa sifuri, e-, E+, n.k. pia itahesabiwa kama tarakimu (herufi).

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

Takwimu muhimu (idadi ya tarakimu muhimu)

Unaweza kubainisha idadi ya jumla ya tarakimu kwa kufanya yafuatayo Kulingana na matokeo, nukuu ya kielelezo itatumika kiotomatiki. Kumbuka kuwa sufuri zinazofuata baada ya nukta ya desimali zitaachwa.
.[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

Ukiacha g, matokeo hayatakuwa nambari kamili. g ni sawa katika hali nyingi, lakini tu katika hali ambapo matokeo ni nambari kamili.

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

Ikiwa tunachakata thamani sawa, tunapata zifuatazo kwa mtiririko huo.

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

Katika kesi ya g au ikiwa imeachwa, sufuri zinazofuata baada ya nukta ya desimali zimeachwa, kwa hivyo ikiwa ungependa kutoa idadi sawa ya tarakimu muhimu (idadi ya tarakimu muhimu), tumia nukuu ya e au E. The sehemu kamili huwa ni tarakimu moja na nukta ya desimali ni nambari iliyobainishwa ya tarakimu, kwa hivyo ikiwa unataka kutoa n tarakimu muhimu, bainisha n-1 tu.

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

Asilimia ya onyesho

Ikiwa % imebainishwa katika mfuatano wa vipimo vya uumbizaji, thamani ya kuelea kwa nambari au int inazidishwa na 100 na kubadilishwa kuwa mfuatano wenye %.

Pia inawezekana kutaja idadi ya tarakimu baada ya uhakika wa decimal. Chaguo-msingi ni tarakimu sita baada ya nukta ya desimali. Kuhalalisha kushoto, kuhalalisha katikati, kuhalalisha kulia, na kujaza sifuri pia zinapatikana. % pia inahesabiwa kama mhusika.

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%