5.Python 数据容器（list 列表、tuple 元组、str 字符串、set 集合、dict（字典）、序列切片）

一、数据容器概述

• Python 中的数据容器是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔值等

• 数据容器根据特点的不同，如：是否支持重复元素、是否可以修改、是否有序等，分为 5 类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

---

二、list 列表

1、列表的特点

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

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

3. 数据是有序存储的（支持下标索引）

4. 允许重复数据存在

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

6. 支持 for 循环和 while 遍历

2、列表的定义

（1）基本格式

• 定义字面量

[【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...]

• 定义变量

【变量名】 = [【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...]

• 定义空列表

【变量名】 = []

# 或
【变量名】 = list()

（2）解析

• 列表元组使用 []，且使用逗号（,）隔开各个元素，元素可以是不同的数据类型

（3）基本使用

list1 = ["jack", "smith", "tom"]

print(list1)
print(type(list1))

print("------------------------------")

list2 = ["Hello World", 123, True]

print(list2)
print(type(list2))

print("------------------------------")

# 定义嵌套列表
list3 = [[1, 2, 3], [4, 5, 6]]

print(list3)
print(type(list3))

• 输出结果

  ['jack', 'smith', 'tom']
  <class 'list'>

  ['Hello World', 123, True]
  <class 'list'>

  [[1, 2, 3], [4, 5, 6]]
  <class 'list'>

3、列表的下标索引

（1）基本介绍

• 列表中的每一个元素，都有其位置下标索引，从前向后的方向，从 0 开始，依次递增，只需要按照下标索引，即可取得对应位置的元素

-	元素 1	元素 2	元素 3	元素 4	元素 5
索引	0	1	2	3	4

• 或者，可以反向索引，也就是从后向前，从 -1 开始，依次递减

-	元素 1	元素 2	元素 3	元素 4	元素 5
索引	-5	-4	-3	-2	-1

• 如果列表是嵌套的列表，同样支持下标索引

-	元素 1	元素 2	元素 3	元素 4	元素 5
二层索引	0	1	0	1	2
一层索引	-	0	-	-	1

（2）列表元素取出

【列表】[【下标】]

• 嵌套列表元素取出

【列表】[【下标】][【下标】]

（3）基本使用

list1 = ["jack", "smith", "tom"]
print(list1[0])
print(list1[1])
print(list1[2])

print("------------------------------")

print(list1[-1])
print(list1[-2])
print(list1[-3])

print("------------------------------")

list2 = [[1, 2, 3], [4, 5, 6]]
print(list2[0])
print(list2[1][1])

• 输出结果

  jack
  smith
  tom

  tom
  smith
  jack

  [1, 2, 3]
  5

5、列表方法引入

（1）列表方法概述

• 列表除了可以定义和使用下标索引获取值以外，列表也提供了一系列功能，如插入元素、删除元素、清空列表、修改元素、统计元素个数等等，这些功能都称之为列表的方法

• 函数是一个封装的代码单元，可以提供特定功能，在 Python 中，如果将函数定义为 class（类）的成员，那么函数会称之为方法

• 函数与方法功能一样，有传入参数，有返回值，只是使用格式不同

（2）函数与方法的使用

• 函数的使用

def add(num1, num2):
    return num1 + num2

print(add(10, 20)) # 30

• 方法的使用

class Calculator:

    def add(self, num1, num2):
        return num1 + num2

calculator = Calculator()
print(calculator.add(30, 40)) # 70

5、列表的常用操作方法

（1）基本介绍

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

（2）基本使用

name_list = ["jack", "smith", "tom"]
print(name_list)

# 列表的查询
print("列表的查询 ------------------------------")

print("index:", name_list.index("jack"))

print("len:", len(name_list))

print("count:", name_list.count("tom"))

# 列表的修改
print("列表的修改 ------------------------------")

name_list[1] = "mery"
print(name_list)

name_list.insert(1, "jerry")
print("insert -----", name_list)

name_list.append("david")
print("append:", name_list)

