03python面向对象编程之多态和枚举6

不念不忘少年蓝@ 2022-01-09 04:11 81阅读 0赞

## 7.多态性 ##

对于弱类型的语言来说，变量并没有声明类型，因此同一个变量完全可以在不同的时间引用不同的对象。当同一个变量在调用同一个方法时，完全可能呈现出多种行为（具体呈现出哪种行为由该变量所引用的对象来决定），这就是所谓的多态（Polymorphism）。

先看下面程序：

In \[1\]:

class Bird:
        def move(self, field):
            print('鸟在%s上自由地飞翔' % field)
            
    class Dog:
        def move(self, field):
            print('狗在%s里飞快的奔跑' % field)

In \[2\]:

# x变量被赋值为Bird对象
    x = Bird()
    # 调用x变量的move()方法
    x.move('天空')

鸟在天空上自由地飞翔

In \[3\]:

# x变量被赋值为Dog对象
    x = Dog()
    # 调用x变量的move()方法
    x.move('草地')

狗在草地里飞快的奔跑

上面程序中 x 变量开始被赋值为 Bird 对象，因此当 x 变量执行 move() 方法时，它会表现出鸟类的飞翔行为。接下来 x 变量被赋值为 Dog 对象，因此当 x 变量执行 move() 方法时，它会表现出狗的奔跑行为。

从上面的运行结果可以看出，同一个变量 x 在执行同一个 move() 方法时，由于 x 指向的对象不同，因此它呈现出不同的行为特征，这就是多态。

看到这里，可能有读者感到失望，这个多态有什么用啊？不就是创建对象、调用方法吗？看不出多态有什么优势啊？

实际上，多态是一种非常灵活的编程机制。假如我们要定义一个 Canvas（画布）类，这个画布类定义一个 draw\_pic() 方法，该方法负责绘制各种图形。该 Canvas类的代码如下：

In \[4\]:

class Canvas:
        def draw_pic(self, shape):
            print('--开始绘图--')
            shape.draw(self)

从上面代码可以看出，Canvas 的 draw\_pic() 方法需要传入一个 shape 参数，该方法就是调用 shape 参数的 draw() 方法将自己绘制到画布上。

从上面程序来看，Canvas 的 draw\_pic() 传入的参数对象只要带一个 draw() 方法就行，至于该方法具有何种行为（到底执行怎样的绘制行为），这与 draw\_pic() 方法是完全分离的，这就为编程增加了很大的灵活性。下面程序定义了三个图形类，并为它们都提供了 draw() 方法，这样它们就能以不同的行为绘制在画布上，这就是多态的实际应用。看如下示例程序：

In \[5\]:

class Rectangle:
        def draw(self, canvas):
            print('在%s上绘制矩形' % canvas)
    class Triangle:
        def draw(self, canvas):
            print('在%s上绘制三角形' % canvas)
    class Circle:
        def draw(self, canvas):
            print('在%s上绘制圆形' % canvas)

In \[6\]:

c = Canvas()
    # 传入Rectangle参数，绘制矩形
    c.draw_pic(Rectangle())

--开始绘图--
    在<__main__.Canvas object at 0x000000000E296550>上绘制矩形

In \[7\]:

# 传入Triangle参数，绘制三角形
    c.draw_pic(Triangle())

--开始绘图--
    在<__main__.Canvas object at 0x000000000E296550>上绘制三角形

In \[8\]:

# 传入Circle参数，绘制圆形
    c.draw_pic(Circle())

--开始绘图--
    在<__main__.Canvas object at 0x000000000E296550>上绘制圆形

从上面这个例子可以体会到 Python 多态的优势。当程序涉及 Canvas 类的 draw\_pic() 方法时，该方法所需的参数是非常灵活的，程序为该方法传入的参数对象只要具有指定方法就行，至于该方法呈现怎样的行为特征，则完全取决于对象本身，这大大提高了 draw\_pic() 方法的灵活性。

### 7.1issubclass和isinstance函数：检查类型 ###

Python 提供了如下两个函数来检查类型：  
1)issubclass(cls, class\_or\_tuple)：检查 cls 是否为后一个类或元组包含的多个类中任意类的子类。  
2)isinstance(obj, class\_or\_tuple)：检查 obj 是否为后一个类或元组包含的多个类中任意类的对象。

通过使用上面两个函数，程序可以方便地先执行检查，然后才调用方法，这样可以保证程序不会出现意外情况。

如下程序示范了通过这两个函数来检查类型：

In \[10\]:

# 定义一个字符串
    hello = "Hello"
    # "Hello"是str类的实例，输出True
    print('"Hello"是否是str类的实例: ', isinstance(hello, str))

"Hello"是否是str类的实例:  True

