Python中f‘‘、str.format()和str%()的字符串格式化详解(2)------格式占位符的使用，日期、时间格式使用

目录
四、 f''、str.format()和str%()格式化表达式中格式占位符的使用
1、实现进制(或格式)的转换与冒号:
2、实现对象的字符串形式转换与感叹号！
3、为对象指定宽度或精度
4、对对象取百分比
5、为对象增加正号+或负号-
6、为对象增加标志(flags)
五、 f''、str.format()和str%()格式化表达式的日期、时间格式使用

四、 f''、str.format()和str%()格式化表达式中格式占位符的使用

       前面我们使用str%()格式化表达式，占位符会增加符号%，表示该位置产生某种格式的数据，对于f''、str.format()格式化表达式使用占位符时采用的是其它符号，比如：冒号:，感叹号！。f''、str.format()格式化表达式使用占位符时大多数情形都是要增加冒号: (它一般表示使用占位符的意思)，就像str%()格式化表达式，占位符会增加符号%一样。下面重点说明f''、str.format()的占位符的使用，也会附带str%()格式化表达式的使用。f''字符串格式化通常称为f-string字符串格式化。

表1-1 常用格式占位符(格式转换符)

1、实现进制(或格式)的转换与冒号:

       在f''、str.format()格式表达式中使用格式占位符，通常会增加冒号:。其中，采用:b，:o，:x，能将十进制转换为二进制、八进制和十六进制。这里以八进制为例，下面是str%()、f''、str.format()格式化表达式的进制转换。

print(f'十进制转换为八进制:{23:o},{25:o}')
print('十进制转换为八进制:{:o},{:o}'.format(23,25))
print('十进制转换为八进制:{1:o},{0:o}'.format(23,25))
print('十进制转换为八进制:%o,%o'%(23,25))

运行结果：

        下面是整型与浮点型的转换。在Python中，浮点型默认7位小数，不足的默认用0填充。

ne1=12.73
ne2=15
#对于f'',ne1为十进制浮点型时,不支持占位符d,ne2为整型的十进制整数d,支持占位符f。
print(f'{ne1:f},{ne2:d}')
print(f'{ne1:f},{ne2:f}')
 
print('\n')
#对于str.format(),ne1为十进制浮点型时,不支持占位符d,ne2为整型的十进制整数d,支持占位符f。
print('{:f},{:d}'.format(ne1,ne2))
print('{:f},{:f}'.format(ne1,ne2))
print('{1:f},{0:f}'.format(ne1,ne2))
 
print('\n')
#对于str%()支持,支持占位符d与f之间的转换。
print('%f,%d'%(ne1,ne2))
print('%d,%f'%(ne1,ne2))

运行结果：

       注意，对于f''、str.format()格式化表达式的占位符是可以缺省的，当然与占位符有关的冒号:不能缺省，它表示使用占位符的意思，这时按默认占位符，但str%()中的占位符是不能缺省的。

ne1=12.73
ne2=15
sr1='abcde'
 
 
 
#占位符可以缺省,缺省时按默认的占位符。
print(f'{ne1:},{ne2:},{sr1:}')
 
print('\n')
print('{:},{:},{:}'.format(ne1,ne2,sr1))
print('{1:},{2:},{0:}'.format(ne1,ne2,sr1))

运行结果：

       为增强可读性，下面应用中，很少缺省占位符，但在缺省时，应该知道这一点。

2、实现对象的字符串形式转换与感叹号！

       在f''、str.format()格式表达式中使用r，a，s格式占位符，需要增加感叹号!，能把对象转换相应的字符串形式。其中，s也可以用在冒号:后面，也表示字符串格式，感叹号!主要针对占位符r，a。

sr1='你好,python\n'
it1=12
print(f'{sr1!r},{it1!r}')
print(f'{sr1!a},{it1!a}')
print(f'{sr1!s},{it1!s}')
 
print('\n')
print('{!r},{!r}'.format(sr1,it1))
print('{1!r},{0!r}'.format(sr1,it1))
print('{!a},{!a}'.format(sr1,it1))
print('{1!a},{0!a}'.format(sr1,it1))
print('{!s},{!s}'.format(sr1,it1))
print('{1!s},{0!s}'.format(sr1,it1))
 
print('%r,%r'%(sr1,it1))
print('%a,%a'%(sr1,it1))
print('%s,%s'%(sr1,it1))

