Python 格式化输出详解：占位符、format 与 f-string

示例：

print("%s %s %s"%("hello",3,3.1415))
print("%s %d %d"%("hello",3,3.1415))
print("%s %d %f"%("hello",3,3.1415))
print("%s %f %f"%("hello",3,3.1415))
# hello 3 3.1415
# hello 3 3
# hello 3 3.141500
# hello 3.000000 3.141500

观察上面的示例，不难看出 s 是一个非常通用的类型，所以很多不讲究的场景，Conversion type 用 s 是比较可靠的，但是要注意都是字符串类型的。

precision

对于有小数的场景，设置精度是基本操作。其写法为 .precision（点 + 精度）。不设置的话，浮点数默认精度值是 6。示例如下：

print('%f'%3.14)
print('%.1f'%3.14)
print('%.2f'%3.14)
# 保留多少小数
# 3.140000 # 默认精度是 6
# 3.1
# 3.14

一般来说，% 操作符下占位符了解到这里就够了，下面的是比较少用的生僻内容。而且也不实用，复杂的对齐操作推荐使用 format 或 f 表达式。

key（不常用）

这个选填字段是搭配字典格式的 values 使用的，示例如下：

print("%(name)s %(age)s"%{"name":"zzz","age":20})
print("%(0)s %(1)s"%("zzz",20)) # 错误的❌❌❌❌---key 必须去字典里取值，这样是不行的
# 输出 zzz 20
print("%(0)s %(1)s"%{"0":"zzz","1":20})
# zzz 20

flags（不常用）

该类型可选择的值有：#、0、-、空格、+; 这里只介绍其中几种（更多的建议查阅官方文档：printf-style-string-formatting）：

示例如下：

print("% d %+d"%(123,321))
print("%d %+d"%(-123,-321))
# output
# 123 +321
# -123 -321

width

设置字段的最小占位宽度，默认右对齐，内容不够时使用空格填充。

print("%4d,%6d,%10f"%(12,1234,3.14)) # 用至少 4 个、6 个、10 个字符显示一个整数，默认右对齐，不够了就用空格补在左边
print("%04d,%06d,%010f"%(12,1234,3.14)) # 用 0 来填充不够的位置
print("%-4d,%-6d,%-10f"%(12,1234,3.14)) # 左对齐
print("%0-4d,%0-6d,%0-10f"%(12,1234,3.14)) # 左对齐的时候，0 是没有意义的，因为会覆盖 0
# output
# 12,1234,3.14000000
# 12,001234,003.140000
# 12,1234,3.140000
# 12,1234,3.140000

Python 的字符串格式化里，没有你需要去'使用'的 length type 它是 C 语言 printf 遗留下来的概念，因此在 python 中我们可以直接忽略它。

1. 什么是 length？（C 语言里的东西） 在 C 语言里，这里的 length 是必须要的，因为 C 是弱类型语言。
2. 为什么 python 不需要 length？ Python 的整数没有长度限制，Python 的 int 是任意精度整数。所以：不存在 'int / long / long long' 的区别。也就不需要 length。 Python 的格式化是'高层抽象'，都能正常工作。唯一的'历史遗留支持'。Python 的 % 格式化里：type 才是真正重要的东西，type 决定'怎么解释这个值'，length 在 Python 中不起作用。

3. str.format()

str.format() 是 Python 2.6 开始的新功能，是字符串格式化方法之一，它允许多个替换、值格式化。这个方法允许我们通过位置，格式化连接字符串中的元素。这个方法是一个非常实用且强大的方法。**对于复杂的对齐要求，首选该方法。**其总的语法格式如下：

"... {[field_name][!conversion][:format_spec]} ...".format(arguments)
# 在 {} 里面可以：
# 指定 用哪个值（field_name）--- 必须要的
# 可选地指定 怎么转换这个值（!conversion）---- 可选的转换符，能够转换为字符换，ASCⅡ转义等。
# 可选地指定 怎么格式化显示（:format_spec）
# .format(arguments)，Python 字符串的方法，用来 把占位符 {} 替换成实际值

3.1 arguments

首先介绍下 arguments，其有两种情况：

• 位置参数（Positional Arguments）-也就是按顺序传递给函数的参数。顺序很重要，如果颠倒就会传错

print("{} {}".format("zhang zhang",668))
print("{1} {0} {0} {1}".format("zhang zhang",668))
print('{} {} {} {}'.format("zhang zhang",668)) # 位置参数不够，后便只有两个参数就错了
# zhang zhang 668
# 668 zhang zhang zhang zhang 668
# IndexError: Replacement index 2 out of range for positional args tuple

• 关键字参数（Keyword Arguments）-也就是通过'名字=值'的方式传递参数。顺序不重要

print("{name} {age}".format(name="Li hua", age=24))
print("{name} {age} {age} {name}".format("Li hua",24))
print("{} {}".format(name="Li hua", age=24))
# Li hua 24
# KeyError: 'name'
# IndexError: Replacement index 0 out of range for positional args tuple

其实位置参数和关键字参数可以混用，但是不推荐。混用容易让代码可读性差容易出错（尤其是 {} 没索引时只能用位置参数）

