第6章Python数据容器

一、数据容器入门

1. Python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素可以是任意类型的数据，如字符串、数字、布尔等

2.根据特点的不同分为五类，列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

二、列表...

1.基本语法

＃ 字面量

[元素1，元素2，元素3……]

＃ 定义变量

变量名称=[元素1，元素2，元素3……]

＃ 定义空列表

变量名称=[]

变量名称=list()

2.列表中的每一个数据称之为元素

以[]作为标识

列表内每一个元素之间用，逗号隔开

3.列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

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

"""
演示数据容器之:list列表语法:[元票，元素.....J
"""
#定义一个列表 list
my_list = ["itheima", "itcast","python"] 
print(my_list)
print(type(my_list))

my_list = ["itheima"，666,True] 
print(my_list)
print(type(my_list))
# 定义一个嵌套的列表
my_list = [ [1，2，3]，[4，5，6]]
print(my_list)
print(type(my_list))

三、列表的下标索引

1.列表的每一个元素，都有编号，称之为下标索引

从前向后的方向，编号从零开始递增

从后向前的方向，编号从-1开始递减

2.如何通过下标索引取出对应位置的元素

列表[下标]即可取出

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

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引]，从前向后从0开始，每次+1,	从后向前从-1开始，每次-1	
print(my_list[0]) 
print(my_list[1]) 
print(my_list[2])
# 错误示范:通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据(倒序取出) 
print(my_list[-1])
print(my_list[-2]) 
print(my_list[-3])

#取出嵌套列表的元素	
my_list = [ [1，2，3]，[4，5，6]]	
print(my_list[1][1])

四、列表的常用操作

1.列表的查询功能（方法）

在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法

2.查找某元素的下标

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

语法：列表.index（元素）

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

3.修改特定位置（索引）的元素值

语法：列表[下标]=值

4.插入元素

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

5.追加元素：

语法：列表.append

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

 

