数据类型操作与方法

数据类型操作与方法

序列基本操作

操作符	描述
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