介绍
Python的
str.format() String类的方法允许你做变量替换和值格式。 这使您可以
串连元素结合在一起，通过位置格式化字符串中。 本教程将指导您了解Python中格式化程序的一些常见用法，这有助于使您的代码和程序更加可读和用户友好。
使用格式化程序
格式化程序的工作通过将一个或多个
替换字段或占位符-由一对大括号定义
{} -为一个字符串并调用
str.format()方法。您将传入该方法中要与字符串连接的值。在运行程序时，此值将在您的占位符所在的相同位置传递。 让我们打印一个使用格式器的字符串：
print("Sammy has {} balloons.".format(5))
OutputSammy has 5 balloons.
在上面的例子中，我们使用一对花括号作为占位符构造了一个字符串：
"Sammy has {} balloons."
然后，我们添加了
str.format()方法，并通过了整数值
5至该方法。 这个地方的价值
5成，其中大括号是字符串：
Sammy has 5 balloons.
我们还可以将一个变量赋值为等于具有formatter占位符的字符串的值：
open_string = "Sammy loves {}."
print(open_string.format("open source"))
OutputSammy loves open source.
在第二个例子中，我们串联字符串
"open source"与较大的字符串，替换原来的串花括号。 在Python格式化程序允许您使用大括号作为占位符，你会与通过值
str.format()方法。
使用带有多个占位符的格式化程序
使用格式化程序时，可以使用多对花括号。如果我们想在上面的句子中添加另一个变量替换，我们可以添加第二对大括号，并将第二个值传递给方法：
new_open_string = "Sammy loves {} {}." #2 {} placeholders
print(new_open_string.format("open-source", "software")) #Pass 2 strings into method, separated by a comma
OutputSammy loves open-source software.
要添加另一个替换，我们在原始字符串中添加了第二对大括号。然后，我们通过两个字符串到
str.format()方法，用逗号隔开。 按照相同的语法，我们可以添加额外的替换：
sammy_string = "Sammy loves {} {}, and has {} {}." #4 {} placeholders
print(sammy_string.format("open-source", "software", 5, "balloons")) #Pass 4 strings into method
OutputSammy loves open-source software, and has 5 balloons.
在
sammy_string我们增加4双大括号作为占位符的变量替换。 然后我们通过4个值到
str.format()方法，混合字符串和整数数据类型。每个值都用逗号分隔。
使用位置和关键字参数重新排序格式化程序
当我们离开大括号空的不带任何参数，Python将取代通过传递的值
str.format()方法的顺序。正如我们已经看到的，到目前为止，带有两个空的大括号和两个值的格式化结构看起来像这样：
print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))
OutputSammy the shark has a pet pilot fish!
第一对大括号被取代为的字符串值
"shark" ，而第二对被取代为的字符串值
"pilot fish" 。 该方法中存在的值如下所示：
("shark", "pilot fish")
它们基本上由
元组数据类型中包含的元组和每个单独的值，可以通过它的索引号码，其与索引号0开始调用。 我们可以将这些索引号传递到作为原始字符串中的占位符的花括号中：
print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))
在上面的例子中，输出将是我们得到的没有传递索引号到大括号，因为我们按顺序调用元组中的值：
OutputSammy the shark has a pet pilot fish!
但是，如果我们使用占位符的参数来反转索引号，我们可以反转传递到字符串中的值：
print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))
OutputSammy the pilot fish has a pet shark!
如果在索引位置0和1处具有值的元组中调用索引号2，那么您正在调用超出范围的值。当您调用超出范围的索引号时，您会收到一条错误消息：
print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))
OutputIndexError: tuple index out of range
我们看到的错误消息指的是元组只有索引号为0和1的值，因此将索引号2超出范围。 让我们添加一些额外的占位符和一些更多的值传递给他们，所以我们可以理解我们如何可以重新排序格式化器更好一点。首先，这里是一个有四个占位符的新字符串：
print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))
OutputSammy is a happy, smiling and blue shark!
如果没有参数，被传递到值
str.format()方法连接成字符串中的顺序。 包含在元组中的字符串值对应于以下索引号：
| “快乐” |
“微笑” |
“蓝色” |
“鲨鱼” |
| 0 |
1 |
2 |
3 |
让我们使用值的索引号来更改它们在字符串中出现的顺序：
print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))
OutputSammy is a shark, blue, and smiling happy!
自从我们开始使用索引号3，我们叫最后的价值
"shark"第一位。作为参数包括的其他索引号改变了单词在原始字符串中出现的顺序。 除了位置参数之外，我们还可以引入由其关键字名称调用的关键字参数：
print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))
OutputSammy the shark made a pull request.
此示例显示使用与位置参数一起使用的关键字参数。我们可以在关键字参数填写
pr旁边位置参数，并且可以移动这些参数来更改所得到的字符串：
print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))
OutputSammy the pull request made a shark.
与字符串格式化程序一起使用的位置和关键字参数使我们能够更好地控制通过重新排序操作我们的原始字符串。
指定类型
我们可以在我们的语法的大括号中包含更多的参数。我们将使用格式代码语法
{field_name:conversion} ，这里
field_name指定的参数的索引号
str.format()我们穿过了方法
重排部 ，并
conversion是指数据的转换代码键入您与格式化程序一起使用。 转换类型是指Python使用的单字符类型代码。我们将使用这里的代码是
s字符串，
d显示十进制整数（10基），以及
f我们将用它来显示与小数位浮动。 你可以阅读更多有关
格式规范的迷你语言通过Python 3中的官方文档。 让我们来看看，我们必须通过方法传递一个整数的例子，但是要通过添加来显示它作为一个浮动
f转换类型参数：
print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))
OutputSammy ate 75.000000 percent of a pizza!
我们使用的语法
{field_name:conversion}第一个大括号替代场输出浮动。 第二花括号仅使用第一参数
{field_name} 在上面的示例中，有很多数字显示在小数点后，但您可以限制这些。当你指定
f浮点值，您还可以通过包含一个句号指定值的精度
.其次是小数点后的数字要包括的数量。 如果sammy吃比萨饼75.765367％，但我们并不需要有精度的一个高层次，我们可以通过添加限制小数到3后的地点
.3的转换类型之前
f ：
print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))
OutputSammy ate 75.765 percent of a pizza!
如果我们只想要一个小数位，我们可以重写字符串和方法如下：
print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))
OutputSammy ate 75.8 percent of a pizza!
请注意，修改精度将导致数字四舍五入。 虽然我们显示不带小数位的浮点数字，如果我们试图通过改变浮到一个整数
d转换类型，我们会收到一个错误：
print("Sammy ate {0:.d} percent of a pizza!".format(75.765367))
OutputValueError: Unknown format code 'd' for object of type 'float'
如果你不想显示小数位，你可以这样写你的格式化：
print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))
OutputSammy ate 75 percent of a pizza!
这不会将您的浮点数转换为整数，而是限制小数点后显示的位数。
填充变量替换
由于占位符替换字段，你可以
垫或通过其他参数增加字段大小创建元素周围的空间。当我们需要在视觉上组织大量数据时，这可能很有用。 我们可以添加一个数字来表示字段大小（以字符计）冒号后
:在我们的语法的花括号：
print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))
OutputSammy has 5 red balloons !
在上面的例子中，我们给数
5的4字符字段大小和字符串
balloons （因为它是一个长字符串）16的字符字段大小。 正如我们看到的，默认情况下字符串在字段中左对齐，数字是右对齐的。您可以通过放置对齐的代码只是跟着冒号对此进行修改。
<会在现场左对齐文本，
^将围绕在该领域的文本，
>将右对齐。 让我们左对齐的数字和中心的字符串：
print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))
OutputSammy has 5 red balloons !
现在我们看到，
5是左对齐，前提供在现场空间
red ，和
balloons为中心在其场与空间的左边和右边。 默认情况下，当我们使用formatters更大的字段时，Python将用空格字符填充该字段。我们可以通过指定我们希望它直接在冒号后面的字符来将其修改为不同的字符：
print("{:*^20s}".format("Sammy"))
Output*******Sammy********
我们正在接受字符串传递给
str.format()在0索引位置，因为我们没有另行指定，包括结肠癌，并指定我们会用
*代替空间，以填补该领域。 我们定心字符串以
^ ，指定该字段的大小20个字符，同时也表明我们正在与一个字符串转换类型由包括工作
s 。 我们可以将这些参数与之前使用的其他参数组合：
print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))
OutputSammy ate 76 percent of a pizza!
在大括号内的参数中，我们指定了浮点的索引字段号，并包括冒号，指示字段号的大小，并包括完整止损，写入小数位后的位数，然后指定转换类型的
f 。
使用变量
到目前为止，我们已经通过了整数，浮点数和字符串到
str.format()方法，但我们也可以通过该方法传递变量。这个工作就像任何其他变量。
nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))
OutputSammy has 8 balloons today!
我们可以为原始字符串和传递给方法的内容使用变量：
sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))
OutputSammy has 8 balloons today!
变量可以容易地替换我们的格式化器语法构造的每个部分。这使得在我们接收用户生成的输入并将这些值分配给变量时更容易使用。
使用格式化程序组织数据
当它们被用于以可视化方式组织大量数据时，格式化器可以在它们最好的光中看到。如果我们向用户显示数据库，使用格式化程序来增加字段大小和修改对齐方式可以使您的输出更易读。 让我们来看看一个典型的在Python循环，将打印出
i ，
i*i和
i*i*i在3至12的范围内：
for i in range(3,13):
print(i, i*i, i*i*i)
Output3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728
虽然输出是以某种方式组织的，但是数字溢出到彼此的列中，使得输出的底部更不可读。如果你正在使用一个更大的数据集与许多小和大数字，这可能会带来一个问题。 让我们使用格式化器给这些数字更多的空间：
for i in range(3,13):
print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))
在这里，我们花括号，我们没有为索引号添加字段名称，并开始与结肠，后跟字段大小数量，以及
d转换类型，因为我们与整数工作。在这个例子中，我们适应每个预期输出的大小，为每个预期输出提供2个额外的字符空间，具体取决于最大可能的数字大小，因此我们的输出如下所示：
Output 3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728
我们可以指定一个一致的字段大小数字，以便有偶数列，确保我们容纳更大的数字：
for i in range(3,13):
print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))
Output 3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728
我们也可以通过添加操作列的排列
< ，
^ ，和
>文本对齐，变化
d到
f添加小数，更改字段名称索引号，更加确保我们显示的数据，我们想。
结论
使用格式化器进行变量替换可以有效地连接字符串和组织值和数据。格式化程序表示一种简单但非描述性的方法，用于将变量替换传递到字符串中，并且有助于确保输出可读和用户友好。
