【Python】格式化字符串_python字符串格式化

1、简述

在Python中，我们通常使用字符串的格式化方法来将变量值插入到字符串中，以便于我们后续的使用，我们通常将字符串格式化用来输出，Python也提供了多种格式化输出的方式，其中包括旧式字符串格式化（%操作符）、str.format()方法、以及较新的f-string（格式化字符串字面值）。

2、旧式字符串格式化

旧式字符串格式化使用%操作符将变量值插入到字符串中。使用该方法，我们需要在字符串中使用占位符%，并在字符串的末尾使用%操作符来指定变量值。占位符可以是%s（字符串）、%d（整数）、%f（浮点数）等

name = "Tom"
age = 18
print("%s的年龄是%d" %(name, age))
1
2
3
'
运行
运行

输出：
Tom的年龄是18
1
2

2.1、字符串占位符

print("%s" % "Hello World")
1
'
运行
运行

输出：
Hello World
1
2

2.2、整数占位符

print("%d" % 66)
1
'
运行
运行

输出：
66
1
2

2.3、浮点数占位符

print("默认精度：%f" % 6.6)
print("指定精度：%.2f" % 6.6)
1
2
'
运行
运行

输出：
默认精度：6.600000
指定精度：6.60
1
2
3

2.4、对齐方式和宽度

在这里将对齐方式和宽度放在一起讲方便我们更直观的观察与理解。我们可以使用%Ns进行右对齐，使用%-Ns进行左对齐，其中N是指定的宽度，如果字符串长度不足宽度N，则会用空格填充

# 左对齐：`%-Ns`
print("左对齐：|%-20s|" % "Hello World")

# 右对齐：`%Ns
print("右对齐：|%20s|" % "Hello World")
1
2
3
4
5
'
运行
运行

输出：
左对齐：|Hello World         |
右对齐：|         Hello World|
1
2
3

2.5、正数带符号

