python数据类型（字符串String2）

五、字符的编码

       计算机只能处理数字（其实就是0和1），如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte）。所以一个字节能表示的最大的整数就是255（二进制8个1=十进制255），如果要表示更大的整数，就必须用更多的字节，比如两个字节可以表示65535，四个字节等等。

 

       由于计算机是美国发明的，因此最早的只有127个字母被编码到计算机里，也就是大小写英文字母，数字和一些符号，这个编码表被称为ASCII编码。

 

       要处理中文，显然一个字节是不够的，至少需要两个字节，而且不能和ASCII编码冲突，所以中国制定了GB2312编码，用来把中文编进去。

 

       可以想象，全世界有上百种语言，日本把日文编到Shift_JIS里，韩国把韩文编到EUC-kr里，各国有各国的标准，就不可避免地出现冲突，结果就是，再多语言混合的文本中就会显示乱码。

 

       Unicode应运而生，Unicode把所有语言都统一到一套编码里，这样就不会有乱码问题了。 Unicode标准在不断发展，最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要四个字节）。现在操作系统和大多数编程语言都直接支持Unicode。统一成Unicode之后，乱码问题解决了，但是写的文本基本上全是英文时，用Unicode编码比ASCII编码多一倍存储空间，在存储和传输上十分不划算。

 

       本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码，UTF-8编码把一个Unicode字符根据不同的数字大小编码成1~6个字节，常用的英文字母被编码成1个字节，汉子通常是3个字节，只有很生僻的字符才会被编码成4~6个字节。如果要传输的文本包含大量英文字符，用UTF-8编码就能节省空间。

 

       UTF-8编码还有一个额外的好处，就是ASCII编码实际上可以看成是UTF-8编码的一部分，所以只支持ASCII编程的大量历史遗留软件可以在UTF-8编码下继续工作。

 

       在现在计算机系统通用的字符编码工作方式：在计算机内存中，同意使用Unicode编码，当需要保存到硬盘或需要传输时，可以转换为UTF-8编码。 用记事本编辑时，从文件读取的UTF-8字符被转换为Unicode字符到内存；编辑完成后，保存时再把Unicode转换为UTF-8保存到文件；浏览网页时，服务器会把动态生成的Unicode内容转换为UTF-8在传输到浏览器；我们经常看到很多网页的源代码上有类似的<meta charset = “UTF-8”/>的信息，表示该网页用的是UTF-8编码。

 

字符和编码相互转换

 

       使用chr和ord方法，可以实现字符和编码之间的相互转换。

1. ord(字符串):返回该字符串的Unicode码。

2. chr(整数):返回该整数对应的字符串。

print(ord('a'))
# 97
print(ord('中'))
# 20013

　　

编码规则

 

       使用字符串的encode方法，可以将字符串按照指定的编码格式传唤成二进制；使用decode方法，可以将一个二进制数据按照指定的编码格式转换成为字符串。

s1='你'.encode('utf')   #将字符 你 按照utf8格式编译成为二进制
print(type(s1))   #<class 'byte'>
print(s1)    #b'xe4xbdxa0'

s2=s1.decode('utf8')   #将二进制按照utf8格式解码为字符串
print(s2)

　　

utf-8编码

 

       包含所有文字和二进制的对应关系，全球应用最为广泛的一种编码。本质上：utf-8是对unicode的压缩，用尽量少的二进制去与文字进行对应。

unicode码位范围              utf-8
0000-007F                   用1个字节表示
0080-07FF                   用2个字节表示
0800-FFFF                   用3个字节表示
10000-10FFFF                用4个字节表示

　　

小结：

1. 字节byte：计算机最小存储单位，等于8 位bit.

2. 字符：单个的数字，文字与符号。

3. 字符集(码表)：存储字符与二进制序列的对应关系。

4. 编码：将字符转换为对应的二进制序列的过程。

5. 解码：将二进制序列转换为对应的字符的过程。

6. 编码方式：

                --ASCII编码：包含英文、数字等字符，每个字符1个字节。

                --GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。

                --Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。

                --UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。

 

 六、成员运算符

 

       成员运算符（in和not in）可以用来快速的判断元素是否在指定的可迭代对象里。

 

       语法格式： 要判断的元素 in/not in 可迭代对象

 

       in运算符

 

              判断一个字符是否在指定的字符串里

msg='hello'
char=input('请输入一个字符：')
if msg.find(char) !=-1:   #使用字符串的find方法可以判断字符是否存在
    print('您输入的字符存在')
else:
    print('您输入的字符不存在')
    
