Format penukaran dalam Python, format (isi sifar, notasi eksponen, perenambelasan, dll.)

Perniagaan

Untuk menukar (format) nombor atau rentetan ke dalam pelbagai format dalam Python, gunakan format fungsi terbina dalam() atau kaedah rentetan str.format().

Dalam bahagian ini, kami akan menerangkan cara menggunakan fungsi berikut.

  • fungsi terbina dalam (cth. dalam bahasa pengaturcaraan)format()
  • kaedah rentetanstr.format()

Di samping itu, rentetan spesifikasi format untuk menukar kepada format berikut dijelaskan dengan kod sampel.

  • Wajar kiri, Wajar tengah, Wajar kanan
  • isian sifar
  • Tanda (tambah atau tolak)
  • Pemisah digit (koma, garis bawah)
  • Nombor perduaan, perlapanan dan heksadesimal
  • Nyatakan bilangan digit selepas titik perpuluhan
  • Angka bererti (bilangan digit bererti)
  • tatatanda eksponen
  • Paparan peratusan

Ambil perhatian bahawa sejak Python 3.6, f-strings (f-strings) telah ditambahkan pada kaedah rentetan str.format() untuk menjadikannya lebih ringkas.

Fungsi terbina dalam: format()

format() disediakan sebagai fungsi terbina dalam Python standard.

Rangkanya adalah seperti berikut.

  • format(value, format_spec)
    • Hujah pertama: yangvalue
      Nilai asal. String str, number int, float, dsb.
    • Hujah keduaformat_spec
      Format rentetan spesifikasi. String str
    • Nilai pulangan: rentetan terformat str

Contoh ditunjukkan di bawah. Jenis rentetan format dan cara menulisnya diterangkan kemudian.

Dalam contoh ini, kami telah menggunakan literal angka dan literal rentetan sebagai hujah pertama, tetapi sudah tentu anda boleh menggunakan pembolehubah yang mengandungi nilai ini.

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

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

Kaedah rentetan str.format()

Terdapat juga kaedah format() untuk jenis str rentetan.

{} dalam str rentetan yang memanggil kaedah format() dipanggil medan penggantian dan digantikan dengan hujah kaedah format().

Rentetan spesifikasi format hendaklah ditulis dalam medan penggantian {} diikuti dengan “:”.

Nilai pulangan ialah str rentetan yang diformatkan.

Proses yang setara dengan format fungsi terbina dalam () yang diterangkan di atas adalah seperti berikut.

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

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

Sekali lagi, kami menggunakan literal angka dan literal rentetan sebagai hujah, tetapi sudah tentu pembolehubah juga boleh diterima.

Menentukan hujah untuk medan penggantian

Tentukan hujah mengikut susunan (lalai)

Terdapat berbilang medan penggantian {} dan secara lalai, argumen kaedah diproses mengikut tertib. Jika rentetan spesifikasi format dalam {} diabaikan, ia hanya akan ditukar kepada rentetan oleh str().

Berguna untuk memasukkan nilai pembolehubah dalam rentetan dan mencetaknya.

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

Tentukan hujah kedudukan untuk nilai integer

Jika nilai integer dinyatakan dalam {}, seperti {0} atau {1}, output akan bergantung pada susunan argumen. Nombor yang sama boleh digunakan berulang kali. Ini berguna apabila anda ingin memasukkan nilai yang sama dalam rentetan.

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

Tentukan hujah kata kunci untuk nama arbitrari (rentetan)

Anda juga boleh menentukan sebarang nama dalam {} dan masukkannya sebagai hujah kata kunci.

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

Tentukan senarai atau kamus sebagai hujah

Senarai dan kamus boleh ditentukan sebagai hujah.

Gunakan [] untuk menentukan indeks senarai atau kunci kamus dalam medan penggantian. Ambil perhatian bahawa tanda petikan “‘” dan “” tidak digunakan untuk menentukan kunci kamus.

Jika anda ingin menggunakan hujah yang sama berulang kali, anda perlu menentukan nilai integer atau rentetan (nama) seperti yang diterangkan di atas.

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.

Ia boleh dikembangkan sebagai hujah kedudukan dengan menambahkan * pada senarai dan menyatakannya sebagai hujah, atau sebagai hujah kata kunci dengan menambahkan ** pada kamus dan menyatakannya sebagai hujah.

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.

