การแปลงรูปแบบใน Python, รูปแบบ (การเติมศูนย์, เลขชี้กำลัง, เลขฐานสิบหก, ฯลฯ )

ในการแปลง (รูปแบบ) ตัวเลขหรือสตริงเป็นรูปแบบต่างๆ ใน ​​Python ให้ใช้ฟังก์ชัน format() ในตัวหรือวิธีสตริง str.format()

ในส่วนนี้ เราจะอธิบายวิธีการใช้ฟังก์ชันต่อไปนี้

• ฟังก์ชันในตัว (เช่น ในภาษาโปรแกรม)format()
• วิธีสตริงstr.format()

นอกจากนี้ สตริงข้อมูลจำเพาะรูปแบบสำหรับการแปลงเป็นรูปแบบต่อไปนี้จะอธิบายด้วยโค้ดตัวอย่าง

• จัดชิดซ้าย จัดกึ่งกลาง จัดชิดขวา
• เติมศูนย์
• เครื่องหมาย (บวกหรือลบ)
• ตัวคั่นหลัก (จุลภาค, ขีดล่าง)
• เลขฐานสอง ฐานแปด และฐานสิบหก
• ระบุจำนวนหลักหลังจุดทศนิยม
• ตัวเลขที่มีนัยสำคัญ (จำนวนหลักสำคัญ)
• สัญกรณ์เลขชี้กำลัง
• เปอร์เซ็นต์การแสดงผล

โปรดทราบว่าตั้งแต่ Python 3.6 f-strings (f-strings) ได้ถูกเพิ่มเข้าไปในเมธอด string str.format() เพื่อให้กระชับยิ่งขึ้น

ฟังก์ชั่นในตัว: รูปแบบ ()

format() เป็นฟังก์ชันมาตรฐานในตัวของ Python

• Built-in Functions — format() — Python 3.10.0 Documentation

เค้าร่างเป็นดังนี้.

• format(value, format_spec)
  • อาร์กิวเมนต์แรก: thevalue
    ค่าเดิม. สตริง str, จำนวน int, ทุ่น ฯลฯ
  • อาร์กิวเมนต์ที่สองformat_spec
    จัดรูปแบบสตริงข้อกำหนด สตริง str
  • ส่งคืนค่า: สตริงที่จัดรูปแบบ str

ตัวอย่างแสดงอยู่ด้านล่าง ประเภทของสตริงรูปแบบและวิธีการเขียนจะอธิบายในภายหลัง

ในตัวอย่างนี้ เราได้ใช้ตัวอักษรตัวเลขและตัวอักษรสตริงเป็นอาร์กิวเมนต์แรก แต่แน่นอนว่า คุณสามารถใช้ตัวแปรที่มีค่าเหล่านี้ได้

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

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

วิธีสตริง str.format()

นอกจากนี้ยังมีเมธอด format() สำหรับประเภทสตริง str

• Built-in Types — str.format() — Python 3.10.0 Documentation

{} ในสตริง str ที่เรียกใช้เมธอด format() เรียกว่าฟิลด์การแทนที่ และถูกแทนที่ด้วยอาร์กิวเมนต์ของเมธอด format()

ควรเขียนสตริงข้อกำหนดรูปแบบในฟิลด์การแทนที่ {} ตามด้วย “:”

ค่าที่ส่งกลับเป็นสตริงที่จัดรูปแบบ str

กระบวนการที่เทียบเท่ากับรูปแบบฟังก์ชันในตัว () ที่อธิบายไว้ข้างต้นมีดังนี้

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

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

อีกครั้ง เราใช้ตัวอักษรตัวเลขและตัวอักษรสตริงเป็นอาร์กิวเมนต์ แต่แน่นอนว่าตัวแปรก็เป็นที่ยอมรับเช่นกัน

การระบุอาร์กิวเมนต์สำหรับฟิลด์การแทนที่

ระบุอาร์กิวเมนต์ตามลำดับ (ค่าเริ่มต้น)

สามารถมีฟิลด์ทดแทนได้หลายฟิลด์ {} และโดยค่าเริ่มต้น อาร์กิวเมนต์ของเมธอดจะได้รับการประมวลผลตามลำดับ หากละเว้นสตริงข้อกำหนดรูปแบบใน {} สตริงนั้นจะถูกแปลงเป็นสตริงโดย str()

มีประโยชน์สำหรับการแทรกค่าตัวแปรในสตริงและพิมพ์ออกมา

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

ระบุอาร์กิวเมนต์ตำแหน่งสำหรับค่าจำนวนเต็ม

