Python数据容器(五)

一.数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

• 每一个元素，可以是任意类型的据数，如字符串、数字、布尔等
• 根据特点的不同可分为5类:列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
  

---

二.列表(list)

列表内的每一个数据，称之为元素

(1) 基本格式

# 定义列表
变量名称 = [元素1, 元素2, 元素3, 元素4, 元素5]
# 定义空列表
变量名称 = []
变量名称 = list()

• 以中括号 [] 作为标识

• 列表内每一个元素之间用, 逗号隔开

• 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

• 使用示例:

my_list_1 = ["观止", 20, True, ["guanzhi", 20]]
my_list_2 = ["观止", 20, True]
print(my_list_2)
print(type(my_list_1))
# 输出
# ['观止', 20, True]
# <class 'list'>

(2) 列表的下标（索引）

我们可以使用下标索引从列表中取出特定位置的数据

• 列表中的每一个元素，都有其对应位置下标索引
• 要注意下标索引的取值范围(有值的位置)，超出范围(没值的位置)无法取出元素，并且会报错
• 语法：变量 = 列表[下标索引]

(2.1) 正向索引

• 从前向后的方向，从0开始，依次递增

• 使用示例:

# 语法： 列表[下标索引]
my_list = ["李白", "章北海", "杜甫"]
print(my_list[0]) # 打印 李白
print(my_list[1]) # 打印 章北海
print(my_list[2]) # 打印 杜甫

(2.2) 反向索引

• 从后向前：从**-1**开始，依次递减（-1、-2、-3…）

• 使用示例:

my_list = ["李白", "章北海", "杜甫"]
print(my_list[-1]) # 打印 杜甫
print(my_list[-2]) # 打印 章北海
print(my_list[-3]) # 打印 李白

(2.3) 嵌套列表的索引

• 如果列表是嵌套的列表，同样支持下标索引，且用法与上述类似

• 使用示例:

# 语法： 列表[外层列表下标索引][内层列表下标索引]
my_list = [["李白", "章北海"], ["罗辑", "杜甫"]]
print(my_list[0][0]) # 打印 李白
print(my_list[0][1]) # 打印 章北海
print(my_list[1][0]) # 打印 罗辑
print(my_list[1][1]) # 打印 杜甫

(3) 列表的常用操作

列表提供了一系列方法：如果将函数定义为class（类）的成员，那么函数称之为：方法

使用方式	作用
列表.append(元素)	向列表中追加一个元素
列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
列表.insert(下标, 元素)	在指定下标处，插入指定的元素
del 列表[下标]	删除列表指定下标元素
列表.pop(下标)	删除列表指定下标元素
列表.remove(元素)	从前向后，删除此元素第一个匹配项
列表.clear()	清空列表
列表.count(元素)	统计此元素在列表中出现的次数
列表.index(元素)	查找指定元素在列表的下标 找不到报错ValueError
len(列表)	统计容器内有多少元素

• 不需要硬记下来,有一个模糊印象，知晓有这样的用法,需要的时候，随时查阅资料即可

(3.1) 查询元素

查找某元素的下标

• 查找指定元素在列表的下标，如果找不到，报错ValueError
• 语法：列表.index(元素)

my_list = ["李白", "章北海", "罗辑", "杜甫"]
print(my_list.index("罗辑")) # 打印 2
print(my_list.index("观止")) # 打印 ValueError: '观止' is not in list

(3.2) 修改元素

修改特定位置（索引）的元素值

• 直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）
• 语法一：列表[下标] = 值

my_list = ["李白", "章北海", "罗辑", "杜甫"]
my_list[0] = "观止"
my_list[-1] = "study"
print(my_list) # 打印 ['观止', '章北海', '罗辑', 'study']

(3.3) 插入元素

在指定的下标位置，插入指定的元素

• 语法：列表.insert(下标, 元素)

my_list = ["李白", "章北海", "罗辑"]
my_list.insert(1, "观止")
print(my_list) # 打印 ['李白', '观止', '章北海', '罗辑']

(3.4) 追加元素

将指定元素，追加到列表的尾部

• 语法一：列表.append(元素)

my_list = ["李白", "章北海", "罗辑"]
my_list.append("观止")
print(my_list) # 打印 ['李白', '章北海', '罗辑', '观止']

• 语法一：列表.extend(其它数据容器)
• 将其它数据容器的内容取出，依次追加到列表尾部