Perihalan kurungan kerinting {}

Jika anda ingin menulis kurungan kerinting {,} dalam kaedah format(), ulangi dua kali seperti {{,}}. Ambil perhatian bahawa garis miring ke belakang tidak boleh dielakkan.

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

rentetan berformat

Dalam kedua-dua kes, untuk menentukan format, tulis “:format string” selepas nilai integer atau nama rentetan dalam {}.

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

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

Dalam perkara berikut, kami akan menerangkan cara menentukan format menggunakan rentetan format. Kod sampel menggunakan kaedah rentetan str.format(), tetapi rentetan format yang sama boleh digunakan dengan format fungsi terbina dalam(). Dalam format fungsi terbina dalam(), rentetan spesifikasi format ditentukan sebagai hujah kedua.

Wajar kiri, Wajar tengah, Wajar kanan

Anda boleh menjajarkan wajaran kiri, wajaran tengah, wajaran kanan, dsb. di bawah. Tentukan jumlah bilangan aksara sebagai nombor.

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

Anda juga boleh menentukan aksara untuk diisi. Jika ditinggalkan, seperti dalam contoh di atas, ia adalah ruang.

Anda boleh menggunakan aksara dua bait asalkan ia adalah satu aksara.

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

Justifikasi dengan > tidak mengambil kira tanda (-+). Jika anda menggunakan =, tanda itu diikuti oleh aksara yang ditentukan. Jika anda ingin menyatakan +, tulis + selepas =. Butiran pemprosesan tanda diterangkan kemudian.

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

<, ^, dan > boleh ditentukan untuk rentetan, tetapi = akan mengakibatkan ralat ValueError. Jika anda ingin menggunakan = untuk rentetan, anda perlu menukarnya kepada nombor menggunakan int().

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

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

Perkara yang sama berlaku untuk nombor titik terapung. Titik perpuluhan juga dikira sebagai aksara.

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

Senarai, tupel, dsb. akan menyebabkan ralat jika dinyatakan seperti sedia ada, dan boleh ditukar kepada rentetan menggunakan 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]*****

Untuk dibenarkan kiri, wajaran tengah dan wajaran kanan, terdapat juga kaedah rentetan khusus yang dipanggil ljust(), center(), dan rjust().

0 isi

Jika anda ingin melaraskan bilangan digit dengan pengisian sifar, tetapkan aksara untuk diisi kepada 0 dan benarkan ia.

Dalam kes pengisian sifar, jika simbol penjajaran ditinggalkan, ia diproses seolah-olah = ditentukan.

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

#RALAT!

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

Untuk pengisian sifar, terdapat juga kaedah rentetan khusus yang dipanggil zfill().

Tanda (tambah atau tolak)

Secara lalai, hanya nombor negatif ditandakan dengan tanda (tolak-).

Apabila + ditambahkan pada rentetan spesifikasi pemformatan, tanda (tambah +) juga dipaparkan untuk nombor positif. Jika ruang ditambah, ruang dipaparkan pada permulaan nombor positif, dan bilangan digit diselaraskan dengan nombor negatif.

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

Berhati-hati apabila mengisi dengan aksara sewenang-wenangnya, seperti pengisian sifar yang disebutkan di atas. Lalai, tanpa + dan tanpa ruang, mengisi nombor positif dengan satu aksara lagi.

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

Jika simbol penjajaran digunakan, simbol penetapan tanda hendaklah ditulis selepas simbol penjajaran.

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

Pemisah digit (koma, garis bawah)

Tambahkan koma atau garis bawah pemisah _ setiap tiga digit. Ini menjadikan nombor yang besar lebih mudah dibaca. Ambil perhatian bahawa underscore_ ialah pilihan yang ditambahkan dalam Python 3.6, jadi ia tidak boleh digunakan dalam versi terdahulu.

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

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

Dalam kes jenis apungan nombor titik terapung, hanya bahagian integer dihadkan.

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

Nombor perduaan, perlapanan dan heksadesimal

Menukar nilai berangka kepada nombor perduaan, perlapanan dan heksadesimal untuk output.

  • b: Perduaan
  • o: Oktal
  • d: Perpuluhan
  • x,X: Heksadesimal (huruf besar ditulis dengan huruf besar)
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

