先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024c （备注Python）
正文
元组的下标：从前向后，下标从0开始从后向前，下标从-1开始
#方式一
变量名称 = （）
#方式二
变量名称 = tuple（）
# 定义单个元素的元组，后面必须加一个逗号，不然它的类型不是tuple而是其他
tuple = (1,)
# 元组的嵌套
t1 = ((1,'多',True),(2,'la',False))
print(type(t1))
print(t1)
# 下表索引取出内容
print(t1[0])
print(t1[0][0])
2.元组的操作：在这里插入图片描述
t1.index('梦')
tuple.count('s')
len(t1)
3.元组的遍历：
#元组的遍历: while
index = 0
while index < len(t1):
print(f"while:元组的元素有: {t1[index]}")
#至关重要
index += 1
#元组的遍历:for
for element in t1:
print(f"for:元组的元素有: {element}")
4.元组的特点：
和list基本相同（有序、任意数量元素、允许重复元素)，唯一不同在于不可修改。支持for循环
5.综合案例：
tuple = ('周小轮',22,['basketball','music'])
print(f"年龄的下标位置：{tuple.index(22)}")
print(f"学生的姓名为：{tuple[0]}")
del tuple[2][0]
tuple[2].append('coding')
print(f"tuble的内容是{tuple}")
（四）字符串
1.字符串的下标：
从前向后，下标从0开始从后向前，下标从-1开始
my_str = "itheima and itcast"
#通过下标索引取值
value = my_str[21]
value2 = my_str[-16]
print(f"从字符串{my\_str}取下标为2的元素，。值是: {value},取下标为-16的元素。值是: {value2}")
2.字符串的常用操作：
a.i查找下标
#index方法：
value = my_str.index( "and" )
print(f"在字符串{my\_str}中查找and，其起始下标是: {value}")
b.字符串替换
语法:字符串.replace(字符串1，字符串2)
功能:将字符串内的全部:字符串1，替换为字符串2
注意:不是修改字符串本身，而是得到了一个新字符串哦
#replace方法
new_my_str = my_str.replace( "it"，"程序")
print(f"将字符串{my\_str}，进行替换后得到: {new\_my\_str}")
c.字符串的分割
语法:字符串.split(分隔符字符串)
功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意:字符串本身不变，而是得到了一个列表对象
# 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)}")
d.字符串的规整
字符串的规整操作(去前后空格)语法:字符串.strip()
字符串的规整操作（去前后指定字符串)语法:字符串.strip(字符串)
# 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}")
e.统计字符串中某个字符出现的次数
my_str.count("it")
f.统计字符串长度
len(my_str)
3.字符串的遍历：
str = "itheima itcast boxuegu"
for x in str:
print(f"for循环遍历字符串{x}")
index = 0
while index<len(str):
print(f"while循环遍历字符串{str[index]}")
index+=1
4.字符串的特点：
只可以存储字符串；长度任意（取决于内存大小)；支持下标索引；允许重复字符串存在；不可以修改（增加或删除元素等)；支持for循环
5.字符串大小的比较：
字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。
6.综合案例
str = "itheima itcast boxuegu"
print(f"有{str.count('it')}个it字符")
new_str = str.replace(" ","|")
print(f"原来的字符串{str}，被替换后的字符串{new\_str}")
list = str.split("|")
print(f"字符串{str}按照 | 分割后的结果为：{list}")
（五）序列
1.定义：
内容连续、有序，可使用下标索引的一类数据容器
2.切片
从一个序列中，取出一个子序列
序列支持切片，即:列表、元组、字符串，均支持进行切片操作
3.切片的语法
语法:序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列:
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取·步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记)
#对list进行切片，从1开始，4结束，步长
list = [0,1,2,3,4,5,6]
print(list[1:4:1])
#对tuple进行切片，从头开始，到最后结束，步长1
tuple = (0,1,2,3,4,5,6)
print(tuple[::])
#对str进行切片，从头开始，到最后结束，步长2
str = '0123456'
print(str[::2])
#对str进行切片，从头开始，到最后结束，步长-1
print(str[::-1])
#对列表进行切片，从3开始，到1结束，步长-1
print(list[3:1:-1])
#对元组进行切片，从头开始，到尾结束，步长-2
print(tuple[::-2])
4.综合案例
my_str='万过薪月，员序程马黑来，nohtyP学'
start = my_str.index('员')
end = my_str.index("黑")
new_str = my_str[start:end+1:]
print(new_str[::-1])
#对比两段代码的输出语句
my_str='万过薪月，员序程马黑来，nohtyP学'
start = my_str.index('员')
end = my_str.index("黑")
print(my_str[start:end + 1:][::-1])
#通过字符串分隔
print(my_str.split("，")[1].replace("来","")[::-1])
（六）集合
1.定义语法
因为集合是无序的，所以集合不支持:下标索引访问。
2.操作
a.添加新元素
语法:集合.add(元素)。将指定元素，添加到集合内。
结果:集合本身被修改，添加了新元素。
b.移除元素
语法:集合.remove(元素)，将指定元素，从集合内移除。
结果:集合本身被修改，移除了元素。
c.随机取出元素
语法∶集合.pop()功能，从集合中随机取出一个元素。
结果:会得到一个元素的结果。同时集合本身被修改，元素被移除。
d.清空集合
集合.clear()
e.取两个集合的差集
语法∶集合1.difference(集合2)
功能:取出集合1和集合2的差集（集合1有而集合2没有的)
结果:得到一个新集合，集合1和集合2不变
f.消除两个集合的差集
语法:集合1.difference_update(集合2)
功能:对比集合1和集合2，在集合1内，删除和集合2相同的元素。
结果:集合1被修改，集合2不变
g.两个集合合并
语法:集合1.union(集合2)
功能:将集合1和集合2组合成新集合
结果:得到新集合，集合1和集合2不变
h.统计集合元素个数
语法:len（集合）
# 定义集合
set_1 = {'多','la','A','梦','多'}
# 定义空集合
set_empty = set()
print(f"set\_1的内容是{set\_1}，类型是{type(set\_1)}")
print(f"set\_empty的内容是{set\_empty}，类型是{type(set\_empty)}")
# 添加新元素
set_1.add('python')
print(f"set\_1添加后的内容是{set\_1}")
# 移除元素
set_1.remove('多')
print(f"set\_1移除后的内容是{set\_1}")
# 随机取出元素
element= set_1.pop()
print(f"随机取出的元素{element}")
print(f"set\_1随机取出后的内容是{set\_1}")
# 清空集合
set_1.clear()
print(f"set\_1清空后的内容是{set\_1}")
# 取出两个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(set3)
print(set2)
print(set1)
# 消除两个集合的差集
set1.difference_update(set2)
print(set1)
print(set2)
# 两个集合合并
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3)
print(set2)
print(set1)
# 统计集合元素个数
print(len(set2))
3.集合遍历
# 集合遍历
#集合不支持下标索引，不能用while循环，可以用于or循环
for x in set1:
print(x)
4.集合的特点
可以容纳多个数据；可以容纳不同类型的数据（混装)；数据是无序存储的（不支持下标索引)；不允许重复数据存在；
可以修改（增加或删除元素等)；支持for循环，不支持while循环
5.案例
my_list=['黑马程序员','传智播客','黑马程序员','传智播客', 'itheima', 'itcast','itheima', 'itcast','best']
my_set = set()
for x in my_list:
my_set.add(x)
print(my_set)
（七）字典
1.字典的定义
字典的定义，同样使用{ }，不过存储的元素是一个个的:键值对，如下语法:
#定义字典
my_dict1 = {'王':99,'林':88,'周':99}
#定义空字典
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_dict4 = {'王':99,'王':88}
print(f"字典4重复key的内容是：{my\_dict4}")
#从字典中基于Key获取Value
print(my_dict1['王'])
#定义嵌套字典
subject = {
'王':{
'语文':77,
'数学':66,
'英语':33
},'周':{
'语文': 88,
'数学': 86,
'英语': 55
},'林':{
'语文': 99,
'数学': 96,
'英语': 66
}
}
# 从嵌套字典中获取数据
print(f"学生的考试信息：{subject}")
print(subject['王']['语文'])
2.为什么使用字典？
字典可以提供基于Key检索Value的场景实现
3.注意事项
键值对的Key和Value可以是任意类型(Key不可为字典)
字典内Key不允许重复，重复添加等同于覆盖原有数据
字典不可用下标索引，而是通过Key检索Value
4.字典的操作
a.新增元素：
语法:字典[Key]= Value，
结果:字典被修改，新增了元素
#新增元素
my_dict1['张']=100
print(my_dict1)
b.更新元素：
语法:字典[Key] = value
结果:字典被修改，元素被更新
注意:字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
#更新元素
my_dict1['林']=33
print(my_dict1)
c.删除元素
语法:字典pop(Key)
结果:获得指定Key的Value，同时字典被修改，指定Key的数据被删除
#删除元素
score = my_dict1.pop('周')
print(f"周的分数{score}，字典中的内容{my\_dict1}")
d.清空元素
#清空元素
my_dict1.clear()
print(f"字典被清空了{my\_dict1}")
e.获取全部的key
语法:字典.keys
结果:得到字典中的全部Key
#获取全部的key
my_dict1 = {'王':99,'林':88,'周':99}
print(my_dict1.keys())
f.遍历字典
#遍历字典
# 方式一
for key in my_dict1.keys():
print(f"字典的key是{key}")
print(f"字典的value是{my\_dict1[key]}")
# 方式二
for key in my_dict1:
print(f"字典的key是{key}")
print(f"字典的value是{my\_dict1[key]}")
g.统计字典的元素数量
#统计字典内的元素数量
print(len(my_dict1))
5.字典的特点：
可以容纳多个数据；可以容纳不同类型的；数据每一份数据是KeyValue键值对；可以通过Key获取到Value，Key不可重复（重复会覆盖)；不支持下标索引；可以修改（增加或删除更新元素等)；支持for循环，不支持while循环
6.综合案例：
dict = {
'王':{
'部门':'科技部',
'工资':3000,
'级别':1
},'周':{
'部门':'市场部',
'工资':5000,
'级别':2
},'林':{
'部门':'市场部',
'工资':7000,
'级别':3
},'张':{
'部门':'科技部',
'工资':4000,
'级别':1
},'':{
'部门':'市场部',
'工资':6000,
'级别':2
}
}
print(f"全体员工当前信息：{dict}")
for employee in dict:
if dict[employee]['级别'] == 1:
dict[employee]['级别'] += 1
dict[employee]['工资'] += 1000
print(f"全体员工级别为1的员工完成升职加薪操作后：{dict}")
（八）数据容器的比较
1.比较
2.通用操作
－ 第六章
（一）函数的多返回值
#演示使用多个变量，接收多个返回值
def test\_return():
return 1,"hello", True
x,y.z.= test_return()
print(x)
print(y)
print(z)
（二）函数多种传递方式
1.函数有4中常见参数使用方式:
位置参数；关键字参数；缺省参数；不定长参数
a.位置参数:调用函数时根据函数定义的参数位置来传递参数。
注意：传递的参数和定义的参数的顺序及个数必须一致
def user\_info(name ,age,gender):
print(f"名字是{name}，年龄是{age}，性别是{gender}")
user_info('韩一',18,'男')
b.关键字参数:函数调用时通过“键=值”形式传递参数.
作用:可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求.
注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
def user\_info(name ,age,gender):
print(f"名字是{name}，年龄是{age}，性别是{gender}")
user_info(name='韩二',age=19,gender='男')
user_info("韩三",age=20,gender='女')
c.缺省参数:缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意:
所有位置参数必须出现在默认参数前，包括函数定义和调用，默认值参数在最后。）
作用:当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值.
注意：函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值
def user\_info( age,name='null',gender='男'):
print(f"名字是{name}，年龄是{age}，性别是{gender}")
user_info('韩四',18)
user_info('韩四',18,'女')
d.不定长参数:不定长参数也叫可变参数．用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。
作用:当调用函数时不确定参数个数时，可以使用不定长参数。
不定长参数的类型：位置传递；关键字传递
#不定长-位置不定长，\*号
#传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，
# args是元组类型，这就是位置传递
def user\_info(\*args):
print(f"args参数的类型是{type(args)},内容是{args}")
user_info('小李',18)
#不定长-关键字不定长，\*\*号
# 参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，
# 同时会根据“键=值”组成字典.
def user\_info(\*\*kwargs):
print(f"args参数的类型是{type(kwargs)},内容是{kwargs}")
user_info(name='小李',age = 18)
（三）函数作为参数传递
1.函数本身是可以作为参数，传入另一个函数中进行使用的。
2.将函数传入的作用在于:传入计算逻辑，而非传入数据。
#定义一个函数，接收另一个函数作为传入参数
def fun\_test(computer):
result =computer (1,2)#确定computer是函数
print(f"computer的类型是{type(computer)},结果是{result}")
#定义一个函数，准备作为参数传入另一个函数
def add(x,y):
return x+y
fun_test(add)
（四）lambda匿名函数
1.语法：
lambda 传入参数: 函数体(一行代码)
lambda是关键字，表示定义匿名函数；传入参数表示匿名函数的形式参数，如:x, y表示接收2个形式参数；函数体，就是函数的执行逻辑，要注意:冲只能写一行，无法写多行代码。
2.注意：
匿名函数用于临时构建一个函数，只用一次的场景；匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数
#定义一个函数，接受其它函数输入
def test\_function(compute):
result = compute(1,2)
print(f"结果是{result}")
#通过lambda匿名函数的形式，将匿名函数作为参数传入
test_function(lambda x,y: x\*y)
－ 第七章
（一）文件编码
1.什么是编码？
编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。编码有许多中，我们最常用的是UTF-8编码。
2.为什么需要使用编码
计算机只认识O和1，所以需要将内容翻译成0和1才能保存在计算机中。同时也需要编码，将计算机保存的O和1，反向翻译回可以识别的内容。
（二）文件的读取操作
1.文件：
可以分为：文本文件、视频文件、音频文件、图像文件、可执行文件等多种类别。
2.文件的操作
打开、关闭、读写
3.文件的操作步骤：
打开文件、读写文件、关闭文件
4.打开文件
open打开函数：open(name, mode, encoding)
name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
mode:设置打开文件的模式(访问模式):只读、写入、追加等。
encoding:编码格式（推荐使用UTF-8)
mode常用的三种基础访问模式
5.读操作相关方法：
a.read( )方法：文件对象.read（num)
num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。
b.readlines()方法
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
c.readline（）方法
一次读取一行内容
d.for循环读取文件行
e.关闭文件对象
f.with open
通过在with open的语句块中对文件进行操作；可以在操作完成后自动关闭close文件，避免遗忘掉close方法
#打开文件
f = open("E:/ceshi.txt","r",encoding="UTF-8")
print(type(f))
#读取文件- read()
print(f.read(1))
print(f.read())
print("------")
#读取文件- readLines()
lines = f.readlines()
print(f"lines对象的类型是{type(lines)}")
print(lines)
#读取文件- readline()
line1 = f.readline()
line2 = f.readline()
line3 = f.readline()
print(f"第一行的内容{line1}")
print(f"第二行的内容{line2}")
print(f"第三行的内容{line3}")
# for循环读取文件行
for line in f:
print(f"每一行的内容是{line}")
#文件的关闭
f.close()
#with open语法操作文件
with open as f:
for line in f:
print(f"每一行的内容是{line}")
6.小练习
f = open("E:/word.txt","r",encoding="UTF-8")
count = 0
# 方法一
str=f.read()
print(str.count("itheima"))
# 方法二
for line in f:
line = line.strip() #去除前后的空格和换行符
words = line.split(" ")
for word in words:
if word =="itheima":
count+=1
print(count)
# 关闭文件
f.close()
（三）文件的写入
1.注意
直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区；当调用flush的时候+内容会真正写入文件；这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写磁盘)
w模式，文件不存在，会创建新文件w模式，文件存在，会清空原有内容close()方法，带有flush()方法的功能。
"""
演示文件的写入
"""
#打开文件，（不存在的文件，会自动创建）
f= open("E:/word.txt","w",encoding="UTF-8")
# write写入
f.write("hello") #内容写到内存中
#flush刷新
f.flush()#将内存积攒的内容写到硬盘的文件中
#close关闭，close方法内置了flush功能
f.close()
#打开一个存在的文件
#write写入、flush刷新
#close关闭
（四）文件的追加
1.追加写入文件使用open函数的"a”模式进行写入
2.追加写入的方法有（和w模式一致)∶wirte()，写入内容； flush()，刷新内容到硬盘中
3.注意事项:
a模式，文件不存在，会创建新文件；a模式，文件存在，会在原有内容后面继续写入；可以使用”\n”来写出换行符
"""
演示文件的追加
"""
#打开文件，（不存在的文件，会自动创建）
f= open("E:/word.txt","a",encoding="UTF-8")
# write写入
f.write("hsz") #内容写到内存中
#flush刷新
f.flush()#将内存积攒的内容写到硬盘的文件中
#close关闭，close方法内置了flush功能
f.close()
（五）综合案例
"""
文件备份
"""
# 读取文件
fr = open("E:/bill.txt","r",encoding="UTF-8")
# 写入文件
fw = open("E:/bill.txt.bak","w",encoding="UTF-8")
# for循环读取文件
for line in fr:
line.strip()
# 判断内容，将满足的内容写出
if line.split(",")[4] =="测试":
continue #进入下一次循环
# 将内容写出去
fw.write(line)
# 由于前面内容进行了strip()的操作，所以要手动的写出换行符
fw.write("\n")
fr.close()
fw.close()
－ 第八章
（一）异常
1.什么是异常？
异常就是程序运行的过程中出现了错误。
2.捕获异常
a.基本语法
try：
可能发生错误的代码
except[异常 as 别名:]：
如果出现异常，执行的代码
[else:]
未出现异常时执行的代码
[finally:]
不管有没有异常都会执行
#捕获指定的异常
try:
print(name)
except NameError as e :
print("出现了变量未定义的异常")
print(e)
#捕获多个异常
try:
# print(name)
1/0
except(NameError,ZeroDivisionError) as e:
print("出现了变量未定义或者除以0的异常错误")
#捕获所有异常
try:
1/0
except Exception as e:
print("出现了异常")
#else异常
try:
print(1)
except Exception as e:
print(e)
else:
print("我是else，是没有异常时执行的代码")
#异常的finally不管出不出现异常都会执行
try:
print(1)
except Exception as e:
print(e)
else:
print("我是else，是没有异常时执行的代码")
finally:
print("我是finally，有没有异常我都执行")
3.异常的传递
"""
演示异常的传递性
"""
#定义一个出现异常的方法
def func1():
print( "func1开始执行")
num = 1 / 0 #肯定有异常，除以0的异常
print( "func1结束执行")
#定义一个无异常的方法调用上面的方法
def func2():
print("func2开始执行")
func1()
print("func2结束执行")
#定义一个方法，调用上面的方法
def main():
try:
func2()
except Exception as e:
print(f"出现异常,异常信息是{e}")
main()
（二）模块
1.什么是模块
Python模块(Module)，是一个Python文件，以.py结尾． 模块能定义函数，类和变量，模块里也能包含可执行的代码.
2.模块的作用
python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能.
3.模块的导入方式
[from 模块名] import [模块|类|变量|函数|\*][as 别名]
常用的组合形式如：
import 模块名
from 模块名 import 类、变量、方法等
from 模块名 import \*
import 模块名 as 别名
from 模块名 import 功能名 as 别名
"""
演示Python的模块导入
"""
#使用import导入time模块使用sleep功能（函数)
import time #导入Python 内置的time模块(time.py这个代码文件>
print("你好")
time.sleep(3)#通过.就可以使用模块内部的全部功能（类、函数、变量）
print("我好")
#使用于from导入time的sleep功能(函数)
from time import sleep
print("你好")
sleep(1)
print("我好")
#使用\*导入time模块的全部功能
from time import \* #\*表示全部
print("你好")
sleep(1)
print("我好")
#使用as给特定功能加上别名
from time import sleep as sl
print("你好")
sl(1)
print("我好")
4.注意事项
from可以省略，直接import即可
as别名可以省略
通过" . "来确定层级关系
模块的导入一般写在代码文件的开头位置
5.自定义模块
my_module1
def test(a,b):
print(a - b)
if __name__ == '\_\_main\_\_':
test(1,2)
my_module2
__all__=['test']
def test(a,b):
print(a + b)
def test2(a,b):
print(a - b)
"""
演示自定义模块
"""
#导入自定义模块的使用
# from my\_module1 import test
# test(1,1)
#导入不同模块的同名功能
# from my\_module1 import test
# from my\_module2 import test
# test(1,1)
#\_\_main变量\_\_
from my_module1 import test
#\_\_all变量\_\_
from my_module2 import \*
test(1,1)
test2(1,1)
a.__main__变量的功能是?
if main== “main”表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入
b.不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
c._all_变帚可以控制import*的时候哪些功能可以被导入
（三）python包
1.什么是python包
包就是一个文件夹，里面可以存放许多Python的模块（代码文件），通过包，在逻辑上将一批模块归为一类，方便使用。
2.init__.py文件的作业
创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹。
3.__all__变量的作用
同模块中学习到的是一个作用，控制import*能够导入的内容
4.第三方包
a.第三方包就是非Python官方内置的包，可以安装它们扩展功能，提高开发效率。
b.安装：在命令提示符内:pip install包名称pip install -i https://pypi .tuna.tsinghua.edu. cn/simple包名称
在PyCharm中安装
5.综合案例
"""
文件处理相关的模块
"""
def print\_file\_info(file_name):
"""
功能是将给定路径的文件内容输出到控制台
:param file\_name:即将被读取的文件路径
:return:None
"""
f = None
try:
f=open(file_name,"r",encoding="UTF-8")
content=f.read()
print("文件的内容如下：")
print(content)
except Exception as e:
print(f"程序出现异常，原因是：{e}")
finally:
if f: #如果变量是None，表示False，如果有任何内容，就是Ture
f.close()
def append\_to\_file(file_name,data):
"""
功能是将指定的数据追加到指定的文件中
:param file\_name:指定的文件路径
:param data:指定的数据
:return:None
"""
f=open(file_name,"a",encoding="UTF-8")
f.write(data)
f.write("\n")
f.close()
print()
if __name__ == '\_\_main\_\_':
print_file_info("F:/a.txt")
append_to_file("F:/a.txt","黑马程序员")
"""
字符串相关的工具模块
"""
def str\_reverse(s):
"""
功能是将字符串完成反转操作
:param s:被反转的字符串
:return:反转后的字符串
"""
return s[::-1]
def substr(s,x,y):
"""
功能是按照给定的下标完成给定的字符串的切片
:param s:即将被切片的字符串
:param x:切片的开始下标
:param y:切片的结束下标
:return:切片完成后的字符串
"""
return s[x:y:1]
if __name__ == '\_\_main\_\_':
print(str_reverse("黑马程序员"))
print(substr("黑马程序员",1,3))
－ 第九章
（一）Json数据格式
1.什么是Json
JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据
JSON本质上是一个带有特定格式的字符串
2.Json转换
"""
演示JSON数据和Python字典的相互转换
"""
import json
#准备列表，列表内每一个元素都是字典，将其转换为JSON
data = [{"name":"张三","age":18},{"name":"李四","age":11},{"name":"王五","age":14}]
json_str = json.dumps(data,ensure_ascii=False)
print(type(json_str))
print(json_str)
#准备字典，将字典转换为JSON
d = {"name":"周杰伦","addr":"中国"}
json_str = json.dumps(d,ensure_ascii=False)
print(type(json_str))
print(json_str)
#将JSON字符串转换为Python数据类型[{k: v, k: v}，{k: v, k: v}]
s = '[{"name": "张三", "age": 18}, {"name": "李四", "age": 11}, {"name": "王五", "age": 14}]'
l = json.loads(s)
print(type(l))
print(l)
#将JSON字符串转换为Python数据类型{k: v, k: v}
str = '{"name": "周杰伦", "addr": "中国"}'
d = json.loads(str)
print(type(d))
print(d)
（二）pyecharts
1.配置选项
全局配置选项，系列配置选项
2.全局配置选项能做什么
配置图表的标题、配置图例、配置鼠标移动效果、配置工具栏等整体配置项
"""
演示pyecharts的基础入门
"""
#导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
#创建一个折线图对象
line = Line()
#给折线图对象添加x轴的数据
line.add_xaxis(["中国","美国","日本"])
#给折线图对象添加y轴的数据
line.add_yaxis("GDP",[30,20,10])
#设置全局配置项set\_global\_opts设置
line.set_global_opts(
title_opts=TitleOpts(title="GDP展示",pos_left="center",pos_bottom="1%"),
legend_opts=LegendOpts(is_show=True),
toolbox_opts=ToolboxOpts(is_show=True),
visualmap_opts=VisualMapOpts(is_show=True)
)
#通过render方法，将代码生成图像
line.render()
（三）地图
"""
演示地图可视化的基本使用
"""
from pyecharts.charts import Map
#准备地图对象
map = Map()
#准备数据
data = [
("北京",99),
("上海",199),
("山西",299),
("天津",399),
("广东",499)
]
#添加数据
map.add("测试地图",data,"china")
#绘图
map.render()
#设置全局选项
（四）柱状图
"""
演示基础柱状图的开发
"""
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
#使用Bar构建基础柱状图
bar = Bar()
#添加x轴数据
bar.add_xaxis(["太原","阳泉","晋中"])
#添加y轴数据
bar.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))
#反转x轴和y轴
bar.reversal_axis()
bar.render()
#设置数值标签在右侧
"""
演示时间线柱状图的开发
"""
from pyecharts.charts import Bar,Timeline
from pyecharts.options import LabelOpts
#使用Bar构建基础柱状图
bar1 = Bar()
bar2 = Bar()
#添加x轴数据
bar1.add_xaxis(["太原","阳泉","晋中"])
bar2.add_xaxis(["太原","阳泉","晋中"])
#添加y轴数据
bar1.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))
bar2.add_yaxis("GDP",[40,30,20],label_opts=LabelOpts(position="right"))
#反转x轴和y轴
bar1.reversal_axis()
bar2.reversal_axis()
#创建时间线对象
timeline = Timeline({"theme":ThemeType.LIGHT})
#timeline对象添加bar柱状图
timeline.add(bar1,"2021")
timeline.add(bar2,"2022")
#自动播放设置
timeline.add_schema(
play_interval=1000,
is_timeline_show=True,
is_auto_play=True,
is_loop_play=True
)
timeline.render()
四、python进阶
-第一章
（一）面向对象
1.初识对象
# 1．设计一个类（类比生活中:设计一张登记表)
class Student:
name = None
gender = None
age = None
#2．创建一个对象（类比生活中:打印一张登记表)
stu_1 = Student()
#3.对象属性进行赋值（类比生活中:填写表单)
stu_1.name = "张三"
stu_1.gender = "男"
stu_1.age = 18
#4．获取对象中记录的信息
print(stu_1.name,stu_1.gender,stu_1.age)
2.成员方法
self 的作用：表示类对象本身的意思；只有通过self，成员方法才能访问类的成员变量；self出现在形参列表中，但是不占用参数位置，无需理会。
"""
演示面向对象类中的成员方法定义和使用
"""
#定义一个带有成员方法的类
class Student:
name = None
gender = None
age = None
def say\_hi(self):
print(f"hi~~,我是{self.name}")
def say\_hi2(self,msg):
print(f"hi~~,我是{self.name},{msg}")
stu_1 = Student()
stu_1.name = "张三"
stu_1.gender = "男"
stu_1.age = 18
stu_1.say_hi()
stu_2 = Student()
stu_2.name = "李四"
stu_2.say_hi()
stu_2.say_hi2("真不错小伙子！！")
3.类和对象
"""
演示类和对象的关系，即面向对象的编程套路（思想)
"""
#设计一个闹钟类
class Clock:
id = None #序列号
price = None #价格
def ring(self):
import winsound
winsound.Beep(2000,3000)
#构建2个闹钟对象并让其工作
clock_1 = Clock()
clock_1.id = "00232"
clock_1.price = 19.9
print(f"闹钟的序列号是{clock\_1.id}，闹钟的价格是{clock\_1.price}")
clock_1.ring()
4.构造方法
a.构造方法的作用：
构建类对象的时候会自动运行；构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值。
b.注意事项
构造方法不要忘记self关键字；在方法内使用成员变量需要使用self。
Python类可以使用:_init_()方法，称之为构造方法。
在创建类对象（构造类）的时候，会自动执行。
在创建类对象（构造类）的时候，将传入参数自动传递给_init_方法使用。
"""
演示类的构造方法
"""
#演示使用构造方法对成员变量进行赋值
# #构造方法的名称: \_\_init\_\_
class Student:
"""
可省略
name = None
age = None
tel = None
"""
def \_\_init\_\_(self,name,age,tel):
self.name = name
self.age = age
self.tel = tel
print("Student类创建了一个类对象")
stu = Student("张三",18,"198")
print(stu.name,stu.age,stu.tel)
5.魔术方法
#字符串方法
class Student:
def \_\_init\_\_(self,name,age):
self.name = name
self.age = age
def \_\_str\_\_(self):
return f"Student类对象，name:{self.name},age:{self.age}"
stu = Student("张三",18)
print(stu)
#lt方法
class Student:
def \_\_init\_\_(self,name,age):
self.name = name
self.age = age
def \_\_lt\_\_(self, other):
return self.age<other.age
stu1 = Student("张三",18)
stu2 = Student("李四",19)
print(stu1<stu2)
#le方法
class Student:
def \_\_init\_\_(self,name,age):
self.name = name
self.age = age
def \_\_le\_\_(self, other):
return self.age<other.age
stu1 = Student("张三",20)
stu2 = Student("李四",19)
stu3 = Student("王五",19)
print(stu2<=stu3)
#eq方法
class Student:
def \_\_init\_\_(self,name,age):
self.name = name
self.age = age
def \_\_eq\_\_(self, other):
return self.age<other.age
stu1 = Student("张三",20)
stu2 = Student("李四",19)
stu3 = Student("王五",19)
print(stu2==stu3)
6.封装
a.封装的概念：将现实世界事物在类中描述为属性和方法，即为封装。
b.什么是私有成员?为什么需要私有成员?
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述属性和方法的时候也需要达到这个要求，就需要定义私有成员了
c.如何定义私有成员
成员变量和成员方法的命名均以__作为开头即可
d.私有成员的访问限制
类对象无法访问私有成员；类中的其他成员可以访问私有成员
"""
演示面向对象封装思想中私有成员的使用"l n1
"""
#定义一个类，内含私有成员变量和私有成员方法
class Phone:
__current_voltage = 1 #当前手机运行电压
def \_\_keep\_single\_core(self):
print("让CPU单核运行")
def call\_by\_5G(self):
if self.__current_voltage >=1:
print("5G通话已开启")
else:
self.__keep_single_core()
print("电量不足无法使用5G，已切换为单核")
phone = Phone()
# phone.\_keep\_single\_core()
phone.call_by_5G()
#练习题
class Phone:
__is_5G_enable = True
def \_\_check\_5G(self):
if self.__is_5G_enable :
print("5G开启")
else:
print("5G关闭，使用4G网络")
def call\_by\_5G(self):
self.__check_5G()
print("正在通话中")
phone = Phone()
phone.call_by_5G()
7.继承
单继承:一个类继承另一个类
多继承:一个类继承多个类，按照顺序从左向右依次继承
多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承
paas的关键字作用：pass是占位语句用来保证函数（方法）或类定义的完整性，表示无内容，空的意思
"""
演示面向对象:继承的基础语法
"""
#演示单继承
class Phone:
IMEI = None #序列号
producer = "iphone"
def call\_by\_4g(self):
print("4g通话")
class Phone2023(Phone):
faceId ="1000" #面部识别id
def call\_by\_5g(self):
print("5g通话")
phone = Phone2023()
phone.call_by_4g()
print(phone.producer)
#演示多继承
class NFCReader:
nfc_type = "第五代"
producer = "iphone"
def read\_card(self):
print("NFC读卡")
def write\_card(self):
print("NFC写卡")
class RemoteControl:
rc_type = "红外遥控器"
def control(self):
print("红外遥控开启了")
class Myphone(Phone,NFCReader,RemoteControl):
pass
print("++++++++++++++")
my_phone = Myphone()
my_phone.call_by_4g()
my_phone.read_card()
my_phone.write_card()
my_phone.control()
8.继承中的复写
a.复写表示：对父类的成员属性或成员方法进行重新定义
b.复写语法：在子类中重新实现同名成员方法或成员属性即可
c.在子类中调用父类成员
方式一：
使用成员变量:父类名.成员变量
使用成员方法:父类名.成员方法(self)
方式二：
使用super()
使用成员变量: super().成员变量
使用成员方法: super().成员方法()
９.变量的类型注解
a.类型注解支持:
变量的类型注解;函数（方法）的形参和返回值的类型注解
b.类型注解只是提示性的，并非决定性的。数据类型和注解类型无法对应也不会导致错误
"""
演示变量的类型注解
"""
import json
import random
#基础数据类型注解
var_1:int = 10
var_2:str = "itheima"
var_3:bool = True
#类对象类型注解
class Student:
pass
stu:Student = Student()
#基础容器类型注解
my_list:list = [1,2,3]
my_tuple:tuple(1,2,3)
my_dict:dict = {"itheima":666}
#容器类型详细注解
my_list:list[int] = [1,2,3]
my_tuple:tuple[int,str,bool](1,"itheima",True)
my_dict:dict[str,int] = {"itheima":666}
#在注释中进行类型注解
var_4 = random.randint(1,10) #type:int
var_5 = json.loads('{"name:zhangsan"}') #type:dict[str,str]
def func():
return 10
var_6 = func() #type:int
#类型注解的限制
var_7:int = "itheima"
var_8:str = 1
10.函数类型注解
a.函数（方法）可以为哪里添加注解?
形参的类型注解；返回值的类型注解
"""
演示对两数(方法)进行类型注解
"""
#对形参进行类型注解
def add(a:int,b:int):
return a+b
add(1,2)
#对返回值进行类型注解
def func(data:list) -> list:
return data
11.Union类型
"""
演示Union联合类型注解
"""
#使用Union类型，必须先导包
from typing import Union
my_list: list[Union[int,str]] = [1,2,"itheima","itcast"]
def func(data: Union[int,str]) -> Union[int, str]:
pass
func()
12.多态
a.多态指的是，同一个行为，使用不同的对象获得不同的状态。
b.包含抽象方法的类，称之为抽象类。抽象方法是指:没有具体实现的方法(pass)称之为抽象方法。
c.抽象类的作用:
多用于做顶层设计（设计标准)，以便子类做具体实现。
也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法
并配合多态使用，获得不同的工作状态。
"""
演示面向对象的多态特性以及抽象类(接口）的使用
"""
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
def make\_noise(animal: Animal):
"""制造噪音，需要传入Animal对象"""
animal.speak()
#演示多态，使用2个子类对象来调用函数
dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)
print("-----------------")
#演示抽象类
class AC:
def cool\_wind(self):
"""制冷"""
pass
def hot\_wind(self):
"""制热"""
pass
def swing\_l\_r(self):
"""左右摆风"""
pass
class Midea\_AC(AC):
def cool\_wind(self):
print("美的制冷")
def hot\_wind(self):
print("美的制热")
def swing\_l\_r(self):
print("美的左右摆风")
class Gree\_AC(AC):
def cool\_wind(self):
print("格力制冷")
def hot\_wind(self):
print("格力制热")
def swing\_l\_r(self):
print("格力左右摆风")
def make\_cool(ac:AC):
ac.cool_wind()
gree = Gree_AC()
meidea = Midea_AC()
make_cool(gree)
make_cool(meidea)
法()
９.变量的类型注解
a.类型注解支持:
文末有福利领取哦~
👉一、Python所有方向的学习路线
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
👉二、Python必备开发工具
👉三、Python视频合集
观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
👉 四、实战案例
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。（文末领读者福利）
👉五、Python练习题
检查学习结果。
👉六、面试资料
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
def hot_wind(self):
print(“美的制热”)
def swing_l_r(self):
print(“美的左右摆风”)
class Gree_AC(AC):
def cool_wind(self):
print(“格力制冷”)
def hot_wind(self):
print(“格力制热”)
def swing_l_r(self):
print(“格力左右摆风”)
def make_cool(ac:AC):
ac.cool_wind()
gree = Gree_AC()
meidea = Midea_AC()
make_cool(gree)
make_cool(meidea)
法()
##### ９.变量的类型注解
a.类型注解支持:
文末有福利领取哦~
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
👉**一、Python所有方向的学习路线**
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
👉**二、Python必备开发工具**
👉**三、Python视频合集**
观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
👉 **四、实战案例**
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。**（文末领读者福利）**
👉**五、Python练习题**
检查学习结果。
👉**六、面试资料**
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）**
[外链图片转存中...(img-CsxK02Ec-1713108157827)]
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
