python课程学习
【1.5.1 数据容器介绍】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=62&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素；每一个元素可以是任意类型的数据，如字符串、数字、布尔等；
可以划分为：list, tuple, str, set, dict
【1.5.2 列表的定义】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=63&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
列表的定义语法
元素：数据容器内的每一份数据，都称之为元素；元素的类型没有限制
# 案例演示：使用[]的方式定义列表name_list= ['itheima', 'itcast', 'python']
print(name_list)
print(type(name_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.5.3 列表下表索引】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=64&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
# 通过下表索引取出对应位置的数据my_list= ['Tom', 'Lily', 'Rose']
# 列表[下标索引]，从前向后从0开始，每次+1， 从后向前从-1开始，每次-1print(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.5.4 列表常用操作】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=65&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
列表的方法
列表的特点
mylist= ['itcast', 'itheima', '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. 在列表的尾部追加'''单个'''新元素 ///列表.append(元素)mylist.append("黑马程序员")
print(f"列表追加新的元素后的结果是：{mylist}")
# 5. 在列表的尾部追加'''一批'''新元素 列表.extend(其他数据容器)mylist2= [1,2,3]
mylist.extend(mylist2)
print(f"列表追加一批新的元素后的结果是：{mylist}")
# 6. 删除指定下标索引的元素(2种方式)# 6.1 方式1: del 列表[下标]mylist= ['itcast', 'itheima', 'python']
delmylist[2]
print(f"列表删除元素后的结果是：{mylist}")
# 6.2 方式2: 列表.pop(下标)mylist= ['itcast' , 'itheima', 'python']
elment=mylist.pop(2)
print(f"列表删除元素后的结果是：{mylist},取出的元素是：{elment}")
# 7. 删除某元素在列表中的第一个匹配项 列表.remove(元素)mylist= ['itcast' , 'itheima', 'itcast' , 'itheima','python']
mylist.remove('itheima')
print(f"列表通过remove方法一处元素后的结果是：{mylist}")
# 8. 清空列表 列表.clear()mylist= ['itcast' , 'itheima', 'itcast' , 'itheima','python']
mylist.clear()
print(f"列表被清空后的结果是：{mylist}")
# 9. 统计列表内某元素的数量mylist= ['itcast' , 'itheima', 'itcast' , 'itheima','python']
count=mylist.count('itheima')
print(f"列表中itheima的数量是：{count}个")
# 10. 统计列表中全部的元素数量 len()mylist= ['itcast' , 'itheima', 'itcast' , 'itheima','python']
cuont=len(mylist)
print(f"列表中总共的元素数量是：{count}个")
【1.5.5 列表练习】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=66&vd_source=8d5bc5d755d146032fa4f38d45db2f92
# 1. 定义这个列表，并用变量去接收它my_list= [21,25,21,23,22,20]
# 2. 追加一个数字31到列表的尾部my_list.append(31)
print(my_list)
# 3. 追加一个新列表[29,33,30]到列表的尾部my_list.extend([29,33,30])
print(my_list)
# 4. 取出第一个元素(应是：21)elment=my_list[0]
print(elment)
# 5. 取出最后一个元素(应是：30)elment=my_list[-1]
print(elment)
# 6. 查找元素31在列表中的下标位置index=my_list.index(31)
print(index)
【1.5.6 列表的循环遍历】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=67&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
使用while循环，遍历列表的元素
使用for循环，遍历列表的元素
deflist_while_func():
""" 使用while循环遍历列表的演示函数 :return: None """my_list= ["传智教育", "黑马程序员", "Python"]
# 循环控制变量通过下标索引来控制，默认0# 每一次循环将下标索引变量+1# 循环条件：下标索引变量 < 列表的元素数量
# 定义一个变量用来标记列表的下标index=0# 初始值为0whileindex<len(my_list):
# 通过index变量取出相应下标的元素element=my_list[index]
print(f"列表的元素:{element}")
# 至关重要！！！ 将循环变量(index)每一次循环都+1index+=1
list_while_func()
deflist_for_func():
""" 使用for循环遍历列表的演示函数 :return: None """my_list= [1,2,3,4,5]
foriinmy_list:
print(f"列表的元素:{i}")
list_for_func()
# 课后练习deflist_while_func():
my_list= [1,2,3,4,5,6,7,8,9,10]
index=0whileindex<len(my_list):
ifmy_list[index] %2==0:
element=my_list[index]
print(f"通过while循环，取出偶数的新列表元素:{element}")
index+=1
list_while_func()
deflist_for_func():
my_list= [1,2,3,4,5,6,7,8,9,10]
foriinmy_list:
ifmy_list[i] %2==0:
print(f"通过for循环，取出偶数的新列表元素:{i}")
list_for_func()
【1.5.7 元组的定义和操作】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=68&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
元组的定义格式
使用小括号，且使用逗号隔开每个数据，数据可以是不同的数据类型
元组的特点
元组的常见操作
# 定义元组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}")
# 元组的嵌套t5= ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")
# 下标索引取出内容print(t5[1][2])
# 元组的操作：index查找方法t6= ("传智教育", "黑马程序员", "Python")
index=t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员，下标是：{index}")
# 元组的操作：count统计方法t7= ("传智教育", "黑马程序员","黑马程序员","黑马程序员", "Python")
num=t7.count("黑马程序员")
print(f"在元组t7中有{num}个黑马程序员")
# 元组的操作：len函数统计元组元素数量t8= ("传智教育", "黑马程序员","黑马程序员","黑马程序员", "Python")
num=len(t8)
print(f"在元组t8中共有{num}个元素")
# 元组的遍历：whilet8= ("传智教育", "黑马程序员","黑马程序员","黑马程序员", "Python")
index=0whileindex<len(t8):
print(f"元组的元素:{t8[index]}")
# 至关重要index+=1
# 元组的遍历：fort8= ("传智教育", "黑马程序员","黑马程序员","黑马程序员", "Python")
foriint8:
print(f"元组的元素:{i}")
# 修改元组内容# t8[0]="itcast" # 不可修改，否则会报错 TypeError: 'tuple' object does not support item assignment# 可以修改元组内的list的内容（修改元素、增加、删除、反转等）t1= (1,2,["itheima","itcast"])
t1[2][1]="best"print(t1)
# 课后练习t1= ("周杰伦",11,["football", "music"])
# 1. 查询年龄所在的下标位置index=t1.index(11)
print(index)
# 2. 查询学生的姓名name=t1[0]
print(name)
# 3. 删除学生爱好中的footballdelt1[2][0]
print(t1)
# 4. 增加爱好：coding到爱好list内t1= ("周杰伦",11,["football", "music"])
print(t1[2].append("coding"))
【问题标记】
# 4. 增加爱好：coding到爱好list内
t1 = ("周杰伦",11,["football", "music"])
print(t1[2].append("coding"))
返回值是none
【1.5.8 字符串的定义和操作】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=69&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
字符串可以看作是字符的容器，支持下标索引等特性
常用操作
特点
my_str="itheima and itcast"# 通过下标索引取值value=my_str[2]
value2=my_str[-16]
print(f"从字符串{my_str}去下标为2的元素，值是：{value}\n从字符串{my_str}去下标为-16的元素，值是：{value2} ")
# index方法my_str="itheima and itcast"value=my_str.index("and")
print(f"从字符串{my_str}中查找and，其起始下标是：{value}）
# replace方法#语法：字符串.replace(字符串1, 字符串2)my_str="itheima and itcast"new_str=my_str.replace("it","程序")
print(new_str)
# split方法# 语法：字符串.split(分割字符串)；将字符串划分为多个字符串，并存在列表对象中 my_str="hello python itheima itcast"my_str_list=my_str.split(" ")
print(my_str_list)
# strip方法(规整操作)# 语法1 (去前后空格)：字符串.strip()my_str=" itheima and itcast "print(my_str.strip())
# 语法2 (去前后指定字符串)：字符串.strip(字符串)my_str="12itheima and itcast21"print(my_str.strip("12")) # 传入的是“12”，其实就是“1”和“2”都会被移除，是按照单个字符
# 统计字符串中某字符串的出现次数my_str="itheima and itcast"print(my_str.count("it"))
# 统计字符串的长度my_str="itheima and itcast"print(len(my_str))
【1.5.9 序列切片】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=71&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
什么是序列
内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列
掌握序列的切片操作
# 语法：序列[起始下标：结束下标：步长]
# 对list进行切片，从1开始，4结束，步长1my_list= [0,1,2,3,4,5,6]
result1=my_list[1:4] # 步长默认是1，可以省略不写print(reslut1)
# 对tuple进行切片，从头开始，到最后结束，步长1my_tuple= (0,1,2,3,4,5,6)
result2=my_tuple[:] # 起始和结束不写表示从头到尾，步长为1可以省略print(reslut2)
# 对str进行切片，从头开始，到最后结束，步长2my_str="0123456"result3=my_str[::2]
print(reslut3)
# 对str进行切片，从头开始，到最后结束，步长-1my_str="0123456"result4=my_str[::-1]
print(reslut4)
# 对列表进行切片，从3开始，到1结束，步长-1my_str="0123456"result5=my_str[3:1:-1]
print(reslut5)
# 对元组进行切片，从头开始，到尾结束，步长-2my_tuple= (0,1,2,3,4,5,6)
result6=my_tuple[::-2]
print(reslut6)
【1.5.10 集合-了解即可】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=73&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
常用功能
特点
# 基本语法# 定义集合字面量{元素,元素,......,元素}
# 定义集合变量变量名称= {元素,元素,......,元素}
# 定义空集合变量名称=set{}
# 定义集合 (集合不允许重复,内容无需，不支持下标索引访问，但允许修改)my_set= {"传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima"}
my_set_empty=set()
print(my_set)
print(my_set_empty)
# 添加新元素 my_set.add("Python")
my_set.add("传智教育")
print(my_set)
# 移除元素my_set.remove("黑马程序员")
print(my_set)
# 随机取出一个元素my_set= {"传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima"}
element=my_set.pop()
print(my_set)
# 清空集合my_set.clear()
# 取2个集合的差集 # 语法：集合1.difference(集合2)，# 功能：取出集合1和集合2的差集（集合1有而集合2没有的）# 结果：得到一个新集合，集合1和集合2不变set1= {1,2,3}
set2= {1,5,6}
set3=set1.difference(set2)
print(set3)
print(set2)
print(set1)
# 消除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)
print(set2)
# 2个集合合并为1个# 语法：集合1.union(集合2)# 功能：将集合1和集合2组合称新集合# 结果：得到新集合，集合1和集合2不变set1= {1,2,3}
set2= {1,5,6}
set3=set1.union(set2)
print(set3)
print(set2)
print(set1)
# 统计集合元素数量set1= {1,2,3,4,5,1,2,3,4,5}
num=len(set1)
print(num)
# 集合的遍历# 集合不支持下标索引，不能用while循环，可以用for循环 set1= {1,2,3,4,5}
foriinset1:
print(i)
【1.5.11 字典的定义】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=75&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
为什么使用字典：字典可以提供基于key检索value的场景实现
字典的定义语法
字典的注意事项
# 定义字典my_dict1= {"王力宏":99, "周杰伦":88, "林俊杰":77}
# 定义空字典my_dict2= {}
my_dict3=dict()
# 定义重复key的字典my_dict1= {"王力宏":99, "王力宏":88, "林俊杰":77}
print(my_dict1) #结果是：{"王力宏":88, "林俊杰":77} 因为字典不允许key重复，如果重复后面的会覆盖前面的
# 从字典中基于key获取valuemy_dict1= {"王力宏":99, "周杰伦":88, "林俊杰":77}
print(my_dict1["王力宏"])
# 定义嵌套字典my_dict= {
"王力宏":{
"语文":77,
"数学":66,
"英语":33 },
"周杰伦":{
"语文":88,
"数学":86,
"英语":55 },
"林俊杰":{
"语文":99,
"数学":96,
"英语":66 }
}
# 从嵌套字典中获取数据score=my_dict["周杰伦"]["语文"]
print(f"周杰伦的语文成绩是：{score}")
【1.5.12 字典的常用操作】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=76&vd_source=8d5bc5d755d146032fa4f38d45db2f92
【主要内容】
常用操作
特点
# 新增元素my_dict["张信哲"]=66print(my_dict)
# 更新元素my_dict= {"王力宏":99, "周杰伦":88, "林俊杰":77}
my_dict["周杰伦"]=33print(my_dict)
# 删除元素my_dict.pop("周杰伦")
print(my_dict)
# 清空元素my_dict.clear()
# 获取全部的keymy_dict= {"王力宏":99, "周杰伦":88, "林俊杰":77}
keys=my_dict.keys()
print(keys)
# 遍历字典# 方式1: 通过获取到全部的key来完成遍历my_dict= {"王力宏":99, "周杰伦":88, "林俊杰":77}
keys=my_dict.keys()
forkeyinkeys:
print(f"字典的key是：{key}")
print(f"字典的value是：{my_dict[key]}")
# 方式2: 直接对字典进行for循环，每一次循环都是直接的到keymy_dict= {"王力宏":99, "周杰伦":88, "林俊杰":77}
forkeyinmy_dict:
print(f"2字典的key是：{key}")
print(f"2字典的value是：{my_dict[key]}")
# 统计字典内的元素数量my_dict= {"王力宏":99, "周杰伦":88, "林俊杰":77}
num=len(my_dict)
print(f"字典有{num}个元素 ")
【1.5.13 字典课后练习】
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=77&vd_source=8d5bc5d755d146032fa4f38d45db2f92
my_dict= {
"王力宏":{
"部门":"科技部",
"工资":3000,
"级别":1 },
"周杰伦":{
"部门":"市场部",
"工资":5000,
"级别":2 },
"林俊杰":{
"部门":"市场部",
"工资":7000,
"级别":3 },
"张学友":{
"部门":"科技部",
"工资":4000,
"级别":1 },
"刘德华":{
"部门":"市场部",
"工资":6000,
"级别":2 }
}
# print(f"全体员工的信息如下：{my_dict}")
fornameinmy_dict:
ifmy_dict[name]["级别"] ==1:
my_dict[name]["级别"]=my_dict[name]["级别"] +1my_dict[name]["工资"]=my_dict[name]["工资"] +1000print(f"全体员工级别为1的员工完成升至加薪后的的信息如下：{my_dict}")
281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