หากระบุค่าจำนวนเต็มใน {} เช่น {0} หรือ {1} ผลลัพธ์จะขึ้นอยู่กับลำดับของอาร์กิวเมนต์ เบอร์เดิมใช้ซ้ำได้ สิ่งนี้มีประโยชน์เมื่อคุณต้องการแทรกค่าเดียวกันในสตริง

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

ระบุอาร์กิวเมนต์ของคีย์เวิร์ดสำหรับชื่อที่กำหนดเอง (สตริง)

คุณยังสามารถระบุชื่อใดๆ ใน {} และป้อนเป็นอาร์กิวเมนต์ของคำหลักได้

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

ระบุรายการหรือพจนานุกรมเป็นอาร์กิวเมนต์

รายการและพจนานุกรมสามารถระบุเป็นอาร์กิวเมนต์ได้

ใช้ [] เพื่อระบุดัชนีของรายการหรือคีย์ของพจนานุกรมในช่องการแทนที่ โปรดทราบว่าเครื่องหมายอัญประกาศ “‘” และ “” ไม่ได้ใช้เพื่อระบุคีย์พจนานุกรม

หากคุณต้องการใช้อาร์กิวเมนต์เดียวกันซ้ำๆ คุณต้องระบุค่าจำนวนเต็มหรือสตริง (ชื่อ) ตามที่อธิบายไว้ข้างต้น

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.

สามารถขยายเป็นอาร์กิวเมนต์ตำแหน่งได้โดยการต่อท้าย * ในรายการและระบุเป็นอาร์กิวเมนต์ หรือเป็นอาร์กิวเมนต์ของคีย์เวิร์ดโดยผนวก ** ลงในพจนานุกรมและระบุเป็นอาร์กิวเมนต์

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.

คำอธิบายของวงเล็บปีกกา {}

หากคุณต้องการเขียนวงเล็บปีกกา {,} ในเมธอด format() ให้ทำซ้ำสองครั้งเช่น {{,}} โปรดทราบว่าแบ็กสแลชไม่สามารถหลีกเลี่ยงได้

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

สตริงที่จัดรูปแบบ

ในทั้งสองกรณี หากต้องการระบุรูปแบบ ให้เขียน “:format string” หลังค่าจำนวนเต็มหรือสตริงชื่อใน {}

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

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

ต่อไปนี้ เราจะอธิบายวิธีระบุรูปแบบโดยใช้สตริงรูปแบบ โค้ดตัวอย่างใช้วิธีสตริง str.format() แต่สตริงรูปแบบเดียวกันสามารถใช้กับฟังก์ชัน format() ที่มีอยู่แล้วภายในได้ ในฟังก์ชัน format() ในตัว สตริงข้อมูลจำเพาะของรูปแบบจะถูกระบุเป็นอาร์กิวเมนต์ที่สอง

จัดชิดซ้าย จัดกึ่งกลาง จัดชิดขวา

คุณสามารถจัดชิดซ้าย ชิดกึ่งกลาง ชิดขวา ฯลฯ ด้านล่าง ระบุจำนวนอักขระทั้งหมดเป็นตัวเลข

• <
• ^
• >

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

คุณยังสามารถระบุอักขระที่จะกรอกได้ หากไม่ระบุ จะเป็นการเว้นวรรค ดังในตัวอย่างด้านบน

คุณสามารถใช้อักขระแบบไบต์คู่ได้ตราบเท่าที่เป็นอักขระตัวเดียว

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

การให้เหตุผลด้วย > ไม่คำนึงถึงเครื่องหมาย (-,+) หากคุณใช้ = เครื่องหมายจะตามด้วยอักขระที่ระบุ หากต้องการระบุ + ให้เขียน + หลัง = รายละเอียดของการประมวลผลสัญญาณจะอธิบายในภายหลัง

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

<, ^ และ > สามารถระบุสตริงได้ แต่ = จะทำให้เกิดข้อผิดพลาด ValueError หากคุณต้องการใช้ = สำหรับสตริง คุณต้องแปลงเป็นตัวเลขโดยใช้ int()

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

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

เช่นเดียวกับตัวเลขทศนิยม จุดทศนิยมจะนับเป็นอักขระด้วย

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

รายการ ทูเพิล ฯลฯ จะทำให้เกิดข้อผิดพลาดหากระบุไว้ตามที่เป็นอยู่ และสามารถแปลงเป็นสตริงได้โดยใช้ 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]*****

