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

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

本文目录

@

目录

• 容器类型的进阶使用（列表、元组）
  • • 本文目录
    • 列表和元组的拼接和重复
    • 列表同元组的索引和数据元素的获取
    • 列表同元组的切片
    • 列表同元组元素的修改和删除
      • • 修改数据元素
        • 删除数据元素
    • 列表同元组的内置函数
      • 列表增删改查相关函数
        • 添加数据
        • 删除数据
      • 列表元组共同的常用内置函数
        • index
        • count
        • sort
        • reverse

列表和元组的拼接和重复

使用 + 可以将多个列表或者是元组结合成为一个

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]

来源：https://www.cnblogs.com/msr20666/p/15997880.html
本站部分图文来源于网络，如有侵权请联系删除。