Konvertimi i formatit në Python, formati (mbushje zero, shënimi eksponencial, heksadecimal, etj.)

biznes

Për të kthyer (formatuar) një numër ose varg në formate të ndryshme në Python, përdorni formatin e integruar të funksionit () ose metodën e vargut str.format ().

Në këtë seksion, ne do të shpjegojmë se si të përdorim funksionet e mëposhtme.

  • funksion i integruar (p.sh. në gjuhën e programimit)format()
  • metoda e vargutstr.format()

Përveç kësaj, vargu i specifikimit të formatit për konvertimin në formatin e mëposhtëm shpjegohet me kodin e mostrës.

  • Majtas-justifikuar, qendër-justifikuar, Djathtas justifikuar
  • mbushje zero
  • Shenja (plus ose minus)
  • Ndarës i shifrave (presje, nënvizim)
  • Numrat binar, oktal dhe heksadecimal
  • Specifikoni numrin e shifrave pas presjes dhjetore
  • Shifra të rëndësishme (numri i shifrave të rëndësishme)
  • shënimi eksponencial
  • Shfaqja e përqindjes

Vini re se që nga Python 3.6, vargjet f (f-strings) janë shtuar në metodën e vargut str.format() për ta bërë atë më koncize.

Funksioni i integruar: format()

format() ofrohet si një funksion standard i integruar në Python.

Skica është si më poshtë.

  • format(value, format_spec)
    • Argumenti i parë:value
      Vlera origjinale. String str, numri int, float etj.
    • Argumenti i dytëformat_spec
      Vargu i specifikimit të formatit. String rr
    • Vlera e kthimit: një varg i formatuar str

Shembujt tregohen më poshtë. Llojet e vargjeve të formatit dhe mënyra e shkrimit të tyre përshkruhen më vonë.

Në këtë shembull, ne kemi përdorur literale numerike dhe literale të vargjeve si argumentin e parë, por sigurisht që mund të përdorni variabla që përmbajnë këto vlera.

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

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

Metoda e vargut str.format()

Ekziston edhe një metodë format() për llojin string str.

{} në vargun str që thërret metodën format() quhet fusha e zëvendësimit dhe zëvendësohet me argumentin e metodës format().

Vargu i specifikimit të formatit duhet të shkruhet në fushën e zëvendësimit {} e ndjekur nga “:”.

Vlera e kthyer është një varg i formatuar.

Procesi ekuivalent me formatin e funksionit të integruar() të përshkruar më sipër është si më poshtë.

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

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

Përsëri, ne po përdorim literale numerike dhe literale të vargjeve si argumente, por sigurisht që variablat janë gjithashtu të pranueshëm.

Specifikimi i argumenteve për fushat e zëvendësimit

Specifikoni argumentet sipas renditjes (parazgjedhja)

Mund të ketë shumë fusha zëvendësimi {}, dhe si parazgjedhje, argumentet e metodës përpunohen sipas radhës. Nëse vargu i specifikimit të formatit në {} hiqet, ai thjesht do të konvertohet në një varg nga str().

E dobishme për futjen e vlerave të ndryshueshme në një varg dhe printimin e tyre.

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

Specifikoni një argument pozicional për vlerat e numrave të plotë

Nëse një vlerë e plotë është specifikuar në {}, si p.sh. {0} ose {1}, dalja do të varet nga rendi i argumenteve. I njëjti numër mund të përdoret në mënyrë të përsëritur. Kjo është e dobishme kur dëshironi të futni të njëjtën vlerë në një varg.

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

Specifikoni argumentet e fjalëve kyçe për emrat arbitrarë (vargjet)

Ju gjithashtu mund të specifikoni çdo emër në {} dhe ta futni atë si argument të fjalës kyçe.

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

Specifikoni një listë ose fjalor si argument

Listat dhe fjalorët mund të specifikohen si argumente.

Përdorni [] për të specifikuar indeksin e një liste ose çelësin e një fjalori në një fushë zëvendësimi. Vini re se thonjëzat “‘” dhe “” nuk përdoren për të specifikuar çelësat e fjalorit.

Nëse dëshironi të përdorni të njëjtin argument në mënyrë të përsëritur, duhet të specifikoni një vlerë të plotë ose një varg (emër) siç përshkruhet më sipër.

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.

Ai mund të zgjerohet si një argument pozicional duke shtuar * në listë dhe duke e specifikuar atë si një argument, ose si një argument me fjalë kyçe duke shtuar ** në fjalor dhe duke e specifikuar atë si një argument.

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.