if char in msg:   #使用in运算符可以更加方便的查看字符是否存在
    print('您输入的字符存在')
else:
    print('您输入的字符不存在') 
    
for s in msg:    #使用for循环遍历字符串查看字符是否存在
    if char==s:
       print('您输入的字符存在')
       break
else:
        print('您输入的字符不存在') 

　　

 七、格式化输出

 

（一）使用print（）函数

 

       1.格式化输出字符串和整数。例如：输出字符串'Hello world!'，并计算字符串的长度。

mystr = 'Hello world!'
print('%s的长度为%d' % (mystr, len(mystr)))
# Hello world!的长度为12

　　% 在字符串中表示格式化操作符，它后面必须附加一个格式化符号，具体说明如下表所示。

        %()元组可以包含一个或多个值，如变量或表达式，用来向字符串中%操作符传递值，元组包含元素数量、顺序都必须与字符串中%操作符一一对应，否则将抛出异常。%()元组必须位于字符串的后面，否则无效。如果字符串中只包含一个%操作符，那么也可以直接传递值。例如：

print("'Hello world!'的长度为%d" % len('Hello world!'))
# Hello world!的长度为12

　　

       2.格式化输出不同进制数。使用 print() 函数把数字输出为十六进制、十进制、八进制格式的字符串。

num = 123
print('十进制数%d转化为八进制为%o,转化为十六进制为%X' % (num, num, num))
# 十进制数123转化为八进制为173,转化为十六进制为7B

　　注意：格式化八进制用%o，格式化十六进制用%x或%X

　　二进制b:bin　　八进制o:oct　　十进制d:dec　　十六进制x:hex        

 

       3.格式化输出浮点数。把数字输出为不同格式的浮点数字符串。

pi = 3.1415926536
print('pi1=%10.3f' % pi)  # 总宽度为10，小数位精度为3
# pi1=     3.142

print('pi2=%.*f' % (2, pi))  # *表示从后面的元组中读取2，定义精度
# pi2=3.14

print('pi3=%010.3f' % pi)  # 用0填充空白
# pi3=000003.142

print('pi4=%-10.3f' % pi)  # 左对齐，总宽度10个字符，小数位精度为3
# pi4=3.142

print('pi5=%+f' % pi)  # 在浮点数前面显示正号,默认小数精度为6
# pi5=+3.141593

　　

       在格式化输出数字或字符串时，可以附加辅助指令来完善格式化操作。具体说明如下表所示：

 

（二）使用str.format（）方法

        % 操作符是传统格式化输出的基本方法，从 Python 2.6 版本开始，为字符串数据新增了一种格式化方法 str.format()，它通过 {} 操作符和 : 辅助指令来代替 % 操作符。

 

       通过位置索引

print('{0} {1}'.format('Beijing', 2008))
# Beijing 2008
print('{} {}'.format('Beijing', 2008))
# Beijing 2008
print('{1} {0} {1}'.format('Beijing', 2008))
# 2008 Beijing 2008

　　在字符串中可以使用 {} 作为格式化操作符。与 % 操作符不同的是，{} 操作符可以通过包含的位置值自定义引用值的位置，也可以重复引用。

 

       通过关键字索引

print('{city}  {year}'.format(city='Beijing', year=2008))
# Beijing  2008

　　

       通过下标进行索引

l = ['Beijing', 2008]
print('{0[0]} {0[1]}'.format(l))
# Beijing 2008

      通过使用 format() 函数这种便捷的 映射 方式，列表和元组可以 打散 成普通参数传递给 format() 方法，字典可以打散成关键字参数给方法。

      format() 方法包含丰富的格式限定符，附带在 {} 操作符中 : 符号的后面。

       1.填充与对齐

    : 符号后面可以附带填充的字符，默认为空格， ^、<、> 分别表示居中、左对齐、右对齐，后面附带宽度限定值。下面示例设计输出 8 位字符，并分别设置不同的填充字符和值对齐方式。

print('{:>8}'.format('BJ'))    # 总宽度为8，右对齐，默认空格填充
#        BJ

print('{:0>8}'.format('BJ'))   # 总宽度为8，右对齐，使用0填充
# 000000BJ

print('{:@<8}'.format('BJ'))   # 总宽度为8，左对齐，使用@填充
# BJ@@@@@@

　　

       2.精度与类型f

print('{:.3f}'.format(3.1415927))
# 3.142

　　其中 .3f 表示小数点后面的精度为 3，f 表示浮点数输出。

       3.进制数字输出

            使用b、d、o、x 分别输出二进制、十进制、八进制、十六进制数字。

