这一篇是面向对象的进阶部分，主要还是面向对象的封装，继承，多态方面的讲解，后面的部分是讲解python异常和模块以及包的部分。

一、Python中的继承
- 1、什么是继承
- 2、继承的基本语法
- 3、与继承相关的几个概念
- 4、单继承
- 5、单继承特性：传递性
- 6、编写面向对象代码中的常见问题
- 7、多继承
- 8、子类扩展：重写父类属性和方法
- 9、super()调用父类属性和方法
- 10、MRO属性或MRO方法：方法解析顺序
二、Python中多态
- 1、什么是多态
- 2、多态原理图
- 3、多态代码实现
三、面向对象其他特性
- 1、类属性
- 2、类属性代码实现
- 3、类方法
- 4、静态方法
四、综合案例
- 1、需求分析
- 2、实例代码
五、面向对象中的单例模式
- 1、什么是设计模式
- 2、单例模式
- 3、\__new__()方法
- 4、单例模式的代码实现
六、Python异常
- 1、什么是异常
- 2、异常演示
- 3、异常捕获
- 4、捕获指定异常
- 5、同时捕获多个异常
- 6、捕获所有未知异常
- 7、异常捕获中else语句
- 8、异常捕获中的finally语句
- 9、异常的综合案例
- - ☆ 异常的传递
  - ☆ raise抛出自定义异常

一、Python中的继承

1、什么是继承

我们接下来来聊聊Python代码中的“继承”：类是用来描述现实世界中同一组事务的共有特性的抽象模型，但是类也有上下级和范围之分，比如：生物 => 动物 => 哺乳动物 => 灵长型动物 => 人类 => 黄种人

从哲学上说，就是共性与个性之间的关系，比如：白马和马！所以，我们在OOP代码中，也一样要体现出类与类之间的共性与个性关系，这里就需要通过类的继承来体现。简单来说，如果一个类A使用了另一个类B的成员（属性和方法），我们就可以说A类继承了B类，同时这也体现了OOP中代码重用的特性！

2、继承的基本语法

假设A类要继承B类中的所有属性和方法（私有属性和私有方法除外）

class B(object):passclss A(B):passa = A()
a.B中的所有公共属性
a.B中的所有公共方法

案例：Person类与Teacher、Student类之间的继承关系

class Person(object):def eat(self):print('i can eat food!')def speak(self):print('i can speak!')class Teacher(Person):passclass Student(Person):passteacher = Teacher()
teacher.eat()
teacher.speak()student = Student()
student.eat()
studnet.speak()

3、与继承相关的几个概念

继承：一个类从另一个已有的类获得其成员的相关特性，就叫作继承！

派生：从一个已有的类产生一个新的类，称为派生！

很显然，继承和派生其实就是从不同的方向来描述的相同的概念而已，本质上是一样的！

父类：也叫作基类，就是指已有被继承的类！

子类：也叫作派生类或扩展类

扩展：在子类中增加一些自己特有的特性，就叫作扩展，没有扩展，继承也就没有意义了！

单继承：一个类只能继承自一个其他的类，不能继承多个类，单继承也是大多数面向对象语言的特性！

多继承：一个类同时继承了多个父类，（C++、Python等语言都支持多继承）

4、单继承

单继承：一个类只能继承自一个其他的类，不能继承多个类。这个类会有具有父类的属性和方法。

基本语法：

# 1、定义一个共性类（父类）
class Person(object):pass
# 2、定义一个个性类（子类）
class Teacher(Person):pass

案例：比如汽车可以分为两种类型（汽油车、电动车）

# 1、定义一个共性类（车类）
class Car(object):def run(self):print('i can run')
# 2、定义汽油车
class GasolineCar(Car):pass
# 3、定义电动车
class EletricCar(Car):passbwm = GasolineCar()
bwm.run()

5、单继承特性：传递性

在Python继承中，如A类继承了B类，B类又继承了C类。则根据继承的传递性，则A类也会自动继承C类中所有属性和方法（公共）

class C(object):def func(self):print('我是C类中的相关方法func')class B(C):passclass A(B):passa = A()
a.func()