In \[11\]:

# "Hello"是object类的子类的实例，输出True
    print('"Hello"是否是object类的实例: ', isinstance(hello, object))
    # str是object类的子类，输出True
    print('str是否是object类的子类: ', issubclass(str, object))

"Hello"是否是object类的实例:  True
    str是否是object类的子类:  True

In \[12\]:

# "Hello"不是tuple类及其子类的实例，输出False
    print('"Hello"是否是tuple类的实例: ', isinstance(hello, tuple))
    # str不是tuple类的子类，输出False
    print('str是否是tuple类的子类: ', issubclass(str, tuple))

"Hello"是否是tuple类的实例:  False
    str是否是tuple类的子类:  False

In \[13\]:

# 定义一个列表
    my_list = [2, 4]
    # [2, 4]是list类的实例，输出True
    print('[2, 4]是否是list类的实例: ', isinstance(my_list, list))
    # [2, 4]是object类的子类的实例，输出True
    print('[2, 4]是否是object类及其子类的实例: ', isinstance(my_list, object))
    # list是object类的子类，输出True
    print('list是否是object类的子类: ', issubclass(list, object))

[2, 4]是否是list类的实例:  True
    [2, 4]是否是object类及其子类的实例:  True
    list是否是object类的子类:  True

In \[14\]:

# [2, 4]不是tuple类及其子类的实例，输出False
    print('[2, 4]是否是tuple类及其子类的实例: ', isinstance([2, 4], tuple))
    # list不是tuple类的子类，输出False
    print('list是否是tuple类的子类: ', issubclass(list, tuple))

[2, 4]是否是tuple类及其子类的实例:  False
    list是否是tuple类的子类:  False

通过上面程序可以看出，issubclass() 和 isinstance() 两个函数的用法差不多，区别只是 issubclass() 的第一个参数是类名，而 isinstance() 的第一个参数是变量，这也与两个函数的意义对应：issubclass 用于判断是否为子类，而 isinstance() 用于判断是否为该类或子类的实例。

issubclass() 和 isinstance() 两个函数的第二个参数都可使用元组。例如如下代码：

In \[15\]:

data = (20, 'fkit')
    print('data是否为列表或元组: ', isinstance(data, (list, tuple))) # True
    # str不是list或者tuple的子类，输出False
    print('str是否为list或tuple的子类: ', issubclass(str, (list, tuple)))
    # str是list或tuple或object的子类，输出True
    print('str是否为list或tuple或object的子类 ', issubclass(str, (list, tuple, object)))

data是否为列表或元组:  True
    str是否为list或tuple的子类:  False
    str是否为list或tuple或object的子类  True

此外，Python 为所有类都提供了一个 **bases** 属性，通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组。例如如下代码：

In \[16\]:

class A:
        pass
    class B:
        pass
    class C(A, B):
        pass
    print('类A的所有父类:', A.__bases__)
    print('类B的所有父类:', B.__bases__)
    print('类C的所有父类:', C.__bases__)

类A的所有父类: (<class 'object'>,)
    类B的所有父类: (<class 'object'>,)
    类C的所有父类: (<class '__main__.A'>, <class '__main__.B'>)

Python 还为所有类都提供了一个 **subclasses**() 方法，通过该方法可以查看该类的所有直接子类，该方法返回该类的所有子类组成的列表。例如在上面程序中增加如下两行：

In \[17\]:

print('类A的所有子类:', A.__subclasses__())
    print('类B的所有子类:', B.__subclasses__())

类A的所有子类: [<class '__main__.C'>]
    类B的所有子类: [<class '__main__.C'>]

## 8.枚举类 ##

**8.1枚举类定义**

在某些情况下，一个类的对象是有限且固定的，比如季节类，它只有 4 个对象；再比如行星类，目前只有 8 个对象。这种实例有限且固定的类，在 Python 中被称为枚举类。

程序有两种方式来定义枚举类： 直接使用 Enum 列出多个枚举值来创建枚举类。 通过继承 Enum 基类来派生枚举类。

如下程序示范了直接使用 Enum 列出多个枚举值来创建枚举类：

In \[18\]:

import enum
    # 定义Season枚举类
    Season = enum.Enum('Season', ('SPRING', 'SUMMER', 'FALL', 'WINTER'))

上面程序使用 Enum() 函数（就是 Enum 的构造方法）来创建枚举类，该构造方法的第一个参数是枚举类的类名；第二个参数是一个元组，用于列出所有枚举值。

在定义了上面的 Season 枚举类之后，程序可直接通过枚举值进行前问，这些枚举值都是该枚举的成员，每个成员都有 name、value 两个属性，其中 name 属性值为该枚举值的变量名，value 代表该枚举值的序号（序号通常从 1 开始）。