name_list.extend(["zhangsan", "lsii"])
print("extend:", name_list)

del name_list[-1]
print("del:", name_list)

name_list.pop(-1)
print("pop:", name_list)

name_list.remove("jerry")
print("remove：", name_list)

name_list.clear()
print("clear:", name_list)

• 输出结果

  ['jack', 'smith', 'tom']
  列表的查询 ------------------------------
  index: 0
  len: 3
  count: 1
  列表的修改 ------------------------------
  ['jack', 'mery', 'tom']
  insert ----- ['jack', 'jerry', 'mery', 'tom']
  append: ['jack', 'jerry', 'mery', 'tom', 'david']
  extend: ['jack', 'jerry', 'mery', 'tom', 'david', 'zhangsan', 'lsii']
  del: ['jack', 'jerry', 'mery', 'tom', 'david', 'zhangsan']
  pop: ['jack', 'jerry', 'mery', 'tom', 'david']
  remove： ['jack', 'mery', 'tom', 'david']
  clear: []

6、列表的遍历

（1）概述

• 将容器内的元素依次取出进行处理的行为称之为遍历或迭代

（2）遍历的方式

• while 循环

1. 定义一个变量表示下标，从 0 开始

2. 循环条件为：【下标】 < 【列表的元素数量】

3. 取出列表的元素方式为：【列表】[【下标】]

• for 循环（for 循环更加适合对列表等数据容器进行遍历）

for 【临时变量】 in 【数据容器】: 
    【执行的代码块】

1. 从容器内，依次取出元素并赋值到临时变量上

2. 在每一次的循环中，可以对临时变量（元素）进行处理

（3）具体实现

name_list = ["jack", "tom", "smith"]

print("for 循环遍历 ------------------------------")

for x in name_list:
    print(x)

print("while 循环遍历 ------------------------------")

index = 0
while index < len(name_list):
    print(name_list[index])
    index += 1

• 输出结果

  for 循环遍历 ------------------------------
  jack
  tom
  smith
  while 循环遍历 ------------------------------
  jack
  tom
  smith

（4）while 循环和 for 循环对比

条件	对比
在循环控制上	while 循环可以自定循环条件，并自行控制 for 循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上	while 循环可以通过条件控制做到无限循环 for 循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上	while 循环适用于任何想要循环的场景 for 循环适用于遍历数据容器的场景或简单的固定次数循环场景

---

三、tuple 元组

1、元组的特点

1. 可以容纳多个元素

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

3. 数据是有序存储的（支持下标索引）

4. 允许重复数据存在

5. 不可以修改（增加或删除元素等）

6. 支持 for 循环和 while 遍历

• 多数特性和列表一致，不同点在于不可修改

2、元组的定义

（1）基本格式

• 定义字面量

(【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...)

• 定义变量

【变量名】 = (【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...)

• 定义空元组

【变量名】 = ()

【变量名】 = ()

• 定义一个元素的元组

# 或
【变量名】 = (【元素】, ) # 元组只有一个元素，这个元素后面要添加逗号

（2）解析

• 定义元组使用 ()，且使用逗号（,）隔开各个元素，元素可以是不同的数据类型

（3）基本使用

tuple1 = ("jack", "smith", "tom")

print(tuple1)
print(type(tuple1))

print("------------------------------")

tuple2 = ("Hello World", 123, True)

print(tuple2)
print(type(tuple2))

print("------------------------------")

# 定义嵌套元组
tuple3 = ((1, 2, 3), (4, 5, 6))

print(tuple3)
print(type(tuple3))

print("------------------------------")

# 定义一个元素的元组
tuple4 = ("Hello World", )

print(tuple4)
print(type(tuple4))

• 输出结果

  ('jack', 'smith', 'tom')
  <class 'tuple'>

  ('Hello World', 123, True)
  <class 'tuple'>

  ((1, 2, 3), (4, 5, 6))
  <class 'tuple'>

  ('Hello World',)
  <class 'tuple'>

3、元组的下标索引

• 同列表

4、元组的常用操作方法

