第 11 章 面 向 对 象 编 程 1
目 录 • 10.1 面 向 对 象 程 序 设 计 基 础 • 10.2 类 与 对 象 • 10.3 属 性 • 10.4 方 法 • 10.5 继 承 和 多 态 • 10.6 重 载 * • 10.7 面 向 对 象 程 序 设 计 应 用 举 例 2
10.1 面 向 对 象 程 序 设 计 基 础 3
11.1.1 面 向 过 程 与 面 向 对 象 1. 面 向 过 程 程 序 设 计 • 主 张 使 用 顺 序 、 选 择 、 循 环 三 种 基 本 结 构 来 嵌 套 连 结 成 具 有 复 杂 层 次 的 “ 结 构 化 程 序 ” ， 严 格 控 制 GOTO 语 句 的 使 用 • 采 用 “ 自 顶 而 下 ， 逐 步 求 精 ” 的 设 计 方 法 • 采 用 “ 模 块 化 ” 编 程 方 法 ， 将 程 序 结 构 按 功 能 划 分 为 若 干 个 基 本 模 块 ， 自 顶 向 下 、 分 而 治 之 4
2. 面 向 对 象 程 序 设 计 • 把 现 实 世 界 看 成 是 一 个 由 对 象 构 成 的 世 界 ， 每 一 个 对 象 都 能 够 接 受 数 据 、 处 理 数 据 并 将 数 据 传 达 给 其 他 对 象 ， 它 们 既 独 立 ， 又 能 够 互 相 调 用 • 对 象 是 程 序 的 基 本 元 素 ， 它 将 数 据 和 操 作 紧 密 联 结 在 一 起 ， 保 护 数 据 不 会 被 外 界 的 函 数 意 外 改 变 5
面 向 对 象 程 序 设 计 的 优 点 （ 1 ） 数 据 抽 象 的 概 念 可 以 在 保 持 外 部 接 口 不 变 的 情 况 下 改 变 内 部 实 现 ， 从 而 减 少 甚 至 避 免 对 外 界 的 干 扰 ； （ 2 ） 通 过 继 承 大 幅 减 少 冗 余 的 代 码 ， 并 可 以 方 便 地 扩 展 现 有 代 码 ， 提 高 编 码 效 率 ， 降 低 了 软 件 维 护 的 难 度 ； （ 3 ） 通 过 对 对 象 的 辨 别 、 划 分 ， 可 以 将 软 件 系 统 分 割 为 若 干 相 对 独 立 的 部 分 ， 在 一 定 程 度 上 更 便 于 控 制 软 件 复 杂 度 ； （ 4 ） 以 对 象 为 中 心 的 设 计 可 以 帮 助 开 发 人 员 从 静 态 （ 属 性 ） 和 动 态 （ 方 法 ） 两 个 方 面 把 握 问 题 ， 从 而 更 好 地 实 现 系 统 ； （ 5 ） 通 过 对 象 的 聚 合 、 联 合 ， 可 以 在 保 证 封 装 与 抽 象 的 原 则 下 实 现 对 象 在 内 在 结 构 以 及 外 在 功 能 上 的 扩 充 ， 从 而 实 现 对 象 由 低 到 高 的 升 级 。 6
11.1.2 面 向 对 象 的 基 本 概 念 • 对 象 ： 要 研 究 的 任 何 事 物 • 类 ： 对 象 的 模 板 ， 是 具 有 相 同 类 型 的 对 象 的 抽 象 • 消 息 ： 对 象 之 间 进 行 通 信 的 一 种 规 格 说 明 • 封 装 ： 一 种 信 息 隐 蔽 技 术 ， 把 对 象 的 设 计 者 和 对 象 的 使 用 者 分 开 ， 让 使 用 者 不 必 知 晓 行 为 实 现 的 细 节 ， 只 需 用 设 计 者 提 供 的 消 息 来 访 问 该 对 象 • 继 承 ： 子 类 自 动 共 享 父 类 的 数 据 和 方 法 • 多 态 ： 不 同 的 对 象 接 收 同 一 消 息 将 产 生 完 全 不 同 的 行 为 7
10.2 类 与 对 象 8
11.2.1 类 的 定 义 • 定 义 类 的 一 般 格 式 class 类 名 ( 父 类 名 ): 类 体 ① class Person(object): pass ② class Person(): pass ③ class Person: pass Python 3.x 中 这 3 种 写 法 都 支 持 9
定 义 一 个 Person 类 的 例 子 class Person: name = 'Holly' # 属 性 def printName(self): # 方 法 print(self.name) 10
11.2.2 对 象 的 创 建 和 使 用 • 创 建 对 象 ， 又 叫 类 的 实 例 化 • 实 例 化 的 一 般 语 法 格 式 对 象 名 = 类 名 ( 参 数 列 表 ) • 访 问 实 例 对 象 的 属 性 和 方 法 • 对 象 名 . 属 性 名 • 对 象 名 . 方 法 名 ( 参 数 列 表 ) 11
例 11-1 创 建 Employee 类 ， 并 创 建 两 个 Employee 对 象 ， 访 问 其 属 性 和 方 法 class Employee: empCount = 0 # 员 工 数 def __init__(self, name, salary): # 构 造 方 法 self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): # 显 示 员 工 数 print("Total Employee %d" % Employee.empCount) def displayEmployee(self): # 显 示 员 工 信 息 print("Name : ", self.name, ", Salary: ", self.salary) 下 一 页 （ 续 ） 12
接 上 一 页 （ 续 ） # 创 建 Employee 类 的 第 一 个 对 象 emp1 = Employee("Zara", 2000) # 创 建 Employee 类 的 第 二 个 对 象 emp2 = Employee("Manni", 5000) emp1.displayEmployee() emp2.displayEmployee() print("Total Employee %d" % Employee.empCount) Name : Zara , Salary: 2000 Name : Manni , Salary: 5000 Total Employee 2 13
10.3 属 性 14
什 么 是 属 性 ？ • 属 性 是 类 中 对 象 所 具 有 的 性 质 ， 即 数 据 值 ， 又 称 为 数 据 成 员 • 属 性 实 际 上 就 是 定 义 在 类 中 的 变 量 • 属 性 的 分 类 • 根 据 定 义 的 位 置 分 ： 实 例 属 性 、 类 属 性 • 根 据 访 问 控 制 权 限 分 ： 私 有 属 性 、 公 有 属 性 15
11.3.1 实 例 属 性 和 类 属 性 1. 实 例 属 性 • 是 某 个 具 体 实 例 特 有 的 属 性 • 不 影 响 类 ， 也 不 影 响 其 他 实 例 • 一 般 定 义 在 __init__() 方 法 中 self. 实 例 变 量 名 = 初 始 值 name ： 张 三 sex ： 男 height ： 178 16
例 11-2 定 义 一 个 Student 类 ， 设 置 有 实 例 属 性 ID 、 name 、 sex ， 分 别 创 建 两 个 对 象 st1 和 st2 ， 并 通 过 调 用 方 法 输 出 其 姓 名 class Student: def __init__(self, ID, name, sex): self.ID = ID self.name = name self.sex = sex def sayhello(self): fmt = "Hello, " if self.sex == "female": fmt = fmt + "Ms. {}!" else: fmt = fmt + "Mr. {}!" print(fmt.format(self.name)) 构 造 方 法 实 例 方 法 定 义 实 例 属 性 接 下 一 页 （ 续 ） 17
接 上 页 （ 续 ） st1 = Student("1111","Holly","female") # 创 建 第 一 个 对 象 st1.sayhello() st2 = Student("2222","John","male") # 创 建 第 二 个 对 象 st2.sayhello() print(st1.name, " 的 学 号 是 ", st1.ID) Hello, Ms. Holly! Hello, Mr. John! Holly 的 学 号 是 1111 类 外 引 用 实 例 属 性 用 ： 对 象 名 . 属 性 名 类 内 引 用 实 例 属 性 用 ： self. 属 性 名 18
2. 类 属 性 • 类 属 性 是 实 例 对 象 共 有 的 属 性 • 类 似 于 全 局 变 量 ， 在 内 存 中 只 存 在 一 个 副 本 • 类 属 性 定 义 在 类 中 方 法 外 • 引 用 方 式 ： • 类 名 . 属 性 名 • 对 象 名 . 属 性 名 不 推 荐 使 用 19
例 11-3 定 义 一 个 Team 类 ， 设 置 有 类 属 性 company 、 boss ， 以 及 实 例 属 性 ID 和 leader 。 创 建 两 个 对 象 t1 和 t2 ， 分 别 输 出 其 信 息 class Team: company = "ABC" boss = "Jenny" def __init__(self, ID, leader): self.ID = ID self.leader = leader 类 属 性 实 例 属 性 下 一 页 （ 续 ） 20
接 上 一 页 （ 续 ） t1 = Team("1", "Holly") # 创 建 第 一 个 对 象 t2 = Team("2", "John") # 创 建 第 二 个 对 象 print(" 公 司 :{}\n 老 板 :{}".format(Team.company, Team.boss)) print("{} 组 的 组 长 是 {}".format(t1.ID, t1.leader)) print("{} 组 的 组 长 是 {}".format(t2.ID, t2.leader)) 公 司 :ABC 老 板 :Jenny 1 组 的 组 长 是 Holly 2 组 的 组 长 是 John 21
11.3.2 私 有 属 性 和 公 有 属 性 • Python 中 用 名 字 来 区 分 公 有 还 是 私 有 • 双 下 划 线 开 头 （ 不 以 双 下 划 线 结 尾 ） ： 私 有 • 单 下 划 线 开 头 ： 只 允 许 本 身 和 子 类 访 问 • 双 下 划 线 开 头 、 双 下 划 线 结 尾 ： 专 用 标 识 符 ， 有 特 定 含 义 • 其 他 ： 全 是 公 有 方 法 名 的 取 名 规 则 也 有 同 样 效 果 22
例 如 ： class Parent: # 基 类 def __init__(self, value): self.__value = value class Child(Parent): # 继 承 自 Parent 的 子 类 def get_value(self): return self.__value child = Child(4) print(child.get_value()) 私 有 属 性 出 错 23
11.3.3 特 殊 属 性 与 方 法 • 双 下 划 线 开 头 和 结 尾 的 属 性 和 方 法 特殊属性或方法名 含义与作用 object.__dict__ 字典，除了一些特殊的属性，实例、类型等对象的所 有属性，都放置在其 __dict__ 字典中。 instance.__class__ 类实例所属的类，可理解为当前实例的模板。 class.__bases__ 类对象的基类构成的元组，只包含直接基类，并不是 继承链上的所有基类。 definition.__name__ 对象的名称，比如 type 、 class 对象的名称就是系统 内置的或自定义的名称字符串，类型的实例通常没有 属性 __name__ 。 definition.__qualname__ 类的限定名称。 class.__mro__ 该属性用于存储 MRO 元组，以便在方法解析期间提供 基类排序。该属性是动态的，每当继承层次更新时， 该属性都可能发生改变。 24
特 殊 属 性 和 方 法 （ 续 1 ） 特殊属性或方法名 含义与作用 class.mro() 通过元类（ metaclass ）可以覆盖此方法，以自定义 类实例的方法解析顺序。该方法会在程序初始化时 调用，其结果存储在 __mro__ 中。 class.__subclasses__() 返回子类列表。 __init__() __init__() 是一个实例方法，用来在实例创建完成 后进行必要的初始化，该方法必须返回 None 。 Python 不会自动调用父类的 __init__() 方法，需要 额外的调用 super(C, self).__init__() 来完成。 __new__(cls[, args...]) __new__() 是一个静态方法，用于根据类型创建实例 。 Python 在调用 __new__() 方法获得实例后，会调用 这个实例的 __init__() 方法，然后将最初传给 __new__() 方法的参数都传给 __init__() 方法。 25
特 殊 属 性 和 方 法 （ 续 2 ） 特殊属性或方法名 含义与作用 __del__(self) 在 GC （ garbage collector ）之前， Python 会调用这 个对象的 __del__() 方法完成一些终止化工作。如果 没有 __del__() 方法，那么 Python 不做特殊的处理。 __repr__(self) __repr__() 方法返回的字符串主要是面向解释器的 ，如果没有定义 __repr__() ，那么 Python 使用一种 默认的表现形式。 __str__(self) 与 __repr__() 返回的详尽的、准确的、无歧义的对 象描述字符串不同， __str__() 方法只是返回一个对 象的简洁的字符串表达形式；当 __str__() 缺失时， Python 会调用 __repr__() 方法。 __unicode__(self) 优先级高于 __str__() 方法；同时定义这两个方法的 实例，调用结果则相同。 26
10.4 方 法 27
什 么 是 方 法 ？ • 方 法 是 定 义 在 类 中 的 函 数 • 分 为 3 类 • 实 例 方 法 • 类 方 法 • 静 态 方 法 28
11.4.1 实 例 方 法 • 定 义 形 式 ： def 实 例 方 法 名 (self, [ 形 参 列 表 ]): 函 数 体 • 调 用 形 式 ： 对 象 名 . 方 法 名 第 1 个 参 数 一 般 是 self 29
例 11-4 实 例 方 法 的 例 子 class Person(object): def __init__(self, name, score): self.__name = name self.__score = score def get_grade(self): if self.__score >= 80: return 'A' if self.__score >= 60: return 'B' return 'C' p1 = Person('Bob', 90) p2 = Person('Alice', 65) p3 = Person('Tim', 48) print(p1.get_grade()) print(p2.get_grade()) print(p3.get_grade()) 30
实 例 方 法 的 注 意 事 项 • 不 要 求 第 1 个 参 数 必 须 是 self （ 但 是 建 议 是 self ， 免 得 引 起 误 会 ） • 不 属 于 类 方 法 和 静 态 方 法 ， 就 一 定 属 于 实 例 方 法 • 实 例 方 法 是 使 用 最 多 的 一 种 方 法 31
11.4.2 类 方 法 • 用 于 只 跟 类 有 关 的 操 作 ， 不 跟 具 体 的 实 例 有 关 • 定 义 格 式 ： @classmethod def 类 方 法 名 (cls, [ 形 参 列 表 ]): 函 数 体 类 方 法 的 标 志 第 1 个 参 数 一 般 是 cls 类 方 法 只 能 修 改 类 属 性 ， 不 能 修 改 实 例 属 性 调 用 ： 类 名 . 类 方 法 名 对 象 名 . 类 方 法 名 32
例 11-5 类 方 法 的 例 子 class Goods: __discount = 1 # 私 有 的 类 属 性   def __init__(self, name, price): # 构 造 方 法 self.name = name self.price = price 下 一 页 （ 续 ） 33
接 上 一 页 （ 续 1 ） @ classmethod def change_discount(cls, new_discount ): cls.__discount = new_discount   @ property # property 装 饰 器 可 以 把 方 法 当 成 属 性 使 用 def finally_price(self): return self.price * self.__discount 下 一 页 （ 续 ） 类 方 法 34
接 上 一 页 （ 续 2 ） banana = Goods(' 香 蕉 ', 10) apple = Goods(' 苹 果 ', 16)   Goods.change_discount(0.8) print(banana.finally_price) print(apple.finally_price)   Goods.change_discount(0.5) print(banana.finally_price) print(apple.finally_price ) 运 行 结 果 ： 8.0 12.8 5.0 8.0 思 考 ： 为 什 么 修 改 折 扣 率 要 采 用 类 方 法 ？ 35
11.4.3 静 态 方 法 • 一 般 用 于 和 类 、 对 象 都 无 关 的 代 码 （ 跟 普 通 函 数 的 作 用 一 样 ， 只 是 位 置 出 现 在 类 中 ） • 定 义 形 式 ： @staticmethod def 静 态 方 法 名 ([ 形 参 列 表 ]) 函 数 体 静 态 方 法 的 标 志 对 参 数 没 有 任 何 要 求 36
例 11-6 静 态 方 法 的 例 子 class Game: @staticmethod def menu(): print('------') print(' 开 始 [1]') print(' 暂 停 [2]') print(' 退 出 [3]') Game.menu() 静 态 方 法 ， 与 类 和 对 象 都 无 关 只 是 为 了 显 示 菜 单 调 用 静 态 方 法 ： 可 以 用 “ 类 名 . 方 法 名 ” 也 可 以 用 “ 对 象 名 . 方 法 名 ” 37
10.5 继 承 和 多 态 38
11.5.1 继 承 • 子 类 可 以 直 接 使 用 父 类 的 所 有 公 有 属 性 和 方 法 • 类 之 间 关 系 ： • 被 继 承 者 ： 称 为 父 类 、 基 类 、 超 类 • 继 承 者 ： 称 为 子 类 、 派 生 类 • 定 义 子 类 的 形 式 ： class 子 类 名 ( 父 类 1 [, 父 类 2, ...]) 类 体 父 类 可 以 有 一 个 ， 也 可 以 有 多 个 多 个 父 类 ： 多 重 继 承 39
例 11-7 创 建 父 类 Person ， 派 生 出 子 类 Man class Person: # 父 类 ， 又 叫 基 类 def __init__(self, name, age): # 构 造 方 法 self.name = name self.age = age def print_age(self): # 父 类 的 实 例 方 法 print("%s's age is %s" % (self.name, self.age)) 下 一 页 （ 续 ） 40
接 上 一 页 （ 续 1 ） class Man(Person): # 子 类 ， 也 叫 派 生 类 work = "Teacher" def print_age(self): # 父 类 、 子 类 同 名 的 实 例 方 法 print("Mr. %s's age is %s" %(self.name, self.age)) def print_work(self): # 子 类 扩 展 出 来 的 实 例 方 法 print("Mr. %s's work is %s" %(self.name, self.work)) 下 一 页 （ 续 ） Man 中 没 有 的 属 性 ， 来 自 父 类 41
接 下 一 页 （ 续 2 ） bob = Man('Bob', 33) bob.print_age() bob.print_work() Mr. Bob's age is 33 Mr. Bob's work is Teacher 42
11.5.2 多 态 • 多 态 的 一 种 体 现 ： 不 同 的 类 中 ， 具 有 同 名 的 方 法 • 另 外 方 面 的 多 态 体 现 ： Python 本 身 就 是 一 种 多 态 语 言 ， 在 很 多 地 方 都 体 现 了 多 态 性 • 变 量 无 需 指 明 类 型 ， 运 行 时 自 动 确 定 变 量 的 类 型 • len() 函 数 在 运 行 时 通 过 参 数 类 型 确 定 具 体 的 计 算 过 程 • ...... 43
例 11-8 定 义 三 个 类 Circle 、 Square 和 Rectangle ， 它 们 都 有 求 面 积 的 Area() 方 法 import math class Circle: def __init__(self, r): self.r = r def Area(self): # 求 圆 面 积 area = math.pi * self.r ** 2 return area 下 一 页 （ 续 ） 44
接 上 一 页 （ 续 1 ） class Square: def __init__(self, size): self.size = size def Area(self): # 求 正 方 形 面 积 area = self.size * self.size return area 下 一 页 （ 续 ） 45
接 上 一 页 （ 续 2 ） class Rectangle: def __init__(self, a, b): self.a = a self.b = b def Area(self): # 求 矩 形 面 积 area = self.a * self.b return area 下 一 页 （ 续 ） 46
接 上 一 页 （ 续 3 ） a = Circle(5) print(a.Area()) b = Square(5) print(b.Area()) c = Rectangle(2, 3) print(c.Area()) 78.53981633974483 25 6 47
10.6 重 载 * 48
什 么 是 重 载 ？ • 其 他 OOP 语 言 ， 例 如 C++ 、 Java 等 ， 一 般 都 包 括 了 方 法 重 载 和 运 算 符 重 载 • 方 法 重 载 ： 函 数 名 相 同 ， 但 是 参 数 的 类 型 或 数 量 不 同 • 运 算 符 重 载 ： 同 一 个 运 算 符 在 不 同 场 景 下 有 不 同 的 处 理 方 式 • 例 如 “+” ， 可 以 做 加 法 ， 可 以 做 字 符 串 或 列 表 连 接 • Python 不 支 持 方 法 重 载 ， 只 有 运 算 符 重 载 • Python 无 需 方 法 重 载 ， 本 身 就 支 持 不 定 长 参 数 和 自 动 数 据 类 型 49
Python 在 运 算 符 重 载 方 面 的 限 制 • 不 能 重 载 内 置 类 型 的 运 算 符 • 不 能 新 建 运 算 符 ， 只 能 重 载 现 有 运 算 符 • 某 些 运 算 符 不 能 重 载 ， 如 is 、 and 、 or 和 not Python 的 运 算 符 实 际 上 是 通 过 调 用 对 象 的 特 殊 方 法 实 现 的 50
常 见 运 算 符 与 对 应 的 特 殊 方 法 （ 1 ） 类型 运算符 特殊方法 含义 一元运算符 - __neg__ 负号 + __pos__ 正号 ~ __invert__ 对整数按位取反 51
常 见 运 算 符 与 对 应 的 特 殊 方 法 （ 2 ） 类型 运算符 特殊方法 含义 中缀运算符 + __add__ 加法 - __sub__ 减法 * __mul__ 乘法 / __truediv__ 除法 // __floordiv__ 整除 % __mod__ 取模（求余） ** __pow__ 幂运算 52
常 见 运 算 符 与 对 应 的 特 殊 方 法 （ 3 ） 类型 运算符 特殊方法 含义 复合赋值算术运 算符 += __iadd__ 加法 -= __isub__ 减法 *= __imul__ 乘法 /= __itruediv__ 除法 //= __ifloordiv__ 整除 %= __imod__ 取模（求余） **= __ipow__ 幂运算 53
常 见 运 算 符 与 对 应 的 特 殊 方 法 （ 4 ） 类型 运算符 特殊方法 含义 比较运算符 < __lt__ 小于 <= __le__ 小于等于 > __gt__ 大于 >= __ge__ 大于等于 == __eq__ 等于 != __ne__ 不等于 54
常 见 运 算 符 与 对 应 的 特 殊 方 法 （ 5 ） 类型 运算符 特殊方法 含义 位运算符 & __and__ 位与 | __or__ 位或 ^ __xor__ 位异或 << __lshift__ 左移 >> __rshift__ 右移 55
常 见 运 算 符 与 对 应 的 特 殊 方 法 （ 6 ） 类型 运算符 特殊方法 含义 复合赋值位运 算符 &= __iand__ 位与 |= __ior__ 位或 ^= __ixor__ 位异或 <<= __ilshift__ 左移 >>= __irshift__ 右移 56
例 11-9 设 计 一 个 新 的 数 值 类 型 ， 有 自 己 的 表 示 形 式 ， 并 重 载 运 算 符 + class MyNumber: def __init__(self, value): self.data = value # 用 data 保 存 数 据 def __repr__(self): # 对 应 于 内 置 函 数 str(), 用 于 显 示 数 据 return "Mynumber(%d)" % self.data def __add__(self, other): v = self.data + other.data r = MyNumber(v) return r 下 一 页 （ 续 ） 57
接 上 一 页 （ 续 ） n1 = MyNumber(100) n2 = MyNumber(200) n3 = n1 + n2 # 运 算 符 重 载 的 计 算 结 果 print(n3.data) print(n1, '+', n2, '=', n3) 300 Mynumber(100) + Mynumber(200) = Mynumber(300) 58
10.7 面 向 对 象 程 序 设 计 应 用 举 例 59
例 11-10 定 义 一 个 Dog 类 ， 类 属 性 有 名 字 （ name ） 、 毛 色 （ color ） 、 体 重 （ weight ） ， 方 法 为 叫 （ bark ） ， 调 用 该 方 法 时 输 出 “wang ！ Wang ！ ” class Dog: # 定 义 类 def __init__(self, name, color, weight): # 构 造 方 法 self.name = name self.color = color self.weight = weight def bark(): # 实 例 方 法 print("wang! wang!") Dog.bark() # 通 过 类 名 调 用 方 法 60
例 11-11 设 计 一 个 Rectangle 类 ， 属 性 为 左 上 角 和 右 下 角 的 坐 标 ， 编 写 方 法 ， 实 现 根 据 坐 标 计 算 矩 形 的 面 积 class Rectangle: def __init__(self, left, top, right, bottom): # 构 造 方 法 self.left = left self.top = top self.right = right self.bottom = bottom 下 一 页 （ 续 ） 61
接 上 一 页 （ 续 ） def get_area(self): # 实 例 方 法 求 面 积 a = self.right - self.left b = self.bottom - self.top return abs(a * b) rec = Rectangle(0, 1, 5, 8) print("Area=", rec.get_area()) Area= 35 62
例 11-12 首 先 设 计 一 个 颜 色 类 作 为 基 类 ， 包 括 红 、 绿 、 蓝 三 原 色 成 员 变 量 ， 并 添 加 构 造 方 法 、 显 示 三 原 色 值 的 方 法 以 及 修 改 红 色 值 的 方 法 ； 接 着 设 计 一 个 颜 色 类 的 派 生 类 叫 彩 虹 类 ， 它 在 颜 色 类 的 基 础 上 再 增 加 四 种 颜 色 ， 即 橙 、 黄 、 青 、 紫 ， 也 添 加 构 造 方 法 ， 显 示 方 法 和 修 改 紫 色 值 的 方 法 ， 最 后 在 主 模 块 中 定 义 这 两 个 类 的 对 象 ， 测 试 所 设 计 的 方 法 并 显 示 最 后 结 果 class Color: # 定 义 颜 色 基 类 def __init__(self, red, green, blue): # 构 造 方 法 self.red = red self.green = green self.blue = blue 下 一 页 （ 续 ） 63
接 上 一 页 （ 续 1 ） def show_color(self): # 显 示 颜 色 color_str = "(" + str(self.red) + "," + str(self.green) + "," + str(self.blue) + ")" print(color_str) def modi_red(self, red): # 修 改 红 色 self.red = red 下 一 页 （ 续 ） 64
接 上 一 页 （ 续 2 ） class Rainbow(Color): # 定 义 子 类 def __init__(self, red, green, blue, orange, yellow, cyan, purple): self.red = red self.green = green self.blue = blue self.orange = orange self.yellow = yellow self.cyan = cyan self.purple = purple 下 一 页 （ 续 ） 65
接 上 一 页 （ 续 3 ） def show_color(self): # 显 示 颜 色 color_str = "(" + str(self.red) + "," + str(self.green) + "," + str(self.blue) + "," color_str = color_str + str(self.orange) + "," + str(self.yellow) + "," color_str = color_str + str(self.cyan) + "," + str(self.purple) + ")" print(color_str) def modi_purple(self, purple): # 修 改 紫 色 self.purple = purple 下 一 页 （ 续 ） 66
接 上 一 页 （ 续 4 ） if __name__ == '__main__': # 控 制 只 能 在 主 程 序 中 执 行 c1 = Color(150, 230, 100) # 创 建 一 个 Color 类 对 象 print("Before:c1=", end="") c1.show_color() c1.modi_red(200) print("After:c1=", end="") c1.show_color() c2 = Rainbow(100, 200, 50, 30, 60, 80, 150) print("Before:c2=", end="") c2.show_color() c2.modi_red(200) c2.modi_purple(0) print("After:c2=", end="") c2.show_color() Before:c1=(150,230,100) After:c1=(200,230,100) Before:c2=(100,200,50,30,60,80,150) After:c2=(200,200,50,30,60,80,0) 67
例 11-13 为 学 校 人 事 部 门 设 计 一 个 简 单 的 人 事 管 理 程 序 ， 满 足 如 下 要 求 ： （ 1 ） 学 校 人 员 分 为 三 类 ： 教 师 、 学 生 、 职 员 ； （ 2 ） 三 类 人 员 的 共 同 属 性 是 姓 名 、 性 别 、 年 龄 、 部 门 ； （ 3 ） 教 师 的 特 别 属 性 是 职 称 、 主 讲 课 程 ； （ 4 ） 学 生 的 特 别 属 性 是 专 业 、 入 学 日 期 ； （ 5 ） 职 员 的 特 别 属 性 是 工 资 。 程 序 可 以 统 计 学 校 总 人 数 和 各 类 人 员 的 人 数 ， 并 随 着 新 人 进 入 注 册 和 离 校 注 销 而 动 态 变 化 。 68
程 序 代 码 ： class Member: # 定 义 基 类 count = 0 # 人 数 ， 类 属 性 def __init__(self, name, sex, age, department): self.name = name self.sex = sex self.age = age self.department 下 一 页 （ 续 ） 69
接 上 一 页 （ 续 1 ） class Teacher(Member): # 定 义 教 师 子 类 count=0 # 人 数 ， 类 属 性 def __init__(self, name, sex, age, department, title, course): self.name = name self.sex = sex self.age = age self.department = department self.title = title self.course = course Teacher.count += 1 Member.count += 1 def __del__(self): # 析 构 方 法 Teacher.count -= 1 Member.count -= 1 下 一 页 （ 续 ） 70
接 上 一 页 （ 续 2 ） class Student(Member): # 定 义 学 生 子 类 count = 0 # 人 数 ， 类 属 性 def __init__(self, name, sex, age, department, major, time_enrollment): self.name = name self.sex = sex self.age = age self.department = department self.major = major self.time_enrollment = time_enrollment Student.count += 1 Member.count += 1 def __del__(self): # 析 构 方 法 Student.count -= 1 Member.count -= 1 下 一 页 （ 续 ） 71
接 上 一 页 （ 续 3 ） class Staff(Member): # 定 义 职 员 子 类 count = 0 # 人 数 ， 类 属 性 def __init__(self, name, sex, age, department, salary): # 构 造 方 法 self.name = name self.sex = sex self.age = age self.department = department self.salary = salary Staff.count += 1 Member.count += 1 def __del__(self): # 析 构 方 法 Staff.count -= 1 Member.count -= 1 下 一 页 （ 续 ） 72
接 上 一 页 （ 续 4 ） t1 = Teacher("Holly", "female", 30, "Computer", "Professor", "Network") t2 = Teacher("John", "male", 40, "Computer", "Lecture", "OS") t3 = Teacher("Jenny", "female", 50, "Maths", "Professor", "Matrix") stu1 = Student("Ada", "female",20, "Computer", "Network Engineering", "Sept 1,2018") stu2 = Student("Jorge", "male", 21, "Computer", "Network Engineering", "Sept 1,2017") stf1 = Staff("Rose", "famale", 35, "Maths", 3500) print("Before:") print(" 教 师 有 :", Teacher.count) print(" 学 生 有 :", Student.count) print(" 职 员 有 :", Staff.count) 下 一 页 （ 续 ） 73
接 上 一 页 （ 续 5 ） del t1 del stu1 del stf1 print("After:") print(" 教 师 有 :", Teacher.count) print(" 学 生 有 :", Student.count) print(" 职 员 有 :", Staff.count) Before: 教 师 有 : 3 学 生 有 : 2 职 员 有 : 1 After: 教 师 有 : 2 学 生 有 : 1 职 员 有 : 0 74
档铺网——在线文档免费处理