6、编写面向对象代码中的常见问题

问题1：在定义类时，其没有遵循类的命名规则

答：在Python中，类理论上是不区分大小写的。但是要遵循一定的命名规范：首字母必须是字母或下划线，其中可以包含字母、数字和下划线，而且要求其命名方式采用大驼峰。

电动汽车：EletricCar

父类：Father

子类：Son

问题2：父类一定要继承object么？Car(object)

答：在Python面向对象代码中，建议在编写父类时，让其自动继承object类。但是其实不写也可以，因为默认情况下，Python中的所有类都继承自object。

问题3：打印属性和方法时，都喜欢用print

class Person():def __init__(self, name):self.name = namedef speak(self):print('i can speak')# 创建对象，打印属性和方法
p = Person('Tom')
print(p.name)
p.speak()

7、多继承

什么是多继承？

Python语言是少数支持多继承的一门编程语言，所谓的多继承就是允许一个类同时继承自多个类的特性。

基本语法：

class B(object):passclass C(object):passclass A(B, C):passa = A()
a.B中的所有属性和方法
a.C中的所有属性和方法

案例：汽油车、电动车 => 混合动力汽车（汽车 + 电动）

class GasolineCar(object):def run_with_gasoline(self):print('i can run with gasoline')class EletricCar(object):def run_with_eletric(self):print('i can run with eletric')class HybridCar(GasolineCar, EletricCar):passtesla = HybridCar()
tesla.run_with_gasoline()
tesla.run_with_eletric()

注意：虽然多继承允许我们同时继承自多个类，但是实际开发中，应尽量避免使用多继承，因为如果两个类中出现了相同的属性和方法就会产生命名冲突。

8、子类扩展：重写父类属性和方法

扩展特性：继承让子类继承父类的所有公共属性和方法，但是如果仅仅是为了继承公共属性和方法，继承就没有实际的意义了，应该是在继承以后，子类应该有一些自己的属性和方法。

什么是重写？

重写也叫作覆盖，就是当子类成员与父类成员名字相同的时候，从父类继承下来的成员会重新定义！

此时，通过子类实例化出来的对象访问相关成员的时候，真正其作用的是子类中定义的成员！

上面单继承例子中 Animal 的子类 Cat和Dog 继承了父类的属性和方法，但是我们狗类Dog 有自己的叫声’汪汪叫’，猫类 Cat 有自己的叫声 ‘喵喵叫’ ，这时我们需要对父类的 call() 方法进行重构。如下：

class Animal(object):def eat(self):print('i can eat')def call(self):print('i can call')class Dog(Animal):passclass Cat(Animal):passwangcai = Dog()
wangcai.eat()
wangcai.call()miaomiao = Cat()
miaomiao.eat()
miaomiao.call()

Dog、Cat子类重写父类Animal中的call方法：

class Animal(object):def eat(self):print('i can eat')# 公共方法def call(self):print('i can call')class Dog(Animal):# 重写父类的call方法def call(self):print('i can wang wang wang')class Cat(Animal):# 重写父类的call方法def call(self):print('i can miao miao miao')wangcai = Dog()
wangcai.eat()
wangcai.call()miaomiao = Cat()
miaomiao.eat()
miaomiao.call()

思考：重写父类中的call方法以后，此时父类中的call方法还在不在？

答：还在，只不过是在其子类中找不到了。类方法的调用顺序，当我们在子类中重构父类的方法后，Cat子类的实例先会在自己的类 Cat 中查找该方法，当找不到该方法时才会去父类 Animal 中查找对应的方法。

9、super()调用父类属性和方法

super()：调用父类属性或方法，完整写法：super(当前类名, self).属性或方法()，在Python3以后版本中，调用父类的属性和方法我们只需要使用super().属性或super().方法名()就可以完成调用了。

案例：Car汽车类、GasolineCar汽油车、ElectricCar电动车

