Python笔记：知识点 数据类型操作与方法
文章目录
- 数据类型操作与方法
-
- 序列基本操作
- 字符串常用方法
- 字符串大小写转换
- 字符串格式输出
- 字符串搜索定位与替换
- 字符串联合与分割
- 字符串条件判断
- 字符串编码
- 转义字符
- str.format() 详解
-
- 说明
-
- 标识码{}
-
- formatspec组件
- 简单字段名
-
- 简单字段名的说明
- 省略字段名
- 数字形式的简单字段名
- 变量名形式的简单字段名
- 简单字段名的混合使用
- 使用元组和字典传参
- 复合字段名
-
- 说明
- 点号的使用
-
- 传递位置参数
- 传递关键字参数
- [] 方括号的使用
-
- 传递位置参数
- 传递关键字参数
- 转换字段
- 格式说明符
-
- 标准格式说明符的格式
- 填充与对齐方式
-
- 填充：
- 对齐方式的取值：
- 正负号
- # 号
- 最小宽度
- 分组选项
- 精度
- 类型码
-
- 字符串类型
- 整数类型
- 浮点数类型
- 补充说明
数据类型操作与方法
序列基本操作
| 操作符 | 描述 |
|---|---|
| s+t | 拼接两个序列 s 和 t |
| s * n 或n * s | 将序列s重复n次生成新序列 |
| s[i] | 索引，返回序列s的第i项 |
| s[start:end :step] | 切片，返回序列 s 从start到end （不包括end ）的步长为step的字符生成新的序列，step默认步长为1，返回序号从start到end的子序列。步长为-1，逆序返回。 |
| len(s) | 返回序列s的长度（包含元素的个数） |
| min(s,[,key, default]) | 返回序列 s的最小值，key关键字缺省时按元素值比较 |
| max(s,[,key, default]) | 返回序列s的最大值，key关键字缺省时按元素值比较 |
| s.count(x) | 序列s中x的个数 |
| s.index(x[, i[, j]]) | 序列中第一个x的索引值，i值表示从索引i处开始查找x，j表示x查找范围在i和j之间。 |
| x in s | 如果序列x与序列s中的任一子序列相等，返回True，否则返回False；当x与s的元素相等时返回True，否则返回False。 |
| x not in s | 如果序列x与序列s中的任何子序列都不相等，返回True，否则返回False |
字符串常用方法
| 方法名 | 描述 |
|---|---|
| str.upper() | 转换字符串str中所有字母为大写 |
| str.lower() | 转换字符串str中所有字母为小写 |
| str.split() | 通过指定分隔符对字符串进行切片，将一个字符串分裂成多个字符串列表，缺省时根据空格切分，可指定逗号或制表符等。 |
| str.join(seq) | 以字符串str作为分隔符，将序列 seq 中所有的元素合并为一个新的字符串 |
| str.find() | 参数是搜索的固定长度的子字符串，之后返回字符串出现处的偏移量【默认从前往后开始搜索 或者 未找到时返回 -1】 |
| str.replace(old, new[, count]) | 把字符串str中的 old 替换成 new，如果 count 指定，则替换不超过 count 次，否则有多个old子串时全部替换为new。 |
| for var in string | 字符串迭代，如果var在string中存在，则进行循环 |
字符串大小写转换
| 方法 | 描述 |
|---|---|
| str.upper() | 转换字符串str中所有字母为大写 |
| str.lower() | 转换字符串str中所有字母为小写 |
| str.capitalize() | 把字符串str的第一个字符大写 |
| str.casefold() | 返回一个字符串的大小写折叠（casefolded）的复制， casefold()类似于lower()，但是更进一步，因为它移除在字符串中的所有差异。例如，德语的小写字母’ß’对应于"ss"，由于它已经是小写，所以lower()将不做任何事，但casefold()会将它转换为"ss"。 |
| str.swapcase() | 翻转字符串str中的大小写字母。 |
| str.title() | 返回“标题化”的字符串str，将所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| str.zfill(width) | 返回一个用0填充到width的字符串Print(“-42”.zfill(5)) # -0042 |
| str.swapcase() | 用于对字符串的大小写字母进行转换。大写变小写，小写变大写。 |
字符串格式输出
| 方法 | 描述 |
|---|---|
| str.center(width[, fillchar]) | 返回一个原字符串居中，并使用空格填充至长度 width 的新字符串，fillchar默认为空格。 |
| str.ljust(width[, fillchar]) | 返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串 |
| str.zfill(width) | 返回长度为 width 的字符串，原字符串str右对齐，前面填充0 |
| str.expandtabs(tabsize=8) | 把字符串str中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
| str.format(mapping) | 格式化字符串 |
| str.format_map(mapping) | 与str.format(mapping)类似，只是mapping是直接使用的，而不是复制到一个字典。 |
字符串搜索定位与替换
| 方法 | 描述 |
|---|---|
| str.count(sub[, start[, end]]) | 返回 sub 在字符串str 里面出现的次数，如果start 或者 end 指定则返回指定范围内 sub出现的次数 |
| str.find(sub[, start[, end]]) | 检测 sub 是否包含在字符串 str 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
| str.replace(old, new[, count]) | 把字符串str中的 old 替换成 new，如果 count 指定，则替换不超过 count 次，否则有多个old子串时全部替换为new。 |
| str.strip([chars]) | 删除字符串首尾指定的字符chars，参数缺省时，删除首尾的空白字符（\t,\n,\r,\xob,\xoc等,结果仍是字符串） |
| str.index(sub[, start[, end]]) | 返回子串存在的起始位置。跟find()方法一样，只不过如果sub不在字符串 str中会报一个异常. |
| str.partition(sep) | 如果字符串sep在str中存在，用sep将str切分三段，返回一个三元组print(‘13907125566’.partition(‘0712’)) #(‘139’, ‘0712’, ‘5566’) |
| str.lstrip() | 截掉字符串 str左边的空格 |
| str.maketrans(x[, y[, z]]) | maketrans()方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| str.translate(table[, deletechars]) | 根据字符串 str给出的表(包含 256 个字符)转换字符串 str中的字符，要过滤掉的字符放到 deletechars参数中 |
| str.rfind(sub[, start[, end]]) | 类似于 find()函数，不过是从右边开始查找。 |
| str.rindex(sub[, start[, end]]) | 类似于 index()，不过是从右边开始。 |
| str.rjust(width[, fillchar]) | 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串。 |
| str.rpartition(sep) | 类似于 partition()函数，不过是从右边开始查找。 |
| str.rsplit(sep=None, maxsplit=-1) | 通过sep指定分隔符对字符串进行分割并返回一个列表，默认分隔符为所有空字符，包括空格、换行(\n)、制表符(\t)等。类似于 split() 方法，只不过是从字符串最后面开始分割。如果指定maxsplit数量max，则最多切分为max次。 |
| str.rstrip([chars]) | 删除字符串str末尾的指定字符（默认为空格）。 |
字符串联合与分割
| 方法 | 描述 |
|---|---|
| str.join(seq) | 以字符串 str作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| str.split(sep) | 通过指定分隔符对字符串进行切片，将一个字符串切分成多个字符串列表，缺省时根据空格切分，可指定逗号或制表符等。 |
| str.partition(sep) | 从第一次出现sep的位置起，把 字 符 串 str 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str)，如果 字符串 str中不包含sep则返回一个包含字符串本身的3元组，后面跟着两个空字符串。(string_pre_str , ’ ', ’ ') |
| str.splitlines([keepends]) | 按照行(’\r’, ‘\r\n’, ‘\n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
字符串条件判断
| 方法 | 描述 |
|---|---|
| str.isalnum() | 如果字符串str至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。 |
| str.isdigit() | 如果字符串str只包含数字（包括：Unicode数字，半角数字（单字节），全角数字（双字节），不包括罗马数字和汉字数字）则返回 True 否则返回 False。 |
| str.isnumeric() | 如果 字符串str中只包含数字字符（包括：Unicode数字，半角数字，全角数字，罗马数字，汉字数字，以及①⒂⒔等类似数字），则返回 True，否则返回 False。 |
| str.isdecimal() | 如果字符串str只包含十进制数字（包括：Unicode数字，半角数字，全角数字；但不包括罗马数字和汉字数字）则返回 True 否则返回 False。 |
| str.isalpha() | 如果字符串str至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。 |
| str.isascii() | 当字符串str为空或全是ASCII字符时，返回True |
| str.isidentifier() | 检测字符串是否是字母开头。 |
| str.islower() | 如果字符串str中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False。 |
| str.isprintable() | 如果字符串str是空串或其中的所有字符都是可打印，返回True，而则False。 |
| str.isspace() | 如果字符串str中只包含空格，制表符tab和回车，则返回 True，否则返回 False。 |
| str.istitle() | 如果字符串str是标题化的(见 title())则返回 True，否则返回 False。 |
| str.isupper() | 如果字符串str中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| str.startswith(prefix[, start[, end]]) | 检查字符串str是否是以 prefix 开头，是则返回 True，否则返回 False。如果start 和 end 指定值，则在指定范围内检查. |
| str.endswith(suffix[, start[, end]]) | 检查字符串str是否以 suffix 结束，如果 start 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False. |
字符串编码
| 方法 | 描述 |
|---|---|
| str.decode(encoding=’ utf-8’, errors=‘strict’) | 以 encoding 指定的编码格式解码字符串str，如果出错默认报一个ValueError的异常，除非 errors 指定的 是 ‘ignore’ 或者’replace’ |
| str.encode(encoding=“utf-8”, errors=“strict”) | 以 encoding 指定的编码格式编码字符串str，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ |
转义字符
| 转义字符 | 意义 | ASCII码值（十进制） |
|---|---|---|
| \a | 响铃(BEL) | 007 |
| \b | 退格(BS) ，将当前位置移到前一列 | 008 |
| \f | 换页(FF)，将当前位置移到下页开头 | 012（0x0c） |
| \n | 换行(LF) ，将当前位置移到下一行开头 | 010（0x0a） |
| \r | 回车(CR) ，将当前位置移到本行开头 | 013（0x0d） |
| \t | 水平制表(HT) （跳到下一个TAB位置） | 009（0x09） |
| \v | 垂直制表(VT) | 011（0x0b） |
| \\ | 代表一个反斜线字符’\’ | 092 |
| ’ | 代表一个单引号（撇号）字符 | 039 |
| " | 代表一个双引号字符 | 034 |
| ? | 代表一个问号 | 063 |
| \0 | 空字符(NUL) | 000 |
| \ddd | 1到3位八进制数所代表的任意字符 | 三位八进制 |
| \xhh | 1到2位十六进制所代表的任意字符 | 二位十六进制 |
| \n | 换行(LF) ，将当前位置移到下一行开头 | |
| \r | 回车(CR) ，将当前位置移到本行开头 | |
| \t | 水平制表(HT) （跳到下一个TAB位置） |
str.format() 详解
说明
str.format( 方法通过字符串中的花括号 {} 来识别替换字段replacement field，从而完成字符串的格式化。- 字段名分为简单字段名
simple field name和复合字段名compound field name。而转换字段和格式说明符都是可选的。 format创建并返回一个新的字符串对象，因为字符串是不可变的。- 在可能空的替换目标的标识码 { } 之后使用一个冒号，后面跟着可以指定字段大小、对齐方式和特定类型编码的格式化说明符——四个部分均可选，中间必须不带有空格。
标识码{}
-
形式化结构：
{*fieldname component !conversionflag : formatspec*} -
fieldname 是辨识参数的一个可选数字或关键词，可以省略以使用相对参数编号。
省略不写 {}
数字 {十进制非负整数}
变量名 {合法的Python标识符} -
component 是有着大于等于零个”.name"或“[index]”引用的字符串，可以被省略以使用完整的参数值。其中的引用用来获取参数的属性或索引值
-
conversionflag 如果出现则以 ！开始，后面跟着 r，s或者a，在这个值上分别调用repr、str、或ascii内置函数
-
formatspec如果出现则以 ：开始，后面跟着文本，指定如何表示该值，包括字段宽度、对齐方式、补零、小数精度等细节，并以一个可选的数据类型码结束。
formatspec组件
- formatspec组件格式：
［[fill]align][sign][#][0][width][,][.precision][typecode]
方括号表示可选组件，实际编写可以不添加
1、fill可以是除{或}之外的任意填充字符
2、align可以是 <,>,+或^，分别表示左对齐，右对齐，符号字符后的填充，或局中对齐
3、sign可以是+，-，或空格
4、而，（逗号）选项请求一个逗号表示千位分隔符
5、width表示字段宽度
6、.precision表示小数精度
7、typecode与%表达式中相重叠
简单字段名
简单字段名的说明
简单字段名有三种写法：
- 省略不写
{} - 数字
{十进制非负整数} - 变量名
{合法的Python标识符}
省略字段名
花括号内省略字段名，传递位置参数。
- 替换字段形式：
{} - 注意：花括号个数可以少于位置参数的个数，反之不然
#省略字段名传递位置参数
>>> print('我叫{}，今年{}岁。'.format('小明', 18))
我叫小明，今年18岁。
#花括号个数可以少于位置参数的个数
>>> print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
我爱吃香蕉和苹果。
#花括号个数多于位置参数的个数则会报错
>>> print('我还吃{}和{}。'.format('西红柿'))```
IndexError: tuple index out of range
数字形式的简单字段名
可以通过数字形式的简单字段名传递位置参数。
- 数字必须是大于等于 0 的整数。
- 带数字的替换字段可以重复使用。
- 数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组，通过字段名中的数字进行取值。
即 {0} 等价于 tuple[0]，所以花括号内的数字不能越界。
# 通过数字形式的简单字段名传递位置参数
>>> print('身高{0}，家住{1}。'.format(1.8, '铜锣湾'))
身高1.8，家住铜锣湾
# 数字形式的简单字段名可以重复使用。
>>>print('我爱{0}。\n她今年{1}。\n{0}也爱我。'.format('阿香', 17))
我爱阿香。
她今年17。
阿香也爱我。
# 体会把所有位置参数整体当成元组来取值
>>> print('阿香爱吃{1}、{3}和{0}。'.format('榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
"""
阿香爱吃臭豆腐、鲱鱼罐头和榴莲。
"""
# 尝试一下越界错误
>>> print('{1}'.format('错误用法'))
IndexError: tuple index out of range
变量名形式的简单字段名
使用变量名形式的简单字段名传递关键字参数。
- 关键字参数的位置可以随意调换。
#使用变量名形式的简单字段名传递关键字参数
print('我大哥是{name}，今年{age}岁。'.format(name='阿飞', age=20))
>>>我大哥是阿飞，今年20岁。
#关键字参数的顺序可以随意调换
>>>print('我大哥是{name}，今年{age}岁。'.format(age=20, name='阿飞'))
我大哥是阿飞，今年20岁。
简单字段名的混合使用
- 混合使用数字形式和变量名形式的字段名，可以同时传递位置参数和关键字参数。
- 关键字参数必须位于位置参数之后。
- 混合使用时可以省略数字。
- 省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。
#混合使用数字形式和变量名形式的字段名
#可以同时传递位置参数和关键字参数
>>>print('这是一个关于{0}、{1}和{girl}的故事。'.format('小明', '阿飞', girl='阿香'))
这是一个关于小明、阿飞和阿香的故事。
#但是关键字参数必须位于位置参数之后
>>>print('这是一个关于{0}、{1}和{girl}的故事。'.format( '小明', girl='阿香' , '阿飞'))
SyntaxError: positional argument follows keyword argument
#数字也可以省略
print('这是一个关于{}、{}和{girl}的故事。'.format('小明', '阿飞', girl='阿香'))
# 但是省略字段名不能和数字形式的字段名同时出现
>>> print('这是一个关于{}、{1}和{girl}的故事。'.format( '小明', '阿飞', girl='阿香'))
ValueError: cannot switch from automatic field numbering to manual field specification
使用元组和字典传参
- str.format() 方法还可以使用 元组 和 字典的形式传参，两者可以混合使用。
- 位置参数、关键字参数、元组和 字典 也可以同时使用，但是要注意，位置参数要在关键字参数前面，元组 要在 字典 前面。
#使用元组传参
>>>infos = '钢铁侠', 66, '小辣椒'
>>>print('我是{}，身价{}亿。'.format(*infos))
我是钢铁侠，身家66亿。
>>>print('我是{2}，身价{1}亿。'.format(*infos))
我是小辣椒，身家66亿。
#使用字典传参
>>>venom = {
'name': '毒液', 'weakness': '火'}
>>>print('我是{name}，我怕{weakness}。'.format(**venom))
我是毒液，我怕火。
#同时使用元组和字典传参
>>>hulk = '绿巨人', '拳头'
>>>captain = {
'name': '美国队长', 'weapon': '盾'}
>>>print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
>>>print('我是{name}, 我怕{1}。'.format(*hulk, **captain))
我是绿巨人, 我怕盾。
我是美国队长, 我怕拳头。
#同时使用位置参数、元组、关键字参数、字典传参
#注意：
#位置参数要在关键字参数前面
#元组要在字典前面
>>>tup = '鹰眼',
>>>dic = {
'weapon': '箭'}
>>>text = '我是{1}，我怕{weakness}。我是{0}，我用{weapon}。'
>>>text = text.format('tup', '黑寡妇', weakness='男人', dic)
>>>print(text)
我是黑寡妇，我怕男人。我是鹰眼，我用箭。
复合字段名
说明
- 同时使用了数字和变量名两种形式的字段名就是复合字段名。
- 复合字段名支持两种操作符：
- [] 方括号
- . 点号
点号的使用
传递位置参数
- 替换字段形式：
{数字.属性名} - 只有一个替换字段的时候可以省略数字
#复合字段名中使用点号传递对象属性
>>>class Person:
>>> def __init__(self, name, addr):
self.name = name
self.addr = addr
p = Person('辣妹子', '重庆')
#点号用法：传递位置参数
>>>print('我是{0.name}，家在{0.addr}。'.format(p))
我是辣妹子，家在重庆。
#当只有一个替换字段的时候可以省略数字
>>>print('{.name}辣！'.format(p))
辣妹子辣！
#试试传递文件对象的属性
>>>f = open('out.txt', 'w')
>>>print('文件名为：{.name}'.format(f))
>>>f.close()
文件名为：out.txt
传递关键字参数
- 替换字段形式：
{关键字参数名.属性名}
#点号用法：传递关键字参数
>>>print('我是{girl.name}，家在{girl.addr}。'.format(girl=p))
#和上一句等价
>>>print('我是{p.name}，家在{p.addr}。'.format(p=p))
我是辣妹子，家在重庆。
我是辣妹子，家在重庆。
[] 方括号的使用
传递位置参数
- 用列表传递位置参数
- 用元组传递位置参数
- 用字典传递位置参数
#方括号用法：用列表传递位置参数
>>>infos = ['阿星', 9527]
>>>food = ['霸王花', '爆米花']
>>>print('我叫{0[0]}，警号{0[1]}，爱吃{1[0]}。'.format(infos, food))
我叫阿星，警号9527，爱吃霸王花。
#方括号用法：用元组传递位置参数
>>>food = ('僵尸', '脑子')
>>>print('我叫{0[0]}，年龄{1}，爱吃{0[1]}。'.format(food, 66))
我叫僵尸，年龄66，爱吃脑子。
#方括号用法：用字典传递位置参数
>>>dic = dict(name='阿星', pid=9527)
>>>print('我是{[name]}！'.format(dic))
#多个替换字段，不能省略数字
>>>print('我是{0[name]}，警号{0[pid]}。'.format(dic))
我是阿星！
我是阿星，警号9527。
传递关键字参数
- 用列表传递关键字参数
- 用元组传递关键字参数
- 用字典传递关键字参数
# 方括号用法：传递关键字参数
>>>names = ['皮卡丘']
>>>dic = {
'name': '妙蛙花'}
>>>skills = ('十万伏特', '飞叶快刀')
>>>text = '我是{names[0]}，我会{skills[0]}。我是{dic[name]}，我会{skills[1]}。'
>>>text = text.format(names=names, skills=skills, dic=dic)
>>>print(text)
我是皮卡丘，我会十万伏特。我是妙蛙花，我会飞叶快刀。
转换字段
转换字段 conversion field的取值有三种，前面要加!：
- s ：传递参数之前先对参数调用
str() - r ：传递参数之前先对参数调用
repr() - a ：传递参数之前先对参数调用
ascii()
ascii() 函数类似 repr() 函数，返回一个可以表示对象的字符串。
但是对于非 ASCII 字符，使用 \x，\u 或者 \U 转义。
#转换字段
>>>print('I am {!s}!'.format('Bruce Lee 李小龙'))
>>>print('I am {!r}!'.format('Bruce Lee 李小龙'))
>>>print('I am {!a}!'.format('Bruce Lee 李小龙'))
I am Bruce Lee 李小龙!
I am 'Bruce Lee 李小龙'!
I am 'Bruce Lee \u674e\u5c0f\u9f99'!
格式说明符
- 在替换字段中，格式说明符前面有一个冒号
:：{字段名!转换字段:格式说明符} - 其中格式说明符本身可以是一个字段名，比如：
>>>print('{0:{1}}'.format(3.14159, '.4f'))
3.1416
标准格式说明符的格式
- 如果不通过重写
__format__方法来进行自定义的话，标准格式说明符的形式如下。其中 方括号是可选的。
[[fill]align][sign][#][0][width][grouping_option][.precision][type] - 中文形式可以写作：
[[填充]对齐方式][正负号][#][0][宽度][分组选项][.精度][类型码]
填充与对齐方式
填充：
- 只能是一个字符
- 不指定默认用空格填充
- 如果指定填充字符，则必须要同时指定对齐方式
对齐方式的取值：
<：左对齐>：右对齐^：居中=：在正负号（如果有的话）和数字之间填充，该对齐选项仅对数字类型有效。
它可以输出类似+0000120这样的字符串。- 注意：如果不给定最小宽度
width，对齐方式毫无意义。
正负号
- 正负号选项仅对数字类型生效
- 取值有三种：
+正数前面添加正号，负数前面添加负号-仅在负数前面添加负号（默认行为）- 空格：正数前面需要添加一个空格，以便与负数对齐
#正负号
>>>print('{:哈=+8.2f}'.format(3.14159))
>>>print('{:哈=+8.2f}'.format(-3.14159))
>>>print('{:哈=+8.2f}'.format(0))
>>>print('{:哈=+8.2f}'.format(-0))
+哈哈哈3.14
-哈哈哈3.14
+哈哈哈0.00
+哈哈哈0.00
# 号
- 给u二进制数加上 0b 前缀
- 给八进制数加上 0o 前缀
- 给十六进制数加上 0x 前缀
最小宽度
最小宽度 width：
- 如果不指定，最小字段宽度由内容决定，与内容相等
- 如果最小宽度前面有一个前导 0，意味着用 0 填充
这等价于指定了 0= 的填充和对齐方式
分组选项
分组选项 grouping_option 的取值有两种：
- 逗号
,：使用逗号对数字以千为单位进行分隔。n类型的数字可以使用本地化的分隔符。
n 类型在本机无法使用分组选项 ,
原因可能是中文没有数字分隔符
#n 类型使用本地化的分组选项 ,
#此项报错，我怀疑是因为中文没有数字的分隔符
>>>print('数字：{0:,n}'.format(6666))
ValueError: Cannot specify ',' with 'n'.
#使用 d 类型确实是可以的
>>>print('数字：{0:,d}'.format(6666))
数字：6,666
- 下划线
_：使用下划线对浮点数和d类型的整数以千为单位进行分隔。对于b、o、x和X类型，每四位插入一个下划线，其他类型都会报错。
#分组选项`_作用于 b 类型
>>>print('数字：{0:_b}'.format(0b100111011))
"""数字：1_0011_1011
#分组选项 _ 作用于 o 类型
>>>print('数字：{0:_o}'.format(0o426754316))
数字：4_2675_4316
#分组选项 _ 作用于 x 类型
>>>print('数字：{0:_x}'.format(0x2a846e98d))
数字：2_a846_e98d
#分组选项 _ 作用于 X 类型
>>>print('数字：{0:_X}'.format(0X2a846e98d))
数字：2_A846_E98D
#分组选项 _ 作用于其他类型（比如 n 类型）
>>>print('字符串：{0:_n}'.format(1234567))
ValueError: Cannot specify ',' with 'n'.
精度
精度：
- 精度指定了小数点后面要展示多少位小数
- 对于非数字类型，精度指定了最大字段宽度
- 整数类型不能指定精度
#对于非数字类型，精度指定最大字段宽度
>>>print('{0:.3}'.format('哇哈哈哈哈哈'))
哇哈哈
#整数类型不能指定精度
>>>print('{:.3d}'.format(666))
ValueError: Precision not allowed in integer format specifier
类型码
类型码可以分为三大类：
- 字符串类型
- 整数类型
- 浮点数类型
字符串类型
s字符串类型。这是字符串的默认类型，可以省略。None不指定类型。同s类型。
#s 类型
>>>print('{0:s}'.format('略略略'))
#s 类型可以省略
>>>print('{0:}'.format('略略略'))
略略略
略略略
整数类型
b二进制。
#b 类型：二进制
>>>print('{0:b}'.format(3))
11
c字符。把整数转换为相应的Unicode字符，然后再打印。
#c 类型：把整数转换成 unicode 字符
>>>print('{:c}'.format(97))
a
-d 十进制整数。
#d 类型：十进制整数
>>>print('{:d}'.format(666))
666
o八进制数。
#o 类型：八进制数
>>>print('{:o}'.format(10))
12
x十六进制数，a到 f小写。
#x 类型：十六进制数，a到f小写
>>>print('{:x}'.format(15))
f
X十六进制数，A到F大写。
#X 类型：十六进制数，A到F大写
>>>print('{:X}'.format(15))
F
n数字number类型，与d相同，只不过它会使用本地化的数字分隔符。
经试验，在本机为 n 类型指定任何分组选项（, 和 _）都会报错。
ValueError: Cannot specify ‘,’ with ‘n’.
#n 类型：与d相同，会插入本地化的分隔符
>>>print('{:n}'.format(66666))
#经试验，本机无法为 n 指定任何分组选项（,_）
>>>print('{:,n}'.format(66666))
ValueError: Cannot specify ',' with 'n'.
>>> print('{:_n}'.format(66666))
ValueError: Cannot specify ',' with 'n'.
None不指定类型，与d相同。
浮点数类型
e科学记数法，用e来表示指数。默认精度为6 位
#e 类型：科学记数法
#默认精度为 6 位
>>>print('{:e}'.format(1234567.1234567))
1.234567e+06
E与e相同，但是使用大写的E表示指数。
#E 类型：与 e 相同，用大写 E 表示指数
#默认精度为 6 位
>>>print('{:E}'.format(1234567.1234567))
#修改精度为 10 位
>>>print('{:.10E}'.format(1234567.1234567))
1.234567E+06
1.2345671235E+06
f定点记法，默认精度为6。
#f 类型
#默认精度为 6 位
>>>print('{:f}'.format(1234567.1234567))
1234567.123457
F定点记法，同f，但是会把nan转换成NAN，把inf转换成INF
#F 类型
>>>nan = float('nan')
>>>inf = float('inf')
>>>print('{:F}\n{:F}'.format(nan, inf))
NAN
INF
g通用general格式。自动转换到e或者f格式，具体的转换规则在此省略。正无穷、负无穷、正零、负零和非数字分别显示为inf，-inf，0，-0，nan。指定精度为0时等价于精度为1。默认精度为6位。
#g 类型
>>>print('{:g}'.format(1234567.1234567))
>>>print('{:g}'.format(1234.1234))
1.23457e+06
1234.12
G通用general格式。自动转换到E或者F格式，转换规则同上，相应表示方式换成大写。
#g 类型
>>>print('{:g}'.format(1234567.1234567))
>>>print('{:g}'.format(1234.1234))
1.23457e+06
1234.12
n数字number类型。跟g一样，只不过用本地化的分隔符来分隔数字。
#n 类型
>>>print('{:n}'.format(1234567.1234567))
>>>print('{:n}'.format(1234.1234))
1.23457E+06
1234.12
#经试验，本机指定分组选项会报错
>>>print('{:,n}'.format(1234.1234))
ValueError: Cannot specify ',' with 'n'.
>>> print('{:_n}'.format(1234.1234))
ValueError: Cannot specify ',' with 'n'.
%百分号类型。会将数字乘以100，然后以f定点fixed-point格式显示，最后加上一个百分号%。
#% 类型
>>>print('{:%}'.format(1))
100.000000%
None不指定类型。输出效果类似调用str()函数。
补充说明
- 输出花括号需要用花括号本身来转义
#打印花括号需要使用花括号转义
>>>print('{
{
{}}}'.format('张无忌'))
{
张无忌}
- 对象可以自定义格式说明符来替换标准格式说明符，比如
datetime类。
>>>from datetime import datetime
>>>print("Today is: {0:%a %b %d %H:%M:%S %Y}".format(datetime.now()))
今天是：Thu Nov 15 13:05:09 2018