Ia juga boleh digabungkan dengan 0-fill, dan selalunya digunakan untuk menjajarkan digit dalam tatatanda binari dan heksadesimal.

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

Ambil perhatian bahawa bilangan aksara isian sifar mesti ditentukan dengan mengambil kira awalan.

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

Untuk nombor perduaan dan perenambelasan, hanya pemisah angka _ garis bawah boleh disisipkan (Python 3.6 atau lebih baru). Pemisah 4 digit digunakan; bilangan aksara yang diisi sifar juga mesti mengambil kira bilangan garis bawah.

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

Hanya int jenis integer boleh menukar format kepada binari atau perenambelasan. Anda boleh menggunakan int() untuk menukarnya kepada nombor.

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

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

Nyatakan bilangan digit selepas titik perpuluhan

Untuk menentukan bilangan digit selepas titik perpuluhan, lakukan perkara berikut: n ialah bilangan digit. Bilangan digit selepas titik perpuluhan menjadi bilangan digit yang ditentukan tanpa mengira bilangan digit dalam bahagian integer.
.[n]f

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

Bahagian kiri titik perpuluhan boleh ditentukan sebagai wajar kiri, wajar tengah, wajar kanan atau diisi sifar seperti yang diterangkan di atas. Jika bilangan digit nilai sasaran lebih daripada nombor yang ditentukan, tiada apa yang dilakukan. Jika bilangan digit dalam nilai sasaran lebih besar daripada bilangan digit yang ditentukan, tiada apa yang dilakukan.

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

Jika anda menentukan bilangan digit kurang daripada bilangan digit asal selepas titik perpuluhan, nilai akan dibundarkan. Ambil perhatian bahawa ini bukan pembundaran kepada nombor bulat terdekat, tetapi kepada nombor genap, mis. 0.5 dibundarkan kepada 0.

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

Jika anda ingin menggunakan pembundaran umum, anda boleh menggunakan kaedah quantize() perpuluhan perpustakaan standard.

tatatanda eksponen

Apabila nombor apungan titik terapung ditukar kepada str rentetan, ia akan ditulis secara automatik dalam tatatanda eksponen bergantung pada bilangan digit. Jenis integer tidak.

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

Jika anda menentukan e atau E dalam rentetan spesifikasi pemformatan, anda sentiasa boleh menukar kepada tatatanda eksponen. Aksara yang digunakan dalam output ialah e dan E, masing-masing.

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

Ia juga mungkin untuk menentukan bilangan digit selepas titik perpuluhan. Bahagian integer akan sentiasa menjadi satu digit dan titik perpuluhan akan menjadi bilangan digit yang ditentukan.

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

Ambil perhatian bahawa jika anda menentukan wajaran kiri, wajaran tengah, wajaran kanan atau isi sifar, e-, E+, dsb. juga akan dikira sebagai digit (aksara).

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

Angka bererti (bilangan digit bererti)

Anda boleh menentukan bilangan keseluruhan digit dengan melakukan perkara berikut Bergantung pada keputusan, tatatanda eksponen akan digunakan secara automatik. Ambil perhatian bahawa sifar di belakang selepas titik perpuluhan akan ditinggalkan.
.[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

Jika anda meninggalkan g, output tidak akan menjadi integer. g adalah sama dalam kebanyakan kes, tetapi hanya dalam kes di mana output ialah 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

Jika kita memproses nilai yang sama, kita mendapat yang berikut masing-masing.

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

Dalam kes g atau jika ia ditinggalkan, sifar mengekor selepas titik perpuluhan ditinggalkan, jadi jika anda ingin mengeluarkan bilangan angka bererti yang sama (bilangan digit bererti), gunakan tatatanda eksponen e atau E. bahagian integer sentiasa satu digit dan titik perpuluhan ialah bilangan digit yang ditentukan, jadi jika anda ingin mengeluarkan n digit bererti, nyatakan 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

Paparan peratusan

Jika % dinyatakan dalam rentetan spesifikasi pemformatan, nilai apungan berangka atau int didarab dengan 100 dan ditukar kepada rentetan dengan %.

Ia juga mungkin untuk menentukan bilangan digit selepas titik perpuluhan. Lalai ialah enam digit selepas titik perpuluhan. Justify kiri, justify tengah, justify kanan dan isian sifar juga tersedia. % juga dikira sebagai aksara.

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