容器类型的进阶应用（列表、元组）

1. 列表同元组的拼接和反复
2. 列表同元组的索引和数据元素的获取
3. 列表同元组的切片
4. 列表同元组元素的批改和删除
5. 列表同元组的内置函数

本文目录

@[toc]

列表和元组的拼接和反复

应用 + 能够将多个列表或者是元组联合成为一个

lst = [1, 2, 3]
lst1 = ['one', 'two', 'three']
res =lst + lst1
print(res)  # [1, 2, 3, 'one', 'two', 'three']


tup = (11, 22, 33)
tup1 = ('aa', 'bb', 'cc')
res = tup + tup1
print(res)  # (11, 22, 33, 'aa', 'bb', 'cc')

应用 * 能够将其中的元素反复屡次

lst = [1, 2, 3] * 3
print(lst)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]


tup = (11, 22, 33) * 2
print(tup)  # (11, 22, 33, 11, 22, 33)

列表同元组的索引和数据元素的获取

咱们之前说过，字符串和列表、元组这三种容器的独特特点是，有序、可获取，且都存在正逆向下标索引。

lst = ['one', 'two', 'three']
res = lst[0]
print(res)  # one


tup = ('aa', 'bb', 'cc')
res = tup[-1]
print(res)  # cc

列表同元组的切片

列表、元组和字符串的切片的应用办法都是截然不同的，这里咱们就不再过多的叙述了，详情请见上一篇，容器类型的进阶应用（字符串）：字符串的切片。

语法：string[开始索引: 完结索引: 距离值]

lst = ['宋江', '卢俊义', '吴用', '关胜', '林冲']

# 1、[开始索引:] 从开始截取至最初
res = lst[2:]
print(res)      # ['吴用', '关胜', '林冲']

# 2、[: 完结索引] 从结尾截取至完结前一个元素
res = lst[:4]
print(res)      # ['宋江', '卢俊义', '吴用', '关胜']


# 3、[开始索引: 完结索引] 从开始截取至完结前一个元素
res = lst[1:3]
print(res)      # ['卢俊义', '吴用']

# 4、[开始索引: 完结索引: 距离值] 依照距离值从开始截取至完结前一个元素
res = lst[1:4:2]
print(res)      # ['卢俊义', '关胜']

列表同元组元素的批改和删除

还记得咱们的将六大数据类型的时候的总结吗？列表是可批改的，而元组是不可批改的，既然不可批改也就不能删除其中的元素。

批改数据元素

如果咱们要批改或者是删除列表或者是其它可批改的其它容器中的数据元素的时候，我要首先要指定数据元素的地位，就像获取一样。而后像定义变量一样从新赋值一个新值，就能够将原有的旧数据笼罩掉。

# 指定一个元素地位赋予新值
lst[3] = '关羽'
print(lst)  # ['宋江', '卢俊义', '吴用', '关羽', '林冲']

也能够应用切片一次批改多个元素，没有数量上的限度

# 抉择一个范畴，批量的赋予新值
lst[1:3] = '武松'
print(lst)  # ['宋江', '武', '松', '关胜', '林冲']

lst[1:3] = '武松', '鲁智深'
print(lst)  # ['宋江', '武松', '鲁智深', '关胜', '林冲']

# 留神，如果咱们抉择的范畴过大，然而却不能赋予等同数量的值，那么就会导致前面没能赋予新值的值删除
lst[1:3] = '时迁',
print(lst)  # ['宋江', '时迁', '关胜', '林冲']

# 如果赋予的值过多，就会导致数据的插队
lst[1:3] = '晁盖', '阮小七', '李逵', '史进', '花荣'
print(lst)  # ['宋江', '晁盖', '阮小七', '李逵', '史进', '花荣', '林冲']

元组是不能够批改数据的，那么元组中的列表的数据元素能批改吗？答案是必定的，元组不反对批改的元组的一级元素。

tup = (1, 2, 3, [4, 5, 6])
# tup[0] = '123'  # error，元组的数据元素不能够批改
tup[-1][1] = '刘备'
print(tup)  # (1, 2, 3, [4, '刘备', 6])

删除数据元素

说到删除数据元素，咱们要学习一个关键字的应用 del，应用的楼就能够删除咱们不想要的数据，以此来开释内存。

语法：del + 数据

删除列表中的元素

# 单个删除
lst = ['宋江', '卢俊义', '吴用', '关胜', '林冲']
del lst[1]
print(lst)  # ['宋江', '吴用', '关胜', '林冲']

# 批量删除
lst = ['宋江', '卢俊义', '吴用', '关胜', '林冲']
del lst[1:4]
print(lst)  # ['宋江', '林冲']

del不仅能够删除容器中的数据，还能够间接删除变量

lst = ['宋江', '卢俊义', '吴用', '关胜', '林冲']

