一、数据容器入门
Python中的数据容器:
一种可以容纳多份数据的数据类型,容纳的每一份数据称之为1个元素,每一个元素,可以是任意类型的数据,如:字符串、数字、布尔等。
数据容器总共分为5种:
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)
二、数据容器:list(列表)
1、列表的定义
基本语法:
# 字面量 [元素1, 元素2, 元素3, ......] # 定义变量 变量名称 = [元素1, 元素2, 元素3, ......] # 定义空列表 变量名称 = [] 变量名称 = list()
列表的每一个数据,称之为元素
以[ ]作为标识
列表内每一个元素之间用**,**逗号隔开
python
# list演示
first_list=["RAY","爱学Python",666,True]
print(first_list)
print(type(first_list))

注:列表可以一次存储多个数据,且可以为不同的数据类型,支持嵌套
嵌套列表的定义
python
# list演示
first_list=[0,["RAY","爱学Python",666,True]]
print(first_list)
print(type(first_list))

2、列表的下标(索引)
可以通过下标索引取出特定位置的数据
python
# 列表 下标索引
name_list=["Java","Python","C"]
print(name_list[0])# 结果:Java
print(name_list[1])# 结果:Python
print(name_list[2])# 结果:C
或者,可以反向索引
python
name_list=["Java","Python","C"]
print(name_list[-1])# 结果:C
print(name_list[-2])# 结果:Python
print(name_list[-3])# 结果:Java
嵌套列表的下标

例:取出列表1中的0元素。列表[1][0]
3、列表的常用操作
- 查询某元素的下标
功能:查找指定元素在列表的下标,如果找不到,报错ValueError
语法:列表.index(元素)
index时列表对象(变量)内置的方法(函数)
python
myList=["RAY","爱学Python",666,True]
# 查找某元素在列表中的下标索引
index=myList.index("爱学Python")
print(f"爱学Python在列表中的下标索引值是:{index}")
# 如果被查找的元素不存在列表中,会报错
index=myList.index("hello")
print(f"hello在列表中的下标索引值是:{index}")
- 列表的修改功能(方法)
语法:列表[下标] = 值
可以使用语法直接对指定下标(正向、反向)的值进行重新赋值
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 正向下标
myList[0]="程序员"
print(myList)
# 反向下标
myList[-2]=888
print(myList)

- 插入元素:
语法:列表insert(下标,元素),在指定的下标位置,插入新的元素
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 插入元素
myList.insert(1,"程序员")
print(myList)

- 追加元素
语法:列表append(元素),将指定元素,追加到列表的尾部
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 追加元素
myList.append("!")
print(myList)

- 追加元素方式2
语法:列表.extend(其他数据容器),将其他数据容器的内容取出,依次追加到列表尾部
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 追加元素2
myList.extend([1,2,3])
print(myList)

- 删除元素
语法1: del 列表[下标]
语法2:列表.pop(下标)
python
myList=["RAY","爱学Python",666,True]
# 删除元素
# 语法1
del myList[3]
print(myList)
# 语法2
myList.pop(2)
print(myList)

- 删除某元素在列表中的第一个匹配项
语法:列表.remove(元素)
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 删除某元素在列表中的第一个匹配项
myList.remove(666)
print(myList)

- 清空列表
语法:列表.clear()
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 清空列表
myList.clear()
print(myList)

- 统计某元素在列表内的数量
语法:列表.count(元素)
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 统计某元素在列表内的数量
count=myList.count(666)
print(count)

- 统计列表内,共多少元素
语法:len(列表)
python
# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
length=len(myList)
print(length)

三、list(列表)的遍历
- while循环遍历列表
python
def list_while():
'''
使用while循环演示遍历列表
:return: None
'''
mylist=["程序猿","爱","学Python"]
index=0
while index<len(mylist):
element=mylist[index]
print(f"列表的元素:{element}")
index+=1
list_while()

