本文详细介绍了Python中的字符串格式化方法，包括%-formatting、str.format()和f-string。通过实例展示了各种格式化技巧，如对齐、填充、宽度、精度等设置，以及不同类型的数据格式化。此外，还比较了%-formatting和str.format()的差异。
相关链接
- 目录
- Mac M1 Python环境搭建
- Python3.x入门 P1 【基础】基础语法、注释、标识符、变量、数据类型、键盘录入input
- Python3.x入门 P2 【基础】运算符
- Python3.x入门 P3 【基础】流程语句【循环结构】
- Python3.x入门 P4 【基础】序列 - 公共方法总结
- Python3.x入门 P5 【基础】可变序列（列表list、字典dict、集合set）
- Python3.x入门 P6 【基础】不可变序列（元组tuple、字符串str）
- Python3.x入门 P7 【字符串格式化】四种方式（手动、%-formatting、str.format()、f-String）
- Python3.x入门 P8 【函数】
- Python3.x入门 P9 【异常Error】常见Error、异常捕获try catch
一、字符串格式化
- 目的：更漂亮的输出格式
- 版本：3.8.9（不同版本测试结果可能会有出入）
1.1 格式化初体验
1) 手动 Manual String Formatting。此方式能实现的效果有限，一般只能做简单的格式处理。此方式在后文中不做详细介绍。
通过如下方法进行对齐操作
center(): 居中对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
ljust(): 左对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
rjust(): 右对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
zfill(): 右对齐，左边用0填充，第1个参数指定宽度，如果设置宽度小于实际宽度则返回原字符串
案例
# 对齐格式输出
for x in range(1, 11):
print(str(x).rjust(2), str(x * x).rjust(3), end=' ')
# Note use of 'end' on previous line
print(str(x * x * x).rjust(4))
'''
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
'''
2) %-formatting Old string formatting。此方式从一开始就在Python语言中。
其效果类似于在 C 语言中使用 %format % values%sprintf()。一些历史遗留bug导致可能会无法正确显示元组(tuples)和字典(dictionaries)，官方文档中建议使用str.format() 。
案例
# 1.顺序定位
print('%s has %03d quote types.' % ('Python', 2)) # Python has 002 quote types.
# 2.关键字参数
print('%(language)s has %(number)03d quote types.' %
{'language': "Python", "number": 2}) # Python has 002 quote types.
3) str.format() The String format() method。此方式从Python2.6开始引入。可以在Python官方更新日志中的PEP3101找到str.format()的详细用法。str.format() 是对 %-formatting 的改进。它使用正常的函数调用语法，并且可以通过正在转换为字符串的对象上的 format() 方法进行扩展。
案例
"""
@author GroupiesM
@date 2022/6/28 16:27
@introduction
"""
# 1.顺序定位
print(1, 'We are the {} who say "{}!"'.format('knights', 'Ni')) # We are the knights who say "Ni!"
# 2.数字定位
print(2, '{0} and {1}'.format('spam', 'eggs')) # spam and eggs
print(2, '{1} and {0}'.format('spam', 'eggs')) # eggs and spam
# 3.关键字参数
print(3, 'This {food} is {adjective}.'.format(
food='spam', adjective='absolutely horrible')) # This spam is absolutely horrible.
# 4.数字定位 + 关键字参数
print(4, 'The story of {0}, {1}, and {other}.'.format(
'Bill', 'Manfred', other='Georg')) # The story of Bill, Manfred, and Georg.
# 5.拆分字典
table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
print(5, 'Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; ''Dcab: {0[Dcab]:d}'
.format(table)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 6.解压字典
table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
print(6, 'Jack: {Jack}; Sjoerd: {Sjoerd}; Dcab: {Dcab}'
.format(**table)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 7.解压字典（指定类型）
table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
print(7, 'Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'
.format(**table)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 8.拆分列表
lst = [4127, 4098, 8637678]
print(8, 'Jack: {0[1]:d}; Sjoerd: {0[0]:d}; ''Dcab: {0[2]:d}'
.format(lst)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 9.解压列表（默认排序）
lst = [4127, 4098, 8637678]
print(9, 'Jack: {}; Sjoerd: {}; ''Dcab: {}'
.format(*lst)) # Jack: 4127; Sjoerd: 4098; Dcab: 8637678
# 10.解压列表（指定排序）
lst = [4127, 4098, 8637678]
print(10, 'Jack: {1}; Sjoerd: {0}; ''Dcab: {2}'
.format(*lst)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 11.解压集合（默认排序）
st = {4127, 4098, 8637678}
print(11, 'Jack: {}; Sjoerd: {}; ''Dcab: {}'
.format(*st)) # Jack: 4127; Sjoerd: 4098; Dcab: 8637678
# 12.解压集合（指定排序）
st = {4127, 4098, 8637678}
print(12, 'Jack: {1}; Sjoerd: {0}; ''Dcab: {2}'
.format(*st)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 13.拆分元组
tup = (4127, 4098, 8637678)
print(13, 'Jack: {0[1]:d}; Sjoerd: {0[0]:d}; ''Dcab: {0[2]:d}'
.format(tup)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 14.解压元组（默认排序）
tup = (4127, 4098, 8637678)
print(14, 'Jack: {}; Sjoerd: {}; ''Dcab: {}'
.format(*tup)) # Jack: 4127; Sjoerd: 4098; Dcab: 8637678
# 15.解压元组（指定排序）
tup = (4127, 4098, 8637678)
print(14, 'Jack: {1}; Sjoerd: {0}; ''Dcab: {2}'
.format(*tup)) # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
# 16.遍历格式化
for x in range(1, 11):
print(15, '{0:2d} {1:3d} {2:4d}'.format(x, x * x, x * x * x))
'''
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
'''
4) f-String Formatted String Literalsf-String是指在字符串中直接使用Python变量，需要在字符串前加f或F标注。这种方式对数据处理更加灵活，甚至可以将变量代入函数后，输出结果。
案例
# 1. 3.8新特性
name, score = '张三', 45.6
print(f'name={name}, score={score:.3f}') # Python3.6 name=张三, score=45.600
print(f'{name=}, {score=:.3f}') # Python3.8 name='张三', score=45.600
# 2.pi保留小数点后三位
import math
print(f'The value of pi is approximately {math.pi:.3f}.') # The value of pi is approximately 3.142.
# 3.列对齐
table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
for name, phone in table.items():
print(f'{name:10} ==> {phone:10d}')
'''
Sjoerd ==> 4127
Jack ==> 4098
Dcab ==> 7678
'''
# 4.格式转换 【ascii()=!a】、【str()=!s】、【repr=!r】
animals = 'eels'
print(f'My hovercraft is full of {animals}.') # My hovercraft is full of eels.
print(f'My hovercraft is full of {animals!r}.') # My hovercraft is full of 'eels'.
# 5.嵌套计算 name='张三', (height+2)=182.40
name, age, height = '张三', 20, 180.4
print(f'{name=}, {(height+2)=:.2f}')
# 6.嵌套函数 name='张三', sum(height,3)=183.40
name, age, height = '张三', 20, 180.4
def sum(a, b):
return a + b
print(f'{name=}, {sum(height,3)=:.2f}')
1.2 Python官方文档
百度搜不清楚的资料，或者不明确的，一切以官方文档+本地测试结果为准：
The Python Tutorial-Python教程
Fancier Output Formatting-更漂亮的输出格式
1.3 格式规范迷你语言
关于 Format Specification Mini-Language，其格式在str.format()以及f-String是类似通用的，但也有一些细微差别。这部分摘自官方文档，仅做翻译。
语法树 format_spec ::= [[fill]align][sign][#][0][width][grouping_option][.precision][type]
填充符 fill ::= <any character>
对齐方式 align ::= "<" | ">" | "=" | "^"
符号选项 sign ::= "+" | "-" | " "
总长度 width ::= digit+
分组选项 grouping_option ::= "_" | ","
有效数字 precision ::= digit+
数据类型 type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
align-对齐方式
| 选项 | 含义 |
|---|---|
| ‘<’ | 强制字段在可用空间内左对齐(这是大多数对象的默认设置)。 |
| ‘>’ | 强制字段在可用空间内右对齐（这是数字的默认值）。 |
| ‘=’ | 强制将填充放在符号（如果有）之后，但放在数字之前。这用于打印格式为“+000000120”的字段。 此对齐选项仅对数值类型有效。当“0”紧跟在字段宽度之前时，它将成为默认值。 |
| ‘^’ | 强制字段在可用空间内居中。 |
sign-符号选项
符号选项仅对数字类型有效，并且可以是以下选项之一：
| 选项 | 含义 |
|---|---|
| ‘+’ | 表示正数前添加’+‘，负数前添加’-'。 |
| ‘-’ | 表示正数不添加，负数前添加’-'（默认选项）。 |
| 不填 | 表示正数前添加’ ‘，负数前添加’-'。 |
type-数据类型
1.字符型
| 选项 | 含义 | 函数 |
|---|---|---|
| ‘s’ | 字符串格式。（默认选项） | str() |
| 不填 | 与’s’相同。 |
2.整数型（%-formatting不支持参数b，%-formatting不支持参数不填)
| 选项 | 含义 | 函数 |
|---|---|---|
| ‘b’ | 二进制格式。输出以 2 为基数的数字。 | bin() |
| ‘c’ | 字符。在打印之前将整数转换为相应的 unicode 字符。 | chr() |
| ‘d’ | 十进制整数。输出以 10 为基数的数字。 | |
| ‘o’ | 八进制格式。输出以 8 为基数的数字。 | oct() |
| ‘x’ | 十六进制格式。输出以 16 为基数的数字，对 9 以上的数字使用小写字母。 | hex() |
| ‘X’ | 十六进制格式。输出以 16 为基数的数字，对 9 以上的数字使用大写字母。 | hex() |
| ‘n’ | 与’d’相同。 | |
| 不填 | 与’d’相同。 |
3.浮点型
| 选项 | 含义 | 函数 |
|---|---|---|
| ‘e’ | 科学记数法。对于给定的精度，用科学记数法格式化数字，用字母“e”将系数与指数分开。 该系数在小数点之前有一位数字，在小数点之后有一位数字，总共有一位有效数字。 在没有给出精度的情况下，使用小数点后的数字精度作为浮点数，并显示十进制的所有系数数字。 如果小数点后面没有数字，则除非使用该选项，否则也会删除小数点。 | |
| ‘E’ | 与’e’相同，但用字母"E"将系数与指数分开。 | |
| ‘f’ | 定点表示法。将整数、浮点数转换成浮点数表示。按照指定percision保留小数，如果未指定默认保留6位小数。 | |
| ‘F’ | 与’f’相同。区别是’f’ ：nan(无穷小)，inf(无穷大)，‘F’ ：NAN(无穷小)，INF(无穷大)。 | |
| ‘g’ | 常规格式。自动调整将整数、浮点数转换成 浮点型或科学计数法表示。 | |
| ‘G’ | 与’g’相同。区别参考’e’与’E’，和’f’与’F’ | |
| ‘n’ | 与’g’相同。 | |
| ‘%’ | 百分比。将数字乘以100，加上百分号，默认保留6位小数 | |
| 不填 | 与’d’相同。 |
1.4 语法示例
1. %-formatting
"""
格式一：
1.一个参数：print('我叫%s' % name) # 可以省略括号
2.多个参数：print('我叫%s,今年%d岁' % (name, age))
"""
name, age, height = '张三', 20, 180.4
print('%s' % name) # 张三
print('%s--%f' % (name, height)) # 张三--180.400000
"""
格式二：
1.一个参数：print('%(name)s' % {'name': '张三'})
2.多个参数：print('%(name)s--%(age)d' % {'name': '张三', 'age': 18})
"""
name, age, height = '张三', 20, 180.4
print('%(name)s' % {'name': '张三'}) # 张三
print('%(name)s--%(age)d' % {'name': '张三', 'age': 18}) # 张三--18
2. str.format()
"""方式一：指定参数"""
'''1.1 不设置指定位置，按默认顺序'''
name, age, height = '张三', 20, 180.4
print(1.1, '我叫{},我叫{},今年{}岁,身高{}'.format(name, name, age, height, )) # 我叫张三,我叫张三,今年20岁,身高180.4
'''1.2 设置指定位置'''
name, age, height = '张三', 20, 180.4
print(1.2, '我叫{0},我叫{0},今年{1}岁,身高{2}'.format(name, age, height)) # 我叫张三,我叫张三,今年20岁,身高180.4
'''1.3 设置参数
网站名：菜鸟教程, 地址 www.runoob.com
'''
name, age, height = '张三', 20, 180.4
print(1.3, '网站名：{name}, 地址 {url}'.format(name="菜鸟教程", url="www.runoob.com"))
'''方式二：通过序列获取'''
'''2.1 通过字典dict设置参数(解包)
网站名：菜鸟教程, 地址 www.runoob.com
'''
name, age, height = '张三', 20, 180.4
site_dict = {"name": "菜鸟教程", "url": "www.runoob.com"}
print(2.1, "网站名：{name}, 地址 {url}".format(**site_dict)) # 使用**解包操作
'''2.2 通过字典dict设置参数(不解包)
网站名：菜鸟教程, 地址 www.runoob.com
'''
name, age, height = '张三', 20, 180.4
site_dict = {"name": "菜鸟教程", "url": "www.runoob.com"}
print(2.2, "网站名：{0[name]}, 地址 {0[url]}".format(site_dict)) # "0" 是固定写法 使用[]访问字典
'''2.3 通过列表list索引设置参数
网站名：菜鸟教程, 地址 www.runoob.com
'''
name, age, height = '张三', 20, 180.4
my_list = ['菜鸟教程', 'www.runoob.com']
print(2.3, "网站名：{}, 地址 {}".format(*my_list)) # 使用*解包操作
'''2.4 通过列表list索引设置参数
网站名：菜鸟教程, 地址 www.runoob.com
'''
name, age, height = '张三', 20, 180.4
my_list = ['菜鸟教程', 'www.runoob.com']
print(2.4, "网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是固定写法的
3. f-String
# 小写f
name, age, height = '张三', 20, 180.4
print(f'我叫{name},我叫{name},今年{age}岁,身高{height}') # 我叫张三,我叫张三,今年20岁,身高180.4
# 大写F
name, age, height = '张三', 20, 180.4
print(F'我叫{name},我叫{name},今年{age}岁,身高{height}') # 我叫张三,我叫张三,今年20岁,身高180.4
二、%-formatting
"""
@author GroupiesM
@date 2022/6/22 14:20
@introduction 字符串格式化-方式1 %【不推荐】
1.简介
%号格式化字符串的方式从Python诞生之初就已经存在。
目前，Python官方没有弃用这种方式，但也不推荐这种方式。
2.%格式符语法
语法一：'${flags}%${width}${.percision}%${typecode}' % ${content}
语法二：%(${name})${#}${flags}${width}${.precision}%${typecode} % ${{'k1':v1,'k2':v2,...}}
${name} 【可选】，用于选择指定的key
${#} 【可选】对于八进制(oct)、十六进制(hex)，如果加上#，会显示0o/0x，否则不显示
${flags} 【可选】，对齐方式、正负号，可供选择的值有：【+、-、 、0】
+ 右对齐：正数的加正号，负数的加负号
- 左对齐：正数前没有负号，负数前加负号
空格 右对齐：正数前加空格，负数前加负号；
0 右对齐：正数前无符号，负数前加负号；用0填充空白处
${width} 【可选】，总长度（不足位数补空格）
${.precision} 【可选】，有效位数
${typecode} 【必选】，数据类型、格式
1)传入"字符串类型"的参数
s，获取传入的对象 str() 方法的返回值（字符串-供人阅读），并将其格式化到指定位置
r，获取传入对象的 repr() 方法的返回值（字符串-供解释器使用），并将其格式化到指定位置
空白，未指定类型，则默认s
2)传入"整数类型"的参数
c，获取传入对象的 chr() 方法的返回值（unicode对应值），10进制范围为0 <= i <=1114111
--%格式符：没有b（2进制数字）方法，format格式化可以支持--
d，10进制整数
o，获取传入对象的 oct() 方法的返回值（8进制数字），并将其格式化到指定位置
x，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文小写）
X，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文大写）
3)传入"浮点型或小数类型"的参数
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
F，同上
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
%，将数字乘以100，加上百分号，默认保留6位小数。当字符串中存在格式化标志时，需要用%%表示一个百分号。
${content} 【必选】，要格式化的内容
"""
'''完整语法示例1：
-16.9
1) ${flag} = '0' 右对齐：正数前无符号，负数前加负号；用0填充空白处
2) ${width} = '10' 总长度（不足位数补空格）
3) ${precision} = '5，有效位数
4) ${typecode} = 'f'，'数据类型float
'''
print('%(money)#010.5f' % {'money': -16.9})# -016.90000
'''完整语法示例2：
100
1) ${flag} = '+' 右对齐：正数的加正号，负数的加负号
2) ${#} = '#' 对于二进制(bin)、八进制(oct)、十六进制(hex)，如果加上#，会显示0b/0o/0x，否则不显示
3) ${width} = '10' 总长度（不足位数补空格）
4) ${precision} = '5'，有效位数
5) ${typecode} = 'f'，数据类型float
'''
print('%(money)#+10d' % {'money': 100}) # +0o00144
2.1 【flags】对齐方式、正负号
"""
@author GroupiesM
@date 2022/6/23 16:26
@introduction
2.%格式符语法
语法一：'${flags}%${width}${.percision}%${typecode}' % ${content}
语法二：%(${name})${#}${flags}${width}${.precision}%${typecode} % ${{'k1':v1,'k2':v2,...}}
"""
name, age, money, height = '张三', 20, -20, 180.4
'''
对齐方式、正负号${flags}：【可选】
不填 右对齐：正数前加空格，负数前加负号
+ 右对齐：正数的加正号，负数的加负号
- 左对齐：正数前没有负号，负数前加负号
空格 右对齐：正数前加空格，负数前加负号
0 右对齐：正数前无符号，负数前加负号；用0填充空白处
P.S
1.只有当${width}>内容长度时，对齐方式才有效
2.不同${typecode}会影响对齐的方式，下面针对 s字符串、d整数、f浮点型 三种类型测试
'''
print('----s字符串----')
print(1, '%10s' % name)
print(2, '%+10s' % name)
print(3, '%-10s' % name)
print(4, '% 10s' % name)
print(5, '%010s' % name)
'''
1 张三
2 张三
3 张三
4 张三
5 张三
'''
print('----d整数----')
print(1, '%10d' % money)
print(2, '%+10d' % money)
print(3, '%-10d' % money)
print(4, '% 10d' % money)
print(5, '%010d' % money)
'''
1 -20
2 -20
3 -20
4 -20
5 -000000020
'''
print('----f浮点型----')
print(1, '%15f' % height)
print(2, '%+15f' % height)
print(3, '%-15f' % height)
print(4, '% 15f' % height)
print(5, '%015f' % height)
'''
1 180.400000
2 +180.400000
3 180.400000
4 180.400000
5 00000180.400000
'''
2.2 【width】总长度
"""
@author GroupiesM
@date 2022/6/23 16:26
@introduction
2.%格式符语法
语法一：'${flags}%${width}${.percision}%${typecode}' % ${content}
语法二：%(${name})${#}${flags}${width}${.precision}%${typecode} % ${{'k1':v1,'k2':v2,...}}
"""
name, age, money, height = '张三', 20, -20, 180.4
'''
总长度${width}：【可选】
%s 不指定长度
%1s ${width} < 字符长度，不生效
%2s ${width} = 字符长度，不生效
%10 ${width} > 字符长度，生效
'''
print('%s' % name)
print('%1s' % name)
print('%2s' % name)
print('%10s' % name)
'''
张三
张三
张三
张三
'''
2.3 【percision】有效位数
"""
@author GroupiesM
@date 2022/6/23 16:26
@introduction
2.%格式符语法
语法一：'${flags}%${width}${.percision}%${typecode}' % ${content}
语法二：%(${name})${#}${flags}${width}${.precision}%${typecode} % ${{'k1':v1,'k2':v2,...}}
"""
name, age, money, height = '张三', 20, -20, 180.4
'''
有效位数${.precision}：【可选】
1.字符串:'张三'，${.precision}会截取字符串
%s 不指定${precision}
%.1s ${.precision} < 字符长度，从左到右截取1位 '张'
%.2s ${.precision} = 字符长度，不生效
%.10 ${.precision} > 字符长度，不生效
2.整数:'23'，${.precision}超过长度部分在前面补0
%d 不指定${precision}
%.1d ${.precision} < 整数长度，不生效
%.2d ${.precision} = 整数长度，不生效
%.10 ${.precision} > 整数长度，超出部分在前面补0
3.浮点型 '180.45'，${precision}表示有效位数（其中浮点型表示：小数点后位数），默认${precision}=6
%f 不指定${precision}，保留6位小数 '180.450000'
%.1f ${.precision} < 字符长度，保留1位小数 '180.4'
%.2f ${.precision} = 字符长度，保留2位小数 '180.45'
%.15f ${.precision} > 字符长度，保留15位小数 '180.449999999999989'
'''
print('----s字符串----')
print(1, '%s' % name)
print(2, '%.1s' % name)
print(3, '%.2s' % name)
print(4, '%.10s' % name)
'''
1 张三
2 张
3 张三
4 张三
'''
print('----s字符串（指定长度）----')
print(1, '%10s' % name)
print(2, '%10.1s' % name)
print(3, '%10.2s' % name)
print(4, '%10.10s' % name)
'''
1 张三
2 张
3 张三
4 张三
'''
print('----d整数----')
print(1, '%d' % age)
print(2, '%.1d' % age)
print(3, '%.2d' % age)
print(4, '%.5d' % age)
'''
1 23
2 23
3 23
4 00023
'''
print('----d整数（指定长度）----')
print(1, '%10d' % age)
print(2, '%10.1d' % age)
print(3, '%10.2d' % age)
print(4, '%10.5d' % age)
'''
1 23
2 23
3 23
4 00023
'''
print('----f浮点型----') # 浮点型按照小数点后位数算起
print(1, '%f' % height) # 浮点型不指定 默认保留小数点后6位
print(2, '%.1f' % height)
print(3, '%.2f' % height)
print(4, '%.15f' % height)
'''
1 180.400000
2 180.4
3 180.40
4 180.400000000000006
'''
print('----f浮点型（指定长度）----')
print(1, '%10f' % height) # 浮点型不指定 默认保留小数点后6位
print(2, '%10.1f' % height)
print(3, '%10.2f' % height)
print(4, '%10.15f' % height)
'''
1 180.400000
2 180.4
3 180.40
4 180.400000000000006
'''
2.4 【typecode】数据类型
"""
@author GroupiesM
@date 2022/6/23 16:26
@introduction
2.%格式符语法
语法一：'${flags}%${width}${.percision}%${typecode}' % ${content}
语法二：%(${name})${#}${flags}${width}${.precision}%${typecode} % ${{'k1':v1,'k2':v2,...}}
${typecode} 【必选】，数据类型、格式
1)传入"字符串类型"的参数
s，获取传入的对象 str() 方法的返回值（字符串-供人阅读），并将其格式化到指定位置
r，获取传入对象的 repr() 方法的返回值（字符串-供解释器使用），并将其格式化到指定位置
空白，未指定类型，则默认s
2)传入"整数类型"的参数
c，获取传入对象的 chr() 方法的返回值（unicode对应值），10进制范围为0 <= i <=1114111
--%格式符：没有b（2进制数字）方法，format格式化可以支持--
d，10进制整数
o，获取传入对象的 oct() 方法的返回值（8进制数字），并将其格式化到指定位置
x，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文小写）
X，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文大写）
3)传入"浮点型或小数类型"的参数
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
F，同上
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
%，当字符串中存在格式化标志时，需要用 %%表示一个百分号
"""
name, age, money, height = '张三', ord('🫡'), -20, 180.4
'''
数据类型${typecode}：【必选】（未测试全部参数）
c，获取传入对象的 chr() 方法的返回值（unicode对应值），10进制范围为0 <= i <=1114111
o，获取传入对象的 oct() 方法的返回值（8进制数字），并将其格式化到指定位置
x，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置
'''
'''参数c -> 获取unicode'''
# 获取🫡的unicode值 ： ord('🫡') -> 129761
print('c_1',chr(age)) # 🫡
print('c_2','%c' % age) # 🫡
'''参数o -> 8进制'''
print('o_1', oct(age)) # 0o375341
print('o_2', '%o' % age) # 375341
'''参数x -> 16进制'''
print('x_1', hex(age)) # 0x1fae1
print('x_2', '%x' % age) # 1fae1
2.5 【#】8、16进制符号
"""
@author GroupiesM
@date 2022/6/23 16:26
@introduction
2.%格式符语法
语法一：'${flags}%${width}${.percision}%${typecode}' % ${content}
语法二：%(${name})${#}${flags}${width}${.precision}%${typecode} % ${{'k1':v1,'k2':v2,...}}
${#} 【可选】对于八进制(oct)、十六进制(hex)，如果加上#，会显示0o/0x，否则不显示
"""
name, age, money, height = '张三', ord('🫡'), -20, 180.4
'''
8,16进制符号${#}：【可选】
P.S
1.仅对${typecode} in [o,x,X]时生效，但其他情况添加不会报错
'''
'''参数o -> 8进制'''
print('8_1', oct(age)) # 0o375341
print('8_2', '%#o' % age) # 0o375341
print('8-3', '%o' % age) # 375341
'''参数x -> 16进制'''
print('16_1', hex(age)) # 0x1fae1
print('16_3', '%#x' % age) # 0x1fae1
print('16_2', '%x' % age) # 1fae1
三、str.format()
更多详细介绍参考：str.Format()语法-官方文档
"""
@author GroupiesM
@date 2022/6/24 10:26
@introduction 字符串格式化-方式2 format【推荐】
1.简介
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 %
format 函数可以接受不限个参数，位置可以不按顺序。
2.format格式话语法
语法：'{:${format1}}...{:${format2}}...'.format(${values})
举例：'{:>10s}--{:<10s}'.format('hello','python')
结果： hello--python
解读： {:>10s} 对应 {${format1}}
{:<10s} 对应 {${format2}}
'hello','python' 对应 ${values} 。
${values}与${format}组合有大概6种赋值写法，这里只是其中一种
3.${format}的组成
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
${fill} 【可选】，空白处填充的字符
${align} 【可选】，对齐方式、正负号，可供选择的值有：【<、>、=、^】
< : 左对齐
> : 右对齐(默认)
= : 内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。
^ : 内容居中
${sign} 【可选】，有无符号数字，可供选择的值有【+、-、空格】
+ : 正号加+，负号加-
- : 正号不变，负号加-
空格: 正号空格，符号加-
${#} 【可选】对于二进制(bin)、八进制(oct)、十六进制(hex)，如果加上#，会显示0b/0o/0x，否则不显示
${width} 【可选】，总长度（不足位数补空格）
${,} 【可选】为数字添加分隔符，如：1,000,000
${precision} 【可选】，有效位数
${typecode} 【可选】，数据类型、格式
1)传入"字符串类型"的参数
s，获取传入的对象 str() 方法的返回值（字符串-供人阅读），并将其格式化到指定位置
r，获取传入对象的 repr() 方法的返回值（字符串-供解释器使用），并将其格式化到指定位置
空白，未指定类型，则默认s
2)传入"整数类型"的参数
c，获取传入对象的 chr() 方法的返回值（unicode对应值），10进制范围为0 <= i <=1114111
--%格式符：没有b（2进制数字）方法，format格式化可以支持--
b，获取传入对象的 byte() 方法的返回值（2进制数字），并将其格式化到指定位置
d，10进制整数
o，获取传入对象的 oct() 方法的返回值（8进制数字），并将其格式化到指定位置
x，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文小写）
X，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文大写）
3)传入"浮点型或小数类型"的参数
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
F，同上
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
n，同'g'
%，百分比，将数字乘以100，加上百分号，默认保留6位小数
${content} 【必选】，要格式化的内容
"""
'''format格式化 完整语法示例1：
16.9
1) ${fill} = ' ' 空白处填充的字符
2) ${align} = '>' 右对齐(默认)
3) ${sign} = '+' 正号加+，负号加-
4) ${width} = '10' 总长度（不足位数补${fill}）
5) ${.precision} = '5'，有效位数
6) ${typecode} = 'f'，数据类型float
'''
print('{: >+010.5f}'.format(16.9)) # +16.90000
'''format格式化 完整语法示例2：
10000
1) ${fill} = ' ' 空白处填充的字符
2) ${align} = '>' 右对齐(默认)
3) ${sign} = '+' 正号加+，负号加-
4) ${#} 对于二进制(bin)、八进制(oct)、十六进制(hex)，如果加上#，会显示0b/0o/0x，否则不显示
5) ${width} = '10' 总长度（不足位数补${fill}）
6) ${.precision} = '5'，有效位数
7) ${typecode} = 'o'，数据类型octonary（二进制）
'''
print('{: >+#10o}'.format(10000)) # +0o23420
'''format格式化 完整语法示例3：
1850000
1) ${fill} = ' ' 空白处填充的字符
2) ${align} = '>' 右对齐(默认)
3) ${sign} = '+' 正号加+，负号加-
4) ${#} 对于二进制(bin)、八进制(oct)、十六进制(hex)，如果加上#，会显示0b/0o/0x，否则不显示
5) ${width} = '14' 总长度（不足位数补${fill}）
6) ${,} = ',' 为数字添加分隔符，如：1,000,000
7) ${.precision} = '2'，有效位数
8) ${typecode} = 'f'，数据类型float
'''
print('{: >+#14.2f}'.format(18500.05432)) # +18500.05
print('{: >+#14,.2f}'.format(18500.05432)) # +18,500.05
'''测试结果：可以看到总长度14，数字分隔符${,}也算入了总长度
+1850000
+1,850,000
'''
format 格式
"""
@author GroupiesM
@date 2022/6/24 17:40
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
'''
format格式${format}：【可选】
P.S
1.以下几种情况的${format}添加位置不同
2.使用 对齐方式${fill} 做测试对比
'''
site_dict, my_list = {"name": "菜鸟教程", "url": "www.runoob.com"}, ['菜鸟教程', 'www.runoob.com']
name, age, height = '张三', 20, 180.4
'''1.1 不设置指定位置，按默认顺序
1.1a 我叫张三,我叫张三,今年20岁,身高180.4
1.1b 我叫***张三,我叫***张三,今年***20岁,身高180.4
'''
print('1.1a', '我叫{},我叫{},今年{}岁,身高{}'.format(name, name, age, height))
print('1.1b', '我叫{:*>5},我叫{:*>5},今年{:*>5}岁,身高{:*>5}'.format(name, name, age, height)) # 居右，长度5，填充*
'''1.2 设置指定位置 {0}、{1}
1.2a 我叫张三,我叫张三,今年20岁,身高180.4
1.2b 我叫@张三@@,我叫@张三@@,今年@20@@岁,身高180.4
'''
print('1.2a', '我叫{0},我叫{0},今年{1}岁,身高{2}'.format(name, age, height))
print('1.2b', '我叫{0:@^5},我叫{0:@^5},今年{1:@^5}岁,身高{2:@^5}'.format(name, age, height)) # 居中，长度5，填充@
'''1.3 设置参数 {name}、{url}
1.3a 网站名：菜鸟教程, 地址 www.runoob.com,利润-123
1.3b 网站名：菜鸟教程, 地址 www.runoob.com,利润-$$123
1.3c 网站名：菜鸟教程, 地址 www.runoob.com,利润$$-123
'''
print('1.3a', '网站名：{name}, 地址 {url},利润{profit}'.format(name="菜鸟教程", url="www.runoob.com", profit=-123))
print('1.3b','网站名：{name}, 地址 {url},利润{profit:$=6}'.format(name="菜鸟教程", url="www.runoob.com", profit=-123)) # =右对齐，仅适用于数字
print('1.3c','网站名：{name}, 地址 {url},利润{profit:$>6}'.format(name="菜鸟教程", url="www.runoob.com", profit=-123)) # >右对齐2，长度6，填充$
'''2.1 通过字典dict设置参数
2.1a 网站名：菜鸟教程, 地址 www.runoob.com
2.1b 网站名：菜鸟教程 , 地址 www.runoob.com
'''
print('2.1a', "网站名：{name}, 地址 {url}".format(**site_dict))
print('2.1b', "网站名：{name:<5}, 地址 {url:<5}".format(**site_dict)) # 居左，长度5，填充空格
'''2.2 通过列表list索引设置参数
2.2a 网站名：菜鸟教程, 地址 www.runoob.com
2.2b 网站名：菜鸟教程🫤, 地址 www.runoob.com
'''
print('2.2a', "网站名：{}, 地址 {}".format(*my_list))
print('2.2b', "网站名：{:🫤<5s}, 地址 {:🫤<5s}".format(*my_list)) # 居左，长度5，填充🫤
'''2.3 通过列表list索引设置参数
2.3a 网站名：菜鸟教程, 地址 www.runoob.com
2.3b 网站名：菜鸟教程💩, 地址 www.runoob.com
'''
print('2.3a', "网站名：{0[0]}, 地址 {0[1]}".format(my_list))
print('2.3b', "网站名：{0[0]:💩<5s}, 地址 {0[1]:💩<5s}".format(my_list)) # 居左，长度5，填充💩
3.1 【fill】填充字符
"""
@author GroupiesM
@date 2022/6/24 16:56
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
name, age, money, height, = '张三', 20, -20, 180.4
'''
填充字符${fill}：【可选】
P.S
1.${fill} 的前提是 ${align}，否则报错
2.${align} 的前提是 ${width} ，不指定不会报错，但对齐方式不会生效
3.${fill} 只能指定一位
4.${fill} 不指定时，默认为空格
5.内容长度<${width}时，触发填充动作；反之不执行任何操作
'''
print('1', '我叫{},我叫{},今年{}岁,身高{}'.format(name, name, age, height, ))
print('2', '我叫{:>5},我叫{:>5},今年{:>5}岁,身高{:>5}'.format(name, name, age, height, )) # 居右，长度5，不指定填充
print('3', '我叫{:*>5},我叫{:*>5},今年{:*>5}岁,身高{:*>5}'.format(name, name, age, height, )) # 居右，长度5，填充*
print('4', '我叫{:*>5},我叫{:🎱>5},今年{:🎱>5}岁,身高{:🎱>5}'.format(name, name, age, height, )) # 居右，长度5，填充🎱
'''测试结果
1 我叫张三,我叫张三,今年20岁,身高180.4
2 我叫 张三,我叫 张三,今年 20岁,身高180.4
3 我叫***张三,我叫***张三,今年***20岁,身高180.4
4 我叫***张三,我叫🎱🎱🎱张三,今年🎱🎱🎱20岁,身高180.4
'''
3.2 【align】对齐方式
"""
@author GroupiesM
@date 2022/6/24 16:57
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
name, age, money, height, = '张三', 20, -20, 180.4
'''
对齐方式${align}：【可选】
< : 左对齐
> : 右对齐(默认)
= : 内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。
^ : 内容居中
P.S
1.不同语法格式的添加位置不同，下面会依次测试
2.${align} 的前提是 ${width} ，不指定不会报错，但对齐方式不会生效
3.${align} 中的右对齐(=)，仅对数字类型有效，参数类型错误会报错
'''
'''字符型string
1 我叫 张三
2 我叫张三
4 我叫 张三
'''
print('1', '我叫{:>5}'.format(name))
print('2', '我叫{:<5}'.format(name))
# print('3', '我叫{:=5}'.format(name)) # = 仅对数字类有效
print('4', '我叫{:^5}'.format(name))
'''数字型int
1 余额 -20
2 余额-20
3 余额- 20
4 余额 -20
'''
print('1', '余额{:>5}'.format(money))
print('2', '余额{:<5}'.format(money))
print('3', '余额{:=5}'.format(money)) # = 仅对数字类有效
print('4', '余额{:^5}'.format(money))
3.3 【sign】数字正负号
"""
@author GroupiesM
@date 2022/6/24 16:57
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
name, age, money, height = '张三', 20, -20, 180.4
'''
数字正负号${sign}：【可选】
+ : 正号加+，负号加-
- : 正号不变，负号加-
空格: 正号空格，符号加-
P.S
1.不同语法格式的添加位置不同，下面会依次测试
2.${align} 的前提是 ${width} ，不指定不会报错，但对齐方式不会生效
3.${sign} 仅对数字类型有效，参数类型错误会报错
'''
print('1', '年龄{:},余额{:}'.format(age, money))
print('2', '年龄{:+},余额{:+}'.format(age, money))
print('3', '年龄{:-},余额{:-}'.format(age, money))
print('4', '年龄{: },余额{: }'.format(age, money))
print('5', '年龄{:$>+10},余额{:$>+10}'.format(age, money))
'''测试结果
1 年龄20,余额-20
2 年龄+20,余额-20
3 年龄20,余额-20
4 年龄 20,余额-20
5 年龄$$$$$$$+20,余额$$$$$$$-20
'''
3.4 【width】总长度
"""
@author GroupiesM
@date 2022/6/24 16:58
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
name, age, money, height = '张三', 20, -2.4, 180.4
'''
总长度${width}：【可选】
%s 不指定长度
%1s ${width} < 字符长度，不生效
%2s ${width} = 字符长度，不生效
%10 ${width} > 字符长度，生效
P.S
1. 不指定${align}默认为">"，右对齐
2. 不指定${fill} 默认为"空格"
3. 负数中的"-"也计算入总长度中，长度为1
4. 浮点类型点的"."也计算入总长度中，长度为1
'''
print('1', '{}'.format(money))
print('2', '{:1}'.format(money))
print('3', '{:2}'.format(money))
print('4', '{:3}'.format(money))
print('5', '{:4}'.format(money))
print('6', '{:5}'.format(money)) # "-2.4" 字符长度为4，指定${width}>=5时才会触发填充操作
'''测试结果
1 -2.4
2 -2.4
3 -2.4
4 -2.4
5 -2.4
6 -2.4
'''
3.5 【,】数字分隔符
"""
@author GroupiesM
@date 2022/6/24 16:58
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
name, age, money, height = '张三', 20, 100000, 11240980.456789657
'''
数字分隔符${,}：【可选】
为数字添加分隔符，如：1,000,000
P.S
1. typecode为整数、浮点类型时才可以添加
2. 小数点前每隔3位数字自动添加一个,
'''
print('1', '{:,}'.format(money))
print('3', '{:,}'.format(height))
print('3', '{:,.11}'.format(height))
'''测试结果
1 100,000
3 11,240,980.456789657
3 11,240,980.457
'''
3.6 【percision】有效位数
"""
@author GroupiesM
@date 2022/6/24 16:59
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
'''
有效位数${.precision}：【可选】
1.字符串:'张三'，${.precision}会截取字符串
%s 不指定${precision}
%.1s ${.precision} < 字符长度，从左到右截取1位 '张'
%.2s ${.precision} = 字符长度，不生效
%.10 ${.precision} > 字符长度，不生效
2.整数:'23'，${.precision}，-str.format()不支持给整数指定${percision}。（%-formatting可以给整数指定${percision}）
3.浮点型 '180.45'，${precision}表示有效位数（其中浮点型表示：小数点后位数），默认${precision}=6
%f 不指定${precision}，保留6位小数 '180.450000'
%.1f ${.precision} < 字符长度，保留1位小数 '180.4'
%.2f ${.precision} = 字符长度，保留2位小数 '180.45'
%.15f ${.precision} > 字符长度，保留15位小数 '180.449999999999989'
'''
print('----s字符串----')
name = '张三'
print(1, '{:}'.format(name))
print(2, '{:.1}'.format(name))
print(3, '{:.2}'.format(name))
print(4, '{:.10}'.format(name))
'''
1 张三
2 张
3 张三
4 张三
'''
print('----s字符串（指定长度）----')
name = '张三'
print(1, '{:10}'.format(name))
print(2, '{:10.1}'.format(name))
print(3, '{:10.2}'.format(name))
print(4, '{:10.10}'.format(name))
'''
1 张三
2 张
3 张三
4 张三
'''
print('----f浮点型----') # 浮点型按照小数点后位数算起
height = 180.4
print(1, '{:f}'.format(height)) # # 浮点型不指定 默认保留小数点后6位
print(2, '{:.1f}'.format(height))
print(3, '{:.2f}'.format(height))
print(4, '{:.10f}'.format(height))
'''
1 180.400000
2 180.4
3 180.40
4 180.4000000000
'''
print('----f浮点型（指定长度）----')
print(1, '{:10f}'.format(height)) # 浮点型不指定 默认保留小数点后6位
print(2, '{:10.1f}'.format(height))
print(3, '{:10.2f}'.format(height))
print(4, '{:10.10f}'.format(height))
'''
1 180.400000
2 180.4
3 180.40
4 180.4000000000
'''
3.7 【#】2,8,16进制符号
"""
@author GroupiesM
@date 2022/6/24 16:58
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
"""
name, age, money, height = '张三', 20, -20, 180.4
'''
2,8,16进制符号${#}：【可选】
P.S
1.仅对${typecode} in [b,o,x,X] 时生效，但其他情况添加不会报错
'''
'''2进制'''
print('{:b}'.format(age)) # 10100
print('{:#b}'.format(age)) # 0b10100
'''8进制'''
print('{:o}'.format(age)) # 24
print('{:#o}'.format(age)) # 0o24
'''16进制'''
print('{:x}'.format(age)) # 14
print('{:#x}'.format(age)) # 0x14
3.8 【typecode】数据类型
"""
@author GroupiesM
@date 2022/6/24 16:59
@introduction
1) ${value}为字符类型时 - （没有${sign}和${,}）
${fill}${align}${#}${width}${.percision}%${typecode}
2) ${value}为整数类型时 - （没有${.percision}）
${fill}${align}${sign}${#}${width}${,}%${typecode}
3) ${value}为浮点型时
${fill}${align}${sign}${#}${width}${,}${.percision}%${typecode}
${typecode} 【必选】，数据类型、格式
1)传入"字符串类型"的参数
s，获取传入的对象 str() 方法的返回值（字符串-供人阅读），并将其格式化到指定位置
r，获取传入对象的 repr() 方法的返回值（字符串-供解释器使用），并将其格式化到指定位置
空白，未指定类型，则默认s
2)传入"整数类型"的参数
c，获取传入对象的 chr() 方法的返回值（unicode对应值），10进制范围为0 <= i <=1114111
--%格式符：没有b（2进制数字）方法，format格式化可以支持--
b，获取传入对象的 byte() 方法的返回值（2进制数字），并将其格式化到指定位置
d，10进制整数
o，获取传入对象的 oct() 方法的返回值（8进制数字），并将其格式化到指定位置
x，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文小写）
X，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置（英文大写）
3)传入"浮点型或小数类型"的参数
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
F，同上
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
n，同'g'
%，百分比，将数字乘以100，加上百分号，默认保留6位小数
"""
name, age, money, height = '张三', ord('🫡'), -20, 180.4
'''
数据类型${typecode}：【可选】（未测试全部参数）
空白，不填默认为s，字符串类型
c，获取传入对象的 chr() 方法的返回值（unicode对应值），10进制范围为0 <= i <=1114111
o，获取传入对象的 oct() 方法的返回值（8进制数字），并将其格式化到指定位置
x，获取传入对象的 hex() 方法的返回值（16进制数字），并将其格式化到指定位置
'''
'''参数不填 -> 字符默认为s、整数默认为d、浮点默认为g'''
print(' _1', age) # 129761
print(' _2','{:}'.format(age)) # 129761
'''参数b -> 2进制'''
print('b_1', bin(age)) # 0b11111101011100001
print('b_2','{:b}'.format(age)) # 11111101011100001
'''参数o -> 8进制'''
print('o_1', oct(age)) # 0o375341
print('o_2','{:o}'.format(age)) # 375341
'''参数x -> 16进制'''
print('x_1', hex(age)) # 0x1fae1
print('x_2','{:x}'.format(age)) # 1fae1
3.9 %-formatting 对比 str.format()
"""
@author GroupiesM
@date 2022/6/27 11:06
@introduction
大部分情况下，%格式符合format格式化都能实现相同功能，以下案例中使用两种格式输出相同格式结果
但也有些不同的地方：关于测试出的不同点总结如下：
1) ${typecode}='b'：表示二进制
%：不支持
format：支持
2) ${typecode}=''：空白不填
%：不支持
format：支持，不填默认为s（字符串）
3) ${.percision}：
%：整数时添加${.percision}，表示有效位数
format：整数时不可以添加
4) ${fill}：手动指定分隔符
%：不支持
format：支持
5) ${,}：为数字添加分隔符，如：1,000,000
%：不支持
format：支持
"""
'''%格式符 完整语法示例1：
16.9
1) ${flag} = '+' 右对齐：正数的加正号，负数的加负号
2) ${width} = '10' 总长度（不足位数补空格）
3) ${precision} = '5'，有效位数
4) ${typecode} = 'f'，数据类型float
'''
print('%(money)+10.5f' % {'money': 16.9}) # +16.90000
'''format格式化 完整语法示例1：
16.9
1) ${fill} = ' ' 空白处填充的字符
2) ${align} = '>' 右对齐(默认)
3) ${sign} = '+' 正号加+，负号加-
4) ${width} = '10' 总长度（不足位数补${fill}）
5) ${precision} = '5'，有效位数
6) ${typecode} = 'f'，数据类型float
'''
print('{: >+010.5f}'.format(16.9)) # +16.90000
'''%格式符 完整语法示例2：
10000
1) ${flag} = + 右对齐：正数的加正号，负数的加负号
2) ${#} 对于二进制(bin)、八进制(oct)、十六进制(hex)，如果加上#，会显示0b/0o/0x，否则不显示
3) ${width} = 10 总长度（不足位数补空格）
4) ${precision} = 5，有效位数
5) ${typecode} = f，数据类型float
'''
print('%(money)#+10o' % {'money': 10000}) # +0o23420
'''format格式化 完整语法示例2：
10000
1) ${fill} = ' ' 空白处填充的字符
2) ${align} = '>' 右对齐(默认)
3) ${sign} = '+' 正号加+，负号加-
4) ${#} 对于二进制(bin)、八进制(oct)、十六进制(hex)，如果加上#，会显示0b/0o/0x，否则不显示
5) ${width} = '10' 总长度（不足位数补${fill}）
6) ${precision} = '5'，有效位数
7) ${typecode} = 'f'，数据类型float
'''
print('{: >+#10o}'.format(10000)) # +0o23420
四、f-String
语法详细介绍参考：PEP 3101 – 高级字符串格式化
累了，不想测了
22/06/28
M
扫一扫
750
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