class Car(object):def __init__(self, brand, model, color):self.brand = brandself.model = modelself.color = colordef run(self):print('i can run')class GasolineCar(Car):def __init__(self, brand, model, color):super().__init__(brand, model, color)def run(self):print('i can run with gasoline')class ElectricCar(Car):def __init__(self, brand, model, color):super().__init__(brand, model, color)# 电池属性self.battery = 70def run(self):print(f'i can run with electric，remain:{self.battery}')bwm = GasolineCar('宝马', 'X5', '白色')
bwm.run()tesla = ElectricCar('特斯拉', 'Model S', '红色')
tesla.run()

10、MRO属性或MRO方法：方法解析顺序

MRO(Method Resolution Order)：方法解析顺序，我们可以通过类名.__mro__或类名.mro()获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找到。

class Car(object):def __init__(self, brand, model, color):self.brand = brandself.model = modelself.color = colordef run(self):print('i can run')class GasolineCar(Car):def __init__(self, brand, model, color):super().__init__(brand, model, color)def run(self):print('i can run with gasoline')class ElectricCar(Car):def __init__(self, brand, model, color):super().__init__(brand, model, color)# 电池属性self.battery = 70def run(self):print(f'i can run with electric，remain:{self.battery}')print(ElectricCar.__mro__)
print(ElectricCar.mro())

说明：有MRO方法解析顺序可知，在类的继承中，当某个类创建了一个对象时，调用属性或方法，首先在自身类中去寻找，如找到，则直接使用，停止后续的查找。如果未找到，继续向上一级继承的类中去寻找，如找到，则直接使用，没有找到则继续向上寻找…直到object类，这就是Python类继承中，其方法解析顺序。

综上：object类还是所有类的基类（因为这个查找关系到object才终止）

二、Python中多态

1、什么是多态

多态指的是一类事物有多种形态。

定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。

① 多态依赖继承

② 子类方法必须要重写父类方法

首先定义一个父类，其可能拥有多个子类对象。当我们调用一个公共方法时，传递的对象不同，则返回的结果不同。

好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！

2、多态原理图

公共接口service就是多态的体现，随着传入水果对象的不同，能返回不同的结果。

3、多态代码实现

多态：可以基于继承也可以不基于继承

class Fruit(object):# 公共方法def makejuice(self):print('i can make juice')class Apple(Fruit):def makejuice(self):print('i can make apple juice')class Banana(Fruit):def makejuice(self):print('i can make banana juice')class Orange(Fruit):def makejuice(self):print('i can make orange juice')class Peach(Fruit):def makejuice(self):print('i can make peach juice')# 定义公共方法如service
def service(obj):obj.makejuice()apple = Apple()
banana = Banana()
orange = Orange()for i in (apple, banana, orange):service(i)

三、面向对象其他特性

1、类属性

Python中，属性可以分为实例属性和类属性。

类属性就是类对象中定义的属性，它被该类的所有实例对象所共有。通常用来记录与这类相关的特征，类属性不会用于记录具体对象的特征。

在Python中，一切皆对象。类也是一个特殊的对象，我们可以单独为类定义属性。

class Person(object):# 定义类属性count = 0def __init(self, name, age):self.name = nameself.age = agep1 = Person('Tom', 23)
p2 = Person('Harry', 26)

2、类属性代码实现

定义count类属性，用于记录实例化Person类，产生对象的数量。

class Person(object):# 定义类属性countcount = 0# 定义一个__init__魔术方法，用于进行初始化操作def __init__(self, name):self.name = name# 对count类属性进行+1操作，用于记录这个Person类一共生成了多少个对象Person.count += 1# 1、实例化对象p1
p1 = Person('Tom')
p2 = Person('Harry')
p3 = Person('Jennifer')
# 2、在类外部输出类属性
print(f'我们共使用Person类生成了{Person.count}个实例对象')

3、类方法

为什么需要类方法，在面向对象中，特别强调数据封装性。所以不建议直接在类的外部对属性进行直接设置和获取。所以我们如果想操作类属性，建议使用类方法。

class Tool(object):# 定义一个类属性countcount = 0# 定义一个__init__初始化方法def __init__(self, name):self.name = nameTool.count += 1# 封装一个类方法：专门实现对Tool.count类属性进行操作@classmethoddef get_count(cls):print(f'我们使用Tool类共实例化了{cls.count}个工具')t1 = Tool('斧头')
t2 = Tool('榔头')
t3 = Tool('铁锹')Tool.get_count()