（1）基本介绍

方法	说明
【元组】.index(【元素】)	查找指定元素的下标，找不到则报错
len(【元组】)	统计元组内有多少元素
【元组】.count(【元素】)	统计指定元素在元组中出现的次数

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

（2）基本使用

name_tuple = ("jack", "smith", "tom")
print(name_tuple)

# 元组的查询
print("元组的查询 ------------------------------")

print("index:", name_tuple.index("jack"))

print("count:", name_tuple.count("tom"))

print("len:", len(name_tuple))

• 输出结果

  ('jack', 'smith', 'tom')
  元组的查询 ------------------------------
  index: 0
  count: 1
  len: 3

5、元组的遍历

• 同列表

6、元组的注意事项

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

tuple1 = (1, 2, 3)

tuple1[0] = 10 # 报错

• 可以修改元组内的 list 的内容

tuple2 = (1, 2, [3, 4])

print(tuple2) # (1, 2, [3, 4])

tuple2[2][0] = 10
print(tuple2) # (1, 2, [10, 4])

• 不可以替换元组内的 list 为其它 list 或其它类型

tuple3 = (1, 2, [3, 4])

tuple3[2] = [5, 6] # 报错

---

四、str 字符串

1、再认字符串

• 字符串同样也是数据容器的一员，字符串是字符的容器，一个字符串可以存放任意数量的字符，如，字符串"Hello World"

-	H	e	l	l	o		W	o	r	l	d
索引	0	1	2	3	4	5	6	7	8	9	10

2、字符串的特点

1. 只可以存储字符串

2. 长度任意（取决于内存大小）

3. 支持下标索引

4. 在内部允许重复字符串存在

5. 不可以修改（增加或删除元素等）

6. 支持遍历

3、字符串的下标索引

• 同列表和元组

4、字符串的常用操作方法

（1）基本介绍

方法	说明
【字符串】.index(【指定字符串】)	查找指定字符串的下标，找不到则报错
【字符串】.replace(【指定字符串 1】, 【指定字符串 2】)	将字符串内的指定字符串 1，替换为指定字符串 2 不会修改原字符串，而是得到一个新的字符串
【字符串】.split(【指定字符串】)	按照指定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
【字符串】.strip() 【字符串】.strip(【指定字符串】)	移除首尾的空格和换行符 移除首尾的指定字符串，按照指定字符串的单个字符来确定移除 不会修改原字符串，而是得到一个新的字符串
【字符串】.count(【指定字符串】)	统计指定字符串在字符串中出现的次数
len(【字符串】)	统计字符串的字符个数
【字符串】.splitlines(【keepends】)	按行（\r、\r\n、\n）分割，返回一个以各行作为元素的列表 keepends 默认为 False，不包含换行符，为 True 则保留换行符

（2）基本使用

my_str1: Hello And World
my_str2:   Hello And World  
my_str3: 12Hello And World21
my_str4: Hello
123

------------------------------
my_str1 - index: 6
my_str1 - replace: Hello And Python
my_str1 - split: ['Hello', 'And', 'World']
my_str2 - strip: Hello And World
my_str3 - strip: Hello And World
my_str1 - count: 3
my_str1 - splitlines: ['Hello', 'World', '123']
len - my_str1: 15

• 输出结果

  my_str1: Hello And World
  my_str2: Hello And World
  my_str3: 12Hello And World21
  my_str4: Hello
  123

  ---

  my_str1 - index: 6
  my_str1 - replace: Hello And Python
  my_str1 - split: ['Hello', 'And', 'World']
  my_str2 - strip: Hello And World
  my_str3 - strip: Hello And World
  my_str1 - count: 3
  my_str1 - splitlines: ['Hello', 'World', '123']
  len - my_str1: 15

5、字符串的遍历

• 同列表和元组

6、字符串的注意事项

• 不可以修改字符串的内容，否则会直接报错

my_str = "Hello World"

my_str[0] = "A" # 报错

---

五、序列切片

1、概述

（1）序列概述

