1. %运算符
1.1 语法介绍
在python中，可以使用%运算符进行灵活多样的格式化处理，通用的语法格式为：
（格式模板） + % +（值组）
格式化处理时，Python使用一个字符串（格式标记模板）作为格式模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个tuple将多个值（值组）传递给格式模板，每个值对应一个格式符。
值组：既要格式化的字符串或者元祖，如果有两个及以上的值则需要用小括号括起来，中间用短号隔开。
格式模板：是一组或多组以%标记的字符串，通过格式标记模板可以灵活对值组进行格式化。格式模板的语法格式如下：
%[(name)][flags][width].[precision]typecode
格式模板中的格式标记符即可以简单、快速对数据进行格式化处理，也可以进行复杂的自动化处理和计算。其中只有typecode参数为必选项，其他选项都是可选项。所以typecode参数是最常用的格式化处理操作，每项操作都要用到，所以放到第一个进行介绍：
1）typecode，必选参数，表示获取对应类型的值并格式化到指定位置。格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型。主要的格式符有：
-
s，获取传入对象的str方法的返回值，并将其格式化到指定位置。
-
r，获取传入对象的repr方法的返回值，并将其格式化到指定位置。
-
c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置。
-
o，将整数转换成八进制表示，并将其格式化到指定位置。
-
x，将整数转换成十六进制表示，并将其格式化到指定位置。
-
d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置。
-
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）。
-
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）。
-
f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）。
-
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）。
-
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）。
-
%，当字符串中存在格式化标志时，需要用 %%表示一个百分号。
这些操作符最常用的是s、f、d，下面结合实例作以介绍：
print('%+s' % 20.53) # 格式化为字符串
print('%d' % 3.1415926) # 格式化为的整数
print('%f' % 20.53) # 格式化为浮点数，默认保留6位
print('%.2f' % 3.1415926) # 格式化为2位的浮点数
print('%3f' % 20.53) # 格式化为3位的浮点数
print('%e' % 3.1415926) # 格式化为科学记数法
输出结果为：
20.53
3
20.530000
3.14
20.530 000
3.141593e+00
2） (name)，可选参数，较少使用。通常用在较复杂的字典格式化处理当中。在字典中选择指定的key，输出字典中指定的key对应的值，字典中没有顺序，只有键值对对应即可。如输出字典中手机的品名、销售数量和价格。
phone = '%(品名)s,%(数量)d,%(单价).2f' % {'单价': 3690, '数量': 2, '品名': 'mate20'}
print(phone )
输出结果为：
mate20,2,3690.00
使用字典格式化时，如果使用(name)作为字典中的键值，不用和字典中的元素进行一一对应。在使用(name)进行格式化时，可以灵活加入字符串常量，字符常量起到标记和说明作用，只相当于一个字符串的作用。如。
phone = '%(品名)s 销售数量为 %(数量)d 个，%(品名)s销售单价为%(单价).2f 元' % {'单价': 3690, '数量': 2, '品名': 'mate20'}
print(phone )
输出结果为：
mate20 销售数量为 2 个，mate20销售单价为3690.00 元
采用(name)这种格式化可以灵活、方便地进行一些自动化工作。如自动出题、批量处理或验证数据。下面是题库自动出题系统中出题（带答案）的示例：
math = '用7、2、4组成一个最大的三位数是（ %(答案1)s）; 用0、4、5组成一个最小的三位数是（ %(答案2)s）。它们的差是（%(答案3)s）。' % {'答案1': 742, '答案2': 405, '答案3': '337'}
print(math)
输出结果为：
题目一：用7、2、4组成一个最大的三位数是（ 742）；用0、4、5组成一个最小的三位数是（ 405）。它们的差是（337）。
3）flags，可选参数，默认为右对齐。可供选择的值有：+，-，’ ‘或0。+ 表示右对齐。- 表示左对齐。’ '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。通常与width结合使用，演示示例放到3）Width中进行介绍。
-
+ ，右对齐；正数前加正号，负数前加负号；
-
- ，左对齐；正数前无符号，负数前加负号；
-
空格 ，右对齐；正数前加空格，负数前加负号；
-
0 ，右对齐；正数前无符号，负数前加负号；用0填充空白处
4）Width，可选参数，指设置占位的宽度。通常和flags参数配合使用，示例如下：
print('%+6s' % '明日') # 字符串右对齐，左侧添加空格占位
print('%+6d' % -3.14) # 格式化为整数，右对齐，左侧添加空格占位
print('%-6s' % '明日') # 字符串左对齐，右侧添加空格占位
print('%-6d' % -3.14) # 格式化为整数，左对齐，右侧添加空格占位
print('% 6s' % '明日') # 字符串右对齐，左侧添加空格占位
print('%06d' % 3.14) # 格式化为整数，右对齐，左侧添加0占位
输出结果为：
明日
-3
明日
-3
明日
000003
5） .precision，可选参数，设置浮点数或字符串的精度。对于浮点数来说，用于设置浮点数的精度，即小数点后保留的位数。对于字符串来说，就是截取字符串的位数。
print('%.2s' % '明日888') # 取字符串的前两位
print('%.2f' % 3.1415926) # 格式化为小数点保存为2位的浮点数
print('%.6f' % 3) # 格式化为小数点保存为6位的浮点数
print('%.f' % 3.14) # 默认小数点后保留的位数为0
print('%f' % 3.14) # 不写小数点，精度默认为6位小数
输出结果为：
明日
3.14
3.000000
3
3.140000
1.2 实战技巧
锦囊1 整数的格式化输出
整数包含十进制整数、八进制整数、十六进制整数等，对于八进制数和十六进制数，转换时需要使用0o（零欧）或0x（零x）前缀，告诉程序你现在格式化的数的进制（o -oct 八进制； d- dec，十进制；x -hex，十六进制）。在进制转换时，使用%o、%x、%d进行八进制整数、十六进制、十进制整数转换。常用转换示例如下：
print('%o' % 24) # 格式化十进制数为八进制数
print('%x' % 24) # 格式化十进制数为十六进制数
print('%o' % 0x3e) # 格式化十六进制数为八进制数
print('%x' % 0o122) # 格式化八进制数为十六进制数
print('%d' % 0x3e) # 格式化十六进制数为十进制数
print('%d' % 0o122) # 格式化八进制数为十进制数
print('%d' % 3.1415926) # 格式化浮点数为整数
print('%d' % (7/3)) # 格式化计算结果为整数
a=100/3+5
print('%d' % a) # 格式化变量为整数
锦囊2 浮点数的格式化输出
在数据格式化时，对浮点数进行格式化是最常用的操作，通常使用“f ”操作符结合精度进行格式化操作。“%f”默认保留小数点后面六位有效数字；“%.3f”保留3位小数位。常用浮点数格式化操作如下：
print('%f' % 3.14) # 默认保留6位小数
print('%.f' % 3.14) # 默认保留0位小数
print('%.1f' % 3.14) # 保留1位小数
print('%.2f' % 3.1415926) # 保留2位小数
print('%+03.2f' % 3.1415926) # 右对齐宽度为3保留2位小数
print('%+6.1f' % -3.1415926) # 宽度为6，右对齐，保留1位小数，不足用空格填充
print('%-6.1f' % -3.1415926) # 宽度为6，左对齐，保留1位小数，不足用空格填充
print('% 6.1f' % -3.1415926) # 宽度为6，左对齐，保留1位小数，不足用空格填充
print('%06.1f' % -3.1415926) # 宽度为6，右对齐，保留1位小数，不足用0填充
锦囊3 科学计数法的格式化输出
使用格式符“e”、“E”、“g”和“G”可以将数字格式华为科学记数法。使用科学计数法 %g ，在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法。常用操作如下：
print('%e' % 31415.92653589) # 科学计数法表示，默认保留6位小数(不包含整数部分)
print('%.3e' % 31415.92653589) # 科学计数法表示，保留3位小数(不包含整数部分)
print('%g' % 31415.92653589) # 默认保留6位有效数字(包含整数部分)
print('%.6e' % 31415.92653589) # 科学计数法表示，默认保留6位小数(不包含整数部分)
print('%.6g' % 31415.92653589) # 保留6位有效数字(包含整数部分)
print('%.2g' % 31415.92653589) # 默认保留2位有效数字(包含整数部分)，所以才用科学计数法
锦囊4 字符串的格式化输出
字符串格式化也是程序中经常要做的工作，通常使用操作符“s ”对字符串进行格式化操作。如%s直接将数据格式化为字符串；%5s，右对齐，字符宽度为5位（如字符实际宽度超过设置的宽度，则按实际字符串输出）； %-5s，左对齐，字符宽度为5位；%.4s，截取字符串的前4位字符串输出。常用的字符串操作如下：
print('%s' % 'mingisoft') # 字符串输出
print('%5s' % 'mingisoft') # 字符串长度超过5，宽度5不起作用
print('%20s' % 'mingisoft') # 默认右对齐，宽度为20位，不够默认用空格补位
print('%-20s' % 'mingisoft') # 默认左对齐，宽度为20位，不够默认用空格补位
print('%.4s' % 'mingisoft') # 截取字符串前4位
print('%8.4s' % 'mingisoft') # 截取字符串前4位，右对齐，设置宽度为8
print('%-8.4s' % 'mingisoft') # 截取字符串前4位，左对齐，设置宽度为8
print('www.%s.com' % 'mingisoft') # 灵活加入字符串常量，连接格式化字符串
print('%s.%s/%s' % ('mingisoft','com','book')) # 组合格式化字符
print('1%.1s 2%.1s 3%.2s' % ('吕布','赵云','典韦')) # 灵活加入字符串的格式化
锦囊5 字典的格式化输出
如果使用字典存储数据，该如何对字典的数据进行格式化处理呢？使用字典时，只要所有给出的键都能在字典中找到，就可以获得任意数量的转换说明符，这种形式只用在要输出的内容为字典时，这时对应关系不必是一一对应的关系，只需格式符中的name与字典中的键值对应即可。简单的词典操作如下：
print("%(pid)s,%(type)s,%(resource)s" % {'pid':1375,'type':'cpu','resource':2048})
print("%(002)s" % {'001':'沃尔玛','002':'中国石油化工集团公司','003':'荷兰皇家壳牌石油公司'})
world500 = {'沃尔玛':514405000,'中国石油化工集团公司':414649900,'荷兰皇家壳牌石油公司':39655600}
print('%(中国石油化工集团公司).2f' % world500)
stud={'Jeff':'1001','Jack':'1002','Joy':'1003','May':'1004'}
print('Jeff的学号：%(Jeff)s，May的学号：%(May)s' % stud)
book = {'name':'零基础学Python','price':79.8,'author':'明日'}
temp = '教材:%(name)s，价格:%(price).2f，作者:%(author)s'
print(temp % book)
输出结果为：
1375,cpu,2048
中国石油化工集团公司
414649900.00
Jeff的学号：1001，May的学号：1004
教材:零基础学Python，价格:79.80，作者:明日
注意：dict只支持字符串形式的key，对于int类型，可以直接取取字典的值。
如果在遍历字典时对字典的数据进行格式化操作，该如何操作呢？使用for循环遍历字典，然后根据需要读取字典中的内容进行格式化即可。但要注意，遍历时是遍历整个字典还是遍历键，如果是遍历字典，按元祖读取每一项值即可；如果是遍历键，通过键读取对应的值。常见的代码操作如下：
phonebook = {'李铁':'135889012','王明':'187222341','胡旭':'1866789011','柳湖':'1778902121'}
for item in phonebook.items(): # 遍历整个字典
print( '%-8s %.6s ****'% (item[0],item[1])) # 对电话后4位用*号代替
for item in phonebook: # 遍历键
print( '%-8s,%.6s ****'% (item, phonebook[item]))
template='%(title)s \n %(homepage)s'
data = {'homepage':'www.baidu.com', 'title':'Welcome to my home page!'}
print(template % data)
结果输出为：
李铁 135889 ****
王明 187222 ****
胡旭 186678 ****
柳湖 177890 ****
李铁 ,135889 ****
王明 ,187222 ****
胡旭 ,186678 ****
柳湖 ,177890 ****
Welcome to my home page!
www.baidu.com
锦囊6 自动化处理数据
随着大数据时代的到来，我们需要处理的数据越来越多，是否可以同%格式符进行一些自动化处理工作呢？当然是可以的，大道至简，下面针对一些简单的数据，实现数据的自动化处理，代码如下：
print ("Name:%8s Age:%8d Height:%8.2f"%("Jeff",37,1.75))
print ("Name:%-8s Age:%-8d Height:%-8.2f"%("Jeff",37,1.75))
print ("Name:%8s Age:%08d Height:%08.2f"%("Jeff",37,1.75))
stud=(("Jeff",37,1.75),("Jack",22,1.85),("Joy",32,1.69),("may",27,1.68))
print ("Name:%8s Age:%08d Height:%08.2f"%(stud[0][0],stud[0][1],stud[0][2]))
print ('%s %s %s %s' % ("Jeff",37,1.75, ['Facebook', 'CFO']))
print ('%(name)s:%(score)02.1f'%{'score':9.0, 'name':'Jeff'})
使用循环语句可以批量格式化数据，从而实现数据的简单自动化处理工作。如下是对学生姓名、年龄和身高的批量输出，代码如下：
syst=[["Jeff",37,1.7523],["Jack",22,1.8534],["Joy",32,1.6908],["may",27,1.6834]]
for item in syst:
print ("Name:%-8s Age:%-8d Height:%-8.2f"%(item[0],item[1],item[2]))
输出结果为：
Name:Jeff Age:37 Height:1.75
Name:Jack Age:22 Height:1.85
Name:Joy Age:32 Height:1.69
Name:may Age:27 Height:1.68
1.3 应用场景
1）对单个字符串进行格式化：
print('%d' % 20.53) # 格式化为整数
print('%6s' % '明日科技') # 格式化为6位居右显示的字符串，不足部分用空格填充
print('%f' % 20.53) # 格式化为浮点数，默认带6位小数
print('%o' % 20) # 格式化为八进制数
注意：模板为字符串形式，所以一定要用单引号或双引号，格式化的内容如果是数字，可以不加引号，如果是字符串，一定要加引号。模板中的%是占位符，按其后面的控制字符格式化字符串。
2）对多个字符串或者元祖进行格式化。如果为多个字符串，需要用括号括起来。并且格式化的字符串和格式模板要一一对应。
print('%d，%f' % (20.53,20.53)) # 格式化20.53为整数和浮点数
print('%d，%f，%.2f，%.4f' % (20.53,20.53,20.53,20.53)) # 模板和字符串要对应
# 分别格式化3.1415926为宽度为4，空位用0填充和保留两位小数的浮点
print('%04d，%0.2f' % (3.1415926,3.1415926))
s1 = "横坐标：%s,纵坐标：%s" % (123, 239) # 分别输出横坐标和纵坐标
print(s1)
注意：在模板中，按%后面的控制字符格式化字符串，在%前面可以添加标示字符串，输出时原文输出标示字符串，标示字符串可以对格式化字符串起到标示或说明作用。模板和值组中的元素要一一对应，否则会报错。
2. format() 函数
2.1 语法介绍
format()可以对数据进行格式化处理操作，语法如下：
format(value, format_spec)
format_spec为格式化解释。当参数format_spec为空时，等同于函数str(value)的方式。value为要转换的数据。format_spec可以设置非常复杂的格式转换参数，实现比较完备的数据格式处理模板。format_spec的编写方式如下形式：
format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]
format_spec格式控制符可以分为文字对齐、填充值、标志设置、格式化、类型转换、千位符（数字分组）等主要应用。
主要参数说明：
1）fill（填充值）：此处可以填写任何字符，通常与align、width一起使用，实现指定位数字符填充。
通常用0、*、#等进行填充。如果不写填充值，则使用默认填充值，默认填充值为空格。代码如下：
print(format(81,'@<10')) # 用@填充，宽度为10个空格
print(format(81,'@>10')) # 用@填充，宽度为10个空格
2）align（对齐方式）：指在width(数字宽度)内输出时的对齐方式，分别使用<、>、^和=四个符号表示左对齐、右对齐、居中对齐和数字填充（只用于数字，在符号后进行补齐）。
3）width（数字宽度）：指设定输出字符宽度，如果数据的实际位数比width指定宽度值大，则使用数据实际的长度。如果该值的实际位数小于指定宽度，则位数将设定的fill值填充或设定的0值填充，如果没有设置填充值，则用空格填充。
s = "PYTHON"
print(format(s,'10')) # 没有标志符，如果是字符串则默认左对齐，不足宽度部分默认用空格填充
print(format(81.23,'10')) # 没有标志符，如果是数字则默认右对齐，不足宽度部分默认用空格填充
print(format(s,'0>10')) # 右对齐，不足指定宽度部分用0号填充
print(format(s,'>04')) # 右对齐，因字符实际宽度大于指定宽度4，不用填充
print(format(s,'*>10')) # 右对齐，不足部分用“*”号填充
print(format(s,'>010')) # 右对齐，不足部分用0号填充
print(format(s,'>10')) # 右对齐，默认用空格填充
print(format(s,'<10')) # 左对齐，默认用空格填充
print(format(s,'<010')) # 左对齐，不足部分用0号填充
print(format(s,'@^10')) # 中间对齐，不足部分用“@”填充，宽度为10个空格
print(format(81.23,'0<10')) # 左对齐，不足部分用0号填充
print(format(81.23,'@^10')) # 右对齐，不足部分用“@”填充
print(format(81.23,'0>10')) # 右对齐，不足部分用0号填充
print(format(-81.23,'0=10')) # 右对齐，负号后面不足部分用0号填充，
4）Precision（精度）：精度由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。 Precision（精度）通常和Type(类型)配合起来使用。
5）Type(类型):表示输出字符串、整数和浮点数类型的格式规则，默认为字符型s。
对于整数类型，输出格式包括7 种：
-
b: 输出整数的二进制方式；
-
c: 输出整数对应的 Unicode 字符；
-
d: 输出整数的十进制方式；
-
n: 输出整数的十进制方式；
-
o: 输出整数的八进制方式；
-
x: 输出整数的小写十六进制方式；
-
X: 输出整数的大写十六进制方式；
对于浮点数类型，输出格式包括7种：
-
e: 输出浮点数对应的小写字母 e 的指数形式；
-
E: 输出浮点数对应的大写字母 E 的指数形式；
-
f: 输出浮点数的浮点表示形式，默认保留6位小数
-
F: 输出浮点数的浮点表示形式，默认保留6位小数，无穷大转换成大写字母’INF’
-
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）。
-
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）。
-
%: 输出浮点数的百分形式。
2.2 实战技巧
锦囊1 格式转换
使用format()函数可以格式转。如果format()函数的参数format_spec未提供，则默认为将其他格式数据格式化为字符型，和调用str(value)效果相同。如：
format(3.14) # 使用format ()函数将浮点数转换成字符
'3.14'
str(3.14)) # 使用str()函数将浮点数转换成字符
'3.14'
# 将日期格式化为字符
format(datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"))
'2019-07-17 02:46:353'
设置参数format_spec的值，可以进行相应数据类型的格式化，字符串可以提供的参数为’s’ 。十进制整形提供的参数为’d’ 和’n’,二进制的参数为’b’,八进制的参数为’o’，十六进制小写的参数为 ‘x’ ，十六进制大写的参数为 ‘X’ ，ASC码的参数为’c’，浮点数的参数为’f’。以上格式化后的数据类型都为字符型，举例如下：
print(format(12.2,'f')) # 转换成浮点数，默认为小数保留6位
print(format(12,'d') ) # 转换成十进制
print(format(13)) # 不带参数默认为10进制
print(format(13,'n')) # 转换成十进制数
print(format(13,'b') ) # 转换成二进制
print(format(65,'c')) # 转换unicode成字符
print(format(97,'c')) # 转换unicode成字符
print(format(8750,'c')) # 转换unicode成字符
print(format(12,'o')) # 转换成八进制
print(format(12,'x')) # 转换成十六进制小写字母表示
print(format(12,'X')) # 转换成十六进制大写字母表示
锦囊2 生成数据编号
利用format()函数实现数据编号。对数据进行编号，也是对字符串格式化操作的一种方式，使用format()方法可以对字符串进行格式化编号。只需设置填充字符（编号通常设置0），设置对齐方式时可以使用<、>和^符号表示左对齐、右对齐和居中对齐，对齐填充的符号在“宽度”范围内输出时填充，即可。对数字1进行3位编号，右对齐，需要设置format()方法的填充字符为0，对齐方式为右对齐，宽度为3。具体代码为：
print(format(1,'0>3'))
要生成的编号通常比较复杂，如根据当天的日期建立编号，或者批量生成编号，或者将给定的批量数据中的数字转换成位数固定的编号，下面给出实现如上编号的实现方法：
import datetime
# 时间+编号
wx=datetime.datetime.now().date()
now=datetime.datetime.now()
print(str(wx),format(1,'0>3')) # 年月日 +3位编号
print(format(now,'%Y-%m-%d'),format(1,'0>3')) # 年月日 +3位编号
print(format(now,'%Y%m%d'),'NO'+format(1,'0>3')) # 年月日+NO+3位编号
print(format(now,'%d'),'NO'+format(1,'0>3')) # 日期+NO+3位编号
print(format(now,'%H%M'),'NO'+format(1,'0>3')) # 时钟+分 +NO+3位编号
锦囊3 格式化十进制整数
对于不同的类型数据，format函数的参数format_spec提供的值都不一样，对于十进制整数，整形数值可以提供的参数有’d’、’n’。具体如下：
print(format(81,'8d')) # 8位整数显示，不足部分整数前用空格填充
print(format(81,'+d')) # 格式化为带符号整数显示数据
print(format(-81,'8d')) # 格式化为8位带符号整数显示，补位空格放到符号前
print(format(81,'=8d')) # 格式化为8位正整数，用空格补位
print(format(-81,'=8d')) # 格式化为8位负整数，不足部分在负号后填充
print(format(81,'+8d')) # 格式化为8位正整数，不足部分在符号前填充
print(format(-81,'8d')) # 格式化为8位负整数，不足部分在符号前填充
print(format(81,'>10')) # 右对齐，宽度为10个空格
print(format(81,'<10')) # 左对齐，宽度为10个空格
print(format(81,'010')) # 用0填充空格，宽度为10个空格
print(format(81,'@<10')) # 用@填充空格，宽度为10个空格
print(format(81,'@>10')) # 用@填充空格，宽度为10个空格
print(format(+81,'=10')) # 用@填充空格，宽度为10个空格
print(format(81,'0^10')) # 用@填充空格，宽度为10个空格
s = 125
print(format(s,'0>10')) # 右对齐，不足指定宽度部分用0号填充
print(format(s,'>04')) # 右对齐，因字符实际宽度大于指定宽度4，不用填充
print(format(s,'*>10')) # 右对齐，不足指定宽度部分用*号填充
print(format(s,'>010')) # 右对齐，指定0标志位填充
print(format(s,'>10')) # 右对齐，没指定填充值，用默认值空格填充
print(format(s,'+^30')) # 居中对齐，用+号填充不足部分
print(format(s,'*<8')) # 右对齐，不足指定宽度部分用*号填充
print(format(s,'08')) # 右对齐，指定0标志位填充
锦囊4 格式化浮点数
对于浮点数类型，可以提供的参数有 ‘e’ ‘E’ ‘f’ ‘F’ ‘g’ ‘G’ ‘n’ ‘%’ None输出格式。
用 f 表示浮点类型，并可以在其前边加上精度控制：用于控制输出宽度。这里由于输出位数大于宽度，就按实际位数输出了。还可以为浮点数指定符号，+ 表示在正数前显示+，负数前显示 -；（空格）表示在正数前加空格，在幅负数前加 -；- 与什么都不加（{:f}）时一致：.3f 表示浮点数的精度为3（小数位保留3位）.3 指定除小数点外的输出位数。
print(format(628,'.1f')) # 格式化为保留1位小数的浮点数
print(format(628,'.2f')) # 格式化为保留2位小数的浮点数
print(format(3.14159,'.1f')) # 格式化为保留1位小数的浮点数
print(format(3.14159,'.2f')) # 格式化为保留2位小数的浮点数
print(format(3.14159,'.5f')) # 格式化为保留5位小数的浮点数
print(format(-3.14159,'.3f')) # 格式化为保留1位小数的浮点数
print(format(3.1415926535898,'f')) # 默认精度保留6位小数
print(format(3.14159,'f')) # 默认精度保留6位小数，不足部分用空格填充
print(format(3.14159,'+.3f')) # 格式化为保留3位小树带符号的浮点数
print(format(3.14159,'>8.2f')) # 右对齐，保留三位小数
print(format(3.14159,'<10.2f')) # 左对齐，宽度为10，保留2位小数，不足空格填充
print(format(3.14159,'<.3f')) # 左对齐，保留3位小数点
print(format(3.14159,'@>10.3f')) # 右对齐，用@填充不足位置
print(format(-3.14159,'=10.2f')) # 格式化为保留2位小数的10位数，默认用空格填充
print(format(-3.14159,'0=10.2f')) # 格式化为保留2位小数的10位数，空格用0填充
print(format(3.14159,'0^10.2f')) # 保留2位小数的10位数，居中显示，空格用0填充
锦囊5 格式化百分数
在格式化解释中单独或者在精度之后添加“%”号，可以实现用百分数显示浮点数，如：
print(format(0.161896,'%')) # 将小数格式化成百分数
print(format(0.161896,'.2%')) # 格式化为保留两位小数的百分数
print(format(0.0238912,'.6%')) # 格式化为保留六位小数的百分数
print(format(2/16,'.2%')) # 格式化为保留两位小数的百分数
print(format(3.1415926,'.1%')) # 格式化为保留一位小数的百分数
print(format(0.161896,'.0%')) # 格式化为保留整数的百分数
print(format(0.0238912,'8.6%')) # 格式化为保留六位小数的八位百分数
print(format(0.0238912,'>8.3%')) # 格式化为保留三位小数的八位百分数
锦囊6 格式化科学记数法
如果要将浮点数采用科学技术法表示，可以在格式化解释中使用“e”和“E”或者“g”和“G”。‘e’ 为通用的幂符号，用科学计数法打印数字，用’e’表示幂。使用’g’时，将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
#####e和E
print(format(3141592653589,'e')) # 科学计数法，默认保留6位小数
print(format(3.14,'e')) # 科学计数法，默认保留6位小数
print(format(3.14,'0.4e')) # 科学计数法，默认保留6位小数
print(format(3141592653589,'0.2e')) # 科学计数法，保留2位小数
print(format(3141592653589,'0.2E')) # 科学计数法，保留2位小数，采用大写E表示
#####g和G
print(format(3.14e+1000000,'F')) # 小数点计数法，无穷大转换成大小字母
print(format(3141592653589,'g')) # 科学计数法，保留2位小数
print(format(314,'g')) # 科学计数法，保留2位小数
print(format(3141592653589,'0.2g')) # 科学计数法，保留2位小数，采用大写E表示
print(format(3141592653589,'G')) # 小数点计数法，无穷大转换成大小字母
print(format(3.14e+1000000,'g')) # 小数点计数法，无穷大转换成大小字母
锦囊7 格式化金额
format()函数提供千位分隔符用逗号还能用来做金额的千位分隔符。如果要实现通常格式化后金额前面带上相关货币的符号，需要在该函数前面手动加上相应货币符号。如：
print('$' + format(1201398.2315,'.2f')) # 添加美元符号，小数保留两位
print(chr(36) + format(1201398.2315,'.2f')) # ASCII码添加美元符号，小数保留两位
print( '¥' + format(78088888,',')) # 添加人民币符号，用千位分隔符进行区分金额
print( '£' + format(7908.2315,'.2f')) # 添加英镑符号，用千位分隔符进行区分
print( '' + format(7908.2315,',.2f')) # 添加欧元符号，保留两位小数，千位分隔
print( chr(8364) + format(1201398.2315,'.2f')) # 添加欧元符号，保留两位小数
print( chr(0x20ac) + format(1201398.2315,',f')) # 使用十六进制编码添加欧元符号
锦囊8 格式化字符
格式化字符主要包括截取字符串，字符串对齐方式显示，填充字符串等几个方面，下面举例如下：
print(format('PYTHON','M^20.3')) # 截取3个字符，宽度为20居中，不足用‘M’填充
print(format("PYTHON",'10')) # 默认居左显示，不足部分用‘ ’填充
print(format('mingrisoft.com','.3')) # 截取3个字符，默认居左显示
print(format("PYTHON",'>10')) # 居右显示，不足部分用‘ ’填充
s='mingrisoft.com'
print(format(s,'0>20')) # 右对齐，不足指定宽度部分用0号填充
print(format(s,'>4')) # 右对齐，因字符实际宽度大于指定宽度4，不用填充
print(format(s,'*>20')) # 右对齐，不足指定宽度部分用*号填充
print(format(s,'>020')) # 右对齐，指定0标志位填充
print(format(s,'>20')) # 右对齐，没指定填充值，用默认值空格填充
print(format(s,'+^30')) # 居中对齐，用+号填充不足部分
锦囊9 进制转换
进制转换主要是进行十进制、十六进制、八进制、二进制的转换，如果是十六进制、八进制、二进制数，转换前最好保留进制前缀，如"0x"“0o”“0b”，这样可以保证转换的准确性。要转换数据主要进制转换符号说明如下：
-
‘b’ - 二进制。将数字以2为基数进行输出。
-
‘d’ - 十进制整数。将数字以10为基数进行输出。
-
‘o’ - 八进制。将数字以8为基数进行输出。
-
‘x’ - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
print(format(77)) # 格式参数为空,默认为10进制
print(format(77, 'd')) # 原来是十进制数，转换后为原值
print(format(-77, 'd')) # 原来是十进制数，转换后为原值
print(format(77, '8d')) # 转换为8位十进制数，空余部分用空格填充
print(format(-77, '8d')) # 转换为8位十进制数，负数在负号前填充空余部分空格
print(format(77, '+8d')) # 转换为8位带符号十进制数，在符号前填充空余部分空格
print(format(-77, '08d')) # 转换为8位十进制数，负数在负号前填充空余部分空格
print(format(77, '+08d')) # 转换为8位带符号十进制数，在符号前填充空余部分空格
print(format(-77, '#8d')) # 转换为8位十进制数，空余部分填充0
print(format(-77, '=8d')) # 转换为8位十进制数，空余部分填充0
print(format(+77, '=8d')) # 转换为8位十进制数，空余部分填充空格
print(format(+77, '*=8d')) # 转换为8位十进制数，空余部分填充*
print(format(+77, '*=+8d')) # 转换为8位带符号十进制数，符号与数据之间填充*
print(format(-77, '#=8d')) # 转换为8位十进制数，在符号与空余部分填充#
print(format(+77, '*<8d')) # 转换为8位十进制数，左对齐，空余部分填充*
print(format(-77, '#>8d')) # 转换为8位十进制数，右对齐，空余部分填充#
print(format(0X5A, 'd')) # 十六进制数5A转换成10进制数，0X代表十六进制数
print(format(0B011101, '+8d')) # 二进制数34转换成10进制数，0B代表二进制数
print(format(0O34, 'd')) # 八进制数011101转换成10进制数，0O代表八进制数
print(format(0O123456, '08d')) # 16制数123456转换成10进制数，不足用0填充
print(format(+0X1234, '*>8d')) # 16进制数1234转换成10进制数，右对齐，不足用*
对于带有进制前缀的数，如"0x"“0o”“0b”，可以直接在后面加上’x’、‘o’、'b’进行删除：
print(format(0X5A, 'x')) # 去除十六进制数的前缀
print(format(0B011101, 'b')) # 去除二进制数的前缀
print(format(0O34, 'o')) # 去除八进制数的前缀
输出效果为：
5a
11101
34
锦囊10 格式化日期和时间
format()函数也可以对日期和时间进行格式化，格式化时可以通过日期和时间格式符号进行设置。
| 符号 | 说明 | 符号 | 说明 |
| %y | 两位数的年份表示（00-99） | %B | 本地完整的月份名称 |
| %Y | 四位数的年份表示（000-9999） | %c | 本地相应的日期表示和时间表示 |
| %m | 月份（01-12） | %j | 年内的一天（001-366） |
| %d | 月内中的一天（0-31） | %p | 本地A.M.或P.M.的等价符 |
| %H | 24小时制小时数（0-23） | %U | 一年中的星期数（00-53）星期天为星期的开始 |
| %I | 12小时制小时数（01-12） | %w | 星期（0-6），星期天为星期的开始 |
| %M | 分钟数（00=59） | %W | 一年中的星期数（00-53）星期一为星期的开始 |
| %S | 秒（00-59） | %x | 本地相应的日期表示 |
| %a | 本地简化星期名称 | %X | 本地相应的时间表示 |
| %A | 本地完整星期名称 | %Z | 当前时区的名称 |
| %b | 本地简化的月份名称 | %% | %号本身 |
import datetime
now=datetime.datetime.now()
print(format(now,'%Y-%m-%d %H:%M:%S %A')) # 当前时间格式化为年月日+完整英文星期
print(format(now,'%Y-%m-%d %H:%M:%S %a')) # 当前时间格式化为年月日+简写英文星期
# 中文年月日显示
print(format(now,'%Y'),'年',format(now,'%m'),'月',format(now,'%d'), '日')
# 中文时间显示
print(format(now,'%H'),'时',format(now,'%M'),'分',format(now,'%S'), '秒') print(format(now,'%Y-%m-%d %H:%M:%S %a')) # 当前时间格式化为年月日+简写英文星期
print(format(now,'%Y-%m-%d')) # 当前时间格式化为标准年月日
print(format(now,'%y-%m-%d')) # 当前时间格式化为短日期年月日
print(format(now,'%Y<%m>%d')) # 当前时间格式化为长日期年月日， 间隔符为“<”和“>”
print(format(now,'%c')) # 本地对应的年月日星期表示
print(format(now,'%B')) # 本地完整的月份表示
print('现在是今年第',format(now,'%j'),'天') # 今天是一年中第几天
print('本周是今年第',format(now,'%U'),'周') # 本周是一年中第几周
print(format(now,'%y%m%d')) # 无间隔符短年月日
print(format(now,'%Y-%m')) # 长日期格式年月
print(format(now,'%m-%d')) # 月日显示、
print(format(now,'%m')) # 月份单独显示
print(format(now,'%d')) # 日期单独显示
print(format(now,'%H%M%S')) # 时分秒。无间隔符
print(format(now,'%H:%M:%S')) # 标准时分秒
print(format(now,'%H:%M:%S %I')) # 12小时制 时分秒
print(format(now,'%H:%M')) # 时+分
print(format(now,'%M%S')) # 时钟+分
print(format(now,'%h')) # 只显示时钟点
print(format(now,'%H:%M:%S %p')) # 日期显示按AM，PM显示
print(format(now,'%a')) # 英文星期简写
print(format(now,'%A')) # 英文星期完整显示
week=['星期日','星期一','星期二','星期三','星期四','星期五','星期六']
print(week[int(format(now,'%w'))]) # 中文星期
dt = datetime.datetime(2019, 9, 9)
dm=datetime.datetime(2019, 9, 9, 12, 50,20)
# 将输入的日期按年月日和时间格式化，因时间没有输入，按0时处理
print(format(dt,'%Y-%m-%d %H:%M:%S'))
print(format(dt,'%Y-%m-%d')) # 将输入的日期按年月日格式化
print(format(dm,'%Y-%m-%d %H:%M:%S')) # 将输入的日期按年月日和时间格式化
print(format(dm,'%Y-%m-%d')) # 将输入的日期按年月日格式化
wx=datetime.datetime.now()
print(str(wx),format(1,'0>3')) # 年月日 +3位编号
print(format(now,'%Y-%m-%d'),format(1,'0>3')) # 年月日 +3位编号
print(format(now,'%Y%m%d'),'NO'+format(1,'0>3')) # 年月日+NO+3位编号
print(format(now,'%d'),'NO'+format(1,'0>3')) # 日期+NO+3位编号
print(format(now,'%H%M'),'NO'+format(1,'0>3')) # 时钟+分 +NO+3位编号
3. Str.format()方法
3.1 语法参考
在Python2.6之后，提供了字符串的format()方法对字符串进行格式化操作。format()功能非常强大，格式也比较复杂，具体语法分解如下：
{参数序号: 格式控制标记}.format(*args,**kwargs)
-
参数序号：参数序号其实是位置参数或关键字参数传递过来的参数变量，对参数序号进行格式控制标记设置其实就是对位置参数或关键字参数进行格式化处理。参数序号可以为空值，为空值时一定对应的是位置参数，并且在顺序上和位置参数一一对应。
-
格式控制标记：用来控制参数显示时的格式，和format()函数的format_spec参数是一样的，包括：<填充><对齐><宽度>,<.精度><类型>6 个字段，这些字段都是可选的，可以组合使用。参数序号和格式设置标记用大括号({})表示，可以有多个。{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
-
*args：位置参数，是一个元组，可以为多个值。其和参数序号在位置上是一一对应的，数量上是一致的。
-
**kwargs是关键字参数，是一个字典，其通过序号和参数序号进行对应，可以一对一，也可以一对多。使用关键字参数时，参数序号和关键字参数不一定数量一致。
下面具体介绍如何通过位置参数或关键字参数进行格式化操作。
其中，参数序号为传入的参数，格式设置模板是一个由字符串和格式控制说明字符组成的字符串，用来对传入的参数进行格式化设置。格式设置模板用大括号 { } 表示，可以有多个，其对应format()方法中逗号分隔的参数。
常量可以是符号、文字，甚至是一段话，根据程序开发需要进行设置。灵活使用常量，可以更大范围发挥format()方法的功效。
索引序号与参数映射
'{索引序号: 格式控制标记}'.format(*args,**kwargs)
-
args是位置参数，是一个元组
-
kwargs是关键字参数，是一个字典
-
{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
（1）通过位置参数映射
就是按照位置顺序用位置参数替换前面的格式字符串的占位符。位置参数按照序号匹配，关键字参数按照名称匹配（注：按照位置填充，大括号只是占位符注，一一对应，按照位置输出结果）
- 索引序号为空
如果索引序号为空，索引序号与位置参数按照从左到右的顺序上可以建立映射，实现对传入参数的格式化处理。如索引序号和格式设置标记均为空值时，直接输出位置参数。代码如下：
'{}'.format('中国') # 输出为“中国”
通过常量可以直接连接或修饰各个序号索引之间的关系，如分别通过字符串常量“：”和“«««««”连接“中国“、”1949” 及“70”，代码如下：
'{}:{}:{}'.format('中国','1949','70') # 输出为“中国:1949:70”
'{}«««{}«««{}'.format('中国','1949','70') # 输出为“中国«««1949«««70”
'{}建国于{}年，到2019年已经{}年！'.format('中国','1949','70')
- 索引序号不为空（同一个参数可以填充多次）
如果索引序号不为空，可以通过设置索引序号内的值和位置参数的索引值进行对应，即通过{n}对位置参数索引为n的值进行对应，从而实现对传入的位置参数进行格式化处理。如格式化2019年世界500强企业名单的第一名，代码如下：
'排名:{0} 企业:{1} 收入:{2} 利润:{3}'.format('1','沃尔玛','5144.05','66.7')
索引序号和位置参数不一定要按照这顺序一一对应，可以根据程序需要对索引序号内的位置索引进行设置。
改变索引序号的，可以通过设置索引序号和位置参数的索引值对应，即通过{n}对位置参数索引为n的值进行对应，从而实现对传入的位置参数进行格式化处理。
'企业:{1} 收入:{2} 排名:{0}'.format('1','沃尔玛','5144.05','66.7')
索引序号的值可以重复，即多个索引序号的值可以是同一个位置参数的索引。如输出2018年和2019年世界500强企业名单的第一名企业沃尔玛，代码如下：
'2018:{0} 收入:{2} 2019:{0} 收入:{1}'.format('沃尔玛','5144.05','5003.43')
同一个位置参数可以填充多次，下面是索引序号和位置参数进行映射的示例：
print('{0}, {1}, {2}'.format('I', 'B', 'M')) # 输出结果为：I, B, M
print('{}, {}, {}'.format('I', 'B', 'M')) # 输出结果为：I, B, M
print('{2}{2}{0}{1}{1}'.format('I', 'B', 'M')) # 输出结果为：MMIBB
print('{0}{1},{0}{2}'.format('I','B','M')) # 输出结果为：IB,IM
print('{2}{1}{0}-{0}{1}{2}'.format('I', 'B', 'M')) # 输出结果为：MBI-IBM
如果位置参数不确定，也可以使用“args”形式的位置参数来进行映射，args可以将号后面的字符串拆解成一个一个元素，如’IBM’，将“IBM”拆解成’I’,‘B’,‘M’，下面代码实现的效果是一样的。
print('{2}, {1}, {0}'.format(*'IBM')) # 输出 M, B, I
print('{2}, {1}, {0}'.format('I', 'B', 'M')) # 输出 M, B, I
位置参数的值可以来自元祖或表，然后使用“*args”形式的位置参数来进行映射，如：
mingri=['www','mingrisoft','com']
print('{0}.{1}.{2}'.format(*mingri)) # 输出结果为：www.mingrisoft.com
如果索引序号设置字符串过长，可以使用变量代替索引序号设置字符串，如：
order='排名:{} 企业名称:{} 营业收入:{}万美元 利润:{}万美元'
print(order.format('1','沃尔玛','51440500','667000'))
（2）通过关键字参数映射（关键字参数或命名参数）
索引序号按照关键字参数名称进行映射，kwargs是关键字参数，是一个字典{xxx}表示在关键字参数中搜素名称一致的。将元祖或字典打散成关键字参数给函数（通过和*或者**）format(),进行非常灵活的映射关系。
print('产品:{name}价格:{price}'.format(spec='6G+128G',name='Mate20',price=3669))
print('***{name}***, {price} '.format(spec='6G+128G',name='Mate20',price=3669))
user = {'net':'双4G','name':'Mate 20','price':3669,'spec':'6GB+128G'}
print('{name},{net},{spec},{price}'.format(**user))
位置参数和关键字参数可以混合使用，如：
print('{server}.{1}.{0}'.format('com','mingrisoft',server= 'www'))
（3）通过元素进行映射
对于一些需要在字符串或元祖中截取部分元素进行格式化处理的情况，可以使用切片技术，但只能单个元素提取，如0[1],0[2],不能截取多个元素，如0[0:3]，0[:2]等。（说明，0[1]查找位置参数索引为0 的元组中索引为1的元素）。代码举例如下：
print('{0[1]}--{0[0]}'.format(('猛龙','01')))
print('{0[0]}.{0[1]}.{0[2]}'.format(['www','mingrisoft','com']))
print('{0[2]}.{0[1]}.{0[0]}'.format('张三丰'))
print('{0[0]} {0[1]} {0[2]}'.format('www.mingrisoft.com'.split('.')))
在对元素进行格式化时，利用转义符可以对格式化的数据进行灵活的操作，如分别连接元祖中的数据，使用“\n”转义符实现分行对NBA球队进行输出。代码如下：
print('{0[1]}--{0[0]}\n{1[1]}--{1[0]}'.format(('猛龙','01'),('勇士','02')))
print('{0[1][1]}\n{0[0][1]}'.format((('www','mingrisoft','com'),('www','huawei','com'))))
可以对不同元祖中的对应元素进行提取，实现相应数据的对应输出。如提取元祖中网址中的网址信息，代码如下：
print('{0[1]}、{1[1]}'.format(('www','mingrisoft','com'),('www','huawei','com')))
（4）通过组合映射
在格式化数据时，可以根据位置参数或关键字参数的制定元素，通过索引序号进行灵活的数据组合映射，以达到程序的需要。如将两个元祖中的元素组合，格式化输出三大互联网公司，代码如下：
print('{1[0]}{0[0]}\n{1[1]}{0[1]}\n{1[1]}{0[2]}\n{1[0]}{0[3]}'.format(('阿里巴巴','亚马逊','谷歌','腾讯','IBM'),('中国','美国')))
也可以将多个未知参数中的元素进行组合，如将姓名等位置参数进行组合，生成新的姓名字符串，代码如下：
print('{0[0]}{1[0]}{2[0]}'.format('张王李赵','世常明延','国成微远'))
（5）通过元祖映射
通过元祖可以很好地实现索引序号与格式化数据的映射，如：
list = ['明日888', 'www.mingrisoft.com']
print("公司名称：{0[0]}, 网址：{0[1]}".format(list)) # "0" 对应字典的索引值
info= ['joy', 22, '1.73']
print('My name is {0[0]}, age is {0[1]}, height is {0[2]}'.format(info))
film= (('复仇者联盟4：终局之战',8.6,2019,2793),('阿凡达',8.7,2009,2788),('泰塔尼克号',9.4,1997,2187))
print( '票房最高： {0[0][3]}, 评分最高： {0[2][1]},最新发行：{0[0][2]}'.format(film))
data = [4, 8, 15, 16, 23, 42]
print('{d[4]} {d[5]}'.format(d=data))
（6）通过字典映射
利用字典进行映射是比较常用的格式化操作的方法，可以通过字典的参数的items访问。
info= {'name': 'joy', 'age': 22, 'height':1.68}
print('name : {0[name]}, age :{0[age]}, height: {0[height]}'.format(info))
order= {'a001': 'joy', 'a002': 'jack', 'a003':'may', 'a004':'jobs'}
fatstr='{0['+random.choice((',').join(info).split(','))+']}'
print(fatstr.format(order))
person = {'name': 'joy', 'age': 22}
print('{p[name]} {p[age]}'.format(p=person))
元祖和字典都支持命名占位符，如：
data = {'a001': '英国SAS', 'b001': '美国三角洲部队','c001': '俄罗斯阿尔法部队'}
print('{b001} {c001}'.format(**data))
（7）通过循环嵌套映射
通过循环语句可以批量循序建立映射关系，如下批量建立虚拟姓名：
new=('张王李赵','世常明延','国成微远')
for i in range(4):
print('{0}{1}{2}'.format(new[0][i],new[1][i],new[2][i]))
class Plant(object):
type = 'tree'
kinds = [{'name': 'oak'}, {'name': 'maple'}]
print('{p.type}: {p.kinds[0][name]}'.format(p=Plant()))
（8）通过传入对象映射
class Person:
def __init__(self,name,age):
self.name,self.age = name,age
def __str__(self):
return '我叫{self.name}, 今年{self.age}岁了'.format(self=self)
print(str(Person('joy', 22)))
（9）灵活应用占位符
print('{0:{fill}{align}12}'.format("python", fill='#', align='^'))
for num in range(1,6):
for base in "dXob":
print("{0:{width}{base}}".format(num, base=base, width=6), end=' ')
print()
格式化模板标签
'{索引序号: 格式控制标记}'.format(*args,**kwargs)
格式控制标记用来控制参数显示时的格式，包括：<填充><对齐><宽度>,<.精度><类型>6 个字段，这些字段都是可选的，可以组合使用。
1）fill，可选参数，指”width”内除了参数外的字符采用什么方式表示，默认采用空格，可以通过<填充>更换，填充字符只能有一个。
s = "PYTHON"
print("{0:30}".format(s))
print("{0:>30}".format(s))
print("{0:*^30}".format(s))
print("{0:-^30}".format(s))
print("{0:3}".format(s))
print("{a:*^8}".format(a="mr")) # 输出***mr***
print("{:0>8}".format("866"))
print("{:$>8}".format("866"))
print("{:0>8}".format("866"))
print("{:-<8}".format("866"))
#中间对齐方式中如果出现字符两侧无法平均分配填充符，字符后填充符可以多填充
print("{:-^8}".format("866"))
print("{:*<30}>".format("www.mingrisoft.com"))
2）align，可选参数，可供选择的值有：<，>，或=。指参数在<宽度>内输出时的对齐方式，分别使用<、>、和=表示左对齐、右对齐、居中对齐和在符号后进行补齐。需要注意的是，如果align参数为空，对于字符串，默认左对齐。对于数字，默认右对齐。
-
< （如果是字符串，默认左对齐）左对齐
-
^ 中间对齐
-
> （如果是数字，默认右对齐）右对齐
-
= （只用于数字）在符号后进行补齐
print("{:10}".format('18'))
print("{:10}".format(18))
print("{:<10}".format('18'))
print("{:<10}".format(18))
print("{:>10}".format('18'))
print("{:0>10}".format('18'))
print('{:A>10}'.format('18'))
print("{:^10}".format('18'))
print('{:0=10}'.format(-18))
print('{:0<10}'.format(-18))
print('{:0>10}'.format(-18))
print('{:0=10}'.format(18))
注意：zfill()方法也可以返回指定长度的字符串，原字符串右对齐，前面填充0。
zfill()方法语法：str.zfill(width)
参数width指定字符串的长度。原字符串右对齐，前面填充0。返回指定长度的字符串。
print("11".zfill(5))
3）sign，可选参数，sign可以使用 “+” | “-” | " "。+表示正号， -表示负号宽度指当前槽的设定输出字符宽度，如果该槽参数实际值比宽度设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则按照对齐指定方式在宽度内对齐，默认以空格字符补充。
s = 3.1415926
t=-3.1415926
print("{:+25}".format(s)) # 左对齐，默认
print("{:^25}".format(s)) # 居中对齐
print("{:>-25}".format(s)) # 右对齐
print("{:*^ 25}".format(t)) # 居中对齐且填充*号
print("{:+^25}".format(t)) # 居中对齐且填充+号
print("{:十^25}".format(t)) # 居中对齐且填充汉字“十”
print("{:^+1}".format(t)) # z指定宽度为1，不足变量s的宽度
4）#和0，可选参数，#为进制标志，对于进制数，在进制符前加#，输出时会带上进制前缀，即显示0b,0o,0x。0为填充0，设置width时，没设填充值，加上0，填充0指定位置用0填充。如：
print("{:0>5}".format('18'))
print("{:#x}".format(50)) # 在进制符前加#，输出时会带上进制前缀
print("{:#o}".format(12)) # 在进制符前加#，输出时会带上进制前缀
print("{:#b}".format(22)) # 在进制符前加#，输出时会带上进制前缀
print("{:>#8x}".format(50)) # 在进制符前加#，输出时会带上进制前缀
print("{:=#10o}".format(12)) # 在进制符前加#，输出时会带上进制前缀
5）Width，可选参数， integer 是数字宽度，表示总共输出多少位数字。通常和align参数配合使用，示例如下：指当前槽的设定输出字符宽度，如果该槽对应的format()参数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则位数将被默认以空格字符补充。如：
print('%+6s' % '明日') # 字符串左对齐
print('%+6d' % -3.14) # 格式化为整数，左对齐
print('%-6s' % '明日') # 字符串左对齐
print('%-6d' % -3.14) # 格式化为整数，左对齐
print('% 6s' % '明日') # 字符串左对齐
print('%06d' % 3.14) # 格式化为整数，左对齐
6）千位符，千位符用逗号（，），用于显示数字的千位分隔符，例如：
print("{0:^12,}".format(31415926))
print("{0:-^12,}".format(3.1415926))
print("{0:*^12,}".format(31415.926))
7） .precision，可选参数，设置浮点数或字符串的精度。对于浮点数来说，用于设置浮点数的精度，即小数点后保留的位数。对于字符串来说，就是截取字符串的位数。表示两个含义，由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。
print("{0:.2f}".format(12345.67890))
print("{0:H^20.3f}".format(12345.67890))
print("{0:.4}".format("PYTHON"))
8）type，可选参数，表示获取对应类型的值并格式化到指定位置。格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，主要的格式符有：
-
s，字符串 (采用str()的显示)。
-
r，字符串 (采用repr()的显示)。
-
c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置。
-
o，将整数转换成八进制表示，并将其格式化到指定位置。
-
x，将整数转换成十六进制表示，并将其格式化到指定位置。
-
b 将整数转换成二进制整数，并将其格式化到指定位置。
-
d，将整数、浮点数转换成十进制表示，并将其格式化到指定位置。
-
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）。
-
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）。
-
f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）。
-
g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）。
-
G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）。
-
%，当字符串中存在格式化标志时，需要用 %%表示一个百分号。
如果类型参数未提供，则和调用str(value)效果相同，转换成字符串格式化。如：
print("{}".format(12345.67890))
print("{0:>12}".format(12345.67890))
对于字符符串类型，可以提供的参数有 ‘s’
print("{:s}".format('3.1415926'))
print("{0:>12s}".format('mingri'))
print("{0:>12s}\n{1:>6s}".format('mingri','mr'))
整形数值可以提供的参数有 ‘b’ ‘c’ ‘d’ ‘o’ ‘x’ ‘X’ ‘n’ None，如：
print("{:c}".format(1221))
print("{:4d}".format(3145926))
print("{:b}".format(31))
print("{:o}".format(31))
print("{:x}".format(31))
print('{0:o} :{0:x}:{0:o}'.format(31))
浮点数可以提供的参数有 ‘e’ ‘E’ ‘f’ ‘F’ ‘g’ ‘G’ ‘n’ ‘%’ None，如：
print('{:e}'.format(314159267)) # 科学计数法，默认保留6位小数
print('{:0.2e}'.format(314159267)) # 科学计数法，指定保留2位小数
print('{:f}'.format(314159267)) # 小数点计数法，默认保留6位小数
print('{:0.2f}'.format(314159267)) # 小数点计数法，指定保留2位小数
print('{0:0.2f}\n{0:0.8f}'.format(314159267)) # 小数点计数法，指定保留小数位数
print('{:0.2F}'.format(314159267)) # 小数点计数法，指定保留2位小数
print('{0:0.2F}\n{0:0.8f}'.format(314159267)) # 小数点计数法，指定小数位数
g 的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数。
print('{:1g}'.format(0.000031415926))
print('{:.2g}'.format(0.000031415926))
print('{:.5G}'.format(0.000031415926))
print('{:.3n}'.format(0.000031415926))
print('{:1g}'.format(3.1415926))
print('{:.2g}'.format(3.1415926))
print('{:.5G}'.format(3.1415926))
print('{:.3n}'.format(3.1415926))
3.2 实战技巧
锦囊1 格式转换
如果格式控制标记未提供，则默认为将其他格式数据格式化为字符型，如：
print('{}'.format(3.14)) # 使用format ()函数将浮点数转换成字符
import datetime # 将日期格式化为字符
print('{}'.format(datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")))
设置格式化为字符型值时，可以进行相应数据类型的格式化，字符串可以提供的参数为’s’ 。十进制整形提供的参数为’d’ 和’n’,二进制的参数为’b’,八进制的参数为’o’，十六进制小写的参数为 ‘x’ ，十六进制大写的参数为 ‘X’ ，ASC码的参数为’c’，浮点数的参数为’f’。主要进制转换符号说明如下：
-
‘b’ - 二进制。将数字以2为基数进行输出。
-
‘d’ - 十进制整数。将数字以10为基数进行输出。
-
‘o’ - 八进制。将数字以8为基数进行输出。
-
‘x’ - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
十进制、十六进制、八进制、二进制的转换示例如下：
print('{:d}'.format(100)) # 转换成字符型、整形和浮点数
print('{:s}'.format('100')) # 转换成字符型、整形和浮点数
print('{:c}'.format(97)) # 转换unicode成字符
print('{:d},{:f}'.format(100,12.2)) # 转换成整形和浮点数
print('{:8d},{:2d}，{:2f}'.format(314,314,314)) # 转换成指定格式的十进制
print('{:c},{:c},{:c}'.format(65,33,8712)) # 转换成unicode字符
print('{:c}{:c}{:c}{:c}'.format(39321,26684,37324,25289)) # 转换unicode成字符
print('{:o},{:x}，{:X}'.format(12,12,12)) # 将十进制转换成八进制和十六进制
如果要将十六进制、八进制、二进制的数字转换为十进制数，一定要标注进制前缀，如"0x"“0o”“0b”，示例代码如下：
print('{:d}'.format(0X5A)) # 十六进制数5A转换成10进制数，0X代表十六进制数
print('{:8d}'.format(0B011101)) # 二进制数转换成10进制数，0B代表二进制数
print('{:d}'.format(0O34)) # 八进制数转换成10进制数，0O代表八进制数
print('{:08d}'.format(0O123456)) # 16制数123456转换成10进制数，不足用0填充
print('{:*>8d}'.format(+0X1234)) # 16进制数1234转换成10进制数，右对齐，不足用*
保留进制前缀，#为进制标志，对于进制数，在进制符前加#，输出时会带上进制前缀，即显示0b,0o,0x，示例代码如下：
print("{:#x}".format(123)) # 在进制符前加#，输出时会带上进制前缀
print("{:#o}".format(28)) # 在进制符前加#，输出时会带上进制前缀
print("{:#b}".format(15)) # 在进制符前加#，输出时会带上进制前缀
锦囊2 格式化十进制整数
格式化整形数值可以提供的参数有’d’、 ’n’,两者相同相同。和format()函数不同，使用str.format()方法格式化数值时，被格式化的数值必须是整数，不能是浮点数。常用应用如下：
print('{:}'.format(122)) # 格式参数为空,默认为10进制
print('{:d}'.format(122)) # 原来是十进制数，转换后为原值
print('{:6d}'.format(122)) # 转换为6位十进制数，空余部分用空格填充
print('{:-6d}'.format(122)) # 转换为6位带符号十进制数，在符号前填充空余部分空格
print('{:08d}'.format(122)) # 转换为8位十进制数，空余部分填充0
print('{:+8d}'.format(122)) # 转换为8位带符号十进制数，在符号前填充空余部分空格
print('{:-8d}'.format(122)) # 转换为8位十进制数，空余部分填充空格
print('{:=8d}'.format(-122)) # 转换为8位十进制数，负号后空余部分填充空格
print('{:=8d}'.format(122)) # 转换为8位十进制数，空余部分填充空格
print('{:*<8d}'.format(122)) # 转换为8位十进制数，左对齐，空余部分填充*
print('{:#>8d}'.format(122)) # 转换为8位十进制数，右对齐，空余部分填充#
print('{:n}'.format(122)) # 原来是十进制数，转换后为原值
print('{:6n}'.format(122)) # 转换为6位十进制数，空余部分用空格填充
print('{:-6n}'.format(122)) # 转换为6位带符号十进制数，在符号前填充空余部分空格
对于整数来说，加、减、乘、除是最基本的操作，对整数进行格式化后可以直接连接成算数式。下面是一些简单的计算操作，代码如下：
print('{:d}={:2d}={:3d}'.format(122,122,122)) # 8位整数显示，不足部分整数前用空格填充
print('{:4d}+{:4d}={:4d}'.format(25,10,35)) # 格式化为带符号整数显示数据
add1=[12,23,35,10,8] # 加数
add2=[7,19,6,211,790] # 被加数
for i in range(5): # 循环输出计算式
print('{:<5d}+{:5d}={:5d}'.format(add1[i],add2[i],add1[i]+add2[i])) # 加数设成左对齐
锦囊3 格式化浮点数
对于浮点数类型，可以提供的格式化参数有 ‘e’ 、‘E’、 ‘f’ 、‘F’、 ‘g’、 ‘G’ 、‘%’ 等。本锦囊主要讲解用 f 格式化浮点类型的方法。使用 f 格式化浮点类型时，可以在其前边加上精度，控制输出浮点数的值；可以设置宽度控制数字的占位宽度。如果输出位数大于宽度，就按实际位数输出，如果输出位数小于宽度，则用占位符填充不足部分；也可以为浮点数指定符号，+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格，在幅负数前加 -；- 与什么都不加（{:f}）时一致：{:f}默认保留6位小数。 {:。3f}表示浮点数的精度为3（小数位保留3位），{:.f}是错误，必须在小数点后书写数字。常用示例代码如下：
print('{:f}'.format(628)) # 格式化为保留1位小数的浮点数
print('{:.1f}'.format(628)) # 格式化为保留1位小数的浮点数
print('{:.2f}'.format(628)) # 格式化为保留2位小数的浮点数
print('{:.1f}'.format(3.14159)) # 格式化为保留1位小数的浮点数
print('{:.5f}'.format(3.14159)) # 格式化为保留5位小数的浮点数
print('{:>8.3f}'.format(-3.14159)) # 格式化为保留1位小数的浮点数
print('{:<8f}'.format(3.1415926535898,'f')) # 默认精度保留6位小数
print('{:f}>{:.4f}>{:.2f}'.format(3.1415926,3.1415926,3.1415926))
print('{:2f}-{:2f}={:2f}'.format(12.2345,10,2.2345)) # 格式化为带符号整数显示数据
在计算式中，可以通过格式化统一浮点数的精度（小数位数）。通常是将浮点数格式化为包含两位小数的浮点数。下面是一些经典的应用，代码如下：
one=[3.2345,6,5.123,12.5678,21] # 计算数
two=[18.54,43.67564,3.1315,21.21,7.543] # 计算数
thr=[9.1287,1.876,6.345,21.654,7] # 计算数
str='{:.2f}{:}{:.2f}{:}{:.2f}={:.2f}'
for i in range(5): # 循环输出计算式
str=('{0:.2f}+{1:.2f}*{2:.2f}={3:.2f}')
x='{:.2f}' # 计算精度
all=float(x.format(one[i]))+float(x.format(two[i]))*float(x.format(thr[i]))
print(str.format(one[i],two[i],thr[i],all))
锦囊4 格式化百分数
在格式化解释中单独或者在精度之后添加“%”号，可以实现用百分数显示浮点数，如：
print('{:%}'.format(0.161896)) # 将小数格式化成百分数
print('{:.2%}'.format(0.161896)) # 格式化为保留两位小数的百分数
print('{:.6%}'.format(0.0238912)) # 格式化为保留六位小数的百分数
print('{:.2%}'.format(2/16)) # 格式化为保留两位小数的百分数
print('{:.1%}'.format(3.1415926)) # 格式化为保留一位小数的百分数
print('{:.0%}'.format(0.161896)) # 格式化为保留整数的百分数
print('{:8.6%}'.format(0.0238912)) # 格式化为保留六位小数的八位百分数
print('{:8.3%}'.format(0.0238912)) # 格式化为保留三位小数的八位百分数
锦囊5 格式化科学记数法
如果要将浮点数采用科学技术法表示，可以在格式化解释中使用“e”和“E”或者“g”和“G”。‘e’ 为通用的幂符号，用科学计数法打印数字，用’e’表示幂。使用’g’时，将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
#####e和E
print('{:e}'.format(3141592653589)) # 科学计数法，默认保留6位小数
print('{:e}'.format(3.14)) # 科学计数法，默认保留6位小数
print('{:e}'.format(3.14,'0.4e')) # 科学计数法，默认保留6位小数
print('{:0.2e}'.format(3141592653589)) # 科学计数法，保留2位小数
print('{:0.2E}'.format(3141592653589)) # 科学计数法，保留2位小数，大写E表示
#####g和G
print('{:F}'.format(3.14e+1000000)) # 小数点计数法，无穷大转换成大小字母
print('{:g}'.format(3141592653589)) # 科学计数法，保留2位小数
print('{:g}'.format(314)) # 科学计数法，保留2位小数
print('{:0.2g}'.format(3141592653589)) # 科学计数法，保留2位小数，大写E表示
print('{:G}'.format(3141592653589)) # 小数点计数法，无穷大转换成大小字母
print('{:g}'.format(3.14e+1000000)) # 小数点计数法，无穷大转换成大小字母
锦囊6 格式化金额
format()函数提供千位分隔符用逗号还能用来做金额的千位分隔符。如果要实现通常格式化后金额前面带上相关货币的符号，需要在该函数前面手动加上相应货币符号。如：
print('${:.2f}'.format(1201398.2315)) # 添加美元符号，小数保留两位
print(chr(36) + '{:.2f}'.format(1201398.2315)) # ASCII码添加美元，小数保留两位
print( '¥{:,.2f}'.format(1201398.2315)) # 添加人民币符号，用千位分隔符进行区分
print( '£{:,.2f}'.format(888800)) # 添加英镑符号，用千位分隔符进行区分
print( '{:.2f}'.format(123.6612)) # 添加欧元符号，保留两位小数，千位分隔
print( chr(0x20ac) +'{:,.2f}'.format(1201398.2315)) # 使用16进制编码添加欧元
print(chr(36) + '{:.2f}'.format(1201398.2315)) # ASCII码加美元符号，小数保留两位
锦囊7 格式化字符
格式化字符主要包括截取字符串，字符串对齐方式显示，填充字符串等几个方面，下面举例如下：
print('{:M^20.3}'.format('PYTHON')) # 截取3个字符，宽度20居中，不足用‘M’填充
print('{:10}'.format("PYTHON",'10')) # 默认居左，不足部分用‘ ’填充
print('{:.3}'.format('mingrisoft.com')) # 截取3个字符，默认居左显示
print('{:>10}'.format("PYTHON")) # 居右显示，不足部分用‘ ’填充
s='mingrisoft.com'
print('{:>20}'.format(s)) # 右对齐，不足指定宽度部分用0号填充
print('{:>4}'.format(s)) # 右对齐，因字符实际宽度大于指定宽度4，不用填充
print('{:*>20}'.format(s)) # 右对齐，不足指定宽度部分用*号填充
print('{:0>20}'.format(s)) # 右对齐，指定0标志位填充
print('{:>20}'.format(s)) # 右对齐，没指定填充值，用默认值空格填充
print('{:0^30}'.format(s)) # 居中对齐，用+号填充不足部分
锦囊8 指定转化
转换字段 conversion field 的取值有三种，前面要加 !：
-
s：传递参数之前先对参数调用 str()
-
r：传递参数之前先对参数调用 repr()
-
a：传递参数之前先对参数调用 ascii()
可以指定字符串的转化类型：其中 “!r” 对应 repr()； “!s” 对应 str(); “!a” 对应 ascii()。
print("repr() shows quotes: {!r}; str() doesn't: {!s}".format('mingri', 'soft'))
print("joy is a cute {!s}".format("baby")) # !s 相当于对于参数调用str()
print("joy is a cute {!r}".format("baby")) # !s 相当于对于参数调用str()
print('I am {!s}!'.format('Bruce Lee 李小龙'))
print('I am {!r}!'.format('Bruce Lee 李小龙'))
print('I am {!a}!'.format('Bruce Lee 李小龙'))
锦囊9 格式化日期月份
format()函数也可以对日期和时间进行格式化，格式化时可以通过日期和时间格式符号进行设置，常用python中时间日期格式化符号如表1所示。常用操作代码如下：
import datetime
now=datetime.datetime.now()
print('{:%Y-%m-%d %H:%M:%S %A}'.format(now)) # 当前时间格式化为年月日+完整英文星期
print('{:%Y-%m-%d %H:%M:%S %a}'.format(now)) # 当前时间格式化为年月日+简写英文星期
# 中文年月日显示
print('{:%Y}'.format(now),'年','{:%m}'.format(now),'月','{:%d}'.format(now), '日')
# 中文时间显示
print('{:%H}'.format(now),'时','{:%M}'.format(now),'分','{:%S}'.format(now), '秒')
print('{:%Y-%m-%d %H:%M:%S %a}'.format(now)) # 当前时间格式化为年月日+简写英文星期
print('{:%Y-%m-%d}'.format(now)) # 当前时间格式化为标准年月日
print('{:%y-%m-%d}'.format(now)) # 当前时间格式化为短日期年月日
print('{:%Y<%m>%d}'.format(now)) # 当前时间格式化为长日期年月日， 间隔符为“<”和“>”
print('{:%c}'.format(now)) # 本地对应的年月日星期表示
import datetime
now=datetime.datetime.now()
print('{:%B}'.format(now)) # 本地完整的英文月份表示
print('现在是今年第{:%j}天'.format(now)) # 今天是一年中第几天
print('本周是今年第{:%U}周'.format(now)) # 本周是一年中第几周
print('{:%y%m%d}'.format(now)) # 无间隔符短年月日
print('{:%Y-%m}'.format(now)) # 长日期格式年月
print('{:%m-%d}'.format(now)) # 月日显示、
print('{:%m}'.format(now)) # 月份单独显示
print('{:%d}'.format(now)) # 日期单独显示
import datetime
now=datetime.datetime.now()
print('{:%H%M%S}'.format(now)) # 时分秒。无间隔符
print('{:%H:%M:%S}'.format(now)) # 标准时分秒
print('{:%H:%M:%S %I}'.format(now)) # 12小时制 时分秒
print('{:%H:%M}'.format(now)) # 时+分
print('{:%M%S}'.format(now)) # 时钟+分
print('{:%h}'.format(now)) # 只显示时钟点
print('{:%H:%M:%S %p}'.format(now)) # 日期显示按AM，PM显示
import datetime
now=datetime.datetime.now()
print('{:%a}'.format(now)) # 英文星期简写
print('{:%A}'.format(now)) # 英文星期完整显示
week=['星期日','星期一','星期二','星期三','星期四','星期五','星期六']
print(week[int('{:%w}'.format(now))]) # 中文星期
import datetime
dt = datetime.datetime(2019, 9, 9)
dm=datetime.datetime(2019, 9, 9, 12, 50,20)
# 将输入的日期按年月日和时间格式化，因时间没有输入，按0时处理
print('{:%Y-%m-%d %H:%M:%S}'.format(dt))
print('{:%Y-%m-%d}'.format(dt)) # 将输入的日期按年月日格式化
print('{:%Y-%m-%d %H:%M:%S}'.format(dm)) # 将输入的日期按年月日和时间格式化
import datetime
now=datetime.datetime.now()
print('{0:%Y%m%d}{1:03d}'.format(now,1)) # 年月日 +3位编号
print('{0:%Y%m%d}NO{1:03d}'.format(now,5)) # 年月日+NO+3位编号
print('{0:%d}NO{1:05d}'.format(now,8)) # 日期+NO+5位编号
print('{0:%H%M}NO{1:05d}'.format(now,8)) # 时钟+分 +NO+5位编号
for i in range(5): # 循环输出计算式
print('{0:%Y%m%d}NO{1:05d}'.format(now,i+1))
锦囊10 数据对齐
通过制表符“\t”，利用format()方法设置对齐字符串的宽度和对齐方式，可以很容易排列对齐数据，下面对世界500强企业进行对齐输出（数据保存在源文件目录下500.txt文件中），代码如下：
with open("500.txt", 'r') as fp:
lines=fp.readlines()
for line in lines:
list=line.strip().split(' ')
str=''
for item in list:
str=str +'\t{:10}'.format(item)
print(str)
对于常规的数据，使用通过制表符“\t”和通过format()方法设置宽度和对齐方式就可以很好地实现对齐，但对于中文字段较多，字段较长的数据，如果设置文字宽度不合适，就很容出现文字不对齐的情况，如输出2018年全球大学排名前20名，代码如下：
with open("dx.txt", 'r') as fp:
lines=fp.readlines()
for line in lines:
list=line.strip().split(',')
str='\t{:0>2}'.format(list[0])+'\t{:<6}'.format(list[1])+'\t{0:<16}'.format(list[2])+'\t{:<40}'.format(list[3])
print(str)
从上图可以看到，输出的一些数据没有对齐，主要问题是utf-8中中文占用3个字节，GBK中占用了2个字节，英文字符占用一个字节，所以设置文字宽度时统一按英文文字占用一个1字节设置就会造成文字宽度不一致的情况。如果设置中文字段宽度时宽度不够时采用中文空格编码chr(12288)填充，就可以很好地解决这个问题，代码如下：
with open("dx.txt", 'r') as fp:
lines=fp.readlines()
for line in lines:
list=line.strip().split(',')
str='\t{0:0>2}'.format(list[0])+'\t{0:{1}<5}'.format(list[3],chr(12288))+'\t{0:{1}<10}'.format(list[1],chr(12288))+'\t{0:<45}'.format(list[2])
print(str)
锦囊11 生成数据编号
对数据进行编号，也是对字符串格式化操作的一种方式，设置填充字符（编号通常设置0），设置对齐方式时可以使用<、>和^符号表示左对齐、右对齐和居中对齐，对齐填充的符号在“宽度”范围内输出时填充，如：
print('{:0>3}'.format(1))
print('{:0>5}'.format('03'))
print('a{:0>6}'.format(111))
要生成的编号通常比较复杂，如根据当天的日期建立编号，或者批量生成编号，或者将给定的批量数据中的数字转换成位数固定的编号，下面给出实现如上编号的实现方法：
import datetime
wx=datetime.datetime.now().date()
now=datetime.datetime.now()
print(str(wx)+'{:0>3}'.format(1)) # 年月日 +3位编号
print('{:%Y%m%d}{:0>3}'.format(now,1)) # 年月日 +3位编号
print('{:%Y%m%d}NO{:0>5}'.format(now,5)) # 年月日+NO+3位编号
print('{:%Y}NO{:0>5}'.format(now,5)) # 日期+NO+3位编号
print('{:%H%M}NO{:0>3}'.format(now,5)) # 时钟+分 +NO+3位编号
锦囊12 format的索引序号作为函数变量
Format()的索引序号可以在Format()的位置参数或关键字参数中给定，也可以把索引序号作为函数变量，动态添加，如对输入的数字格式化为5位编号，编写函数mark，变量num作为索引序号，调用时直接赋值给num变量即可，实现代码如下：
mark = "编号：{num:0>5d}".format
print(mark(num=3))
输出结果为：
编号：00003
调用mark函数可以实现批量输出格式化的编号，如输出10个5位编号，编号从0001到00009，代码如下：
mark = "编号：{num:0>5d}".format
for i in range(10):
print(mark(num=i))
锦囊13 {}内嵌{}
格式化标签模板中的格式设置参数也可以通过str.Format()方法的位置参数或关键字参数给定，但必须放在{}里面，如通过{}内嵌{}将位置参数2的值设置位置参数1（3.1415926）的小数位数为2，则格式化模板为{0:>.{1}f}，其中{1}指定的是第2个位置参数2。代码如下：
print('{0:>.{1}f} '.format(3.1415926,2)) # {1}对应位置参数2
输出结果为：
3.14
通过{}内嵌{}在批量处理数据时非常有用，可以方便的设置变量，不用按个修改模板参数中的值，如输出9*9的乘法口诀，可以设置输出口诀元素的宽度，如设置long为‘1d’或‘2d’，把long设置为位置参数即可。代码如下：
long='2d'
for i in range(1,10):
for j in range(1,10):
print("{0:<{3}}*{1:>{3}}={2:{3}}".format (i,j,i*j,long),end=" ")
print("")
锦囊14 format变形
可以简化为f’xxxx’形式，在字符串前加f以达到格式化的目的，在{}里加入对象，如下面的代码：
print('{0} {1}'.format('hello','world'))
可以简化为：
a = 'hello'
b = 'world'
print(f'{a} {b}')
522
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
