python基础-第五章容器

第五章 数据容器

5.1 数据容器入门

数据容器：一种可以存储多个元素的python的数据类型

list(列表)，tuple(元组) str(字符串) set(集合) dict(字典)，各有特点，但都满足可容纳多个元素的特性。

5.2 数据容器：list(列表)

5.2.1 列表的定义

#变量名称 = [元素1，元素2，元素3......]
my_list = [True,666,"python"]  
print(my_list)  
my_list = [[1,2,3],[1,2,5]]  
print(my_list)

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

5.2.2 列表的下标索引

my_list = [1,2,3]  
#列表[下标索引]，从前向后从0开始，每次+1,从后向前从-1开始，每次-1  
print(my_list[0])  
print(my_list[-1])  
#取出嵌套列表的元素
my_list = [[1,2,3],[1,2,5]]  
print(my_list[0][1])

注意：

超出下标索引的取值范围无法取出元素，并且会报错

5.2.3 列表的常用操作----方法

5.2.3.1 查询

功能：查询指定元素在列表的下标，如果找不到，则报错ValueError

语法：列表.index(元素)

index就是列表对象(变量)内置的方法(函数)

mylist = [True,666,"python"]
index = mylist.index(666)
print(f"{index}")

5.2.3.2 修改功能—修改特定位置(位置)的元素值

功能：修改特定位置(位置)的元素值

语法：列表[下标] = 值

可以使用如下语法，直接对指定下标(正向，反向均可)的值进行：重新赋值（修改）

my_list[0] = "python"  
print(f"正向修改结果为：{my_list}")  
my_list[-3] = "rrr"  
print(f"正向修改结果为：{my_list}")  

5.2.3.3修改功能—插入

语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

mylist = [True,666,"python"]
mylist.insert(1,"item")
print(mylist)           结果：[True, 'item', 666, 'python']

5.2.3.4修改功能—追加元素（append）

语法：列表.append(元素)，将指定元素，追加到列表的尾部

mylist = [1,2,3]
mylist.append(4)
print(mylist)        结果：[1, 2, 3, 4]

mylist = [1,2,3]
mylist.append([4,5,6])
print(mylist)        结果：[1, 2, 3, [4, 5, 6]]

5.2.3.5修改功能—追加元素（extend）

语法：列表.extend（其他数据容器），将其他数据容器的内容取出，依次追加到列表尾部

mylist = [1,2,3]
mylist.extend([4,5,6])
print(mylist)        结果：[1, 2, 3, 4, 5, 6]

5.2.3.6删除元素—指定下标删除(del)

del 列表[下标]

mylist = [1,2,3]
del mylist[2]
print(mylist)     结果：[1, 2]

5.2.3.7删除元素—指定下标删除(pop)

列表.pop(下标)

mylist = [1,2,3]
element = mylist.pop(2)
print(element,mylist)   结果：3 [1, 2]

5.2.3.8删除元素—某元素在列表中的第一个匹配项(remove)

语法：列表.remove(元素)

mylist = [1,3,2,3,5,6]
mylist.remove(3)
print(mylist)   结果：[1, 2, 3, 5, 6]  

5.2.3.9删除元素—清空列表内容(clear)

语法：列表.clear( )

mylist = [1,3,2,3,5,6]
mylist.clear()
print(mylist)

5.2.3.9统计某元素在列表内的数量(count)

语法：列表.count(元素)

mylist = [1,3,2,3,5,6,3,3,3,3]
print(mylist.count(3))

5.2.3.10统计列表内有多少元素(len)

语法：len(列表)

mylist = [1,3,2,3,5,6,3,3,3,3]
print(len(mylist))

列表的特点：

1.可容纳多个元素 2.可容纳不同类型的元素（混装） 3.数据是有序存储的（下标） 4.允许重复数据存在 5.可修改(增删等)

5.3 list (列表)的遍历

