先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024c （备注Python）
正文
创建对象
haier1 = Washer()
添加实例属性
haier1.width = 500
haier1.height = 800
haier1.print_info()
haier1洗衣机的宽度是500
haier1洗衣机的⾼高度是800
在 Python 中 ,__xx__() 的函数叫做魔法方法，指的是具有特殊功能的函数
1.3.1、__init__()
思考：洗衣机的宽度高度是与生俱来的属性，可不可以在生产过程中就赋予这些属性呢？
答：理应如此
__init__方法的作用：初始化对象
定义类
class Washer():
定义初始化功能的函数
def init(self):
#添加实例属性
self.width = 500
self.height = 800
def print_info(self):
#类里面调用实例属性
print(f’洗衣机的宽度是{self.width},高度是{self.height}')
创建对象
haier1 = Washer()
haier1.print_info() # 洗衣机的宽度是500,高度是800
注意：
-
__init__()方法，在创建一个对象时默认被调用，不需要手动调用 -
__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。
1.3.2、带参数的__init__()
思考：一个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢？
答案：传参数
class Washer():
def init(self, width, height):
self.width = width
self.height = height
def print_info(self):
print(f’洗衣机的宽度是{self.width}')
print(f’洗衣机的⾼高度是{self.height}')
haier1 = Washer(10, 20)
haier1.print_info() # 洗衣机的宽度是10 洗衣机的⾼高度是20
haier2 = Washer(30, 40)
haier2.print_info() # # 洗衣机的宽度是30 洗衣机的⾼高度是40
1.3.3、__str__()
当使用 print 输出对象的时候，默认打印对象的内存地址。如果类定义了__str__方法，那么就会打印从在这个方法中 return 的数据。
class Washer():
def init(self, width, height):
self.width = width
self.height = height
def str(self):
return ‘这是海尔洗衣机的说明书’
haier1 = Washer(10, 20)
这是海尔洗衣机的说明书
print(haier1)
1.3.4、__del__()
当删除对象时，python解释器也会默认调用 __del__()方法。
class Washer():
def init(self, width, height):
self.width = width
self.height = height
def del(self):
print(f’{self}对象已经被删除’)
haier1 = Washer(10, 20)
<main.Washer object at 0x000001BDAD57F860>对象已经被删除
del haier1
面向对象重要组成部分
-
类
-
创建类
class 类名():
代码
- 创建对象
对象名 = 类名()
-
添加对象属性
-
类外面添加
对象名.属性名 = 值
- 类里面
self.属性名 = 值
-
获取对象属性
-
类外面
对象名.属性名
- 类里面
self.属性名
-
魔法方法
-
__init__()初始化 -
__str__()输出对象信息 -
__del__()删除对象时调用
===========================================================================
父类
class Father(object):
pass
子类，继承父类
class Son(Father):
pass
在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。
-
继承：一个类从另一个已有的类获得其成员的相关特性，就叫作继承！
-
派生：从一个已有的类产生一个新的类，称为派生！
很显然，继承和派生其实就是从不同的方向来描述的相同的概念而已，本质上是一样的！
-
父类：也叫作基类，就是指已有被继承的类！
-
子类：也叫作派生类或扩展类
-
扩展：在子类中增加一些自己特有的特性，就叫作扩展，没有扩展，继承也就没有意义了！
-
单继承：一个类只能继承自一个其他的类，不能继承多个类，单继承也是大多数面向对象语言的特性！
-
多继承：一个类同时继承了多个父类， （C++、Python、Java等语言都支持多继承）[注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法]
Python中的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，如下：
父类A
class A(object):
def init(self):
self.num = 1
def info_print(self):
print(self.num)
子类B
class B(A):
pass
result = B()
result.info_print() # 1
在python中，所有类默认基础object类，object类是顶级类或者基类，其他子类叫做派生类
单继承：一个类只能继承自一个其他的类，不能继承多个类。这个类会有具有父类的属性和方法。
例如：猫，狗 都属于动物，它们行为相似性高。都会吃、会睡
动物类
class Animal(object):
def eat(self):
print(“吃…”)
def sleep(self):
print(“睡…”)
def call(self):
print(“叫…”)
狗类
class Dog(Animal):
pass
猫类
class Cat(Animal):
pass
重写也叫覆盖，就是当子类成员与父类成员名字相同的时候，从父类继承下来的成员会重新定义。
子类重写父类同名方法和属性，上面的例子中Animal 的子类 Cat和Dog 继承了父类的属性和方法，但是我们狗类Dog 有自己的叫声’汪汪叫’，猫类 Cat 有自己的叫声 ‘喵喵叫’ ，这时我们需要对父类的 call() 方法进行重构：
class Animal(object):
def eat(self):
print(“吃…”)
def sleep(self):
print(“睡…”)
def call(self):
print(“叫…”)
class Dog(Animal):
def call(self):
print(“汪汪叫…”)
class Cat(Animal):
def call(self):
print(“喵喵叫…”)
Dog实例对象
dog = Dog()
dog.call() # 汪汪叫…
Cat实例对象
cat = Cat()
cat.call() # 喵喵叫…
子类和父类具有同名属性和方法，默认使用子类的同名属性和方法
思考：此时父类中的 call 方法还在不在？
答：还在，只不过是在其子类中找不到了。类方法的调用顺序，当我们在子类中重构父类的方法后，Cat 子类的实例先会在自己的类Cat中查找该方法，当找不到该方法时才会去父类Animal中查找对应的方法。
super()：调用父类属性和方法，完整写法为：super(当前类名，self).属性或方法()
class Animal(object):
def init(self,name,age):
self.name = name
self.age = age
def eat(self):
print(“吃…”)
def sleep(self):
print(“睡…”)
def call(self):
print(“叫…”)
class Dog(Animal):
def init(self,name,age,sex):
调用父类的 init 方法
super(Dog,self).init(name,age)
super().init(name,age)
self.sex = sex
class Cat(Animal):
def init(self,name,age,sex):
调用父类的 init 方法
super(Cat,self).init(name,age)
super().init(name,age)
self.sex = sex
多继承：一个类同时继承了多个父类，并且同时具有所有父类的属性和方法例如：孩子会继承父亲 和 母亲的方法
class Father(object):
pass
class Mother(object):
pass
class Child(Father,Mother):
pass
===========================================================================
定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
-
多态依赖继承
-
子类方法必须要重写父类方法
-
定义父类，并提供公共方法
-
定义子类，并重写父类方法
-
传递子类对象给调用者，可以看到不同子类执行效果不同
类具有继承关系，并且子类类型可以向上转型可看做父类类型，如果我们从 Animal 派生出 Cat 和 Dog，并且都写了一个 call() 方法，如下示例：
动物类
class Animal(object):
def init(self,name,age):
self.name = name
self.age = age
def call(self):
print(self.name,‘会叫’)
狗类继承动物类
class Dog(Animal):
def init(self,name,age,sex):
调用父类的 init 方法
super(Dog,self).init(name,age)
self.sex = sex
def call(self):
print(self.name,‘会汪汪叫’)
猫类继承动物类
class Cat(Animal):
def init(self,name,age,sex):
调用父类的 init 方法
super(Cat,self).init(name,age)
self.sex = sex
def call(self):
print(self.name,‘会喵喵叫’)
定义一个do函数
def do(all):
all.call()
创建实例
A = Animal(‘动物’,4)
C = Cat(‘猫’,2,‘男’)
D = Dog(‘狗’,2,‘女’)
for x in (A,C,D):
do(x)
‘’’
动物 会叫
猫 会喵喵叫
狗 会汪汪叫
‘’’
上述这种行为称为多态，也就是说，方法调用将作用在 all 的实际类型上。
-
C 是 Cat 类型，它实际上上拥有自己的 call() 方法以及从 Animal 继承的 call 方法，但调用 C.call() 总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。
-
传递给函数 do(all) 的参数 all 不一定是 Animal 或 Animal 的子类型。任何数据类型的实例都可以，只要它有一个 call() 的方法即可。
-
其他类不继承于 Animal，具备 call 方法也可以使用 do 函数。
-
这就是动态语言，动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。
再来看一个例子：
class Dog(object):
父类提供统一的方法,哪怕是空方法
def work(self):
print(“指哪打哪”)
class ArmyDog(Dog):
子类重写父类同名方法
def work(self):
print(“追击敌人”)
class DrugDog(Dog):
子类重写父类同名方法
def work(self):
print(“追查毒品”)
class Person(object):
def work_with_dog(self,dog):
dog.work()
ad = ArmyDog()
dd = DrugDog()
police = Person()
police.work_with_dog(ad) # 追击敌人
police.work_with_dog(dd) # 追查毒品
def work_with_dog(self,dog)： 传入不同的对象,执行不同的代码,即不同的work函数。
=============================================================================
在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。
设置私有属性和私有方法的方式非常简单：在属性名和方法名前面加上两个下划线 "__" 即可。
class Girl():
def init(self):
self.name = ‘小美’
self.age = 18
def __showinfo(self):
print(f’姓名:{self.name},年龄:{self.age}')
girl = Girl()
print(girl.name) # 小美
print(girl.age) # 18
#外界不能直接访问私有属性和私有方法
girl.showinfo() # 报错
私有属性和私有方法也不能被子类继承
class Cat(object):
def init(self):
self.name = ‘猫大师’
self.kungfu = ‘闪、展、腾、挪’
私有属性
self.__skill = ‘爬树’
class Tiger(Cat):
pass
tiger = Tiger()
tiger.name = ‘学徒虎’
print(f’{tiger.name},功夫:{tiger.kungfu}') # 学徒虎,功夫:闪、展、腾、挪
print(f’{tiger.__skill}') # 报错,私有属性不能被子类继承
在Python中，一般定义函数名 get_xx 用来获取私有属性，定义 set_xx 用来修改私有属性值
class Girl():
def init(self):
self.name = ‘小美’
self.age = 18
def get_age(self):
return self.age
def set_age(self,age):
self.age = age
girl = Girl()
girl.set_age(19)
print(girl.get_age()) # 19
4.4.1、类属性
类属性就是类对象中定义的属性，它是该类的所有实例对象所共有。
class Tool(object):
定义类属性,用于记录创建了多少个工具对象
count = 0
4.4.2、类方法
类方法：类方法就是针对类对象定义的方法，在类方法中可以直接访问类属性或者调用其他类方法。
基本语法：
@classmethod
def 类名称(cls):
pass
-
类方法需要用修饰器
@classmethod来标识，告诉解释器这是一个类方法，类方法的第一个参数是cls -
有哪一个类调用的方法，方法内的 " cls " 就是哪一个类的引用
-
这个参数和示例方法的第一个参数是 “self” 类似
-
提示使用其他名称也可以，不过习惯使用 " cls " 通过
类名.调用类方法，调用方法时，不需要传递" cls "参数 -
在方法内部
-
可以通过
cls.访问类的属性 -
也可以通过
cls.调用其他的类方法
class Tool(object):
定义类属性,用于记录创建了多少个对象
count = 0
def init(self, name):
self.name = name
针对类属性做一个计数+1的操作
Tool.count += 1
类方法,类方法需要用 @classmethod 修饰，并且第一个参数为cls
@classmethod
def show_tools_count(cls):
使用 cls.count 访问类的属性
print(f’对象的数量：{cls.count}')
tool1 = Tool(‘斧子’)
tool2 = Tool(‘榔头’)
tool3 = Tool(‘铁锹’)
输出对象的总数
Tool.show_tools_count() # 对象的数量：3
在开发时，如果需要在类中封装一个方法，这个方法：
-
既不需要访问实例属性或者调用实例方法
-
也不需要访问类属性或者调用类方法
这个时候，可以把这个方法封装成一个静态方法
基本语法：
@staticmethod
def 静态方法名():
pass
静态方法需要用修饰器 @staticmethod 来标识，告诉解释器这是一个静态方法。
通过类名.调用 静态方法
class Game:
静态方法
@staticmethod
def menu():
print(‘开始[1]’)
print(‘暂停[2]’)
print(‘退出[3]’)
直接通过 类名.静态方法() 调用
Game.menu()
======================================================================
当检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。
try:
可能发生错误的代码
except:
可能出现异常执行的代码
例如：
try:
print(name)
except NameError:
print(‘name变量名称未定义错误’)
- 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
- 一般try下方只放一行尝试执行的代码。
当捕获多个异常时，可以把要捕获的异常类型的名字，放到except 后，并使用元组的方式进行书写。
try:
print(1/0)
except(NameError,ZeroDivisionError):
print(‘有错误’)
try:
print(num)
except(NameError,ZeroDivisionError) as e:
print(e)
Exception是所有程序异常类的⽗父类。
try:
print(num)
except Exception as e:
print(e)
else表示的是如果没有异常要执行的代码
try:
print(1)
except Exception as e:
print(e)
else:
print(‘我是else，是没有异常的时候执行的代码’)
finally表示的是无论是否异常都要执行的代码，例如关闭文件。
try:
f = open(‘text.txt’,‘r’)
except Exception as e:
f = open(‘text.txt’,‘w’)
else:
print(‘没有异常可真好’)
finally:
f.close()
感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：
① 2000多本Python电子书（主流和经典的书籍应该都有了）
② Python标准库资料（最全中文版）
③ 项目源码（四五十个有趣且经典的练手项目及源码）
④ Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）
⑤ Python学习路线图（告别不入流的学习）
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
isionError) as e:
print(e)
Exception是所有程序异常类的⽗父类。
try:
print(num)
except Exception as e:
print(e)
else表示的是如果没有异常要执行的代码
try:
print(1)
except Exception as e:
print(e)
else:
print(‘我是else，是没有异常的时候执行的代码’)
finally表示的是无论是否异常都要执行的代码，例如关闭文件。
try:
f = open(‘text.txt’,‘r’)
except Exception as e:
f = open(‘text.txt’,‘w’)
else:
print(‘没有异常可真好’)
finally:
f.close()
感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：
① 2000多本Python电子书（主流和经典的书籍应该都有了）
② Python标准库资料（最全中文版）
③ 项目源码（四五十个有趣且经典的练手项目及源码）
④ Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）
⑤ Python学习路线图（告别不入流的学习）
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
[外链图片转存中…(img-o6FTBkxx-1713365708591)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