我们在正数输出正数的时候是不会输出符号+的，但当我们使用%+d则可以对正数显示`+·号

# 正数带符号
print("正数带符号：%+d" % 66)
print("负数（带+）：%+d" % -66)
print("正数不带符号：%d" % 66)
print("负数（不带+）：%d" % -66)
1
2
3
4
5
'
运行
运行

输出：
正数带符号：+66
负数（带+）：-66
正数不带符号：66
负数（不带+）：-66
1
2
3
4
5

2.6、零填充和宽度

我们可以使用%0Nd，这个的含义是当整数的长度不足N的时候用0填充，使得整数达到指定宽度

print("零填充和宽度：%05d" % 66)
print("零填充和宽度：%05d" % -66)
1
2
'
运行
运行

输出：
零填充和宽度：00066
零填充和宽度：-0066
1
2
3

2.7、小结

尽管旧式字符串格式化依然有效，但随着Python版本的迭代，更推荐使用f-string或str.format()来进行字符串格式化，因为他们更简洁易读，并且支持更多功能

3、str.format()格式化字符串

str.format()是一种更强大、更灵活的字符串格式化方式，相较于旧式字符串格式化（%操作符），更推荐在新代码中使用，因为它提供了更多的功能和更易读的语法。

3.1、基本用法

str.format()方法通过使用花括号{}来表示占位符，然后通过调用format()方法，将需要插入的值传递进去。

name = "Tom"
age = 18
print("{}的年龄是{}".format(name, age))
1
2
3
'
运行
运行

3.2、位置参数

需要指出的是，上面基本用法的示例代码也是使用了位置参数，当我们没有在花括号{}里面指定参数的位置时，默认的就是第1个花括号对应format里面的第一个参数，第2个花括号对应format里面的第二个参数

对于位置参数，我们可以在format()方法中使用位置参数，通过指定参数的位置来确定插入值的顺序，需要指出的是，这里的指定是从0开始编号的

name = "Tom"
age = 18
print("{1}的年龄是{0}".format(age, name))
print("{}的年龄是{}".format(age, name))
1
2
3
4
'
运行
运行

输出：
Tom的年龄是18
18的年龄是Tom
1
2
3

• 注意：当我们要指定确定的位置时，则，每个花括号{}里面都要指定位置，否则就是按照默认的方式进行插入对应的值

3.3、关键字参数

通过指定参数的名称来确定插入值的顺序

name = "Tom"
age = 18
print("{n}的年龄是{a}".format(a=age, n=name))
1
2
3
'
运行
运行

输出：
Tom的年龄是18
1
2

3.4、索引和属性

3.4.1、索引

在str.format()中，可以使用索引来按位置引用参数。索引是从0开始的整数，用花括号{}包围，放在format()方法中的占位符中。这样，可以根据传入参数的位置来确定对应的值。

3.4.2、属性

当传入的参数是一个对象（比如字典或类的实例），可以使用属性来引用对象的属性。在str.format()中，可以使用点号.来访问对象的属性，格式为{对象属性名}。

person1 = {"name": "Tom", "age": 18}
person2 = {"name":"Bob", "age":20}
print("我的名字是{0[name]}，我的朋友是{1[name]}，我{0[age]}岁了，他{1[age]}岁了".format(person1,person2))
1
2
3
'
运行
运行

输出：
我的名字是Tom，我的朋友是Bob，我18岁了，他20岁了
1
2

在上面的例子中，0[name]和0[age]分别对应person1的name属性和age属性，1[name]和1[age]分别对应person2的name属性和age属性

3.5、格式和规范

我们可以在占位符中使用冒号:来指定格式规范，比如小数位数，对齐方式

3.5.1、对齐方式和宽度

可以通过冒号:后面添加<（左对齐）、>（右对齐）和^（居中对齐）来指定对齐方式，并通过添加宽度值来设置宽度。

print("默认对齐（宽度20）：|{:20}|".format("Hello World"))
print("靠左对齐（宽度20）：|{:<20}|".format("Hello World"))
print("居中对齐（宽度20）：|{:^20}|".format("Hello World"))
print("靠右对齐（宽度20）：|{:>20}|".format("Hello World"))
1
2
3
4
'
运行
运行

输出：
默认对齐（宽度20）：|Hello World         |
靠左对齐（宽度20）：|Hello World         |
居中对齐（宽度20）：|    Hello World     |
靠右对齐（宽度20）：|         Hello World|
1
2
3
4
5

3.5.2、指定填充字符

在旧式字符串的格式化时，我们对%Ns进行格式化时，当不足N位时会默认使用空格进行填充，但我们不方便修改，在str.format()和f-string中，我们可以指定补充字符

print("{1:@<5s}的年龄是{0:+5d},这次考了{2:.2f}分".format(18, "Tom", 98))
1
'
运行
运行

输出：
Tom@@的年龄是  +18,这次考了98.00分
1
2

在上面，我们指定使用@字符来填充空位

3.6、小结

总体而言，str.format()方法是一种更灵活、更强大的字符串格式化方式。它允许使用位置参数、关键字参数、格式规范，以及对齐方式和宽度等选项，使得字符串格式化更加直观、清晰，并且支持更多的定制化需求。如果使用的是Python 3.6及以上版本，推荐优先使用str.format()方法或者f-string来进行字符串格式化。

而对于上面的格式与规范，对于占位符里面的，我们可以归纳为
{[索引][属性]:[填充符][对齐方式][宽度].[精度]}
需要注意的是，上面的只是一个大概的顺序，并不是在%s、%d和%f里面都是这样，有的里面并没有精度，有的不能指定填充符等，需要合理运用，或则自己进行总结。

4、f-string格式化字符串

f-string是Python 3.6及以上版本引入的一种方便、直观、灵活的方法。f-string是格式化字符串字面值的缩写，它以f或F开头，并允许在字符串中直接嵌入表达式和变量，而无需使用占位符。在f-string中，使用花括号{}来包围表达式或变量，并直接在花括号内部写入Python代码。

4.1、基本用法

在f-string中，可以直接嵌入变量和表达式，也可以访问对象的属性和方法

print("================基本用法================")
name = "Tom"
age = 18
print(f"{name}的年龄是{age}")

print("================表达式================")
num1 = 18
num2 = 23
print(f"{num1} * {num2} = {num1 * num2}")

print("================对象属性和方法================")
person = {"name":"Bod", "age":20}
print(f"{person['name']}的年龄为{person['age']}")
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

输出：
================基本用法================
Tom的年龄是18
================表达式================
18 * 23 = 414
================对象属性和方法================
Bod的年龄为20
1
2
3
4
5
6
7

4.2、格式规范

和str.format()一样，也可以在f-string中使用冒号:来指定格式规范，比如小数位数、对齐方式等。

print(f"默认对齐（宽度为20）：|{'Hello World':20}|")
print(f"靠左对齐（宽度为20）：|{'Hello World':<20}|")
print(f"居中对齐（宽度为20）：|{'Hello World':^20}|")
print(f"靠右对齐（宽度为20）：|{'Hello World':>20}|")
1
2
3
4
'
运行
运行

输出：
默认对齐（宽度为20）：|Hello World         |
靠左对齐（宽度为20）：|Hello World         |
居中对齐（宽度为20）：|    Hello World     |
靠右对齐（宽度为20）：|         Hello World|
1
2
3
4
5

4.3、小结

就我个人而言，我还是更喜欢使用f-string的方式的，不过这个全看个人习惯吧

5、例题

可以做做一个例题，链接在这

参考代码

width, precision = map(int, input().strip().split())
print(f"{18.16054:>{width}.{precision}f} {17.676767:>{width}.{precision}f}")
1
2