mylist = [1,3,2,3,5,6,3,3,3,3]
#while循环可自定循环条件，自行控制，可通过条件控制做到无限循环，适用任何场景
def fun():

    index = 0
    while index < len(mylist):
        element = mylist[index]
        print(f"列表元素为：{element}")
        index = index + 1
fun()
#for循环不可自定循环条件，只能从容器内取数据，不可无限循环，适用遍历数据容器和固定次数的循环场景
def fun1():

    index = 0
    for element in mylist:
        print(f"列表元素为：{element}")

fun1()

5.4 数据容器：tuple(元组)

5.4.1定义格式与特点

元组同列表一样，都是可以封装多个，不同类型的元素在内，但最大的不同点在于：元组一旦完成，就不可修改

变量名称 = （元素，元素，元素）

5.4.2特点

可容纳多个元素，可容纳不同类型的数据（混装），数据是有序存储的（下标），允许重复数据，不可修改（增删，内部含列表list可改），支持for循环

5.5 数据容器：str(字符串)

只可存储字符串，长度任意，支持下标索引，允许重复字符串存在，不可修改（增删），支持for循环

5.5.1 下标索引取值

mystr = "i am a boy"
# 通过下标索引取值
value1 = mystr[2]
print(f"{value1}")

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

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

mystr = "i am a boy"
print(mystr.index("boy"))

5.5.3 字符串替换

字符串不可修改

语法：字符串.replace(字符串1，字符串2)

功能：将字符串内部的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新字符串

mystr = "i am a boy"
mystr2 = mystr.replace("am","ammmmmm")
print(mystr2)

5.5.4 字符串的分割

语法:字符串.split(分隔符字符串)

功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意:字符串本身不变，而是得到了一个列表对象

mystr = "i am a boy"
mystr3 = mystr.split(" ")
print(mystr3)

5.5.5 字符串的规整操作(去前后空格)

语法:字符串.strip()

my_str =" itheima and itcast "
print(my_str.strip())
#结果:itheima and itcast

5.5.6 字符串的规整操作(去前后指定字符串)

语法:字符串.strip(字符串)

my_str ="12itheima and itcast21"
print(my_str.strip("12"))
#结果:itheima and itca
# 注意，传入的是“12”其实就是:”1”和”2”都会移除，是按照单个字符。

5.5.7 统计字符串在某字符串的出现次数

my_str ="itheima and itcast"
count = my_str.count("it")
print(f"{count}")

5.5.8 统计字符串的长度

my_str ="itheima and itcast"
num = len(my_str)
print(f"{num}")

5.6 数据容器的切片

5.6.1 序列

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

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

5.6.2 序列的常用操作-切片

序列支持切片，即:列表、元组、字符串，均支持进行切片操作

切片:从一个序列中，取出一个子序列
语法:序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列:

1.起始下标表示从何处开始，可以留空，留空视作从头开始
2.结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾

3.步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)

此操作不会影响序列本身，而是会得到一个新序列

#对list进行切片，从1开始，4结束，步长1
my_list=[0,1,2,3,4,5,6]
#步长默认是1，所以可以省略不写
result1 = my_list[1:4]
print(f"结果1:{result1}")    结果1:[1, 2, 3]

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple=(0,1,2,3,4,5,6)
result2 = my_tuple[:]
#起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2:{result2}")    结果2:(0, 1, 2, 3, 4, 5, 6)

#对str进行切片，从头开始，到最后结束，步长2
my_str ="01234567"
result3 = my_str[::2]
print(f"结果3:{result3}")      结果3:0246

# 对str进行切片，从头开始，到最后结束，步长-1
my_str ="01234567"
result4 = my_str[::-1]    # 等同于将序列反转了
print(f"结果4:{result4}")      结果4:76543210

5.7 数据容器：set(集合)

5.7.1集合定义

特点：可容纳多个数据，不同类型的数据（混装），数据是无序存储的（不支持下标索引），不允许重复数据存在，可修改，支持for循环

变量名称 = {元素,元素,元素}

myset =  {"黑马","黑马","你","研","究","生",}
print(myset)

5.7.2 集合的常用操作—修改

