【Python学习笔记】字符串格式化

1. printf 风格

这种格式化语法 和 传统的C语言printf函数 一样 。

salary = input('请输入薪资：')

# 计算出缴税额，存入变量tax
tax = int(salary) *25/100  

# 计算出税后工资，存入变量aftertax
aftertax = int(salary) *75/100 

print('税前薪资：%s元，缴税：%s元，税后薪资：%s元' %(salary,tax,aftertax))
1
2
3
4
5
6
7
8
9

其中 %s 就是模板中的占位符，表示这个位置先占着，待会儿要有数据填入到这里。

然后再提供一个元组，里面依次存放需要填入到 %s 位置 的数据。

这里是使用变量 (salary,tax,aftertax) 。

%s 是一种格式化符号， Python 解释器 看到 %s ， 就会调用内置函数 str()，并将对应的格式化对象作为参数传入 ， 返回的结果字符串填入对应占位符。简单说 %s 位置填入的结果，就是调用str函数的返回值。

str()内置函数的参数 可以是任何类型的对象，比如：字符串、 整数、 浮点数、列表、元组 等等，都可以。

所以 %s 为占位符， 对应的格式化对象， 不仅仅是字符串，还可以是整数、 浮点数、列表、元组 等等。

• 格式化字符串里面占位符的个数 必须 和 后面对应的格式化对象个数相同

如果占位符是1个，后面的元组里面的格式化对象就应该是1个。像这样

'税前薪资：%s 元' % (salary,)
1

还记得，我们说过， 元组里面只有1个元素，后面别忘了加个逗号。

像这种只有一个格式化对象的情况下，可以直接就用格式化对象，不需要放到元组里面，像这样

'税前薪资：%s 元' % salary
1

指定宽度和对齐

如果我们需要将下面这样的3个字符串进行格式化

print('税前薪资：%s 元' % 100000)
print('税前薪资：%s 元' % 10000)
print('税前薪资：%s 元' % 1000)
print('---------------------------------')
print('税前薪资：%10s 元' % 100000)
print('税前薪资：%10s 元' % 10000)
print('税前薪资：%10s 元' % 1000)
print('---------------------------------')
print('税前薪资：%-10s 元' % 100000)
print('税前薪资：%-10s 元' % 10000)
print('税前薪资：%-10s 元' % 1000)
1
2
3
4
5
6
7
8
9
10
11

得到的结果如下

$ python main.py
税前薪资：100000 元
税前薪资：10000 元
税前薪资：1000 元
---------------------------------
税前薪资：    100000 元
税前薪资：     10000 元
税前薪资：      1000 元
---------------------------------
税前薪资：100000     元
税前薪资：10000      元
税前薪资：1000       元
1
2
3
4
5
6
7
8
9
10
11
12

%10s 中的 10 就是指定了格式化结果至少10个字符。

如果希望是左边对齐，而不是右边对齐，就可以加一个 -

%d 和 %f

占位符除了 %s ，还有其它的一些。

常见的是 %d 和 %f 。

%d 用在格式化对象是整数的情况 ，比如

'税前薪资：%d 元' % 10000
1

%f 用在 格式化对象 是 浮点数的情况，比如

'税前薪资：%f 元' % 10000.32
1

%s 也可以用来格式化 整数和浮点数，但是有些情况下， %d %f 有特别的用处。

比如，打印数字的时候，我们指定宽度，而且希望不足宽度 补零 ，而不是补空格，就可以这样

'税前薪资：%010d 元' % 100000
'税前薪资：%010d 元' % 10000
'税前薪资：%010d 元' % 1000
1
2
3

可以得到如下结果

税前薪资：0000100000 元
税前薪资：0000010000 元
税前薪资：0000001000 元
1
2
3

对于小数的格式化，通常使用 %f，如下

'税前薪资：%010f 元' % 1000.4522
'税前薪资：%010f 元' % 1008.6621
'税前薪资：%010f 元' % 1009.3351
1
2
3

可以得到如下结果

税前薪资：1000.452200 元
税前薪资：1008.662100 元
税前薪资：1009.335100 元
1
2
3

如果我们想保留小数点后面2位数字，就可以加上 .2 像这样

'税前薪资：%010.2f 元' % 1000.4522
'税前薪资：%010.2f 元' % 1008.6621
'税前薪资：%010.2f 元' % 1009.3351
1
2
3

可以得到如下结果

税前薪资：0001000.45 元
税前薪资：0001008.66 元
税前薪资：0001009.34 元
1
2
3

printf格式化官网描述

2. f-string 格式化

f-string 格式化就是在字符串模板前面加上f，然后占位符使用{} ,里面直接放入对应的数据对象。Python解释器是3.6 以后的版本才支持。

如下所示

f'税前薪资是：{salary}元， 缴税：{tax}元， 税后薪资是：{aftertax}元'
1

完整的代码如下

完整的代码如下

salary = input('请输入薪资：')

# 计算出缴税额，存入变量tax
tax = int(salary) * 25/100

# 计算出税后工资，存入变量aftertax
aftertax = int(salary) * 75/100