num = 94
print('{:b}'.format(num))
# 1011110
print('{:o}'.format(num))
# 136
print('{:d}'.format(num))
# 94
print('{:x}'.format(num))
# 5e

　　

       4.千位分隔输出

           使用逗号（,）输出金额的千分位分隔符。

print('{:,}'.format(1234567890))
# 1,234,567,890

　　 

（三）详解format（）函数

 

        format()函数可以对数据进行格式化处理操作。语法格式如下：

        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一起使用，实现指定位数字符填充，通常格式如图1.2所示，填充效果及位置如图1.3所示。

 通常用 0、*、#、@ 等进行填充。如果不写填充值，则使用默认填充值，默认填充值为空格。代码如下：

print(format(3.14, '@<10'))     # 用@符号填充，宽度为10,左对齐
# 3.14@@@@@@

print(format(3.14, '@>10'))     # 用@符号填充，宽度为10,右对齐

# @@@@@@3.14

       (2) align(对齐方式)：指在 width(数字宽度) 内输出时的对齐方式，分别使用 <、>、^、= 4个符号表示左对齐、右对齐、居中对齐和数字填充（只用于数字，在符号后进行补齐)。
       (3) width(数字宽度)：指设定输出字符宽度，如果数据的实际位数比 width 指定宽度值大，则使用数据实际的长度。如果该值的实际位数小于指定宽度，则位数将设定的 fill 值填充或设定的 0 值填充，如果没有设置填充值，则用空格填充。　

 

s = "PYTHON"
print(format(s, '10')) # 没有标志符，如果是字符串则默认左对齐，不足宽度部分默认用空格填充
# PYTHON 
print(format(13.14, '10')) # 没有标志符，如果是数字则默认右对齐，不足宽度部分默认用空格填充
#       13.14
print(format(s, '0>10')) # 右对齐，不足指定宽度部分用0填充
# 0000PYTHON
print(format(s, '>04')) # 右对齐，因字符实际宽度大于指定宽度4，不用填充
# PYTHON
print(format(s, '*>10')) # 右对齐，不足部分用"*"填充
# ****PYTHON
print(format(s, '>010')) # 右对齐，不足部分用0填充
# 0000PYTHON
print(format(s, '>10')) # 右对齐，默认用空格填充
#       PYTHON
print(format(s, '<10')) # 左对齐，默认用空格填充
# PYTHON    
print(format(s, '<010')) # 左对齐，不足部分用0填充
# PYTHON0000
print(format(s, '@^10')) # 中间对齐，不足部分用'@'填充，宽度为10个空格
# @@PYTHON@@
print(format(13.14, '0<10')) # 左对齐，不足部分用0填充
# 13.1400000
print(format(13.14, '@^10')) # 中间对齐，不足部分用@填充
# @@13.14@@@
print(format(13.14, '0>10')) # 右对齐，不足部分用0填充
# 0000013.14
print(format(-13.14, '0=10')) # 右对齐，符号后面不足部分用0填充
# -000013.14

　　

       (4) precision(精度)：精度由小数点 . 开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。precision(精度) 通常和 type(类型) 配合起来使用。
       (5) type(类型)：表示输出字符串、整数和浮点数类型的格式规则，默认为字符型 s。对于整数类型，输出格式包括 7 种：

       b：输出整数的二进制方式。c：输出整数对应的 Unicode 字符。d：输出整数的十进制方式。n：输出整数的十进制方式。o：输出整数的八进制方式。x：输出整数的小写十六进制方式。当值为整数时和 d 类似，值为浮点数时和 g 类似。不同之处在于 n 会使用当前区域设置来插入适当数字分隔字符。X：输出整数的大写十六进制方式。

       对于浮点数类型，输出格式包括 7 种：

       e：输出浮点数对应的小写字母 e 的指数形式。E：输出浮点数对应的大写字母 E 的指数形式。f：输出浮点数的浮点表示形式，默认保留 6 位小数。F：输出浮点数的浮点表示形式，默认保留 6 位小数，无穷大转换成大写字母 INF。g：自动调整将整数、浮点数转换成浮点型或科学记数法表示(超过 6 位数用科学记数法)，并将其格式化到指定位置（如果是科学计数则是 e)。G：自动调整将整数、浮点数转换成浮点型或科学记数法表示(超过 6 位数用科学记数法)，并将其格式化到指定位置（如果是科学计数则是 E)。%：输出浮点数的百分形式。 运用一：格式转换

       使用 format() 函数可以转换格式。如果 format() 函数的参数format_spec 未提供，则默认为将其他格式数据格式化为字符型，和调用 str(value) 效果相同。如：

 