集合无序，故集合不支持：下标索引访问

5.7.2.1添加新元素

语法:集合.add(元素)

将指定元素，添加到集合内结果:集合本身被修改，添加了新元素

my_set ={"He11o","Wor1d"}
my_set.add("itheima")
print(my_set)          结果{'He11o'，'itheima','World'}

5.7.2.2移除元素

语法:集合.remove(元素)

将指定元素，从集合内移除结果:集合本身被修改，移除了元素

my_set ={"He11o","Wor1d"}
my_set.remove("He11o")
print(my_set)       结果{'Wor1d'}

5.7.2.3从集合中随机取出元素

语法:集合.pop()，功能，从集合中随机取出一个元素

结果:会得到一个元素的结果。同时集合本身被修改，元素被移除

my_set = {"He11o","world","itheima"}
element =my_set.pop()
print(my_set)
print(element) 结果 {'world'，'itheima'}    结果He11o

5.7.2.4清空集合

语法:集合.clear()，功能，清空集合

结果:集合本身被清空

my_set = {"He11o","world","itheima"}
my_set.clear()
print(my_set)     结果：set()

5.7.2.5 取出2个集合的差集

语法:集合1.difference(集合2)

功能:取出集合1和集合2的差集(集合1有而集合2没有的)

结果:得到一个新集合，集合1和集合2不变

set1={1,2,3}
set2={1,5,6}
set3 = set1.difference(set2)
print(set3)   # 结果:{2，3}    得到的新集合
print(set1)   #结果:{1，2，3}  不变
print(set2)   # 结果:{1，5，6}  不变

5.7.2.6 消除2个集合的差集

语法:集合1.difference_update(集合2)

功能:对比集合1和集合2，在集合1内，删除和集合2相同的元素

结果:集合1被修改，集合2不变

set1={1,2,3}
set2={1,5,6}
set1.difference_update(set2)
print(set1)  # 结果:{2，3}
print(set2)  # 结果:{1，5，6}

5.7.2.7 2个集合合并为1个

语法:集合1.union(集合2)功能:将集合1和集合2组合成新集合

结果:得到新集合，集合1和集合2不变

set1={1,2,3}
set2={1,5,6}
set3 = set1.union(set2)
print(set3)   # 结来:{1,2,3,5,6}
print(set1)   #结果:{1，2，3}，set1不变
print(set2)   # 结果:{1，5，6}，set2不变

5.7.2.8 统计集合元素数量

set1={1,2,3}
num = len(set1)
print(num)

5.7.2.9 集合的遍历

set1={1,2,3,6,5,8}
for element in set1:
    print(element)

5.8 数据容器：dict(字典、映射)

可容纳多个数据，不同类型的数据，每一份数据是keyValue键值对，可通过Key获取到Value，Key不可重复（重复会覆盖），不支持下标索引，可修改，只支持for循环

5.8.1 字典定义

变量名称 = {key:value,key:value,key:value}

mydict = {"Li":33,"Wang":88,"Huang":70}

5.8.2 字典数据的获取

字典同集合一样，不可以使用下标索引但是字典可以通过Key值来取得对应的Value

键值对的Key和Value可以是任意类型(Key不可为字典)

语法，字典[Key]可以取到对应的Value

stu_score ={"王力鸿":99,"周杰轮":88,"林俊节":77}  
print(stu_score["王力鸿"])  #结果99  
print(stu_score["周杰轮"])  #结果88  
print(stu_score["林俊节"])  #结果77

5.8.2 定义嵌套字典

stu_score ={
    "王力鸿":{
        "语文":77,
        "数学":88,
        "英语":99
    }, "周杰轮":{
        "语文":76,
        "数学":85,
        "英语":69
    }, "林俊节":{
        "语文":87,
        "数学":68,
        "英语":69
    }
}
print(stu_score)
score = stu_score["王力鸿"]["英语"]
print(score)
# {'王力鸿': {'语文': 77, '数学': 88, '英语': 99}, '周杰轮': {'语文': 76, '数学': 85, '英语': 69}, '林俊节': {'语文': 87, '数学': 68, '英语': 69}}
# 99语"]