然后介绍下该语法下的占位符格式：

{[field_name][!conversion][:format_spec]}

field_name

选填。字段名，常使用其基础格式 arg_name 来指定使用 arguments 哪一个。对于关键词参数，arg_name 必须为其中的关键字（此时该字段是必填项），比如 "{name} {age}".format(name="Li hua", age=24)。对于位置参数，arg_name 必须为序号（此时该字段可不填，不填则默认第一个为 0，从前往后依次 +1），比如 "{0} {1}".format("Li hua", 24)，"{} {}".format("Li hua", 24)，两者效果一样。

在 .format() 里，field_name 就是占位符 {} 里指定的内容，用来告诉 Python 用哪一个参数去填充这个 {}。对于关键字参数，field_name 就是关键字名；对于位置参数，field_name 就是参数的序号，也可以省略。

该字段完整语法格式为 arg_name(.attribute_name | [element_index])*，是在 arg_name 对应的值为对象、列表或字典时使用，获取其进一步的属性值或者内部值。占位符 {} 不只是可以直接对应参数，还可以'深入访问'参数内部的属性或元素。这里举一个例子：

# 也就是说，arg_name 可以访问更深层次的属性
# 例如，最基础的 field_name 就是参数名字或位置号
print("{0} {1}".format("Li Hua",24)) # 0 → "Li Hua", 1 → 24
# 进一步，还可以访问对象属性。如果参数是对象，可以用点号 .属性名 访问对象属性。
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
p = Person("Li Hua",24)
print("{0.name} {0.age}".format(p)) # Li Hua 24
# 还可以访问列表或者字典元素（[element_index]），如果参数是列表、元组或字典，可以用 [] 访问元素。
mylist = ["a","b","c"]
print("{0[0]} {0[2]}".format(mylist))

conversion

选填。变换，不常用。指定时要用 ! 来开头，指定后会在格式化之前将 arguments 中对应的值进行类型变换。其有三个值可以指定，分别为：

format_spec

选填，格式化具体规范，核心内容，超常用。填写时要用 : 来开头，填写后，会按照其指定的规则来进行格式化。其详细语法为：

在 Python 的 .format() 或 f-string 中，format_spec 用来指定格式化规则。它总是以冒号 : 开头，例如：

