零基础Python学习，第六章：数据容器-CSDN博客

本文链接：https://blog.csdn.net/weixin_39559852/article/details/142685051
# 数据容器入门
#数据容器：一个可以存储多个元素的Python数据类型
# 数据容器：list列表，tuple元组，str字符串，set集合，dict字典

# 1.list列表定义
#定义变量,列表内每个元素之间用逗号隔开,列表中存储类型可以不同
"""
name_list = ['Sean','Chan',666,'YL',True]
#定义空列表
a = []
b = list()
print(name_list)
print(type(name_list))
"""

# 列表内存放列表（Matrix）
"""
my_list = [[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))
"""

# 2.list下标索引
"""
# 列表中下表从左到右，从0开始
name_list = ['Sean','Chan',666,'YL',True]
#随意取用列表内元素，但超出索引范围会报错
print(name_list[0],name_list[1],name_list[3],name_list[2])
#两层下表索引，依然按顺序排列
my_list = [[1,2,3],[4,5,6]]
print(my_list[0][1],my_list[1][2]) #获取元素2与6
"""

# 3.list常用操作
# 功能(方法)：插入元素，删除元素，清空列表，修改元素，统计元素个数
# 将函数定义为class类的成员，那么函数就会被称为方法

# 查找某元素下标，语法：list.index(element)
"""
name_list = ['Sean','Chan',666,'YL',True]
index = name_list.index('YL')
print(f"YL 在列表中的索引值是：{index}")
# 如果元素不在列表内，用index查找该元素就会报错
#print(f"HELLO 在列表中的索引值是：{name_list.index('HELLO')}")
"""

# 修改特定位置的元素值，语法：list[index]=object
"""
my_list = [[1,2,3],[4,5,6]]
my_list[0][0] = 100
print(f"列表被修改元素值后结果是：{my_list}")
"""

# 在列表指定位置中插入元素，语法：list.insert(index,object)
"""
name_list = ['Sean','Chan',666,'YL',True]
name_list.insert(0,'HAHA')
# 插入后，原本的元素往后靠
print(name_list)
"""

# 追加元素方法1，追加1个，将指定元素放至列表尾部，语法：list.append(object)
# 追加元素方法2，追加1批，将其他数据容器放置于列表后，语法：list.extend(other data container)
"""
name_list = ['Sean','Chan',666,'YL',True]
name_list.append('HAHA')
print(name_list)
my_list = [[1,2,3],[4,5,6]]
name_list.extend(my_list)
print(name_list)
"""

# 元素删除方法1，语法：del list[index]
# 元素删除方法2，语法：list.pop[index]
"""
name_list = ['Sean','Chan',666,'YL',True]
del name_list[2]
print(name_list)
element = name_list.pop(3) #该方法可以返回取出值
print(name_list)
print(f"通过pop方法取出的元素是：{element}")
"""

# 删除指定内容，语法：list.remove(object)
"""
num_list = [1,2,4,3,4]
num_list.remove(4) #只删除第一个找到的元素（从前到后）
print(num_list)
"""

# 清空列表内容，语法：list.clear()
"""
num_list = [1,2,4,3,4]
num_list.clear()
print(num_list)
"""

# 统计某元素在列表中的数量，语法：list.count(object)
"""
num_list = [1,2,4,3,4]
print(num_list.count(4)) #输出结果为2
"""

# 统计列表中元素的数量，用len(list)
"""
num_list = [1,2,4,3,4]
print(len(num_list)) #输出结果为5
"""

"""
列表特点总结：
1. 可容纳多个元素，2**63-1个；
2. 元素混装
3. 数据是有序存储的
4. 允许重复数据的存在
5. 可以修改元素
"""

# 练习：列表功能运用
"""
age_list = [21,25,21,23,22,20]
age_list.append(31)
age_list.extend([29,33,30])
first_element = age_list[0]
last_element = age_list[-1] #-1索引列表中最后一个元素
print(age_list)
print(f"元素31在列表中的下标位置为：{age_list.index(31)}")
"""

# 4.list的遍历
# 遍历（迭代）：将容器内元素依次取出进行处理的行为

# 利用while循环遍历列表元素
def list_while_func():
    name_list = ['Sean','Chan',666,'YL',True] #创建列表
    index = 0 #循环控制变量
    while index < len(name_list):
        print(f"列表元素为：{name_list[index]}")
        index += 1

#list_while_func()

# 利用for循环遍历列表元素
def list_for_func():
    name_list = ['Sean','Chan',666,'YL',True] #创建列表
    for object_1 in name_list:
        print(f"列表元素为：{object_1}")

#list_for_func()

# 练习：取出列表内偶数，并组成新列表
num_list = [1,2,3,4,5,6,7,8,9,10]