import datetime

print(format(3.14))
# 3.14
print(str(3.14))
# 3.14
print(format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
# 2021-02-02 08:17:20

　　设置参数 format_spec 的值，可以进行相应数据类型的格式化，字符串可以提供的参数为 s。十进制整型提供的参数为 d 和 n，二进制的参数为 b，八进制的参数为 o，十六进制小写的参数为 x，十六进制大写的参数为 X，ASIIC 码的参数为 c，浮点数的参数为 f。以上格式化后的数据类型都为字符型，举例如下：

 

print(format(12.2, 'f'))  # 转换成浮点数，默认为小数保留6位，输出：12.200000
print(format(12, 'd'))  # 转换成十进制，输出：12
print(format(13))  # 不带参数默认为十进制，输出：13
print(format(13, 'n'))  # 转换成十进制数，输出：13
print(format(13, 'b'))  # 转换成二进制，输出：1101
print(format(65, 'c'))  # 转换Unicode成字符，输出：A
print(format(97, 'c'))  # 转换Unicode成字符，输出：a
print(format(8750, 'c'))  # 转换Unicode成字符，输出：∮
print(format(12, 'o'))  # 转换成八进制，输出：14
print(format(13, 'x'))  # 转换成十六进制小写字母表示，输出：d
print(format(13, 'X'))  # 转换成十六进制大写字母表示，输出：D

　　

运用二：生成数据编号

       利用 format() 函数实现数据编号。对数据进行编号，也是对字符串格式化操作的一种方式，使用 format() 函数可以对字符串进行格式化编号。只需设置填充字符（编号通常设置 0)，设置对齐方式时可以使用 <、> 和 ^ 符号表示左对齐、右对齐和居中对齐，对齐填充的符号在 宽度 范围内输出时填充即可。对数字 1 进行 3 位编号，右对齐，需要设置 format() 函数的填充字符为 0，对齐方式为右对齐，宽度为 3。具体代码为：

 

print(format(1, '0>3'))  # 001
print(format(1, '>03'))  # 001
print(format(15, '0>5'))  # 00015

　　要生成的编号通常比较复杂，如根据当天的日期建立编号，或者批量生成编号，或者将给定的批量数据中的数字转换成位数固定的编号，下面给出实现编号的代码：

import datetime

# 时间+编号
wx = datetime.datetime.now().date()
now = datetime.datetime.now()
print(str(wx), format(1, '0>3'))  # 年-月-日 +3位编号，输出：2021-02-02 001
print(format(now, '%Y-%m-%d'), format(1, '0>3'))  # 年-月-日 +3位编号，输出：2021-02-02 001
print(format(now, '%Y%m%d'), 'NO' + format(1, '0>3'))  # 年-月-日+NO+3位编号，输出：20210202 NO001
print(format(now, '%d'), 'NO' + format(1, '0>3'))  # 日期 +NO+3位编号，输出：02 NO001
print(format(now, '%H%M'), 'NO' + format(1, '0>3'))  # 时-+分 +NO+3位编号，输出：0866 NO001

       批量生成编号：

for i in range(1, 6):
    print(format(i, '0>3'))
# 001
# 002
# 003
# 004
# 005

       要实现嵌套编号，如A001-A005、B001-B005、C001-005 的嵌套编号，代码如下：

for i in range(65,69):
    for j in range(1,6):
        data=chr(i)+format(j,'0>3')+'  '
        print(data,end=' ')
    print()
    
# A001   A002   A003   A004   A005   
# B001   B002   B003   B004   B005   
# C001   C002   C003   C004   C005   
# D001   D002   D003   D004   D005 

 

运用三：格式化十进制数

       对于不同的类型数据，format() 函数的参数 format_spec 提供的值都不一样，对于十进制整数，整型数值可以提供的参数有d、n。具体如下：

print(format(81, '8d'))  # 8位整数显示，不足部分整数前用空格填充
#        81
print(format(81, '+d'))  # 格式化为带符号整数显示数据
# +81
print(format(-81, '8d'))  # 格式化为8位带符号整数显示，补位空格放到符号前
#       -81
print(format(81, '=8d'))  # 格式化为8位正整数，用空格补位
#        81
print(format(-81, '=8d'))  # 格式化为8位负整数，不足部分在负号后填充
#-       81
print(format(81, '+8d'))  # 格式化为8位正整数，不足部分在符号前填充
#       +81
print(format(-81, '8d'))  # 格式化为8位负整数，不足部分在符号前填充
#       -81