运行结果：

3、为对象指定宽度或精度

       宽度(width)适合数字型和字符串型，宽度表示占位个数，宽度大于对象默认位数时才有效，当宽度小于或等于对象默认位数时，对象按默认位数。宽度(width)可以用表1-1占位符中的n表示，也即表1-1里的n.m中的n。

       当宽度大于对象默认位数时，若对象是数字型，f''、str.format()默认右对齐(向右边靠齐)，多的位数在左端填充空格(一个空格占一位)，若对象是字符串型，f''、str.format()默认左对齐，多的位数在右端填充空格，而对于str%()都是默认右对齐，多的位数在左端填充空格。

       另外，在python中，对于一般的浮点型(float)，或整型(int)转换为浮点型，对象默认的小数位数是7，小数位数不足的会自动0补充，构成7位小数，宽度是按这个基础来判断的。    

       f''、str.format()格式化表达式使用占位符时通常都是要增加冒号:，str()格式化表达式使用占位符时通常要增加%。在没有指定宽度时，f''、str.format()、str()格式化表达式默认都是左对齐的。在宽度里，对于整型、字符串可以缺省格式占位符，比如，3d可以写成3。

ne1=12.73
sr1='abcde'
 
print(f'{sr1:7s},{ne1:10f}')
print(f'{sr1:7},{ne1:10f}')
 
print('\n')
print('{:2f},{:7s}'.format(ne1,sr1))
print('{1:2s},{0:12f}'.format(ne1,sr1))
 
print('\n')
print('%2f,%2s'%(ne1,sr1))
print('%10f,%7s'%(ne1,sr1))

运行结果：

       精度(precision)在数学中表示保留小数位数，这里取广义，精度(precision)是针对数字型或字符串型来讲的。精度可以用表1-1占位符中的.m表示，也即表1-1里的n.m中的.m。

       对于浮点数来讲，精度是保留小数位数(个数，按四舍五入取舍)，当精度超过小数的位数时，补充0，而且精度不适合整型。

       对于字符串来讲，精度是保留字符的位数(个数)，当精度超过对象的位数，返回原对象。

       但对于整数，f''、str.format()的精度不适合整数，而str%()的精度对于整数来讲，当精度大于整数位数(个数)，多的左边增加0。

       精度与宽度不同，精度是有取舍的，可能会改变对象自身，而宽度是确定是否增加位数，不对对象自身造成改变。而且单独使用精度(不与宽度一起使用)，f''、str.format()、str%()都是左对齐(向左边靠齐)。

ne1=15.0928
ne2=627
sr1='abcde'
 
#f''精度不支持整数。
print(f'{ne1:.1f},{ne1:.2f},{ne2:.1f},{sr1:.1s}')
 
print('\n')
#str.format()精度不支持整数。
print('{:.1f},{:.2f},{:.2f},{:.2s}'.format(ne1,ne1,ne2,sr1))
print('{1:.1f},{2:.7s},{0:.5f}'.format(ne1,ne1,sr1))
 
print('\n')
#str%()对于整数的精度,当精度大于整数位数(个数),多的左边增加0。
print('%.1f,%.2f,%.4d,%.2s'%(ne1,ne1,ne2,sr1))
print('%.3d,%.3f,%.2d,%.8s'%(ne1,ne1,ne2,sr1))

运行结果：

       宽度和精度经常一起使用，这时候宽度是精度处理后的结果的作用，也即先做精度处理，然后根据这个处理的结果再做宽度处理(注意，不是对原对象进行宽度处理)。当宽度和精度一起使用时，f''、str.format()、str%()的字符串格式化的对齐由宽度确定。宽度和精度可以用表1-1占位符中的n.m表示。

ne1=12.73
ne2=15.0928
sr1='abcde'
 
print(f'{ne1:7.1f},{ne2:5.1f},{sr1:2.1s}')
 
print('\n')
print('{:3.2f},{:6.2f},{:1.2s}'.format(ne1,ne2,sr1))
print('{1:7.2f},{2:4.2s},{0:5.5f}'.format(ne1,ne2,sr1))
 
print('\n')
print('%3.5f,%5.1f,%2.8s'%(ne1,ne2,sr1))
 
print('%3.1f,%4.1f,%3.2s'%(ne1,ne2,sr1))
#上面书写形式等价于下面形式。
print('%*.1f,%*.1f,%*.2s'%(3,ne1,4,ne2,3,sr1))