my_list_1 = ["李白", "章北海"]
my_list_2 = ["罗辑", "观止"]
my_list_1.extend(my_list_2)
print(my_list_1) # 打印 ['李白', '章北海', '罗辑', '观止']

(3.5) 删除元素

• 语法一:del 列表[下标]

my_list = ["李白", "章北海", "罗辑"]
del my_list[0]
print(my_list) # 打印 ['章北海', '罗辑']

• 语法二:列表.pop(下标)

my_list = ["李白", "章北海", "罗辑"]
my_list.pop(0)
print(my_list) # 打印 ['章北海', '罗辑']

• 语法三:列表.remove(元素)
• 删除某元素在列表中的第一个匹配项

my_list = ["李白", "章北海", "罗辑", "李白"]
my_list.remove("李白")
print(my_list) # 打印 ['章北海', '罗辑', '李白']

(3.6) 清空列表内容

• 语法:列表.clear()

my_list = ["李白", "章北海", "罗辑"]
my_list.clear()
print(my_list) # 打印 []

(3.7) 统计某元素在列表内的数量

• 语法:列表.count(元素)

my_list = ["李白", "章北海", "罗辑", "李白"]
num = my_list.count("李白")
print(num) # 打印 2

(3.8) 统计列表内有多少元素

• 语法:len(列表)

my_list = ["李白", "章北海", "罗辑", "李白"]
print(len(my_list)) # 打印 4

(4) 列表的遍历

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

• 可以使用循环遍历列表的元素

• 通过列表[下标]的方式在循环中取出列表的元素

• 循环条件为 下标值 < 列表的元素数量

(4.1) while循环遍历

• 基本格式

index = 0
while index < len(列表):
    元素 = 列表[index]
#    对元素进行处理
    index += 1 

• 使用示例：

my_list = [1,2,3,4]
index = 0
while index < len(my_list):
    num = my_list[index]
    print(num)
    index += 1 
# 输出
# 1
# 2
# 3
# 4

(4.2) for循环遍历

• 依次取出元素并赋值到临时变量上,在每一次的循环中，可以对临时变量（元素）进行处理。
• 基本格式：

for 临时变量 in 数据容器:
    对临时变量（元素）进行处理

• 使用示例：

my_list = [1, 2, 3, 4]
for x in my_list:
    print(x)
# 输出
# 1
# 2
# 3
# 4

(4.3) for与while对比

• 在循环控制上：

  • while循环可以自定循环条件，并自行控制

  • for循环不可以自定循环条件，只可以一个个从容器内取出数据

• 在无限循环上：

  • while循环可以通过条件控制做到无限循环

  • for循环理论上不可以，因为被遍历的容器容量不是无限的

• 在使用场景上：

  • while循环适用于任何想要循环的场景

  • for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

(5) 列表小结

• 列表特点:

  • 可以容纳多个元素（上限为2**63-1、9223372036854775807个）

  • 可以容纳不同类型的元素（混装）

  • 数据是有序存储的（有下标序号）

  • 允许重复数据存在

  • 可以修改（增加或删除元素等）

---

三.元组(tuple)

元组同列表一样,但一旦定义完成，就不可修改

(1) 基本格式

# 定义元组
变量名称 = (元素1, 元素2, 元素3, 元素4, 元素5)
# 定义只有一个元素的元组
变量名称 = (元素1,)
# 定义空元组
变量名称 = ()
变量名称 = tuple()

• 以小括号 () 作为标识

• 列表内每一个元素之间用, 逗号隔开

• 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

• 使用示例:

my_tuple_1 = ("观止", 20, True, ("guanzhi", 20))
my_tuple_2 = ("观止", 20, True)
print(my_tuple_2)
print(type(my_tuple_1))
# 输出
# ('观止', 20, True)
# <class 'tuple'>

• 元组只有一个数据，这个数据后面要添加逗号，否则不是元组

my_tuple = ("观止")
print(type(my_tuple)) # 打印 <class 'str'>
my_tuple = ("观止",)
print(type(my_tuple))  # 打印 <class 'tuple'>

• 嵌套元组使用:

# 获取值方式与列表一致
my_tuple = ((1, 2, 3), (4, 5, 6))
print(my_tuple[0][0]) # 打印 1

(2) 元组的常用操作

元组由于不可修改的特性，所以其操作方法非常少。

方法	作用
元组.index(元素)	查找某个数据，如果数据存在返回对应的下标，否则报错
元组.count(元素)	统计某个数据在当前元组出现的次数
len(元组)	统计元组内的元素个数

(2.1) 查询元素