类方法主要用于操作类属性或类中的其他方法。

4、静态方法

在开发时，如果需要在类中封装一个方法，这个方法：

① 既不需要访问实例属性或者调用实例方法

② 也不需要访问类属性或者调用类方法

这个时候，可以把这个方法封装成一个静态方法

# 开发一款游戏
class Game(object):# 开始游戏，打印游戏功能菜单@staticmethoddef menu():print('1、开始游戏')print('2、游戏暂停')print('3、退出游戏')# 开始游戏、打印菜单
Game.menu()

四、综合案例

1、需求分析

设计一个Game类

属性：

定义一个类属性top_score记录游戏的历史最高分

定义一个实例属性player_name记录当前游戏的玩家姓名

方法：

静态方法show_help显示游戏帮助信息

类方法show_top_score显示历史最高分

实例方法start_game开始当前玩家的游戏

2、实例代码

class Game(object):# 1、定义类属性top_scoretop_score = 0# 2、定义初始化方法__init__def __init__(self, player_name):self.player_name = player_name# 3、定义静态方法，用于输出帮助信息@staticmethoddef show_help():print('游戏帮助信息')# 4、定义类方法@classmethoddef show_top_score(cls):print(f'本游戏历史最高分：{cls.top_score}')# 5、定义实例方法，start_game()def start_game(self):print(f'{self.player_name}，游戏开始了，你准备好了么？')# 实例化类生成实例对象
mario = Game('itheima')
mario.start_game()# 显示历史最高分
Game.show_top_score()# 弹出游戏帮助信息
Game.show_help()

五、面向对象中的单例模式

1、什么是设计模式

设计模式就是前人根据实际的问题提出的问题解决方案，我们把这种就称之为设计模式。

2、单例模式

单例模式是一种常见的设计模式！

所谓的设计模式，不是一种新的语法，而是人们在实际的应用中，面对某种特定的情形而设计出来的某种常见的有效的解决方案，所以，设计模式只是经验的总结！

什么又是单例模式？单例，就是单一实例！

在实际的运用中，存在一些类，只需要实例化一个对象，就可以完成其所有的功能操作。所以，如果我们能够通过某些技巧，使得一个类只能开辟一个对象空间的话，这样就可以节省相应的对象资源，这种模式就叫作单例模式！

应用场景：音乐播放器对象、回收站对象、打印机对象

3、_new_()方法

在Python中，我们目前已经学了3个魔术方法了，分别是__init__()、__str__()、__del__()，接下来介绍一下__new__()方法。

使用类名()创建对象时，Python的解释器首先会调用__new__方法为对象分配空间。

__new__是一个由object积累提供的内置的静态方法，主要作用有两个：

○ 在内存中为对象分配空间

○ 返回对象的引用

Python解析器获得对象的引用后，将引用作为第一个参数，传递给__init__方法重写__new__方法的代码非常固定，一定要使用return super(). __new__(cls)，否则Python解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法。

__new__方法是一个静态方法，在调用时，要求将自身类信息cls作为参数传递到这个方法中，这个方法属于object类中的一个静态方法。

案例：

# 定义一个播放器类
class MusicPlayer(object):# 重写__new__()魔术方法def __new__(cls, *args, **kwargs):print('1、开辟内存空间')print('2、返回实例化对象引用地址')return super().__new__(cls)def __init__(self, name):self.name = name# 1、实例mp1对象
mp1 = MusicPlayer('红色的高跟鞋')
print(mp1)# 2、实例化mp2对象
mp2 = MusicPlayer('春夏秋冬')
print(mp2)

4、单例模式的代码实现

# 定义一个播放器类
class MusicPlayer(object):# 定义一个类属性，如instance，用于记录之前实例化对象返回的内存引用instance = None# 重写__new__()魔术方法def __new__(cls, *args, **kwargs):# 判断实例化时有没有分配过内存空间if cls.instance is None:cls.instance = super().__new__(cls)return cls.instancedef __init__(self, name):self.name = name# 1、实例mp1对象
mp1 = MusicPlayer('红色的高跟鞋')
print(mp1)# 2、实例化mp2对象
mp2 = MusicPlayer('春夏秋冬')
print(mp2)

