7.python基础--format()函数

1.术语说明：

str.format() 方法通过字符串中的花括号 {} 来识别替换字段 replacement field，从而完成字符串的格式化。
替换字段由字段名 field name 和转换字段 conversion field 以及格式说明符 format specifier 组成，即一般形式为 {字段名!转换字段:格式说明符}。
字段名分为简单字段名 simple field name 和复合字段名 compound field name。
而转换字段和格式说明符都是可选的。

2.简单字段名：

简单的字段名有三种写法：省略不写、数字和变量名。

花括号内省略字段名，传递位置参数。注意：花括号个数可以少于位置参数的个数，反之不然。

 1 #省略字段名传递位置参数
 2 print('我叫{},今年{}岁！'.format('小明',18))
 3 ###########################
 4 我叫小明,今年18岁！
 5 
 6 #花括号个数可以少于位置参数的个数
 7 print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
 8 ###########################
 9 我爱吃香蕉和苹果。
10 
11 #花括号个数多于位置参数的个数则会报错
12 print('我还吃{}和{}。'.format('西红柿'))
13 ###########################
14 Traceback (most recent call last):
15   File "E:/python文件夹/jiujiu.py", line 5, in <module>
16     print('我还吃{}和{}。'.format('西红柿'))
17 IndexError: tuple index out of range

可以通过数字形式的简单字段名传递位置参数。数字必须是大于等于0的整数；带数字的替换字段可以重复使用；数字形式的简单字段名相当于把format中的所有位置参数整体当做一个元组，通过字段名中的数字进行取值；即{0}等价于tuple[0]，所以花括号内的数字不能越界。

 1 #通过数字形式的简单字段名传递位置参数
 2 print('身高{0}，家住{1}。'.format(1.8, '铜锣湾'))
 3 ######################
 4 身高1.8，家住铜锣湾
 5 
 6 #数字形式的简单字段名可以重复使用。
 7 print('我爱{0}。\n她今年{1}。\n{0}也爱我。'.format('阿香', 17))
 8 ######################
 9 我爱阿香。
