标签:name tuple 03python list 枚举 面向对象编程 子类 print
<style></style> <style></style> <style></style>
7.1 多态性
对于弱类型的语言来说,变量并没有声明类型,因此同一个变量完全可以在不同的时间引用不同的对象。当同一个变量在调用同一个方法时,完全可能呈现出多种行为(具体呈现出哪种行为由该变量所引用的对象来决定),这就是所谓的多态(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.2 issubclass和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类的实例: TrueIn [11]:
# "Hello"是object类的子类的实例,输出True print('"Hello"是否是object类的实例: ', isinstance(hello, object)) # str是object类的子类,输出True print('str是否是object类的子类: ', issubclass(str, object))
"Hello"是否是object类的实例: True str是否是object类的子类: TrueIn [12]:
# "Hello"不是tuple类及其子类的实例,输出False print('"Hello"是否是tuple类的实例: ', isinstance(hello, tuple)) # str不是tuple类的子类,输出False print('str是否是tuple类的子类: ', issubclass(str, tuple))
"Hello"是否是tuple类的实例: False str是否是tuple类的子类: FalseIn [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类的子类: TrueIn [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.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_nameIn [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 两个参数。简单来说,枚举的构造器需要几个参数,此处就必须指定几个值。
标签:name,tuple,03python,list,枚举,面向对象编程,子类,print 来源: https://www.cnblogs.com/xinmomoyan/p/10809124.html
本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享; 2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关; 3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关; 4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除; 5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。