Python 中的面向对象和异常处理

发表于

这是我参与11月更文挑战的第19天，活动详情查看：2021最后一次更文挑战

前言

在之前我们已经说过了 Python 中内置的主要的几种对象类型，（数，字符串，列表，元组和字典）。而面向对象的核心人物还没出场呢 。那么我们常说的对象是什么类型的呢，其实他的类型就是“类”。继承封装和多态，这是通用的面向对象编程的思想 。

Python 中的继承

继承是为了提高代码的复用性，子类可以通过继承父类来实现父类中的方法，这就是光明正大的偷懒 。举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ruby复制代码class Person():
    def eat(self):
        print("person can eat ...")
    def slepp(self):
        print("person can slepp ...")

calss Man(Person):
    def hardWork(self):
        print("man should be work hard ...")

# 测试
m = Man()
m.eat()
# person can eat ...

以上一个例子，说明了很多问题，首先，定义类是使用class关键字，定义方法使用def，默认传入一个参数，其实这个参数不一定非要叫self但是为了辨识性，我们这样定义，因为它代表的就是当前对象，类似 Java 中的 this 。当然还有我们的继承是通过一个括号+父类来定义的，那为什么 Person 没有写呢，其实这里省略了一个object 不写就表示默认继承 object 超类 。另外，Python 支持多继承，像这样即可，calss Man(Animal,Person) 一个问题需要注意，当多个父类中含有同一个方法时，以后面父类中的为准 。但是，不推荐大家使用多重继承 。

Python 中的封装

封装，理解起来很简单，就是将类中的属性信息隐藏起来，提供公共的方法以备调用，我们将属性进行 ” 私有化 “，在属性的前面加上两个下划线 __name 定义一个假的私有的属性 。看例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ruby复制代码class Man():

    def __init(self): # 这是对象的初始化方法，创建对象是默认执行
        self.__name = ''

    def set_name(self,name):
        self.__name = name
    def get_name(self):
        return self.__name

m = Man() # 创建对象
m.set_name('YJK923') # 设置 name 值 ( 其实是 _Man__name )
m.get_name() # 获取 name 值 ( 其实是 _Man__name )
'YJK923'
m.name = 'YJK' #注意这里是另外添加了一个属性 name
m.get_name() # 获取 name 值 ( 其实是 _Man__name )
'YJK923'
m.name # 获取的是刚刚为 m 创建的 name 的值
'YJK'
m._Man__name # 获取属性 _Man__name ,这就是 Python 猫腻的地方，其实并没有私有化，只是转化格式了 。
'YJK923'

Python 中的多态

还有就是多态了，简单理解，就是有多种状态，常见的就是同一个方法但是执行的效果却不一样，就像是同一个名字人有太多了，而每个人却又不一样，看吧，编程思想也都是来自于日常的生活 。举例 ，都是睡觉 ，但是有的人喜欢躺在床上，有的人喜欢睡在椅子上 。用代码怎么实现呢？看下面

1
2
3
4
5
6
7
ruby复制代码class People():
    def sleep(self):
        print("人睡觉 。。。")

class Roommate(People):
    def sleep(self):
        print('睡在椅子上 。。。')

看吧，同样是睡觉，Roommate 却是睡在椅子上，通过继承的方式实现多态只是实现多态的一种方式而已 。还可以通过其它的方式，比方说这样，方法的参数是超类。

1
2
3
kotlin复制代码# 不同的对象调用同样的方法，结果却一样 。
fun(obj):
    print( obj.__len__() )

Python 中常用的方法

附加说几个比方常用的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
python复制代码# 标准模块 random 中包含一个名为 choice 的函数，用于从序列中水机选择一个元素。
from random import choice
x = choice(['Hello,world !',[1,2,'e','e',4]])
x.count('e')
2 # 随机生成的，也可能不是 2

# 判断类 A 是不是 B 的子类
issubclass(A，B) # 儿子在前，老子在后

# 查找类 A 的所有父类
A.__bases__

# 查找一个对象 A 中的所有属性
A.__dict__

# 查找对象 A 属于哪一个类
A.__class__

# 检查方法或属性是否存在与对象中
hasattr(instance，'methedName | attrName')

# 设置对象的属性
setattr(instance，'attrName'，value')

Python 中的抽象类

关于抽象类：定义了一种规则（抽象方法），继承这个类的子类必须实现抽象类中的抽象方法 。而且，抽象类是不能被实例化的 。

Python 中引入了 abc 模块来实现抽象类的定义，示例：

1
2
3
4
5
6
7
8
python复制代码# 下面表示定义了一个 抽象类 Talker , 包含一个抽象方法 talk .

from abc import ABC,abstractmethod

class Talker(ABC):
    @abstractmethod
    def talk(self):
        pass

插播一曲关于面向对象设计的一些思考 。

  1. 将相关的东西放在一起，如果一个方法要使用全局变量，那就将他作为类的属性和方法
  2. 不要让对象之间过于亲密 。这就是所谓的解耦和吧 。
  3. 慎用继承，尤其是多重继承 。
  4. 保持简单，让方法尽可能的短小精悍 。
1
2
3
4
5
6
7
8
复制代码如何将需求转化为具体的实体类呢 ？ 我们可以尝试这样做 。
将需求描述出来记录其中的名词，动词和形容词。
在名词中找出可能的类，
在动词中找出可能的方法，
在形容词中找出可能的属性，
最后将找出的方法和属性分配给各个类。
这样类的模型就出来了，然后我们可以思考对象之间的关系，继承或是组合。
后面再思考一下对应业务有哪些可以使用的模式，待各个业务模块都思考清楚后就可以着手编程了 。

Python 中的异常处理机制

下面简单的说一下 Python 中的异常处理机制 。

抛出异常使用关键字 raise 例如，raise Exception('exception msg !') 但是需要注意的是异常的抛出只能是 Exception 或 Exception 的子类 。

捕获异常：我们可以使用try ... except : ... finally: ... 语句块来处理可能出现异常的代码 。

1
2
3
4
5
6
7
8
python复制代码try 
    1 / 0
except ZeroDivisionError as e:
    print(e)
else :
    print('No exception will run ...')
finally :
    print('must be run ... ')

自定义异常类，定义一个类继承 Exception 类即可 。

1
2
kotlin复制代码class MyException(Exception):
    pass

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%