[[fill]align][sign][#][0][width][grouping_option][.precision][type]

其中所有字段均为选填，下面依次介绍下（其中加粗的为常用）：

• align: 对齐方式，有以下值：

• sign: 符号展现格式，仅对数字类型有效。有以下值：

• grouping_option: 分组选择，有两个选项可选：

• width: 最小字段宽度，不设置则字段宽度将始终与填充它的数据长度相同（此时对齐方式 align 没有意义）。

width ≠ 固定宽度 至少要占这么多字符，不够就补，够了就不管

• 0: 当没有设置对齐方式 align 时，在宽度字段前面加一个零 ('0') 字符，将等价于填充字符 fill 为 0 且对齐方式 align 为 >。

如果你写了 0，但没有写对齐方式，Python 会自动把它理解成：用 0 填充 + 右对齐

• #: 复杂生僻，基本不使用，不介绍，有需要的可查阅官方文档（见本部分开头）。

# 的作用主要有两类：进制前缀（二进制 / 八进制 / 十六进制）强制浮点显示小数点

• type: 类型，决定'怎么显示这个数据'。有很多值，这里只介绍几个常用的：

• precision: 精度，指定时要用 . 来开头，是一个十进制数，指定用 'f' 和 'f' 格式化的浮点值在小数点后应该显示多少位，即保留几位小数。

precision 只能写在 . 后面 . → 告诉 Python：下面要写'精度' 2 → 小数点后保留 2 位 f → 浮点数

补充说明 1：fill, align 只有设置了 width 才能生效。**fill 和 align 的作用对象是'多出来的宽度空间'，如果没有 width，就没有多余空间，所以它们不会生效。**简单示例：

# 没写的部分 = 使用默认规则，所有规则都是在'width 提供的空间里'起作用
print("{:4}{:6},{:10}".format("1","2",3.14)) # 只有 width，没有 align-默认右对齐，没有 fill-默认填充空格。
print("{:4}{:>6}, {:^10}".format("1","2",3.14)) # 有 width
print("{:_<4}{:0>6}, {:^10}".format("1","2",3.14)) # 有 fill。就按照指定的 fill 填充
# output
# 12,3.14
# 12,3.14 1___000002,3.14

4. f-string

这是从 Python 3.6 开始的一个新功能。f 表达式 (f-string)，又名 formatted string literal，是前缀为'f'或'F'，用花括号 {} 包裹替换字段的字符串文字。其简易格式为：f'{name} is {age} years old'。其中花括号 {} 包裹的是替换字段 replacement_field，相当于上面的占位符，但是不同于占位符是先占住位置最后标明变量进行替换，f 表达式里的替换字段直接在花括号里面进行变量替换。上面的例子就是用 name 变量值替换 {name} 字段，用 age 变量值替换 {age} 字段。f 表达式详细格式为：

f-string 就是：'在字符串里，用 {} 直接写变量或表达式，Python 会自动替换成结果。'**只要字符串前面加了 f 或 F，Python 就会：**把 {} 里面的内容当成 Python 表达式计算结果再变成字符串，放回原来的位置

其中花括号 {} 包裹的是替换字段 replacement_field。那么和 .format() / % 的本质区别是？

f'(literal_char | {{ | }} | replacement_field)*'
F'(literal_char | {{ | }} | replacement_field)*'

{} 在 f-string 里有特殊含义，如果你只是想输出一个字面量（也就是原来写出来的值，些什么就表示本身，不需要再计算。）的 { 或 } 就必须转义。

以上说明 f 表达式中的字符串内容，是由任意个 literal_char、{{、}}、replacement_field 自由组成的。其中 literal_char 是除花括号 {} 外的任意字符或空。f 表达式中要表示花括号 {} 文本，需要进行转义，转义方式为 {{, }}.

4.1 replacement_field

替换字段，是 f 表达式的核心。其格式为：

{f_expression[=][!conversion][:format_spec]}

• 替换字段由花括号包裹

f_expression

必填内容，常规 Python 表达式，一般要被圆括号包围，只有少数注意事项：

1. 不允许使用空表达式。
2. lambda 和赋值表达式 := 必须用显式括号括起来。

在 f-string 的 {} 里：f"{ ... }" 里面只能放'能算出一个值的东西'，不放那些只做动作不产出结果的东西。

1. 数字
2. 变量
3. 计算 这些都'算得出一个结果'都可以放进 {}，但是像 x = 10 不是算一个值，他是给 x 赋值的一个命令。但是 := 叫赋值表达式，它在赋值的同时还返回了这个值 (x := 10) 把 10 放进 x，然后还返回 10；大多数表达式不用括号，但有两类表达式如果不用括号，Python 会'读错'。因为 {} 本身不是一个'完整表达式环境'，而这两种东西语法优先级太特殊，Python 需要你用括号'明确边界'。

• :=（赋值表达式，海象运算符）

赋值表达式，意思是一边'赋值'，一边'返回值'

• lambda

lambda 是 Python 的匿名函数，也就是'临时函数'，不用给它起名字

3. 替换表达式可以包含换行符（例如在三重引号字符串中），但不能包含注释。
4. 每个表达式在格式化字符串文本出现的上下文中按从左到右的顺序进行计算。

其完整格式为：

(conditional_expression |* or_expr)(, conditional_expression |,* or_expr)*[,]| yield_expression 

过于复杂，只展示不介绍，详情可查阅官方文档：https://docs.python.org/3/reference/lexical_analysis.html#grammar-token-f-expression

conversion

选填。转换，指定时要在开头添加 !，指定后对表达式求值的结果在格式化之前进行转换。

在表达式后加 ! + 一个字符，对表达式求值的结果在格式化之前进行转换。

下方示例中，name = "Ståle"

=

选填 (3.8 新版功能)，在表达式后添加等号 =，可以显示表达式文本及其求值后的值 (在调试中很有用)。

在 f-string 的替换字段 {} 内，加上 =，可以打印表达式本身和它的值，主要用于调试，方便看变量名字和对应结果

| conversion | 说明 | 示例 | 输出 | | --- | --- | --- | | s | 对结果调用 str() 方法 | f"His name is {name!s}." | 'His name is Ståle.' | | r | 对结果调用 repr() 方法 | f"His name is {name!r}." | "His name is 'Ståle'." | | a | 对结果调用 ascii() 方法 | f"His name is {name!a}." | "His name is 'St\xe5le'." |

format_spec

格式规范，和本文第二部分 format 中的 format_spec 格式规范是一样的。不过这里的可以嵌套使用 replacement_field 指定其中的值。也就是需要再冒号后写：

line = "The output will have the expression text"
print(f"{line =}") # 变量名 + 等号，表示显示变量的值。自动打印'变量名 = 变量的值'
width = 10
precision = '4f'
precision = 4
value = 12.34567
print(f"result: {value:{10}.{4}}") # width 为 10，precision 精度为 4，就是保留小数点后 4 位
print(f"result: {value:{width}.{precision}f}") #{value:{width}.{precision}}#{变量：宽度。精度}#.精度 表示：小数点后保留几位。默认情况下，Python 会四舍五入到指定的精度
# 在 f-string 里，当你写 {value:宽度。精度} 且 没有指定类型 时，是按浮点数处理，但是实际上更像 %g 保留的是有效数字的总位数，并且：精度指的是 小数点后显示的位数，会自动四舍五入。
# 当没有指定类型（比如没有写 :10.4f 而是写 :10.4）时，Python 的行为更像 %g（默认类型是 g，没有加字母默认是用 %g 来格式化浮点数，%g 的聪明之处是：自动去除末尾多余的 0，尽量用最简洁的方式显示数字。precision = 4 → %g 会先考虑有效数字最多 4 位）：precision = 有效数字的总位数（整数部分 + 小数部分）。
# output
# line ='The output will have the expression text'
# result:12.35
# result:12.3457