• 序列是指内容连续、有序，可使用下标索引的一类数据容器，列表、元组、字符串，均可以可以视为序列

（2）切片概述

• 序列支持切片，即列表、元组、字符串，均支持进行切片操作

• 切片操作是从一个序列中，取出一个子序列

2、基本格式

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

【序列】[【起始下标】:【结束下标（不含）】:【步长】]

参数	说明
起始下标	表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）	表示何处结束，可以留空，留空视作取到结尾
步长	表示依次取元素的间隔，可以留空，留空视作 1

步长	说明
1	表示一个个取
2	表示每次跳过 1 个元素取
N	表示每次跳过 N-1 个元素取
负数	表示反向取，此时起始下标和结束下标也要反向标记

• 注：切片操作不会影响序列本身，而是会得到一个新的序列

3、基本使用

my_list = [0, 1, 2, 3, 4, 5, 6]
print("my_list:", list)

print("对 list 进行切片")

# 对 list 进行切片，从下标 1 开始，到下标 4 结束，步长为 1
new_list1 = my_list[1:4]
print("new_list1:", new_list1)

# 对 list 进行切片，从下标 3 开始，到下标 1 结束，步长为 -1
new_list2 = my_list[3:1:-1]
print("new_list1:", new_list2)

print("------------------------------")

my_tuple = [0, 1, 2, 3, 4, 5, 6]
print("my_tuple:", list)

print("对 tuple 进行切片")

# 对 tuple 进行切片，从头开始，到尾结束，步长为 1
new_tuple1 = my_tuple[:]
print("new_tuple1:", new_tuple1)

# 对 tuple 进行切片，从头开始，到尾结束，步长为 -2
new_tuple2 = my_tuple[::-2]
print("new_tuple2:", new_tuple2)

print("------------------------------")

my_str = "0123456"
print("my_str:", my_str)

print("对 str 进行切片")

# 对 str 进行切片，从头开始，到尾结束，步长为 2
new_str1 = my_str[::2]
print("new_str1:", new_str1)

# 对 str 进行切片，从头开始，到尾结束，步长为 -1
# 等同于将序列反转
new_str2 = my_str[::-1]
print("new_str2:", new_str2)

• 输出结果

  my_list: <class 'list'>
  对 list 进行切片
  new_list1: [1, 2, 3]
  new_list1: [3, 2]

  my_tuple: <class 'list'>
  对 tuple 进行切片
  new_tuple1: [0, 1, 2, 3, 4, 5, 6]
  new_tuple2: [6, 4, 2, 0]

  my_str: 0123456
  对 str 进行切片
  new_str1: 0246
  new_str2: 6543210

---

六、set 集合

1、集合的特点

1. 可以容纳多个元素

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

3. 数据是无序存储的（不支持下标索引）

4. 不允许重复数据存在

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

6. 支持 for 循环遍历，因为不支持下标索引，所以不支持 while 循环遍历

2、集合的定义

（1）基本格式

• 定义字面量

{【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...}

• 定义变量

【变量名】 = {【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...}

• 定义空集合

【变量名】 = set()

（2）解析

• 定义集合使用 {}，且使用逗号（,）隔开各个元素，元素有类型限制

（3）基本使用

set1 = {"jack", "smith", "tom", "jack", "smith", "tom"}

print(set1)
print(type(set1))

• 输出结果

  {'tom', 'smith', 'jack'}
  <class 'set'>

3、集合的常用操作方法

（1）基本介绍

方法	说明
【集合】.add(【元素】)	向集合内添加一个元素，集合本身被修改
【集合】.remove(【元素】)	移除集合内指定的元素，集合本身被修改
【集合】.pop()	从集合中随机取出一个元素，集合本身被修改
len(【集合】)	统计集合的元素个数
【集合】.clear()	清空集合，集合本身被修改
【集合 1】.difference(【集合 2】)	得到集合 1 和集合 2 的差集（集合 1 有而集合 2 没有的） 得到一个新集合，集合 1 和集合 2 不变
【集合 1】.difference_update(【集合 2】)	在集合 1 中删除集合 2 中存在的元素，集合 1 被修改，集合 2 不变
【集合 1】.union(【集合 2】)	得到一个新集合，内含集合 1 和集合 2 的全部元素，集合 1 和集合 2 不变

