python不支持面向对象程序设计,
Yyds干货库存
一、Python 1中的继承。什么是继承？接下来说一下Python代码中的“继承”:类是一个抽象模型，用来描述现实世界中同一组事务的共同特征。但是，一个类也是有层次和范围的，比如：生物=动物=哺乳动物=灵长类=人类=黄种人。
哲学上讲就是共性和个性的关系，比如白马和马！所以在OOP代码中，我们还需要体现类之间的共性和个性，这需要通过类继承来体现。简单来说，如果一个类A使用了另一个类B的成员(属性和方法)，我们就可以说类A继承了类B，而这也体现了OOP中代码重用的特点！
2.继承的基本语法假设类A继承了类B中的所有属性和方法(私有属性和方法除外)。
B类(对象):
及格
clss A(B):
及格
a=A()
A.B .中的所有公共属性
a.B中的所有公共方法案例：Person类与教师和学生类之间的继承关系
类别人员(对象):
定义吃(自己):
打印(我能吃食物！)
定义说话(自我):
打印(“我会说话！”)
班主任(人):
及格
班级学生(人):
及格
教师=教师()
teacher.eat()
teacher.speak()
学生=学生()
学生.吃()
Studnet.speak()3。与继承相关的几个概念？继承：一个类从另一个已存在的类中获得其成员的相关特征称为继承！
派生：从一个现有的类生成一个新的类叫做派生！
很明显，继承和派生其实是从不同方向描述的同一个概念，本质上是一样的！
父类：也叫基类，是指继承的类！
子类：也称为派生类或扩展类。
扩展：给子类增加一些独特的特性叫做扩展。没有延伸，传承就没有意义！
单一继承：一个类只能从另一个类继承，不能从多个类继承。单一继承也是大多数面向对象语言的一个特点！
多重继承：一个类同时继承多个父类，(C，Python等语言支持多重继承)
4.单一继承单一继承：一个类只能从另一个类继承，不能从多个类继承。这个类将拥有带有父类的属性和方法。
基本语法：
# 1.定义一个公共类(父类)
类别人员(对象):
及格
# 2.定义个性类别(子类)
班主任(人):
通过案例：比如汽车可以分为两种(汽油车和电动车)。
# 1.定义一个公共类别(车辆类别)
汽车类(对象):
定义运行(自身):
打印(“我能跑”)
# 2.定义汽油车
汽油汽车等级：
及格
# 3.定义电动汽车
电动汽车(汽车)等级：
及格
bwm=汽油汽车()
Bwm.run()5。单一继承特性：传递性在Python继承中，比如A类继承B类，B类又继承c类，那么根据继承的传递性，A类会自动继承c类中的所有属性和方法(public)。
C类(对象):
定义函数(自身):
Print(我是C类中的相关方法func )
乙(丙)类：
及格
甲(乙)类：
及格
a=A()
A.func()6。编写面向对象代码常见问题1:定义类时，不遵循类的命名规则。
答：在Python中，理论上类是不区分大小写的。但需要遵循一定的命名规则：首字母必须是字母或下划线，可以包含字母、数字和下划线，并且要求其命名方式采用大驼峰。
电动车：电动汽车
班级：父亲
子类：儿子
问题2:父类必须继承object吗？汽车(物体)
答：在Python面向对象代码中，建议在编写父类时，应该自动继承对象类。但其实不写也没关系，因为默认情况下，Python中的所有类都是从object继承的。
问题3:打印属性和方法时，都喜欢用print。
class Person():
def __init__(self，name):
self.name=name
定义说话(自我):
打印(“我会说话”)
#创建对象，打印属性和方法
p=人(“汤姆”)
打印(姓名)
说话。什么是多重继承？
Python是少数支持多重继承的编程语言之一。所谓多重继承，就是允许一个类同时继承多个类的特性。
基本语法：
B类(对象):
及格
C类(对象):
及格
甲类(乙类、丙类):
及格
a=A()
A.B .中的所有属性和方法。
a.C .中所有属性和方法的例子：汽油车、电动车=混合动力车(电动车)
汽油汽车类别(对象):
def run _ with _汽油(self):
打印(“我能用汽油跑”)
类电动汽车(对象):
def run _ with _ eletic(self):
打印(“我可以用电子设备运行”)
混合动力汽车(汽油汽车、电动汽车):
及格
特斯拉=混合动力车()
特斯拉. _ with _汽油()
Tesla.run_with_eletric()注：虽然多重继承允许我们同时继承多个类，但在实际开发中，我们应该尽量避免使用多重继承，因为如果两个类中出现相同的属性和方法，就会出现命名冲突。
8.子类扩展：覆盖父类属性和方法扩展特性：继承允许子类继承父类的所有公共属性和方法，但如果只是为了继承公共属性和方法，继承没有实际意义。应该是继承之后，子类应该有自己的一些属性和方法。
什么是重写？
Override也叫覆盖，就是子类成员和父类成员同名时，从父类继承的成员会被重新定义！
此时，当相关成员被子类实例化的对象访问时，真正的角色是子类中定义的成员！
在上面的单继承例子中，子类Cat和Dog of Animal继承了父类的属性和方法，但是我们的Dog dog有自己的叫声‘bark’，Cat cat有自己的叫声‘meow’。这时候我们需要重构父类的call()方法。如下所示：
动物类(物体):
定义吃(自己):
打印(“我能吃”)
定义呼叫(自我):
打印(“我可以打电话”)
犬类(动物):
及格
类别猫(动物):
及格
王采=狗()
wangcai.eat()
wangcai.call()
苗苗=猫()
苗苗. eat()
Mimi.call () dog和Cat子类覆盖父类Animal中的call方法：
动物类(物体):
定义吃(自己):
打印(“我能吃”)
#公共方法
定义呼叫(自我):
打印(“我可以打电话”)
犬类(动物):
#重写父类的调用方法
定义呼叫(自我):
印刷品(《我王粲汪汪》)
类别猫(动物):
#重写父类的调用方法
定义呼叫(自我):
印刷(《我能苗苗苗》)
王采=狗()
wangcai.eat()
wangcai.call()
苗苗=猫()
苗苗. eat()
Miaomiao.call()思考：重写父类中的call方法后，此时父类中的call方法还存在吗？
答：它还在，但是在它的子类中找不到了。类的调用顺序，当我们在子类中重构父类的方法时，Cat子类的实例会先在自己的类Cat中寻找方法，找不到时，再去父类Animal中寻找对应的方法。
9.super()调用父类属性和方法super():调用父类属性或方法，全写：super(当前类名，self)。属性或方法()。在Python3及以后的版本中，我们只需要使用super()。属性或super()。方法名()来完成调用。
案例：汽车、汽油汽车和电动汽车。
汽车类(对象):
def __init__(自身，品牌，型号，颜色):
自我品牌=品牌
self.model=模型
self.color=颜色
定义运行(自身):
打印(“我能跑”)
汽油汽车等级：
def __init__(自身，品牌，型号，颜色):
超级()。__init__(品牌、型号、颜色)
定义运行(自身):
打印(“我能用汽油跑”)
电动汽车(汽车)等级：
def __init__(自身，品牌，型号，颜色):
超级()。__init__(品牌、型号、颜色)
#电池属性
自带电池=70
定义运行(自身):
打印(如果我可以用电运行，剩余：{self.battery} )
Bwm=汽油汽车(宝马， X5 ，白色)
bwm.run()
特斯拉=电动车(特斯拉， S型，红色)
Tesla.run()10、mro属性或MRO方法：方法解析顺序MRO(Method Resolution Order):方法解析顺序。我们可以通过类名得到“类层次结构”。__mro__或类名。MRO()，方法解析顺序也是根据这个“类层次结构”找到的。
汽车类(对象):
def __init__(自身，品牌，型号，颜色):
自我品牌=品牌
self.model=模型
self.color=颜色
定义运行(自身):
打印(“我能跑”)
汽油汽车等级：
def __init__(自身，品牌，型号，颜色):
超级()。__init__(品牌、型号、颜色)
定义运行(自身):
打印(“我能用汽油跑”)
电动汽车(汽车)等级：
def __init__(自身，品牌，型号，颜色):
超级()。__init__(品牌、型号、颜色)
#电池属性
自带电池=70
定义运行(自身):
打印(如果我可以用电运行，剩余：{self.battery} )
打印(电动车。__mro__)
打印(ElectricCar.mro())
注意：按照MRO方法的分析顺序，在类的继承中，当一个类创建一个对象时，它调用属性或方法，首先在自己的类中寻找。如果找到，则直接使用，并停止后续搜索。如果没有找到，则继续在下一个更高级别继承的类中查找。如果找到了，直接用。如果没有找到，继续查找.直到对象类，这是Python类继承中的方法解析顺序。
综上所述：object类是所有类的基类(此搜索因与object有关而终止)
二。Python 1中的多态性。什么是多态性？多态性是指一类事物有多种形式。
定义：多态是使用对象的一种方式。子类覆盖父方法，调用不同子类的相同父方法，会产生不同的执行结果。
多态依赖继承
子类方法必须覆盖父方法。
首先，定义一个父类，它可能有多个子类。当我们调用一个公共方法时，传递不同的对象，因此返回不同的结果。
好处：灵活调用，有了多态，更容易写通用代码，让通用编程适应不断变化的需求！
2.多态示意图
公共接口服务就是多态的体现，可以用不同的传入水果对象返回不同的结果。
3.多态代码可以实现多态：可以基于继承，也可以不基于继承。
类果(对象):
#公共方法
def makejuice(自身):
打印(“我会做果汁”)
苹果类(水果):
def makejuice(自身):
打印(“我会做苹果汁”)
香蕉类(水果类):
def makejuice(自身):
打印(“我会做香蕉汁”)
橘子类(水果):
def makejuice(自身):
打印(“我会做橙汁”)
桃类(水果类):
def makejuice(自身):
打印(“我会做桃汁”)
#定义公共方法，如服务
定义服务(对象):
makejuice()
苹果=苹果()
香蕉=香蕉()
橙色=橙色()
对于i in(苹果、香蕉、橘子):
服务(一)三。其他面向对象的特性。类属性在Python中，属性可以分为实例属性和类属性。
类是在类对象中定义的属性，由该类的所有实例对象共享。通常用于记录与该类相关的特征，类属性不用于记录特定对象的特征。
在Python中，一切都是对象。类也是一个特殊的对象，我们可以为类单独定义属性。
类别人员(对象):
#定义类属性
计数=0
def __init(自己，姓名，年龄):
self.name=name
年龄=年龄
p1=人(“汤姆”，23)
P2=Person(哈利，26)2。类属性代码实现定义了count类属性，用于记录实例化Person类生成的对象数量。
类别人员(对象):
#定义类属性计数
计数=0
#为初始化定义一个__init__ magic方法。
def __init__(self，name):
self.name=name
#对count类的属性执行1次操作，记录这个Person类生成了多少个对象。
Person.count=1
# 1.实例化对象p1
p1=人(“汤姆”)
p2=人(“哈里”)
p3=人(詹妮弗)
# 2.在类外输出类属性。
Print(f 我们用Person类生成了{Person.count}实例对象)3 .为什么类方法需要类方法？在面向对象中，特别强调数据封装。因此，不建议在类外直接设置和获取属性。所以如果我们想操作类属性，我们建议使用类方法。
类工具(对象):
#定义类属性计数
计数=0
#定义__init__初始化方法
def __init__(self，name):
self.name=name
Tool.count=1
#封装一个类方法：具体实现Tool.count类的属性上的操作。
@classmethod
定义获取计数(cls):
Print(f 我们已经使用工具类实例化了总共{cls.count}个工具)
T1=工具(“轴”)
T2=工具(“锤子”)
T3=工具(“铲子”)
Tool.get_count()类方法主要用于操作类属性或者类中的其他方法。
4.开发静态方法时，如果需要在类中封装一个方法，这个方法：
不需要访问实例属性或调用实例方法。
不需要访问类属性或者调用类方法。
此时，可以将该方法封装为静态方法。
#开发一个游戏
类游戏(对象):
#启动游戏，打印游戏功能菜单。
@静态方法
定义菜单():
打印( 1，开始游戏)
打印( 2，游戏暂停)
打印( 3，退出游戏)
#开始游戏，打印菜单
Game.menu()四。综合案例1。需求分析并设计一个游戏课件。
属性：
定义一个类属性top_score来记录游戏历史最高分。
定义一个实例属性player_name来记录当前游戏的玩家名字。
方法：
静态show_help方法显示游戏帮助信息。
班级show_top_score显示历史最高分。
start_game方法启动当前玩家的游戏。
2.示例代码类游戏(对象):
# 1.定义类属性top_score
top_score=0
# 2.定义初始化方法__init__
def __init__(self，player_name):
self.player_name=player_name
# 3.定义静态方法来输出帮助信息。
@静态方法
定义show_help():
打印(“游戏帮助信息”)
# 4.定义类方法
@classmethod
定义show_top_score(cls):
Print(f 本游戏历史最高分：{cls.top_score} )
# 5.定义实例方法，start_game()
def start_game(自己):
Print(f{self.player_name}，游戏开始，准备好了吗？)
#实例化该类以生成实例对象
马里奥=游戏( itheima )
mario.start_game()
#展示史上最高分
Game.show_top_score()
#弹出游戏帮助信息
Game.show_help()五、面向对象1中的singleton模式。什么是设计模式？设计模式是前人根据实际问题提出的解决问题的方案，我们称之为设计模式。
2.单例模式单例模式是一种常见的设计模式！
所谓的设计模式，并不是一种新的语法，而是人们在实际应用中，在特定情境下设计出来的一种通用有效的解决方案。所以，设计模式只是经验总结！
什么是单例模式？单个实例就是单个实例！
在实际应用中，有一些类，只需要实例化一个对象就可以完成它所有的功能操作。所以如果能通过一些技巧让一个类只开放一个对象空间，这样就可以节省相应的对象资源，这种模式就叫singleton模式！
应用场景：音乐播放器对象，回收站对象，打印机对象
3.\new()方法在Python中，到目前为止我们已经学习了三个神奇的方法，分别是__init__()、__str__()和__del__()。接下来，我们来介绍__new__()方法。
当创建一个类名为()的对象时，Python的解释器将首先调用__new__方法为对象分配空间。
__new__是对象累积提供的内置静态方法，它有两个主要功能：
在内存中为对象分配空间。
返回对象的引用。
Python解析器得到对象的引用后，将引用作为第一个参数，传递给__init__方法重写__new__方法的代码非常固定。一定要使用return super()。__new__(cls)，否则Python解释器不会在没有分配空间引用的情况下调用对象的初始化方法。
__new__方法是静态方法。当被调用时，它需要将自己的类信息cls作为参数传递给此方法。此方法属于object类中的静态方法。
案例：
#定义玩家类别
类MusicPlayer(对象):
#重写__new__()魔法方法
def __new__(cls，*args，**kwargs):
打印(“1，打开内存空间”)
Print(2，返回实例化对象的引用地址)
返回super()。__新__(cls)
def __init__(self，name):
self.name=name
# 1，mp1对象实例
Mp1=音乐播放器(“红色高跟鞋”)
打印(mp1)
# 2.实例化mp2对象
Mp2=MusicPlayer(春夏秋冬)
打印(mp2)4。singleton模式#的代码实现定义了一个玩家类
类MusicPlayer(对象):
#定义一个类属性，如instance，以记录先前实例化的对象返回的内存引用。
实例=无
#重写__new__()魔法方法
def __new__(cls，*args，**kwargs):
#确定在实例化期间是否已经分配了内存空间。
如果cls.instance为None:
cls.instance=super()。__新__(cls)
返回cls.instance
def __init__(self，name):
self.name=name
# 1，mp1对象实例
Mp1=音乐播放器(“红色高跟鞋”)
打印(mp1)
# 2.实例化mp2对象
Mp2=MusicPlayer(春夏秋冬)
Print(mp2)注意：Class属性在内存中是一个特殊的存在，对于前面提到的局部变量是不使用的(局部变量在函数执行后会被内存破坏)。但是，一旦定义了类属性，它就不会自动销毁，除非在内存中销毁对象和类。
不及物动词Python异常1。什么是例外？当检测到错误时，解释器不能继续执行。而是出现一些错误提示，这叫做‘异常’。
2.异常示范#运算符
#打印(10/0)
#文件异常
f=打开( python.txt ， r )
content=f.readlines()
打印(内容)3。异常捕获的基本语法：
尝试：
可能出现错误的代码。
除了(捕获):
如果代码执行异常，请尝试.except主要用于捕获代码运行时异常。
案例：
尝试：
f=打开( python.txt ， r )
content=f.readline()
打印(内容，结束= )
除了：
f=open(python.txt ， w ，编码=utf-8 )
F.write(发生异常时，执行except语句中的代码)
F.close()4。捕捉指定的异常。在上面的case代码中，except相当于捕捉所有异常，无论遇到什么错误，except中封装的代码都会自动执行。但是在某些情况下，我们会捕捉异常并执行相应的代码。
基本语法：
尝试：
可能遇到异常的代码。
例外类型除外：
在捕捉到相应的错误后，执行的代码如果你试图执行的代码的异常类型与要捕捉的异常类型不一致，那么你就无法捕捉到该异常。
一般只有一行要尝试执行的代码放在try下面。
案例：捕获FileNotFoundError异常
尝试：
f=打开( python.txt ， r )
除了FileNotFoundError作为e:
打印(戊)5。同时捕捉多个异常尝试：
打印(姓名)
#打印(10/0)
除了(NameError，ZeroDivisionError)作为e:
打印(e)6。捕捉所有未知的异常。无论我们在except之后定义多少异常类型，都可能存在实际应用中无法捕捉到的未知异常。此时，我们考虑使用异常异常类型来捕获所有可能遇到的未知异常：
尝试：
可能遇到的错误代码
例外情况为e:
打印(e) case:打印一个未定义的变量，用异常类捕获它。
尝试：
打印(姓名)
例外情况为e:
打印(戊)7。异常捕获中的else语句：表示没有异常时要执行的代码。
尝试：
打印(1)
例外情况为e:
打印(e)
否则：
打印(哈哈，真凯森，我没遇到什么异常)案例：
尝试：
f=打开( python.txt ， r )
例外情况为e:
打印(e)
否则：
content=f.readlines()
打印(内容，结束= )
F.close()8。异常捕获中的finally语句最终指示不管异常如何都要执行的代码，比如关闭文件和关闭数据库连接。
尝试：
f=打开( python.txt ， r )
除了：
f=打开( python.txt ， w )
否则：
打印(哈哈，真凯森，我没遇到什么不寻常的事)
最后：
打印(“关闭文件”)
F.close()9。异常全面的案例。异常交付要求：
尝试以只读模式打开python.txt文件。如果文件存在，读取文件的内容。如果文件不存在，提示用户。
内容阅读要求：尽量循环阅读内容。如果用户在阅读过程中意外终止程序，将捕获除。
导入时间
尝试：
f=打开( python.txt ， r )
尝试：
虽然正确：
content=f.readline()
如果len(内容)==0:
破裂
时间.睡眠(3)
打印(内容，结束= )
除了：
# Ctrl C(在终端内部，代表终止程序的继续执行)
Print(python.txt未完全读取，中断.)
最后：
f.close()
除了：
打印(未找到python.txt文件.)raise抛出自定义异常。在Python中，抛出自定义异常的语法是抛出异常类对象。
要求：如果密码长度不足，则报告异常(如果密码长度小于6位，则报告错误，即抛出并捕获用户自定义的异常)。
本机方法：
定义输入密码():
Password=input(请输入不少于6位的密码：)
if len(密码)6:
#抛出异常
引发异常(“您的密码长度少于6位数”)
返回
#如果密码长度正常，将直接显示密码
打印(密码)
输入密码()
引发了面向对象的自定义异常：
类ShortInputError(异常):
# length表示输入密码的长度，min_length表示ShortInputError的最小长度。
def __init__(self，length，min_length):
自身长度=长度
self.min_length=min_length
#定义__str__方法来输出字符串信息
def __str__(self):
Return 您输入的密码是{self.length}并且不能少于{self.min_length}个字符
尝试：
Password=input(请输入不少于6位的密码：)
if len(密码)6:
引发short input terror(len(password)，6)
例外情况为e:
打印(e)
否则：
打印(f 密码输入完成，您的密码为{password} )
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。