注：类属性在内存中是一个特殊的存在，其不用于以前讲过的局部变量（局部变量当函数执行完毕后，其会被内存所销毁）。但是类属性一旦定义，除非对象以及这个类在内存中被销毁了，否则其不会自动销毁。

六、Python异常

1、什么是异常

当检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。

2、异常演示

# 运算符
# print(10/0)# 文件异常
f = open('python.txt', 'r')
content = f.readlines()
print(content)

3、异常捕获

基本语法：

try:可能发生错误的代码
except(捕获):如果出现异常执行的代码

try…except主要用于捕获代码运行时异常

案例：

try:f = open('python.txt', 'r')content = f.readline()print(content, end='')
except:f = open('python.txt', 'w', encoding='utf-8')f.write('发生异常，执行except语句中的代码')f.close()

4、捕获指定异常

在以上案例代码中，except相当于捕获了所有异常，无论遇到什么错误都会自动执行except中封装的代码。但是有些情况下，我们向针对性的捕获异常，并执行相应的代码。

基本语法：

try:可能遇到异常的代码
except 异常类型:捕获到对应的错误以后，执行的代码

① 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。

② 一般try下方只放一行尝试执行的代码。

案例：捕获FileNotFoundError异常

try:f = open('python.txt', 'r')
except FileNotFoundError as e:print(e)

5、同时捕获多个异常

try:print(name)# print(10/0)
except (NameError, ZeroDivisionError) as e:print(e)

6、捕获所有未知异常

无论我们在except后面定义多少个异常类型，实际应用中，也可能会出现无法捕获的未知异常。这个时候，我们考虑使用Exception异常类型捕获可能遇到的所有未知异常：

try:可能遇到的错误代码
except Exception as e:print(e)

案例：打印一个未定义变量，使用Exception异常类进行捕获

try:print(name)
except Exception as e:print(e)

7、异常捕获中else语句

else语句：表示的是如果没有异常要执行的代码。

try:print(1)
except Exception as e:print(e)
else:print('哈哈，真开森，没有遇到任何异常')

案例：

try:f = open('python.txt', 'r')
except Exception as e:print(e)
else:content = f.readlines()print(content, end='')f.close()

8、异常捕获中的finally语句

finally表示的是无论是否异常都要执行的代码，例如关闭文件、关闭数据库连接。

try:f = open('python.txt', 'r')
except:f = open('python.txt', 'w')
else:print('哈哈，真开森，没有遇到任何异常')
finally:print('关闭文件')f.close()

9、异常的综合案例

☆ 异常的传递

需求：

① 尝试只读方式打开python.txt文件，如果文件存在则读取文件内容，文件不存在则提示用户即可。

② 读取内容要求：尝试循环读取内容，读取过程中如果检测到用户意外终止程序，则except捕获

import timetry:f = open('python.txt', 'r')try:while True:content = f.readline()if len(content) == 0:breaktime.sleep(3)print(content, end='')except:# Ctrl + C（终端里面，其代表终止程序的继续执行）print('python.txt未全部读取完成，中断了...')finally:f.close()
except:print('python.txt文件未找到...')

☆ raise抛出自定义异常

在Python中，抛出自定义异常的语法为raise 异常类对象。

需求：密码长度不足，则报异常（用户输入密码，如果输入的长度不足6位，则报错，即抛出自定义异常，并捕获该异常）。

原生方法：

def input_password():password = input('请输入您的密码，不少于6位：')if len(password) < 6:# 抛出异常raise Exception('您的密码长度少于6位')return# 如果密码长度正常，则直接显示密码print(password)input_password()

面向对象抛出自定义异常：