def while_func():
    index = 0
    even_list_1 = []
    while index < len(num_list):
        if num_list[index]%2 == 0:
            even = num_list[index]
            even_list_1.append(even)
        index += 1
    print(f"通过while循环，从列表中取出偶数，组成新列表：{even_list_1}")

#while_func() #调用函数

def for_func():
    even_list_2 = []
    for even in num_list:
        if even%2 == 0:
            even_list_2.append(even)
    print(f"通过for循环，从列表中取出偶数，组成新列表：{even_list_2}")

#for_func() #调用函数

# 5.数据容器：tuple(元组)
# 元组一旦定义完成，就不可修改，用于数据封装
# 定义元组方式：1.变量名称 = (); 2.变量名称 = tuple()
# 定义元组字面量：(1,2,3,4,5) 通过逗号隔开元素
# 定义元组变量：a = (1,2,3,4,5)
"""
t1 = (1,"Hello",True) #不限定类型
t2 = ()
t3 = tuple()
t4 = ("HEHE",) #注意，若元组内只有单个元素时，要在元素后面加','
print(f"各变量类型是{type(t1),type(t2),type(t3),type(t4)}")

t5 = ((1,2,3),(4,5,6)) #嵌套元组
num = t5[1][1]; print(num) #取出元组内元素5
"""

# 在元组中查找，统计某元素出现次数，统计元素个数都可以
"""
t6 = ("Sean","Chan",666,666)
print(f"t6中元素“666”的个数是{t6.count(666)}")
print(f"t6中元素的个数是{len(t6)}")
print(f"t6中第Chan元素下标是{t6.index("Chan")}")
"""

# 特殊情况，修改元组内容
# 若元组内有list列表则可以修改list列表里的内容
"""
t7 = (1,2,["HEHEHE","HAHAHA"])
print(f"t7的内容是：{t7}")
t7[2][0] = "Sean"
t7[2][1] = "Chan"
print(f"t7的内容是：{t7}")
"""

# 练习：元组基本操作
"""
# 1.定义一个元组
stu_info = ('Sean Chan', 18, ['Gaming','Music'])
# 2.询问年零所在的下标位置
print(f"年龄信息所在的下标为：{stu_info.index(18)}")
# 3.查询学生姓名
print(f"学生姓名为：{stu_info[0]}")
# 4.删除学生爱好中的Gaming
stu_info[2].pop(0) ###重要！！！
print(f"学生{stu_info[0]}的爱好为：{stu_info[2]}")
# 5.增加爱好：Coding到爱好list内
stu_info[2].append('Coding') ###重要！！！
print(f"学生{stu_info[0]}的爱好为：{stu_info[2]}")
"""

# 6.字符串常见操作
# 字符串是字符的容器
# 从前向后，下标从0开始；从后向前，下标从-1开始
# 字符串也是不可修改的数据容器

"""
my_str = "Sean Chan"
value_1 = my_str[0]
value_2 = my_str[-9] #空格也算长度
print(f"value_1的值是{value_1}")
print(f"value_2的值是{value_2}")
"""

# 字符串index
#print(my_str.index('C'))

# 字符串的替换
# 语法：字符串.replace(字符串1, 字符串2)
# 功能：将字符串1全部替换为字符串2，得到了一个新的字符串(不是修改！)
"""
new_my_str = my_str.replace("Sean","YL")
print(new_my_str)
"""
# 字符串的分割
# 语法：字符串.split(分隔符字符串)
# 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
# 注意：字符串本身不变，而是得到一个列表对象
"""
my_str = "YL named SW"
my_str_list = my_str.split(" ")
print(f"将字符串通过分隔符” ”分割后是{my_str_list}")
"""

# 字符串规整操作(去前后空格)
# 语法：字符串.strip()
"""
my_str = "  Hello World!  "
print(my_str.strip()) #不传参就是默认去除空格
"""

# 字符串规整操作(去前后指定字符串) 注意：是前后！！！
# 语法：字符串.strip(字符串)
"""
my_str = "12Hello World!21"
my_str_1 = my_str.strip("12") #此处是将12两个字符串分割成1与2，这样就能识别12或21
print(my_str_1)
"""

# 统计字符串出现次数
"""
my_str = "12Hello World!21"
print(my_str.count("1"))
"""

# 统计字符串长度
"""
my_str = "12Hello World!21"
print(len(my_str))
"""

# 字符串遍历
"""
my_str = "12Hello World!21"
for x in my_str:
    print(x,end=' ')
"""

