Veguheztina formatê ya di Python de, format (sifir-dagirtin, nîşankirina berbiçav, hexadecimal, hwd.)

Dikan

Ji bo veguherandina (format) hejmarek an rêzek di nav formên cihêreng ên Python de, forma fonksiyonê ya çêkirî () an jî rêbaza rêzikê str.format() bikar bînin.

Di vê beşê de, em ê rave bikin ka meriv çawa fonksiyonên jêrîn bikar tîne.

  • fonksiyona çêkirî (mînak di zimanê bernamekirinê de)format()
  • rêbaza stringstr.format()

Digel vê yekê, rêzika taybetmendiya formatê ya ji bo veguheztina forma jêrîn bi koda nimûneyê tê rave kirin.

  • Çep-rastdar, Navend-mafdar, Rast-rastdar
  • sifir tije
  • Nîşan (zêde an kêm)
  • Veqetkera jimareyan (koma, binxet)
  • Hejmarên binary, octal, û hexadecimal
  • Hejmara reqemên piştî xala dehiyê diyar bikin
  • Hêjmarên girîng (hejmara jimareyên girîng)
  • nîşeya pêşangeh
  • Nîşana sedî

Bala xwe bidinê ku ji Python 3.6-ê vir ve, f-string (f-strings) li rêbaza rêzikê str.format() hatine zêdekirin da ku ew kurttir bibe.

Fonksiyona çêkirî: format()

format() wekî fonksiyonek çêkirî ya standard Python tê peyda kirin.

Rêjeya rêzê wiha ye.

  • format(value, format_spec)
    • Argumana yekem: yavalue
      Nirxa orîjînal. String str, hejmar int, float, hwd.
    • Argumana duyemînformat_spec
      Format rêzika taybetmendiyê. String str
    • Nirxa vegerê: str

Nimûne li jêr têne nîşandan. Cûreyên rêzikên formatê û awayê nivîsandina wan paşê têne vegotin.

Di vê nimûneyê de, me tîpên hejmarî û rêzikên rêzikan wekî argumana yekem bikar anîne, lê bê guman hûn dikarin guhêrbarên ku van nirxan dihewînin bikar bînin.

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

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

Rêbaza rêzikê str.format()

Di heman demê de ji bo celebê string rêbazek format() jî heye.

Di rêzika str de {} ya ku gazî rêbaza format() dike, jê re qada cîgiriyê tê gotin, û bi argumana rêbaza format() tê guheztin.

Divê rêzika taybetmendiya formatê di qada veguheztinê de {} li pey “:” were nivîsandin.

Nirxa vegerê strek xêzkirî ye.

Pêvajoya wekhev a bi forma fonksiyonê ya çêkirî () ku li jor hatî destnîşan kirin wiha ye.

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

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

Dîsa, em biwêjên hejmarî û rêzikên rêzikan wekî arguman bikar tînin, lê bê guman guhêrbar jî têne pejirandin.

Diyarkirina argumanan ji bo qadên cîgir

Argumanan li gorî rêzê diyar bikin (pêşniyaz)

Dibe ku gelek qadên veguheztinê {} hebin, û ji hêla xwerû ve, argumanên rêbazê bi rêz têne hilberandin. Heke rêzika taybetmendiya formatê ya di {}-ê de were jêbirin, ew ê tenê ji hêla str() ve bibe stringek.

Ji bo têxistina nirxên guhêrbar di rêzekê de û çapkirina wan bikêr e.

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

Ji bo nirxên yekjimar argûmanek pozîsyonê diyar bikin

Heke di {}-ê de nirxek bêhejmar, wek {0} an {1}-ê were destnîşan kirin, dê encam bi rêza argumanan ve girêdayî be. Heman hejmar dikare çend caran were bikar anîn. Dema ku hûn dixwazin heman nirxê têxin nav rêzek ev bikêr e.

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

Argumanên peyva key ji bo navên keyfî (rêzan) diyar bikin

Her weha hûn dikarin her navekî di {}-ê de diyar bikin û wekî argumana peyva sereke têkevin.

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

Lîsteyek an ferhengek wekî arguman diyar bikin

Lîst û ferheng dikarin wekî argûman bêne destnîşan kirin.

[]-ê bikar bînin da ku navnîşek navnîşek an jî mifteya ferhengê di qada veguheztinê de diyar bikin. Bala xwe bidinê ku îşaretên “‘” û “” ji bo diyarkirina bişkojkên ferhengê nayên bikar anîn.

Heke hûn dixwazin heman argumana çend caran bikar bînin, hûn hewce ne ku wekî ku li jor hatî destnîşan kirin nirxek yekjimar an rêzek (nav) diyar bikin.

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.

Ew dikare wekî argumanek pozîsyonê bi pêvekirina * li navnîşê û destnîşankirina wê wekî arguman, an jî wekî argumanek peyva sereke bi pêvekirina ** li ferhengê û destnîşankirina wê wekî arguman were berfireh kirin.

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.