运行结果：

       上面宽度和精度是针对整型、浮点型和字符串型的一般情形，宽度和精度还可以用在科学计数法和有效数字这种特别情形，宽度的使用原则同上，精度的使用稍有差异。

        科学计数法z*e**k，k是指数，e是底数，在计算机中，e相当于10， z是大于或等于1，且小于10，保留小数位数(个数)由z来确定。

        宽度和精度也可以用在科学计数法，科学计算法中占位符为e(或E)，精度是确定z保留的小数位数(个数)，然后宽度再对科学计数法进行判断处理。

ne1=15.7634317
ne2=15.7634317
 
print(f'{ne1:12.2e},{ne2:6.3e}')
 
print('\n')
print('{:6.2e},{:12.3e}'.format(ne1,ne2))
print('{1:10.2e},{0:11.5e}'.format(ne1,ne2))
 
print('\n')
print('%10.2e,%e'%(ne1,ne2))

运行结果：

       有效数字是针对数字型的。有效数字是指从该数的第一个非零数字起，直到末尾数字为止的数字。保留有效数字时遇到小数也是按四舍五入来取舍。精度与占位符g联用有保留有效数字的作用，此时，精度是指保留有效数字的位数(个数)，宽度再对这个结果进行判断处理。

       上面科学记数法中的有效数字也是由z来确定。在f''、str.format()的字符串格式化中的精度后面缺省占位符，会默认对象按有效数字处理(也即默认为g来处理)，精度表示保留有效数字的位数(个数)。在进行有效数字处理时，有时候会用到科学记数法，因为科学记数法中的有效数字是由z来确定，对于整数可以用它来表示有效数字。

ne1=15.7634317
ne2=15.7634317
ne3=12680
 
print(f'{ne1:12.2g},{ne2:6.3g},{ne3:6.3g}')
#精度后面缺省占位符,会默认对象按有效数字处理,精度表示保留有效数字的位数(个数)。
print(f'{ne1:12.2},{ne2:6.3},{ne2:6.3f},{ne2:6}')
 
print('\n')
print('{:2.2g},{:12.3g}'.format(ne1,ne2))
#精度后面缺省占位符,会默认对象按有效数字处理,精度表示保留有效数字的位数(个数)。
print('{1:10.2g},{0:11.5}'.format(ne1,ne2))
print('{:2.2},{:12.3}'.format(ne1,ne2))
 
print('\n')
print('%10.2g,%g'%(ne1,ne2))

运行结果：

         另外，对于f''的字符串格式化中的宽度和精度还可以用{整数}.{整数}表示。

ne1=15.7634317
sr1='abcde'
 
print(f'{ne1:6.3},{ne1:6.3f},{sr1:6.2s},')
print(f'{ne1:{6}.{3}},{ne1:{6}.{3}f},{sr1:{6}.{2}},{sr1:{6}.{2}s}')

运行结果：

       注意，上面代码中缺省占位符的，使用默认占位符，比如：6.3、{6}.{3}默认为有效数字的处理，{6}.{2}默认为字符串的处理。

4、对对象取百分比

       对对象取百分比，使用占位符%，对于f''、str.format()格式化表达式，不能有其它占位符，在执行时，无论是浮点数还是整数，自动先在数值的基础上扩大100倍，然后取精度，再增加一个百分比符号。

        而str%()需要在其它占位符后面用%%，在执行时，先执行其它占位符，再取精度，然后增加一个百分比符号，而没有扩大100倍。注意，str%()的浮点数和整数的精度使用是有差异的。

ne1=15.7634317
ne2=15
 
print(f'{ne1:.2%},{ne2:.2%}')
 
print('\n')
print('{:.2%},{:.2%}'.format(ne1,ne2))
 
print('\n')
#下面先取浮点数,再取精度,然后再增加符号%。
print('%.3f%%,%.3f%%'%(ne1,ne2))
#下面先取整数,再取精度,精度大于整数位数时,多的在左边增加0,然后再增加符号%。
print('%.3d%%,%.3d%%'%(ne1,ne2))

运行结果：

5、为对象增加正号+或负号-

      正负号是针对数字型对象而言的。+与占位符联用可以表示正号(也即在冒号:或%后面使用)，而且会显式+(即对象会增加符号+)，在对象(包括名称name)中增加+，不显式+。

      对象为负数，即使增加+，也不显示+，对象为正数，即使增加-，也不显示-，而且-与占位符联用不表示负号的意思，-与名称name联用才表示负号(对于关键字实参，直接在对象上增加-)，会显式-。