- for循环遍历列表
python
def list_for():
'''
使用for循环演示遍历列表
:return: None
'''
mylist=["程序猿","爱","学Python"]
for i in mylist:
print(f"列表的元素:{i}")
list_for()

while循环和for循环,都是循环语句,但是细节不一样
在循环控制上:
while循环可以自定循环条件,并自行控制
for循环不可以自定循环条件,只可以一个个从容器里取出数据
在无限循环上:
while循环可以通过条件控制做到无线循环
for循环理论上不可以,因为被遍历的容器的容量不是无限的
在使用场景上:
while循环适用于任何想要循环的场景
for循环适用于,遍历数据容器的场景或简单的固定次数循环场景
四、数据容器:tuple(元组)
元组一旦完成,就不可以篡改,所以我们需要在程序内封装数据,但又不希望封装的数据被篡改,就使用元组
1、元组定义:
定义元组使用小括号,且用逗号隔开各个数据,数据可以是不同的数据类型
# 定义元组字面量 (元素, 元素, 元素, ......) # 定义元组变量 变量名称 = (元素, 元素, 元素, ......) # 定义空元组 变量名称 = () # 方式1 变量名称 = tuple() # 方式2
元组也支持嵌套
# 定义一个嵌套元组 t1 = ((1, 2, 3), (4, 5, 6)) print(t1[0][1]) # 结果:2
注: 当定义一个元素的元组时,需要在这个数据后面添加逗号,否则不是元组类型
python
t1=("1",)
2、元组的相关操作:
|---------|---------------------------|
| 方法 | 作用 |
| index() | 查找某个数据,如果数据存在返回对应的下标,否则报错 |
| count() | 统计某个数据在当前元组出现的次数 |
| len(元组) | 统计元组的元素数量 |
python
t1=(1,"1","程序猿","爱","学Python",1)
print(t1[0])
print(t1.index("爱"))
print(t1.count(1))
print(len(t1))

3、元组的遍历
while循环:
python
t1=(1,"1","程序猿","爱","学Python",1)
index=0
while index<len(t1):
print(f"元组元素有:{t1[index]}")
index+=1

for循环:
python
t1=(1,"1","程序猿","爱","学Python",1)
for i in t1:
print(f"元组元素有:{i}")

注:元组不可以修改内容,但可以修改元组内的list内容,包括:修改元素、增加、删除、反转等
五、数据容器:str(字符串)
1、字符串定义
字符串是字符的容器,一个字符串可以存放任意数量的字符
字符串的下标:
空格也会计入索引
python
name="RAY"
print(name[0]) # 结果:R
print(name[1]) # 结果:A
print(name[-1]) # 结果:Y
字符串是一个无法修改的数据容器,所以不可以完成修改指定下标的字符、移除指定下标的字符、追加字符等。如果必须要做,只能得到一个新的字符串
2、字符串的常见操作
- 字符串的替换
语法:字符串.replace(字符串1,字符串2)
功能:将字符串内的全部:字符串1,替换为字符串2
注意:不是修改字符串本身,而是得到了一个新的字符串
python
name="RAY"
name_new=name.replace("AY","ay")
print(f"将字符串{name}替换后得到{name_new}")

- 字符串的分割
语法:字符串.split(字符串)
功能:按照指定的分割字符串,将字符串划分为多个字符串,并存入到列表对象中
注意:字符串本身不变,而是得到了一个列表对象
python
name="R A Y"
name_list=name.split(" ")
print(f"将字符串{name}分割后得到{name_list}")

- 字符串的规整操作(去前后空格)
语法:字符串.strip()
python
name=" R A Y "
name_list=name.split()
print(f"将字符串{name}规整(去前后空格)后得到{name_list}")

- 字符串的规整操作(去前后指定字符串)
语法:字符串.strip(字符串)
python
name="12RAY21"
name_list=name.split("1")
print(f"将字符串{name}规整(去前后指定字符串)后得到{name_list}")