• 根据下标(索引)取出数据
• 语法：元组[下标索引]

my_tuple = ("观止", True, 20)
print(my_tuple[0])  # 打印 观止

• 查找特定元素的第一个匹配项

• 语法：元组.index(元素)

my_tuple = ("观止", True, "观止")
print(my_tuple.index("观止"))  # 打印 0

(2.2) 统计操作

• 统计某个数据在元组内出现次数
• 语法一：元组.count(元素)

my_tuple = ("观止", True, "观止")
print(my_tuple.count("观止"))  # 打印 2

• 统计元组内元素个数
• 语法二：len(元组)

my_tuple = ("观止", True, "观止")
print(len(my_tuple))  # 打印 3

(2.3) 注意事项

• 不可以修改元组的内容，否则会直接报错

my_tuple = (1, True, "观止")
my_tuple[0] = 5 # 报错 'tuple' object does not support item assignment

• 可以修改元组内的list的内容（修改元素、增加、删除、反转等）

my_tuple = (1, True, [2, 3, 4])
my_tuple[2][0] = 5
print(my_tuple) # 打印 (1, True, [5, 3, 4])

• 不可以替换list为其它list或其它类型

my_tuple = (1, True, [2, 3, 4])
my_tuple[2] = [1, 2, 3] # 报错

(3) 元组小结

• 可以与列表一样使用for与while循环遍历
• 多数特性和list一致，不同点在于不可修改的特性
• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）

---

四.字符串(str)

字符串是字符的容器，一个字符串可以存放任意数量的字符。

• 同元组一样,字符串是一个无法修改的数据容器
  

(1) 索引取值

• 同列表、元组一样，字符串也可以通过下标进行访问
  • 从前向后，下标从0开始
  • 从后向前，下标从-1开始

name = "guanzhi"
print(name[0])  # 打印 g
print(name[-1])  # 打印 i

(2) 字符串的常用操作

操作	说明
字符串[下标]	根据下标索引取出特定位置字符
字符串.index(字符串）	查找给定字符的第一个匹配项的下标
字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
字符串.split(字符串)	按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
字符串.count(字符串)	统计字符串内某字符串的出现次数
len(字符串)	统计字符串的字符个数

(2.1) 查找元素

查找特定字符串的下标索引值

• 语法：字符串.index(字符串)

name = "guanzhi"
print(name.index("a"))  # 打印 2

(2.2) 替换元素

将字符串内的全部：字符串1，替换为字符串2

• 语法：字符串.replace(字符串1，字符串2）

name = "guanzhi"
new_name = name_1.replace("guan", "study")
print(name)  # 打印 guanzhi
print(new_name)  # 打印 studyzhi

• 不是修改字符串本身，而是得到了一个新字符串

(2.3) 分割元素

按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

• 语法：字符串.split(分隔符字符串）

name = "guanzhi,study,20"
new_list = name.split(",")
print(name)  # 打印 guanzhi,study,20
print(new_list)  # 打印 ['guanzhi', 'study', '20']
print(type(new_list))  # 打印 <class 'list'>
# 字符串按照给定的,进行了分割，变成多个子字符串，并存入一个列表对象中

• 字符串本身不变，而是得到了一个列表对象

(2.4) 规整操作

• 去前后空格以及换行符
• 语法一：字符串.strip()

name = "  guanzhi  "
new_name = name.strip()
print(new_name)  # 打印 guanzhi

• 去前后指定字符串
• 语法二：字符串.strip(字符串)

name = "20guanzhi20"
new_name = name.strip("20")
print(name)  # 打印 20guanzhi20
print(new_name)  # 打印 guanzhi

• 字符串本身不变，而是得到了一个新字符串

(2.5) 统计操作

• 统计字符串中某字符串的出现次数
• 语法一：字符串.count(字符串)

name = "20guanzhi20"
print(name.count("20"))  # 打印 2

• 统计字符串的长度
• 语法二：len(字符串)

name = "20guanzhi 20"
print(len(name))  # 打印 12

• 数字（1、2、3…），字母（abcd、ABCD等），符号（空格、!、@、#、$等），中文均算作1个字符

(3) 字符串小结

• 同列表、元组一样，字符串也支持while循环和for循环进行遍历

• 特点：

  • 只可以存储字符串
  • 长度任意（取决于内存大小）
  • 支持下标索引
  • 允许重复字符串存在
  • 不可以修改（增加或删除元素等）

• 基本和列表、元组相同

  • 不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。

  • 不同于列表，相同于元组的在于：字符串不可修改

---

五.数据容器（序列）的切片

序列：内容连续、有序，可使用下标索引的一类数据容器

切片：从一个序列中，取出一个子序列

• 序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求
• 序列支持切片，即：列表、元组、字符串，均支持进行切片操作

(1) 基本格式

• 语法：序列[起始下标:结束下标:步长]

• 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始

• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

• 步长表示，依次取元素的间隔

  • 步长1表示，一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长N表示，每次跳过N-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

(2) 基本用法

• 用法
  • 起始下标可以省略，省略从头开始
  • 结束下标可以省略，省略到尾结束
  • 步长可以省略，省略步长为1（可以为负数，表示倒序执行）
• 用法一：

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]  # 下标1开始，下标4（不含）结束，步长1
print(new_list)  # 结果：[2, 3, 4]

• 用法二：

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]  # 从头开始，到最后结束，步长1
print(new_tuple)  # 结果：(1, 2, 3, 4, 5)

• 用法三：

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]       # 从头开始，到最后结束，步长2
print(new_list)       # 结果：[1, 3, 5]

