Python序列方法
1、列表
基本介绍
列表是包含了若干元素的有序连续内存空间，当列表的元素进行增加或者删除时，列表对象会自动进行内存的扩展或收缩，从而保证了相邻元素之间没有缝隙
方法讲解
1.insert（）
作用
在指定位置进行一个列表元素的添加（原地添加），具体操作为：在指定位置元素的前面（左边为前面，右边为后面）插入新元素
返回值
空类型对象 None
案例
lst = [1,2,3,4,5]
lst.insert(-100,0) #指定的下标可为列表中不存在的下标
print(lst)
#输出结果：[0, 1, 2, 3, 4, 5]
lst = [1,2,4,5]
lst.insert(2,3)
print(lst)
#输出结果：[1, 2, 3, 4, 5]
lst = [1,2,3,5]
lst.insert(-1,4)
print(lst)
#输出结果：[1, 2, 3, 4, 5]
2.append（）
作用
进行一个列表元素的追加（原地追加）
返回值
空类型对象 None
案例
lst = [1,2,3,4]
lst.append(5)
print(lst)
#输出结果：[1, 2, 3, 4, 5]
3.extend（）
作用
通过把一个可迭代对象中所有的元素追加到一个列表中，实现多个列表元素的追加（原地追加）
返回值
空类型对象 None
案例
lst = [1,2,3]
lst.extend([4,5])
print(lst)
#输出结果：[1, 2, 3, 4, 5]
lst = [1,2,3]
lst.extend(map(int, ['4','5']))
print(lst)
#输出结果：[1, 2, 3, 4, 5]
4.pop（）
作用
- 有指定索引
- 索引存在，移除指定索引对应的元素（原地移除）
- 索引不存在，抛出异常
- 不指定索引，默认移除列表中最后一个元素
返回值
被移除的元素
案例
lst = [1,2,3]
data = lst.pop()
print(lst, data)
#输出结果：[1, 2] 3
lst = [1,2,3]
data = lst.pop(1)
print(lst, data)
#输出结果：[1, 2] 2
lst = [1,2,3]
data = lst.pop(3)
print(lst, data)
#引发异常：IndexError: pop index out of range
5.remove（）
作用
- 必须指定目标元素
- 目标元素存在，移除目标元素（原地移除），如果存在多个重复元素，只会移除第一个元素
- 目标元素不存在，抛出异常
返回值
空类型对象 None
案例
lst = [1,2,3]
data = lst.remove(2)
print(lst)
#输出结果：[1, 3]
lst = [1,2,3]
lst.remove(4)
print(lst)
#引发异常：ValueError: list.remove(x): x not in list
6.sort（）
作用
对于存储相同类型元素的列表进行升序或者降序（通过形参reverse指定升序or降序）排列（原地重排）
通过对形参key赋值一个函数，可以对要进行比较的元素先进行一些处理再拿去比较（最终比较的是函数返回值），从而达到对元素进行特定规则比较的目的
返回值
空类型对象 None
案例
lst = [1,3,2,5,4]
lst.sort(reverse = False) #reverse为默认值形参，默认值为False
print(lst)
#输出结果：[1, 2, 3, 4, 5]
lst = [1,3,2,5,4]
lst.sort(reverse = True)
print(lst)
#输出结果：[5, 4, 3, 2, 1]
lst = [] #传入一个空列表也不会抛出异常
lst.sort()
print(lst)
#输出结果：[]
7.reverse（）
作用
对列表中的元素进行原地反转（原地重排）
注意和设定默认值参数reverse为True的sort方法的反转进行区分，reverse方法的反转为直接对列表元素进行反转操作，而sort方法的反转为先对列表元素进行排序操作，再进行反转操作
返回值
空类型对象 None
案例
lst = [1,3,2,5,4]
lst.reverse()
print(lst)
#输出结果：[4, 5, 2, 3, 1]
lst = [] #传入一个空列表也不会抛出异常
lst.reverse()
print(lst)
#输出结果：[]
8.index（）
作用
- 必须指定目标元素
- 目标元素存在，对指定元素进行查找，返回对应索引，如果列表中存在多个相同元素，只会返回第一个元素的索引
- 目标元素不存在，抛出异常
可以在指定的[start，stop)（皆为索引）范围内进行查找
返回值
int类型对象 元素索引
案例
lst = [1,2,3,4,5]
ind = lst.index(4)
print(ind)
#输出结果：3
lst = [1,2,3,4,5]
ind = lst.index(6)
print(ind)
#引发异常：ValueError: 6 is not in list
9.count（）
作用
得到指定元素在列表中的个数
返回值
int类型对象 元素个数
案例
lst = [1,1,1,2,3,4]
cnt = lst.count(1)
print(cnt)
#输出结果：3
10.clear（）
作用
清除列表中的所有元素，使一个列表成为空列表
返回值
空类型对象 None
案例
lst = [1,2,3,4]
lst.clear()
print(lst)
#输出结果：[]
11.copy（）
作用
实现列表的浅拷贝
返回值
列表类型对象 一个id不同的"新"列表
案例
lst = [[1,2],3,4]
Lst = lst.copy()
print('源列表内容：',lst)
print('源列表id：',id(lst))
print('源列表第一个元素的id：',id(lst[1]))
print("=======================================")
print('拷贝列表内容：',Lst)
print('拷贝列表id：',id(Lst))
print('拷贝列表第一个元素的id：',id(Lst[1]))
#输出结果：
"""
源列表内容： [[1, 2], 3, 4]
源列表id： 1204130447040
源列表第一个元素的id： 1204080175472
=======================================
拷贝列表内容： [[1, 2], 3, 4]
拷贝列表id： 1204132545728
拷贝列表第一个元素的id： 1204080175472
"""
2、元组
基本介绍
元组是包含了若干元素的有序连续内存空间，为轻量级列表/常量列表，元组是不可变的，一旦定义后，元组中的元素的数量和引用都不能改变（元组元素的元素的引用是可以改变的），好处就是在多任务环境下同时有多个人要操作对象时不用加锁，元组的访问速度比列表要略快一些，如果定义了一系列常量值，并主要用途仅仅是对其进行遍历而不需要进行任何修改，建议使用元组而不是列表
方法
1.index（）
作用
- 必须指定目标元素
- 目标元素存在，对指定元素进行查找，返回对应索引，如果列表中存在多个相同元素，只会返回第一个元素的索引
- 目标元素不存在，抛出异常
可以在指定的[start，stop)（皆为索引）范围内进行查找
返回值
int类型对象 元素索引
案例
tpl = [1,2,3,4,5]
ind = tpl.index(4)
print(ind)
#输出结果：3
tpl = (1,2,3,4,5)
ind = tpl.index(6)
print(ind)
#引发异常：ValueError: tuple.index(x): x not in tuple
2.count（）
作用
得到指定元素在列表中的个数
返回值
int类型对象 元素个数
案例
tpl = [1,1,1,2,3,4]
cnt = tpl.count(1)
print(cnt)
#输出结果：3
3、字典
基本介绍
也称为关联数组，为包含若干键值对形式元素的无序可变序列，字典中的每一个元素包括用冒号隔开的"键"和"值"两部分，表示一种映射关系
键可以为Python中的任意不可变对象，且同一个字典中的键不可重复，对字典对象直接进行遍历的时候默认遍历"键"；值没有什么特殊要求，可重复，可为可变对象
字典在内部维护的哈希表使得查询操作的效率极高，由于哈希表的特点，于是字典会浪费较大的内存空间，是一种以空间换时间的数据结构
使用内置字典类型dict的时候不需要特别在意元素的先后顺序，如果确实需要，可以使用collections模块中的OrderedDict有序字典类构造的实例对象
方法
1.keys（）
作用
获取字典所有的键
返回值
dict_keys类型对象（类似于集合） 以字典所有的键为元素的一个可迭代对象
案例
dct = {1:2, 3:4, 5:6}
keys = list(dct.keys())
print(keys)
#输出结果：[1, 3, 5]
dct = {1:2, 3:4, 5:6}
keys = dct.keys()
print(keys & {1, 2})
#输出结果：{1}
2.values（）
作用
获取字典所有的值
返回值
dict_values类型对象 以字典所有的值为元素的一个可迭代对象
案例
dct = {1:2, 3:4, 5:6}
values = list(dct.values())
print(values)
#输出结果：[2, 4, 6]
dct = {1:2, 3:4, 5:6}
values = dct.values()
print(values & {1, 2})
#引发异常：unsupported operand type(s) for &: 'dict_values' and 'set'
3.items（）
作用
获取字典所有的键值对
返回值
dict_items类型对象 以字典所有的键值对为元素（元素为元组类型对象）的一个可迭代对象
案例
dct = {1:2, 3:4, 5:6}
items = list(dct.items())
print(items)
#输出结果：[(1, 2), (3, 4), (5, 6)]
dct = {1:2, 3:4, 5:6}
items = dct.items()
print(items & {(1, 2), 3, 4})
#输出结果：{(1, 2)}
4.get（）
作用
- 必须指定目标键
- 目标键存在，根据"键"获取字典中对应的"值"
- 目标键不存在，返回默认值（默认为None，可以修改）
返回值
获取到的"值"
案例
dct = {1:2, 3:4, 5:6}
value = dct.get(3)
print(value)
#输出结果：4
dct = {1:2, 3:4, 5:6}
value = dct.get(6)
print(value)
#输出结果：None
dct = {1:2, 3:4, 5:6}
value = dct.get(6,123)
print(value)
#输出结果：123
5.pop（）
作用
- 必须指定目标键
- 目标键存在，删除该键值对，并返回字典中该键对应的值
- 目标键不存在，如果有指定默认值，返回默认值（默认为None，可以修改），否则抛出异常
返回值
被删除的键值对的"值"
案例
dct = {1:2, 3:4, 5:6}
value = dct.pop(3)
print(dct, value)
#输出结果：{1: 2, 5: 6} 4
dct = {1:2, 3:4, 5:6}
value = dct.pop(6, None)
print(dct, value)
#输出结果：{1: 2, 3: 4, 5: 6} None
dct = {1:2, 3:4, 5:6}
value = dct.pop(6)
print(dct, value)
#引发异常：KeyError: 6
6.popitem（）
作用
删除顺序像堆栈一样，LIFO（后进先出），返回一个包括键和值的元组，如果字典为空，抛出异常
返回值
元组类型对象 被删除的键值对
案例
dct = {1:2, 3:4, 5:6}
value = dct.popitem() #默认输出最后一个键值对
print(dct, value)
dct[6] = 7
value = dct.popitem()
print(dct, value)
#输出结果：
"""
{1: 2, 3: 4} (5, 6)
{1: 2, 3: 4} (6, 7)
"""
7.update（）
作用
格式为D.update([E, ]**F)
- 如果E具有keys方法
- 本质为 for k in E: D[k] = E[k]
- 如果E不具有keys方法
- 本质为 for k, v in E: D[k] = v
不管是哪一种情况，都会有for k in F: D[k] = F[k]
返回值
空类型对象 None
案例
dct = {1:2, 3:4, 5:6}
dct.update(a = 'b')
print(dct)
#输出结果：{1: 2, 3: 4, 5: 6, 'a': 'b'}
dct = {1:2, 3:4, 5:6}
dct.update([(7,8),(9,10)], a = 'b')
print(dct)
#输出结果：{1: 2, 3: 4, 5: 6, 7: 8, 9: 10, 'a': 'b'}
dct = {1:2, 3:4, 5:6}
dct.update({7:8, 9:10}, a = 'b')
print(dct)
#输出结果：{1: 2, 3: 4, 5: 6, 7: 8, 9: 10, 'a': 'b'}
8.fromkeys（）
作用
将一个可迭代对象的每一个元素作为字典的键，字典的值默认皆为None，可以进行修改
指定的字典的值实际进行了一个浅拷贝的过程
返回值
字典类型对象 一个以可迭代对象的元素为键，以一个指定对象为值的字典
案例
dct = {1:2, 3:4, 5:6}
Dct = dct.fromkeys([3,5,7]) #会先进行原来字典的clear，再进行字典构造
print(Dct)
#输出结果：{3: None, 5: None, 7: None}
dct = {1:2, 3:4, 5:6}
Dct = dct.fromkeys([3,5,7], 0)
print(Dct)
#输出结果：{3: 0, 5: 0, 7: 0}
dct = {1:2, 3:4, 5:6}
Dct = dct.fromkeys([3,5,7], [0,0])
print(Dct)
for i in Dct.values():
print("每一个值及其id：", i, id(i))
#输出结果：
"""
{3: [0, 0], 5: [0, 0], 7: [0, 0]}
每一个值及其id： [0, 0] 2657536471808
每一个值及其id： [0, 0] 2657536471808
每一个值及其id： [0, 0] 2657536471808
"""
9.setdefault（）
作用
- 如果目标键在字典中存在
- 返回字典中该键对应的值
- 如果目标键在字典中不存在
- 在字典中添加该键，值为一个默认值（默认为None，可以修改），同时返回该默认值
返回值
字典中目标键对应的值
案例
dct = {1:2, 3:4, 5:6}
value = dct.setdefault(3, 0)
print(dct, value)
#输出结果：{1: 2, 3: 4, 5: 6} 4
dct = {1:2, 3:4, 5:6}
value = dct.setdefault(6)
print(dct, value)
#输出结果：{1: 2, 3: 4, 5: 6, 6: None} None
dct = {1:2, 3:4, 5:6}
value = dct.setdefault(6,0)
print(dct, value)
#输出结果：{1: 2, 3: 4, 5: 6, 6: 0} 0
10.clear（）
作用
清除字典中所有的键值对
返回值
空类型对象 None
案例
dct = {1:2, 3:4, 5:6}
dct.clear()
print(dct)
#输出结果：{}
11.copy（）
作用
实现字典的浅拷贝
返回值
字典类型对象 一个id不同的"新"字典
案例
dct = {1:[1,2],2:3,4:5}
Dct = dct.copy()
print('源字典内容：',dct)
print('源字典id：',id(dct))
print('源字典第一个键值对的值的id：',id(dct[1]))
print("=======================================")
print('拷贝字典内容：',Dct)
print('拷贝字典id：',id(Dct))
print('拷贝字典第一个键值对的值的id：',id(Dct[1]))
#输出结果：
"""
源字典内容： {1: [1, 2], 2: 3, 4: 5}
源字典id： 1544906243456
源字典第一个键值对的值的id： 1544908403136
=======================================
拷贝字典内容： {1: [1, 2], 2: 3, 4: 5}
拷贝字典id： 1544906406848
拷贝字典第一个键值对的值的id： 1544908403136
"""
4、集合
基本介绍
为无序可变序列，同一个集合中的各个元素都是唯一的，元素之间不允许重复，集合中只能包含不可变对象，集合在内部维护的哈希表使得查询操作的效率极高，由于哈希表的特点，于是集合会浪费较大的内存空间，是一种以空间换时间的数据结构，可以看作是为无"值"的字典，当然对应的方法还是大相径庭的
集合为可变序列，如果想要不可变的集合，可以使用内置库中的frozenset类构造的实例对象
方法
基本方法
(1)add（）
作用
向集合中添加一个元素，如果元素已经存在，没有任何效果，不会抛出异常
返回值
空类型对象 None
案例
s = {1,2,3}
s.add(3)
print(s)
#输出结果：{1, 2, 3}
s = {1,2,3}
s.add(4)
print(s)
#输出结果：{1, 2, 3, 4}
(2)update（）
作用
通过把一个可迭代对象中所有的元素添加到一个集合中，实现多个集合元素的添加
返回值
空类型对象 None
案例
s = {1,2,3}
s.update([4,5])
print(s)
#输出结果：{1, 2, 3, 4, 5}
(3)remove（）
作用
- 必须指定目标元素
- 目标元素存在，移除目标元素
- 目标元素不存在，抛出异常
返回值
空类型对象 None
案例
s = {1,2,3,4,5}
s.remove(2)
print(s)
#输出结果：{1, 3, 4, 5}
s = {1,2,3,4,5}
s.remove(6)
print(s)
#引发异常：KeyError: 6
(4)discard（）
作用
- 必须指定目标元素
- 目标元素存在，移除目标元素
- 目标元素不存在，不会抛出异常
返回值
空类型对象 None
案例
s = {1,2,3,4,5}
s.discard(2)
print(s)
#输出结果：{1, 3, 4, 5}
s = {1,2,3,4,5}
s.discard(6)
print(s)
#输出结果：{1, 2, 3, 4, 5}
(5)pop（）
作用
删除一个任意的元素，如果集合为空，则抛出异常
返回值
被删除的元素
案例
s = {1,2,3,4,5}
data = s.pop()
print(s,data)
#输出结果：{2, 3, 4, 5} 1
s = set() #注意空集合只能用set()构造
data = s.pop()
print(s,data)
#引发异常：KeyError: 'pop from an empty set'
(6)clear（）
作用
清除集合中的所有元素，使一个集合成为空集合
返回值
空类型对象 None
案例
s = {1,2,3,4,5}
s.clear()
print(s)
#输出结果：set()
集合的数学操作方法
(1)issubset（）
作用
判断该集合是否为一个集合的子集
返回值
布尔类型对象 True 或 False
案例
s1 = {1,2,3,4}
s2 = {1,2,3,4,5}
b = s1.issubset(s2)
print(b)
#输出结果：True
s = {1,2,3,4,5}
b = s.issubset(s) #一个集合为本身的子集
print(b)
#输出结果：True
(2)issuperset（）
作用
判断该集合是否为一个集合的超集
返回值
布尔类型对象 True 或 False
案例
s1 = {1,2,3,4,5,6}
s2 = {1,2,3,4,5}
b = s1.issuperset(s2)
print(b)
#输出结果：True
s = {1,2,3,4,5}
b = s.issuperset(s) #一个集合为本身的超集
print(b)
#输出结果：True
(3)isdisjoint（）
作用
判断两个集合是否没有交集
返回值
布尔类型对象 True 或 False
案例
s1 = {1,2,3}
s2 = {4,5}
b = s1.isdisjoint(s2)
print(b)
#输出结果：True
s1 = {1,2,3}
s2 = {3,4,5}
b = s1.isdisjoint(s2)
print(b)
#输出结果：False
(4)intersection（）
作用
可以求多个可迭代对象的交集，与运算符 & 等效
返回值
集合类型对象 多个可迭代对象的交集
案例
s1 = {1,2,3}
s2 = [2,3,4]
s3 = map(int,(3,4,5))
print(s1.intersection(s2,s3))
#输出结果：{3}
(5)union（）
作用
可以求多个可迭代对象的并集，与运算符 | 等效
返回值
集合类型对象 多个可迭代对象的并集
案例
s1 = {1,2,3}
s2 = [2,3,4]
s3 = map(int,(3,4,5))
print(s1.union(s2,s3))
#输出结果：{1, 2, 3, 4, 5}
(6)difference（）
作用
可以求多个可迭代对象的差集，与运算符 - 等效
返回值
集合类型对象 多个可迭代对象的差集（被减数始终为调用该方法的集合对象）
案例
s1 = {1,2,3}
s2 = [2,3,4]
s3 = map(int,(3,4,5))
print(s1.difference(s2,s3))
#输出结果：{1}
(7)symmetric_difference（）
作用
可以求两个可迭代对象的对称差集，与运算符 ^ 等效
返回值
集合类型对象 两个可迭代对象的对称差集
案例
s1 = {1,2,3}
s2 = [2,3,4]
print(s1.symmetric_difference(s2))
#输出结果：{1, 4}
5、字符串
基本介绍
为不可变有序序列，使用单引号、单双引号、三单引号、三双引号（双单引号和双双引号并不能成为定界符），特别地三引号可以分布在多行，不同定界符之间可以相互嵌套，且只能三单引号、三双引号在外，单引号、双引号在内，使用print进行字符串输出的时候，展示的结果中无最外层的定界符，元素必定都是字符串类型对象，每一个字符就是一个元素（例如"abc123"中的"a"、“b”、"1"都是该字符串的元素）
常用的基本方法
(1)join（）
作用
将一个序列（每一个元素皆为字符串）中的每一个元素用指定的字符串连接（可以为空字符），形成新的字符串返回
当需要进行字符串拼接的时候，尽量使用join方法而不是运算符 + ，因为join的构造过程是先计算出所有字符的长度，然后进行拷贝，建立一个对象，而使用运算符 + 要建立多个对象，效率较join方法低
返回值
字符串类型对象 一个将指定序列中的元素通过指定字符串拼接而成的字符串
案例
lst = ["1","2","3","4"]
tlp = ("1","2","3","4")
dct = {"1":1,"2":2,"3":3,"4":4}
st = {"1","2","3","4"}
sr = "1234"
print('列表拼接结果：',"*".join(lst))
print('元组拼接结果：',"*".join(tlp))
print('字典拼接结果：',"*".join(dct))
print('集合拼接结果：',"*".join(st))
print('字符串拼接结果：',"*".join(sr))
#输出结果：
"""
列表拼接结果： 1*2*3*4
元组拼接结果： 1*2*3*4
字典拼接结果： 1*2*3*4
集合拼接结果： 2*3*1*4
字符串拼接结果： 1*2*3*4
"""
(2)format（）
作用
实现字符串格式化（详细的使用方法在字符串的格式化中有进行讲解）
返回值
字符串类型对象 一个格式化的字符串
案例
sr = "{}, {}".format('amazing','因吹斯挺') #通过位置参数设置参数值
print(sr)
#输出结果：amazing, 因吹斯挺
sr = "{1}, {0}".format('amazing','因吹斯挺') #通过索引设置参数值
print(sr)
#输出结果：因吹斯挺, amazing
sr = "{a}, {b}".format(b = 'amazing',a = '因吹斯挺') #通过关键字参数设置参数值
print(sr)
#输出结果：因吹斯挺, amazing
字符串内容查询的方法
(1)index（）
作用
以从左向右的顺序，查找指定子串第一次出现的位置，如果不存在，会抛出异常
可以指定查询范围，会根据查询范围会先进行切片（即左闭右开），后进行查询
返回值
int类型对象 子串的第一个元素的下标
案例
sr = "12345"
ind = sr.index("5",2,5)
print(ind)
#输出结果：4
sr = "12345"
ind = sr.index("5",2,4)
print(ind)
#引发异常：ValueError: substring not found
(2)rindex（）
作用
以从右向左的顺序，查找指定子串第一次出现的位置，如果不存在，会抛出异常
可以指定查询范围，会根据查询范围会先进行切片（即左闭右开），后进行查询
返回值
int类型对象 子串的第一个元素的下标
案例
sr = "12345"
ind = sr.rindex("5",2,5)
print(ind)
#输出结果：4
sr = "12345"
ind = sr.index("5",2,4)
print(ind)
#引发异常：ValueError: substring not found
(3)find（）
作用
以从左向右的顺序，查找指定子串第一次出现的位置，如果不存在，不会抛出异常（返回 -1）
可以指定查询范围，会根据查询范围会先进行切片（即左闭右开），后进行查询
返回值
int类型对象 子串的第一个元素的下标
案例
sr = "12345"
ind = sr.find("5",2,5)
print(ind)
#输出结果：4
sr = "12345"
ind = sr.find("5",2,4)
print(ind)
#输出结果：-1
(4)rfind（）
作用
以从右向左的顺序，查找指定子串第一次出现的位置，如果不存在，不会抛出异常
可以指定查询范围，会根据查询范围会先进行切片（即左闭右开），后进行查询
返回值
int类型对象 子串的第一个元素的下标
案例
sr = "12345"
ind = sr.rfind("5",2,5)
print(ind)
#输出结果：4
sr = "12345"
ind = sr.rfind("5",2,4)
print(ind)
#输出结果：-1
(5)count（）
作用
得到子串在该字符串中出现的次数
可以指定查询范围，会根据查询范围会先进行切片（即左闭右开），后进行查询
返回值
int类型对象 子串出现的次数
案例
sr = "1234,12345,1234"
cnt = sr.count('23',1,10)
print(cnt)
#输出结果：2
字符串内容替换的方法
(1)replace（）
作用
对该字符串进行内容替换，把子串看作一个整体，从左到右进行该字符串内容的部分替换，可以指定替换次数（默认为-1，表示全部替换）
返回值
字符串类型对象 一个内容替换过的字符串
案例
sr = "hello Python Python Python"
Sr = sr.replace("Python","java",2)
print(Sr)
#输出结果：hello java java Python
(2)maketrans（）
作用
用来生成一个字符映射表（其实就是一个字典类型对象）
返回值
字典类型对象 一个标识被替换字符和替换字符对应关系的字典
(3)translate（）
作用
根据一个字符映射表（一般使用maketrans函数的返回值）作为依据，进行字符替换
返回值
字符串类型对象 替换内容之后的字符串
案例
dct = ''.maketrans("12","34")
print("maketrans方法生成的 转换表的内容 及 转换表类型 ：",dct,type(dct))
print("使用 自己定义 的字典对象进行转化：","123456".translate({49: 51, 50: 52}))
print("使用 maketrans方法生成 的转换表进行转化：","123456".translate(dct))
#输出结果：
"""
maketrans方法生成的 转换表的内容 及 转换表类型 ： {49: 51, 50: 52} <class 'dict'>
使用 自己定义 的字典对象进行转化： 343456
使用 maketrans方法生成 的转换表进行转化： 343456
"""
(4)expandtabs（）
作用
改变相邻制表符位置间的间隔（默认在第 0、8、16…等处给出制表符位置，即默认间隔为8个字符），将字符串中的转义字符 \t 替换为一定数目的空格，直到下一个制表符位置为止
返回值
字符串类型对象 替换内容之后的字符串
案例
sr = "123\t12345\t123"
print('原字符串（两个制表符位置之间间隔4个字符）：')
print(sr)
print('修改后的字符串（两个制表符位置之间间隔3个字符）：')
print(sr.expandtabs(3))
print('修改后的字符串（两个制表符位置之间间隔5个字符）：')
print(sr.expandtabs(5))
print('expandtabs方法的间隔默认值为8：')
print(sr.expandtabs())
#输出结果：
"""
原字符串（两个制表符位置之间间隔4个字符）：
123 12345 123
修改后的字符串（两个制表符位置之间间隔3个字符）：
123 12345 123
修改后的字符串（两个制表符位置之间间隔5个字符）：
123 12345 123
expandtabs方法的间隔默认值为：
123 12345 123
"""
字符串中英文字母大小写转化的方法
(1)upper（）
作用
将字符串中的所有英文字符都转化为大写字母
返回值
字符串类型对象 大小写转化之后的字符串
案例
sr = 'Hello World'
Sr = sr.upper()
print(Sr)
#输出结果：HELLO WORLD
(2)lower（）
作用
将字符串中的所有英文字符都转化为小写字母
返回值
字符串类型对象 大小写转化之后的字符串
案例
sr = 'Hello World'
Sr = sr.lower()
print(Sr)
#输出结果：hello world
(3)swapcase（）
作用
将字符串中的大写英文字符都转化为小写字母；小写英文字符都转化为大写字母
返回值
字符串类型对象 大小写转化之后的字符串
案例
sr = 'Hello World'
Sr = sr.swapcase()
print(Sr)
#输出结果：hELLO wORLD
(4)upper（）
作用
将字符串中的第一个英文字符转化为大写，后续英文字符都转化为小写
返回值
字符串类型对象 大小写转化之后的字符串
案例
sr = 'Hello World'
Sr = sr.capitalize()
print(Sr)
#输出结果：Hello world
(5)title（）
作用
将每一个连续的英文字符子串中的第一个英文字符转化为大写，该子串中的其他英文字符转化为小写
返回值
字符串类型对象 大小写转化之后的字符串
案例
sr = 'Hello World'
Sr = sr.title()
print(Sr)
#输出结果：Hello World
字符串中有效内容对齐的方法
(1)center（）
作用
根据指定宽度对字符串内容进行居中对齐
默认填充空格，可以修改
如果指定宽度小于原字符串长度，则返回原字符串；如果指定宽度和原字符串长度相减，为一个奇数，右边会比左边多填充一个字符
返回值
字符串类型对象 有效内容居中对齐之后的字符串
案例
sr = 'Hello'
Sr = sr.center(3,'*')
print(Sr)
#输出结果：Hello
sr = 'Hello'
Sr = sr.center(8,'*')
print(Sr)
#输出结果：*Hello**
(2)ljust（）
作用
根据指定宽度对字符串内容进行左对齐
默认填充空格，可以修改
如果指定宽度小于原字符串长度，则返回原字符串
返回值
字符串类型对象 有效内容左对齐之后的字符串
案例
sr = 'Hello'
Sr = sr.ljust(8,'*')
print(Sr)
#输出结果：Hello***
(3)rjust（）
作用
根据指定宽度对字符串内容进行右对齐
默认填充空格，可以修改
如果指定宽度小于原字符串长度，则返回原字符串
返回值
字符串类型对象 有效内容右对齐之后的字符串
案例
sr = 'Hello'
Sr = sr.rjust(8,'*')
print(Sr)
#输出结果：***Hello
sr = '-99'
Sr = sr.rjust(8,'*')
print(Sr)
#输出结果：*****-99
(4)zfill（）
作用
根据指定宽度对字符串内容进行右对齐
填充字符"0"，不可修改
如果指定宽度小于原字符串长度，则返回原字符串
返回值
字符串类型对象 有效内容右对齐之后的字符串
案例
sr = 'Hello'
Sr = sr.zfill(8)
print(Sr)
#输出结果：000Hello
sr = '-99'
Sr = sr.zfill(8)
print(Sr)
#输出结果：-0000099
字符串中对内容进行判断的方法
(1)isidentifier（）
作用
判断该字符串的内容是否为一个合法的标识符
返回值
布尔类型对象 True 或 False
案例
sr = "123hello"
b = sr.isidentifier()
print(b)
#输出结果：False
sr = "hello123"
b = sr.isidentifier()
print(b)
#输出结果：True
sr = "你好呀"
b = sr.isidentifier()
print(b)
#输出结果：True
(2)isupper（）
作用
判断该字符串的内容是否具有英文字符，并且全为大写字母
返回值
布尔类型对象 True 或 False
案例
sr = "123"
b = sr.isupper()
print(b)
#输出结果：False
sr = "123A"
b = sr.isupper()
print(b)
#输出结果：True
sr = "123Aa"
b = sr.isupper()
print(b)
#输出结果：False
(3)islower（）
作用
判断该字符串的内容是否具有英文字符，并且全为小写字母
返回值
布尔类型对象 True 或 False
案例
sr = "123"
b = sr.islower()
print(b)
#输出结果：False
sr = "123a"
b = sr.islower()
print(b)
#输出结果：True
sr = "123aA"
b = sr.isupper()
print(b)
#输出结果：False
(4)istitle（）
作用
判断该字符串的内容是否每一个连续的英文字符子串中的第一个英文字符为大写，该子串中的其他英文字符为小写
返回值
布尔类型对象 True 或 False
案例
sr = "123Aa123Aa"
b = sr.istitle()
print(b)
#输出结果：True
sr = "123Aa123a"
b = sr.istitle()
print(b)
#输出结果：False
(5)isascii（）
作用
判断该字符串的内容是否全部属于128个标准ASCII码字符集
返回值
布尔类型对象 True 或 False
案例
sr = "123ABCabc"
b = sr.isascii()
print(b)
#输出结果：True
sr = "123ABCabc你好呀"
b = sr.isascii()
print(b)
#输出结果：False
(6)isalpha（）
作用
判断该字符串的内容是否全部由字母构成
返回值
布尔类型对象 True 或 False
案例
sr = "ABCabc你好呀"
b = sr.isalpha()
print(b)
#输出结果：True
(7)isdigit（）
作用
判断该字符串的内容是否全部由数字构成
支持Unicode数字、全角数字（双字节）、Byte数字（单字节）
不支持小数、罗马数字、汉字数字
均不会抛出异常
返回值
布尔类型对象 True 或 False
案例
sr = "123"
b = sr.isdigit()
print(b)
#输出结果：True
sr = "１２３"
b = sr.isdigit()
print(b)
#输出结果：True
sr = "12.3"
b = sr.isdigit()
print(b)
#输出结果：False
sr = "ⅠⅡⅢ"
b = sr.isdigit()
print(b)
#输出结果：False
sr = "一二三"
b = sr.isdigit()
print(b)
#输出结果：False
sr = b"123"
b = sr.isdigit()
print(b)
#输出结果：True
(8)isdecimal（）
作用
判断该字符串的内容是否全部由数字构成
支持Unicode数字、全角数字（双字节）
不支持小数、罗马数字、汉字数字、Byte数字（单字节）
当该字符内容为Byte数字（单字节）时，会抛出异常
返回值
布尔类型对象 True 或 False
案例
sr = "123"
b = sr.isdecimal()
print(b)
#输出结果：True
sr = "１２３"
b = sr.isdecimal()
print(b)
#输出结果：True
sr = "12.3"
b = sr.isdecimal()
print(b)
#输出结果：False
sr = "ⅠⅡⅢ"
b = sr.isdecimal()
print(b)
#输出结果：False
sr = "一二三"
b = sr.isdecimal()
print(b)
#输出结果：False
sr = b"123"
b = sr.isdecimal()
print(b)
#引发异常：AttributeError: 'bytes' object has no attribute 'isdecimal'
(9)isnumeric（）
作用
判断该字符串的内容是否全部由数字构成
支持Unicode数字、全角数字（双字节）、罗马数字、汉字数字
不支持小数、Byte数字（单字节）
当该字符内容为Byte数字（单字节）时，会抛出异常
返回值
布尔类型对象 True 或 False
案例
sr = "123"
b = sr.isnumeric()
print(b)
#输出结果：True
sr = "１２３"
b = sr.isnumeric()
print(b)
#输出结果：True
sr = "12.3"
b = sr.isnumeric()
print(b)
#输出结果：False
sr = "ⅠⅡⅢ"
b = sr.isnumeric()
print(b)
#输出结果：True
sr = "一二三"
b = sr.isnumeric()
print(b)
#输出结果：True
sr = b"123"
b = sr.isnumeric()
print(b)
#引发异常：AttributeError: 'bytes' object has no attribute 'isnumeric'
(9)isalnum（）
作用
判断该字符串的内容是否全部由数字或者字母构成
支持Unicode数字、全角数字（双字节）、罗马数字、汉字数字、Byte数字（单字节）
不支持小数
当该字符内容为Byte数字（单字节）时，会抛出异常
返回值
布尔类型对象 True 或 False
案例
sr = "123ABCabc"
b = sr.isalnum()
print(b)
#输出结果：True
sr = "123ABCabc你好呀"
b = sr.isalnum()
print(b)
#输出结果：True
sr = "123"
b = sr.isalnum()
print(b)
#输出结果：True
sr = "１２３"
b = sr.isalnum()
print(b)
#输出结果：True
sr = "12.3"
b = sr.isalnum()
print(b)
#输出结果：False
sr = "ⅠⅡⅢ"
b = sr.isalnum()
print(b)
#输出结果：True
sr = "一二三"
b = sr.isalnum()
print(b)
#输出结果：True
sr = b"123"
b = sr.isalnum()
print(b)
#输出结果：True
(10)startswith（）
作用
判断该字符串是否以指定子串开头
通过传入一个元素皆为字符串类型对象的元组，可以指定多个子串，如果该字符串以其中的任意一个子串开头，都会返回True
可以指定查询范围，会根据查询范围会先进行切片（即左闭右开），后进行查询
返回值
布尔类型对象 True 或 False
案例
sr = "123ABC"
b = sr.startswith("12",0,1)
print(b)
#输出结果：False
sr = "123ABC"
b = sr.startswith("12",0,2)
print(b)
#输出结果：True
sr1 = "123ABC"
b = sr1.startswith(("12","AB"))
print("对第一个字符串的判断结果：",b)
sr2 = "ABC123"
b = sr2.startswith(("12","AB"))
print("对第一个字符串的判断结果：",b)
#输出结果：
"""
对第一个字符串的判断结果： True
对第一个字符串的判断结果： True
"""
(11)endswith（）
作用
判断该字符串是否以指定子串结尾
通过传入一个元素皆为字符串类型对象的元组，可以指定多个子串，如果该字符串以其中的任意一个子串结尾，都会返回True
可以指定查询范围，会根据查询范围会先进行切片（即左闭右开），后进行查询
返回值
布尔类型对象 True 或 False
案例
sr = "123ABC"
b = sr.endswith("BC",0,5)
print(b)
#输出结果：False
sr = "123ABC"
b = sr.endswith("BC",0,6)
print(b)
#输出结果：True
sr1 = "123ABC"
b = sr1.endswith(("23","BC"))
print("对第一个字符串的判断结果：",b)
sr2 = "ABC123"
b = sr2.endswith(("23","BC"))
print("对第一个字符串的判断结果：",b)
#输出结果：
"""
对第一个字符串的判断结果： True
对第一个字符串的判断结果： True
"""
(12)isprintable（）
作用
判断该字符串的内容是否全部属于可打印字符
返回值
布尔类型对象 True 或 False
案例
sr = "123ABC你好呀"
b = sr.isprintable()
print(b)
#输出结果：True
sr = "\n"
b = sr.isprintable()
print(b)
#输出结果：False
"""
(13)isspace（）
作用
判断该字符串的内容是否全部属于空白字符
返回值
布尔类型对象 True 或 False
案例
sr = "\n\v\r\t\f "
b = sr.isspace()
print(b)
#输出结果：True
sr = "123"
b = sr.isspace()
print(b)
#输出结果：False
"""
实现字符串劈分的方法
(1)split（）
作用
把指定字符串看作一个整体
以从左向右的顺序，根据分隔符（默认为空白字符）进行劈分
没有指定分隔符时，所有的连续出现的空白字符（即使类型不同）都看作一个分隔符进行劈分
明确指定分隔符时，只会识别这个分隔符，所以必定会在分隔符两端进行劈分，不管分隔符是否连续，其实可以看作join方法的逆运算，如果将劈分结果再调用join方法和劈分字符，可以进行字符串的还原
可以指定最大劈分次数（默认为-1，表示全部劈分，指定次数可以大于实际可以进行分割的次数），剩下未劈分的字符串会保留为一个子串
返回值
列表类型对象 一个元素皆为原字符串子串的列表，元素的数目为劈分次数+1
案例
sr = "1 2 \n 3 \t 4"
lst = sr.split()
print(lst)
#输出结果：['1', '2', '3', '4']
sr = "1**2*3*4***"
lst = sr.split('*')
print(lst)
#输出结果：['1', '', '2', '3', '4', '', '', '']
sr = "1**2*3*4***"
lst = sr.split('*',4)
print(lst)
#输出结果：['1', '', '2', '3', '4***']
(2)rsplit（）
作用
把指定字符串看作一个整体
以从右向左的顺序，根据分隔符（默认为空白字符）进行劈分
没有指定分隔符时，所有的连续出现的空白字符（即使类型不同）都看作一个分隔符进行劈分
明确指定分隔符时，只会识别这个分隔符，所以必定会在分隔符两端进行劈分，不管分隔符是否连续，其实可以看作join方法的逆运算，如果将劈分结果再调用join方法和劈分字符，可以进行字符串的还原
可以指定最大劈分次数（默认为-1，表示全部劈分，指定次数可以大于实际可以进行分割的次数），剩下未劈分的字符串会保留为一个子串
返回值
列表类型对象 一个元素皆为原字符串子串的列表，元素的数目为劈分次数+1
案例
sr = "1 2 \n 3 \t 4"
lst = sr.rsplit()
print(lst)
#输出结果：['1', '2', '3', '4']
sr = "1**2*3*4***"
lst = sr.rsplit('*')
print(lst)
#输出结果：['1', '', '2', '3', '4', '', '', '']
sr = "1**2*3*4***"
lst = sr.rsplit('*',4)
print(lst)
#输出结果：['1**2*3', '4', '', '', '']
(3)partition（）
作用
把指定字符串看作一个整体
只进行两次劈分，以从左向右的顺序，将字符串分割为三部分：
1.分隔符位置之前的字符串
2.分隔符字符串
3.分隔符位置之后的字符串
如果指定的分隔符不在指定的字符串中，则返回原字符串和两个空字符串
如果具有多个分隔符，则把遇到的第一个分隔符作为进行分割的标准
返回值
元组类型对象 一个具有三个字符串元素的元组
案例
s = "12345"
tpl = s.partition("6")
print(tpl)
#输出结果：('12345', '', '')
s = "12345"
tpl = s.partition("3")
print(tpl)
#输出结果：('12', '3', '45')
(4)rpartition（）
作用
把指定字符串看作一个整体
只进行两次劈分，以从右向左的顺序，将字符串分割为三部分：
1.分隔符位置之前的字符串
2.分隔符字符串
3.分隔符位置之后的字符串
如果指定的分隔符不在指定的字符串中，则返回两个空字符串和原字符串
如果具有多个分隔符，则把遇到的第一个分隔符作为进行分割的标准
返回值
元组类型对象 一个具有三个字符串元素的元组
案例
s = "12345"
tpl = s.rpartition("6")
print(tpl)
#输出结果：('', '', '12345')
s = "12345"
tpl = s.rpartition("3")
print(tpl)
#输出结果：('12', '3', '45')
字符串内容修整的方法
(1)strip（）
作用
把指定字符串中的每一个字符串元素单独识别
删除字符串两端的指定字符（默认为空白字符，可以修改），split方法不指定分割符的情况下也可以实现两端空白字符的删除，借助join方法可以达到相同的效果
从左右两边一层层往里面进行指定字符串的删除，直到遇到非指定字符
返回值
字符串类型对象 一个删除了左右两端指定字符的字符串
案例
s = "abc1234def"
S = s.strip('abcdef')
print(S)
#输出结果：1234
(2)rstrip（）
作用
把指定字符串中的每一个字符串元素单独识别
删除字符串右端包含在指定字符串的字符（默认为空白字符，可以修改）
从右边一层层往里面进行指定字符串的删除，直到遇到非指定字符
返回值
字符串类型对象 一个删除了右端指定字符的字符串
案例
s = "abc1234def"
S = s.rstrip('abcdef')
print(S)
#输出结果：abc1234
(3)lstrip（）
作用
把指定字符串中的每一个字符串元素单独识别
删除字符串左端包含在指定字符串的字符（默认为空白字符，可以修改）
从左边一层层往里面进行指定字符串的删除，直到遇到非指定字符
返回值
字符串类型对象 一个删除了左端指定字符的字符串
案例
s = "abc1234def"
S = s.lstrip('abcdef')
print(S)
#输出结果：1234def
1359
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
