Python中的格式轉換，格式（補零、指數記法、十六進制等）

商業

要在 Python 中將數字或字符串轉換（格式化）為各種格式，請使用內置函數 format() 或字符串方法 str.format()。

在本節中，我們將解釋如何使用以下功能。

  • 內置函數（例如在編程語言中）format()
  • 字符串方法str.format()

此外，用於轉換為以下格式的格式指定字符串通過示例代碼進行說明。

  • 左對齊、中心對齊、右對齊
  • 零填充
  • 符號（加號或減號）
  • 數字分隔符（逗號、下劃線）
  • 二進制、八進制和十六進制數
  • 指定小數點後的位數
  • 有效數字（有效數字的位數）
  • 指數符號
  • 百分比顯示

請注意，從 Python 3.6 開始，字符串方法 str.format() 中添加了 f-strings (f-strings) 以使其更加簡潔。

內置函數：format()

format() 作為標準的 Python 內置函數提供。

概要如下。

  • format(value, format_spec)
    • 第一個論點：value
      原始值。字符串 str、數字 int、浮點數等。
    • 第二個論點format_spec
      格式規範字符串。字符串字符串
    • 返回值：格式化字符串 str

示例如下所示。格式字符串的類型以及如何編寫它們將在後面描述。

在本例中，我們使用數字文字和字符串文字作為第一個參數，但當然您可以使用包含這些值的變量。

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

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

字符串方法 str.format()

字符串 str 類型還有一個 format() 方法。

字符串 str 中調用 format() 方法的 {} 稱為替換字段，並由 format() 方法的參數替換。

格式規範字符串應寫入替換字段 {} 中，後跟“:”。

返回值是一個格式化的字符串 str。

上面描述的內置函數format()的等效過程如下。

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

數字分隔符（逗號、下劃線）

每三位數添加一個逗號或下劃線 _ 分隔符。這使得大數字更容易閱讀。注意 underscore_ 是 Python 3.6 中新增的一個選項，因此不能在早期版本中使用。

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

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

在浮點數 float 類型的情況下，只有整數部分被分隔。

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

二進制、八進制和十六進制數

將數值轉換為二進制、八進制和十六進制數以供輸出。

  • b: 二進制
  • o: 八進制
  • 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-fill 結合使用，通常用於對齊二進制和十六進製表示法中的數字。

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

如果要使用一般四捨五入，可以使用標準庫decimal的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

百分比顯示

如果在格式規範字符串中指定了 %，則數值 float 或 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%
Copied title and URL