print(format(81, '>10'))  # 右对齐，宽度为10个字符
#        81
print(format(81, '<10'))  # 左对齐，宽度为10个字符
#81
print(format(81, '010'))  # 用0填充空格，宽度为10个字符
#0000000081
print(format(81, '@<10'))  # 用“@”填充空格，宽度为10个字符
#81@@@@@@@@
print(format(81, '@>10'))  # 用“@”填充空格，宽度为10个字符
# @@@@@@@@@81
print(format(+81, '=10'))  # 右对齐，宽度为10个字符
#        81
print(format(81, '0^10'))  # 用0填充空格，宽度为10个字符
#0000810000

s = 125
print(format(s, '0>10'))  # 右对齐，不足指定宽度部分用0填充
# 0000000125
print(format(s, '>04'))  # 右对齐，不足指定宽度部分用0填充
# 0125
print(format(s, '*>10'))  # 右对齐，不足指定宽度部分用“*”填充
# *******125
print(format(s, '>010'))  # 右对齐，指定0标志位填充
# 0000000125
print(format(s, '>10'))  # 右对齐，没指定填充值，用默认值空格填充
#        125
print(format(s, '+^30'))  # 居中对齐，用“+”填充不足部分
# +++++++++++++125++++++++++++++
print(format(s, '*<8'))  # 右对齐，不足指定宽度部分用“*”填充
# 125*****
print(format(s, '08'))  # 右对齐，指定0标志位填充
# 00000125

运用四：格式化浮点数

       对于浮点数类型，可以提供的参数有e、E、f、F、g、G、n、%、None 等。
       用 f 表示浮点类型，可以在其前边加上精度控制，用于控制输出宽度。如果输出位数大于宽度，就按实际位数输出。还可以为浮点数指定符号，＋表示在正数前显示正号+。- 表示在负数前显示负号 - (- 与什么都不加（{:f}）时一致)。空格表示在正数前加空格，在负数前加 -，.3f 表示浮点数的精度为 3（小数位保留3位）。

print(format(628, '.1f'))  # 格式化为保留1位小数的浮点数，输出：628.0
print(format(628, '.2f'))  # 格式化为保留2位小数的浮点数，输出：628.00
print(format(3.14159, '.1f'))  # 格式化为保留1位小数的浮点数，输出：3.1
print(format(3.14159, '.2f'))  # 格式化为保留2位小数的浮点数，输出：3.14
print(format(3.14159, '.5f'))  # 格式化为保留5位小数的浮点数，输出：3.14159
print(format(-3.14159, '.3f'))  # 格式化为保留3位小数的浮点数，输出：-3.142
print(format(3.1415926535898, 'f'))  # 默认精度保留6位小数，输出：3.141593
# 默认精度保留6位小数，不足部分用空格填充，输出：3.141590
print(format(3.14159, 'f'))

print(format(3.14159, '+.3f'))  # 格式化为保留3位小数带符号的浮点数
# 3.142
print(format(3.14159, '>8.2f'))  # 右对齐，保留2位小数
#    3.14  
print(format(3.14159, '<10.2f'))  # 左对齐，宽度为10，保留2位小数，不足部分用空格填充
# 3.14
print(format(3.14159, '<.3f'))  # 左对齐，保留3位小数
# 3.142
print(format(3.14159, '@>10.3f'))  # 右对齐，用“@”填充不足位置
# @@@@@3.142
print(format(-3.14159, '=10.2f'))  # 格式化为保留2位小数的10位数，默认用空格填充
# -     3.14
print(format(-3.14159, '0=10.2f'))  # 格式化为保留2位小数的10位数，空格用0填充
# -000003.14
print(format(3.14159, '0^10.2f'))  # 保留2位小数的10位数，居中显示，空格用0填充
# 0003.14000

运用五： 格式化百分数

       在格式化解释中单独或者在精度之后添加 % 号，可以实现用百分数显示浮点数，如：

print(format(0.161896, '%'))  # 将小数格式化成百分数，输出：16.189600%
print(format(0.161896, '.2%'))  # 格式化为保留2位小数的百分数，输出：16.19%
print(format(0.0238912, '.6%'))  # 格式化为保留6位小数的百分数，输出：2.389120%
print(format(2 / 16, '.2%'))  # 格式化为保留2位小数的百分数，输出：12.50%
print(format(3.1415926, '.1%'))  # 格式化为保留1位小数的百分数，输出：314.2%
print(format(0.161896, '.0%'))  # 格式化为保留整数的百分数，输出：16%
print(format(0.0238912, '8.6%'))  # 格式化为保留6位小数的八位百分数，输出：2.389120%
print(format(0.0238912, '>8.3%'))  # 格式化为保留3位小数的八位百分数，输出：2.389%

　

