参考视频和资料:第一阶段-第六章-01-数据容器入门_哔哩哔哩_bilibili
Day06
对应视频:第一阶段第六章
第六章 数据容器
目录
一、基本知识点
学习数据容器,就是为了批量存储或批量使用多份数据
1.定义
(1)数据容器: 一种可以容纳多份数据的数据类型
(2)元素:容纳的每一份数据称之为1个元素
每一个元素,可以是任意类型的数据,如字符串、数字、布尔等。
2.分类
(1)依据
是否支持重复元素
是否可以修改
是否有序
......
(2)类型
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)
二、数据容器:list(列表)
1.列表的基本知识
(1)元素:列表中的每一个数据称之为元素
(2)标识:[]
列表内每一个元素之间用逗号隔开
(3)数据类型:list
2.列表的语法
(1)字面量
[元素1,元素2,元素3,...]
(2)定义变量
变量名称 = [元素1,元素2,元素3,...]
list1 = ["python","study","up"]
print(list1) # 结果:['python', 'study', 'up']
print(type(list1)) # 结果:<class 'list'>
(3)定义空列表
a.变量名称 = []
b.变量名称 = list()
(4)元素的数据类型不受限制
list2 = ["python",666,True]
print(list2) # 结果:['python', 666, True]
print(type(list2)) # 结果:<class 'list'>
(5)支持列表嵌套
list3 = [[1,2,3],[4,5,6]]
print(list3) # 结果:[[1, 2, 3], [4, 5, 6]]
print(type(list3)) # 结果:<class 'list'>
3.列表的下标索引
(1)定义
使用下标索引可以取出特定位置的数据
(2)语法
列表[下标]
列表中的每一个元素都具有对应位置的下标索引,从前往后,从0开始依次递增
# 正向下标索引取出元素
list1 = ["Tom","rose","lily"]
print(list1[0]) # 结果:Tom
print(list1[1]) # 结果:rose
print(list1[2]) # 结果:lily
# 下面一行语句会报错:IndexError: list index out of range
# 使用下标索引取数据,下标不能超出列表的范围
# print(list1[3])
(3)反向下标索引
从后往前,从-1开始依次递减(-1,-2,-3,...)
(因为0没有正负,所以如果用0开始就无法与正向区别开)
# 反向下标索引取出元素
list1 = ["Tom","rose","lily"]
print(list1[-1]) # 结果:lily
print(list1[-2]) # 结果:rose
print(list1[-3]) # 结果:Tom
(4)嵌套的下标索引
例如:第二个列表中的第一个元素列表[1][0]
# 取出嵌套列表中的元素
list2 = [[1,2,3],[4,5,6]]
print(list2[1][0]) # 结果:4
【注意】:通过下标索引取数据,不可以超过列表的范围
4.列表的常用操作(方法)
Python中,若将函数定义为class(类)的成员,那么函数就会被称为:方法
方法的调用需要先获得方法所在class类的对象,再通过类对象获取方法——面向对象
(1)查询元素
查询指定元素在列表的下标
语法:
列表.index(元素)
index就是列表对象(变量)内置的方法(函数)
若找不到,报错ValueError
【注意】:该语句查询不了嵌套列表,且查询到的是正向索引
test_list = ["python","study","up"]
# 1.查询某个元素在列表中的索引下标
index = test_list.index("study")
print(f"study在列表中的索引下标是:{index}") # 结果:study在列表中的索引下标是:1
# 若被查询的元素不存在,会报错:ValueError: 'sleep' is not in list
# index = test_list.index("sleep")
# print(f"sleep在列表中的索引下标是:{index}")
(2)修改元素
修改特定位置(索引)的元素值
语法:
列表[下标] = 值
test_list = ["python","study","up"]
# 2.修改特定下标索引的值
test_list[2] = "go"
print(f"列表被修改后的值为:{test_list}") # 结果:列表被修改后的值为:['python', 'study', 'go']
(3)插入元素
在指定下标位置,插入指定的元素
语法:
列表.insert(下标,元素)
test_list = ["python","study","up"]
# 3.在指定下标位置插入指定的元素
test_list.insert(1,"it")
print(f"在列表位置1出插入元素后的值为:{test_list}") # 结果:在列表位置1出插入元素后的值为:['python', 'it', 'study', 'up']
(4)追加元素
语法:
a.追加单个元素
列表.append(元素)
将指定元素,追加到列表的尾部
test_list = ["python","study","up"]
# 4_1.追加单个元素:将指定元素,追加到列表的尾部
test_list.append("come on")
print(f"追加单个元素后,列表的值为:{test_list}") # 结果:追加单个元素后,列表的值为:['python', 'study', 'up', 'come on']
b.追加多个元素
列表.extend(其他数据容器)
将其他数据容器的内容取出,依次追加到列表尾部
test_list = ["python","study","up"]
# 4_2.追加多个元素:将其他数据容器的内容取出,依次追加到列表尾部
list1 = [1,2,3]
test_list.extend(list1)
print(f"追加多个元素后,列表的值为:{test_list}") # 结果:追加多个元素后,列表的值为:['python', 'study', 'up', 1, 2, 3]
(5)删除功能
语法:
a.del 列表[下标]
删除指定下标的元素
# 5_1.删除指定下标元素:del
test_list = ["python","study","up"]
del test_list[2]
print(f"通过del删除下标为2的元素后,列表的值为:{test_list}") # 结果:通过del删除下标为2的元素后,列表的值为:['python', 'study']
b.列表.pop(下标)
将指定下标元素取出来,再返回出去
当不指定下标时,即列表.pop(),默认删除最后一位
# 5_2.删除指定下标元素:pop
test_list = ["python","study","up"]
element = test_list.pop(2)
print(f"通过pop删除下标为2的元素后,列表的值为:{test_list}。删除的元素为:{element}") # 结果:通过pop删除下标为2的元素后,列表的值为:['python', 'study']。删除的元素为:up
c.列表.remove(元素)
删除指定元素在列表中的第一个匹配项(从前往后)
# 5_3.删除指定元素在列表中的第一个匹配项
test_list = ["python","study","up","python"]
test_list.remove("python")
print(f"通过remove删除python元素后,列表的值为:{test_list}") # 结果:通过remove删除python元素后,列表的值为:['study', 'up', 'python']
d.列表.clear()
清空列表内容
# 5_4.清空列表
test_list = ["python","study","up","python"]
test_list.clear()
print(f"清空列表后,列表的值是:{test_list}") # 结果:清空列表后,列表的值是:[]
del与pop的区别:
a.del是删除命令,pop与remove为list的内置方法
b.列表就是一个python内置类,pop是列表类封装的实现元素删除功能的方法
补充:函数和方法本质相同,只不过方法是封装在一个类中,用于被该类创建的对象调用
可以说,方法是函数的一种
(6)统计功能
语法:
a.列表.count(元素)
统计某元素在列表中的数量,给一个返回值
# 6.统计某元素在列表中的数量
test_list = ["python","study","up","python"]
count = test_list.count("python")
print(f"列表中python元素出现的次数是:{count}") # 结果:列表中python元素出现的次数是:2
b.len(列表)
统计列表内,有多少元素,给一个返回值
# 7.统计列表有多少个元素
test_list = ["python","study","up","python"]
count = len(test_list)
print(f"列表中的元素个数是:{count}") # 结果:列表中的元素个数是:4
建议:不用硬记所有的功能方法,只需要有一个印象,知道有这样一个方法就行。需要的时候再查阅资料
5.列表的特点
(1)可以容纳多个元素(上限为2**63-1、9223372036854775807个)
(2)可以容纳不同类型的元素(混装)
(3)数据是有序存储的(有下标序号)
(4)允许重复数据存在
(5)可以修改(增加或删除元素等)
6.常用功能练习
test_list = [21,25,21,23,22,20]
# 追加数字31,到列表尾部
test_list.append(31)
print(f"在尾部追加数字31后,列表的值为:{test_list}") # 结果:在尾部追加数字31后,列表的值为:[21, 25, 21, 23, 22, 20, 31]
# 追加一个新列表[29,33,30],到列表尾部
test_list.extend([29,33,30])
print(f"在尾部追加新列表[29,33,30]后,列表的值为:{test_list}") # 结果:在尾部追加新列表[29,33,30]后,列表的值为:[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
# 取出第一个元素
num = test_list.pop(0)
print(f"取出第一个元素后,列表的值为:{test_list}。所取出的元素值为:{num}") # 结果:取出第一个元素后,列表的值为:[25, 21, 23, 22, 20, 31, 29, 33, 30]。所取出的元素值为:21
# 取出最后一个元素
length = len(test_list)
# num = test_list.pop(-1)
num = test_list.pop(length-1)
print(f"取出最后一个元素后,列表的值为:{test_list}。所取出的元素值为:{num}") # 结果:取出最后一个元素后,列表的值为:[25, 21, 23, 22, 20, 31, 29, 33]。所取出的元素值为:30
# 查找元素31,在列表中的下标位置
position = test_list.index(31)
print(f"元素31在列表中的下标位置为:{position}") # 结果:元素31在列表中的下标位置为:5
7.list(列表)的遍历
将容器内的元素依次取出进行处理的行为,称之为:遍历、迭代
(1)方法:借助循环语句
a.while循环
index = 0
while index < len(列表)
元素 = 列表[index]
对元素进行处理
index += 1
test_list = ["python","study","up"]
def list_while_func(use_list):
"""
使用while循环遍历列表元素
1.循环变量通过索引下标来控制,默认为0
2.每次循环都将索引下标变量+1
3.循环条件:遍历的索引下标 < 列表长度
:param use_list:从外部传进来的需要操作的列表
:return: None
"""
# index:列表元素下标
index = 0
while index < len(use_list):
# element:临时存储当前遍历到的元素值
element = use_list[index]
print(f"列表的元素:{element}")
# 每次循环都将索引下标变量+1
index += 1
list_while_func(test_list)
# 结果:
# 列表的元素:python
# 列表的元素:study
# 列表的元素:up
b.for循环(更便利)
for 临时变量 in 数据容器
对临时变量进行处理
test_list = ["python","study","up"]
def list_for_func(use_list):
"""
使用for循环遍历列表
依次取出列表中的元素赋给临时变量,然后进行输出
:param use_list: 从外部传进来的需要操作的列表
:return: None
"""
for element in use_list:
print(f"列表的元素:{element}")
list_for_func(test_list)
# 结果:
# 列表的元素:python
# 列表的元素:study
# 列表的元素:up
(2)while循环和for循环的区别
a.在循环控制上:
while循环可以自定循环条件,并自行控制
for循环不可以自定循环条件,只可以一个个从容器内取出数据
b.在无限循环上:
while循环可以通过条件控制做到无限循环
for循环理论上不可以,因为被遍历的容器容量不是无限的
c.在使用场景上:
while循环适用于任何想要循环的场景
for循环适用于,遍历数据容器的场景或简单的固定次数循环场景
for循环更简单,while循环更灵活
(3) 取出列表内的偶数小练习
test_list = [1,2,3,4,5,6,7,8,9,10]
def list_while(use_list):
index = 0
new_list = []
while index < len(use_list):
if use_list[index] % 2 == 0:
element = use_list.pop(index)
new_list.append(element)
index += 1
return new_list
def list_for(use_list):
i = 0
new_list = []
for x in use_list:
if x % 2 == 0:
element = use_list.pop(i)
new_list.append(element)
i += 1
return new_list
print(f"通过while循环,从列表:[1,2,3,4,5,6,7,8,9,10]中取出偶数,组成新列表:{list_while(test_list)},取出后原来的列表为:{test_list}")
# 结果:通过while循环,从列表:[1,2,3,4,5,6,7,8,9,10]中取出偶数,组成新列表:[2, 4, 6, 8, 10],取出后原来的列表为:[1, 3, 5, 7, 9]
print(f"通过for循环,从列表:{test_list}中取出偶数,组成新列表:{list_for(test_list)},取出后原来的列表为:{test_list}")
# 结果:通过for循环,从列表:[1, 3, 5, 7, 9]中取出偶数,组成新列表:[],取出后原来的列表为:[1, 3, 5, 7, 9]
# 原因见补充
test_list = [1,2,3,4,5,6,7,8,9,10]
print(f"通过for循环,从列表:[1,2,3,4,5,6,7,8,9,10]中取出偶数,组成新列表:{list_for(test_list)},取出后原来的列表为:{test_list}")
# 结果:通过for循环,从列表:[1,2,3,4,5,6,7,8,9,10]中取出偶数,组成新列表:[2, 4, 6, 8, 10],取出后原来的列表为:[1, 3, 5, 7, 9]
补充:
在python中,根据实参的对象类型,分为可变对象和不可变对象
当实参是可变对象(如列表和字典等),函数参数的传递方式将采用引用传递方式——相当于直接使用它本身,改变它的值会影响它本身。
当实参是不可变对象(如字符串,整型和浮点型等),函数传递时会复制一份再进行传递,这时在函数内改变它的值不会影响原来的值
三、数据容器:tuple(元组)
1.元组基本知识
元组同列表一样,可以封装多个、不同类型的元素
特点:元组一旦定义完成,就不可以被修改——相当于一个只允许读的list
2.语法
数据可以是不同的数据类型
(1)定义元组字面量
(元素,元素,元素,...,元素)
(2)定义元组变量
变量名称 = (元素,元素,元素,...,元素)
t1 = ("python",666,True)
print(f"t1的数据类型是:{type(t1)},内容是:{t1}")
# 结果:t1的数据类型是:<class 'tuple'>,内容是:('python', 666, True)
(3)定义空元组
a.变量名称 = ()
b.变量名称 = tuple()
t2 = ()
t3 = tuple()
print(f"t2的数据类型是:{type(t2)},内容是:{t2}")
# 结果:t2的数据类型是:<class 'tuple'>,内容是:()
print(f"t3的数据类型是:{type(t3)},内容是:{t3}")
# 结果:t3的数据类型是:<class 'tuple'>,内容是:()
【注意】:当元组只有一个数据的时候,这个数据后面要添加逗号,不然就不是元组类型
t4 = ("hello")
print(f"t4的数据类型是:{type(t4)},内容是:{t4}")
# 结果:t4的数据类型是:<class 'str'>,内容是:hello
t4 = ("hello",)
print(f"t4的数据类型是:{type(t4)},内容是:{t4}")
# 结果:t4的数据类型是:<class 'tuple'>,内容是:('hello',)
(4)元组也支持嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的数据类型是:{type(t5)},内容是:{t5}")
# 结果:t5的数据类型是:<class 'tuple'>,内容是:((1, 2, 3), (4, 5, 6))
(5)元组也支持下标索引
num = t5[1][0]
print(f"取出值的数据类型是:{type(num)},内容是:{num}")
# 结果:取出值的数据类型是:<class 'int'>,内容是:4
3.元组的相关操作
【注意】:元组不可修改,也就没有列表中插入删除等操作
(1)查找
index()
# 查询元组中某个数据的下标
t1 = ("python",666,True)
index = t1.index(666)
print(f"666在元组中的下标为:{index}")
# 结果:666在元组中的下标为:1
(2)统计某个数据在元组中出现的次数
count()
# 统计元组中某个数据出现的次数
t2 = ("python",666,True,"python",666,True,"python",666,True)
count = t2.count(666)
print(f"666在元组中出现的次数为:{count}")
# 结果:666在元组中出现的次数为:3
(3)统计元组内的元素个数
len(元组)
# 统计元组的长度
t2 = ("python",666,True,"python",666,True,"python",666,True)
length = len(t2)
print(f"元组t2的长度为:{length}")
# 结果:元组t2的长度为:9
(4)元组的遍历:for循环和while循环
# 元组的遍历
t1 = ("python",666,True)
# while循环遍历
index = 0
while index < len(t1):
element = t1[index]
print(f"元组的元素有:{element}")
index += 1
# 结果:
# 元组的元素有:python
# 元组的元素有:666
# 元组的元素有:True
# for循环遍历
for element in t1:
print(f"元组的元素有:{element}")
# 结果:
# 元组的元素有:python
# 元组的元素有:666
# 元组的元素有:True
# 元组的内容不可以被修改
# t1 = ("python",666,True)
# t1[0] = 1
# # 元组中list的内容可被修改
# t1 = (1,2,3,[3,5,6])
# print(f"修改前:{t1}")
# t1[3][0] = 4
# print(f"修改后:{t1}")
4.元组的注意事项
(1)元组的内容不可以被修改
(2)元组内list的内容是可以被修改的(修改元素、增加、删除和反转等)
5.元组的特点
(1)可以容纳多个数据
(2)可以容纳不同类型的数据
(3)数据是有序存储的(下标索引)
(4)允许重复数据纯在
(5)不可以修改(增加或删除元素等)
(6)支持for循环
大部分与列表一致,不同于元组不可修改
6.元组基本操作练习
"""
元组基本操作练习
"""
t1 = ("张三",18,["football","music"])
# 查询年龄所在下标
print(f"年龄所在下标为:{t1.index(18)}")
# 结果:年龄所在下标为:1
# 查询姓名
print(f"姓名为:{t1[0]}") # 结果:姓名为:张三
# 删除学生爱好中的football
del t1[2][0]
print(f"删除football后,元组内容为:{t1}")
# 结果:删除football后,元组内容为:('张三', 18, ['music'])
# 增加爱好coding
print(f"删除football后,music所在位置的数据类型为:{type(t1[2])}")
# 结果:删除football后,music所在位置的数据类型为:<class 'list'>
# list(t1[2])
t1[2].insert(1,"coding")
print(f"插入coding后,元组的内容为:{t1}")
# 结果:插入coding后,元组的内容为:('张三', 18, ['music', 'coding'])
四、数据容器:str(字符串)
1.基本知识点
a.字符串可以存放任意数量的字符,可以看做是字符的容器
b.同样字符串也支持下标访问
前往后,从下标0开始
后往前,从下标-1开始
test_str = "Hello python gogogo"
print(f"字符串下标为1的值为:{test_str[1]},下标为-18的值为:{test_str[-18]}")
# 结果:字符串下标为1的值为:e,下标为-18的值为:e
c.字符串同元组一样,是一个无法修改的数据容器
如果必须要修改,只能得到一个新的字符串,旧的字符串无法修改
test_str[1] = "o" # 报错:TypeError: 'str' object does not support item assignment
2.字符串的常用操作
![](https://i-blog.csdnimg.cn/blog_migrate/1d143043c17325ac6e11b5d485750a6b.png)
(1)查找特定字符串的下标索引值
字符串.index(字符串)
返回的是起始下标
test_str = "Hello python and gogogo"
# index方法
value = test_str.index("and")
print(f"and在字符串{test_str}中的起始下标为:{value}")
# 结果:and在字符串Hello python and gogogo中的起始下标为:13
(2)字符串的替换
字符串.replace(字符串1,字符串2)
将字符串内的字符串1替换为字符串2
# replace方法
test_str = "Hello python and gogogo"
new_str = test_str.replace("and","then")
print(f"将字符串{test_str}中的and替换为then后得到:{new_str}")
# 结果:将字符串Hello python and gogogo中的and替换为then后得到:Hello python then gogogo
【注意】:替换后得到的是一个新的字符串,并不是在原来的基础上进性修改
(3)字符串的分割
字符串.split(分隔符字符串)
按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表对象中
# split方法
test_str = "Hello python and gogogo"
new_list = test_str.split(" ")
print(f"将字符串{test_str}对空格按照split进行分割后,得到:{new_list},其类型是:{type(new_list)}")
# 结果:将字符串Hello python and gogogo对空格按照split进行分割后,得到:['Hello', 'python', 'and', 'gogogo'],其类型是:<class 'list'>
【注意】:字符串本身并没有被改变,而是得到了一个列表对象
(4)字符串的规整
a.字符串.strip()
去掉前后空格
# 字符串的规整
test_str = " Hello python and gogogo "
new_str = test_str.strip()
print(f"对字符串{test_str}进行strip()操作后,字符串内容为:{new_str}")
# 结果:对字符串 Hello python and gogogo 进行strip()操作后,字符串内容为:Hello python and gogogo
b.字符串.strip(字符串)
去掉前后指定字符串
test_str = "12Hello python and gogogo21"
new_str = test_str.strip("12")
print(f"对字符串{test_str}进行strip()操作后,字符串内容为:{new_str}")
# 结果:对字符串12Hello python and gogogo21进行strip()操作后,字符串内容为:Hello python and gogogo
【注意】:是按照单个字符移除
传入的是12,其实就是按照1和2单个字符移除。并且按照的是单个字符进行匹配移除,而不是完全按照符合12这种顺序进行删除
(5)字符串的次数统计
字符串.count(字符串)
test_str = "Hello python and gogogo"
count = test_str.count("go")
print(f"字符串{test_str}中go出现的次数为:{count}")
# 结果:字符串Hello python and gogogo中go出现的次数为:3
(6)字符串的长度
len(字符串)
test_str = "Hello python and gogogo"
print(f"字符串{test_str}的长度为:{len(test_str)}")
# 结果:字符串Hello python and gogogo的长度为:23
(7)字符串的遍历
for循环和while循环
# 字符串的遍历
# for循环遍历
test_str = "pyt"
for element in test_str:
print(element)
# 结果:
# p
# y
# t
# while循环遍历
index = 0
while index < len(test_str):
print(test_str[index])
index += 1
# 结果:
# p
# y
# t
3.字符串的特点
(1)只可以存储字符串
(2)长度任意(取决于内存大小)
(3)支持下标索引
(4)允许重复字符串存在
(5)不可以修改(增加或删除元素等)
(6)支持for循环
4.分割字符串小练习
test_str = "itheima itcast boxuegu"
# 统计it字符个数
num = test_str.count("it")
print(f"字符串{test_str}中字符的个数为:{num}")
# 结果:字符串itheima itcast boxuegu中字符的个数为:2
# 将空格替换为|
new_str = test_str.replace(" ","|")
print(f"字符串{test_str}中空格替换为|后为:{new_str}")
# 结果:字符串itheima itcast boxuegu中空格替换为|后为:itheima|itcast|boxuegu
# 按照|进行字符串的分割
new_str1 = new_str.split("|")
print(f"字符串{new_str}按照|进行分割后为:{new_str1}")
# 结果:字符串itheima|itcast|boxuegu按照|进行分割后为:['itheima', 'itcast', 'boxuegu']
五、数据容器:序列
1.定义
序列:内容连续、有序,可以使用下标索引的一类数据容器
列表、元组、字符串,均可以视为序列
2.切片
(1)定义
从一个序列中,取出一个子序列
(2)语法
序列[起始下标:结束下标:步长]
表示从序列中,从指定位置开始,依次取出元素到指定位置结束,得到一个新序列:
起始下标可以省略,省略视作从头开始
结束下标(不含)可以省略,省略视作到尾结束
步长表示,依次取元素的间隔——默认步长为1
步长N表示,每次跳过N-1个元素取
步长为负数表示,反向取(注意,起始下标和结束下标也要反向标记)
步长可以省略,省略表示步长为1:[起始下标:结束下标]
【注意】:切片操作不会影响序列本身,而是会得到一个新的序列
# 对列表list进行切片
my_list = [0,1,2,3,4,5,6]
# 下标1开始,下标4(不含)结束,步长1
new_list = my_list[1:4]
print(new_list) # 结果:[1, 2, 3]
# 对元组tuple进行切片
my_tuple = (0,1,2,3,4,5,6)
# 从头开始,到最后结束,步长1
new_tuple = my_tuple[:]
print(new_tuple) # 结果:(0, 1, 2, 3, 4, 5, 6)
# 对字符串str进行切片
my_str = "01234567"
# 从头开始,到下标4(不含)结束,步长2
new_str = my_str[::2]
print(new_str) # 结果:0246
# 对字符串str进行反向切片
my_str = "01234567"
# 从最后开始,到头结束,步长-1
new_str = my_str[::-1]
# 相当于反向取
print(new_str) # 结果:76543210
# 对列表list进行反向切片
my_list = [0,1,2,3,4,5,6]
# 下标3开始,下标1(不含)结束,步长-1
new_list = my_list[3:1:-1]
print(new_list) # 结果:[3, 2]
# 对元组tuple进行反向切片
my_tuple = (0,1,2,3,4,5,6)
# 从最后开始,到头结束,步长-2
new_tuple = my_tuple[::-2]
print(new_tuple) # 结果:(6, 4, 2, 0)
3.切片小练习
"""
切片小练习
要求输出:努力学python
"""
str1 = "上向天天,nohtyp学力努快,习学好好"
# 方法一:切片倒序取出
new_str = str1[13:4:-1]
print(new_str) # 结果:努力学python
# 另一种写法
new_str = str1[::-1][6:15]
print(new_str) # 结果:努力学python
# 方法二:split分割,replace替换快为空,逆置
new_str1 = str1.split(",")
new_str2 = new_str1[1]
new_str3 = new_str2.replace("快","")
new_str4 = new_str3[::-1]
print(new_str4) # 结果:努力学python
# 另一种写法
new_str = str1.split(",")[1].replace("快","")[::-1]
print(new_str) # 结果:努力学python
六、数据容器:set(集合)
1.列表,元组和字符串的综合分析
(1)列表:可修改,支持重复元素且有序
(2)元组、字符串不可以修改,支持重复元素且有序
2.集合的特点
(1)不支持元素重复,相当于自带去重功能
(2)内容无序
(3)不支持下标索引访问(因为集合是无序的)
(4)允许修改
(5)可以容纳多个不同类型的数据
(6)支持for循环
3.集合的语法
(1)定义字面量
{元素,元素,......,元素}
(2)定义集合变量
变量名称 = {元素,元素,......,元素}
set1 = {"好好学习","python","天天向上","好好学习","python","天天向上","好好学习","python","天天向上"}
print(f"str1的内容是:{set1},数据类型是:{type(set1)}")
# 结果:str1的内容是:{'python', '好好学习', '天天向上'},数据类型是:<class 'set'>
(3)定义空集合
变量名称 = set()
set2 = set()
print(f"str2的内容是:{set2},数据类型是:{type(set2)}")
# 结果:str2的内容是:set(),数据类型是:<class 'set'>
4.集合的常用操作
(1)添加新元素
集合.add(元素)
将指定元素添加到集合内
集合本身被修改
若添加了集合本身就有的元素,相当于没有添加
set1 = {"好好学习","python","天天向上"}
# 添加元素
set1.add("come on")
print(f"添加come on元素后,集合的内容是:{set1}")
# 结果:添加come on元素后,集合的内容是:{'天天向上', 'come on', '好好学习', 'python'}
(2)移除元素
集合.remove(元素)
将指定元素从集合内移除
集合本身被修改
set1 = {"好好学习","python","天天向上"}
# 移除元素
set1.remove("python")
print(f"移除python元素后,集合的内容是:{set1}")
# 结果:移除python元素后,集合的内容是:{'天天向上', '好好学习'}
(3)随机取出元素
集合.pop()
随机从集合中取出一个元素
返回一个元素,并且集合本身被修改
set1 = {"好好学习","python","天天向上"}
# 随机取出元素
set2 = set1.copy()
element = set2.pop()
print(f"集合{set1}随机移除元素后,集合的内容是:{set2},移除的元素是:{element}")
# 结果:集合{'天天向上', '好好学习', 'python'}随机移除元素后,集合的内容是:{'好好学习', 'python'},移除的元素是:天天向上
(4)清空集合
集合.clear()
集合本身被修改
set1 = {"好好学习","python","天天向上"}
# 清空集合
set1.clear()
print(f"集合清空后,集合的内容是:{set1}")
# 结果:集合清空后,集合的内容是:set()
(5)取出两个集合的差集
集合1.difference(集合2)
取出集合1和集合2的差集(集合1有而集合2没有的)
得到一个新的集合,原来的集合不受影响
# 取出两个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出的集合为:{set3}") # 结果:取出的集合为:{2, 3}
print(f"取出差集后,原来的set1为:{set1},set2为:{set2}")
# 结果:取出差集后,原来的set1为:{1, 2, 3},set2为:{1, 5, 6}
(6)消除两个集合的交集
集合1.difference_update(集合2)
在集合1内删除与集合2相同的元素
集合1被修改,集合2不变
# 消除两个集合的交集
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(f"消除交集后,原来的set1为:{set1},set2为:{set2}")
# 结果:消除交集后,原来的set1为:{2, 3},set2为:{1, 5, 6}
(7)两个集合合并
集合1.union(集合2)
将集合1和2合并,组成一个新的集合
得到一个新的集合,原来的集合不变
# 合并两个集合
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"两个集合合并后为:{set3}") # 结果:两个集合合并后为:{1, 2, 3, 5, 6}
print(f"原来的set2为:{set2},set1为:{set1}")
# 结果:原来的set2为:{1, 5, 6},set1为:{1, 2, 3}
(8)统计集合中元素的数量
len(集合)
计数的结果是去重之后的结果,因为集合元素不能重复
# 统计集合中元素的数量
# 因为集合内的元素不能重复,所以计数的结果是去完重之后的结果
set1 = {1,2,3,1,2,3,1,2,3}
print(f"集合内元素的数量为:{len(set1)}")
# 结果:集合内元素的数量为:3
(9)集合的遍历
因为集合无序,所以不支持下标索引,也就不能使用下标索引的while循环
但是集合支持for循环遍历
# 集合的遍历
set1 = {1,2,3}
for x in set1:
print(x)
# 结果:
# 1
# 2
# 3
5.信息去重小练习
my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']
# 定义一个空集合
set1 = set()
# 通过for循环遍历列表
for element in my_list:
# 在for循环中将列表的元素添加至集合
set1.add(element)
# 最终得到元素去重后的集合对象,并打印输出
print(f"原来列表中的内容是:{my_list}")
# 结果:原来列表中的内容是:['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']
print(f"循环赋值去重后,得到的集合内容是:{set1}")
# 结果:循环赋值去重后,得到的集合内容是:{'itheima', '传智播客', '黑马程序员', 'best', 'itcast'}
七、数据容器:dict(字典、映射)
1.定义
字典的作用:通过【key】找到对应的【value】
2.语法
(1)定义字典字面量
{key:value,key:value,......,key:value}
(2)定义字典变量
my_dict = {key:value,key:value,......,key:value}
# 定义字典
dict1 = {"张三":95,"李四":92,"玄武":98,"白虎":100}
print(f"dict1中的内容是:{dict1},其数据类型是:{type(dict1)}")
# 结果:dict1中的内容是:{'张三': 95, '李四': 92, '玄武': 98, '白虎': 100},其数据类型是:<class 'dict'>
(3)定义空字典
my_dict = {}
my_dict = dict()
# 定义空字典
dict2 = {}
dict3 = dict()
print(f"dict2中的内容是:{dict2},其数据类型是:{type(dict2)}")
# 结果:dict2中的内容是:{},其数据类型是:<class 'dict'>
print(f"dict3中的内容是:{dict3},其数据类型是:{type(dict3)}")
# 结果:dict3中的内容是:{},其数据类型是:<class 'dict'>
(4)字典内的key不允许重复
若定义了重复的key,对于相同的key,后面数据的会将前面的值覆盖掉
# 定义重复key的字典
# 对于重复的key,后面的内容会将前面的覆盖掉
dict4 = {"张三":95,"张三":92,"玄武":98,"白虎":100}
print(f"定义key重复字典的内容是:{dict4}")
# 结果:定义key重复字典的内容是:{'张三': 92, '玄武': 98, '白虎': 100}
(5)不可以使用下标索引
(6)可以通过key值来取得对应的value
字典[key值]
# 从字典中基于key获取value
dict1 = {"张三":95,"李四":92,"玄武":98,"白虎":100}
score1 = dict1["张三"]
print(f"张三的分数是:{score1}")
# 结果:张三的分数是:95
score2 = dict1["白虎"]
print(f"白虎的分数是:{score2}")
# 结果:白虎的分数是:100
(7)字典支持嵌套
字典的key和value可以是任意数据类型,但是key不可为字典
# 定义嵌套字典
dict1 = {
"张三":{
"语文":105,
"数学":110,
"英语":90
},"李四":{
"语文":100,
"数学":120,
"英语":93
}
}
print(dict1)
# 结果:{'张三': {'语文': 105, '数学': 110, '英语': 90}, '李四': {'语文': 100, '数学': 120, '英语': 93}}
# 从嵌套字典中获取数据
# 查看李四的数学信息
score = dict1["李四"]["数学"]
print(f"李四的数学成绩是:{score}")
# 结果:李四的数学成绩是:120
小技巧:对于像字典和列表这样的元素定义,可以在里面使用回车,使得看上去更直观。(字典和列表等的元素分割靠的是逗号)
3.字典的常用操作
![](https://i-blog.csdnimg.cn/blog_migrate/f9a7479330d32ee9619121628448050d.png)
(1)新增元素(新增的key在原来的字典中不存在)
字典[key] = value
字典被修改,增加新的元素
dict1 = {"张三":95,"李四":92,"玄武":98}
# 新增元素
dict1["白虎"] = 60
print(dict1) # 结果:{'张三': 95, '李四': 92, '玄武': 98, '白虎': 60}
(2)更新元素(新增的key在原来的字典中存在)
字典[key] = Value
字典被修改,元素被更新
dict1 = {"张三":95,"李四":92,"玄武":98}
# 更新元素
dict1["玄武"] = 100
print(dict1) # 结果:{'张三': 95, '李四': 92, '玄武': 100}
(3)删除元素
字典.pop(key)
获取指定key的value,同时删除字典里面对应的key的数据
dict1 = {"张三":95,"李四":92,"玄武":98}
# 删除元素
score = dict1.pop("李四")
print(f"删除李四的数据后,字典值为:{dict1},删除的内容为:{score}")
# 结果:删除李四的数据后,字典值为:{'张三': 95, '玄武': 98},删除的内容为:92
(4)清空字典
字典.clear()
字典被修改,元素被清空
dict1 = {"张三":95,"李四":92,"玄武":98}
# 清空元素
dict1.clear()
print(dict1) # 结果:{}
(5)获取全部的key
字典.keys()
可以用于字典的遍历(for循环)
# 获取全部的key
dict1 = {"张三":95,"李四":92,"玄武":98}
keys = dict1.keys()
print(keys) # 结果:dict_keys(['张三', '李四', '玄武'])
(6)字典的遍历
for循环
因为字典不支持下标索引,也就不能使用下标索引的while循环
dict1 = {"张三":95,"李四":92,"玄武":98}
# 遍历字典
# 方法一:通过获取全部的key来进行遍历
for key in keys:
print(f"{key}的成绩是:{dict1[key]}")
# 结果:
# 张三的成绩是:95
# 李四的成绩是:92
# 玄武的成绩是:98
# 方法二:直接对字典进行for遍历
for key in dict1:
print(f"{key}的成绩是:{dict1[key]}")
# 结果:
# 张三的成绩是:95
# 李四的成绩是:92
# 玄武的成绩是:98
(7)统计字典的元素个数
# 统计字典中的元素个数
dict1 = {"张三":95,"李四":92,"玄武":98}
len = len(dict1)
print(len) # 结果:3
4.字典的特点
(1)可以容纳多个不同类型的数据
(2)每一份数据的key值与value值都是对应的
(3)可以通过Key获取到Value,Key不可重复(重复会覆盖)
(4)不支持下标索引
(5)可以修改(增加或删除更新元素等)
(6)支持for循环,不支持下标索引的while循环
5.升职加薪小练习
dict1 = {
"张三":{
"部门":"科技部",
"工资":3000,
"级别":1
},"李四":{
"部门":"市场部",
"工资":5000,
"级别":2
},"玄武":{
"部门":"市场部",
"工资":7000,
"级别":3
},"青龙":{
"部门":"科技部",
"工资":4000,
"级别":1
},"白虎":{
"部门":"市场部",
"工资":6000,
"级别":1
}
}
print(f"升职加薪前,员工的信息如下:{dict1}")
# 结果:升职加薪前,员工的信息如下:{'张三': {'部门': '科技部', '工资': 3000, '级别': 1}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '玄武': {'部门': '市场部', '工资': 7000, '级别': 3}, '青龙': {'部门': '科技部', '工资': 4000, '级别': 1}, '白虎': {'部门': '市场部', '工资': 6000, '级别': 1}}
# for key in dict1:
# if dict1[key]["级别"] == 1:
# dict1[key]["级别"] += 1
# dict1[key]["工资"] += 1000
# 这样写更好,修改过程中不会直接更改原来字典的内容,以后的操作变更更方便
for key in dict1:
if dict1[key]["级别"] == 1:
element_dict = dict1[key]
element_dict["级别"] += 1
element_dict["工资"] += 1000
dict1[key] = element_dict
print(f"升职加薪后,员工的信息如下:{dict1}")
# 结果:升职加薪后,员工的信息如下:{'张三': {'部门': '科技部', '工资': 4000, '级别': 2}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '玄武': {'部门': '市场部', '工资': 7000, '级别': 3}, '青龙': {'部门': '科技部', '工资': 5000, '级别': 2}, '白虎': {'部门': '市场部', '工资': 7000, '级别': 2}}
八、数据容器的分类
1.是否支持下标索引
(1)支持:列表、元组、字符串——序列类型
(2)不支持:集合、字典——非序列类型
2.是否支持重复元素:
(1)支持:列表、元组、字符串——序列类型
(2)不支持:集合、字典——非序列类型
3.是否可以修改
(1)支持:列表、集合、字典
(2)不支持:元组、字符串
九、数据容器的通用操作
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {1,2,3,4,5}
my_dict = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5,}
1.遍历
(1)5类数据容器都支持for循环遍历
(2)列表、元组、字符串支持while循环,集合、字典不支持(无法下标索引while)
2.统计容器元素个数
len(容器)
# 容器的长度
print(f"列表 的长度为:{len(my_list)}")
print(f"元组 的长度为:{len(my_tuple)}")
print(f"字符串的长度为:{len(my_str)}")
print(f"集合 的长度为:{len(my_set)}")
print(f"字典 的长度为:{len(my_dict)}")
# 结果:
# 列表 的长度为:5
# 元组 的长度为:5
# 字符串的长度为:7
# 集合 的长度为:5
# 字典 的长度为:5
3.统计容器最大(小)元素
max(容器)
min(容器)
# 容器的最大元素
print(f"列表 的最大元素是:{max(my_list)}")
print(f"元组 的最大元素是:{max(my_tuple)}")
print(f"字符串的最大元素是:{max(my_str)}")
print(f"集合 的最大元素是:{max(my_set)}")
print(f"字典 的最大元素是:{max(my_dict)}")
# 结果:
# 列表 的最大元素是:5
# 元组 的最大元素是:5
# 字符串的最大元素是:g
# 集合 的最大元素是:5
# 字典 的最大元素是:key5
#
# 容器的最小元素
print(f"列表 的最小元素是:{min(my_list)}")
print(f"元组 的最小元素是:{min(my_tuple)}")
print(f"字符串的最小元素是:{min(my_str)}")
print(f"集合 的最小元素是:{min(my_set)}")
print(f"字典 的最小元素是:{min(my_dict)}")
# 结果:
# 列表 的最小元素是:1
# 元组 的最小元素是:1
# 字符串的最小元素是:a
# 集合 的最小元素是:1
# 字典 的最小元素是:key1
小技巧:shift + alt + 鼠标拖动——将选中的内容全部替换为所输入的数值
4.将指定容器转换为列表
list(容器)
字符串转列表是将字符串中每一个元素分别取出来作为列表的元素
字典转列表会将value的值都抛弃掉,只留key的值
# 容器转列表
print(f"列表转 列表的结果是:{list(my_list)}")
print(f"元组转 列表的结果是:{list(my_tuple)}")
print(f"字符串转列表的结果是:{list(my_str)}")
print(f"集合转 列表的结果是:{list(my_set)}")
print(f"字典转 列表的结果是:{list(my_dict)}")
# 结果:
# 列表转 列表的结果是:[1, 2, 3, 4, 5]
# 元组转 列表的结果是:[1, 2, 3, 4, 5]
# 字符串转列表的结果是:['a', 'b', 'c', 'd', 'e', 'f', 'g']
# 集合转 列表的结果是:[1, 2, 3, 4, 5]
# 字典转 列表的结果是:['key1', 'key2', 'key3', 'key4', 'key5']
5.将指定容器转换为元组
tuple(容器)
字符串和字典的转换同列表
# 容器转元组
print(f"列表转 元组的结果是:{tuple(my_list)}")
print(f"元组转 元组的结果是:{tuple(my_tuple)}")
print(f"字符串转元组的结果是:{tuple(my_str)}")
print(f"集合转 元组的结果是:{tuple(my_set)}")
print(f"字典转 元组的结果是:{tuple(my_dict)}")
# 结果:列表转 元组的结果是:(1, 2, 3, 4, 5)
# 元组转 元组的结果是:(1, 2, 3, 4, 5)
# 字符串转元组的结果是:('a', 'b', 'c', 'd', 'e', 'f', 'g')
# 集合转 元组的结果是:(1, 2, 3, 4, 5)
# 字典转 元组的结果是:('key1', 'key2', 'key3', 'key4', 'key5')
6.将指定容器转换为字符串
str(容器)
字典转字符串时,所有元素都会保留
# 容器转字符串
print(f"列表转 字符串的结果是:{str(my_list)}")
print(f"元组转 字符串的结果是:{str(my_tuple)}")
print(f"字符串转字符串的结果是:{str(my_str)}")
print(f"集合转 字符串的结果是:{str(my_set)}")
print(f"字典转 字符串的结果是:{str(my_dict)}")
# 结果:
# 列表转 字符串的结果是:[1, 2, 3, 4, 5]
# 元组转 字符串的结果是:(1, 2, 3, 4, 5)
# 字符串转字符串的结果是:abcdefg
# 集合转 字符串的结果是:{1, 2, 3, 4, 5}
# 字典转 字符串的结果是:{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
7.将指定容器转换为集合
set(容器)
字符串和字典的转换同列表
【注意】:对于转换成字典,有函数:dict(),但是转换要求元素是键值对。
# 容器转集合
print(f"列表转 集合的结果是:{set(my_list)}")
print(f"元组转 集合的结果是:{set(my_tuple)}")
print(f"字符串转集合的结果是:{set(my_str)}")
print(f"集合转 集合的结果是:{set(my_set)}")
print(f"字典转 集合的结果是:{set(my_dict)}")
# 结果:
# 列表转 集合的结果是:{1, 2, 3, 4, 5}
# 元组转 集合的结果是:{1, 2, 3, 4, 5}
# 字符串转集合的结果是:{'a', 'e', 'c', 'f', 'd', 'b', 'g'}
# 集合转 集合的结果是:{1, 2, 3, 4, 5}
# 字典转 集合的结果是:{'key5', 'key3', 'key4', 'key1', 'key2'}
8.排序
sorted(容器,[reverse = True])
reverse默认等于False:从小到大
reverse = True:从大到小
# 容器的排序
my_list = [2,3,5,1,4]
my_tuple = (2,3,5,1,4)
my_str = "acbgedf"
my_set = {2,3,5,1,4}
my_dict = {"key3":3,"key4":4,"key1":1,"key2":2,"key5":5,}
print(f"列表 对象排序的结果是:{sorted(my_list)}")
print(f"元组 对象排序的结果是:{sorted(my_tuple)}")
print(f"字符串对象排序的结果是:{sorted(my_str)}")
print(f"集合 对象排序的结果是:{sorted(my_set)}")
print(f"字典 对象排序的结果是:{sorted(my_dict)}")
# 结果:
# 列表 对象排序的结果是:[1, 2, 3, 4, 5]
# 元组 对象排序的结果是:[1, 2, 3, 4, 5]
# 字符串对象排序的结果是:['a', 'b', 'c', 'd', 'e', 'f', 'g']
# 集合 对象排序的结果是:[1, 2, 3, 4, 5]
# 字典 对象排序的结果是:['key1', 'key2', 'key3', 'key4', 'key5']
print(f"列表 对象反向排序的结果是:{sorted(my_list,reverse=True)}")
print(f"元组 对象反向排序的结果是:{sorted(my_tuple,reverse=True)}")
print(f"字符串对象反向排序的结果是:{sorted(my_str,reverse=True)}")
print(f"集合 对象反向排序的结果是:{sorted(my_set,reverse=True)}")
print(f"字典 对象反向排序的结果是:{sorted(my_dict,reverse=True)}")
# 结果:
# 列表 对象反向排序的结果是:[5, 4, 3, 2, 1]
# 元组 对象反向排序的结果是:[5, 4, 3, 2, 1]
# 字符串对象反向排序的结果是:['g', 'f', 'e', 'd', 'c', 'b', 'a']
# 集合 对象反向排序的结果是:[5, 4, 3, 2, 1]
# 字典 对象反向排序的结果是:['key5', 'key4', 'key3', 'key2', 'key1']
【注意】:排序的结果通通会变成列表对象
字典的排序会丢失value值
十、字符串大小的比较
1.基本知识点
(1)在程序中,字符串所用的所有字符,比如:大小写英文、数字和特殊符号(!、\、|、@、#和空格)等,都有对应的SACII码表值
(2)每个字符对应一个数字码值
(3)字符串的比较基于数字的码值大小进行比较
2.字符串的比较
从头到尾,一位一位的按位进行比较,只要其中一位大,整体就大,比较结束
# abc与abd比较
print("abc"<"abd") # 结果是:True
# a与ab比较
print("a"<"ab") # 结果是:True
# a与A比较
print("a"<"A") # 结果是:False
# key1与key2比较
print("key1"<"key2") # 结果是:True