ne1=15.7634317
ne2=15.7634317
 
print(f'{ne1:+9.2f},{ne1:-9.2f},{-ne2:9.2f},{+ne2:9.2f}')
 
print('\n')
print('{:+9.2f},{:9.2f},{z:5.1f}'.format(ne1,-ne2,z=-3.26))
print('{0:+9.2f},{1:-9.2f},{1:9.2f}'.format(ne1,+ne2))
 
print('\n')
print('%+9.2f,%-9.2f'%(ne1,ne2))
print('%+9.2f,%9.2f'%(-ne1,-ne2))

运行结果：

       注意，这里讲的+、-表示正负号(也叫做sign设置)，而不是作为填充(fill)符号，下面会讲到填充符号。

6、为对象增加标志(flags)

       标志(flags) 表示某些约定的符号，格式里会产生这种符号或产生某种效果。这里把冒号: (或%)后面与占位符一起使用的其它符号都看作是标志(flags)，以减少过多的区分，其它位置的符号不看作是标志。下面主要从实现功能的角度进行区分，这样我们不再区分fill、align、sign、grouping_option，实际它们只是代表对应功能的符号的整体称呼。

(1)0与宽度联用，可以用0填充

      0与宽度联用，宽度大于对象位数时，多的位数用0填充(fill)，而不是默认用空格填充。对于str%()格式化表达式，0与宽度联用不适合字符串型。注意这里0是与宽度联用。

ne1=15.7634317
ne2=15.7634317
sr1='abcde'
lt1=[192, 168, 0, 1]
 
print(f'{ne1:09.2f},{ne2:02.2f},{sr1:09.2s}')
 
print('\n')
print('{:02.2f},{:07.2f},{:09.2s}'.format(ne1,ne2,sr1))
print('{1:02.3f},{0:09.5f},{2:07.3s}'.format(ne1,ne2,sr1))
#*lt1是一个位置参数,*具有解包作用,*lt1解包为三个数字类型的对象,
#也即三个整数的位置实参,参见前面关于解包、参数的知识。
#下面{}按顺序对应,省去了序数,X是十六进制,2是宽度(width),
#打印时默认右对齐,内容不够时用0在左边填充。
print('{:02X}{:02X}{:02X}{:02X}'.format(*lt1))
 
print('\n')
#对于str%()格式化表达式,0与宽度联用不适合字符串。
print('%09.2f,%02.2f,%09.2s'%(ne1,ne2,sr1))
print('%09.2f,%02.2f,%9.2s'%(ne1,ne2,sr1))

运行结果：

(2)对数字型对象的左侧手动添加一个空格

      当宽度大于对象(若有精度，应该取完精度后的对象)的位数，采用默认的填充空格，而手动添加的空格无效，反之，手动添加空格有效，而且，f''、str.format()的冒号:后面只能添加一个空格，str%()的符号%后面即使添加多个空格，也实际只一个空格有效。

ne1=15.763
 
print(f'{ne1: .1f},{ne1: f}')
print(f'{ne1: 5.1f}')
print(f'{ne1: 2.1f}')
 
print('\n')
print('{: .2f}'.format(ne1))
print('{:5.2f}'.format(ne1))
print('{: 5.2f}'.format(ne1))
 
print('\n')
print('%        .2f'%ne1)
print('%7.2f'%ne1)
print('% 7.2f'%ne1)

运行结果：

(3)控制左对齐、右对齐或居中对齐(-、<、>、^、=)及填充

       -与占位符联用，用来左对齐(向左边靠齐)，实际只适合str%()格式化表达式。-与占位符联用使得原来默认的右对齐变为左对齐，默认左对齐的不变。左对齐后，对于宽度的使用，宽度大于对象位数时，默认右边空格填充。不指定宽度和精度，-不产生作用，相当于按默认位数。

       -与占位符联用不表示负号的意思，-与名称name联用才表示负号(对于关键字实参，直接在对象上增加-)。

ne1=15.7634317
ne2=15.7634317
sr1='abcde'
 
