Python 字符串 format()

format() 方法的语法是

template.format(p0, p1, ..., k0=v0, k1=v1, ...)

这里，p0, p1,... 是位置参数，k0, k1,... 是 关键字参数，分别带有值 v0, v1,...。

并且，template 是格式代码和参数占位符的混合体。

字符串 format() 参数

format() 方法接受任意数量的参数。但，分为两种类型的参数

• 位置参数 - 可通过大括号 {index} 内的参数索引访问的参数 列表
• 关键字参数 - 键值对类型的参数列表，可通过大括号 {key} 内的参数键访问

字符串 format() 的返回值

format() 方法返回格式化后的字符串。

字符串 format() 如何工作？

format() 读取传递给它的参数类型，并根据字符串中定义的格式代码对其进行格式化。

对于位置参数

这里，参数 0 是字符串“Adam”，参数 1 是浮点数 230.2346。

注意： Python 中的参数列表从 0 开始。

字符串 "Hello {0}, your balance is {1:9.3f}" 是模板字符串。它包含用于格式化的格式代码。

大括号只是用于放置参数的占位符。在上面的例子中，{0} 是 "Adam" 的占位符，{1:9.3f} 是 230.2346 的占位符。

由于模板字符串将 format() 参数引用为 {0} 和 {1}，因此这些参数是位置参数。它们也可以不带数字引用，例如 {}，Python 会在内部将其转换为数字。

在内部，

• 由于 "Adam" 是第 0 个参数，它被放置在 {0} 的位置。由于 {0} 不包含任何其他格式代码，因此它不执行任何其他操作。
• 然而，对于第一个参数 230.2346 并非如此。这里，{1:9.3f} 将 230.2346 放置在其位置，并执行操作 9.3f。
• f 指定格式处理的是浮点数。如果未正确指定，将导致错误。
• “.”之前的部分 (9) 指定数字 (230.2346) 可以占用的最小宽度/填充。在这种情况下，230.2346 分配了包括“.”在内的最小 9 个位置。
  如果未指定对齐选项，则它将对齐到剩余空间的右侧。（对于字符串，它将对齐到左侧。）
• “.”之后的部分 (3) 将小数部分 (2346) 截断到给定数字。在这种情况下，2346 在 3 个位置后被截断。
  剩余数字 (46) 四舍五入，输出 235。

对于关键字参数

我们使用了与上面相同的示例来展示关键字参数和位置参数之间的区别。

这里，我们不是仅仅使用参数，而是为参数使用了键值对。即，name="Adam" 和 blc=230.2346。

由于这些参数通过它们的键（如 {name} 和 {blc:9.3f}）引用，因此它们被称为关键字参数或命名参数。

在内部，

• 占位符 {name} 被 name 的值 — “Adam” 替换。因为它不包含任何其他格式代码，所以放置了 “Adam”。
• 对于参数 blc=230.2346，占位符 {blc:9.3f} 被值 230.2346 替换。但在替换之前，像前面的例子一样，它对其执行 9.3f 操作。
  这输出为   230.235。小数部分在 3 位后被截断，剩余数字四舍五入。同样，总宽度被分配为 9，左侧留下两个空格。

使用 format() 进行基本格式化

format() 方法允许使用简单的占位符进行格式化。

示例 1：默认、位置和关键字参数的基本格式化

# default arguments
print("Hello {}, your balance is {}.".format("Adam", 230.2346))

# positional arguments
print("Hello {0}, your balance is {1}.".format("Adam", 230.2346))

# keyword arguments
print("Hello {name}, your balance is {blc}.".format(name="Adam", blc=230.2346))

# mixed arguments
print("Hello {0}, your balance is {blc}.".format("Adam", blc=230.2346))

输出

Hello Adam, your balance is 230.2346.
Hello Adam, your balance is 230.2346.
Hello Adam, your balance is 230.2346.
Hello Adam, your balance is 230.2346.

注意：在混合参数的情况下，关键字参数必须始终跟在位置参数之后。

使用 format() 格式化数字

您可以使用以下格式说明符格式化数字