# 练习案例：分割字符串
# 给定一个字符串
"""
str_1 = "Learn IT for IT job in IT blog"
# 统计字符串中有多少“IT”字符
print(f"字符串{str_1}中有：{str_1.count("IT")}个IT字符")
#将字符串内空格全部替换为字符“|”
str_2 = str_1.replace(" ", "|")
print(f"字符串{str_1}，被替换空格后，结果：{str_2}")
#按照“|”进行字符串分隔，得到列表
list_1 = str_2.split("|")
print(f"字符串{str_2}，按照|分隔后，得到：{list_1}")
"""

# 7.数据容器(序列)的切片操作
# 序列：内容连续、有序，可以使用下标索引的一类数据容器

# 切片：从一个序列中，取出一个子序列。序列均支持切片。
# 语法：序列[起始下标:结束下标:步长]
# 表示从序列中从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。
# 起始下标和结束下标留空的话默认从头开始截取至结尾
# 切片操作不影响序列本身，故元组、字符串均可用

#切片演示
"""
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8]
result_1 = my_list[0:4] #注意：不包含结束位的元素
result_5 = my_list[5:0:-1]
print(result_1)
print(result_5)

my_tuple = (0, 1, 2, 3, 4, 5, 6, 7, 8)
result_2 = my_tuple[:]
result_6 = my_tuple[::-2]
print(result_2)
print(result_6)

my_str = "012345678"
result_3 = my_str[::2]
result_4 = my_str[::-1]
print(result_3)
print(result_4)
"""

# 练习：序列切片
# 将字符串：“万过薪月,TI搞,nohtyP学”中的“搞IT”提取出来
"""
# 方式1
my_str = "万过薪月,TI搞,nohtyP学"
rever_my_str = my_str[::-1]
my_list = rever_my_str.split(",")
print(f"取出的切片为：{my_list[1]}")
# 方式2
result = my_str[7:4:-1]
print(f"取出的切片为：{result}")
# 方式3
result_1 = my_str[5:8][::-1] #取出列表，然后列表倒序
print(f"取出的切片为：{result_1}")
"""

# 8.集合的定义和操作
# 上述数据容器都有一个局限性，就是都支持重复元素
# 特定场景中若要对内容做去重处理，列表、字符串、元组就不方便了
# 集合主要特点：不支持重复，内容无序，不支持下标索引访问，但可以修改
# 记：列表用[]，元组用()，字符串用""，集合用{}

#定义集合字面量
# {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}
#定义集合变量
# my_set_1 = {"Sean", "Chan", "666","YL", "Chan", "Chan"}
#定义空集合
# my_set_2 = set()
"""
print(f"my_set_1的内容是{my_set_1}") # 去重了,并且无序，多运行几次
print(f"my_set_2的内容是{my_set_2}") # 空集合
print(f"my_set_1的类型是{type(my_set_1)}")
print(f"my_set_2的类型是{type(my_set_2)}")
"""
# 集合常用操作-修改
# 添加新元素
"""
my_set_2.add("Python")
print(f"my_set_2的内容是{my_set_2}")
my_set_2.add("Python") #去重，再添加无意义
print(f"my_set_2的内容是{my_set_2}")
"""
# 移除元素
"""
my_set_2.remove("Python")
print(f"my_set_2的内容是{my_set_2}")
"""
# 随机取出一个元素
"""
element_1 = my_set_1.pop()
print(f"从my_set_1取出的元素是{element_1}") #随机取
"""
# 清空集合
"""
my_set_1.clear()
print(f"my_set_1的内容被清空后是{my_set_1}")
"""
# 取两个集合的差集
# 语法：set_1.difference(set_2)
# 功能：取出集合1有的而集合2没有的元素
# 注意：集合1与集合2不变
"""
my_set_1 = {"Sean", "Chan", "666","YL"}
my_set_2 = {"Sean", "Chan"}
my_set_3 = my_set_1.difference(my_set_2)
print(f"my_set_3的内容是{my_set_3}")
"""

# 清除2个集合的差集
# 语法：set_1.difference_update(set_2)
# 功能：对比集合1与集合2，在集合1内删除与集合2相同的元素
# 结果：集合1被修改，集合2不变
"""
my_set_1 = {"Sean", "Chan", "666","YL"}
my_set_2 = {"Sean", "Chan"}
my_set_1.difference_update(my_set_2)
print(f"my_set_1修改的内容是{my_set_1}")
print(f"my_set_2的内容是{my_set_2}")
"""

# 2个集合合并
# 语法：set_1.union(set_2)
# 功能：组成一个合并的新集合
# 结果：得到新集合，集合1与集合2不变
"""
my_set_1 = {"Sean", "Chan"}
my_set_2 = {"666","YL","Chan"}
my_set_3 = my_set_1.union(my_set_2)
print(f"合并集合：my_set_3的内容是{my_set_3}") #已去重
"""
# 统计集合元素数量
"""
my_set_1 = {"Sean", "Chan", "666","YL", "Chan"}
num = len(my_set_1)
print(f"my_set_1的元素数量有{num}个") #已去重
"""
# 集合遍历
# 注意：集合不支持下标索引，所以不能用while遍历
"""
my_set_1 = {"Sean", "Chan", "666","YL", "Chan"}
for x in my_set_1:
    print(x, end=' ')
"""

