Python中的格式转换，格式（填零，指数符号，十六进制，等等）。

要在Python中把一个数字或字符串转换（格式化）为各种格式，可以使用内置函数format()或字符串方法str.format()。

在本节中，我们将解释如何使用以下函数。

内置函数format()
字串方法str.format()

此外，还用示例代码解释了转换为以下格式的格式规范字符串。

左对齐，中间对齐，右对齐
零填充
符号（加号或减号）
数字分隔符（逗号、下划线）。
二进制、八进制和十六进制数字
指定小数点后的位数
有效数字（有效数字的数量）。
指数记号
百分比显示

注意，从Python 3.6开始，字符串方法str.format()中加入了f-字符串(f-strings)，使其更加简明。

Table of Contents

内置函数：format()
字符串方法 str.format()
左对齐，中间对齐，右对齐
0 填补
符号（加号或减号）
数字分隔符（逗号、下划线）。
二进制、八进制和十六进制数字
指定小数点后的位数
指数记号
有效数字（有效数字的数量）。
百分比显示

内置函数：format()

format()是作为一个标准的Python内置函数提供的。

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

大纲如下。

format(value, format_spec)
- 第一个参数：value
  原始值。字符串str，数字int，float，等等。
- 第二个参数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

调用format()方法的字符串str中的{}被称为替换字段，并被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}

格式化的字符串

在这两种情况下，为了指定格式，在{}中的整数值或名称字符串后面写上”:格式字符串”。

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()。

符号（加号或减号）

默认情况下，只有负数才会用符号（minus-）标记。

当+被添加到格式化规范字符串中时，对于正数也会显示一个符号（加+）。如果添加了空格，正数的开头会显示一个空格，位数会与负数对齐。

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

如果是浮点数的浮动类型，只有整数部分被划定。

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

如果你想使用一般的四舍五入，你可以使用标准库十进制的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%