运用六：格式化科学记数法

       如果要将浮点数采用科学记数法表示，可以在格式化模板中使用 e 和 E 或者 g 和 G。e 为通用的幂符号，用科学记数法打印数字，用 e 表示幂。使用 g 时，将数值以 fixed-point 格式输出。当数值特别大的时候，用幂形式输出。

#####e和E
print(format(3141592653589, 'e'))  # 科学记数法，默认保留6位小数，输出：3.141593e+12
print(format(3.14, 'e'))  # 科学记数法，默认保留6位小数，输出：3.140000e+00
print(format(3.14, '0.4e'))  # 科学记数法，默认保留4位小数，输出：3.1400e+00
print(format(3141592653589, '0.2e'))  # 科学记数法，保留2位小数，输出：3.14e+12
print(format(3141592653589, '0.2E'))  # 科学记数法，保留2位小数，采用大写E表示，输出：3.14E+12
#####g和G
print(format(3.14e+1000000, 'F'))  # 无穷大转换成大写字母，输出：INF
print(format(3141592653589, 'g'))  # 科学记数法，保留2位小数，输出：3.14159e+12
print(format(314, 'g'))  # 科学记数法，保留2位小数，输出：314
print(format(3141592653589, '0.2g'))  # 科学记数法，保留2位有效数字，采用小写e表示，输出：3.1e+12
print(format(3141592653589, 'G'))  # 科学记数法，保留5位小数，采用大写E表示，输出：3.14159E+12
print(format(3.14e+1000000, 'g'))  # 小数点计数法，无穷大转换成小写字母，输出：inf

　　

运用七：格式化金额

       format() 函数还能用来作金额的千位分隔符。如果要实现金额前面带上相关货币的符号形式的功能，需要在该函数前面手动加上相应货币符号。如：

print('$' + format(1201398.2315, '.2f')) # 添加美元符号，小数保留2位
# $1201398.23
print(chr(36) + format(1201398.2315, '.2f')) # ASCII码添加美元符号，小数保留2位
# $1201398.23
print('¥' + format(78088888, ',')) # 添加人民币符号，用千位分隔符区分金额
# ¥78,088,888
print('£' + format(7908.2315, '.2f')) # 添加英镑符号，用千位分隔符进行区分
# £7908.23
print('€' + format(7908.2315, ',.2f')) # 添加欧元符号，保留两位小数，千位分隔
# €7,908.23
print(chr(0x20ac) + format(1201398.2315, ',f')) # 使用十六进制编码添加欧元符号
# €1,201,398.231500

　　

运用八：格式化字符

       格式化字符主要包括截取字符串，字符串对齐方式显示，填充字符串等，代码如下：

 

print(format('PYTHON', 'M^20.3')) # 截取3个字符，宽度为20居中，不足用M填充
# MMMMMMMMPYTMMMMMMMMM
print(format("PYTHON", '10')) # 默认居左显示，不足部分用空格填充
# PYTHON 
print(format('www.cnblogs.net', '.3')) # 截取3个字符，默认居左显示
# www
print(format("PYTHON", '>10')) # 居右显示，不足部分用空格填充
#    PYTHON 
s = 'www.cnblogs.net'
print(format(s, '0>20')) # 右对齐，不足指定宽度部分用0填充
# 00000www.cnblogs.net
print(format(s, '>4')) # 右对齐，因字符实际宽度大于指定宽度4，不用填充
# www.cnblogs.net
print(format(s, '*>20')) # 右对齐，不足指定宽度部分用*填充
# *****www.cnblogs.net
print(format(s, '>020')) # 右对齐，指定0标志位填充
# 00000www.cnblogs.net
print(format(s, '>20')) # 右对齐，没指定填充值，用默认值空格填充
#      www.cnblogs.net
print(format(s, '+^30')) # 居中对齐，用+填充不足部分
# +++++++www.cnblogs.net++++++++

　　

运用九：进制转换

       进制转换主要是进行十进制、十六进制、八进制、二进制的转换，如果是十六进制、八进制、二进制数，转换前最好保留进制前缀，如 Ox/0o/0b，这样可以保证转换的准确性。主要进制转换符号说明如下：

       b：二进制。将数字以 2 为基数进行输出。d：十进制整数。将数字以 10 为基数进行输出。o：八进制。将数字以 8 为基数进行输出。x：十六进制。将数字 以16 为基数进行输出，9 以上的数字用小写字母。

       十进制、十六进制、八进制、二进制的转换代码如下：