Përshkrimi i kllapave kaçurrelë {}

Nëse dëshironi të shkruani kllapa kaçurrelë {,} në metodën format(), përsëriteni dy herë si {{,}}. Vini re se vijat e prapme nuk mund të shmangen.

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

varg i formatuar

Në të dyja rastet, për të specifikuar formatin, shkruani “:format string” pas vlerës së plotë ose vargut të emrit në {}.

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

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

Në vijim, ne do të shpjegojmë se si të specifikoni formatin duke përdorur një varg formati. Kodi i mostrës përdor metodën string str.format(), por i njëjti varg formati mund të përdoret me formatin e integruar të funksionit (). Në formatin e funksionit të integruar(), vargu i specifikimit të formatit specifikohet si argumenti i dytë.

Majtas-justifikuar, qendër-justifikuar, Djathtas justifikuar

Më poshtë mund të rreshtoni të justifikuara majtas, të justifikuara në qendër, të justifikuara nga djathtas, etj. Specifikoni numrin total të karaktereve si numër.

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

Ju gjithashtu mund të specifikoni një karakter që do të plotësohet. Nëse hiqet, si në shembullin e mësipërm, është një hapësirë.

Ju mund të përdorni karaktere me dy bajt për sa kohë që është një karakter i vetëm.

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

E drejta-justifikimi me > nuk merr parasysh shenjën (-,+). Nëse përdorni =, shenja ndiqet nga karakteri i specifikuar. Nëse dëshironi të specifikoni +, shkruani + pas =. Detajet e përpunimit të shenjave përshkruhen më vonë.

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

<, ^, dhe > mund të specifikohet për vargjet, por = do të rezultojë në një gabim ValueError. Nëse dëshironi të përdorni = për një varg, duhet ta konvertoni atë në një numër duke përdorur int().

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

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

E njëjta gjë vlen edhe për numrat me pikë lundruese. Pikët dhjetore numërohen gjithashtu si karakter.

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

Listat, tuples, etj. do të shkaktojnë një gabim nëse specifikohen si është, dhe mund të konvertohen në vargje duke përdorur 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]*****

Për arsyetimin e majtë, të justifikuar në qendër dhe të justifikuar në të djathtë, ekzistojnë gjithashtu metoda të dedikuara të vargut të quajtura ljust(), center() dhe rjust().

0 mbushur

Nëse dëshironi të rregulloni numrin e shifrave duke plotësuar zero, vendosni karakterin që do të plotësohet në 0 dhe justifikoni atë djathtas.

Në rastin e mbushjes së zeros, nëse simboli i shtrirjes hiqet, ai përpunohet sikur të ishte specifikuar =.

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

Për mbushjen e zeros, ekziston gjithashtu një metodë e dedikuar e vargut të quajtur zfill().

Shenja (plus ose minus)

By default, vetëm numra negative janë të shënuara me një shenjë (minus-).

Kur + është shtuar në vargun formatimit specifikim, një shenjë (plus +) është shfaqur edhe për numrat pozitiv. Nëse një hapësirë ​​është shtuar, një hapësirë ​​shfaqet në fillim të numrit pozitiv, dhe numri i shifrave është një linjë me numër negativ.

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

Kini kujdes kur mbushni me karaktere arbitrare, siç është mbushja zero e përmendur më sipër. Parazgjedhja, pa + dhe pa hapësira, mbush numrat pozitivë me një karakter më shumë.

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

Nëse përdoret një simbol shtrirjeje, simboli i përcaktimit të shenjës duhet të shkruhet pas simbolit të shtrirjes.

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

Ndarës i shifrave (presje, nënvizim)

Shtoni një presje ose ndarës _ nënvizon çdo tre shifra. Kjo i bën numrat e mëdhenj më të lehtë për t’u lexuar. Vini re se underscore_ është një opsion i shtuar në Python 3.6, kështu që nuk mund të përdoret në versionet e mëparshme.

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

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

Në rastin e llojeve të float-it të numrave me pikë lundruese, vetëm pjesa e plotë është e kufizuar.

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

Numrat binar, oktal dhe heksadecimal

Konverton vlerat numerike në numra binar, oktal dhe heksadecimal për dalje.

  • b: Binar
  • o: oktal
  • d: dhjetore
  • x,X: Heksadecimal (shkronjat e mëdha janë të kapitalizuara)
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