print(lst)  # ['宋江', '卢俊义', '吴用', '关胜', '林冲']

del lst
print(lst)  # error，名为 lst 的数据不存在

列表同元组的内置函数

列表增删改查相干函数

在下面咱们对列表这个难的数据元素进行操作的时候，感觉局限性很大，而且有很大的不适感，更要害的中央在于有对数据误操作的可能性，所以咱们更举荐应用内置函数来对数据元素进行相干的操作。

增加数据

append 开端增加数据，单个增加

lst = [1, 2, 3]
lst.append('msr')
print(lst)  # [1, 2, 3, 'msr']

insert 在指定的地位之前增加数据

lst.insert(1, 'msr20666')
print(lst)  # [1, 'msr20666', 2, 3, 'msr']
lst.insert(-1, 'hello')
print(lst)  # [1, 'msr20666', 2, 3, 'hello', 'msr']

增加数据只有应用 +和 extend 才能够批量的增加数据，然而 + 只能和等同的数据类型，而 extend 能够反对可迭代的数据类型。

# 应用 extend 迭代增加数据元素
lst = [1, 2, 3]
newcont = [11, 22, 33]
lst.extend(newcont)
print(lst)  # [1, 2, 3, 11, 22, 33]

# 反对其它的可迭代的数据类型
newcont1 = 'abc'
lst.extend(newcont1)
print(lst)  # [1, 2, 3, 11, 22, 33, 'a', 'b', 'c']

删除数据

应用 pop 删除指定索引元素，默认值为 -1

lst = [1, 2, 3, 4, 5]
res = lst.pop()
print(res)  # 5
print(lst)  # [1, 2, 3, 4]

res = lst.pop(3)
print(res)  # 4
print(lst)  # [1, 2, 3]

应用 remove 删除指定的值，如果有多个雷同的值，删除第一个，如果没有这个值，就会报错。

lst = ['msr20666', 'msr', 1, 2, 3, 'msr']

lst.remove('msr')
print(lst)  # ['msr20666', 1, 2, 3, 'msr']

lst.remove(4)   # error, 没有这个值

应用 clear 清空列表

lst = [1, 2, 3, 4]
lst.clear()
print(lst)  # []

列表元组独特的罕用内置函数

index

获取某个元素的索引值；如果有多个雷同的值，获取第一个数据的索引值；如果没有该数据，就会报错。

语法：container.index(value, [start], [end])

# 查找某个数据的索引
lst = [1, 2, 3, 1, 2, 3]
res = lst.index(1)
print(res)  # 0

# 在某个范畴中查找
tup = (1, 2, 3, 1, 2, 3)
res = lst.index(1, 3)    # 从索引 3 开始查找数据 1
print(res)  # 3

count

计算某个元素呈现的数量，列表中的 count 与字符串中的不同，字符串中的 count 能够划定范畴，列表中的不反对此性能。

lst = [1, 2, 3, 1, 2, 3]
res = lst.count(1)
print(res)  # 2

sort

给容器中的数据元素依照大小进行排序，默认是从小到大的。

# 默认状况是从小到大排序的
lst = [1, 334, 44, 55, 56, 65, 67, 78,]
lst.sort()
print(lst)  # [1, 44, 55, 56, 65, 67, 78, 334]

sort 也能够依照从大到小的程序进行排序，默认状况下 sort 的参数 reverse 的值是 False，只有将值改成 True 即可。

lst = [1, 334, 44, 55, 56, 65, 67, 78,]
lst.sort(reverse=True)
print(lst)  # [334, 78, 67, 65, 56, 55, 44, 1]

字符串进行排序。如果是数字类型的字符串进行排序，不是依照数字的大小进行，而是依照第一位的元素进行排序，如果第一位雷同，而后依照第二位，顺次类推；如果是英文字母，依照 ASCII 编码进行排序，排序的办法和规定和数字字符串雷同；如果是中文或者是其它的字符，排序没有法则可言；一个列表中如果有字符串类型和数字类型，不能应用排序，否则报错。

# 排序数字
lst = ['1', '334', '44', '55', '56', '65', '67', '78',]
lst.sort()
print(lst)  # ['1', '334', '44', '55', '56', '65', '67', '78']

# 排序字母，依照 ASCII 码表，正序为：A -> Z -> a -> z
lst = ['apple', 'Microsoft', 'IBM', 'huawei', 'Cisco']
lst.sort()
print(lst)  # ['Cisco', 'IBM', 'Microsoft', 'apple', 'huawei']

ASCII 编码表

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-U7YR9g3f-1647077804821)(imgs/ASCII.jpg)]

reverse

将列表中的程序反转

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst.reverse()
print(lst)  # [9, 8, 7, 6, 5, 4, 3, 2, 1]