1200字范文 > python入门到精通 _5数据容器（list tuple str set dict）

python入门到精通 _5数据容器（list tuple str set dict）

时间：2023-02-11 03:55:46

文章目录

1.list列表1.1 列表的定义1.2 列表的下标索引1.3 常用操作方法总结案例1.4 列表的遍历for/while案例 2. tuple元组2.1 定义元组2.2 相关操作总结案例 3. str字符串3.1 下标索引3.2 常用操作总结3.3 字符串的特点案例 4. 序列的切片5. set集合5.1 集合的常用操作 - 修改5.3 集合的常用操作 - 两个集合5.2 集合的常用操作 - 集合长度5.3 集合的常用操作 - for循环遍历5.4 集合常用功能总结案例 6. dict字典6.1 字典的定义6.2 字典的嵌套及获取6.3 字典的常用操作6.4 字典的常用操作总结案例 7. 总结7.1 数据容器分类7.2 容器通用功能

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

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：

是否支持重复元素

是否可以修改

是否有序，等

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

1.list列表

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

以 [ ] 作为标识

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

1.1 列表的定义

基本语法

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

元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

my_list = [[1,2,3], [4,5,6]]print(f"列表为：{my_list},数据类型为：{type(my_list)}")

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

1.2 列表的下标索引

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

我们只需要按照下标索引，即可取得对应位置的元素。

列表的每一个元素，都有编号称之为下标索引

从前向后的方向，编号从0开始递增

从后向前的方向，编号从-1开始递减

my_list = [[1, 2, 3], [4, 5, 6]]# 索引print(f"内层第一个元素为：{my_list[0][0]}")

1.3 常用操作方法总结

列表也提供了一系列功能：

插入元素

删除元素

清空列表

修改元素

统计元素个数

等等功能，这些功能我们都称之为：列表的方法

列表有如下特点：

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

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

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

允许重复数据存在

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

案例

有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄

请通过列表的功能（方法），对其进行

定义这个列表，并用变量接收它

追加一个数字31，到列表的尾部

追加一个新列表[29, 33, 30]，到列表的尾部

取出第一个元素（应是：21）

取出最后一个元素（应是：30）

查找元素31，在列表中的下标位置

# 案例age = [21, 25, 21, 23, 22, 20]# 追加31到尾部age.append(31)print(age)# 追加一个新列表到尾部age.extend([29,33,30])print(age)# 取出第一个元素print(f"取出的第一个元素是：{age[0]}")# 取最后一个元素print(f"最后一个元素：{age[-1]}")# 查找元素31print(f"元素31的下标：{age.index(31)}")

1.4 列表的遍历for/while

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。

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

while循环

index = 0while index < len(列表):元素 = 列表[index]方法index += 1

for循环

for 临时变量 in 数据容器:处理操作

对比

while循环和for循环，都是循环语句，但细节不同：

在循环控制上：

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

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

在无限循环上：

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

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

在使用场景上：

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

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

案例

定义一个列表，内容是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

遍历列表，取出列表内的偶数，并存入一个新的列表对象中

使用while循环和for循环各操作一次

# 练习案例my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# while 循环new_list = []index = 0while index < len(my_list):if my_list[index] % 2 == 0:new_list.append(my_list[index])index += 1print(new_list)# for 循环new_list = []for i in my_list:if i % 2 == 0:new_list.append(i)print(new_list)

2. tuple元组

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于：

元组一旦定义完成，就不可修改

2.1 定义元组

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

变量名称 = (元素1,元素2,...)# 定义口元组变量名称 = ()变量名称 = tuple()

注意：元组只有一个数据，这个数据后面要添加逗号

2.2 相关操作总结

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

特点：

经过上述对元组的学习，可以总结出列表有如下特点：

可以容纳多个数据

可以容纳不同类型的数据（混装）

数据是有序存储的（下标索引）

允许重复数据存在

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

支持for循环

多数特性和list一致，不同点在于不可修改的特性。

案例

定义一个元组，内容是：（‘cxk’, 2.5, [‘football’, ‘music’]），记录的是（姓名、年龄、爱好）

请通过元组的功能（方法），对其进行

查询其年龄所在的下标位置

查询姓名

删除爱好中的football

增加爱好：coding到爱好list内

# 案例my_tuple = ("cxk",11,["football","music"])print(f"年龄的位置为：{my_tuple.index(11)}")print(f"姓名：{my_tuple[0]}")del my_tuple[2][0]print(f"删除football后：{my_tuple}")my_tuple[2].append("coding")print(f"增加coding到list：{my_tuple}")

3. str字符串

尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。

但不可否认的是，字符串同样也是数据容器的一员。

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

3.1 下标索引

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

从前向后，下标从0开始

从后向前，下标从-1开始

同元组一样，字符串是一个：无法修改的数据容器。

所以：

修改指定下标的字符（如：字符串[0] = “a”）

移除特定下标的字符（如：del 字符串[0]、字符串.remove()、字符串.pop()等）

追加字符等（如：字符串.append()）

均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

3.2 常用操作总结

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

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

字符串的替换

语法：字符串.replace(字符串1，字符串2）功能：将字符串内的全部：字符串1，替换为字符串2注意：不是修改字符串本身，而是得到了一个新字符串

字符串的分割

语法：字符串.split(分隔符字符串）功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中注意：字符串本身不变，而是得到了一个列表对象

字符串去除空格

语法：字符串.strip() #去除两端空格

统计字符串中某字符串的出现次数count

统计字符串的长度len

字符串的遍历

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

3.3 字符串的特点

作为数据容器，字符串有如下特点：

只可以存储字符串

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

支持下标索引

允许重复字符串存在

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

支持for循环

基本和列表、元组相同

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

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

案例

给定一个字符串：“itcsdn itcast sb”

统计字符串内有多少个"it"字符

将字符串内的空格，全部替换为字符：“|”

并按照"|"进行字符串分割

my_list = "itcsdn itcast sb"print(f"有{my_list.count('it')}个it字符")new_list = my_list.replace(" ", "|")print(f"替换|后的字符串为：{new_list}")new1_list = my_list.split("|")print(f"按|分割字符串为：{new1_list}")

4. 序列的切片

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

列表、元组、字符串，均可以可以视为序列。

序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

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

序列[起始下标:结束下标:步长]# 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列

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

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

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

步长1表示，一个个取元素

步长2表示，每次跳过1个元素取

步长N表示，每次跳过N-1个元素取

步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

序列的切片实战

有字符串：“作工的误错做合适不，短太命生”

使用切片得到"生命太短"

my_str1 = "作工的误错做合适不，短太命生"new_str1 = my_str1[-1:-5:-1]print(f"切片字符串为：{new_str1}")

5. set集合

集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

# 定义集合变量定义集合变量 = {元素,元素,....,元素}# 定义空集合变量名称 = set()

和列表、元组、字符串等定义基本相同

列表使用：[]

元组使用：()

字符串使用：“”

集合使用：{}

5.1 集合的常用操作 - 修改

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

但是集合和列表一样，是允许修改的

添加新元素

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

移除元素

# 语法集合.remove(元素) # 将指定元素，从集合内移除# 结果：集合本身被修改，移除了元素

从集合中随机取出元素

# 语法集合.pop() #功能，从集合中随机取出一个元素# 结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

清空集合

# 语法集合.clear() # 功能，清空集合# 结果：集合本身被清空

5.3 集合的常用操作 - 两个集合

取出2个集合的差集

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

# 取两个集合的差集differenceset1 = {1,3,5,7,9}set2 = {2, 4, 5, 7, 9}set3 = set1.difference(set2)print(f"两个集合的差集为：{set3}")print(f"原集合set1：{set1}")print(f"原集合set2：{set2}")

消除2个集合的差集

# 语法集合1.difference_update(集合2) #功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。# 结果：集合1被修改，集合2不变

set1 = {1,3,5,7,9}set2 = {2, 4, 5, 7, 9}set1.difference_update(set2)print(f"消除两个集合的差集为：{set1}")print(f"原集合set2：{set2}")

2个集合合并

语法：集合1.union(集合2)功能：将集合1和集合2组合成新集合结果：得到新集合，集合1和集合2不变

set1 = {1,3,5,7,9}set2 = {2, 4, 5, 7, 9}set3 = set1.union(set2)print(f"两个集合为：{set3}")print(f"原集合set1：{set1}")print(f"原集合set2：{set2}")

5.2 集合的常用操作 - 集合长度

# 查看集合的元素数量语法：len(集合)功能：统计集合内有多少元素结果：得到一个整数结果

5.3 集合的常用操作 - for循环遍历

集合同样支持使用for循环遍历（语法同上）

集合是无序的

要注意：集合不支持下标索引，所以也就不支持使用while循环。

5.4 集合常用功能总结

经过上述对集合的认知，可以总结出集合有如下特点：

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

案例

有如下列表对象：

my_list = [‘我’, ‘是’, ‘小趴菜’, ‘小趴菜’, ‘cai’, ‘cai’, ‘da’, ‘sa’, ‘bi’]

请：

定义一个空集合

通过for循环遍历列表

在for循环中将列表的元素添加至集合

最终得到元素去重后的集合对象，并打印输出

## 案例my_set = set()my_list = ['我', '是', '小趴菜', '小趴菜', 'cai', 'cai', 'da', 'sa', 'bi']for i in my_list:my_set.add(i)print(my_set)

6. dict字典

为什么使用字典？

因为可以使用字典，实现用key取出Value的操作

6.1 字典的定义

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

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

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

6.2 字典的嵌套及获取

获取

字典同集合一样，不可以使用下标索引

但是字典可以通过Key值来取得对应的Value

嵌套

字典的Key和Value可以是任意数据类型（Key不可为字典）

那么，就表明，字典是可以嵌套的

需求如下：记录学生各科的考试信息

## 记录学生成绩stu_score = {"小王": {'语文':60, "数学":70, "英语":80},"小趴": {'语文':78, "数学":80, "英语":90},"小菜": {'语文': 66, "数学": 77, "英语": 88}}# 获取值print(f"小王的成绩为：{stu_score['小王']}")print(f"小趴的语文成绩为：{stu_score['小趴']['语文']}")

6.3 字典的常用操作

新增元素

语法：字典[Key] = Value
结果：字典被修改，新增了元素

stu_score = {"小王": {'语文':60, "数学":70, "英语":80},"小趴": {'语文':78, "数学":80, "英语":90},"小菜": {'语文': 66, "数学": 77, "英语": 88}}# 新增stu_score["大菜"] = {'语文': 66, "数学": 77, "英语": 88}print(f"新增后：{stu_score}")

更新元素

语法：字典[Key] = Value，结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

stu_score = {"小王": {'语文':60, "数学":70, "英语":80},"小趴": {'语文':78, "数学":80, "英语":90},"小菜": {'语文': 66, "数学": 77, "英语": 88}}# 更新stu_score["小菜"] = {'语文': 67, "数学": 78, "英语": 89}print(f"更新后：{stu_score}")

删除元素

语法：字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

stu_score = {"小王": {'语文':60, "数学":70, "英语":80},"小趴": {'语文':78, "数学":80, "英语":90},"小菜": {'语文': 66, "数学": 77, "英语": 88}}# 删除popvalue = stu_score.pop("小王")print(f"删除的值：{value}")print(f"删除后的原数据：{stu_score}")

清空字典

语法：字典.clear()
结果：字典被修改，元素被清空

stu_score = {"小王": {'语文':60, "数学":70, "英语":80},"小趴": {'语文':78, "数学":80, "英语":90},"小菜": {'语文': 66, "数学": 77, "英语": 88}}# 清除字典stu_score.clear()print(f"清除后：{stu_score}")

获取全部的key

语法：字典.keys()
结果：得到字典中的全部Key

stu_score = {"小王": {'语文':60, "数学":70, "英语":80},"小趴": {'语文':78, "数学":80, "英语":90},"小菜": {'语文': 66, "数学": 77, "英语": 88}}keys = stu_score.keys()print(f"所有的键为：{keys}")

遍历字典

语法：for key in 字典.keys()

stu_score = {"小王": {'语文':60, "数学":70, "英语":80},"小趴": {'语文':78, "数学":80, "英语":90},"小菜": {'语文': 66, "数学": 77, "英语": 88}}keys = stu_score.keys()for key in keys:print(f"学生：{key}, 分数：{stu_score[key]}")

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

计算字典内的全部元素（键值对）数量

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

6.4 字典的常用操作总结

案例

有如下员工信息，请使用字典完成数据的记录。

并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元

# 组织字典记录数据info_dict = {"小王": {"部门": "科技部","工资": 8000,"级别": 1},"小趴": {"部门": "市场部","工资": 6000,"级别": 2},"小菜": {"部门": "人事部","工资": 7000,"级别": 1},"大趴": {"部门": "市场部","工资": 4000,"级别": 3},"大菜": {"部门": "科技部","工资": 5000,"级别": 2}}print(f"员工在升值加薪之前的结果：{info_dict}")# for循环遍历字典for name in info_dict:# if条件判断符合条件员工if info_dict[name]["级别"] == 1:# 升职加薪操作# 获取到员工的信息字典employee_info_dict = info_dict[name]# 修改员工的信息employee_info_dict["级别"] = 2 # 级别+1employee_info_dict["工资"] += 1000 # 工资+1000# 将员工的信息更新回info_dictinfo_dict[name] = employee_info_dict# 输出结果print(f"对员工进行升级加薪后的结果是：{info_dict}")