5.8.3字典的常用操作

5.8.3.1 新增元素

语法:字典[Key] = Value

结果:字典被修改，新增了元素

stu_score ={
    "王力鸿":77,
    "周杰轮":88,
    "林俊节": 99
}
 # 新增:张学油的考试成绩
stu_score['张学油']=66
print(stu_score)    #结果:{'王力鸿': 77，'周杰轮’:88，"林俊节’:99，"张学油':66}

5.8.3.2 更新元素

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

stu_score ={
    "王力鸿":77,
    "周杰轮":88,
    "林俊节": 99
}
stu_score['王力鸿']=66
print(stu_score)   #结果:{'王力鸿': 66，'周杰轮’:88，"林俊节’:99}

5.8.3.3 删除元素

语法:字典:pop(Key)

结果:获得指定Key的Value，同时字典被修改，指定Key的数据被删除

stu_score ={
    "王力鸿":77,
    "周杰轮":88,
    "林俊节": 99
}
value = stu_score.pop("王力鸿")
print(value)
print(stu_score)   
#77
#{'周杰轮': 88, '林俊节': 99}

5.8.3.4 清空字典

语法：字典.clear( )

结果：字典被修改，元素被清空

stu_score ={
    "王力鸿":77,
    "周杰轮":88,
    "林俊节": 99
}
stu_score.clear() 
print(stu_score)   #结果{}

5.8.3.5 获取全部的Key

语法：字典.keys()

结果：得到字典中的全部key

stu_score ={
    "王力鸿":77,
    "周杰轮":88,
    "林俊节": 99
}
keys = stu_score.keys()
print(keys)    #结果：dict_keys(['王力鸿', '周杰轮', '林俊节'])

5.8.3.6 遍历字典

#1.通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{stu_score[key]}")
#2.直接对字典进行for循环，每一次循环都是直接得到key
for key in stu_score:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{stu_score[key]}")

5.8.3.7 统计字典内的元素数量

num = len(stu_score)  
print(num)

5.9数据容器

5.9.1数据容器简单的分类:

是否支持下标索引支持:

        列表、元组、字符串-序列类型

        不支持:集合、字典-非序列类型

是否支持重复元素支持:

        列表、元组、字符串-序列类型

        不支持:集合、字典-非序列类型

是否可以修改：
支持:列表、集合、字典

        不支持:元组、字符串

5.9.2特点

5.9.3应用场景

基于各类数据容器的特点，它们的应用场景如下
列表:一批数据，可修改、可重复的存储场景
元组:一批数据，不可修改、可重复的存储场景
字符串:一串字符串的存储场景
集合:一批数据，去重存储场景
字典:一批数据，可用Key检索Value的存储场景##

5.9.4 通用操作

5.9.4.1 统计功能

1.len(容器) 统计容器的元素个数

mylist = [1,2,3]
mytuple=(1,2,3,4,5)
mystr = "itiheima"
print(len(mylist))# 结果3
print(len(my tuple))# 结果5
print(len(mystr))# 结果8

2.max(容器) 统计容器的最大元素

mylist =[1,2,3]
mytuple=(1,2,3,4,5)
mystr= "itiheima"
print(max(mylist))#结果3
print(max(mytuple))# 结果5
print(max(mystr))# 结果t

3.min(容器) 统计容器的最小元素

mylist =[1,2,3]
mytuple=(1,2,3,4,5)
mystr= "itiheima"
print(min(mylist))# 结果1
print(min(mytuple))# 结果1
print(min(mystr))# 结果a

5.9.4.2 转换功能

list(容器) 将给定容器转换为列表
tuple(容器) 将给定容器转换为元组
str(容器) 将给定容器转换为字符串
set(容器) 将给定容器转换为集合

5.9.4.3 排序功能

sorted(容器,[reverse = True]) 降序

将给定容器排序，排序结果全部变为列表