class ShortInputError(Exception):# length代表输入密码长度，min_length代表ShortInputError最小长度def __init__(self, length, min_length):self.length = lengthself.min_length = min_length# 定义一个__str__方法，用于输出字符串信息def __str__(self):return f'您输入的密码长度为{self.length}，不能少于{self.min_length}个字符'try:password = input('请输入您的密码，不少于6位：')if len(password) < 6:raise ShortInputError(len(password), 6)
except Exception as e:print(e)
else:print(f'密码输入完成，您的密码是：{password}')

Python面向对象进阶与异常、模块以及包管理相关推荐

Python中的类、模块和包究竟是什么?
Python培训教程:Python中的类.模块和包究竟是什么?在Python和其他编程语言中,都有类似或相同的概念,如对象.类.模块.包,名称都是一样的,只不过会有细微的一些区别,正是因为有这些存在, ...
Python基础（七）--模块和包
目录 Python基础(七)--模块和包 1 模块 1.1 什么是模块 1.2 模块的使用 1.3 模块的搜索路径 1.4 模块的缓存 2 包 2.1 什么是包 2.2 包的使用 3 常用模块 3.1 ...
python3.4学习笔记(八) Python第三方库安装与使用，包管理工具解惑
python3.4学习笔记(八) Python第三方库安装与使用,包管理工具解惑许多人在安装Python第三方库的时候, 经常会为一个问题困扰:到底应该下载什么格式的文件? 当我们点开下载页时, 一 ...
python3第三方库手册_python3.4学习笔记(八) Python第三方库安装与使用，包管理工具解惑...
python3.4学习笔记(八) Python第三方库安装与使用,包管理工具解惑许多人在安装Python第三方库的时候, 经常会为一个问题困扰:到底应该下载什么格式的文件? 当我们点开下载页时, 一 ...
模块和包管理工具npm
模块和包管理工具npm 什么是模块化模块化的优点模块化规范 nodejs中模块的分类加载模块用require方法模块作用域向外共享模块作用域中的成员 require()模块时,得到的永远是m ...
Python面向对象进阶和socket网络编程
写在前面为什么坚持?想一想当初: 一.面向对象进阶 - 1.反射补充 - 通过字符串去操作一个对象的属性,称之为反射: - 示例1: class Chinese:def __init__(self, ...
python traceback 丢失_Python异常模块traceback用法实例分析
本文实例讲述了python异常模块traceback用法.分享给大家供大家参考,具体如下: traceback模块被用来跟踪异常返回信息. 如下例所示: import traceback try: r ...
Python 中引入多个模块，包的概念
实际开发中,一个大型的项目往往需要使用成百上千的 Python 模块,如果将这些模块都堆放在一起,势必不好管理. 而且,使用模块可以有效避免变量名或函数名重名引发的冲突,但是如果模块名重复怎么办呢? ...
Python学习-基础篇4 模块与包与常用模块
一模块介绍 1.什么是模块?#常见的场景:一个模块就是一个包含了一组功能的python文件,比如spam.py,模块名为spam,可以通过import spam使用.#在python中,模块的使用方 ...

Python面向对象进阶与异常、模块以及包管理

目录

一、Python中的继承

1、什么是继承

2、继承的基本语法

3、与继承相关的几个概念

4、单继承

5、单继承特性：传递性

6、编写面向对象代码中的常见问题

7、多继承

8、子类扩展：重写父类属性和方法

9、super()调用父类属性和方法

10、MRO属性或MRO方法：方法解析顺序

二、Python中多态

1、什么是多态

2、多态原理图

3、多态代码实现

三、面向对象其他特性

1、类属性

2、类属性代码实现

3、类方法

4、静态方法

四、综合案例

1、需求分析

2、实例代码

五、面向对象中的单例模式

1、什么是设计模式

2、单例模式

3、_new_()方法

4、单例模式的代码实现

六、Python异常

1、什么是异常

2、异常演示

3、异常捕获

4、捕获指定异常

5、同时捕获多个异常

6、捕获所有未知异常

7、异常捕获中else语句

8、异常捕获中的finally语句

9、异常的综合案例

☆ 异常的传递

☆ raise抛出自定义异常

Python面向对象进阶与异常、模块以及包管理相关推荐

最新文章

热门文章