print(f'税前薪资是：{salary}元， 缴税：{tax}元， 税后薪资是：{aftertax}元')
1
2
3
4
5
6
7
8
9

运行一下，可以发现输出结果一样。这种方式更加的直观明了。

指定宽度

同样，为了输出对齐，我们需要指定填入的字符串的宽度。

方法是，在括号里面的变量后面加上 :宽度值

比如

salary = 10000
print(f'{salary:10}') 
1
2

f'{salary:10}' 就指定了 宽度为10 个字符， 如果填入的字符串不足10个字符，就在前面加上空格

比如上面的输出结果就是

>>> salary = 10000
>>> print(f'{salary:10}')
     10000
1
2
3

完整的一个示例程序如下

salary = 8000
tax = int(salary) *25/100  
aftertax = int(salary) *75/100 
print(f'税前薪资是：{salary:8}元， 缴税：{tax:8}元， 税后薪资是：{aftertax:8}元')
1
2
3
4

运行一下结果如下：

税前薪资是：    8000元， 缴税：  2000.0元， 税后薪资是：  6000.0元
1

这样，整体就显得很清爽。

左右对齐

上面的输出结果是不足在前面补空格，对于数字对象来说，缺省为 右边对齐，而字符串缺省为 左边对齐 。

比如

下面这个表达式
f"|{'abc':10}|{300:10}|"
结果如下
'|abc       |       300|'
1
2
3
4

指定左右对齐，可以在括号里使用 < > 符号

箭头朝左就是左对齐，箭头朝右就是右对齐

比如

下面这个表达式
f"|{'abc':>10}|{300:<10}|"
结果如下
'|       abc|300       |'
1
2
3
4

上面的薪资计算代码中，要打印的数字左对齐，就可以这样写

def calcTax(salary):
    tax = int(salary) *25/100  
    aftertax = int(salary) *75/100 
    print(f'税前薪资是：{salary:<8}元， 缴税：{tax:<8}元， 税后薪资是：{aftertax:<8}元')
    
calcTax(8320)
calcTax(15023)
calcTax(100030)
1
2
3
4
5
6
7
8

运行结果如下：

税前薪资是：8320    元， 缴税：2080.0  元， 税后薪资是：6240.0  元
税前薪资是：15023   元， 缴税：3755.75 元， 税后薪资是：11267.25元
税前薪资是：100030  元， 缴税：25007.5 元， 税后薪资是：75022.5 元
1
2
3

小数点后位数

如果我们想指定小数点后保留几位，可以像这样 {salary:<8.1f}

后面的.1f就表示小数点后面保留1位

def calcTax(salary):
    tax = int(salary) *25/100  
    aftertax = int(salary) *75/100 
    print(f'税前薪资是：{salary:8.1f}元， 缴税：{tax:8.1f}元， 税后薪资是：{aftertax:8.1f}元')

calcTax(8320)
calcTax(15023)
calcTax(100030)
1
2
3
4
5
6
7
8

运行结果如下：

税前薪资是：  8320.0元， 缴税：  2080.0元， 税后薪资是：  6240.0元
税前薪资是： 15023.0元， 缴税：  3755.8元， 税后薪资是： 11267.2元
税前薪资是：100030.0元， 缴税： 25007.5元， 税后薪资是： 75022.5元
1
2
3

不足补零

如果我们想在不足指定宽度的时候不是补空格，而是补数字0，可以像这样 {salary:08}

def calcTax(salary):
    tax = int(salary) *25/100  
    aftertax = int(salary) *75/100 
    print(f'税前薪资是：{salary:08}元， 缴税：{tax:08.1f}元， 税后薪资是：{aftertax:08.1f}元')

calcTax(8320)
calcTax(15023)
calcTax(100030)
1
2
3
4
5
6
7
8

运行结果如下：

税前薪资是：00008320元， 缴税：002080.0元， 税后薪资是：006240.0元
税前薪资是：00015023元， 缴税：003755.8元， 税后薪资是：011267.2元
税前薪资是：00100030元， 缴税：025007.5元， 税后薪资是：075022.5元
1
2
3

上面的例子是对 数字 的不足补零，如果要对 字符串 不足补零，就应该 使用符号 < 或者 > 同时指定左右对齐方式。

>>> var = '34324'
>>> f'{var:08}'
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: '=' alignment not allowed in string format specifier
>>> f'{var:<08}'
'34324000'
>>> f'{var:>08}'
'00034324'
1
2
3
4
5
6
7
8
9

16进制格式化数字

# 用 x 表示格式化为16进制，并采用小写格式
f'数字65535的16进制表示为：{65535:x}'  

# 用 X 表示格式化为16进制，并采用大写格式
f'数字65535的16进制表示为：{65535:X}'
1
2
3
4
5

字符串内容里有花括号

采用 f-string 方式格式化的 字符串内容本身就有 { 或者 } 符号，一定要 双写 进行转义，否则会被当成是 格式化占位符。

比如 我们要格式化的字符串为 文章中 { 符号 出现了 xx 次

times1 = 1000
times2 = 2000

print(f'文章中 {{ 符号 出现了 {times1} 次')
print(f'文章中 }} 符号 出现了 {times2} 次')
1
2
3
4
5