Danasîna bendikên çîçek {}

Heger tu dixwazî ​​bi awayê format() bendikên çîçek {,} binivîsin, wê du caran wek {{,}} dubare bikin. Bala xwe bidinê ku paşpirtikan nikarin birevin.

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

string formatkirî

Di her du rewşan de jî, ji bo diyarkirina formatê, piştî nirxa yekjimar an rêzika navî ya di {} de “:format string” binivîse.

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

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

Di jêrîn de, em ê rave bikin ka meriv çawa bi karanîna rêzek formatê formatê diyar dike. Koda nimûneyê rêbaza rêzikê str.format() bikar tîne, lê heman rêzika formatê dikare bi forma fonksiyonê ya çêkirî were bikar anîn(). Di forma fonksiyonê ya çêkirî de (), rêzika taybetmendiya formatê wekî argumana duyemîn tê destnîşan kirin.

Çep-rastdar, Navend-mafdar, Rast-rastdar

Hûn dikarin li jêr bi çep-rastdar, navend-rastdar, rast-rastdar, hwd. Bi tevahî hejmara tîpan wekî jimarek diyar bikin.

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

Her weha hûn dikarin karekterek diyar bikin ku tê dagirtin. Heke ji holê were rakirin, wek mînaka li jor, ew valahiyek e.

Hûn dikarin karakterên du-byte bikar bînin heya ku ew karakterek yekane be.

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

Rast-rastdarkirina bi & gt; nîşana (-,+) nahesibîne. Heke hûn = bikar bînin, nîşana bi karaktera diyarkirî tê şopandin. Heke hûn dixwazin + diyar bikin, + piştî = binivîsin. Hûrguliyên pêvajoya nîşanê paşê têne şirove kirin.

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

<, ^, û > dikare ji bo rêzan were diyar kirin, lê = dê bibe xeletiyek ValueError. Heke hûn dixwazin = ji bo rêzek bikar bînin, hûn hewce ne ku wê bi karanîna int() veguherînin hejmarek.

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

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

Heman tişt ji bo jimareyên xala hêlînê jî derbas dibe. Xalên dehanî jî wekî karakter têne hesibandin.

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îst, tîp, hwd. heke wekî ku were destnîşan kirin dê bibe sedema xeletiyekê û dikare bi karanîna str() veguhezîne rêzan.

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

Ji bo çep-rastdar, navend-rastdar, û rast-mafdar, rêbazên rêzê yên bi navê ljust(), navend(), û rjust() jî hene.

0 dagirtin

Ger hûn dixwazin hejmara jimareyan bi dagirtina sifirê verast bikin, karaktera ku were dagirtin wekî 0-ê bicîh bikin û wê rast-rast bikin.

Di rewşa dagirtina sifirê de, heke sembola hevrêziyê were derxistin, ew wekî ku = hatî destnîşan kirin tête kirin.

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

#ŞAŞÎ!

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

Ji bo tijîkirina sifir, di heman demê de rêbazek rêzika taybetî ya bi navê zfill() jî heye.

Nîşan (zêde an kêm)

Bi xwerû, tenê hejmarên neyînî bi nîşanek (minus-) têne nîşankirin.

Dema ku + li rêzika taybetmendiya formatkirinê tê zêdekirin, nîşanek (plus +) jî ji bo hejmarên erênî tê xuyang kirin. Ger valahiyek lê were zêdekirin, di destpêka jimareya erênî de cîhek tê xuyang kirin, û hejmara reqeman bi jimareya neyînî re tê rêz kirin.

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

Dema ku bi tîpên keyfî dagirtin, wek zero-dagirtina ku li jor hatî destnîşan kirin, baldar bin. Vebijêrk, bêyî + û bê cîh, hejmarên erênî bi karakterek din tije dike.

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

Ger nîşanek hevrêziyê were bikar anîn, divê nîşana nîşana nîşanê li dû nîşana hevrêziyê were nivîsandin.

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

Veqetkera jimareyan (koma, binxet)

Ji her sê jimaran veqetandek an binxala _ veqetandinê lê zêde bikin. Ev yek xwendina hejmarên mezin hêsantir dike. Têbînî ku underscore_ vebijarkek e ku di Python 3.6 de hatî zêdekirin, ji ber vê yekê ew di guhertoyên berê de nayê bikar anîn.

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

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

Di rewşa cureyên float-hejmar-xala hêlînê de, tenê beşa yekjimar tê veqetandin.

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

Hejmarên binary, octal, û hexadecimal

Ji bo derketinê nirxên jimareyî vediguherîne jimareyên binar, octal, û hexadecimal.

  • b: Binary
  • o: Octal
  • d: Dehanî
  • x,X: Hexadecimal (herfên mezin têne mezin kirin)
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