（2）基本使用

my_set1 = {1, 2, 3, 4, 5}
my_set2 = {4, 5, 6, 7, 8}
my_set3 = {"jack", "tom", "smith"}

print("my_set1:", my_set1)
print("my_set2:", my_set2)
print("my_set3:", my_set3)

print("------------------------------")

my_set1.add(10)
print("my_set1 - add:", my_set1)

my_set1.remove(1)
print("my_set1 - remove:", my_set1)

element = my_set1.pop()
print("my_set1 - pop:", my_set1)

print("len - my_set1:", len(my_set1))

my_set3.clear()
print("my_set3 - clear:", my_set3)

print("difference ------------------------------")

new_set1 = my_set1.difference(my_set2)
print("new_set1:", new_set1)
print("my_set1:", my_set1)
print("my_set2:", my_set2)

print("difference_update ------------------------------")

my_set1.difference_update(my_set2)
print("my_set1:", my_set1)
print("my_set2:", my_set2)

print("union ------------------------------")

new_set2 = my_set1.union(my_set2)
print("new_set2:", new_set2)
print("my_set1:", my_set1)
print("my_set2:", my_set2)

• 输出结果

  my_set1: {1, 2, 3, 4, 5}
  my_set2: {4, 5, 6, 7, 8}
  my_set3: {'jack', 'smith', 'tom'}

  my_set1 - add: {1, 2, 3, 4, 5, 10}
  my_set1 - remove: {2, 3, 4, 5, 10}
  my_set1 - pop: {3, 4, 5, 10}
  len - my_set1: 4
  my_set3 - clear: set()
  difference ------------------------------
  new_set1: {10, 3}
  my_set1: {3, 4, 5, 10}
  my_set2: {4, 5, 6, 7, 8}
  difference_update ------------------------------
  my_set1: {3, 10}
  my_set2: {4, 5, 6, 7, 8}
  union ------------------------------
  new_set2: {3, 4, 5, 6, 7, 8, 10}
  my_set1: {3, 10}
  my_set2: {4, 5, 6, 7, 8}

---

七、dict（字典）

1、字典的特点

• 生活中的字典是通过字去找到对应的含义，Python 中的字典是通过 key 去找到对应 value

1. 可以容纳多个数据

2. 可以容纳不同类型的数据

3. 每一份数据是 key value 键值对

4. 可以通过 key 获取到 value，key 不可重复（重复会覆盖）

5. 不支持下标索引

6. 可以修改，支持 for 循环，不支持 while 循环

2、字典的定义

（1）基本格式

• 定义字面量

{【key 1】: 【value 1】, 【key 2】: 【value 2】, 【key 3】: 【value 3】...}

• 定义变量

【变量名】 = {【key 1】: 【value 1】, 【key 2】: 【value 2】, 【key 3】: 【value 3】...}

• 定义空字典

【变量名】 = {}

# 或
【变量名】 = dist()

（2）解析

• 定义字典使用大括号（{}），且使用逗号（,）隔开各个元素

• 每一个元素是一个键值对，每一个键值对包含 key 和 value，用冒号（:）分隔

• key 和 value 可以是任意类型的数据，所以字典可以嵌套，但 key 不可为字典

• key 不可重复，重复会对原有数据进行覆盖

（3）基本使用

dist1 = {1: "jack", 2: "smith", 3: "tom"}

print(dist1)
print(type(dist1))

print("------------------------------")

# 定义嵌套字典
dist2 = {
    "jack": {"age": 18, "height(cm)": 170},
    "smith": {"age": 20, "height(cm)": 180},
    "tom": {"age": 25, "height(cm)": 175}
}

print(dist2)
print(type(dist2))