• 用法四：

my_str = "12345"
new_str = my_str[:4:2]  # 从头开始，到下标4（不含）结束，步长2
print(new_str)  # 结果："13"

• 用法五：

my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]  # 从下标3开始，到下标1（不含）结束，步长-1（倒序）
print(new_list)  # 打印 [4, 3]

• 注：
  • 这个操作对列表、元组、字符串是通用的
  • 此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
  • 起始位置，结束位置，步长（正反序）都是可以自行控制的

---

六.集合(set)

不支持元素的重复（自带去重功能）、并且内容无序

(1) 基本格式

# 定义集合
变量名称 = {元素1, 元素2, 元素3, 元素4, 元素5}
# 定义空集合
变量名称 = set()

• 以大括号 {} 作为标识

• 集合内每一个元素之间用, 逗号隔开

• 集合可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

• 使用示例：

my_set = {"观止", True, "观止"}
print(my_set)  # 打印 {True, '观止'}

• 去重且无序

(2) 集合的遍历

集合不支持下标索引，所以也就不支持使用while。

• 因为集合是无序的，所以集合不支持下标索引访问

my_set = {"观止", True, "观止"}
for i in my_set:
    print(i)
# 打印
# True
# 观止

(3) 集合的常用操作

操作	说明
集合.add(元素)	集合内添加一个元素
集合.remove(元素)	移除集合内指定的元素
集合.pop()	从集合中随机取出一个元素
集合.clear()	将集合清空
集合1.difference(集合2)	得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
len(集合)	得到一个整数，记录了集合的元素数量

(3.1) 增加元素

• 集合本身被修改，将指定元素，添加到集合内
• 语法：集合.add(元素)

my_set = {"观止", True, "观止"}
my_set.add("study")
print(my_set)  # 打印 {'观止', True, 'study'}

(3.2) 移除元素

• 集合本身被修改，将指定元素，从集合内移除

• 语法一：集合.remove(元素)

my_set = {"观止", True, "观止"}
my_set.remove("观止")
print(my_set)  # 打印 {True}

• 从集合中随机取出一个元素，同时集合本身被修改，元素被移除

• 语法二：集合.pop()

  my_set = {"观止", True}
  num = my_set.pop()
  print(my_set)  # 打印 {'观止'}
  print(num)  # 打印 True
  

• 清空集合,集合本身被清空

• 语法三：集合.clear()

my_set = {"观止", True}
my_set.clear()
print(my_set)  # 打印 set()

(3.3) 两集合操作

• 取出集合1和集合2的差集（集合1有而集合2没有的)，得到一个新集合，集合1和集合2不变
• 语法一：集合1.difference(集合2)

my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_3 = my_set_1.difference(my_set_2)
print(my_set_1)  # 打印 {1, 2}
print(my_set_2)  # 打印 {1, 3}
print(my_set_3)  # 打印 {2}

• 对比集合1和集合2，在集合1内，删除和集合2相同的元素,集合1被修改，集合2不变

• 语法二：集合1.difference_update(集合2)

my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_1.difference_update(my_set_2)
print(my_set_1)  # 打印 {2}
print(my_set_2)  # 打印 {1, 3}

• 将集合1和集合2组合成新集合(去重)，集合1和集合2不变
• 语法三：集合1.union(集合2)