- 统计字符串内某字符出现的次数【字符串.count(字符串)】
- 统计字符串的字符个数 【len(字符串)】
六、数据容器(序列)的切片
序列:内容连续、有序,可以使用下标索引的一类数据容器
列表、元组、字符串,均可视为序列,序列支持切片
切片:从一个序列中,取出一个子序列
语法:序列[起始下标:结束下标:步长]
表示从序列中,从指定位置依次取出元素,到指定位置结束,得到一个新序列
其实下标表示从何处开始,可以留空,留空视作从头开始
结束下标(不含)表示何处结束,可以留空,留空表示视截取到结尾
步长表示,依次取元素的间隔,默认步长1
步长1表示,一个个取元素
步长2表示,每次跳过一个元素取
步长为负数表示,反向取(注意,其实下标和结束下标也要反向标记)
**注:**此操作不会影响序列本身,而是会得到一个新的序列
python
mylist=[0,1,2,3,4,5,6]
# 对mylist进行切片,从1开始,4结束,步长1
result1=mylist[1:4]
print(f"结果1:{result1}")
# 对mylist进行切片,从头到尾,步长1
result2=mylist[:]
print(f"结果2:{result2}")
# 对mylist进行切片,从头到尾,步长2
result3=mylist[::2]
print(f"结果3:{result3}")
# 对mylist进行切片,从头到尾,步长-1
result4=mylist[::-1]
print(f"结果4:{result4}")
# 对mylist进行切片,从3开始,1结束,步长-1
result5=mylist[3:1:-1]
print(f"结果5:{result5}")
# 对mylist进行切片,从头到尾,步长-2
result6=mylist[::-2]
print(f"结果6:{result6}")

七、数据容器:set(集合)
1、元组定义
基础语法:
# 定义集合字面量 {元素, 元素, 元素, ......} # 定义集合变量 变量名称 = {元素, 元素, 元素, ......} # 定义空集合 变量名称 = set()
特点:不支持元素的重复、并且内容无序(不支持下标索引)、可以修改、支持for循环
2、数组的常见操作
- 添加新元素
语法:集合.add(元素)
将指定元素,添加到集合内
结果:集合本身被修改,添加了新元素
python
mySet={"Hello","World","!"}
mySet.add("RAY")
print(mySet) # 结果:{'Hello', 'RAY', 'World', '!'}
- 移除元素
语法:集合.remove(元素)
python
mySet = {"Hello", "World", "!"}
mySet.remove("!")
print(mySet) # 结果:{'Hello', 'World'}
- 随机取出一个元素
语法:变量名=集合.pop()
python
mySet = {"Hello", "World", "!"}
res = mySet.pop()
print(res) # 结果:!
print(mySet) # 结果:{'Hello', 'World'}
- 清空集合
python
mySet = {"Hello", "World", "!"}
mySet.clear()
print(mySet) # 结果:set()
- 取两个集合的差值
语法:集合.difference(集合2)
功能:取出集合1和集合2的差值(集合1有而集合2没有的)
结果:得到一个辛几何,集合1和集合2没变
python
set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
print(set1) # 结果:{1, 2, 3}
print(set2) # 结果:{1, 5, 6}
print(set3) # 结果:{2, 3}
- 消除两个集合的差值
语法:集合1.difference_update(集合2)
功能:对比集合1和集合2,在集合1内,删除和集合2相同的怨怒是
结果:集合1被修改,集合2不变
python
set1={1,2,3}
set2={1,5,6}
set1.difference_update(set2)
print(set1) # 结果:{2, 3}
print(set2) # 结果:{1, 5, 6}
- 2个集合合并为1个
语法:集合1.union(集合2)
功能:将集合1和集合2组合成新集合
结果:得到新数组,集合1和集合2不变
python
set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)
print(set1) # 结果:{1, 2, 3}
print(set2) # 结果:{1, 5, 6}
print(set3) # 结果:{1, 2, 3, 5, 6}
- 统计集合元素数量
语法:len(集合)
python
set={1, 2, 3, 5, 6}
print(len(set)) # 结果:5
- 集合的遍历
集合不支持下标索引,不能使用while循环,可以使用for循环
python
set={1, 2, 3, 5, 6}
for i in set:
print(f"集合的元素有:{i}")