10 她今年17。
11 阿香也爱我。
12 
13 #体会把所有位置参数整体当成元组来取值
14 print('阿香爱吃{1}、{3}和{0}。'.format('榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
16 ######################
17 阿香爱吃臭豆腐、鲱鱼罐头和榴莲。
18 
19 #尝试一下越界错误
20 print('{1}'.format('错误用法'))
21 #####################
22 Traceback (most recent call last):
23   File "E:/python文件夹/jiujiu.py", line 1, in <module>
24     print('{1}'.format('错误用法'))
25 IndexError: tuple index out of range

使用变量名形式的简单字段名传递关键字参数。关键字参数的位置可以随意调换。

1 #使用变量名形式的简单字段名传递关键字参数
2 print('我大哥是{name}，今年{age}岁。'.format(name='阿飞', age=20))
3 #######################
4 我大哥是阿飞，今年20岁。
5 
6 #关键字参数的顺序可以随意调换
7 print('我大哥是{name}，今年{age}岁。'.format(age=20, name='阿飞'))
8 #######################
9 我大哥是阿飞，今年20岁。

简单字段名的混合使用。混合使用数字形式和变量名形式的字段名，可以同时传递位置参数和关键字参数；关键字参数必须位于位置参数之后；混合使用时可以省略数字；省略字段名{}不能和数字形式的字段名{非负整数}同时使用。

 1 #混合使用数字形式和变量名形式的字段名
 2 #可以同时传递位置参数和关键字参数
 3 print('这是一个关于{0}、{1}和{girl}的故事。'.format('小明', '阿飞', girl='阿香'))
 5 #######################
 6 这是一个关于小明、阿飞和阿香的故事。
 7 
 8 #但是关键字参数必须位于位置参数之后
 9 print('这是一个关于{0}、{1}和{girl}的故事。'.format('小明', girl='阿香' , '阿飞'))
10 #######################
11   File "E:/python文件夹/jiujiu.py", line 1
12     print('这是一个关于{0}、{1}和{girl}的故事。'.format('小明', girl='阿香' , '阿飞'))                                                                                            
13 SyntaxError: positional argument follows keyword argument
14 
15 #数字也可以省略
16 print('这是一个关于{}、{}和{girl}的故事。'.format('小明', '阿飞', girl='阿香'))
17 ########################
18 这是一个关于小明、阿飞和阿香的故事。
19 
20 #但是省略字段名不能和数字形式的字段名同时出现
21 print('这是一个关于{}、{1}和{girl}的故事。'.format('小明', '阿飞', girl='阿香'))
22 ########################
23 Traceback (most recent call last):
24   File "E:/python文件夹/jiujiu.py", line 1, in <module>
25     print('这是一个关于{}、{1}和{girl}的故事。'.format('小明', '阿飞', girl='阿香'))
26 ValueError: cannot switch from automatic field numbering to manual field specificatio

使用元组和字典传递参数。format()还可以使用*元组和**字典的形式传递参数，两者可以混合使用。位置参数、关键字参数、*元组和**字典也可以混合使用，但是要注意的是位置参数要在关键字参数前面，*元组要在**字典前面。

 1 #使用元组传参
 2 infos = '钢铁侠', 66, '小辣椒'
 3 print('我是{}，身价{}亿。'.format(*infos))
 4 ####################
 5 我是钢铁侠，身家66亿。
 6 
 7 print('我是{2}，身价{1}亿。'.format(*infos))
 8 ####################
 9 我是小辣椒，身家66亿。
10 
11 #使用字典传参
12 venom = {'name': '毒液', 'weakness': '火'}
13 print('我是{name}，我怕{weakness}。'.format(**venom))
14 ####################
15 我是毒液，我怕火。
16 
17 #同时使用元组和字典传参
18 hulk = '绿巨人', '拳头'
19 captain = {'name': '美国队长', 'weapon': '盾'}
20 print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
21 print('我是{name}, 我怕{1}。'.format(*hulk, **captain))
22 ###################
23 我是绿巨人, 我怕盾。
24 我是美国队长, 我怕拳头。
25 
26 #同时使用位置参数、元组、关键字参数、字典传参
27 #注意：
28 #位置参数要在关键字参数前面
29 #*元组要在**字典前面
30 tup = '鹰眼',
31 dic = {'weapon': '箭'}
32 text = '我是{1}，我怕{weakness}。我是{0}，我用{weapon}。'
33 text = text.format(*tup, '黑寡妇', weakness='男人', **dic)
35 print(text)
36 #########################
37 我是黑寡妇，我怕男人。我是鹰眼，我用箭。

3.复合字段名：

同时使用了数字和变量名两种形式的字段名就是复合字段名。支持两种操作符：[ ] 方括号和 . 点号。

点号的作用：

传递位置参数：替换字符段形式{数字.属性名}；只有一个替换字段的时候可以省略数字。

 1 # 复合字段名中使用点号传递对象属性
 2 class Person:
 3     def __init__(self, name, addr):
 4         self.name = name
 5         self.addr = addr
 6 
 7 
 8 p = Person('辣妹子', '重庆')
 9 
10 # 点号用法：传递位置参数
11 print('我是{0.name}，家在{0.addr}。'.format(p))
12 """
13 我是辣妹子，家在重庆。
14 """
15 
16 # 当只有一个替换字段的时候可以省略数字
17 print('{.name}辣！'.format(p))
18 """
19 辣妹子辣！
20 """
21 
22 # 试试传递文件对象的属性
23 f = open('out.txt', 'w')
24 print('文件名为：{.name}'.format(f))
25 f.close()
26 """
27 文件名为：out.txt
28 """

传递关键字参数：替换字段形式{关键字参数名.属性名}。

1 # 点号用法：传递关键字参数
2 print('我是{girl.name}，家在{girl.addr}。'.format(girl=p))
3 # 和上一句等价
4 print('我是{p.name}，家在{p.addr}。'.format(p=p))
5 """
6 我是辣妹子，家在重庆。
7 我是辣妹子，家在重庆。
8 """

方括号的作用：

传递位置参数：分别用列表、元组和字典传递位置参数。

 1 # 方括号用法：用列表传递位置参数
 2 infos = ['阿星', 9527]
 3 food = ['霸王花', '爆米花']
 4 print('我叫{0[0]}，警号{0[1]}，爱吃{1[0]}。'.format(infos, food))
 6 """
 7 我叫阿星，警号9527，爱吃霸王花。
 8 """
 9 
10 # 方括号用法：用元组传递位置参数
11 food = ('僵尸', '脑子')
12 print('我叫{0[0]}，年龄{1}，爱吃{0[1]}。'.format(food, 66))
14 """
15 我叫僵尸，年龄66，爱吃脑子。
16 """
17 
18 # 方括号用法：用字典传递位置参数
19 dic = dict(name='阿星', pid=9527)
20 print('我是{[name]}！'.format(dic))
22 # 多个替换字段，不能省略数字
23 print('我是{0[name]}，警号{0[pid]}。'.format(dic))
25 """
26 我是阿星！
27 我是阿星，警号9527。
28 """

传递关键字参数：分别用列表、元组和字典传递关键字参数。

 1 # 方括号用法：传递关键字参数
 2 names = ['皮卡丘']
 3 dic = {'name': '妙蛙花'}
 4 skills = ('十万伏特', '飞叶快刀')
 5 text = '我是{names[0]}，我会{skills[0]}。我是{dic[name]}，我会{skills[1]}。'
 6 text = text.format(names=names, skills=skills, dic=dic)
 7 print(text)
 8 """
 9 我是皮卡丘，我会十万伏特。我是妙蛙花，我会飞叶快刀。
10 """

4.转换字段：

转换字段的取值有三种，前面要加 !，s:传递参数之前先对参数调用 str(); r:传递参数之前先对参数调用 repr(); a:传递参数之前先对参数调用 ascii()。

ascii() 函数类似 repr() 函数，返回一个可以表示对象的字符串。但是对于非 ASCII 字符，使用 \x，\u 或者 \U 转义。

1 # 转换字段
2 print('I am {!s}!'.format('Bruce Lee 李小龙'))
3 print('I am {!r}!'.format('Bruce Lee 李小龙'))
4 print('I am {!a}!'.format('Bruce Lee 李小龙'))
5 """
6 I am Bruce Lee 李小龙!
7 I am 'Bruce Lee 李小龙'!
8 I am 'Bruce Lee \u674e\u5c0f\u9f99'!
9 """

5.格式说明符：

在替换字段中，格式说明符前面有一个冒号：，{字段名!转换字段:格式说明符}。其中格式说明符本身可以是一个字段名，比如：

1 print('{0:{1}}'.format(3.14159, '.4f'))
2 """
3 3.1416
4 """

标准格式说明符的格式：如果不通过重写 __format__ 方法来进行自定义的话，标准格式说明符的形式如下。其中方括号是可选的。[[fill]align][sign][#][0][width][grouping_option][.precision][type]；中文形式可以写作：[[填充]对齐方式][正负号][#][0][宽度][分组选项][.精度][类型码]
填充与对齐方式：如果不给定最小宽度 width，对齐方式毫无意义。正负号：正负号选项仅对数字类型生效。取值有三种：“+” 正数前面添加正号，负数前面添加负号；“-” 仅在负数前面添加负号(默认行为)；“空格” 正数前面需要添加一个空格，以便与负数对齐。
- 填充：只能是一个字符；不指定默认用空格填充；如果指定填充字符，则必须要同时指定对齐方式。
- 对齐方式：(<)左对齐；(>)右对齐；(^)居中；(=)在正负号（如果有的话）和数字之间填充，该对齐选项仅对数字类型有效。它可以输出类似 +0000120 这样的字符串。

 1 # 正负号
 2 print('{:哈=+8.2f}'.format(3.14159))
 3 print('{:哈=+8.2f}'.format(-3.14159))
 4 print('{:哈=+8.2f}'.format(0))
 5 print('{:哈=+8.2f}'.format(-0))
 6 """
 7 +哈哈哈3.14
 8 -哈哈哈3.14
 9 +哈哈哈0.00
10 +哈哈哈0.00
11 """

#号：给u二进制数加上 0b 前缀；给八进制数加上 0o 前缀；给十六进制数加上 0x 前缀
最小宽度：如果不指定，最小字段宽度由内容决定，与内容相等；如果最小宽度前面有一个前导 0，意味着用 0 填充，这等价于指定了 0= 的填充和对齐方式。
分组选项：取值有两种。
- 逗号 ,：使用逗号对数字以千为单位进行分隔。n 类型的数字可以使用本地化的分隔符。n 类型在本机无法使用分组选项 ,原因可能是中文没有数字分隔符。

 1 # n 类型使用本地化的分组选项 ,
 2 # 此项报错，我怀疑是因为中文没有数字的分隔符
 3 # print('数字：{0:,n}'.format(6666))
 4 """
 5 ValueError: Cannot specify ',' with 'n'.
 6 """
 7 
 8 # 使用 d 类型确实是可以的
 9 print('数字：{0:,d}'.format(6666))
10 """
11 数字：6,666
12 """

- 下划线 _：使用下划线对浮点数和 d 类型的整数以千为单位进行分隔。对于 b、o、x 和 X 类型，每四位插入一个下划线，其他类型都会报错。

 1 # 分组选项 _ 作用于 b 类型
 2 print('数字：{0:_b}'.format(0b100111011))
 3 """
 4 数字：1_0011_1011
 5 """
 6 
 7 # 分组选项 _ 作用于 o 类型
 8 print('数字：{0:_o}'.format(0o426754316))
 9 """
10 数字：4_2675_4316
11 """
12 
13 # 分组选项 _ 作用于 x 类型
14 print('数字：{0:_x}'.format(0x2a846e98d))
15 """
16 数字：2_a846_e98d
17 """
18 
19 # 分组选项 _ 作用于 X 类型
20 print('数字：{0:_X}'.format(0X2a846e98d))
21 """
22 数字：2_A846_E98D
23 """
24 
25 # 分组选项 _ 作用于其他类型（比如 n 类型）
26 # print('字符串：{0:_n}'.format(1234567))
27 """
28 ValueError: Cannot specify ',' with 'n'.
29 """

精度：精度指定了小数点后面要展示多少位小数；对于非数字类型，精度指定了最大字段宽度；整数类型不能指定精度。

 1 # 对于非数字类型，精度指定最大字段宽度
 2 print('{0:.3}'.format('哇哈哈哈哈哈'))
 3 """
 4 哇哈哈
 5 """
 6 # 整数类型不能指定精度
 7 print('{:.3d}'.format(666))
 8 """
 9 ValueError: Precision not allowed in integer format specifier
10 """

类型码：分为三大类：字符串类型、整数类型、浮点数类型。
- 字符串类型：s 字符串类型。这是字符串的默认类型，可以省略；None 不指定类型。同 s 类型。

1 # s 类型
2 print('{0:s}'.format('略略略'))
3 # s 类型可以省略
4 print('{0:}'.format('略略略'))
5 """
6 略略略
7 略略略
8 """

- 整数类型：

 1 # b 类型：二进制
 2 print('{0:b}'.format(3))
 3 """
 4 11
 5 """
 6 
 7 # c 类型：把整数转换成 unicode 字符
 8 print('{:c}'.format(97))
 9 """
10 a
11 """
12 
13 # d 类型：十进制整数
14 print('{:d}'.format(666))
15 """
16 666
17 """
18 
19 # o 类型：八进制数
20 print('{:o}'.format(10))
21 """
22 12
23 
24 # x 类型：十六进制数，a到f小写
25 print('{:x}'.format(15))
26 """
27 f
28 """
29 
30 # X 类型：十六进制数，A到F大写
31 print('{:X}'.format(15))
32 """
33 F
34 """
35 
36 # n 类型：与d相同，会插入本地化的分隔符
37 print('{:n}'.format(66666))
38 # 经试验，本机无法为 n 指定任何分组选项（,_）
39 # print('{:,n}'.format(66666))
40 """
41 ValueError: Cannot specify ',' with 'n'.
42 """
43 # print('{:_n}'.format(66666))
44 """
45 ValueError: Cannot specify ',' with 'n'.
46 """
47 
48 # None 不指定类型，与 d 相同。

- 浮点数类型：

 1 # e 类型：科学记数法
 2 # 默认精度为 6 位
 3 print('{:e}'.format(1234567.1234567))
 4 """
 5 1.234567e+06
 6 """
 7 
 8 # E 类型：与 e 相同，用大写 E 表示指数
 9 # 默认精度为 6 位
10 print('{:E}'.format(1234567.1234567))
11 # 修改精度为 10 位
12 print('{:.10E}'.format(1234567.1234567))
13 """
14 1.234567E+06
15 1.2345671235E+06
16 """
17 
18 # f 类型
19 # 默认精度为 6 位
20 print('{:f}'.format(1234567.1234567))
21 """
22 1234567.123457
23 """
24 
25 # F 类型
26 # 同 f，但是会把 nan 转换成 NAN，把 inf 转换成 INF
27 nan = float('nan')
28 inf = float('inf')
29 print('{:F}\n{:F}'.format(nan, inf))
30 """
31 NAN
32 INF
33 """
34 
35 # g 类型
36 # 通用 general 格式。自动转换到 e 或者 f 格式，具体的转换规则在此省略。正无穷、负无穷、正零、负零和非数字分别显示为 inf，-inf，0，-0，nan。指定精度为 0 时等价于精度为 1。默认精度为 6 位。
37 print('{:g}'.format(1234567.1234567))
38 print('{:g}'.format(1234.1234))
39 """
40 1.23457e+06
41 1234.12
42 """
43 
44 # g 类型
45 # 通用 general 格式。自动转换到 E 或者 F 格式，转换规则同上，相应表示方式换成大写。
46 print('{:g}'.format(1234567.1234567))
47 print('{:g}'.format(1234.1234))
48 """
49 1.23457e+06
50 1234.12
51 """
52 
53 # n 类型
54 # number 类型。跟 g 一样，只不过用本地化的分隔符来分隔数字。
55 print('{:n}'.format(1234567.1234567))
56 print('{:n}'.format(1234.1234))
57 """
58 1.23457E+06
59 1234.12
60 """
61 
62 # 经试验，本机指定分组选项会报错
63 # print('{:,n}'.format(1234.1234))
64 """
65 ValueError: Cannot specify ',' with 'n'.
66 """
67 # print('{:_n}'.format(1234.1234))
68 """
69 ValueError: Cannot specify ',' with 'n'.
70 """
71 
72 # % 类型
73 # 会将数字乘以 100，然后以 f 定点 fixed-point 格式显示，最后加上一个百分号 %。
74 print('{:%}'.format(1))
75 """
76 100.000000%
77 """
78 
79 # None 不指定类型。输出效果类似调用 str() 函数。

6.补充说明：

输出花括号需要用花括号本身来转义。

1 # 打印花括号需要使用花括号转义
2 print('{{{}}}'.format('张无忌'))
3 """
4 {张无忌}
5 """

对象可以自定义格式说明符来替换标准格式说明符，比如 datetime 类。

1 from datetime import datetime
2 print("Today is: {0:%a %b %d %H:%M:%S %Y}".format(datetime.now()))
3 """
4 今天是：Thu Nov 15 13:05:09 2018
5 """

转载于：https://blog.csdn.net/jpch89/article/details/84099277

7.python基础--format()函数

猜你喜欢