#f''中-只能对数字型由作用,但没作用。
print(f'{ne1:9.2f},{ne2:.2f},{sr1:9.2s}')
print(f'{ne1:-9.2f},{ne2:-.2f},{sr1:9.2s}')
#下面实际等效于print(f'{ne1:f},{ne2:f},{sr1:s}')
print(f'{ne1:-f},{ne2:-f},{sr1:s}')
 
print('\n')
#str.format()中-只能对数字型由作用,但没作用。
print('{:2.2f},{:7.2f},{:9.2s}'.format(ne1,ne2,sr1))
print('{:-2.2f},{:-7.2f},{:9.2s}'.format(ne1,ne2,sr1))
#下面实际等效于print('{:f},{:f},{:s}'.format(ne1,ne2,sr1))
print('{:-f},{:-f},{:s}'.format(ne1,ne2,sr1))
 
print('\n')
#str%()中用-后左对齐,原来默认的右对齐的变为左对齐,默认左对齐的不变。
print('%9.2f,%.2f,%9.2s'%(ne1,ne2,sr1))
print('%-9.2f,%-.2f,%-9.2s'%(ne1,ne2,sr1))
#下面实际等效于print('%f,%f,%s'%(ne1,ne2,sr1))
print('%-f,%-f,%-s'%(ne1,ne2,sr1))

运行结果：

       <与占位符联用，用来左对齐，只适合f''、str.format()格式化表达式。<与占位符联用使得原来默认的右对齐的变为左对齐，默认左对齐的不变。左对齐后，对于宽度的使用，宽度大于对象位数时，默认右边空格填充。不指定宽度和精度，<不产生作用，相当于按默认位数。

ne1=15.7634317
ne2=15.7634317
sr1='abcde'
 
#f''中用<后左对齐,原来默认的右对齐的变为左对齐,默认左对齐的不变。
print(f'{ne1:<9.2f},{ne2:<.2f},{sr1:<9.2s}')
#下面实际等效于print(f'{ne1:f},{ne2:f},{sr1:s}')
print(f'{ne1:<f},{ne2:<f},{sr1:<s}')
 
print('\n')
#str.format()中用<后左对齐,原来默认的右对齐的变为左对齐,默认左对齐的不变。
print('{:<2.2f},{:<7.2f},{:<9.2s}'.format(ne1,ne2,sr1))
#下面实际等效于print('{:f},{:f},{:s}'.format(ne1,ne2,sr1))
print('{:<f},{:<f},{:<s}'.format(ne1,ne2,sr1))

运行结果：

       >与占位符联用，用来右对齐，只适合f''、str.format()格式化表达式。<与占位符联用使得原来默认的左对齐的变为右对齐，默认右对齐的不变。右对齐后，对于宽度的使用，宽度大于对象位数时，默认左边空格填充。不指定宽度和精度，>不产生作用，相当于按默认位数。

ne1=15.7634317
ne2=15.7634317
sr1='abcde'
 
#f''中用>后右对齐,原来默认的左对齐的变为右对齐,默认右对齐的不变。
print(f'{ne1:>9.2f},{ne2:>.2f},{sr1:>9.2s}')
#下面实际等效于print(f'{ne1:f},{ne2:f},{sr1:s}'),
print(f'{ne1:>f},{ne2:>f},{sr1:>s}')
 
print('\n')
#str.format()中用>后右对齐,原来默认的左对齐的变为右对齐,默认右对齐的不变。
print('{:>2.2f},{:>7.2f},{:>9.2s}'.format(ne1,ne2,sr1))
#下面实际等效于print('{:f},{:f},{:s}'.format(ne1,ne2,sr1))
print('{:>f},{:>f},{:>s}'.format(ne1,ne2,sr1))

运行结果：

       ^与占位符联用，用来居中对齐(中间对齐)，只适合f''、str.format()格式化表达式。^与占位符联用使得原来默认的左对齐或右对齐变为居中。居中后，对于宽度的使用，宽度大于对象位数时，默两边空格填充，偶数时两边填充是对称的，奇数时右边多一个。不指定宽度和精度，^不产生作用，相当于按默认位数。

ne1=15.7634317
ne2=15.7634317
sr1='abcde'
 
#f''中用^后居中。
print(f'{ne1:^9.2f},{ne2:^.2f},{sr1:^3.2s}')
#下面实际等效于print(f'{ne1:f},{ne2:f},{sr1:s}'),
print(f'{ne1:^f},{ne2:^f},{sr1:^s}')
 