例如，如下代码测试了枚举成员的用法：

In \[19\]:

# 直接访问指定枚举
    print(Season.SPRING)
    # 访问枚举成员的变量名
    print(Season.SPRING.name)
    # 访问枚举成员的值
    print(Season.SPRING.value)

Season.SPRING
    SPRING
    1

程序除可直接使用枚举之外，还可通过枚举变量名或枚举值来访问指定枚举对象。例如如下代码：

In \[20\]:

# 根据枚举变量名访问枚举对象
    print(Season['SUMMER']) # Season.SUMMER
    # 根据枚举值访问枚举对象
    print(Season(3)) # Season.FALL

Season.SUMMER
    Season.FALL

此外，Python 还为枚举提供了一个 **members** 属性，该属性返回一个 dict 字典，字典包含了该枚举的所有枚举实例。程序可通过遍历 **members** 属性来访问枚举的所有实例。例如如下代码：

In \[21\]:

# 遍历Season枚举的所有成员
    for name, member in Season.__members__.items():
        print(name, '=>', member, ',', member.value)

SPRING => Season.SPRING , 1
    SUMMER => Season.SUMMER , 2
    FALL => Season.FALL , 3
    WINTER => Season.WINTER , 4

如果要定义更复杂的枚举，则可通过继承 Enum 来派生枚举类，在这种方式下程序就可以为枚举额外定义方法了。例如如下程序：

In \[22\]:

import enum
    class Orientation(enum.Enum):
        # 为序列值指定value值
        EAST = '东'
        SOUTH = '南'
        WEST = '西'
        NORTH = '北'
        def info(self):
            print('这是一个代表方向【%s】的枚举' % self.value)

In \[23\]:

print(Orientation.SOUTH)
    print(Orientation.SOUTH.value)
    # 通过枚举变量名访问枚举
    print(Orientation['WEST'])
    # 通过枚举值来访问枚举
    print(Orientation('南'))
    # 调用枚举的info()方法
    Orientation.EAST.info()
    # 遍历Orientation枚举的所有成员
    for name, member in Orientation.__members__.items():
        print(name, '=>', member, ',', member.value)

Orientation.SOUTH
    南
    Orientation.WEST
    Orientation.SOUTH
    这是一个代表方向【东】的枚举
    EAST => Orientation.EAST , 东
    SOUTH => Orientation.SOUTH , 南
    WEST => Orientation.WEST , 西
    NORTH => Orientation.NORTH , 北

上面程序通过继承 Enum 派生了 Orientation 枚举类，通过这种方式派生的枚举类既可额外定义方法，如上面的 info() 方法所示，也可为枚举指定 value（value 的值默认是 1、2、3、…）。

虽然此时 Orientation 枚举的 value 是由类型，但该枚举同样可通过 value 来访问特定枚举，如上面程序中的 Orientation('南')，这是完全允许的。

### 8.2 枚举的构造器 ###

枚举也是类，因此枚举也可以定义构造器。为枚举定义构造器之后，在定义枚举实例时必须为构造器参数设置值。例如如下程序：

In \[24\]:

import enum
    class Gender(enum.Enum):
        MALE = '男', '阳刚之力'
        FEMALE = '女', '柔顺之美'
        def __init__(self, cn_name, desc):
            self._cn_name = cn_name
            self._desc = desc
        @property
        def desc(self):
            return self._desc
        @property
        def cn_name(self):
            return self._cn_name

In \[25\]:

# 访问FEMALE的name
    print('FEMALE的name:', Gender.FEMALE.name)
    # 访问FEMALE的value
    print('FEMALE的value:', Gender.FEMALE.value)
    # 访问自定义的cn_name属性
    print('FEMALE的cn_name:', Gender.FEMALE.cn_name)
    # 访问自定义的desc属性
    print('FEMALE的desc:', Gender.FEMALE.desc)

FEMALE的name: FEMALE
    FEMALE的value: ('女', '柔顺之美')
    FEMALE的cn_name: 女
    FEMALE的desc: 柔顺之美

上面程序定义了 Gender 枚举类，并为它定义了一个构造器，调用该构造器需要传入 cn\_name 和 desc 两个参数，因此程序使用如下代码来定义 Gender 的枚举值。

上面代码为 MALE 枚举指定的 value 是‘男’和‘阳刚之力’这两个字符串，其实它们会被自动封装成元组后传给 MALE 的 value 属性；而且此处传入的‘男’和‘阳刚之力’ 这两个参数值正好分别传给 cnname 和 desc 两个参数。简单来说，枚举的构造器需要几个参数，此处就必须指定几个值。

转载于:https://www.cnblogs.com/xinmomoyan/p/10809124.html