สำหรับการจัดชิดซ้าย จัดกึ่งกลาง และจัดชิดขวา ยังมีวิธีสตริงเฉพาะที่เรียกว่า ljust(), center() และ rjust()

0 เติม

หากคุณต้องการปรับจำนวนหลักโดยการเติมศูนย์ ให้ตั้งค่าอักขระที่จะเติมเป็น 0 และปรับให้เหมาะสม

ในกรณีของการเติมเป็นศูนย์ หากละเว้นสัญลักษณ์การจัดตำแหน่ง ระบบจะประมวลผลราวกับว่า = ถูกระบุ

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

#ข้อผิดพลาด!

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

สำหรับการเติมศูนย์ ยังมีเมธอดสตริงเฉพาะที่เรียกว่า zfill()

เครื่องหมาย (บวกหรือลบ)

ตามค่าเริ่มต้น เฉพาะตัวเลขติดลบเท่านั้นที่มีเครื่องหมาย (ลบ-)

เมื่อเพิ่ม + ลงในสตริงข้อกำหนดการจัดรูปแบบ เครื่องหมาย (บวก +) จะแสดงเป็นจำนวนบวกด้วย หากมีการเว้นวรรค จะมีการเว้นวรรคที่จุดเริ่มต้นของจำนวนบวก และจำนวนหลักจะสอดคล้องกับจำนวนลบ

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

โปรดใช้ความระมัดระวังเมื่อเติมด้วยอักขระที่กำหนดเอง เช่น การเติมศูนย์ที่กล่าวถึงข้างต้น ค่าดีฟอลต์ที่ไม่มี + และไม่มีการเว้นวรรค จะเติมตัวเลขบวกด้วยอักขระอีกตัวหนึ่ง

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

หากใช้สัญลักษณ์การจัดตำแหน่ง ควรเขียนสัญลักษณ์การจัดตำแหน่งหลังสัญลักษณ์การจัดตำแหน่ง

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

ตัวคั่นหลัก (จุลภาค, ขีดล่าง)

เพิ่มเครื่องหมายจุลภาคหรือขีดล่าง _ ตัวคั่นทุก ๆ สามหลัก ทำให้อ่านตัวเลขจำนวนมากได้ง่ายขึ้น โปรดทราบว่าขีดล่าง_ เป็นตัวเลือกที่เพิ่มใน Python 3.6 ดังนั้นจึงไม่สามารถใช้ในเวอร์ชันก่อนหน้าได้

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

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

ในกรณีของประเภททศนิยมแบบทศนิยม เฉพาะส่วนจำนวนเต็มเท่านั้นที่คั่นด้วย

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

เลขฐานสอง ฐานแปด และฐานสิบหก

แปลงค่าตัวเลขเป็นเลขฐานสอง ฐานแปด และเลขฐานสิบหกสำหรับเอาต์พุต

• b: ไบนารี่
• o: Octal
• d: ทศนิยม
• x,X: เลขฐานสิบหก (ตัวพิมพ์ใหญ่เป็นตัวพิมพ์ใหญ่)

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

นอกจากนี้ยังสามารถใช้ร่วมกับการเติม 0 และมักใช้เพื่อจัดตำแหน่งตัวเลขในรูปแบบเลขฐานสองและเลขฐานสิบหก

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

โปรดทราบว่าต้องระบุจำนวนอักขระเติมศูนย์โดยคำนึงถึงคำนำหน้า

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

สำหรับเลขฐานสองและเลขฐานสิบหก สามารถแทรกได้เฉพาะตัวคั่นขีดล่าง _ หลัก (Python 3.6 หรือใหม่กว่า) ใช้ตัวคั่น 4 หลัก จำนวนอักขระที่เติมศูนย์จะต้องคำนึงถึงจำนวนขีดล่างด้วย

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

เฉพาะ int ชนิดจำนวนเต็มเท่านั้นที่สามารถแปลงรูปแบบเป็นเลขฐานสองหรือเลขฐานสิบหก คุณสามารถใช้ int() เพื่อแปลงเป็นตัวเลข

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

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

ระบุจำนวนหลักหลังจุดทศนิยม

ในการระบุจำนวนหลักหลังจุดทศนิยม ให้ทำดังนี้: n คือจำนวนหลัก จำนวนหลักหลังจุดทศนิยมจะกลายเป็นจำนวนหลักที่ระบุโดยไม่คำนึงถึงจำนวนหลักในส่วนจำนวนเต็ม
.[n]f

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