示例 2：简单数字格式化

# integer arguments
print("The number is:{:d}".format(123))

# float arguments
print("The float number is:{:f}".format(123.4567898))

# octal, binary and hexadecimal format
print("bin: {0:b}, oct: {0:o}, hex: {0:x}".format(12))

输出

The number is: 123
The number is:123.456790
bin: 1100, oct: 14, hex: c

示例 3：整数和浮点数带填充的数字格式化

# integer numbers with minimum width
print("{:5d}".format(12))

# width doesn't work for numbers longer than padding
print("{:2d}".format(1234))

# padding for float numbers
print("{:8.3f}".format(12.2346))

# integer numbers with minimum width filled with zeros
print("{:05d}".format(12))

# padding for float numbers filled with zeros
print("{:08.3f}".format(12.2346))

输出

   12
1234
  12.235
00012
0012.235

这里，

• 在第一个语句中，{:5d} 接受一个整数参数并分配最小宽度为 5。由于未指定对齐方式，因此它向右对齐。
• 在第二个语句中，您可以看到宽度 (2) 小于数字 (1234)，因此它不会在左侧占用任何空间，也不会截断数字。
• 与整数不同，浮点数同时具有整数部分和小数部分。并且，为数字定义的最小宽度是针对这两个部分的整体，包括 "."。
• 在第三个语句中，{:8.3f} 将小数部分截断为 3 位，并对最后 2 位进行四舍五入。并且，数字，现在是 12.235，整体占用 8 的宽度，左侧留下 2 个位置。
• 如果要用零填充剩余位置，在格式说明符前放置零即可。它适用于整数和浮点数：{:05d} 和 {:08.3f}。

示例 4：带符号数字的格式化

# show the + sign
print("{:+f} {:+f}".format(12.23, -12.23))

# show the - sign only
print("{:-f} {:-f}".format(12.23, -12.23))

# show space for + sign
print("{: f} {: f}".format(12.23, -12.23))

输出

+12.230000 -12.230000
12.230000 -12.230000
 12.230000 -12.230000

带对齐的数字格式化

运算符 <, ^, > 和 = 用于在为数字分配一定宽度时进行对齐。

示例 5：带有左对齐、右对齐和居中对齐的数字格式化

# integer numbers with right alignment
print("{:5d}".format(12))

# float numbers with center alignment
print("{:^10.3f}".format(12.2346))

# integer left alignment filled with zeros
print("{:<05d}".format(12))

# float numbers with center alignment
print("{:=8.3f}".format(-12.2346))

输出

   12
  12.235  
12000
- 12.235

注意：对于整数，左对齐并用零填充可能会导致问题，例如第三个示例，它返回 12000，而不是 12。

使用 format() 格式化字符串

与数字一样，字符串也可以用 format() 以类似的方式进行格式化。

示例 6：带填充和对齐的字符串格式化

# string padding with left alignment
print("{:5}".format("cat"))

# string padding with right alignment
print("{:>5}".format("cat"))

# string padding with center alignment
print("{:^5}".format("cat"))

# string padding with center alignment
# and '*' padding character
print("{:*^5}".format("cat"))

输出

cat  
  cat
 cat 
*cat*

示例 7：使用 format() 截断字符串

# truncating strings to 3 letters
print("{:.3}".format("caterpillar"))

# truncating strings to 3 letters
# and padding
print("{:5.3}".format("caterpillar"))

# truncating strings to 3 letters,
# padding and center alignment
print("{:^5.3}".format("caterpillar"))

输出

cat
cat  
 cat 

使用 format() 格式化类和字典成员

Python 内部使用 getattr() 处理“.age”形式的类成员。并且，它使用 __getitem__() 查找“[index]”形式的 字典 成员。

示例 8：使用 format() 格式化类成员

# define Person class
class Person:
    age = 23
    name = "Adam"

# format age
print("{p.name}'s age is: {p.age}".format(p=Person()))

输出

Adam's age is: 23

这里，Person 对象 作为关键字参数 p 传递。

在模板字符串内部，通过 .name 和 .age 分别访问 Person 的 name 和 age。

