python数据类型

可变序列：列表(list)，字典(dict)，集合(set)
不可变序列：元组(tuple)，字符串(str)
有序序列：列表，元组，字符串
无序序列：字典，集合

逻辑值

被定义为假值的常量: None 和 False。
任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
空的序列和多项集: '', (), [], {}, set(), range(0)

运算符

布尔运算

and:并且，全为真
 or:或者，一个为真
 not:逻辑非，优先级比非布尔运算符低， not a == b 相当于not（a==b）

比较运算

比较运算可以任意串连,x < y <= z 等价于 x < y and y <= z

运算	含意
<	严格小于
<=	小于或等于
>	严格大于
>=	大于或等于
==	等于
!=	不等于
is	对象标识
is not	否定的对象标识

运算符 is 和 is not 用于检测对象的标识号：当且仅当 x 和 y 是同一对象时 x is y 为真。 一个对象的标识号可使用 id() 函数来确定。 x is not y 会产生相反的逻辑值

数字类型

整数, 浮点数 和 复数：int ，float，complex，分别使用构造函数 int()、float() 和 complex()

运算	结果：	备注
x + y	x 和 y 的和
x - y	x 和 y 的差
x * y	x 和 y 的乘积
x / y	x 和 y 的商
x // y	x 和 y 的商数(向下取整)	(1)
x % y	x / y 的余数	(2)
-x	x 取反
+x	x 不变
abs(x)	x 的绝对值或大小
int(x)	将 x 转换为整数	(3)(6)
float(x)	将 x 转换为浮点数	(4)(6)
complex(re, im)	一个带有实部 re 和虚部 im 的复数。im 默认为0。	(6)
c.conjugate()	复数 c 的共轭
divmod(x, y)	(x // y, x % y)	(2)
pow(x, y)	x 的 y 次幂	(5)
x ** y	x 的 y 次幂	(5)

1. 也称为整数除法。 结果值是一个整数，但结果的类型不一定是 int。 运算结果总是向负无穷的方向舍入: 1//2 为 0, (-1)//2 为 -1, 1//(-2) 为 -1 而 (-1)//(-2) 为 `0。
2. 不可用于复数。 而应在适当条件下使用 abs() 转换为浮点数。
3. 从浮点数转换为整数会被舍入，字符串浮点数不可直接转换整数，可以先转浮点再转整数。
4. float 也接受字符串 "nan" 和附带可选前缀 "+" 或 "-" 的 "inf" 分别表示非数字 (NaN) 以及正或负无穷。
5. Python 将 pow(0, 0) 和 0 ** 0 定义为 1，这是编程语言的普遍做法。
6. 接受的数字字面值包括数码 0 到 9 或任何等效的 Unicode 字符（具有 Nd 特征属性的代码点）。
   取整
   rount(x)对x四舍五入,math.ceil向上取整,math.trunc,math.float想下取整，见math

函数

int

函数	解释	结果
int.bit_length()	以二进制表示一个整数所需要的位数，不包括符号位和前面的零	num = -37 print(num.bit_length()) #6
int.bit_count()	返回整数的绝对值的二进制表示中 1 的个数	num = 37(二进制为0b100101) print(num.bit_count()) #3
int.to_bytes()	返回表示一个整数的字节数组	num = 1024 print(num.to_bytes(2, byteorder='big')) #b'\x04\x00'
int.from_bytes()	返回由给定字节数组所表示的整数	int.from_bytes(b'\x00\x10', byteorder='big') #16
int.as_integer_ratio()	返回一对整数，其比率正好等于原整数并且分母为正数。 整数的比率总是用这个整数本身作为分子，1 作为分母。	(4.5).as_integer_ratio() #(9, 2)

float

函数	解释	结果
float.is_integer	float能否是整数	print((4.5).is_integer()) # False,print((-4.0).is_integer()) #True
float.hex	以十六进制字符串的形式返回一个浮点数表示	print((16.0).hex()) #0x1.0000000000000p+4
float.fromhex(s)	返回以十六进制字符串 s 表示的浮点数的类方法	print(float.fromhex('0x1.0000000000000p+4')) #16.0

序列类型

list,tuple,range

运算	结果：	备注
x in s	如果 s 中的某项等于 x 则结果为 True，否则为 False	(1) print(1 in ('1',2,3)) #False,print('1' in list(('1',2,3)) # True)
x not in s	如果 s 中的某项等于 x 则结果为 False，否则为 True	(1)print('1' not in ('1',2,3)) #False,print(1 not in list(('1',2,3)) # True)
s + t	s 与 t 相拼接	(6)(7)
s * n 或 n * s	相当于 s 与自身进行 n 次拼接	(2)(7)
s[i]	s 的第 i 项，起始为 0	(3)
s[i:j]	s 从 i 到 j(不包含s[j]) 的切片	(3)(4)
s[i:j:k]	s 从 i 到 j (不包含s[j]) 步长为 k 的切片	(3)(5)
len(s)	s 的长度
min(s)	s 的最小项
max(s)	s 的最大项
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）	(8)
s.count(x)	x 在 s 中出现的总次数

注释：

1. 虽然 in 和 not in 操作在通常情况下仅被用于简单的成员检测，某些专门化序列 (例如 str, bytes和bytearray也使用它们进行子序列检测:"gg" in "eggs" # True
2. 小于 0 的 n 值会被当作 0 来处理 (生成一个与 s 同类型的空序列)。 请注意序列 s 中的项并不会被拷贝；它们会被多次引用。 这一点经常会令 Python 编程新手感到困扰；例如:print([[]] * 3) #[[], [], []],lists = [[]] * 3 lists[0].append(3) print(lists) # [[3], [3], [3]]
   具体的原因在于 [[]] 是一个包含了一个空列表(id相同)的单元素列表，所以 [[]] * 3 结果中的三个元素都是对这一个空列表的引用。 修改 lists 中的任何一个元素实际上都是对这一个空列表的修改。 你可以用以下方式创建以不同列表为元素的列表:lists = [[] for i in range(3)] lists[0].append(3) print(lists) #[[3], [], []]
3. 如果 i 或 j 为负值，则索引顺序是相对于序列 s 的末尾: 索引号会被替换为 len(s) + i 或 len(s) + j。 但要注意 -0 仍然为 0。
4. s 从 i 到 j 的切片被定义为所有满足 i <= k < j 的索引号 k 的项组成的序列。 如果 i 或 j 大于 len(s)，则使用 len(s)。 如果 i 被省略或为 None，则使用 0。 如果 j 被省略或为 None，则使用 len(s)。 如果 i 大于等于 j，则切片为空。
5. s 从 i 到 j 步长为 k 的切片被定义为所有满足 0 <= n < (j-i)/k 的索引号 x = i + n*k 的项组成的序列。 换句话说，索引号为 i, i+k, i+2*k, i+3*k，以此类推，当达到 j 时停止 (但一定不包括 j)。 当 k 为正值时，i 和 j 会被减至不大于 len(s)。 当 k 为负值时，i 和 j 会被减至不大于 len(s) - 1。 如果 i 或 j 被省略或为 None，它们会成为“终止”值 (是哪一端的终止值则取决于 k 的符号)。 请注意，k 不可为零。 如果 k 为 None，则当作 1 处理。print(list(range(1,10))[5:1:-1]) #[6, 5, 4, 3],print(list(range(1,10))[1:5:2]) #[2, 4]
6. 拼接不可变序列总是会生成新的对象。 这意味着通过重复拼接来构建序列的运行时开销将会基于序列总长度的乘方。 想要获得线性的运行时开销，你必须改用下列替代方案之一：

• 如果拼接str对象，你可以构建一个列表并在最后使用 str.join()或是写入一个 io.StringIO 实例并在结束时获取它的值
• 如果拼接 bytes 对象，你可以类似地使用 bytes.join() 或 io.BytesIO，或者你也可以使用 bytearray 对象进行原地拼接。 bytearray 对象是可变的，并且具有高效的重分配机制
• 如果拼接元组tuple 对象，请改为 list 列表
• 对于其它类型，请查看相应的文档

7. 某些序列类型 (例如range) 仅支持遵循特定模式的项序列，因此并不支持序列拼接或重复。
8. 当 x 在 s 中找不到时 index 会引发 ValueError。 不是所有实现都支持传入额外参数 i 和 j。 这两个参数允许高效地搜索序列的子序列。 传入这两个额外参数大致相当于使用 s[i:j].index(x)，但是不会复制任何数据，并且返回的索引是相对于序列的开头而非切片的开头。

可变序列操作

lists = list(range(1,10)) #lists [1, 2, 3, 4, 5, 6, 7, 8, 9]
list1 = lists#lists变，list1也变
list2 = lists.copy() #lists变，list2不变
print(id(list1),id(lists),id(list2)) #2060917896832 2060917896832 2060918255168
lists[2:4] = [11,22,44,77] #lists [1, 2, 11, 22, 44, 77, 5, 6, 7, 8, 9]
lists[2:4:2] = [88] #lists [1, 2, 88, 22, 44, 77, 5, 6, 7, 8, 9]替换和被替换的长度一样
del lists[1:2] #lists [1, 88, 22, 44, 77, 5, 6, 7, 8, 9] 删除了2
del lists[1:4:2] #lists [1, 22, 77, 5, 6, 7, 8, 9] 删除了88和44
lists.append(88) #lists[1, 22, 77, 5, 6, 7, 8, 9, 88]
print(list1) #list1 [1, 22, 77, 5, 6, 7, 8, 9, 88]
print(list2) #list2 [1, 2, 3, 4, 5, 6, 7, 8, 9]
lists.extend([88,11])#lists [1, 22, 77, 5, 6, 7, 8, 9, 88, 88, 11]
print(lists*2)#[1, 22, 77, 5, 6, 7, 8, 9, 88, 88, 11, 1, 22, 77, 5, 6, 7, 8, 9, 88, 88, 11]
lists.insert(1,211) #lists [1, 211,22, 77, 5, 6, 7, 8, 9, 88, 88, 11]
lists.pop(2) #lists [1, 211, 77, 5, 6, 7, 8, 9, 88, 88, 11]
lists.remove(88) #lists [1, 211, 77, 5, 6, 7, 8, 9, 88, 11]
lists.reverse() #lists [11, 88, 9, 8, 7, 6, 5, 77, 211, 1]
lists.clear()#[]

运算	结果：	备注
s[i] = x	将 s 的第 i 项替换为 x
s[i:j] = t	将 s 从 i 到 j 的切片替换为可迭代对象 t 的内容
del s[i:j]	等同于 s[i:j] = []
s[i:j:k] = t	将 s[i:j:k] 的元素替换为 t 的元素	(1)
del s[i:j:k]	从列表中移除 s[i:j:k] 的元素
s.append(x)	将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])
s.clear()	从 s 中移除所有项 (等同于 del s[:])	(5)
s.copy()	创建 s 的浅拷贝 (等同于 s[:])	(5)
s.extend(t) 或 s += t	用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)
s *= n	使用 s 的内容重复 n 次来对其进行更新	(6)
s.insert(i, x)	在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
s.pop() 或 s.pop(i)	提取在 i 位置上的项，并将其从 s 中移除	(2)
s.remove(x)	删除 s 中第一个 s[i] 等于 x 的项目。	(3)
s.reverse()	就地将列表中的元素逆序。	(4)

