当前位置:   article > 正文

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

python f

目录
四、 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、实现进制(或格式)的转换与冒号:

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

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

运行结果:

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

  1. ne1=12.73
  2. ne2=15
  3. #对于f'',ne1为十进制浮点型时,不支持占位符d,ne2为整型的十进制整数d,支持占位符f。
  4. print(f'{ne1:f},{ne2:d}')
  5. print(f'{ne1:f},{ne2:f}')
  6. print('\n')
  7. #对于str.format(),ne1为十进制浮点型时,不支持占位符d,ne2为整型的十进制整数d,支持占位符f。
  8. print('{:f},{:d}'.format(ne1,ne2))
  9. print('{:f},{:f}'.format(ne1,ne2))
  10. print('{1:f},{0:f}'.format(ne1,ne2))
  11. print('\n')
  12. #对于str%()支持,支持占位符d与f之间的转换。
  13. print('%f,%d'%(ne1,ne2))
  14. print('%d,%f'%(ne1,ne2))

运行结果:

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

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

运行结果:

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

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

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

  1. sr1='你好,python\n'
  2. it1=12
  3. print(f'{sr1!r},{it1!r}')
  4. print(f'{sr1!a},{it1!a}')
  5. print(f'{sr1!s},{it1!s}')
  6. print('\n')
  7. print('{!r},{!r}'.format(sr1,it1))
  8. print('{1!r},{0!r}'.format(sr1,it1))
  9. print('{!a},{!a}'.format(sr1,it1))
  10. print('{1!a},{0!a}'.format(sr1,it1))
  11. print('{!s},{!s}'.format(sr1,it1))
  12. print('{1!s},{0!s}'.format(sr1,it1))
  13. print('%r,%r'%(sr1,it1))
  14. print('%a,%a'%(sr1,it1))
  15. print('%s,%s'%(sr1,it1))

运行结果:

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

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

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

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

       f''、str.format()格式化表达式使用占位符时通常都是要增加冒号:,str()格式化表达式使用占位符时通常要增加%。在没有指定宽度时,f''、str.format()、str()格式化表达式默认都是左对齐的。

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

运行结果:

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

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

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

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

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

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

运行结果:

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

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

运行结果:

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

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

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

  1. ne1=15.7634317
  2. ne2=15.7634317
  3. print(f'{ne1:12.2e},{ne2:6.3e}')
  4. print('\n')
  5. print('{:6.2e},{:12.3e}'.format(ne1,ne2))
  6. print('{1:10.2e},{0:11.5e}'.format(ne1,ne2))
  7. print('\n')
  8. print('%10.2e,%e'%(ne1,ne2))

运行结果:

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

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

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

运行结果:

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

  1. ne1=15.7634317
  2. sr1='abcde'
  3. print(f'{ne1:6.3},{ne1:6.3f},{sr1:6.2s},')
  4. 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%()的浮点数和整数的精度使用是有差异的。

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

运行结果:

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

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

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

  1. ne1=15.7634317
  2. ne2=15.7634317
  3. print(f'{ne1:+9.2f},{ne1:-9.2f},{-ne2:9.2f},{+ne2:9.2f}')
  4. print('\n')
  5. print('{:+9.2f},{:9.2f},{z:5.1f}'.format(ne1,-ne2,z=-3.26))
  6. print('{0:+9.2f},{1:-9.2f},{1:9.2f}'.format(ne1,+ne2))
  7. print('\n')
  8. print('%+9.2f,%-9.2f'%(ne1,ne2))
  9. 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是与宽度联用。

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

运行结果:

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

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

  1. ne1=15.763
  2. print(f'{ne1: .1f},{ne1: f}')
  3. print(f'{ne1: 5.1f}')
  4. print(f'{ne1: 2.1f}')
  5. print('\n')
  6. print('{: .2f}'.format(ne1))
  7. print('{:5.2f}'.format(ne1))
  8. print('{: 5.2f}'.format(ne1))
  9. print('\n')
  10. print('%        .2f'%ne1)
  11. print('%7.2f'%ne1)
  12. print('% 7.2f'%ne1)

运行结果:

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

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

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

  1. ne1=15.7634317
  2. ne2=15.7634317
  3. sr1='abcde'
  4. #f''中-只能对数字型由作用,但没作用。
  5. print(f'{ne1:9.2f},{ne2:.2f},{sr1:9.2s}')
  6. print(f'{ne1:-9.2f},{ne2:-.2f},{sr1:9.2s}')
  7. #下面实际等效于print(f'{ne1:f},{ne2:f},{sr1:s}')
  8. print(f'{ne1:-f},{ne2:-f},{sr1:s}')
  9. print('\n')
  10. #str.format()中-只能对数字型由作用,但没作用。
  11. print('{:2.2f},{:7.2f},{:9.2s}'.format(ne1,ne2,sr1))
  12. print('{:-2.2f},{:-7.2f},{:9.2s}'.format(ne1,ne2,sr1))
  13. #下面实际等效于print('{:f},{:f},{:s}'.format(ne1,ne2,sr1))
  14. print('{:-f},{:-f},{:s}'.format(ne1,ne2,sr1))
  15. print('\n')
  16. #str%()中用-后左对齐,原来默认的右对齐的变为左对齐,默认左对齐的不变。
  17. print('%9.2f,%.2f,%9.2s'%(ne1,ne2,sr1))
  18. print('%-9.2f,%-.2f,%-9.2s'%(ne1,ne2,sr1))
  19. #下面实际等效于print('%f,%f,%s'%(ne1,ne2,sr1))
  20. print('%-f,%-f,%-s'%(ne1,ne2,sr1))

运行结果:

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

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

运行结果:

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

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