print(format(77)) # 格式参数为空，默认为十进制
# 77
print(format(77, 'd')) # 原来是十进制数，转换后为原值
# 77
print(format(-77, 'd')) # 原来是十进制数，转换后为原值
# -77
print(format(77, '8d')) # 转换为8位十进制数，空余部分用空格填充
#       77
print(format(-77, '8d')) # 转换为8位十进制数，负数在负号前填充空余部分空格
#      -77
print(format(77, '+8d')) # 转换为8位带符号十进制数，在符号前填充空余部分空格
#      +77
print(format(-77, '08d')) # 转换为8位十进制数，负数在负号前填充空余部分空格
# -0000077
print(format(77, '+08d')) # 转换为8位带符号十进制数，在符号前填充空余部分空格
# +0000077
print(format(-77, '#8d')) # 转换为8位十进制数，加进制标志
#      -77

print(format(-77, '=8d')) # 转换为8位十进制数，空余部分填充空格
# -     77
print(format(+77, '=8d')) # 转换为8位十进制数，空余部分填充空格
#       77
print(format(+77, '*=8d')) # 转换为8位十进制数，空余部分填充*
# ******77
print(format(+77, '*=+8d')) # 转换为8位带符号十进制数，符号与数据之间填充*
# +*****77
print(format(-77, '#=8d')) # 转换为8位十进制数，在符号与空余部分填充#
# -#####77
print(format(+77, '*<8d')) # 转换为8位十进制数，左对齐，空余部分填充*
# 77******
print(format(-77, '#>8d')) # 转换为8位十进制数，右对齐，空余部分填充#
# #####-77

print(format(0X5A, 'd')) # 十六进制数5A转换成十进制数，0X代表十六进制数
# 90
print(format(0B011101, '+8d')) # 二进制数011101转换成十进制数，0B代表二进制数
#      +29
print(format(0O34, 'd')) # 八进制数34转换成十进制数，0O代表八进制数
# 28
print(format(0O123456, '08d')) # 十六制数123456转换成十进制数，不足用0填充
# 00042798
print(format(+0X1234, '*>8d')) # 十六进制数1234转换成十进制数，右对齐，不足用*
# ****4660

　　对于带有进制前缀的数，如 0x、0o、0b，可以直接在后面加上 x、o、b 进行删除。

print(format(0X5A, 'x')) # 去除十六进制数的前缀，输出：5a
print(format(0B011101, 'b')) # 去除二进制数的前缀，输出：11101
print(format(0O34, 'o')) # 去除八进制数的前缀，输出：34

　　

运用十：格式化日期和时间

       format() 函数也可以对日期和时间进行格式化，格式化时可以通过日期和时间格式符号进行设置，Python 中常用的时间日期格式化符号如表 1.1 所示。

 

 常用操作代码如下：

import datetime

now = datetime.datetime.now()
print(format(now, '%Y-%m-%d %H:%M:%S %A'))  # 当前时间格式化为年-月-日+完整英文星期
# 2021-02-02 10:51:02 Tuesday
print(format(now, '%Y-%m-%d %H:%M:%S %a'))  # 当前时间格式化为年-月-日+简写英文星期
# 2021-02-02 10:51:02 Tue