注释：

1. t 必须与它所替换的切片具有相同的长度。
2. 可选参数 i 默认为 -1，因此在默认情况下会移除并返回最后一项。
3. 当在 s 中找不到 x 时 remove() 操作会引发 ValueError。
4. 当反转大尺寸序列时 reverse() 方法会原地修改该序列以保证空间经济性。 为提醒用户此操作是通过间接影响进行的，它并不会返回反转后的序列。
5. 包括 clear() 和 copy() 是为了与不支持切片操作的可变容器 (例如 dict和 set的接口保持一致。 copy() 不是 collections.abc.MutableSequenceABC 的一部分，但大多数具体的可变序列类都提供了它。
6. n 值为一个整数，或是一个实现了 __index__() 的对象。 n 值为零或负数将清空序列。 序列中的项不会被拷贝；它们会被多次引用，正如 通用序列操作 中有关 s * n 的说明。

列表[可变序列]

定义

lists = [[] for i in range(3)]
lists = list(range(1,10)) #lists [1, 2, 3, 4, 5, 6, 7, 8, 9]
lists = [i for i in range(1,10)] #lists [1, 2, 3, 4, 5, 6, 7, 8, 9]
lists = [1,2]
lists = list('123') #['1', '2', '3'],不能是int
lists = list((1,2,3)) #[1, 2, 3]
lists.sort(reverse=True) #[3, 2, 1]

元组[不可变序列]

t = ()#()
t = 1,#(1,)
t = 1,2,3 #(1, 2, 3)
t = ('1',2,3) #('1', 2, 3)
t = tuple(range(1,5))#(1, 2, 3, 4)
t = tuple('1213') #('1', '2', '1', '3')

range对象

range(start, stop[, step])

如果 step 为正值，确定 range r 内容的公式为 r[i] = start + stepi 其中 i >= 0 且 r[i] < stop。print(list(range(1,5))) #[1, 2, 3, 4]
如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + stepi，但限制条件改为 i >= 0 且 r[i] > stop.print(list(range(5,1,-1))) #[5, 4, 3, 2],print(list(range(0,-10,-2))) #[0, -2, -4, -6, -8]

range类型相比常规 list或 tuple元组 的优势在于一个 range对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start, stop 和 step 值，并会根据需要计算具体单项或子范围的值）

print(list(range(1,5)))#[1, 2, 3, 4]
print(list(range(5,1,-1)))#[5, 4, 3, 2]
print(list(range(0,-10,-2)))#[0, -2, -4, -6, -8]
print(2 in range(1,5))#True
print(range(1,5).index(4))#3
print(range(1,5)[1])#2
print(range(1,5)[1:3])#range(2, 4)

文本序列类型[不可变序列]

str(object=b'', encoding='utf-8', errors='strict')

str1 = 'abCd'
print('abCd'.capitalize())# AbCd
print('abCd'.casefold()) #abcd
print('str1'.upper()) #STR1
print('Shdd'.lower()) #shdd
print('Hello worlD'.title(),"they're bill's".title()) #Hello World They'Re Bill'S
print('HddAAA'.swapcase()) #hDDaaa
print('abCdCd'.find('Cd'))#2
print('abCdCd'.index('Cd'))#2
print('1+2={},2*2={}'.format(3,4)) #1+2=3,2*2=4
print('{name} was born in {country}'.format_map({'name':'uan','country1':'china1','country':'china'}))#uan was born in china
print('abCd'.center(10,'-')) #---abCd---
print('abCd'.ljust(10,'-')) #abCd------
print('abCd'.rjust(10,'-')) #------abCd
print('abCdCd'.count('Cd',2,4)) #1
print('abCdCd'.encode()) #b'abCdCd'
print('sss.com/1.html'.endswith(('html','css'))) #True
print('sss.com/1.html'.endswith('html')) #True
print('01\t012\t0123\t01234'.expandtabs(1))#01 012 0123 01234
print('01\t012\t\n0123\n01234'.expandtabs(1))
print('ddd11'.isalnum()) #True
print('ddd11'.isalpha(),'ddd'.isalpha(),'汉字'.isalpha())#False True True
print('ddd11'.isascii(),'ddd'.isascii(),'汉字'.isascii())#True True False
print('ddd11'.isdecimal(),'222'.isdecimal(),'汉字'.isdecimal())#False True False
print('33.3'.isdigit(),'33'.isdigit())#False True
print('33.3'.isnumeric(),'222'.isnumeric())#False True
print('33.3'.isdigit(),'33'.isdigit())#False True
print('ddd11'.isidentifier(),'33dxx'.isidentifier())#True False
print('ddd11'.islower(),'Dxx'.islower(),'333'.islower())#True False False
print('DADA'.isupper(),'Dxx'.isupper(),'333'.isupper())#True False False
print(' '.isspace(),'33d xx'.isspace())#True False
print(','.join(str1))
print('    xss ddd  '.strip(),'sdd111dds'.strip('ds')) #xss ddd 111
print('    xss ddd  '.lstrip(),'sdd111dds'.lstrip('ds')) #xss ddd   111dds
print('    xss ddd  '.rstrip(),'sdd111dds'.rstrip('ds')) #    xss ddd sdd111

print('hello,world'.partition(',')) #('hello', ',', 'world')
#print('TestHook'.removeprefix('Test'),'TestHook'.removeprefix('test')) #Hook TestHook
#print('TestHook'.removeprefix('Hook'),'TestHook'.removeprefix('hook')) #Test TestHook
print('hello world'.startswith(('ll','he')),'hello world'.startswith(('ll','he'),1,5)) #True False
print('hello,world'.replace('hello','nihao')) #nihao,world
print('hello,world'.rfind('l')) #9
print('hello,world'.rindex('l')) #9
print('hello,world'.split(',')) #['hello', 'world']
print('hello\r\nworld'.splitlines(),'hello\r\nworld'.splitlines(keepends=True))#['hello', 'world'] ['hello\r\n', 'world']
print('jjsss2'.zfill(10),'jjsss2'.zfill(3),'-20'.zfill(5),'20'.zfill(5)) #0000jjsss2 jjsss2 -0020 00020
'''格式化字符串'''
# %占位符，%s字符串，%i或者%d整数，%f浮点数
name='张三'
age=20
print('我叫%s,今年%d' % (name,age))
#{}占位符
print('我叫{0},今年{1}'.format(name,age))
#f-string
print(f'我叫{name},今年{age}')

方法	说明	示例
str.find(sub[, start[, end]])	返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引，要检查 sub 是否为子字符串请使用in	print('abCdCd'.find('Cd'))#2
str.rfind(sub[, start[, end]])	返回子字符串 sub 在字符串内被找到的最大（最右）索引	print('abCdCd'.find('Cd'))#2
str.index(sub[, start[, end]])	返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引,找不到子字符串时会引发 ValueError	print('abCdCd'.index('Cd'))#2
str.rindex(sub[, start[, end]])	返回子字符串 sub 在 s[start:end] 切片内被找到的最大索引,找不到子字符串时会引发 ValueError	print('hello,world'.rindex('l')) #9
str.join(iterable)	返回一个由 iterable 中的字符串拼接而成的字符串。str为需要的分隔符	print(','.join(str1))
str.format(*args, **kwargs)	执行字符串格式化操作,以花括号 {} 括起来的替换域	print('1+2={0},2*2={1}'.format(3,4)) #1+2=3,2*2=4
str.format_map(mapping)	执行字符串格式化操作	print('{name} was born in {country}'.format_map({'name':'uan','country1':'china1','country':'china'}))#uan was born in china
str.capitalize()	首字符大写	print(str1.capitalize()) # Abcd
str.lower()	转换为小写	print('Shdd'.lower()) #shdd
str.upper()	转换为大写	print('str1'.upper()) #STR1
str.casefold()	全部转成小写，针对部分语言比lower()谨	str1 = str1.casefold() #abcd
str.swapcase()	大写转小写，小写转大写	print('HddAAA'.swapcase()) #hDDaaa
str.title()	每个单词第一个字母为大写，其余字母为小写	print('Hello worlD'.title(),"they're bill's".title()) #Hello World They'Re Bill'S
str.islower()	如果字符串中至少有一个区分大小写的字符 且此类字符均为小写则返回 True ，否则返回 False	print('ddd11'.islower(),'Dxx'.islower(),'333'.islower())#True False False
str.isupper()	如果字符串中至少有一个区分大小写的字符 4 且此类字符均为大写则返回 True ，否则返回 False 。	print('DADA'.isupper(),'Dxx'.isupper(),'333'.isupper())#True False False
str.count(sub[, start[, end]])	检测字符换sub在[start, end] 范围内出现的次数	print('abCdCd'.count('Cd',2,4)) #1
str.endswith(suffix[, start[, end]])	如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。	print('sss.com/1.html'.endswith(('html','css'))) #True,print('sss.com/1.html'.endswith('html')) #True
str.strip([chars])	移除其中的左右chars字符，chars可以是组合	print(' xss ddd '.strip(),'sdd111dds'.strip('ds')) #xss ddd 111
str.lstrip([chars])	移除其中的左侧chars字符，chars可以是组合	print(' xss ddd '.lstrip(),'sdd111dds'.lstrip('ds')) #xss ddd 111dds
str.rstrip([chars])	移除其中的右侧chars字符，chars可以是组合	print(' xss ddd '.rstrip(),'sdd111dds'.rstrip('ds')) # xss ddd sdd111
str.startswith(prefix[, start[, end]])	如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组	print('hello world'.startswith(('ll','he')),'hello world'.startswith(('ll','he'),1,5)) #True False
str.removeprefix(prefix, /)	替换掉开头的prefix字符串	print('TestHook'.removeprefix('Test'),'TestHook'.removeprefix('test')) #Hook TestHook
str.removesuffix(prefix, /)	替换掉结尾的prefix字符串	print('TestHook'.removeprefix('Hook'),'TestHook'.removeprefix('hook')) #Test TestHook
str.split(sep=None, maxsplit=- 1)	返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串，如果给出了 maxsplit，则最多进行 maxsplit 次拆分	print('hello,world'.split(',')) #['hello', 'world']
str.splitlines(keepends=False)	返回由原字符串中各行组成的列表，在行边界的位置拆分,设置keepends=True结果中包含行边界，行边界见下	print('hello\r\nworld'.splitlines(),'hello\r\nworld'.splitlines(keepends=True))#['hello', 'world'] ['hello\r\n', 'world']
str.partition(sep)	在 sep 首次出现的位置拆分字符串，返回一个 3 元组,如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串	print('hello,world'.partition(',')) #('hello', ',', 'world')
str.rpartition(sep)	在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组,如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串	print('hello,world'.partition(',')) #('hello', ',', 'world')
str.isalnum()	如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False	print('ddd11'.isalnum()) #True
str.isalpha()	如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False	print('ddd11'.isalpha(),'ddd'.isalpha(),'汉字'.isalpha())#False True True
str.isascii()	如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F 。	print('ddd11'.isascii(),'ddd'.isascii(),'汉字'.isascii())#True True False
str.isdecimal()	如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ， 否则返回 False	print('ddd11'.isdecimal(),'222'.isdecimal(),'汉字'.isdecimal())#False True False
str.isdigit()	如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。	print('33.3'.isdigit(),'33'.isdigit())#False True
str.isnumeric()	如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。	print('33.3'.isnumeric(),'222'.isnumeric())#False True
str.isidentifier()	判断字符串是否为Python标识符或者变量名是否合法	print('ddd11'.isidentifier(),'33dxx'.isidentifier())#True False
str.isspace()	如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False 。	print(' '.isspace(),'33d xx'.isspace())#True False
str.zfill(width)	在左边填充 ASCII '0' 数码使其长度变为 width	print('jjsss2'.zfill(10),'jjsss2'.zfill(3),'-20'.zfill(5),'20'.zfill(5)) #0000jjsss2 jjsss2 -0020 00020
str.center(width[, fillchar])	文字居中，使用fillchar填充	print('abCd'.center(10,'-')) #---abCd---
str.ljust(width[, fillchar])	左对齐，使用fillchar填充	print('abCd'.ljust(10,'-')) #abCd------
str.rjust(width[, fillchar])	右对齐，使用fillchar填充	print('abCd'.rjust(10,'-')) #------abCd
str.encode(encoding='utf-8', errors='strict')	返回原字符串编码为字节串对象的版本	print('abCdCd'.encode()) #b'abCdCd'
str.expandtabs(tabsize=8)	所有的制表符(\t)会tabsize个空格替换	print('01\t012\t0123\t01234'.expandtabs(1))#01 012 0123 01234

行边界

表示符	描述
\n	换行
\r	回车
\r\n	回车 + 换行
\v 或 \x0b	行制表符
\f 或 \x0c	换表单
\x1c	文件分隔符
\x1d	组分隔符
\x1e	记录分隔符
\x85	下一行 (C1 控制码)
\u2028	行分隔符
\u2029	段分隔符

字符串常量

print(string.ascii_letters)#abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.ascii_lowercase)#小写字母 abcdefghijklmnopqrstuvwxyz
print(string.ascii_uppercase)#大写字母 ABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.digits) #0123456789
print(string.hexdigits) #0123456789abcdefABCDEF
print(string.octdigits) #01234567
print(string.punctuation) #视为标点符号的 ASCII 字符 !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
print(string.printable) #可打印符号的 ASCII 字符组成的字符串 digits, ascii_letters, punctuation 和 whitespace总和
print(string.whitespace) #空白符号的 ASCII 字符组成的字符串,空格、制表、换行、回车、进纸和纵向制表符

集合类型

set([iterable])可变，且不能被用作字典的键或其他集合的元素
frozenset([iterable])不可变，可以被用作字典的键或其他集合的元素
集合内的元素具有唯一性的，无序，常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等

print(type({'1',2})) #<class 'set'>
print({c for c in 'abracadabra' if c not in 'abc'}) #{'d', 'r'}
print(set(),set('1'),set(['a', 'b', 'foo'])) #set() {'1'} {'a', 'b', 'foo'}

set,frozenset通用

print(len({'1', 2})) #长度 2
print('1' in {'1', 2}) #成员 True
print('1' not in {'1', 2}) #非成员 False
print({2,3}.isdisjoint({'1', 2}),{'2',3}.isdisjoint({'1', 2})) #非交集 False True
print({2}.issubset({'1', 2}),{'2',3}.issubset({'1', 2})) #a是b的子集 True False
print({2}<={2,3}) #a是b的子集 True
print({'1', 2}.issuperset({2})) #b是a的子集 True
print({'1', 2}.union({2,3,'2'})) #并集 {2, '2', 3, '1'}
print({'1', 2}.intersection({2,3,'2'})) #交集 {2}
print({'1', 2}.difference({2,3,'2'}))#b中不存在，a中存在的 {'1'}
print({'1', 2}.symmetric_difference({2,3,'2'})) #ab都不存在的 {3, '2', '1'}
print({'1', 2}.copy()) #浅拷贝 {2, '1'}

set可用,frozenset不可用

print(len({'1', 2})) #长度 2
print('1' in {'1', 2}) #成员 True
print('1' not in {'1', 2}) #非成员 False
print({2,3}.isdisjoint({'1', 2}),{'2',3}.isdisjoint({'1', 2})) #非交集 False True
print({2}.issubset({'1', 2}),{'2',3}.issubset({'1', 2})) #a是b的子集 True False
print({2}<={2,3}) #a是b的子集 True
print({'1', 2}.issuperset({2})) #b是a的子集 True
print({'1', 2}.union({2,3,'2'})) #并集 {2, '2', 3, '1'}
print({'1', 2}.intersection({2,3,'2'})) #交集 {2}
print({'1', 2}.difference({2,3,'2'}))#b中不存在，a中存在的 {'1'}
print({'1', 2}.symmetric_difference({2,3,'2'})) #ab都不存在的 {3, '2', '1'}
print({'1', 2}.copy()) #浅拷贝 {2, '1'}
set1 = {'1','2'}
set1.update({'3'}) #合并集合
print(set1) #{'2', '1', '3'}
set1.intersection_update({'2',1,'3'}) #保留交集
print(set1) #{'3', '2'}
set1.difference_update({'2',1}) #移除交集
print(set1) #{'3'}
set1.symmetric_difference_update({'2',1,'3'}) #合并并去除交集
print(set1) #{'2', 1}
set1.add(3) #新增元素
set1.add(4)
print(set1) #{4,3, 1, '2'}
set1.remove(1) #移除元素，不存在于集合中则会引发 KeyError
print(set1) #{'2', 3,4}
set1.discard(3)#移除元素,不存在不报错
print(set1) #{'2',4}
print(set1.pop()) #从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError 4
print(set1) #{'2'}
set1.clear() #清空集合
print(set1) #set()

字典

dict

print({'name':'张三','age':22})#{'name': '张三', 'age': 22}
print({x:x*2 for x in range(1,5)})#推导式 {1: 2, 2: 4, 3: 6, 4: 8}
print(dict([('name','张三'),('age',20)]),dict(name='张三',age=20)) #{'name': '张三', 'age': 20}
dict1 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
print(dict1) #{'one': 1, 'two': 2, 'three': 3}
print(list(dict1)) #返回所有键 ['one', 'two', 'three']
keys = iter(dict1) #返回以字典的键为元素的迭代器
for i in keys:
    print(i) #one two three
print(len(dict1)) #3
print(dict1['one']) #1
print(dict1.get('one'),dict1.get('four')) #1 None
del dict1['one'] #删除元素
print(dict1) #{'two': 2, 'three': 3}
print('two' in dict1) #True
print('two' not in dict1) #False
dict2 = dict1.copy()
print(dict2) #{'two': 2, 'three': 3}
dict2.clear()#移除字典中的所有元素
print(dict2) #{}
print(dict.fromkeys({'one':0,'two':1,'three':3},2)) #{'one': 2, 'two': 2, 'three': 2}
print(dict1.pop('two',False)) #移除元素,并返回元素的值，如果没有键，则返回第二个参数默认值
print(dict1)#{'three': 3}
print(dict1.popitem())#('three', 3) dict1为空将会报错
print(dict1) #{}
dict1 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
print(dict1) #{'one': 1, 'two': 2, 'three': 3}
for i in reversed(dict1): #返回一个逆序获取字典键的迭代器
    print(i) #three two one
#setdefault 如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default
res1 = dict1.setdefault('one',2)
res2 = dict1.setdefault('four',4)
print(dict1,res1,res2) #'one': 1, 'two': 2, 'three': 3, 'four': 4} 1 4
dict1.update([('one',1.5)])
dict1.update({'five':5,'four':4.5})
print(dict1) #{'one': 1.5, 'two': 2, 'three': 3, 'four': 4.5, 'five': 5}
#print(dict1 | {'five':5.1,'six':6}) #3.9以后
#字典视图对象，该对象提供字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变
print(dict1.items()) #dict_items([('one', 1.5), ('two', 2), ('three', 3), ('four', 4.5), ('five', 5)])
values = dict1.values()
list_values = list(dict1.values())
print(values)#dict_values([1.5, 2, 3, 4.5, 5])
print(list_values) #[1.5, 2, 3, 4.5, 5]
keys = dict1.keys()
list_keys = list(keys)
print(keys)#dict_keys(['one', 'two', 'three', 'four', 'five'])
print(list_keys) #['one', 'two', 'three', 'four', 'five']
print('---------修改完值-----------')
dict1['six'] = 2
dict1['five'] = 5.1
print(values) #dict_values([1.5, 2, 3, 4.5, 5.1, 2])
print(list_values) #不变
print(keys) #dict_keys(['one', 'two', 'three', 'four', 'five', 'six'])
print(list_keys) #不变
print(values.mapping)