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

最新推荐文章于 2023-09-21 15:44:20 发布

小趴菜_

最新推荐文章于 2023-09-21 15:44:20 发布

阅读量1.7k

点赞数 4

分类专栏： python入门到精通文章标签： python

本文链接：https://blog.csdn.net/hexiaosi_/article/details/127577839

版权

python入门到精通专栏收录该内容

7 篇文章 3 订阅

订阅专栏

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为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 常用操作方法总结

列表也提供了一系列功能：
插入元素
删除元素
清空列表
修改元素
统计元素个数
等等功能，这些功能我们都称之为：列表的方法

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

列表有如下特点：
可以容纳多个元素（上限为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]}")
# 查找元素31
print(f"元素31的下标：{age.index(31)}")

在这里插入图片描述

1.4 列表的遍历for/while

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

while循环

index = 0
while 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 = 0
while index < len(my_list):
    if my_list[index] % 2 == 0:
        new_list.append(my_list[index])
    index += 1
print(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 相关操作总结

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

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

特点：

经过上述对元组的学习，可以总结出列表有如下特点：
可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是有序存储的（下标索引）
允许重复数据存在
不可以修改（增加或删除元素等）
支持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 常用操作总结

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

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

 语法：字符串.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不变

# 取两个集合的差集difference
set1 = {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 集合常用功能总结

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

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

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是无序存储的（不支持下标索引）
不允许重复数据存在
可以修改（增加或删除元素等）
支持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不可为字典）
那么，就表明，字典是可以嵌套的

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

姓名	语文	数学	英语
小王	60	70	80
小趴	78	80	90
小菜	66	77	88

## 记录学生成绩
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}
}

# 删除pop
value = 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 字典的常用操作总结

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

案例

有如下员工信息，请使用字典完成数据的记录。
并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元

姓名	部门	工资	级别
小王	科技部	8000	1
小趴	市场部	6000	2
小菜	人事部	7000	1
大趴	市场部	4000	3
大菜	科技部	5000	2

# 组织字典记录数据
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    # 级别+1
        employee_info_dict["工资"] += 1000    # 工资+1000
        # 将员工的信息更新回info_dict
        info_dict[name] = employee_info_dict

# 输出结果
        print(f"对员工进行升级加薪后的结果是：{info_dict}")

在这里插入图片描述

7. 总结

7.1 数据容器分类

数据容器可以从以下视角进行简单的分类：

是否支持下标索引

支持：列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型

是否支持重复元素

支持：列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型

是否可以修改

支持：列表、集合、字典
不支持：元组、字符串

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

7.2 容器通用功能

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

小趴菜_

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
python入门到精通 _5数据容器（list、tuple、str、set、dict）

基本语法# 定义变量变量名称 = [ 元素 1 , 元素 2 , 元素 3 , . . . . ] # 空列表变量名称 = [ ] 变量名称 = list()元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表my_list = [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] print(f"列表为： {my_list } ,数据类型为： {{my_list = [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] print(f"列表为： {
复制链接

扫一扫