八、数据容器:dict(字典、映射)
字典可以基于Key检索Value的场景实现
1、字典的定义
字典的定义,同样使用{},不过存储的元素是一个个的:键值对,如下语法:
# 定义字典字面量 {key: value, key: value, key: value, ......} # 定义字典变量 myDict = {key: value, key: value, key: value, ......} # 定义空字典 myDict = {} # 定义空字典方式1 myDict = dict() # 定义空字典方式2
python
myDict1 = {"张三": 99, "李四": 88, "王五": 77}
# 定义空字典
myDict2 = {} # 定义空字典方式1
myDict3 = dict() # 定义空字典方式2
print(f"字典1内容是:{myDict1},类型是{type(myDict1)}")
print(f"字典2内容是:{myDict2},类型是{type(myDict2)}")
print(f"字典3内容是:{myDict3},类型是{type(myDict3)}")

注:不允许定义重复key的字典 ,重复添加等同于覆盖原有数据
字典的Key和Value可以是任意类型(Key不可为字典)
字典不可以使用下标检索,而是使用Key检索Value
2、字典的常见操作
- 字典数据的获取
字典同集合一样,不可以使用下标索引
但在字典中可以通过key值来获取对应的value
python
# 语法,字典[key]可以获取到对应的value
myDict = {"张三": 99, "李四": 88, "王五": 77}
print(myDict["张三"]) # 结果:99
print(myDict["李四"]) # 结果:88
print(myDict["王五"]) # 结果:77
# print(myDict["王老五"]) # 结果:报错
- 字典的嵌套
字典的Key和Value可以是任意类型(Key不可为字典)
例:

python
score = {"张三": {"语文": 77, "数学": 66, "英语": 33},
"李四": {"语文": 88, "数学": 86, "英语": 55},
"王五": {"语文": 99, "数学": 96, "英语": 86}}
print(f"学生信息:{score}")
# 结果:学生信息:{'张三': {'语文': 77, '数学': 66, '英语': 33}, '李四': {'语文': 88, '数学': 86, '英语': 55}, '王五': {'语文': 99, '数学': 96, '英语': 86}}
#在嵌套字典中获取数据
#看王五的语文
ww_chinese=score["王五"]["语文"]
print(f"王五的语文是:{ww_chinese}")
# 结果:王五的语文是:99
- 新增元素
语法:字典[Key] = Value
结果:字典被修改,新增了元素
python
myDict = {"张三": 99, "李四": 88, "王五": 77}
myDict["老六"]=66
print(myDict) # 结果:{'张三': 99, '李四': 88, '王五': 77, '老六': 66}
- 更新元素
语法:字典[Key] = Value
结果:字典被修改,元素被更新
注意:字典Key不可以被修改,所以对已存在的Key执行更新元素,就是在更新Value值
python
myDict = {"张三": 99, "李四": 88, "王五": 77}
myDict["王五"]=55
print(myDict) # 结果:{'张三': 99, '李四': 88, '王五': 55}
- 删除元素
语法:字典.pop(Key)
结果:获取指定Key的Value,同时字典被修改,指定Key的数据被删除
python
myDict = {"张三": 99, "李四": 88, "王五": 77}
val=myDict.pop("张三")
print(val) # 结果:99
print(myDict) # 结果:{'李四': 88, '王五': 77}
- 清空元素
语法:字典.clear()
结果:字典被修改,元素被清空
python
myDict = {"张三": 99, "李四": 88, "王五": 77}
myDict.clear()
print(myDict) # 结果:{}
- 获取全部的Key
语法:字典.keys()
结果:获得字典中所有的Key
python
myDict = {"张三": 99, "李四": 88, "王五": 77}
keys=myDict.keys()
print(keys) # 结果:dict_keys(['张三', '李四', '王五'])
- 遍历字典
python
myDict = {"张三": 99, "李四": 88, "王五": 77}
keys=myDict.keys()
# 遍历字典
# 方式1
print("============方式1==============")
for key in keys:
print(f"字典的Key是:{key}")
print(f"字典的value是:{myDict[key]}")
# 方式2
print("============方式2==============")
for key in myDict:
print(f"字典的Key是:{key}")
print(f"字典的value是:{myDict[key]}")