• 输出结果

  {1: 'jack', 2: 'smith', 3: 'tom'}
  <class 'dict'>

  {'jack': {'age': 18, 'height(cm)': 170}, 'smith': {'age': 20, 'height(cm)': 180}, 'tom': {'age': 25, 'height(cm)': 175}}
  <class 'dict'>

3、字典元素的获取

（1）基本介绍

【字典】[【key】]

• 字典同集合一样，不可以使用下标索引，但是字典可以通过 key 来取得对应的 value

（2）基本使用

dist1 = {1: "jack", 2: "smith", 3: "tom"}

print(dist1[1])
print(dist1[3])

print("------------------------------")

# 定义嵌套字典
dist2 = {
    "jack": {"age": 18, "height(cm)": 170},
    "smith": {"age": 20, "height(cm)": 180},
    "tom": {"age": 25, "height(cm)": 175}
}

print(dist2["jack"])
print(dist2["tom"])

print(dist2["smith"]["age"])
print(dist2["tom"]["age"])

• 输出结果

  jack
  tom

  {'age': 18, 'height(cm)': 170}
  {'age': 25, 'height(cm)': 175}
  20
  25

4、字典的常用操作方法

（1）基本介绍

方法	说明
【字典】[【key】] = 【value】	新增 / 修改元素
【字典】.pop(key)	删除元素，获取指定 key 对应的 value
【字典】.clear()	清空元素
【字典】.keys()	获取全部的 key
len(【字典】)	获取字典内的元素数量

（2）基本使用

stu_score = {
    "jack": 50,
    "tom": 60,
    "smith": 70,
}

print(stu_score)

print("新增 / 修改元素 ------------------------------")

stu_score["jerry"] = 80
print(stu_score)

stu_score["jerry"] = 90
print(stu_score)

print("删除元素 ------------------------------")

print(stu_score.pop("jerry"))
print(stu_score)

print("获取全部的 key ------------------------------")

keys = stu_score.keys()
print(keys)

print("获取字典内的元素数量 ------------------------------")

print(len(stu_score))

print("清空元素 ------------------------------")

stu_score.clear()
print(stu_score)

• 输出结果

  {'jack': 50, 'tom': 60, 'smith': 70}
  新增 / 修改元素 ------------------------------
  {'jack': 50, 'tom': 60, 'smith': 70, 'jerry': 80}
  {'jack': 50, 'tom': 60, 'smith': 70, 'jerry': 90}
  删除元素 ------------------------------
  90
  {'jack': 50, 'tom': 60, 'smith': 70}
  获取全部的 key ------------------------------
  dict_keys(['jack', 'tom', 'smith'])
  获取字典内的元素数量 ------------------------------
  3
  清空元素 ------------------------------
  {}

5、字典的遍历

（1）基本介绍

1. 通过获取到全部的 key 来完成遍历

2. 直接对字进行 for 循环，每一次环都是直接得到 key

（2）基本使用

stu_score = {
    "jack": 50,
    "tom": 60,
    "smith": 70,
}

for key in stu_score.keys():
    print(f"{key}: {stu_score[key]}")

print("------------------------------")

for key in stu_score:
    print(f"{key}: {stu_score[key]}")

• 输出结果

  jack: 50
  tom: 60
  smith: 70

  jack: 50
  tom: 60
  smith: 70

---

八、数据容器对比

1、数据容器分类

• 是否支持下标索引

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

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

• 是否支持重复元素

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

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

• 是否可以修改

1. 支持：列表、集合、字典

2. 不支持：元组、字符串

2、数据容器特点对比

-	元素类型	下标索引	重复元素	可修改	元素有序	使用场景
列表	任意类型	支持	支持	是	是	一批可修改、可重复的数据
元素	任意类型	支持	支持	否	是	一批不可修改、可重复的数据
字符串	仅字符类型	支持	支持	否	是	一串字符
集合	任意类型	不支持	不支持	是	否	一批不可重复的数据
字典	key：除字典外任意类型 value：任意类型	不支持	不支持	是	否	一批键值对数据