Mund të kombinohet gjithashtu me 0-mbushje dhe shpesh përdoret për të rreshtuar shifrat në shënimin binar dhe heksadecimal.

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

Vini re se numri i karaktereve me mbushje zero duhet të specifikohet duke marrë parasysh prefiksin.

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

Për numrat binar dhe heksadecimal, mund të futet vetëm ndarësi i nënvizave _ shifra (Python 3.6 ose më i ri). Përdoret ndarës me 4 shifra; numri i karaktereve të mbushura me zero duhet të marrë parasysh edhe numrin e nënvizave.

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

Vetëm tipi i plotë int mund ta konvertojë formatin në binar ose heksadecimal. Ju mund të përdorni int() për ta kthyer atë në një numër.

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

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

Specifikoni numrin e shifrave pas presjes dhjetore

Për të specifikuar numrin e shifrave pas presjes dhjetore, bëni sa më poshtë: n është numri i shifrave. Numri i shifrave pas presjes dhjetore bëhet numri i caktuar i shifrave pavarësisht nga numri i shifrave në pjesën e plotë.
.[n]f

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

Ana e majtë e pikës dhjetore mund të specifikohet si e justifikuar në të majtë, e justifikuar në qendër, e justifikuar në të djathtë ose e mbushur me zero siç përshkruhet më sipër. Nëse numri i shifrave të vlerës së synuar është më shumë se numri i specifikuar, asgjë nuk bëhet. Nëse numri i shifrave në vlerën e synuar është më i madh se numri i specifikuar i shifrave, asgjë nuk bëhet.

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

Nëse specifikoni një numër shifrash më pak se numri fillestar i shifrave pas pikës dhjetore, vlera do të rrumbullakoset. Vini re se ky nuk është rrumbullakim në numrin e plotë më të afërt, por në një numër çift, p.sh. 0.5 rrumbullakoset në 0.

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

Nëse dëshironi të përdorni rrumbullakim të përgjithshëm, mund të përdorni metodën quantize() të dhjetorit standard të bibliotekës.

shënimi eksponencial

Kur një numër notues me pikë lundruese konvertohet në një varg vargu, ai automatikisht do të shkruhet me shënime eksponenciale në varësi të numrit të shifrave. Lloji i plotë int jo.

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

Nëse specifikoni e ose E në vargun e specifikimeve të formatimit, gjithmonë mund të konvertoheni në shënimin eksponencial. Karakteret e përdorura në dalje do të jenë përkatësisht e dhe E.

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

Është gjithashtu e mundur të specifikohet numri i shifrave pas pikës dhjetore. Pjesa e plotë do të jetë gjithmonë një shifër dhe pika dhjetore do të jetë numri i caktuar i shifrave.

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

Vini re se nëse specifikoni të justifikuara majtas, të justifikuara në qendër, të justifikuara nga djathtas ose të mbushura me zero, e-, E+, etj. do të numërohen gjithashtu si shifra (karaktere).

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

Shifra të rëndësishme (numri i shifrave të rëndësishme)

Mund të specifikoni numrin e përgjithshëm të shifrave duke bërë sa vijon. Në varësi të rezultatit, shënimi eksponencial do të përdoret automatikisht. Vini re se zerat pasuese pas presjes dhjetore do të hiqen.
.[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

Nëse e hiqni g, dalja nuk do të jetë një numër i plotë. g është i njëjtë në shumicën e rasteve, por vetëm në rastet kur dalja është një numër i plotë.

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

Nëse përpunojmë të njëjtën vlerë, marrim përkatësisht sa vijon.

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

Në rastin e g ose nëse hiqet, zero pas presjes dhjetore hiqen, kështu që nëse dëshironi të nxirrni të njëjtin numër shifrash domethënëse (numri i shifrave domethënëse), përdorni shënimin eksponencial të e ose E. Pjesa e plotë është gjithmonë një shifër dhe pika dhjetore është numri i specifikuar i shifrave, kështu që nëse dëshironi të nxirrni n shifra të rëndësishme, thjesht specifikoni 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

Shfaqja e përqindjes

Nëse % është specifikuar në vargun e specifikimit të formatimit, vlera e float numerike ose int shumëzohet me 100 dhe konvertohet në një varg me %.

Është gjithashtu e mundur të specifikohet numri i shifrave pas pikës dhjetore. Parazgjedhja është gjashtë shifra pas pikës dhjetore. Majtas-justify, qendër-justify, djathtas justify dhe zero-fill janë gjithashtu të disponueshme. % llogaritet gjithashtu si karakter.

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