print('\n')
#str.format()中用^后居中。
print('{:^2.2f},{:^7.2f},{:^9.2s}'.format(ne1,ne2,sr1))
#下面实际等效于print('{:f},{:f},{:s}'.format(ne1,ne2,sr1))
print('{:^f},{:^f},{:^s}'.format(ne1,ne2,sr1))

运行结果：

       上面<、>、^的左对齐、右对齐、居中统称为align设置，<、>、^可以用任何字符进行填充(fill)，比如：*、&、0、￥、$、a等。

ne1=15.7634317
ne2=15.7634317
sr1='abcde'
print(f'{ne1:&<9.2f},{ne2:0<7.2f},{sr1:$<4.2s}')
print(f'{ne1:&>9.2f},{ne2:c>7.2f},{sr1:$>4.2s}')
print(f'{ne1:*^9.2f},{ne2:￥^7.2f},{sr1:$^4.2s}')
 
print('\n')
print('{:&<9.2f},{:0<7.2f},{:$<9.2s}'.format(ne1,ne2,sr1))
print('{:&>9.2f},{:d>7.2f},{:$>9.2s}'.format(ne1,ne2,sr1))
print('{:*^2.2f},{:&^7.2f},{:0^9.2s}'.format(ne1,ne2,sr1))

运行结果：

       =与占位符联用，只适合f''、str.format()格式化表达式中数字型对象，按默认的对齐(比如：按宽度或精度的对齐)，但当=前面有符号(这里的符号不包括名称name)时，这个符号将放在最左侧。对于宽度的使用，右对齐后，宽度大于对象位数时，默认左边空格填充(若指定填充符号，按该符号填充)。

ne1=15.7634317
ne2=15.7634317
 
#=不仅可以使用符号填充,而且能对前面的负号-产生作用,使其放在最左侧。
print(f'{ne1:9.2f},{ne1:=9.2f},{ne2:*=9.2f},{ne2:*=2.2f}')
print(f'{-ne1:=9.2f},{-ne2:9.2f}')
#下面实际等效于print(f'{ne1:f},{ne2:f}'),
print(f'{ne1:=f},{ne2:=f}')
 
print('\n')
print('{:9.2f},{:&=9.2f}'.format(ne1,ne2))
print('{:9.2f},{:=9.2f}'.format(ne1,-ne2))
#下面实际等效于print('{:f},{:f}'.format(ne1,ne2))
print('{:=f},{:=f}'.format(ne1,ne2))

运行结果：

       =实际没有对齐效果，是按默认的对齐，但它能使前面的符号(这里的符号不包括名称name)放在最左侧。上面代码中的负号,对于上面讲到的<、>、^等对齐方式是不能产生类似效果的，<、>、^等对齐方式是把负号当着对象的局部，而=不是把负号看作对象的部分，实际把对象与负号分开看待。

       另外，=在f''格式化表达式中与name联用(若有冒号:，则=在冒号:前面)，表示符号=自身，类似赋值的符号。

ne1=15.7634317
sr1='abcd'
lt1=[1,2,3]
#下面使用了占位符,但缺省。
#占位符可以缺省,缺省时按默认的占位符。
#str.format()不支持下面的表达方式。
print(f'{ne1=:9.2f},{ne1=:9.2},{ne1:},{sr1=:.2s},{sr1=:.2},{sr1=:}')
print(f'{-ne1=:9.2f},{-ne1=:9.2},{-ne1:}')
 
print('\n')
#下面没用到冒号:,没用到占位符。
#下面前后有多少空格,都会在对应位置增加多少空格,
#但这里的空格不能用其它符号替代。
#str.format()不支持下面的表达方式。
print(f'{    ne1=   }')
print(f'{    sr1=   }')
 
print('\n')
#下面实际没用到冒号:,没用到占位符,与上面使用不同,
#下面的使用实际是增加了字符描述,前面已经讲述。
print(f'a={lt1[0]},b={lt1[1]}')
#str.format(),虽然format只有一个位置参数,但下面是对lt1局部取值,因而序数0不能缺省。
print('a={0[0]},b={0[1]}'.format(lt1))

运行结果：

       注意，上面代码中缺省占位符后，代码运行时按默认占位符执行，上面代码中9.2按默认为有效数字的科学记数法的处理。

