- 数据容器入门
- 数据容器:list(列表)
- list(列表)的遍历
- 数据容器:tuple(元组)
- 数据容器:str(字符串)
- 数据容器的切片
- 数据容器:set(集合)
- 数据容器:dict(字典、映射)
- 数据容器的通用操作
- 综合案例
1 数据容器入门
了解数据容器是什么:一种可以存储多个元素的Python数据类型
list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)它们各有特点，但都满足可容纳多个元素的特性，
2数据容器:list(列表)
列表的定义
掌握列表的定义格式:以[]作为标识;列表内每一个元素之间用，逗号隔开
【】内的都是元素，元素没有数据类型之分，都可一起
"""
演示list
"""
my_list=['lkx','kx','xp']
print(my_list)
print(type(my_list))
#列表可以存储不同类型的元素
my_list2=["lkx",666,True]
print(my_list2)
print(type(my_list2))
#嵌套列表
my_list3=[[1,2,3],[4,5,6]]
print(my_list3)
print(type(my_list3))
#通过下标索引取出对应位置的数据
列表的下标索引列表的常用操作
掌握使用列表的下标索引从列表中取出元素：列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增我们只需要按照下标索引，即可取得对应位置的元素。或者，可以反向索引，也就是从后向前:从-1开始，依次递减(-1、-2、-3....）
#通过下标索引取出对应位置的数据
my_list4=["kx","lk","lx"]
#列表【写下小标索引，从前向后cong0开始】
print(my_list4[0])
print(my_list4[1])
print(my_list4[2])
#错误示范：不要超过定义的列表元素
# print(my_list4[3])
#列表【写下小标索引，从后向前cong-1开始】
print(my_list4[-1])
print(my_list4[-2])
print(my_list4[-3])
#取出嵌套列表
my_list5=[[1,2,3],[4,5,6]]
print(my_list5[1][2])列表的常用操作：掌握列表的常用操作(方法)和特点
列表除了可以:
·定义
使用下标索引获取值以外，列表也提供了一系列功能:
插入元素：语法:列表.inser(下标,元素)，在指定的下标位置，插入指定的元素；
语法:列表.append(元素)，将指定元素，追加到列表的尾部；
追加一批元素 到尾部：列表距xtend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部
删除元素：语法1: del 列表[下标]
语法2:列表.pop(下标)
清空列表;语法:列表.clear()
修改元素：语法:”列表.remove(元素)，从左到右删除一次
统计元素个数：语法:列表.count(元素)：语法:len(列表)元素总共有几个
等等功能，这些功能我们都称之为:列表的方法
my_list=["lkx","kx","lx"]
#1.1查找某元素在列表内的下标索引
index=my_list.index("kx")
print(f"kx在列表的下标索引的值是：{index}")
#1.2如果被查找的元素不存在，会报错ValueError:
# index=my_list.index("hello")
# print(f"hello在列表的下标索引的值是：{index}")
#2.修改特定下标索引的值
my_list[0]="lkt"
print(f"修改的值后的list:{my_list}")
#3:在指定下标位置插入新元素
my_list.insert(1,"niu")
print(f"插入后list的值：{my_list}")
#4、在列表的尾部追加、、单个八、新元素
my_list.append("666")
print(f"追加后的list的值：{my_list}")
#5.在列表的尾部追加`、一批`、新元素
my_list=[1,2,3]
my_list.extend([4,5,6])
print(f"追加一批list的值{my_list}")
#6.删除指定下标索引的元素(2种方式)
my_list=["lkx","kx","lx"]
#6.1 方式1:del 列表[下标]
del my_list[1]
print(f"语法1删除元素后的list:{my_list}")
#6.2方式2:列表.pop(下标)
my_list=["lkx","kx","lx"]
element=my_list.pop(2)
print(f"通过pop的方法移除的list{my_list},取出的元素是{element}")
#7.删除某元素在列表中的第一个匹配项
my_list=["lkx","kx","lx","kx","lx"]
my_list.remove("kx")
my_list.remove("kx")
print(f"语法1删除元素后的list:{my_list}")
#8.清空列表
my_list.clear()
print(f"全部清空后的list{my_list}")
#9.统计列表内某元素的数量
my_list=["lkx","kx","lx","kx","lx"]
count=my_list.count("lx")
print(f"列表在lx的数量是{count}")
#10.统计列表中全部的元素数量
my_list=["lkx","kx","lx","kx","lx"]
count=len(my_list)
print(f"列表的数量总共有{count}ge ")
什么是方法：在Python中，如果将函数定义为class(类)的成员，那么函数会称之为:方法
3list(列表)的遍历
什么是遍历;将容器内的元素依冷取出，并处理，称之为遍历操作
1.掌握使用while循环，遍历列表的元素
定义一个变量表示下标，从0开始循环条件为 下标值<列表的元素数量
2.掌握使用for循环，遍历列表的元素;
表示，从容器内，依次取出元素并赋值到临时变量上。在每一次的循环中，我们可以对临时变量(元素)进行处理
while循环和for循环，都是循环语句，但细节不同:在循环控制上:
while循环可以自定循环条件并自行控制
for循环不奇以自定循环条件，只可以一个个从容器内取出数据在无限循环上:
while循环可以通过条件控制做到无限循环
for循环理论上不可以，因为被遍历的容器容量不是无限的在使用场景上:
while循环适用于任何想要循环的场景
for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
"""
演示while遍历列表
"""
def lkx_list():
"""
使用while循环遍历列表的演示函数:return: None
:return:
"""
my_list=["kx","lkx","lx"]
#循环控制变量下标索引默认0
#每次索引下标+1
#循环条件，下标值《列表元素数量
#首先定义一个变量
index=0
while index<len(my_list):
#通过index变量取出对应下标的值
element=my_list[index]
print(f"列表元素：{element}")
index+=1
lkx_list()
def for_kx():
"""
使用for循环遍历列表的演示函数:return: None
:return:
"""
my_list2=["kx","lkx","lx"]
for element in my_list2:
print(f"列表元素：{element}")
for_kx()
"""
定义一个列表，内容是:[1,2,3,4,5,6,7,8,9,10]遍历列表，取出列表内的偶数，并存入一个新的列表对象中使用while循环和for循环各操作一次
"""
#while测试
def while_fun_():
my_list=[1,2,3,4,5,6,7,8,9,10]
index=0
list1=[]
while index<len(my_list):
element=my_list[index]
if element%2==0:
list1.append(element)
index+=1
print(f"通过while循环，从列表：{my_list}中取出偶数，组成新列表：",list1)
while_fun_()
#for测试
def for_fun_():
my_list1=[1,2,3,4,5,6,7,8,9,10]
list2=[]
for element in my_list1:
if element%2==0:
list2.append(element)
print(f"通过for循环，从列表：{my_list1}中取出偶数，组成新列表：", list2)
for_fun_()
4数据容器:tuple(元组)
- 掌握元组的定义格式
同类型的元素在内。元组同列表一样，都是可以封装但最大的不同点在于:
元组一旦定义完成，就不可修改(等同于不可更改的list)
元组定义:定义元组使用小括号，
且使用逗号隔开各个数据，数据可以是不同的数据类型。
注意:元组只有一个数据，这个数据后面要添加逗号
不可修改内容(可以修改内部list的内部元素)
- 掌握元组的特点
- 掌握元组的常见操作
"""
演示tuple元组的定义和操作
"""
#定义元组
t=(1,"kx",True)
t1=()
t2=tuple()
print(f"t的类型是{type(t)},内容是{t}")
print(f"t1的类型是{type(t1)},内容是{t1}")
print(f"t2的类型是{type(t2)},内容是{t2}")
#定义单个元素的元素
t4=("hello")
print(f"t4的类型是{type(t4)},内容是{t4}")
t4=("hello",)
print(f"t4的类型是{type(t4)},内容是{t4}")
# 元组的嵌套
t5=((1,2,3),(4,5,6))
print(f"t5的类型是{type(t5)},内容是{t5}")
num=t5[1][2]
print(f"t5取出的元组是{num}")
#元组的操作:index查找方法
t6=("kx","aa","ss")
index=t6.index("aa")
print(f"t6的下标{index}")
#元组的操作:count统计方法
t7=("kx","aa","ss","aa","ss","aa","ss")
num=t7.count("ss")
print(f"t7 {num}个ss")
#元组的操作:len函数统计元组元素数量
t8=("kx","aa","ss","aa","ss","aa","ss")
num1=len(t8)
print(f"t8 {num}个元素")
#元组的遍历:wHile
index=0
while index<len(t8):
print(f"元组的元素有{t8[index]}")
index+=1
#元组的遍历:for
for element in t8:
print(f"2元组的元素有{element}")
"""
定义一个元组，内容是:龄、爱好)
['football','music"])，记录的是一个学生的信息(姓名、年('周杰轮'，11,
请通过元组的功能(方法)，对其进行
查询其年龄所在的下标位置1.
2.查询学生的姓名
删除学生爱好中的football
增加爱好:coding到爱好list内4
"""
my_list=["football",'music']
test=('周杰伦',11,[my_list])
index=test.index(11)
print(f"test_age的下标{index}")
name=test[0]
print(f"test_name{name}")
player=my_list.pop(0)
print(f"显示现在的test{test}")
my_list.insert(1,"baskball")
print(f"显示现在的test{test}")
5数据容器:str(字符串)
掌握字符串的常见操作
和其它容器如:列表、元组一样，字符串也可以通过下标进行访问
从前向后，下标从0开始
从后向前，下标从-1开始
同元组一样，字符串是一个:无法修改的数据容器，所以:
修改指定下标的字符(如:字符串[0]=“a”
移除特定下标的字符如:del字符串[0]、字符串.remove()、字符串.pop()等)
追加字符等((如:字符串.append())
字符串的替换
语法:字符串.replace(字符串1，字符串2)功能:将字符串内的全部:字符串1，替换为字符串2注意:不是修改字符串本身，而是得到了一个新字符串哦
字符串的分割
语法:字符串.split(分隔符字符串)
功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中注意:9字符串本身不变，而是得到了一个列表对象
字符串的规整操作(法前后空格
语法:字符串.strip()
作为数据容器，字符串有如下特点:只可以存储字符串
长度任意(取决于内存大小)
支持下标索引
允许重复字符串存在不可以修改(增加或删除元素等)
支持for循环
"""
给定一个字符串:"itheimaitcast boxuegu统计字符串内有多少个"it"字符
将字符串内的空格，全部替换为字符:""并按照""进行字符串分割，得到列表
"""
my_str="itheimaitcast boxuegu"
newmy_str=my_str.count('it')
print(f"{my_str}中与{newmy_str}个it")
new_my_str=my_str.replace(" ","|")
print(f"{my_str}中与{new_my_str}")
my_str_list=new_my_str.split("|")
print(f"{my_str_list}")
6数据容器的切片
1.了解什么是序列
序列是指:内容连续、有序，可使用下标索引的一类数据容器列表、元组、字符串，均可以可以视为序列。
2.掌握序列的切片操作
序列支持切片，即:列表、元组、字符串，均支持进行切片操作切片:从一个序列中，取出一个子序列
语法:序列[起始下标:结束下标:步长]表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列:
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标(不含)表示何处结束可以留空，留空视作截取到结尾步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)
"""
演示序列
"""
#对list进行切片，从1开始，4结束，步长1
my_list=[0,1,2,3,4,5,6]
new_list=my_list[1:4:1]
print(f"list的切片新序列{new_list}")
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple=(0,1,2,3,4,5,6)
nee_tuple=my_tuple[ : ]
print(f"tuple的切片新序列{nee_tuple}")
# 对str进行切片，从头开始，到最后结束，步长2
my_str="01234567"
new_str=my_str[ : :2]
print(f"str的切片新序列{new_str}")
#对str进行切片，从头开始，到最后结束，步长-1
my_str1="01234567"
new_str2=my_str1[ : :-1]
print(f"str的切片新序列{new_str2}")
#对列表进行切片，从3开始，到1结束，步长-1
my_list1=[0,1,2,3,4,5,6]
new_list1=my_list1[3:1:-1]
print(f"list的切片新序列{new_list1}")
#对元组进行切片，从头开始，到尾结束，步长-2
my_tuple1=(0,1,2,3,4,5,6)
nee_tuple1=my_tuple1[ : :-2]
print(f"tuple的切片新序列{nee_tuple1}")
"""
有字符串:"万过薪月，员序程马黑来，nohtyP学请使用学过的任何方式，得到"黑马程序员
可用方式参考:
倒序字符串，切片取出或切片取出，然后倒序split分隔"，"replace替换"来"为空，倒序字符串
"""
my_str="万过薪月,员序程马黑来,nohtyP学"
new_str=my_str[ : :-1][9:14]
print(f"倒序过来的str:{new_str}")
new_str1=my_str.split(",")[1].replace("来","")[: :-1]
print(f"取出:{new_str1}")
7数据容器:set(集合)
1.掌握集合的定义格式
2.掌握集合的特点
首先，因为集合是无序的，所以集合不支持:下标索引访问但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。
3.掌握集合的常见操作
添加新元素
语法:集合.add(元素)。将指定元素，添加到集合内结果:集合本身被修改，添加了新元素
移除元素
语法:集合.remove(元素)，将指定元素，从集合内移除结果:集合本身被修改，移除了元素
从集合中随机取出元素
语法:集合.pop(，功能，从集合中随机取出一个元素结果:会得到一个元素的结果。同时集合本身被修改，元素被移除
取出2个集合的差集
语法:集合1.difference(集合2)，功能:取出集合1和集合2的差集(集合1有而集合2没有的)结果:得到一个新集合，集合1和集合2不变
消除2个集合的差集
语法:集合1.difference_update(集合2)
功能:对比集合1和集合2，在集合1内，删除和集合2相同的元素，
结果:集合1被修改，集合2不变
2个集合合并
语法:集合1.union(集合2)
功能:将集合1和集合2组合成新集合结果:得到新集合，集合1和集合2不变'
"""
集合的演示
"""
#定义集合
my_set={"lkx","kx","lx","lkx","kx","lx","lkx","kx","lx","lkx","kx","lx"}
my_set_empty=set()
print(f"my_set的内容：{my_set},类型是{type(my_set)}")
print(f"my_set_empty的内容：{my_set_empty},类型是{type(my_set_empty)}")
# 添加新元素
my_set.add("lkxx")
my_set.add("罗凯旋")
my_set.add("lkxx")#会被去重
print(f"my_set的内容：{my_set}")
#移除元素
my_set.remove("kx")
print(f"remove后的{my_set}")
# 随机取出一个元素
my_set={"lkx","kx","lx"}
element=my_set.pop()
print(f"随机取出{element},后面的集合{my_set}")
# 清空集合
my_set.clear()
print(f"集合被清空后{my_set}")
#取2个集合的差集
set1={1,2,3,4}
set2={1,5,6,3,4}
set3=set1.difference(set2)
print(f"set3后差集的集合{set3}")
print(f"set1后差集的集合{set1}")
print(f"set2后差集的集合{set2}")
#消除2个集合的差集
set1={1,2,3,4}
set2={1,5,6,3,4}
set1.difference_update(set2)
print(f"set1后消除差集的集合{set1}")
print(f"set2后消除差集的集合{set2}")
#2个集合合并为1个
set1={1,2,3,4}
set2={1,5,6,3,4}
set3=set1.union(set2)
print(f"set3后差集的集合{set3}")
print(f"set1后差集的集合{set1}")
print(f"set2后差集的集合{set2}")
#统计集合元素数量
set6={1,2,3,4,5}
num=len(set6)
print(f"集合内的元素有{num}")
经过上述对集合的学习，可以总结出集合有如下特点:
可以容纳多个数据
可以容纳不同类型的数据(混装)
数据是无序存储的(不支持下标索引)
不允许重复数据存在
可以修改(增加或删除元素等)支持for循环
"""
集合的演示
"""
#定义集合
my_set={"lkx","kx","lx","lkx","kx","lx","lkx","kx","lx","lkx","kx","lx"}
my_set_empty=set()
print(f"my_set的内容：{my_set},类型是{type(my_set)}")
print(f"my_set_empty的内容：{my_set_empty},类型是{type(my_set_empty)}")
# 添加新元素
my_set.add("lkxx")
my_set.add("罗凯旋")
my_set.add("lkxx")#会被去重
print(f"my_set的内容：{my_set}")
#移除元素
my_set.remove("kx")
print(f"remove后的{my_set}")
# 随机取出一个元素
my_set={"lkx","kx","lx"}
element=my_set.pop()
print(f"随机取出{element},后面的集合{my_set}")
# 清空集合
my_set.clear()
print(f"集合被清空后{my_set}")
#取2个集合的差集
set1={1,2,3,4}
set2={1,5,6,3,4}
set3=set1.difference(set2)
print(f"set3后差集的集合{set3}")
print(f"set1后差集的集合{set1}")
print(f"set2后差集的集合{set2}")
#消除2个集合的差集
set1={1,2,3,4}
set2={1,5,6,3,4}
set1.difference_update(set2)
print(f"set1后消除差集的集合{set1}")
print(f"set2后消除差集的集合{set2}")
#2个集合合并为1个
set1={1,2,3,4}
set2={1,5,6,3,4}
set3=set1.union(set2)
print(f"set3后差集的集合{set3}")
print(f"set1后差集的集合{set1}")
print(f"set2后差集的集合{set2}")
#统计集合元素数量
set6={1,2,3,4,5}
num=len(set6)
print(f"集合内的元素有{num}")
# 集合的遍历
set6={1,2,3,4,5}
for element in set6:
print(f"集合的元素有{element}")
8数据容器:dict(字典、映射)
字典的定义
字典的定义:同样使用{}不过存储的元素是一个个的:键值对，如下语法:
"""
演示字典
"""
#定义字典
my_dict={"lkx":666,"kx":111,"lx":555}
#定义空字典
my_dict1={}
my_dict2=dict()
print(f"字典1的内容是：{my_dict},类型是{type(my_dict)}")
print(f"字典2的内容是：{my_dict1},类型是{type(my_dict1)}")
print(f"字典3的内容是：{my_dict2},类型是{type(my_dict2)}")
#从字典中基于Key获取Value
sorce=my_dict["lkx"]
print(f"lkx的分数是{sorce}")
sorce1=my_dict["kx"]
print(f"kx的分数是{sorce1}")
#定义嵌套字典
my_dict4={"lkx":{
"语文":477,
"数学":1040,
"化学":1030
},"kx":{
"语文":727,
"数学":1020,
"化学":1020
},"lx":{
"语文":11,
"数学":120,
"化学":11100
}}
print(f"考试信息：{my_dict4}")
#从嵌套字典中获取数据
score=my_dict4["lkx"]["语文"]
print(f"{score}")
字典的常用操作
1.掌握字典的常用操作
新增元素
语法:字典[Key] =Value，结果:字典被修改，新增了元素
更新元素
语法:字典[Key]=Value，结果:字典被修改，元素被更新注意:字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
删除元素
语法:字典.pop(Key)，结果:获得指定Key的Value，同时字典被修改，指定Key的数据被删除
获取全部的key
语法:字典.keys()，结果:得到字典中的全部Key
2.掌握字典的特点
\可以容纳多个数据
类型的数据可以容纳不同目
每一份数据是KeyValue键值对
可以通过Key获取到Value，Key不可重复(重复会覆盖)
不支持下标索引
可以修改(增加或删除更新元素等)支持for循环，不支持while循环
"""
演示字典的操作
"""
my_dict={"lkx":666,"kx":111,"lx":555}
# 新增元素
my_dict["wrj"]=66
print(f"{my_dict}")
#更新元素
my_dict["lkx"]=66
print(f"{my_dict}")
#删除元素
spurce=my_dict.pop("lkx")
print(f"删除了一个元素{my_dict}，lkx的成绩是{spurce}")
#清空元素
my_dict.clear()
print(f"{my_dict}")
#获取全部的key
my_dict={"lkx":666,"kx":111,"lx":555}
keys=my_dict.keys()
print(f"全部的key{keys}")
#遍历字典
for key in keys:
print(f"key:{key}")
print(f"value:{my_dict[key]}")
#统计字典内的元素数量
num =len(my_dict)
print(f"字典的数量有{num}")"""
有如下员工信息，请使用字典完成数据的记录并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元
"""
my_dict={
"王力宏":{
"部门 ":"科技部",
"工资": 3000,
"级别":1
},
"周杰伦":{
"部门 ":"市场部",
"工资": 5000,
"级别":2
},"林俊杰":{
"部门 ": "市场部",
"工资": 7000,
"级别":3
},"张学友":{
"部门 ": "科技部",
"工资": 4000,
"级别":1
},"刘德华":{
"部门 ": "市场部",
"工资": 6000,
"级别": 2
}}
for name in my_dict:
if my_dict[name]["级别"]==1:
em_mydict=my_dict[name]
em_mydict["级别"]=2
em_mydict["工资"]+=1000
my_dict[name]=em_mydict
print(f"{my_dict}")
应用场景
9数据容器的通用操作
5类数据容器都支持for循环遍历
列表、元组、字符串支持while循环，集合、字典不支持(无法下标索引)
10综合案例
每一个字符都能对应上一个:数字的码值字符串进行比较就是基于数字的码值大小进行比较的。
扫一扫
4686
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