- 统计字典内的元素数量
语法:len(字典)
python
myDict = {"张三": 99, "李四": 88, "王五": 77}
print(len(myDict))# 结果:3
练习 :升值加薪
有如下员工信息,请使用字典完成数据的记录。
并通过for循环,对所有级别为1级的员工,级别上升1级,薪水增加1000元
分别输出加薪前后的数据
|-----|-----|------|----|
| 姓名 | 部门 | 工资 | 级别 |
| 吴老二 | 科技部 | 4000 | 2 |
| 张三 | 科技部 | 3000 | 1 |
| 李四 | 市场部 | 5000 | 2 |
| 王五 | 科技部 | 7000 | 3 |
| 老六 | 市场部 | 6000 | 2 |
python
# 定义字典
dict = {"吴老二": {"部门": "科技部", "工资": 4000, "级别": 2},
"张三": {"部门": "科技部", "工资": 3000, "级别": 1},
"李四": {"部门": "市场部", "工资": 5000, "级别": 2},
"王五": {"部门": "科技部", "工资": 7000, "级别": 3},
"老刘": {"部门": "市场部", "工资": 6000, "级别": 2}}
# 输出
print(f"对员工升职加薪前结果:{dict}")
# 结果:对员工升职加薪前结果:{'吴老二': {'部门': '科技部', '工资': 4000, '级别': 2}, '张三': {'部门': '科技部', '工资': 3000, '级别': 1}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '王五': {'部门': '科技部', '工资': 7000, '级别': 3}, '老刘': {'部门': '市场部', '工资': 6000, '级别': 2}}
# 遍历字典
for name in dict:
if dict[name]["级别"] == 1:
# 升职加薪
# 获取员工信息字典
employeeDict=dict[name]
# 修改员工信息
employeeDict["级别"]=2
employeeDict["工资"]+=1000
# 将信息返回
dict[name]=employeeDict
# 输出结果
print(f"对员工升职加薪后结果:{dict}")
# 结果:对员工升职加薪后结果:{'吴老二': {'部门': '科技部', '工资': 4000, '级别': 2}, '张三': {'部门': '科技部', '工资': 4000, '级别': 2}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '王五': {'部门': '科技部', '工资': 7000, '级别': 3}, '老刘': {'部门': '市场部', '工资': 6000, '级别': 2}}
九、数据容器的异同
|------|------------------|---------------------|------------|-------------|-----------------------------------|
| | 列表 | 元组 | 字符串 | 集合 | 字典 |
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | | 仅字符 | 任意 | Key:Value key:除字典外任意类型 Value:任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景场景 | 一串字符串的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
数据容器的通用操作:
- 遍历:都支持for循环,部分支持while循环(列表、元组、字符串)
- 统计容器的元素个数【len(容器)】
- 统计容器的最大元素【max(容器)】
- 统计容器的最小元素【min(容器)】
- 通用转换:
- 将给定容器转换为列表【list(容器)】
- 将给定容器转换为字符串【str(容器)】
- 将给定容器转换为元组【tuple(容器)】
- 将给定容器转换为集合【set(容器)】
- 将给容器进行排序【sorted(容器,[reverse=True])】