(4)对对象的整数部分进行分组

      可以通过逗号,或下划线_对数字型的整数部分进行分组，以3位为一组，这种操作也叫做grouping_option分组设置。有宽度或精度时，符号,或_应该放在宽度的后面，放在精度的前面。分组实际对整型有效，对浮点型无效。

ne1=1538.763
ne2=12000
ne3=15.763
 
print(f'{ne1:,f};{ne2:,};{ne2:,d};{ne2:9,};{ne2:9,d};{ne3:,f}')
print(f'{ne1:_f};{ne2:_};{ne2:_d};{ne2:9_.2f};{ne2:9_d}')
 
print('\n')
print('{:,f};{:_d};{:,f}'.format(ne1,ne2,ne3))
print('{:9,.2f};{:9,.2f};{:,f}'.format(ne1,ne2,ne3))

运行结果：

         注意，上面代码中缺省占位符后，代码运行时按默认占位符执行。

(5)二、八、十六进制的对象显示对应的0b、0o、0x

       符号#(或#0)与进制占位符联用，使得二进制对象增加0b、八进制对象增加0o、十六进制对象增加0x。注意，str%()不支持二进制。

ne1=17
 
print(f'{ne1:#b},{ne1:#o},{ne1:#x}')
print(f'{ne1:#0b},{ne1:#0o},{ne1:#0x}')#也可以用#0
 
print('\n')
print('{0:#b},{0:#o},{0:#x}'.format(ne1))
print('{0:#0b},{0:#0o},{0:#0x}'.format(ne1))#也可以用#0
 
print('\n')
#str%()不支持二进制。
print('%#o,%#x'%(ne1,ne1))
print('%#0o,%#0x'%(ne1,ne1))#也可以用#0

运行结果：

      上面分别讲述了占位符的使用情况，我们可以几种功能一起使用，这里不列举实例，具体把上面的功能组合在一起使用即可。

五、 f''、str.format()和str%()格式化表达式的日期、时间格式使用

       对日期、时间的字符串格式化适合f''、str.format()格式化表达式，而且这里的日期、时间的格式符号不同于前面讲到的占位符，为了区分开来，这里称为日期格式符、时间格式符，日期格式符、时间格式符都会有一个符号%，再加上一个字母构成。f''、str.format()表示日期、时间格式，是冒号:与日期格式符、时间格式符联用。

        常用的日期、时间格式符如下表5-1所示。

表5-1 日期、时间格式符

       上面表5-1的日期、时间格式符一般适合f''、str.format()格式化表达式，f''、str.format()表示日期、时间在表达上有一定的局限，实际上，日期、时间的格式表示有对应的函数(或方法)，比如：datetime、time模块。

       python对日期和时间的获取有很多方式，这里不展开讨论，这里给一个代码实例来展现f''、str.format()对日期、时间的格式化表示，代码中的日期格式符、时间格式符代表的作用可以结合打印结果理解，日期格式符、时间格式符之间可以用符号隔开，一般可以用逗号，日期格式符、时间格式符的字母大小写代表不同的作用。

import datetime
 
de1= datetime.datetime(year=2023,month=11,day=5)
print(de1)
print(f'{de1:%B %D,%Y};{de1:%m %D,%Y};{de1:%b,%d,%y};{de1:%B,%Y,%d}')
print('{0:%B,%d,%Y,%A},{0:%B-%d-%Y}'.format(de1))
 
print('\n')
de1= datetime.datetime(year=2023,month=11,day=5,hour=12,minute=32,second=2,microsecond=20)
print(de1)
print(f'{de1:%B %D,%Y,%H,%M,%S,%f,%a}')
print('{:%m %D,%Y,%H,%M,%S,%f}'.format(de1))
 
print('\n')
de1= datetime.date.today()
print(de1)
print(f'{de1:%B %d,%Y};{de1:%b,%d,%Y};{de1:%B,%y,%d}')
print('{0:%m,%D,%Y};{0:%b %d,%y}'.format(de1))
 
print('\n')
de1=  datetime.datetime.now()
print(de1)
de2=de1.date()#获取日期
print(de2)
de3=de1.time()#获取时间
print(de3)
print(f'{de1:%B,%D,%Y,%H,%M,%S}')
print('{:%m,%D,%Y};{:%H:%M:%S}'.format(de2,de3))

运行结果：

        最后，欢迎你点击下面链接参与一个小问卷，你的举手之劳，让博主受宠若惊，不胜感激！

https://www.wjx.cn/vm/w42huU2.aspx#