示例 9：使用 format() 格式化字典成员

# define Person dictionary
person = {'age': 23, 'name': 'Adam'}

# format age
print("{p[name]}'s age is: {p[age]}".format(p=person))

输出

Adam's age is: 23

与类相似，person 字典作为关键字参数 p 传递。

在模板字符串内部，通过 [name] 和 [age] 分别访问 person 的 name 和 age。

在 Python 中使用 str.format(**mapping) 格式化字典有一种更简单的方法。

# define Person dictionary
person = {'age': 23, 'name': 'Adam'}

# format age
print("{name}'s age is: {age}".format(**person))

** 是一个格式参数（最小字段宽度）。

使用 format() 将参数作为格式代码

您还可以将精度、对齐、填充字符等格式代码作为位置参数或关键字参数动态传递。

示例 10：使用 format() 进行动态格式化

# dynamic string format template
string = "{:{fill}{align}{width}}"

# passing format codes as arguments
print(string.format('cat', fill='*', align='^', width=5))

# dynamic float format template
num = "{:{align}{width}.{precision}f}"

# passing format codes as arguments
print(num.format(123.236, align='<', width=8, precision=2))

输出

*cat*
123.24  

这里，

• 在第一个例子中，'cat' 是要格式化的位置参数。同样，fill='*'、align='^' 和 width=5 都是关键字参数。
• 在模板字符串中，这些关键字参数不是作为要打印的普通字符串检索，而是作为实际的格式代码 fill, align 和 width。
  参数替换相应的命名占位符，并且字符串“cat”相应地被格式化。
• 同样，在第二个示例中，123.236 是位置参数，并且对齐方式、宽度和精度作为格式代码传递给模板字符串。

使用 format() 的额外格式化选项

format() 还支持特定于类型的格式化选项，例如日期时间格式和复数格式。

format() 在内部为 datetime 调用 __format__()，而 format() 访问复数的属性。

您可以轻松覆盖任何对象的 __format__() 方法以进行自定义格式化。

示例 11：使用 format() 和覆盖 __format__() 方法进行类型特定格式化

import datetime
# datetime formatting
date = datetime.datetime.now()
print("It's now: {:%Y/%m/%d %H:%M:%S}".format(date))

# complex number formatting
complexNumber = 1+2j
print("Real part: {0.real} and Imaginary part: {0.imag}".format(complexNumber))

# custom __format__() method
class Person:
    def __format__(self, format):
        if(format == 'age'):
            return '23'
        return 'None'

print("Adam's age is: {:age}".format(Person()))

输出

It's now: 2016/12/02 04:16:28
Real part: 1.0 and Imaginary part: 2.0
Adam's age is: 23

这里，

• 对于日期时间
  当前日期时间作为位置参数传递给 format() 方法。
  并且，format() 内部使用 __format__() 方法访问年份、月份、日期、小时、分钟和秒。
• 对于复数
  1+2j 内部被转换为一个 ComplexNumber 对象。
  然后通过访问其属性 real 和 imag 来格式化数字。
• 覆盖 __format__()
  像 datetime 一样，您可以覆盖自己的 __format__() 方法进行自定义格式化，当作为 {:age} 访问时返回年龄。

您还可以使用 format() 的简写符号 !r 和 !s 来使用对象的 __str__() 和 __repr__() 功能。

与 __format__() 类似，您可以轻松覆盖对象的 __str__() 和 __repr_() 方法。

示例 12：使用 format() 的 __str()__ 和 __repr()__ 简写 !r 和 !s

# __str__() and __repr__() shorthand !r and !s
print("Quotes: {0!r}, Without Quotes: {0!s}".format("cat"))

# __str__() and __repr__() implementation for class
class Person:
    def __str__(self):
        return "STR"
    def __repr__(self):
        return "REPR"

print("repr: {p!r}, str: {p!s}".format(p=Person()))

输出

Quotes: 'cat', Without Quotes: cat
repr: REPR, str: STR

另请阅读

• Python format()
• Python 字符串 format_map()