运行结果:

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

  1. ne1=15.7634317
  2. ne2=15.7634317
  3. sr1='abcde'
  4. #f''中用^后居中。
  5. print(f'{ne1:^9.2f},{ne2:^.2f},{sr1:^3.2s}')
  6. #下面实际等效于print(f'{ne1:f},{ne2:f},{sr1:s}'),
  7. print(f'{ne1:^f},{ne2:^f},{sr1:^s}')
  8. print('\n')
  9. #str.format()中用^后居中。
  10. print('{:^2.2f},{:^7.2f},{:^9.2s}'.format(ne1,ne2,sr1))
  11. #下面实际等效于print('{:f},{:f},{:s}'.format(ne1,ne2,sr1))
  12. print('{:^f},{:^f},{:^s}'.format(ne1,ne2,sr1))

运行结果:

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

  1. ne1=15.7634317
  2. ne2=15.7634317
  3. sr1='abcde'
  4. print(f'{ne1:&<9.2f},{ne2:0<7.2f},{sr1:$<4.2s}')
  5. print(f'{ne1:&>9.2f},{ne2:c>7.2f},{sr1:$>4.2s}')
  6. print(f'{ne1:*^9.2f},{ne2:¥^7.2f},{sr1:$^4.2s}')
  7. print('\n')
  8. print('{:&<9.2f},{:0<7.2f},{:$<9.2s}'.format(ne1,ne2,sr1))
  9. print('{:&>9.2f},{:d>7.2f},{:$>9.2s}'.format(ne1,ne2,sr1))
  10. print('{:*^2.2f},{:&^7.2f},{:0^9.2s}'.format(ne1,ne2,sr1))

运行结果:

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

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

运行结果:

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

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

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

运行结果:

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

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

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

  1. ne1=1538.763
  2. ne2=12000
  3. ne3=15.763
  4. print(f'{ne1:,f};{ne2:,};{ne2:,d};{ne2:9,};{ne2:9,d};{ne3:,f}')
  5. print(f'{ne1:_f};{ne2:_};{ne2:_d};{ne2:9_.2f};{ne2:9_d}')
  6. print('\n')
  7. print('{:,f};{:_d};{:,f}'.format(ne1,ne2,ne3))
  8. print('{:9,.2f};{:9,.2f};{:,f}'.format(ne1,ne2,ne3))

运行结果:

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

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

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

  1. ne1=17
  2. print(f'{ne1:#b},{ne1:#o},{ne1:#x}')
  3. print(f'{ne1:#0b},{ne1:#0o},{ne1:#0x}')#也可以用#0
  4. print('\n')
  5. print('{0:#b},{0:#o},{0:#x}'.format(ne1))
  6. print('{0:#0b},{0:#0o},{0:#0x}'.format(ne1))#也可以用#0
  7. print('\n')
  8. #str%()不支持二进制。
  9. print('%#o,%#x'%(ne1,ne1))
  10. print('%#0o,%#0x'%(ne1,ne1))#也可以用#0

运行结果:

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

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

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

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

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

%Y

四位数的年份(0000-9999)

%y

两位数的年份(00-99)

%B

英文月份(比如:November)

%m

月份(01-12)

%D

月/日/年(比如:12/05/23)

%d

天(01-31)

%H

24制小时(00-23)

%h

简写字母月份(比如:Nov)

%I

12制小时(01-12)

%p

A.M.(上午)或P.M.(下午)

%M

分钟(00-59)

%j

一年的第几天(001-366)

%S

秒(00-59)

%f

微秒

%X

时间(比如:10:32:02)

%x

日期(比如:01/16/23)

%A

英文星期(比如:Sunday)

%a

简写字母星期(比如:Sun)

%W

一年的第几个星期(00-53),星期一为星期的开始

%w

星期几(0-6),星期日为星期的开始

%U

一年的第几个星期(00-53),星期日为星期的开始

%u

星期几(1-7),星期一为星期的开始

%Z

本地时区名称,若无则返回空字符,本地可理解为当前设备的。

%c

日期和时间的默认表示(比如:Sun Nov  5 12:32:02 2023)

%%

表示符号%

 

 

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

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

  1. import datetime
  2. de1= datetime.datetime(year=2023,month=11,day=5)
  3. print(de1)
  4. print(f'{de1:%B %D,%Y};{de1:%m %D,%Y};{de1:%b,%d,%y};{de1:%B,%Y,%d}')
  5. print('{0:%B,%d,%Y,%A},{0:%B-%d-%Y}'.format(de1))
  6. print('\n')
  7. de1= datetime.datetime(year=2023,month=11,day=5,hour=12,minute=32,second=2,microsecond=20)
  8. print(de1)
  9. print(f'{de1:%B %D,%Y,%H,%M,%S,%f,%a}')
  10. print('{:%m %D,%Y,%H,%M,%S,%f}'.format(de1))
  11. print('\n')
  12. de1= datetime.date.today()
  13. print(de1)
  14. print(f'{de1:%B %d,%Y};{de1:%b,%d,%Y};{de1:%B,%y,%d}')
  15. print('{0:%m,%D,%Y};{0:%b %d,%y}'.format(de1))
  16. print('\n')
  17. de1=  datetime.datetime.now()
  18. print(de1)
  19. de2=de1.date()#获取日期
  20. print(de2)
  21. de3=de1.time()#获取时间
  22. print(de3)
  23. print(f'{de1:%B,%D,%Y,%H,%M,%S}')
  24. print('{:%m,%D,%Y};{:%H:%M:%S}'.format(de2,de3))

运行结果:

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

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

声明:本文内容由网友自发贡献,转载请注明出处:【wpsshop】
推荐阅读
相关标签
  

闽ICP备14008679号