my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_3 = my_set_1.union(my_set_2)
print(my_set_1)  # 打印 {1, 2}
print(my_set_2)  # 打印 {1, 3}
print(my_set_3)  # 打印 {1, 2, 3}

(3.4) 集合长度

• 查看集合的元素数量，统计集合内有多少元素

• 语法四：len(集合)

my_set = {1, 3}
print(len(my_set))  # 打印 2

(4) 集合小结

• 特点：
  • 可以容纳多个数据
  • 可以容纳不同类型的数据（混装）
  • 数据是无序存储的（不支持下标索引）
  • 不允许重复数据存在
  • 可以修改（增加或删除元素等）

---

七.字典、映射(dict)

Python中字典和生活中字典十分相像

(1) 基本格式

# 定义字典
变量名称 = {key:value, key:value, key:value}
# 定义空字典
变量名称 = {}
变量名称 = dict()

• 使用{}存储原始，每一个元素是一个键值对
• 每一个键值对包含Key和Value（用冒号分隔）
• 键值对之间使用逗号分隔
• Key和Value可以是任意类型的数据（key不可为字典）
• Key不可重复，重复会对原有数据覆盖
• 使用示例:

my_dict = {"观止": 99, "李白": 120, "观止": 110}
print(my_dict)  # 打印 {'观止': 110, '李白': 120}
print(type(my_dict))  # 打印  <class 'dict'>

(2) 数据的获取

• 字典同集合一样，不可以使用下标索引取值
• 字典可以通过Key值来取得对应的Value

my_dict = {"李白": 120, "观止": 110}
print(my_dict["李白"])  # 打印 120

• 字典的Key和Value可以是任意数据类型（Key不可为字典）,即字典是可以嵌套的

my_dict = {
    "李白": {"语文": 110, "数学": 100}, 
    "观止": {"语文": 90, "数学": 120}
}
print(my_dict["李白"])  # 打印 {'语文': 110, '数学': 100}
print(my_dict["李白"]["语文"])  # 打印 110

• 字典不支持下标索引，同样不可以用while循环遍历

my_dict = {"李白": 120, "观止": 110}
for name in my_dict:
    print(f"key为：{name},value为：{my_dict[name]}")
# 打印
# key为：李白,value为：120
# key为：观止,value为：110

(3) 字典的常用操作

操作	说明
字典[Key]	获取指定Key对应的Value值
字典[Key] = Value	添加或更新键值对
字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
字典.clear()	清空字典
字典.keys()	获取字典的全部Key，可用于for循环遍历字典
len(字典)	计算字典内的元素数量

(3.1) 新增元素

• 字典被修改，新增了元素
• 如果key不存在字典中执行上述操作，就是新增元素
• 语法：字典[Key] = Value

my_dict = {"李白": 120, "观止": 110}
my_dict["罗辑"] = 115
print(my_dict)  # 打印 {'李白': 120, '观止': 110, '罗辑': 115}

(3.2) 更新元素

• 字典被修改，元素被更新

• 字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

• 语法：字典[Key] = Value

my_dict = {"李白": 120, "观止": 110}
my_dict["李白"] = 115
print(my_dict)  # 打印 {'李白': 115, '观止': 110}

(3.3) 删除元素

• 获得指定Key的Value，同时字典被修改，指定Key的数据被删除

• 语法：字典.pop(Key)

my_dict = {"李白": 120, "观止": 110}
name = my_dict.pop("李白")
print(name)  # 打印 120
print(my_dict)  # 打印 {'观止': 110}

(3.4) 清空字典

• 字典被修改，元素被清空

• 语法：字典.clear()

my_dict = {"李白": 120, "观止": 110}
my_dict.clear()
print(my_dict)  # 打印 {}

(3.5) 获取全部的key

• 得到字典中的全部Key

• 语法：字典.keys()

my_dict = {"李白": 120, "观止": 110}
my_keys = my_dict.keys()
print(my_keys)  # 打印 dict_keys(['李白', '观止'])

(3.6) 计算字典内键值对数量

• 得到一个整数，表示字典内元素（键值对）的数量
• 语法：len(字典)

my_dict = {"李白": 120, "观止": 110}
print(len(my_dict))  # 打印 2

(4) 字典小结

• 特点：
  • 可以容纳多个数据
  • 可以容纳不同类型的数据
  • 每一份数据是Key-Value键值对
  • 可以通过Key获取到Value，Key不可重复（重复会覆盖）
  • 不支持下标索引
  • 可以修改（增加或删除更新元素等）

---

八.数据容器对比总结

