一、数据容器概述
-
Python 中的数据容器是一种可以容纳多份数据的数据类型,容纳的每一份数据称之为元素,每一个元素,可以是任意类型的数据,如字符串、数字、布尔值等
-
数据容器根据特点的不同,如:是否支持重复元素、是否可以修改、是否有序等,分为 5 类,分别是:列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)
二、list 列表
1、列表的特点
-
可以容纳多个元素,上限为 2**63-1(9223372036854775807) 个
-
可以容纳不同类型的元素(混装)
-
数据是有序存储的(支持下标索引)
-
允许重复数据存在
-
可以修改(增加或删除元素等)
-
支持 for 循环和 while 遍历
2、列表的定义
(1)基本格式
- 定义字面量
python
[【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...]
- 定义变量
python
【变量名】 = [【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...]
- 定义空列表
python
【变量名】 = []
python
# 或
【变量名】 = list()
(2)解析
- 列表元组使用 [],且使用逗号(,)隔开各个元素,元素可以是不同的数据类型
(3)基本使用
python
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)列表元素取出
python
【列表】[【下标】]
- 嵌套列表元素取出
python
【列表】[【下标】][【下标】]
(3)基本使用
python
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
tomtom
smith
jack[1, 2, 3]
5
5、列表方法引入
(1)列表方法概述
-
列表除了可以定义和使用下标索引获取值以外,列表也提供了一系列功能,如插入元素、删除元素、清空列表、修改元素、统计元素个数等等,这些功能都称之为列表的方法
-
函数是一个封装的代码单元,可以提供特定功能,在 Python 中,如果将函数定义为 class(类)的成员,那么函数会称之为方法
-
函数与方法功能一样,有传入参数,有返回值,只是使用格式不同
(2)函数与方法的使用
- 函数的使用
python
def add(num1, num2):
return num1 + num2
print(add(10, 20)) # 30
- 方法的使用
python
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)基本使用
python
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 循环
-
定义一个变量表示下标,从 0 开始
-
循环条件为:【下标】 < 【列表的元素数量】
-
取出列表的元素方式为:【列表】[【下标】]
- for 循环(for 循环更加适合对列表等数据容器进行遍历)
python
for 【临时变量】 in 【数据容器】:
【执行的代码块】
-
从容器内,依次取出元素并赋值到临时变量上
-
在每一次的循环中,可以对临时变量(元素)进行处理
(3)具体实现
python
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、元组的特点
-
可以容纳多个元素
-
可以容纳不同类型的元素(混装)
-
数据是有序存储的(支持下标索引)
-
允许重复数据存在
-
不可以修改(增加或删除元素等)
-
支持 for 循环和 while 遍历
- 多数特性和列表一致,不同点在于不可修改
2、元组的定义
(1)基本格式
- 定义字面量
python
(【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...)
- 定义变量
python
【变量名】 = (【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...)
- 定义空元组
python
【变量名】 = ()
python
【变量名】 = ()
- 定义一个元素的元组
python
# 或
【变量名】 = (【元素】, ) # 元组只有一个元素,这个元素后面要添加逗号
(2)解析
- 定义元组使用 (),且使用逗号(,)隔开各个元素,元素可以是不同的数据类型
(3)基本使用
python
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)基本使用
python
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、元组的注意事项
- 不可以修改元组的内容,否则会直接报错
python
tuple1 = (1, 2, 3)
tuple1[0] = 10 # 报错
- 可以修改元组内的 list 的内容
python
tuple2 = (1, 2, [3, 4])
print(tuple2) # (1, 2, [3, 4])
tuple2[2][0] = 10
print(tuple2) # (1, 2, [10, 4])
- 不可以替换元组内的 list 为其它 list 或其它类型
python
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、字符串的特点
-
只可以存储字符串
-
长度任意(取决于内存大小)
-
支持下标索引
-
在内部允许重复字符串存在
-
不可以修改(增加或删除元素等)
-
支持遍历
3、字符串的下标索引
- 同列表和元组
4、字符串的常用操作方法
(1)基本介绍
方法 | 说明 |
---|---|
【字符串】.index(【指定字符串】) | 查找指定字符串的下标,找不到则报错 |
【字符串】.replace(【指定字符串 1】, 【指定字符串 2】) | 将字符串内的指定字符串 1,替换为指定字符串 2 不会修改原字符串,而是得到一个新的字符串 |
【字符串】.split(【指定字符串】) | 按照指定字符串,对字符串进行分隔 不会修改原字符串,而是得到一个新的列表 |
【字符串】.strip() 【字符串】.strip(【指定字符串】) | 移除首尾的空格和换行符 移除首尾的指定字符串,按照指定字符串的单个字符来确定移除 不会修改原字符串,而是得到一个新的字符串 |
【字符串】.count(【指定字符串】) | 统计指定字符串在字符串中出现的次数 |
len(【字符串】) | 统计字符串的字符个数 |
【字符串】.splitlines(【keepends】) | 按行(\r、\r\n、\n)分割,返回一个以各行作为元素的列表 keepends 默认为 False,不包含换行符,为 True 则保留换行符 |
(2)基本使用
python
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、字符串的注意事项
- 不可以修改字符串的内容,否则会直接报错
python
my_str = "Hello World"
my_str[0] = "A" # 报错
五、序列切片
1、概述
(1)序列概述
- 序列是指内容连续、有序,可使用下标索引的一类数据容器,列表、元组、字符串,均可以可以视为序列
(2)切片概述
-
序列支持切片,即列表、元组、字符串,均支持进行切片操作
-
切片操作是从一个序列中,取出一个子序列
2、基本格式
- 从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列
python
【序列】[【起始下标】:【结束下标(不含)】:【步长】]
参数 | 说明 |
---|---|
起始下标 | 表示从何处开始,可以留空,留空视作从头开始 |
结束下标(不含) | 表示何处结束,可以留空,留空视作取到结尾 |
步长 | 表示依次取元素的间隔,可以留空,留空视作 1 |
步长 | 说明 |
---|---|
1 | 表示一个个取 |
2 | 表示每次跳过 1 个元素取 |
N | 表示每次跳过 N-1 个元素取 |
负数 | 表示反向取,此时起始下标和结束下标也要反向标记 |
- 注:切片操作不会影响序列本身,而是会得到一个新的序列
3、基本使用
python
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、集合的特点
-
可以容纳多个元素
-
可以容纳不同类型的元素(混装)
-
数据是无序存储的(不支持下标索引)
-
不允许重复数据存在
-
可以修改(增加或删除元素等)
-
支持 for 循环遍历,因为不支持下标索引,所以不支持 while 循环遍历
2、集合的定义
(1)基本格式
- 定义字面量
python
{【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...}
- 定义变量
python
【变量名】 = {【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...}
- 定义空集合
python
【变量名】 = set()
(2)解析
- 定义集合使用 {},且使用逗号(,)隔开各个元素,元素有类型限制
(3)基本使用
python
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)基本使用
python
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
-
可以容纳多个数据
-
可以容纳不同类型的数据
-
每一份数据是 key value 键值对
-
可以通过 key 获取到 value,key 不可重复(重复会覆盖)
-
不支持下标索引
-
可以修改,支持 for 循环,不支持 while 循环
2、字典的定义
(1)基本格式
- 定义字面量
python
{【key 1】: 【value 1】, 【key 2】: 【value 2】, 【key 3】: 【value 3】...}
- 定义变量
python
【变量名】 = {【key 1】: 【value 1】, 【key 2】: 【value 2】, 【key 3】: 【value 3】...}
- 定义空字典
python
【变量名】 = {}
python
# 或
【变量名】 = dist()
(2)解析
-
定义字典使用大括号({}),且使用逗号(,)隔开各个元素
-
每一个元素是一个键值对,每一个键值对包含 key 和 value,用冒号(:)分隔
-
key 和 value 可以是任意类型的数据,所以字典可以嵌套,但 key 不可为字典
-
key 不可重复,重复会对原有数据进行覆盖
(3)基本使用
python
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)基本介绍
python
【字典】[【key】]
- 字典同集合一样,不可以使用下标索引,但是字典可以通过 key 来取得对应的 value
(2)基本使用
python
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)基本使用
python
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)基本介绍
-
通过获取到全部的 key 来完成遍历
-
直接对字进行 for 循环,每一次环都是直接得到 key
(2)基本使用
python
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: 70jack: 50
tom: 60
smith: 70
八、数据容器对比
1、数据容器分类
- 是否支持下标索引
-
支持:列表、元组、字符串 - 序列类型
-
不支持:集合、字典 - 非序列类型
- 是否支持重复元素
-
支持:列表、元组、字符串 - 序列类型
-
不支持:集合、字典 - 非序列类型
- 是否可以修改
-
支持:列表、集合、字典
-
不支持:元组、字符串
2、数据容器特点对比
- | 元素类型 | 下标索引 | 重复元素 | 可修改 | 元素有序 | 使用场景 |
---|---|---|---|---|---|---|
列表 | 任意类型 | 支持 | 支持 | 是 | 是 | 一批可修改、可重复的数据 |
元素 | 任意类型 | 支持 | 支持 | 否 | 是 | 一批不可修改、可重复的数据 |
字符串 | 仅字符类型 | 支持 | 支持 | 否 | 是 | 一串字符 |
集合 | 任意类型 | 不支持 | 不支持 | 是 | 否 | 一批不可重复的数据 |
字典 | key:除字典外任意类型 value:任意类型 | 不支持 | 不支持 | 是 | 否 | 一批键值对数据 |