前言:导师让近期速成一下Python,以下是我跟着“黑马程序员Python教程,Python从入门到精通”学习时记录的笔记,方便自己的复习,也方便Python初学者参考,我会争取将学到的Python知识记录上面,欢迎收藏学习~~
文章目录
06_Python数据容器
6.1 数据容器入门
6.2 数据容器:list(列表)
1、列表的定义
2、列表的下标索引
下标索引的注意事项:要注意下标索引的取值范围,超出范围无法取出元素,并且会报错。
3、列表的常用操作
列表除了可以定义,使用下标索引获取值以外,列表也提供了一系列的功能:插入元素,删除元素,清空列表,修改元素,统计元素个数等等功能,这些功能我们都称之为列表的方法。
- 列表的查询功能(方法)
- 列表的修改功能(方法)
- 插入元素
- 追加元素
- 追加元素方式2
- 删除元素
- 删除元素在列表中的第一个匹配项
- 清空列表内容
- 统计某元素在列表内的数量
- 统计列表内有多少个元素
4、列表的方法(常用操作)-总览
5、列表的特点
6、常用功能练习
age = [21, 25, 21, 23, 22, 20]
age.append(31)
age.extend([29, 33, 30])
print(age[0]) # 21
print(age[-1]) # 30
print(age)
index = age.index(31)
print(index)
6.3 list(列表)的遍历
1、列表的遍历-while循环
2、列表的遍历-for循环
3、while循环和for循环的对比
4、练习案例:取出列表内的偶数
my_list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_list2 = []
my_list3 = []
index = 0
while index < len(my_list1):
if my_list1[index] % 2 == 0:
my_list2.append(my_list1[index])
index += 1
print(f"通过while循环,从列表{my_list1}中取出偶数,组成新列表:{my_list2}")
for element in my_list1:
if element % 2 == 0:
my_list3.append(element)
print(f"通过for循环,从列表{my_list1}中取出偶数,组成新列表:{my_list3}")
6.4 数据容器:tuple(元组)
1、元组的定义
元组定义:定义元组使用小括号,且使用逗号隔开各个数据,数据可以是不同的数据类型。
注意:元组只有一个数据时,这个数据后面要添加逗号。
2、元组的相关操作
注意:元组由于不可修改的特性,所以其操作方法非常少。
3、元组的相关操作-注意事项
4、元组的遍历
同列表一样,元组也可以被遍历。可以使用while循环和for循环遍历它。
5、元组的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据(混装)
- 数据是有序存储的(下标索引)
- 允许重复数据存在
- 不可以修改(增加或删除元素等)
- 支持for循环
6、练习案例:元组的基本操作
stu_info = ("周杰伦", 11, ["football", "music"])
print(stu_info.index(11))
print(stu_info[0])
del stu_info[2][0]
stu_info[2].insert(1, "coding")
print(stu_info)
6.5 数据容器:str字符串
1、字符串的定义
字符串为什么被称之为数据容器呢?字符串可以看做是字符的容器,支持下标索引等特性。
2、字符串的下标(索引)
3、字符串的常用操作
- 查找特定字符串的下标索引值
- 字符串的替换
- 字符串的分割
- 字符串的规整操作
- 统计字符串中某字符的出现次数
- 统计字符串的长度
4、字符串的常用操作汇总
5、字符串的遍历
同列表、元组一样,字符串也支持while循环和for循环进行遍历。
6、字符串的特点
基本和列表、元组相同,不同与列表和元组的在于:字符串容器可以容纳的类型是单一的,只能是字符串类型。不同于列表,相同于元组的在于:字符串不可修改。
- 只可以存储字符串
- 长度任意(取决于内存大小)
- 支持下标索引
- 允许重复字符串存在
- 不可以修改(增加或删除元素等)
- 支持for循环
7、练习案例:分割字符串
str = "itheima itcast boxuegu"
num = str.count("it")
print(f"字符串{str}中有:{num}个it字符")
new_str = str.replace(" ", "|")
print(f"字符串{str},被替换空格后,结果:{new_str}")
new_str2_list = new_str.split("|")
print(f"字符串{new_str},按照|分割后,得到:{new_str2_list}")
6.6 数据容器(序列)的切片
1、序列
序列:内容连续、有序,可使用下标索引的一类数据容器。列表、元组、字符串均可以视为序列。
如下图,序列的典型特征就是有序,并可用下标索引,字符串、元组、列表均满足这个要求。
2、序列的常用操作-切片
3、序列的切片演示
my_list = [0, 1, 2, 3, 4, 5]
new_list = my_list[1:4] # 下标1开始,下标4(不含)结束,步长1
print(new_list) # [1, 2, 3]
my_tuple = (0, 1, 2, 3, 4, 5)
new_tuple = my_tuple[:] # 从头开始,到最后结束,步长1
print(new_tuple) # (0, 1, 2, 3, 4, 5)
my_list = [0, 1, 2, 3, 4, 5]
new_list = my_list[::2] # 从头开始,到最后结束,步长2
print(new_list) # [0, 2, 4]
my_str = "012345"
new_str = my_str[:4:2] # 从头开始,到下标4(不含)结束,步长2
print(new_str) # 02
my_str = "012345"
new_str = my_str[::-1] # 从头(最后)开始,到尾结束,步长-1(倒序)
print(new_str) # 543210
my_list = [0, 1, 2, 3, 4, 5]
new_list = my_list[3:1:-1] # 从下标3开始,到下标1(不含)结束,步长-1(倒序)
print(new_list) # [3, 2]
my_tuple = (0, 1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] # 从头(最后)开始,到下标1(不含)结束,步长-2(倒序)
print(new_tuple) # (5, 3)
4、总结
5、练习案例:序列的切片实战
my_str = "万过薪月,员序程马黑来,nohtyP学"
# 直接倒序切片取出
result = my_str[9:4:-1]
print(result)
# 先倒序字符串,再切片取出
result1 = my_str[::-1][9:14:]
print(result1)
# 先切片取出,然后倒序
result2 = my_str[5:10:][::-1]
print(result2)
# split分割,replace替换"来"为空,倒序字符串
result3 = my_str.split(",")[1].replace("来", "")[::-1]
print(result3)
6.7 数据容器:set(集合)
1、为什么使用集合
2、集合的定义
3、集合的常用操作-修改和集合长度
- 添加新元素
- 移除元素
- 从集合中随机取出元素
- 清空集合
- 取出两个集合的差集
- 消除两个集合的差集
- 两个集合合并
- 查看集合的元素数量
4、集合的常用功能总结
5、集合的常用操作-for循环遍历
6、集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据(混装)
数据是无序存储的(不支持下标索引)
不允许重复数据存在
- 可以修改(增加或删除元素等)
- 支持for循环
7、练习:信息去重
my_list = ["黑马程序员", "传智播客", "黑马程序员", "传智播客",
"itheima", "itcast", "itheima", "itcast", "best"]
my_set = set()
for element in my_list:
my_set.add(element)
print(f"有列表:{my_list}")
print(f"存入集合后结果:{my_set}")
6.8 数据容器:dict(字典、映射)
1、为什么使用字典
所以,为什么使用字典?因为可以使用字典,实现用Key取出Value的操作。
2、字典的定义
字典的定义,同样使用{},不过存储的元素是一个个的:键值对,如下语法:
- 使用{}存储元素,每一个元素是一个键值对。
- 每一个键值对包含Key和Value(用冒号分隔)
- 键值对之间使用逗号分割
Key和Value可以是任意类型的数据(Key不可为字典)
- Key不可重复,重复会对原有数据覆盖
3、字典数据的获取
4、字典的嵌套
5、嵌套字典的内容获取
6、总结
7、字典的常用操作
- 新增元素
- 更新元素
- 删除元素
- 清空字典
- 获取全部的Key
- 遍历字典(两种方式)
# 方式1:通过获取到全部的Key来完成遍历
for key in keys:
print(f"学生{key}, 分数{stu_score[key]}")
# 方式2:直接对字典进行for循环,每一次循环都是直接得到Key
for key in stu_score:
print(f"学生{key}, 他的分数{stu_score[key]}")
注意:字典不支持下标索引,所以同样不可以用while循环遍历
- 计算字典内全部元素(键值对)数量
8、字典的常用操作总结
9、字典的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value,key不可重复(重复会覆盖)
- 不支持下标索引
- 可以修改(增加或删除更新元素等)
- 支持for循环,不支持while循环
10、练习:升职加薪
employee_info = {
"王力宏": {"部门": "科技部", "工资": 3000, "级别": 1},
"周杰伦": {"部门": "市场部", "工资": 5000, "级别": 2},
"林俊杰": {"部门": "市场部", "工资": 7000, "级别": 3},
"张学友": {"部门": "科技部", "工资": 4000, "级别": 1},
"刘德华": {"部门": "市场部", "工资": 6000, "级别": 2}
}
print(f"全体员工当前信息如下:\n{employee_info}")
for name in employee_info:
if employee_info[name]["级别"] == 1:
employee_info[name]["级别"] = 2
employee_info[name]["工资"] += 1000
print(f"全体员工级别为1的员工完成升职加薪操作,操作后:\n{employee_info}")
6.9 拓展:数据容器对比总结
1、数据容器分类
2、数据容器特点对比
3、各类数据容器应用场景总结
6.10 数据容器的通用操作
1、数据容器通用操作-遍历
- 5类数据容器都支持for循环遍历
- 列表、元组、字符串支持while循环,集合、字典不支持(无法下标索引)
2、数据容器的通用统计功能
- len(容器)
- max(容器)
- min(容器)
my_list = [3, 1, 5, 2, 4]
my_tuple = (3, 1, 5, 2, 4)
my_str = "bdacge"
my_set = {3, 1, 5, 2, 4}
my_dict = {"Key3": 3, "Key1": 1, "Key5": 5, "Key2": 2, "Key4": 4}
# len(容器)"
print(len(my_list)) # 5
print(len(my_tuple)) # 5
print(len(my_str)) # 6
print(len(my_set)) # 5
print(len(my_dict)) # 5
# max(容器)
print(max(my_list)) # 5
print(max(my_tuple)) # 5
print(max(my_str)) # g
print(max(my_set)) # 5
print(max(my_dict)) # Key5
# min(容器)
print(min(my_list)) # 1
print(min(my_tuple)) # 1
print(min(my_str)) # a
print(min(my_set)) # 1
print(min(my_dict)) # Key1
3、容器的通用转换功能
- list(容器)
- tuple(容器)
- str(容器)
- set(容器)
my_list = [3, 1, 5, 2, 4]
my_tuple = (3, 1, 5, 2, 4)
my_str = "bdacge"
my_set = {3, 1, 5, 2, 4}
my_dict = {"Key3": 3, "Key1": 1, "Key5": 5, "Key2": 2, "Key4": 4}
# 数据容器转列表
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)}")
print("-----------------")
# 数据容器转元组
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)}")
print("--------------------")
# 数据容器转字符串
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)}")
print("-------------------")
# 数据容器转集合
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)}")
4、容器通用排序功能
通用排序功能:将给定容器进行排序(不写reverse=True为升序排序,写reverse=True为降序排序)
sorted(容器,[reverse] = True)
注意:排序后都会得到列表(list)对象
my_list = [3, 1, 5, 2, 4]
my_tuple = (3, 1, 5, 2, 4)
my_str = "bdacge"
my_set = {3, 1, 5, 2, 4}
my_dict = {"Key3": 3, "Key1": 1, "Key5": 5, "Key2": 2, "Key4": 4}
# 升序排序
print(sorted(my_list))
print(sorted(my_tuple))
print(sorted(my_str))
print(sorted(my_set))
print(sorted(my_dict))
print("--------------------")
# 降序排序
print(sorted(my_list, reverse=True))
print(sorted(my_tuple, reverse=True))
print(sorted(my_str, reverse=True))
print(sorted(my_set, reverse=True))
print(sorted(my_dict, reverse=True))
5、容器的通用功能总览
本篇是“黑马程序员Python教程,8天学会Python(2022新版)”学习笔记,有任何问题,欢迎留言讨论~~