ด้านซ้ายของจุดทศนิยมสามารถระบุเป็นแบบชิดซ้าย ชิดกึ่งกลาง ชิดขวา หรือเติมศูนย์ตามที่อธิบายไว้ข้างต้น หากจำนวนหลักของค่าเป้าหมายมากกว่าจำนวนที่ระบุ จะไม่มีอะไรเกิดขึ้น หากจำนวนหลักในค่าเป้าหมายมากกว่าจำนวนหลักที่ระบุ จะไม่มีการดำเนินการใดๆ

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

หากคุณระบุจำนวนหลักน้อยกว่าจำนวนหลักเดิมหลังจุดทศนิยม ค่าจะถูกปัดเศษ โปรดทราบว่านี่ไม่ใช่การปัดเศษเป็นจำนวนเต็มที่ใกล้เคียงที่สุด แต่เป็นจำนวนคู่ เช่น 0.5 ถูกปัดเศษเป็น 0

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

หากคุณต้องการใช้การปัดเศษทั่วไป คุณสามารถใช้เมธอด quantize() ของทศนิยมไลบรารีมาตรฐานได้

สัญกรณ์เลขชี้กำลัง

เมื่อแปลงจำนวนทศนิยมจุดลอยตัวเป็นสตริง str มันจะถูกเขียนโดยอัตโนมัติในรูปแบบเลขชี้กำลังขึ้นอยู่กับจำนวนหลัก ชนิดจำนวนเต็ม int ไม่ได้

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

หากคุณระบุ e หรือ E ในสตริงข้อกำหนดการจัดรูปแบบ คุณสามารถแปลงเป็นสัญลักษณ์เอ็กซ์โพเนนเชียลได้เสมอ อักขระที่ใช้ในเอาต์พุตจะเป็น e และ E ตามลำดับ

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

นอกจากนี้ยังสามารถระบุจำนวนหลักหลังจุดทศนิยมได้อีกด้วย ส่วนจำนวนเต็มจะเป็นตัวเลขหนึ่งหลักเสมอ และจุดทศนิยมจะเป็นจำนวนหลักที่ระบุ

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

โปรดทราบว่าหากคุณระบุชิดซ้าย ชิดกึ่งกลาง ชิดขวา หรือเติมศูนย์ e-, E+ ฯลฯ จะนับเป็นตัวเลข (อักขระ) ด้วย

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

ตัวเลขที่มีนัยสำคัญ (จำนวนหลักสำคัญ)

คุณสามารถระบุจำนวนหลักโดยรวมได้โดยทำดังนี้ ขึ้นอยู่กับผลลัพธ์ สัญกรณ์เลขชี้กำลังจะถูกใช้โดยอัตโนมัติ โปรดทราบว่าศูนย์ที่ต่อท้ายหลังจากจุดทศนิยมจะถูกละเว้น
.[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

หากคุณละเว้น g ผลลัพธ์จะไม่ใช่จำนวนเต็ม g จะเหมือนกันในกรณีส่วนใหญ่ แต่ในกรณีที่ผลลัพธ์เป็นจำนวนเต็มเท่านั้น

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

หากเราประมวลผลค่าเท่ากัน เราจะได้ค่าต่อไปนี้ตามลำดับ

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

ในกรณีของ g หรือถ้าละไว้ ศูนย์ที่ต่อท้ายหลังจากจุดทศนิยมจะถูกละเว้น ดังนั้น หากคุณต้องการให้ผลลัพธ์เป็นตัวเลขที่มีนัยสำคัญเท่ากัน (จำนวนหลักที่มีนัยสำคัญ) ให้ใช้สัญกรณ์เลขชี้กำลังของ e หรือ E ส่วนของจำนวนเต็มจะเป็นตัวเลขหนึ่งหลักเสมอ และจุดทศนิยมคือจำนวนหลักที่ระบุ ดังนั้นหากคุณต้องการแสดงตัวเลขนัยสำคัญ n หลัก ให้ระบุ 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

เปอร์เซ็นต์การแสดงผล

หากระบุ % ในสตริงข้อกำหนดการจัดรูปแบบ ค่าของจำนวนทศนิยมหรือ int จะถูกคูณด้วย 100 และแปลงเป็นสตริงด้วย %

นอกจากนี้ยังสามารถระบุจำนวนหลักหลังจุดทศนิยมได้อีกด้วย ค่าเริ่มต้นคือหกหลักหลังจุดทศนิยม ชิดซ้าย จัดกึ่งกลาง จัดชิดขวา และเติมศูนย์ % จะถูกนับเป็นอักขระด้วย

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%