print(format(now, '%Y'), '年', format(now, '%m'), '月', format(now, '%d'), '日')  # 中文年-月-日显示
# 2021 年 02 月 02 日
print(format(now, '%H'), '年', format(now, '%M'), '分', format(now, '%S'), '秒')  # 中文时间显示
# 10 年 51 分 02 秒
print(format(now, '%Y-%m-%d %H:%M:%S %a'))  # 当前时间格式化为年-月-日+简写英文星期
# 2021-02-02 10:51:02 Tue
print(format(now, '%Y-%m-%d'))  # 当前时间格式化为标准年-月-日
# 2021-02-02
print(format(now, '%y-%m-%d'))  # 当前时间格式化为短日期年-月-日
# 21-02-02
print(format(now, '%Y<%m>%d'))  # 当前时间格式化为长日期年-月-日，间隔符为“<”和“>”
# 2021<02>02
print(format(now, '%c'))  # 本地对应的年-月-日星期表示
# Tue Feb  2 10:51:02 2021
print(format(now, '%B'))  # 本地完整的月份表示，输出：February
# February
print('现在是今年第', format(now, '%j'), '天')  # 今天是一年中第几天，输出：现在是今年第 033 天
# 现在是今年第 033 天
print('本周是今年第', format(now, '%U'), '周')  # 本周是一年中第几周，输出：本周是今年第 05 周
# 本周是今年第 05 周
print(format(now, '%y%m%d'))  # 无间隔符短日期格式年月日，输出：210202
# 210202
print(format(now, '%Y-%m'))  # 长日期格式年-月，输出：2021-02
# 2021-02
print(format(now, '%m-%d'))  # 月-日显示，输出：02-02
# 02-02
print(format(now, '%m'))  # 月份单独显示，输出：02
# 02
print(format(now, '%d'))  # 日期单独显示，输出：02
# 02
print(format(now, '%H%M%S'))  # 无间隔符，输出：105102
# 105102
print(format(now, '%H:%M:%S'))  # 标准时-分-秒，输出：10:51:02
# 10:51:02
print(format(now, '%I:%M:%S %I'))  # 12小时制时-分-秒，输出：10:51:02 10
# 10:51:02 10
print(format(now, '%H:%M'))  # 时+分，输出：10:51
# 10:51
print(format(now, '%M%S'))  # 分+秒，输出：5102
# 5102
print(format(now, '%H'))  # 只显示小时，输出：10
# 10
print(format(now, '%H:%M:%S %p'))  # 日期显示按AM，PM显示，输出：10:51:02 AM
# 10:51:02 AM
print(format(now, '%a'))  # 英文星期简写，输出：Tue
# Tue
print(format(now, '%A'))  # 英文星期完整显示，输出：Tuesday
# Tuesday
week = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六']
print(week[int(format(now, '%w'))])  # 中文星期，输出：星期二
# 星期二
dt = datetime.datetime(2020, 5, 9)
dm = datetime.datetime(2020, 5, 9, 12, 50, 20)
# 将输入的日期按年-月-日和时间格式化，因时间没有输入，按0时处理
print(format(dt, '%Y-%m-%d %H:%M:%S'))
# 2020-05-09 00:00:00
print(format(dt, '%Y-%m-%d'))  # 将输入的日期按年-月-日格式化
# 2020-05-09
print(format(dm, '%Y-%m-%d %H:%M:%S'))  # 将输入的日期按年-月-日和时间格式化
# 2020-05-09 12:50:20
print(format(dm, '%Y-%m-%d'))  # 将输入的日期按年-月-日格式化
# 2020-05-09

wx = datetime.datetime.now()
print(str(wx), format(1, '0>3'))  # 年-月-日 +3位编号
# 2021-02-02 10:51:02.390395 001
print(format(now, '%Y-%m-%d'), format(1, '0>3'))  # 年-月-日 +3位编号
# 2021-02-02 001
print(format(now, '%Y%m%d'), 'NO' + format(1, '0>3'))  # 年-月-日 +NO+3位编号
# 20210202 NO001
print(format(now, '%d'), 'NO' + format(1, '0>3'))  # 日期 +NO+3位编号
# 02 NO001
print(format(now, '%H%M'), 'NO' + format(1, '0>3'))  # 时钟+分 +NO+3位编号
# 1051 NO001

　　 

（四）使用f-string方法

       f-string 是 Python3.6 新增的一种字符串格式方法，由于前面已经介绍了多种格式化方式，大同小异，此处用简单的案例对其用法进行演示。

 

       使用 f-string 方法在字符串中嵌入变量和表达式

name = 'Python'
ver = 3.6
print(f'{name}-{ver}、{name}-{ver + 0.1}、{name}-{ver + 0.2}')
# Python-3.6、Python-3.7、Python-3.8000000000000003

　　表达式计算浮点数时发生溢出，可以使用特殊格式化修饰符限定只显示 1 位小数。

name = 'Python'
ver = 3.6
print(f'{name}-{ver}、{name}-{ver + 0.1}、{name}-{ver + 0.2:.1f}')
# Python-3.6、Python-3.7、Python-3.8

　　把十六进制数字 10 分别转换为用十进制、十六进制、八进制和二进制表示。

n = 0x10 # 十六进制数字10
# 输出：dec:16, hex:10, oct:16, bin:10000
print(f"dec:{n:d}, hex:{n:x}, oct:{n:0}, bin:{n:b}")

　　如果要在多行中表示字符串，可以使用下面示例方式，在每一行子串前面都加上 f 修饰符。

name = "Python" # 字符串
ver = 3.6 # 浮点数
s = f"{name}-" 
 f"{ver}"
print(s) # 输出：Python-3.6

　　转载于  https://www.jb51.net/article/204291.htm