# 集合练习
# 有如下列表对象：
"""
my_list = ['Sean', 'Chan', 'YL', 'YL', '666', 'NCHU', 'WYU', '666']
# 定义一个空集合
my_set = set()
#通过for循环遍历列表并将列表元素添加至集合中，最后打印输出集合
for x in my_list:
    my_set.add(x)
print(f"集合中的内容是：{my_set}")
"""

# 9.数据容器：字典(键值对)
# 格式：key: value
# 功能：通过key找到对应的value

# 定义字典字面量
"""
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
print(f"字典1的内容是：{my_dict},类型是{type(my_dict)}")
"""
# 定义空字典
"""
my_empty_dict_1 = {}
my_empty_dict_2 = dict()
print(f"字典2的内容是：{my_empty_dict_1},类型是{type(my_empty_dict_1)}")
print(f"字典3的内容是：{my_empty_dict_2},类型是{type(my_empty_dict_2)}")
"""
# Python中字典的key是不能重复的
"""
my_dict = {"Sean": 88, "Sean": 93, "YL": 99}
print(f"字典1的内容是：{my_dict}") #后一个被前一个覆盖了
"""
# 字典不可以用下标索引，只能用key值
"""
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
score = my_dict["Sean"]
print(f"Sean的分数是：{score}")
"""

# 字典嵌套
# 注：字典的key和value可以是任意数据类型（key不可以为字典类型）
# 记录各学生的各科的考试成绩
"""
stu_score_dict = {
    "Sean":{
        "语文": 77,
        "数学": 88,
        "英语": 88},
    "Chan":{
        "语文": 87,
        "数学": 76,
        "英语": 90},
    "YL":{
        "语文": 78,
        "数学": 89,
        "英语": 94}
}
print(stu_score_dict)
score = stu_score_dict["Chan"]["语文"]
print(f"Chan的语文分数是：{score}")
"""

# 10.字典的常用操作

# 字典新增元素
# 语法：dict[key] = value
# 原有key就覆盖，未有key就新增；key不可重复
"""
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
my_dict["HEHE"] = 85
print(f"新增后：{my_dict}")
my_dict["HEHE"] = 99
print(f"修改后：{my_dict}")
"""

# 字典删除元素
# 语法：dict.pop(key)
"""
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
score = my_dict.pop("Sean")
print(f"Sean被删除后：{my_dict}，Sean的考试分数是：{score}")
"""

# 字典清空元素
# 语法：dict.clear()
"""
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
my_dict.clear()
print(f"字典被清空了，内容是{my_dict}")
"""

# 字典获取全部key
# 功能：得到字典中全部的key
# 语法：dict.keys()
"""
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
keys = my_dict.keys()
print(f"字典中全部的key是{keys}")
"""

# 字典遍历
# 一般情况下不支持while循环
"""
# 方式1：获取全部key来完成遍历
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
keys = my_dict.keys()
for key in keys:
    print(f"字典的key是：{key}", end='\t\t')
    print(f"字典的value是：{my_dict[key]}")
# 方式2：直接对字典进行for循环，每次循环直接得到key
for key in my_dict:
    print(f"字典的key是：{key}", end='\t\t')
    print(f"字典的value是：{my_dict[key]}")
"""

# 统计字典的元素数量
# len()
"""
my_dict = {"Sean": 88, "Chan": 93, "YL": 99}
num = len(my_dict)
print(f"字典的元素数量为：{num}")
"""

# 练习：升值加薪
# 给定一个字典
department_message = {
    "Sean": {
        "department": "Tech",
        "salary": 16000,
        "rank": 1
},
    "Chan": {
        "department": "Market",
        "salary": 23000,
        "rank": 2
},
    "YL": {
        "department": "Market",
        "salary": 28000,
        "rank": 3
},
    "Zhang": {
        "department": "Market",
        "salary": 17000,
        "rank": 1
},
    "Liu": {
        "department": "Market",
        "salary": 24000,
        "rank": 2
}
}

# 输出当前员工信息
print("全体员工当前信息如下：")
for x in department_message:
    print(f"{x}{department_message[x]}")

# 利用for循环将所有级别为1的员工的级别上升1级并加薪4000
for x in department_message:
    if department_message[x]["rank"] == 1:
        department_message[x]["rank"] += 1
        department_message[x]["salary"] += 4000

# 输出修改后的信息
print("级别为1的员工升职加薪后信息如下：")
for x in department_message:
    print(f"{x}{department_message[x]}")