演示数据容器之:list列表的常用操作
mylist = ["itcast", "itheina", "python"]
# 1.1 查找某元素在列表内的下标索引 
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是:{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是:{index}")

# 2.修改特定下标索引的值 
mylist[0]="传智教育”
print(f"列表被修改元素值后，结果是:{mylist}")

# 3.在指定下标位置插入新元素 
mylist.insert(1,"best")
print(f"列表插入元素后，结果是:{mylist}")

# 4.在列表的尾部追加	新元素	
mylist.appehd("黑马程序员")
print(f"列表在追加了元素后，结果是{mylist}")

# 5.在列表的尾部追加一批```新元素
mylist2 = [1,2，3] 
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是:{mylist}")

# 6.删除指定下标索引的元素(2种方式)
mylist = ["itcast","itheima", "python"]
# 6.1 方式1:del列表[下标]
del mylist[2]	3	
print(f"列表删除元素后结果是:{mylist}")

# 6.2 方式2:列表.pop(下标)
mylist = ["itcast", "itheima", "python"] 
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容:{mylist}，取出的元素是:{element}")
# 7.删除某元素在列表中的第一个匹配项
mylist = ["itcast","itheima"， "itcast"，"itheima", "python"] 
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是:{mylist}")

# 8. 清空列表 
mylist.clear()
print(f"列表被清空了，结果是:{mylist}")

# 9.统计列表内某元素薇数
mylist = ["itcast", "itheima", "itcast","itheima", "python"] 
count = mylist.count("itheima")
print(f"列表中itheima的数量是:{count}")

# 10.统计列表中全部的元素数量
mylist = ["itcast"，"itheima"， "itcast", "itheima", "python"] 
count = len(mylist)
print(f"列表的元素数量总共有:{count}个")

五、列表的循环遍历

1.将容器内的元素依次取出进行处理的行为，称之为遍历、迭代

2.通过While和fo r循环

语法：

for 临时变量 in 数据容器:

     对临时变量进行处理

表示从容器内依次取出元素并赋值到临时变量，尚在每一次的循环中，我们可以对临时变量（元素）进行处理

3.while循环和for循环都是循环语句,细节不同

在循环控制上：

while循环可以自定循环条件，并自行控制

for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上:

while循环可以通过条件控制做到无限循环

for循环理论不可以，因为被遍历的容器容量不是无限的

在使用场景上:

while循环适用于任何想要循环的场景

for循环适用于遍历数据容器的场景或简单的固定次数循环场景

"""
演示对list列表的循环，使用while和for循环2种方式
"""

def list_while_func():
"""
使用while循环遍历列表的演示函数
:return: None
"""

my_list = ["传智教育"，"黑马程序员"，"Python"]
# 循环控制变量通过下标索引来控制，0
# 每一次循环将下标索引变量+1
# 循环条件:下标索引变量<列表的元素数量

#定义一个变量用来标记列表的下标
index=0	# 初始值为0	
while index < len(my_list):
#通过index变量取出对应下标的元素 
element = my_list[index]
print(f"列表的元素:{element}")


# 至关重要 将循环变量(index)每一次循环都+1 index += 1

def list_for_func():
"""
使用for循环遍历列表的演示函数
:return: None
"""
 	
list_while_func()

六、元组

1.元组一旦定义完成，就不可修改，所以当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适

2.定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

3.注意：元组只有一个数据，这个数据后面要添加

不可以修改元组的内容，否则会直接报错

可以修改元组内的list的内容（元组、增加、删除、反转等）

4.元组的特点

可以容纳多个数据

可以容纳不同类型的数据（混装）

数据是有序存储的(下标索引)

允许重复数据存在

不可以修改

支持for循环

"""
演示tuple元组的定义和操作
"""
#定义元组
t1 = (1,"Hello", True) 
t2=()
t3= tuple()
print(f"t1的类型是:{type(t1)}，内容是:{t1}") 
print(f"t2的类型是:{type(t2)}，内容是:{t2}") 
print(f"t3的类型是:{type(t3)}，内容是:{t3}")

# 定义单个元素的元素 t4 =("hello")
print(f"t4的类型是:{type(t4)}，t4的内容是: {t4}")

#元组的嵌套
t5 =((1,2,	3)，(4，5，6))	
print(f"t5的类	型是:{type(t5)},内容是:{t5}")

# 下标索引去取出内容 num = t5[1][2]
print(f"从嵌套元组中取出的数据是:{num}")

#元组的操作:index直找方法
t6 = ("传智教育"，"黑马程序员"，"Python")	
index= t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员，的下标是:{ len(元组)

#元组的操作:count统计方法
t7 =("传智教育”，“黑马程序员"，"黑马程序员"，“黑马程序员"，"python") 
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有:{num}个")

#元组的操作:len函数统计元组元素数分
t8=("传智教育"，"黑马程序员"，"黑马程序员"，"黑马程序员"，"python")
num = 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}")
#	修改元组内容	
# t8[0] = "itcast"
# 定义一个元组
t9 = (1， 2，["itheima", "itcast"l) print(f"t9的内容是:{t9}") t9

七、字符串

1.字符串的替换

语法：字符串.replace（字符串1，字符串2）

功能:将字符串内的全部:字符串1,替换为字符串2

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

2.字符串的分割

语法：字符串.split（分隔符字符串）

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

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

3.字符串的规整操作（去前后空格）

语法：字符串.strip()

字符串的规整操作（去前后指定字符串）

语法：字符串.strip（字符串）

4.字符串的特点

只可以存储字符串

"""
演示以数据容器的角色，学习字符串的相关操作
"""
my_str = "itheima and itcast"
# 通过下标索引取值 
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，。值是:{value},取下标为-16的元素。值是:{value2}")
my_str[2]="H"


# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是:{value}")

# replace方法
new_my_str = my_str.replace("it"，"程序")
print(f"将字符串{my_str}，进行替换后得到:{new_my_str}")

# split方法
my_str = "hello python itheima itcast" 
my_str_list = my_str.split("")
print(f"将字符串{my_str}进行split切分后得到:{my_str_list}，类型是:{type(my_str_list)}")

# strip方法
my_str = " itheima and itcast "
new_my_str = my_str.strip() #不传入参数，去除首尾空格 
print(f"字符串{my_str}被strip后，结果:{new_my_str}")
my_str = "12itheima and itcast21" 
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip(12)后，结果:{new_my_str}")

统计字符串中某字符串的出现次数，count 
my_str = "itheima and itcast" 
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是:{count}")
# 统计字符串的长度，
len() num = len(my_str)
print(f"字符串{my_str}的长度是:{num}")

允许重复字符串存在

支持下标索引

不可以修改

支持for循环

5.字符串可以看作是字符的容器，支持下标索引等特性

 

八、数据容器的切片操作

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

2.列表、元组、字符串均可以视为序列

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

4.切片：从一个序列中，取出一个子序列

5.语法：序列[起始下标：结束下标：步长]

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

"""

演示对序列进行切片操作
"""

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

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

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

# 对列表进行切片，从3开始，到1结束，步长-1 
my_list = [0, 1, 2. 3， 4，5，6] 
result5 = my_list[3:1:-1] 
print(f"结果5:{result5}")

# 对元组进行切片，从头开始，到尾结束，步长-2 
my_tuple = (d，1，2，3，4，5，6) 
result6 = my_tuple[::-2] 
print(f"结果6:{result6}")

九、集合

1.和列表、元组、字符串的定义基本相同

列表使用:[]

元组使用：()

字符串使用：" "

集合使用：{}

2.因为集合是无序的，所以集合不支持下标索引访问

3.添加新元素

语法：集合.add（元素）

4.取出两个集合的差集

语法：集合1.difference（集合2）

功能：取出集合1和集合2的差集

 5.消除两个集合的差集

语法：集合1.difference_ update（集合2）

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

6.两个集合合并

语法：集合1.union（集合2）

功能：将集合1和集合2组合成新集合

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

7.集合的特点

可以容纳多个数据

可以容纳不同类型的数据（混装）

数据是无序存储的（不支持下标索引）

不允许重复数据存在

可以修改

支持for循环

"""
演示数据容器集合的使用
"""

# 定义集合
my_set = {"传智教育"，"黑马程序员"，"itheima"，"传智教育	"黑马程序员"，"itheima"，"传智教育"，"黑马程序员"，"itheima"}	
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("Python")
my_set.add("传智教育")	#	
print(f"my_set添加元素后结果是:{my_set}")

# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是:{my_set}")#随机取出一个元素
my_set = {"传智教育"，"黑马程序员"，"itheima"} 
element = my_set.pop()
print(f"集合被取出元素是:{element}，取出元素后:{my_set}")

# 清空集合
my_set.clear()
print(f"集合被清空啦，结果是:{my_set}")

# 取2个集合的差集 
set1 = {1，2，3} 
set2 = {1，5， 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是:{set3}")
print(f"取差集后，原有set1的内容:{set1}") 
print(f"取差集后，原有set2的内容:{set2}")

# 2个集合合并为1个 
set1 = {1, 2，3} 
set2 = {1,5， 6}
set3 = set1.union(set2)
print(f"2集合合并结果:{set3}") 
print(f"合并后集合1:{set1}") 
print(f"合并后集合2:{set2}")

# 统计集合元素数量len()
set1 = {1, 2， 3， 4，5，1，2，3，4，5}
num = len(set1)
print(f"集合内有:{num}个")

# 集合的遍历
# 集合不支持下标索引	不能用while循坏	
# 可以用for循环
set1 = {1，2，3，4，5} 
for element in set1:
    print(f"集合的元素有:{element}")

十、字典

1.可以使用字典,实现用key取出Value的操作

2.字典的定义，同样使用{}，不过存储的元素是一个个的：键值对

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

4.字典内key不允许重复，重复添加等同于覆盖原有数据

5.键指对的key和Value可以是任意类型（key不可为字典）

"""
演示数据容器字典的定义
"""

# 定义字典
my_dict1 = {"王力鸿": 99，"周杰轮":88，"林俊节":77}
# 定义空字典 
my_dict2 ={}
my_dict3 = dict()
print(f"字典1的内容是:{my_dict1}，类型:{type(my_dict1)}") 
print(f"字典2的内容是:{my_dict2}，类型:{type(my_dict2)}") 
print(f"字典3的内容是:{my_dict3}，类型:{type(my_dict3)}")

# 定义重复Key的字典
my_dict1 = {"王力鸿": 99，"王力鸿":88，"林俊节":77}
print(f"重复key的字典的内容是:{my_dict1}	

# 从字典中基于Key获取Value		
my_dict1 = {"王力鸿":99，"周杰轮":88}	
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是:{score}") 
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是:{score}")

#定义嵌套字典
stu_score_dict ={
    "王力鸿": {
    "语文": 77，
    "数学":66，
    "英语":33}，
 }, "周杰轮":{
    "语文": 88,
    "数学":86，
    "英语":55"
{,  "林俊节":{
    "语文":99,
    "数学":96,
    "英语":66
}
}

print(f"学生的考试信息是:{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"] 
print(f"周杰轮的语文分数是:{score}")
score = stu_score_dict["林俊节”]["英语"] 
print(f"林俊节的英语分数是:{score}")

# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果:{my_dict}，周杰轮的考试分数是:{score}")
#	清空元素clear	
my_dict.clear()
print(f"字典被清空了，内容是，{my_dict}")
# 获取全部的key
my_dict = {"周杰轮":99，"林俊节":88，“张学油":77} 
keys = my_dict.keys()
print(f"字典的全部keys是:{keys}")

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

# 统计字典内的元素数	len()函数	
num = len(my_dict)
print(f"字典中的元素数量有:{num}个")

十一、字典的常用操作

1.新增元素

2.更新元素（字典key不可以重复，所以对已存在的key执行上述操作,就是更新Value值）

3.删除元素

4.清空字典

5.获取全部的key

6.特点

可以容纳多个数据

可以容纳不同类型的数据

每一份数据是KeyValue键值对

可以修改

支持for循环，不支持while循环

7.新增和更新元素的语法一致，如果Key不存在即新增,如果Key存在即更新

操作	说明
字典[key]=value	添加或更新键值对
字典[key]	获取指定key对应的Value值
字典.pop(key)	取出key对应的Value并在字典内删除此key的键值对
字典.clear()	清空字典
字典.keys()	获取字典的全部key,可用于for循环遍历字典
len（字典）	计算字典内的元素数量

 

十二、五类数据容器对比总结

1.是否支持下标索引

支持：列表、元组、字符串—序列类型

不支持：集合、字典—非序列类型

2.是否支持重复元素

支持：列表、元组、字符串—序列类型

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

3.是否可以修改

支持:列表、集合、字典

不支持：元组、字符串

十三、数据容器的通用操作

1.遍历

2.len（容器）：统计容器的元素个数

max（容器）：统计容器的最大元素

min（容器）：统计容器的最小元素

3.

tuple(容器) ：将给定容器转换为元组

set(容器)：将给定容器转换为集合

list（容器）：将给定容器转化为列表

str（容器）:将给定容器换为字符串

4.通用排序功能：

sorted（容器，[reverse=True]）

将给定容器进行排序

"""
演示数据容器的通用功能
"""
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}
# len元素个数
pridt(f"列表元素个数有:{len(my_list)}") 
print(f"元组 元素个数有:{len(my_tuple)}") 
print(f"字符串元素个数有:{len(my_str)}") 
print(f"集合 元素个数有:{len(my_set)}") 
print(f"字典元素个数有:{len(my_dict)}")

 

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