Di heman demê de ew dikare bi 0-dagirtinê re were hev kirin, û pir caran tê bikar anîn da ku jimareyan di nîgara binary û hexadecimal de li hev bikin.

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

Bala xwe bidinê ku divê hejmara tîpên tijî sifir bi pêşgira xwe ve were diyar kirin.

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

Ji bo jimareyên binary û hexadecimal, tenê veqetandina jimareya jêrîn dikare were danîn (Python 3.6 an derengtir). Veqetandina 4-reqemî tê bikaranîn; divê hejmara tîpên dagirtî yên sifir jî hejmara xêzkirinan li ber çavan bigire.

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

Tenê tîpa yekjimar int dikare formatê bike binary an hexadecimal. Hûn dikarin int() bikar bînin da ku wê veguherînin hejmarek.

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

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

Hejmara reqemên piştî xala dehiyê diyar bikin

Ji bo diyarkirina hejmara reqemên piştî dehiyê, wiha bikin: n hejmara reqeman e. Hejmara reqemên piştî dehjimarê dibe jimareya diyarkirî ya reqeman bêyî ku hejmara jimareyên di beşa yekjimar de hebe.
.[n]f

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

Aliyê çepê yê dehiyê dikare wekî ku li jor hatî destnîşan kirin wekî çep-rastdar, navend-rastdar, rast-rastdar, an sifir-dagirtî were destnîşankirin. Ger hejmara hejmarên nirxa armancê ji hejmara diyarkirî zêdetir be, tiştek nayê kirin. Ger hejmara reqeman di nirxa armancê de ji hejmara diyarkirî ya reqeman mezintir be, tiştek nayê kirin.

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

Ger hûn jimareyek reqeman ji jimareya eslî ya reqeman kêmtir diyar bikin piştî xala dehiyê, dê nirx were girover kirin. Bala xwe bidinê ku ev ne li jimareya tevayî ya herî nêzik e, lê li jimareyek zewacê ye, wek mînak. 0.5 bi 0 ve tê dorpêç kirin.

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

Heke hûn dixwazin dorpêkirina gelemperî bikar bînin, hûn dikarin rêbaza quantize() ya pirtûkxaneya standard ya dehan bikar bînin.

nîşeya pêşangeh

Dema ku jimareyek float-xala hêlînê vediguherîne rêzika rêzê, ew ê bixweber li gorî jimara reqeman bi nîşana nîşankirî were nivîsandin. Tîpa yekjimar int nake.

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

Ger hûn e an E-yê di rêzika taybetmendiya formatkirinê de destnîşan bikin, hûn dikarin her gav biguhezînin nîşana pêşangeh. Karakterên ku di encam de têne bikar anîn dê bi rêzdarî e û E bin.

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

Di heman demê de gengaz e ku meriv hejmara jimareyên piştî xala dehiyê diyar bike. Beşa yekjimar dê her dem yek reqem be û xala dehiyê dê jimara diyarkirî ya reqeman be.

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

Bala xwe bidinê ku ger hûn rastdar-çep, navend-rastdar, rast-rastdar, an jî-dagirtî diyar bikin, e-, E+, hwd jî dê wekî jimar (karakter) werin hesibandin.

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

Hêjmarên girîng (hejmara jimareyên girîng)

Hûn dikarin jimara giştî ya reqeman bi kirina jêrîn diyar bikin. Li gorî encamê, nîşana berfire dê bixweber were bikar anîn. Bala xwe bidinê ku sifirên paşdemayî yên piştî xala dehiyê dê werin jêbirin.
.[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

Ger hûn g ji holê rakin, dê encam ne jimarek be. g di pir rewşan de heman e, lê tenê di rewşên ku derketin hejmareke yekjimar e.

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

Ger em heman nirxê bişopînin, em bi rêzê ve ya jêrîn digirin.

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

Di rewşa g de an jî heke ew ji holê rabe, sifirên paşdemayî yên piştî dehsalan têne derxistin, ji ber vê yekê heke hûn dixwazin heman hejmarên girîng derxînin (hejmara jimareyên girîng), nîşana nîşankirina e an E bikar bînin. Beşa yekjimar her gav yek jimar e û xala dehiyê jî hejmara diyarkirî ya reqeman e, ji ber vê yekê heke hûn dixwazin n jimareyên girîng derxînin, tenê n-1 diyar bikin.

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

Nîşana sedî

Ger % di rêzika taybetmendiya formatkirinê de were destnîşan kirin, nirxa hejmar an jî int bi 100-ê tê zêdekirin û vediguhere rêzek bi % .

Di heman demê de gengaz e ku meriv hejmara jimareyên piştî dehemîn jî diyar bike. Vebijêrk şeş reqem piştî xala dehiyê ye. Çep-rastkirin, navend-rastkirin, rast-rastkirin, û sifir-dagirtin jî hene. % jî wekî karakter tê hesibandin.

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