(1) 简单分类

• 是否支持下标索引

  • 支持：列表、元组、字符串 - 序列类型

  • 不支持：集合、字典 - 非序列类型

• 是否支持重复元素：

  • 支持：列表、元组、字符串 - 序列类型

  • 不支持：集合、字典 - 非序列类型

• 是否可以修改

  • 支持：列表、集合、字典

  • 不支持：元组、字符串

(2) 特点对比

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key：Value Key：除字典外任意类型 Value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以Key检索Value的数据记录场景

(3) 应用场景

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景

功能	描述
通用for循环	遍历容器（字典是遍历key）
max	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列, [reverse=True])	排序，reverse=True表示降序 得到一个排好序的列表

(4) 通用操作-遍历

• 5类数据容器都支持for循环遍历

• 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

(5) 通用操作-统计

(5.1)统计容器的元素个数

• 语法：len(容器)

my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(len(my_list))  # 结果 3
print(len(my_tuple))  # 结果 5
print(len(my_str))  # 结果 7

(5.2) 统计容器的最大元素

• 语法：max(容器)

my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(max(my_list))  # 结果 3
print(max(my_tuple))  # 结果 5
print(max(my_str))  # 结果 z

(5.3) 统计容器的最小元素

• 语法：min(容器)

my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(min(my_list))  # 结果 1
print(min(my_tuple))  # 结果 1
print(min(my_str))  # 结果 a

(5.4) 字符串大小比较

• ASCII码表：
  

• 在程序中，字符串所用的所有字符如：大小写，英文单词，数字特殊符号(!、\、|、@、#、空格等），都有其对应的ASCII码表值

• 每一个字符都能对应上一个：数字的码值，字符串进行比较就是基于数字的码值大小进行比较的。

• 字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大:

(6) 通用操作-排序

• 将给定容器进行排序,排序后都会得到列表（list）对象。

• 语法:sorted(容器, [reverse=True])

  my_list = [1, 4, 2]
  my_list_asc = sorted(my_list)
  print(my_list_asc)  # 结果 [1, 2, 4]
  my_list_des = sorted(my_list, reverse=True)
  print(my_list_des)  # 结果 [4, 2, 1]
  

(7) 通用操作-转换

• 将给定容器转换为列表

• 语法一：list(容器)

my_tuple = (1, 4, 2) 
print(type(my_tuple))  # 打印 <class 'tuple'>
my_list = list(my_tuple)
print(type(my_list))  # 打印 <class 'list'>

• 将给定容器转换为字符串

• 语法二：str(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_str = str(my_tuple)
print(type(my_str))  # 打印 <class 'str'>

• 将给定容器转换为集合

• 语法三：set(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_set = set(my_tuple)
print(type(my_set))  # 打印 <class 'set'>

• 将给定容器转换为元组

• 语法四：tuple(容器)

my_list = [1, 4, 2]
print(type(my_list))  # 打印 <class 'list'>
my_tuple = tuple(my_list)
print(type(my_tuple))  # 打印 <class 'tuple'>

个字符都能对应上一个：数字的码值，字符串进行比较就是基于数字的码值大小进行比较的。

• 字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大:

[外链图片转存中…(img-OBBEKbw3-1672218055750)]

(6) 通用操作-排序

• 将给定容器进行排序,排序后都会得到列表（list）对象。

• 语法:sorted(容器, [reverse=True])

  my_list = [1, 4, 2]
  my_list_asc = sorted(my_list)
  print(my_list_asc)  # 结果 [1, 2, 4]
  my_list_des = sorted(my_list, reverse=True)
  print(my_list_des)  # 结果 [4, 2, 1]
  

(7) 通用操作-转换

• 将给定容器转换为列表

• 语法一：list(容器)

my_tuple = (1, 4, 2) 
print(type(my_tuple))  # 打印 <class 'tuple'>
my_list = list(my_tuple)
print(type(my_list))  # 打印 <class 'list'>

• 将给定容器转换为字符串

• 语法二：str(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_str = str(my_tuple)
print(type(my_str))  # 打印 <class 'str'>

• 将给定容器转换为集合

• 语法三：set(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_set = set(my_tuple)
print(type(my_set))  # 打印 <class 'set'>

• 将给定容器转换为元组

• 语法四：tuple(容器)

my_list = [1, 4, 2]
print(type(my_list))  # 打印 <class 'list'>
my_tuple = tuple(my_list)
print(type(my_tuple))  # 打印 <class 'tuple'>