Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。
参考：Python入门之类(class)、python中class的定义及使用
接下来我们先来简单的了解下面向对象的一些基本特征。
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。
面向对象技术简介
- 类(Class)： 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- **数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。
- **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
- **实例变量：**定义在方法中的变量，只作用于当前实例的类。
- **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，素以Dog也是一个Animal。
- **实例化：**创建一个类的实例，类的具体对象。
- **方法：**类中定义的函数。
- **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
python3 类创建
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
#创建类
class Foo(): #class是关键字（表示要开始创建类）：Foo是新建类名称
#创建类中函数
def bar(self): #self特殊参数（必填）
pass
#根据Foo创建对象obj
obj = Foo
'''
ps：类中的函数第一个参数必须是self
类中定义的函数叫做“方法”
'''
总结：函数式的应用场景 –> 各个函数之间是独立且无共用的数据
面向对象三大特性
面向对象的三大特性是指：封装、继承和多态。
一、封装
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：
- 将内容封装到某处
- 从某处调用被封装的内容
#创建类
class Foo():
def __init__(self, name, age): #构造函数，类实例化是自动执行
#初始化实例属性
self.name = name
self.age = age
#根据类Foo创建对象
#自动执行Foo类的__init__方法
obj1 = Foo('chengd', 18) #将changd和18分别封装到obj1/self的name和age属性中（此处obj2其实就是self）
#根据类Foo创建对象
#自动执行Foo类的__init__方法
obj2 = Foo('python', 99) #将python和99分别封装到obj2/self的name和age属性中（此处obj2其实就是self）
self是一个形式参数，
当执行obj1=Foo('wupeiqi', 18)时，self等于obj1
当执行obj2=Foo('alex', 78)时，self等于obj2
所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。
调用被封装的内容时，有两种情况：
- 通过对象直接调用
- 通过self间接调用
1、通过对象直接调用被封装的内容
上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名
class Foo():
def __init__(self, name, age):
#初始化实例属性
self.name = name
self.age = age
obj1 = Foo('chengd', 18)
print(obj1.name) #直接调用obj1对象的name属性
print(obj1.age) #直接调用obj1对象的age属性
obj2 = Foo('python', 99)
print(obj2.name)
print(obj2.age)
结果：
chengd
18
python
99
2、通过self间接调用被封装的内容
执行类中的方法时，需要通过self间接调用被封装的内容
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
def detail(self):
print(self.name)
print(self.age)
obj1 = Foo('chengd', 18)
obj1.detail() # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 chengd ；self.age 是 18
obj2 = Foo('python', 99)
obj2.detail() # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 python ； self.age 是 99
结果：
chengd
18
python
99
综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。
将多个函数封装成类的例子
这是多个自定义函数组成的简单游戏代码：
import time, random
# 需要的数据和变量放在开头
player_list = ['【狂血战士】', '【森林箭手】', '【光明骑士】', '【独行剑客】', '【格斗大师】', '【枪弹专家】']
enemy_list = ['【暗黑战士】', '【黑暗弩手】', '【暗夜骑士】', '【嗜血刀客】', '【首席刺客】', '【陷阱之王】']
players = random.sample(player_list, 3)
enemies = random.sample(enemy_list, 3)
player_info = {}
enemy_info = {}
# 随机生成角色的属性
def born_role():
life = random.randint(100, 180)
attack = random.randint(30, 50)
return life, attack
# 生成和展示角色信息
def show_role():
for i in range(3):
player_info[players[i]] = born_role()
enemy_info[enemies[i]] = born_role()
# 展示我方的3个角色
print('----------------- 角色信息 -----------------')
print('你的人物：')
for i in range(3):
print('%s 血量：%s 攻击：%s'
% (players[i], player_info[players[i]][0], player_info[players[i]][1]))
print('--------------------------------------------')
print('电脑敌人：')
# 展示敌方的3个角色
for i in range(3):
print('%s 血量：%s 攻击：%s'
% (enemies[i], enemy_info[enemies[i]][0], enemy_info[enemies[i]][1]))
print('--------------------------------------------')
input('请按回车键继续。\n') # 为了让玩家更有控制感，可以插入类似的代码来切分游戏进程。
return
# 角色排序，选择出场顺序。
def order_role():
global players
order_dict = {}
for i in range(3):
order = int(input('你想将 %s 放在第几个上场？(输入数字1~3)' % players[i]))
order_dict[order] = players[i]
players = []
for i in range(1, 4):
players.append(order_dict[i])
print('\n我方角色的出场顺序是：%s、%s、%s' % (players[0], players[1], players[2]))
print('敌方角色的出场顺序是：%s、%s、%s' % (enemies[0], enemies[1], enemies[2]))
return
# 角色PK
def pk_role():
round = 1
score = 0
for i in range(3): # 一共要打三局
player_name = players[i]
enemy_name = enemies[i]
player_life = player_info[players[i]][0]
player_attack = player_info[players[i]][1]
enemy_life = enemy_info[enemies[i]][0]
enemy_attack = enemy_info[enemies[i]][1]
# 每一局开战前展示战斗信息
print('\n----------------- 【第%s局】 -----------------' % round)
print('玩家角色：%s vs 敌方角色：%s ' % (player_name, enemy_name))
print('%s 血量：%s 攻击：%s' % (player_name, player_life, player_attack))
print('%s 血量：%s 攻击：%s' % (enemy_name, enemy_life, enemy_attack))
print('--------------------------------------------')
input('请按回车键继续。\n')
# 开始判断血量是否都大于零，然后互扣血量。
while player_life > 0 and enemy_life > 0:
enemy_life = enemy_life - player_attack
player_life = player_life - enemy_attack
print('%s发起了攻击，%s剩余血量%s' % (player_name, enemy_name, enemy_life))
print('%s发起了攻击，%s剩余血量%s' % (enemy_name, player_name, player_life))
print('--------------------------------------------')
time.sleep(1)
else: # 每局的战果展示，以及分数score和局数的变化。
# 调用show_result()函数，打印返回元组中的result。
print(show_result(player_life, enemy_life)[1])
# 调用show_result()函数，完成计分变动。
score += int(show_result(player_life, enemy_life)[0])
round += 1
input('\n点击回车，查看比赛的最终结果\n')
if score > 0:
print('【最终结果：你赢了！】\n')
elif score < 0:
print('【最终结果：你输了！】\n')
else:
print('【最终结果：平局！】\n')
return
# 返回单局战果和计分法所加分数。
def show_result(player_life, enemy_life): # 注意：该函数要设定参数，才能判断单局战果。
if player_life > 0 and enemy_life <= 0:
result = '\n敌人死翘翘了，你赢了！'
return 1, result # 返回元组(1,'\n敌人死翘翘了，你赢了！')，类似角色属性的传递。
elif player_life <= 0 and enemy_life > 0:
result = '\n悲催，敌人把你干掉了！'
return -1, result
else:
result = '\n哎呀，你和敌人同归于尽了！'
return 0, result
# （主函数）展开战斗流程
def main():
show_role() # 生成和展示角色信息
order_role() # 角色排序，选择出场顺序
pk_role() # 完成角色PK，并展示PK结果
# 启动程序（即调用主函数）
main()
运行结果：
----------------- 角色信息 -----------------
你的人物：
【枪弹专家】 血量：163 攻击：50
【光明骑士】 血量：119 攻击：37
【森林箭手】 血量：139 攻击：39
--------------------------------------------
电脑敌人：
【嗜血刀客】 血量：110 攻击：38
【暗夜骑士】 血量：115 攻击：50
【黑暗弩手】 血量：151 攻击：40
--------------------------------------------
请按回车键继续。
你想将 【枪弹专家】 放在第几个上场？(输入数字1~3)3
你想将 【光明骑士】 放在第几个上场？(输入数字1~3)1
你想将 【森林箭手】 放在第几个上场？(输入数字1~3)2
我方角色的出场顺序是：【光明骑士】、【森林箭手】、【枪弹专家】
敌方角色的出场顺序是：【嗜血刀客】、【暗夜骑士】、【黑暗弩手】
----------------- 【第1局】 -----------------
玩家角色：【光明骑士】 vs 敌方角色：【嗜血刀客】
【光明骑士】 血量：119 攻击：37
【嗜血刀客】 血量：110 攻击：38
--------------------------------------------
请按回车键继续。
【光明骑士】发起了攻击，【嗜血刀客】剩余血量73
【嗜血刀客】发起了攻击，【光明骑士】剩余血量81
--------------------------------------------
【光明骑士】发起了攻击，【嗜血刀客】剩余血量36
【嗜血刀客】发起了攻击，【光明骑士】剩余血量43
--------------------------------------------
【光明骑士】发起了攻击，【嗜血刀客】剩余血量-1
【嗜血刀客】发起了攻击，【光明骑士】剩余血量5
--------------------------------------------
敌人死翘翘了，你赢了！
----------------- 【第2局】 -----------------
玩家角色：【森林箭手】 vs 敌方角色：【暗夜骑士】
【森林箭手】 血量：139 攻击：39
【暗夜骑士】 血量：115 攻击：50
--------------------------------------------
请按回车键继续。
【森林箭手】发起了攻击，【暗夜骑士】剩余血量76
【暗夜骑士】发起了攻击，【森林箭手】剩余血量89
--------------------------------------------
【森林箭手】发起了攻击，【暗夜骑士】剩余血量37
【暗夜骑士】发起了攻击，【森林箭手】剩余血量39
--------------------------------------------
【森林箭手】发起了攻击，【暗夜骑士】剩余血量-2
【暗夜骑士】发起了攻击，【森林箭手】剩余血量-11
--------------------------------------------
哎呀，你和敌人同归于尽了！
----------------- 【第3局】 -----------------
玩家角色：【枪弹专家】 vs 敌方角色：【黑暗弩手】
【枪弹专家】 血量：163 攻击：50
【黑暗弩手】 血量：151 攻击：40
--------------------------------------------
请按回车键继续。
【枪弹专家】发起了攻击，【黑暗弩手】剩余血量101
【黑暗弩手】发起了攻击，【枪弹专家】剩余血量123
--------------------------------------------
【枪弹专家】发起了攻击，【黑暗弩手】剩余血量51
【黑暗弩手】发起了攻击，【枪弹专家】剩余血量83
--------------------------------------------
【枪弹专家】发起了攻击，【黑暗弩手】剩余血量1
【黑暗弩手】发起了攻击，【枪弹专家】剩余血量43
--------------------------------------------
【枪弹专家】发起了攻击，【黑暗弩手】剩余血量-49
【黑暗弩手】发起了攻击，【枪弹专家】剩余血量3
--------------------------------------------
敌人死翘翘了，你赢了！
点击回车，查看比赛的最终结果
【最终结果：你赢了！】
把上面的代码封装成类，只需做这么几件事：
上面的代码，我们使用了很多全局变量，这是因为有多个函数都需要使用这些变量。而当这些函数被封装成一个类之后，我们就不必再使用全局变量，直接把它们放在类里面，作为类属性来被不同的类方法调用。
import time,random
# 将变量放在类里面，作为类属性
class Game():
player_list = ['【狂血战士】','【森林箭手】','【光明骑士】','【独行剑客】','【格斗大师】','【枪弹专家】']
enemy_list = ['【暗黑战士】','【黑暗弩手】','【暗夜骑士】','【嗜血刀客】','【首席刺客】','【陷阱之王】']
player_info = {}
enemy_info = {}
# 初始化函数
def __init__(self):
# 随机抽取3个角色名形成玩家角色列表和敌人角色列表
self.players = random.sample(self.player_list,3)
self.enemies = random.sample(self.enemy_list,3)
# 然后执行游戏流程的相关函数
self.show_role()
self.order_role()
self.pk_role()
# 随机生成角色的属性
def born_role(self):
life = random.randint(100, 180)
attack = random.randint(30, 50)
return life, attack
# 生成和展示角色信息
def show_role(self):
for i in range(3):
self.player_info[self.players[i]] = self.born_role()
self.enemy_info[self.enemies[i]] = self.born_role()
# 展示我方的3个角色
print('----------------- 角色信息 -----------------')
print('你的人物：')
for i in range(3):
print('%s 血量：%s 攻击：%s'
% (self.players[i], self.player_info[self.players[i]][0], self.player_info[self.players[i]][1]))
print('--------------------------------------------')
print('电脑敌人：')
# 展示敌方的3个角色
for i in range(3):
print('%s 血量：%s 攻击：%s'
% (self.enemies[i], self.enemy_info[self.enemies[i]][0], self.enemy_info[self.enemies[i]][1]))
print('--------------------------------------------')
input('请按回车键继续。\n') # 为了让玩家更有控制感，可以插入类似的代码来切分游戏进程。
return
# 角色排序，选择出场顺序。
def order_role(self): # 在类方法中加入self作为参数
order_dict = {}
for i in range(3):
order = int(input('你想将 %s 放在第几个上场？(输入数字1~3)' % self.players[i]))
order_dict[order] = self.players[i]
self.players = [] # 变量前加上self.其余几处同理
for i in range(1, 4):
self.players.append(order_dict[i])
print('\n我方角色的出场顺序是：%s、%s、%s' % (self.players[0], self.players[1], self.players[2]))
print('敌方角色的出场顺序是：%s、%s、%s' % (self.enemies[0], self.enemies[1], self.enemies[2]))
return
# 角色PK
def pk_role(self):
round = 1
score = 0
for i in range(3): # 一共要打三局
player_name = self.players[i]
enemy_name = self.enemies[i]
player_life = self.player_info[self.players[i]][0]
player_attack = self.player_info[self.players[i]][1]
enemy_life = self.enemy_info[self.enemies[i]][0]
enemy_attack = self.enemy_info[self.enemies[i]][1]
# 每一局开战前展示战斗信息
print('\n----------------- 【第%s局】 -----------------' % round)
print('玩家角色：%s vs 敌方角色：%s ' % (player_name, enemy_name))
print('%s 血量：%s 攻击：%s' % (player_name, player_life, player_attack))
print('%s 血量：%s 攻击：%s' % (enemy_name, enemy_life, enemy_attack))
print('--------------------------------------------')
input('请按回车键继续。\n')
# 开始判断血量是否都大于零，然后互扣血量。
while player_life > 0 and enemy_life > 0:
enemy_life = enemy_life - player_attack
player_life = player_life - enemy_attack
print('%s发起了攻击，%s剩余血量%s' % (player_name, enemy_name, enemy_life))
print('%s发起了攻击，%s剩余血量%s' % (enemy_name, player_name, player_life))
print('--------------------------------------------')
time.sleep(1)
else: # 每局的战果展示，以及分数score和局数的变化。
# 调用show_result()函数，打印返回元组中的result。
print(self.show_result(player_life, enemy_life)[1])
# 调用show_result()函数，完成计分变动。
score += int(self.show_result(player_life, enemy_life)[0])
round += 1
input('\n点击回车，查看比赛的最终结果\n')
if score > 0:
print('【最终结果：你赢了！】\n')
elif score < 0:
print('【最终结果：你输了！】\n')
else:
print('【最终结果：平局！】\n')
return
# 返回单局战果和计分法所加分数。
def show_result(self, player_life, enemy_life): # 注意：该函数要设定参数，才能判断单局战果。
if player_life > 0 and enemy_life <= 0:
result = '\n敌人死翘翘了，你赢了！'
return 1, result # 返回元组(1,'\n敌人死翘翘了，你赢了！')，类似角色属性的传递。
elif player_life <= 0 and enemy_life > 0:
result = '\n悲催，敌人把你干掉了！'
return -1, result
else:
result = '\n哎呀，你和敌人同归于尽了！'
return 0, result
gp = Game() # 运行游戏
结果：
----------------- 角色信息 -----------------
你的人物：
【森林箭手】 血量：130 攻击：32
【格斗大师】 血量：164 攻击：48
【光明骑士】 血量：142 攻击：42
--------------------------------------------
电脑敌人：
【陷阱之王】 血量：135 攻击：32
【暗夜骑士】 血量：165 攻击：50
【暗黑战士】 血量：141 攻击：44
--------------------------------------------
请按回车键继续。
你想将 【森林箭手】 放在第几个上场？(输入数字1~3)1
你想将 【格斗大师】 放在第几个上场？(输入数字1~3)3
你想将 【光明骑士】 放在第几个上场？(输入数字1~3)2
我方角色的出场顺序是：【森林箭手】、【光明骑士】、【格斗大师】
敌方角色的出场顺序是：【陷阱之王】、【暗夜骑士】、【暗黑战士】
----------------- 【第1局】 -----------------
玩家角色：【森林箭手】 vs 敌方角色：【陷阱之王】
【森林箭手】 血量：130 攻击：32
【陷阱之王】 血量：135 攻击：32
--------------------------------------------
请按回车键继续。
【森林箭手】发起了攻击，【陷阱之王】剩余血量103
【陷阱之王】发起了攻击，【森林箭手】剩余血量98
--------------------------------------------
【森林箭手】发起了攻击，【陷阱之王】剩余血量71
【陷阱之王】发起了攻击，【森林箭手】剩余血量66
--------------------------------------------
【森林箭手】发起了攻击，【陷阱之王】剩余血量39
【陷阱之王】发起了攻击，【森林箭手】剩余血量34
--------------------------------------------
【森林箭手】发起了攻击，【陷阱之王】剩余血量7
【陷阱之王】发起了攻击，【森林箭手】剩余血量2
--------------------------------------------
【森林箭手】发起了攻击，【陷阱之王】剩余血量-25
【陷阱之王】发起了攻击，【森林箭手】剩余血量-30
--------------------------------------------
哎呀，你和敌人同归于尽了！
----------------- 【第2局】 -----------------
玩家角色：【光明骑士】 vs 敌方角色：【暗夜骑士】
【光明骑士】 血量：142 攻击：42
【暗夜骑士】 血量：165 攻击：50
--------------------------------------------
请按回车键继续。
【光明骑士】发起了攻击，【暗夜骑士】剩余血量123
【暗夜骑士】发起了攻击，【光明骑士】剩余血量92
--------------------------------------------
【光明骑士】发起了攻击，【暗夜骑士】剩余血量81
【暗夜骑士】发起了攻击，【光明骑士】剩余血量42
--------------------------------------------
【光明骑士】发起了攻击，【暗夜骑士】剩余血量39
【暗夜骑士】发起了攻击，【光明骑士】剩余血量-8
--------------------------------------------
悲催，敌人把你干掉了！
----------------- 【第3局】 -----------------
玩家角色：【格斗大师】 vs 敌方角色：【暗黑战士】
【格斗大师】 血量：164 攻击：48
【暗黑战士】 血量：141 攻击：44
--------------------------------------------
请按回车键继续。
【格斗大师】发起了攻击，【暗黑战士】剩余血量93
【暗黑战士】发起了攻击，【格斗大师】剩余血量120
--------------------------------------------
【格斗大师】发起了攻击，【暗黑战士】剩余血量45
【暗黑战士】发起了攻击，【格斗大师】剩余血量76
--------------------------------------------
【格斗大师】发起了攻击，【暗黑战士】剩余血量-3
【暗黑战士】发起了攻击，【格斗大师】剩余血量32
--------------------------------------------
敌人死翘翘了，你赢了！
点击回车，查看比赛的最终结果
【最终结果：平局！】
二、继承
继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
“类的实例化”的格式：
这是“初始化函数”的格式：
class 类():
def __init__(self):
print('实例化成功！')
实例 = 类()
像这样，我们先写出一个类Role()，里面有三个类属性：名称、血量、攻击力。然后用实例化的方法，就可以得到角色的实例，并使用实例.属性的方式提取出每个实例的属性值。不过我们没有对实例的name属性做区别，现在它们都是“普通角色”。
# 创建一个类，可实例化成一个固定的游戏角色
import random
class Role():
def __init__(self):
self.name = '【普通角色】'
self.life = random.randint(100,150)
self.attack = random.randint(30,50)
a = Role()
print('实例a的角色名称是：'+ a.name)
print('实例a的血量是：'+ str(a.life))
print('实例a的攻击力是：' + str(a.attack))
b = Role()
print('实例b的角色名称是：'+ b.name)
print('实例b的血量是：'+ str(b.life))
print('实例b的攻击力是：' + str(b.attack))
c = Role()
print('实例c的角色名称是：'+ c.name)
print('实例c的血量是：'+ str(c.life))
print('实例c的攻击力是：' + str(c.attack))
结果：
实例a的角色名称是：【普通角色】
实例a的血量是：120
实例a的攻击力是：36
实例b的角色名称是：【普通角色】
实例b的血量是：101
实例b的攻击力是：47
实例c的角色名称是：【普通角色】
实例c的血量是：106
实例c的攻击力是：32
写出三个角色的类，其中属性差异如下：
class Role():
# 父类 “【普通角色】”
# 随机生成血量和攻击
class Knight(Role):
# 子类 “【圣光骑士】” (英文是Knight)
# 血量是随机数的5倍大小，攻击力是随机数的3倍大小
class Assassin(Role):
# 子类 “【暗影刺客】” (英文是Assassin)
# 血量是随机数的3倍大小，攻击力是随机数的5倍大小
class Bowman(Role):
# 子类 “【精灵弩手】” (英文是Bowman)
# 血量是随机数的4倍大小，攻击力是随机数的4倍大小
根据上面的属性差异，写出三个子类，并把每个角色的类属性也打印出来
在这里，每个子类都重写了一遍初始化函数，把角色名、血量、攻击力做出了区分。例如self.name = ‘【圣光骑士】’，是区分了子类的名称，而self.life = random.randint(100,150)*5代表5倍血量。
这样做，我们就既保证了血量和攻击力是随机数，又保证了在不同类型的角色中，血量和攻击力是有差异的。
import random
class Role():
def __init__(self):
self.name = '【普通角色】'
self.life = random.randint(100,150)
self.attack = random.randint(30,50)
class Knight(Role):
def __init__(self):
self.name = '【圣光骑士】'
self.life = random.randint(100,150)*5
self.attack = random.randint(30,50)*3
class Assassin(Role):
def __init__(self):
self.name = '【暗影刺客】'
self.life = random.randint(100, 150) * 3
self.attack = random.randint(30, 50) * 5
class Bowman(Role):
def __init__(self):
self.name = '【精灵弩手】'
self.life = random.randint(100, 150) * 4
self.attack = random.randint(30, 50) * 4
a = Role()
print(a.name + '的血量是' + str(a.life) + '；攻击力是' + str(a.attack))
b = Knight()
print(b.name + '的血量是' + str(b.life) + '；攻击力是' + str(b.attack))
c = Assassin()
print(c.name + '的血量是' + str(c.life) + '；攻击力是' + str(c.attack))
d = Bowman()
print(d.name + '的血量是' + str(d.life) + '；攻击力是' + str(d.attack))
结果：
【普通角色】的血量是112；攻击力是45
【圣光骑士】的血量是630；攻击力是135
【暗影刺客】的血量是366；攻击力是155
【精灵弩手】的血量是440；攻击力是156
改进：
import random
class Role():
def __init__(self, name='【角色】'): # 把角色名作为默认参数
self.name = name
self.life = random.randint(100,150)
self.attack = random.randint(30,50)
# 创建三个子类，可实例化为3个不同类型的角色
class Knight(Role):
def __init__(self, name='【圣光骑士】'): # 把子类角色名作为默认参数
Role.__init__(self,name) # 利用了父类的初始化函数
self.life = self.life*5 # 骑士有5份血量
self.attack = self.attack*3 # 骑士有3份攻击力
class Assassin(Role):
def __init__(self, name='【暗影刺客】'):
Role.__init__(self, name) # 利用了父类的初始化函数
self.life = random.randint(100, 150) * 3
self.attack = random.randint(30, 50) * 5
class Bowman(Role):
def __init__(self, name='【精灵弩手】'):
Role.__init__(self, name) # 利用了父类的初始化函数
self.life = random.randint(100, 150) * 4
self.attack = random.randint(30, 50) * 4
a = Role()
b = Knight()
c = Assassin()
d = Bowman()
#我们创建了一个列表把4个实例保存起来，然后用for循环遍历即可。
list1 = [a,b,c,d]
for i in list1:
print(i.name + '的血量是' + str(i.life) + '；攻击力是' + str(i.attack))
结果：
【角色】的血量是136；攻击力是39
【圣光骑士】的血量是590；攻击力是126
【暗影刺客】的血量是417；攻击力是180
【精灵弩手】的血量是600；攻击力是144
队伍中的角色可以随机生成（也就是队伍中的角色可以重复，比如随机生成三个【暗影刺客】都是合理的）。
import random
import time
# 创建一个类，可实例化成具体的游戏角色
class Role():
def __init__(self, name='【角色】'): # 把角色名作为默认参数
self.name = name
self.life = random.randint(100, 150)
self.attack = random.randint(30, 50)
# 创建三个子类，可实例化为3个不同类型的角色
class Knight(Role):
def __init__(self, name='【圣光骑士】'): # 把子类角色名作为默认参数
Role.__init__(self, name) # 利用了父类的初始化函数
self.life = self.life * 5 # 骑士有5份血量
self.attack = self.attack * 3 # 骑士有3份攻击力
class Assassin(Role):
def __init__(self, name='【暗影刺客】'):
Role.__init__(self, name)
self.life = self.life * 3
self.attack = self.attack * 5
class Bowman(Role):
def __init__(self, name='【精灵弩手】'):
Role.__init__(self, name)
self.life = self.life * 4
self.attack = self.attack * 4
# 创建一个类，可生成3V3并展示：可分为：欢迎语→随机生成→展示角色
class Game:
def __init__(self):
# 初始化各种变量
self.players = []
self.enemies = []
self.score = 0
# 执行各种游戏函数
self.game_start()
self.born_role()
self.show_role()
# 欢迎语
def game_start(self):
print('------------ 欢迎来到“PK小游戏” ------------')
print('将自动生成【玩家角色】和【电脑人物】')
input('请按回车键继续。')
return
# 随机生成6个角色
def born_role(self):
for i in range(3):
self.players.append(random.choice([Knight(), Assassin(), Bowman()]))
self.enemies.append(random.choice([Knight(), Assassin(), Bowman()]))
return
# 展示角色
def show_role(self):
print('----------------- 角色信息 -----------------')
print('你的队伍：')
for i in range(3):
print('『我方』%s 血量：%s 攻击：%s' %(self.players[i].name, self.players[i].life, self.players[i].attack))
print('--------------------------------------------')
print('敌人队伍：')
for i in range(3):
print('『敌方』%s 血量：%s 攻击：%s' %(self.enemies[i].name, self.enemies[i].life, self.enemies[i].attack))
print('--------------------------------------------')
return
gp = Game() # 运行游戏
结果：
------------ 欢迎来到“PK小游戏” ------------
将自动生成【玩家角色】和【电脑人物】
请按回车键继续。
----------------- 角色信息 -----------------
你的队伍：
『我方』【精灵弩手】 血量：508 攻击：192
『我方』【精灵弩手】 血量：428 攻击：168
『我方』【圣光骑士】 血量：675 攻击：138
--------------------------------------------
敌人队伍：
『敌方』【暗影刺客】 血量：426 攻击：200
『敌方』【圣光骑士】 血量：725 攻击：117
『敌方』【暗影刺客】 血量：312 攻击：200
--------------------------------------------
这里的代码绝大部分都复用了第一部分封装成Game类的代码，然后在这个基础上又做了两处改变。
第一处改变是把函数拆开，函数拆开后，游戏逻辑会更加清晰：
第二处改变是改写了born_role()函数，这也是刚才重点实操练习过的：
# 随机生成6个角色
def born_role(self):
for i in range(3):
self.players.append(random.choice([Knight(),Assassin(),Bowman()]))
self.enemies.append(random.choice([Knight(),Assassin(),Bowman()]))
所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。
那么问题又来了，多继承呢？
- 是否可以继承多个类
- 如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？
1、Python的类可以继承多个类，Java和C#中则只能继承一个类
2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
下图中B、C类继承D类，A类继承B、C类。
- 当类是经典类时，多继承情况下，会按照深度优先方式查找
- 当类是新式类时，多继承情况下，会按照广度优先方式查找
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
- 经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
- 新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
三、多态
Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。
class F1:
pass
class S1(F1):
def show(self):
print('S1.show')
class S2(F1):
def show(self):
print('S2.show')
# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象
def Func(F1, obj):
"""Func函数需要接收一个F1类型或者F1子类的类型"""
print(obj.show())
s1_obj = S1()
Func(F1, s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
s2_obj = S2()
Func(F1, s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
# Python伪代码实现Java或C的多态
结果：
S1.show
None
S2.show
None
class F1:
pass
class S1(F1):
def show(self):
print('S1.show')
class S2(F1):
def show(self):
print('S2.show')
def Func(obj):
print(obj.show())
s1_obj = S1()
Func(s1_obj)
s2_obj = S2()
Func(s2_obj)
# Python “鸭子类型”
结果；
S1.show
None
S2.show
None
总结
以上就是本节对于面向对象初级知识的介绍，总结如下：
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
类——项目例子
1、猫和老鼠
class Animal(): # 创建一个父类“动物”
def __init__(self, name='动物'):
self.name = name
self.attack = 100 # 动物的攻击力是100
class Cat(Animal): # 创建一个子类“猫”
def __init__(self, name='猫'):
Animal.__init__(self, name) # 完全继承动物的初始化函数，也就是攻击力还是100
def fight_buff(self, opponent): # fight_buff的意思是“战斗强化”，opponent的意思是“对手”
if opponent.name == '老鼠':
self.attack = int(self.attack * 1.5)
class Rat(Animal): # 创建一个子类“老鼠”
def __init__(self, name='老鼠'):
Animal.__init__(self, name) # 完全继承动物的初始化函数，也就是攻击力还是100
class Monkey(Animal): # 创建一个子类“猴子”
def __init__(self, name='猴子'):
Animal.__init__(self, name) # 完全继承动物的初始化函数，也就是攻击力还是100
Tom = Cat() # 实例化一只叫做Tom的猫
Jerry = Rat() # 实例化一只叫做Jerry的老鼠
Bobo = Monkey() # 实例化一只叫做Bobo的猴子
print('猫的攻击力是：')
print(Tom.attack)
Tom.fight_buff(Jerry)
print('遇到老鼠，猫的攻击力是：')
print(Tom.attack)
Tom.fight_buff(Bobo)
print('遇到猴子，猫的攻击力是：')
print(Tom.attack)
结果：
猫的攻击力是：
100
遇到老鼠，猫的攻击力是：
150
遇到猴子，猫的攻击力是：
150
上面代码的关键是新增了一个类方法fight_buff()，这个函数需要接受一个参数opponent，也就是战斗对手的实例对象。
然后在函数中用opponent.name可以把对手的名称给提取出来，并用条件判断，如果对手的名称是’老鼠’，那就给自己的攻击力重新赋值为1.5倍（也就是增加了50%攻击力）
2、游戏角色互相PK
游戏可以在开始前调用角色子类对应的fight_buff()实例方法，从而获得攻击力加成，实现属性克制功能！
import random
import time
# 创建一个类，可实例化成具体的游戏角色
class Role:
def __init__(self, name='【角色】'): # 把角色名作为默认参数
self.name = name
self.life = random.randint(100, 150)
self.attack = random.randint(30, 50)
# 创建3个子类，可实例化为3个不同的职业
class Knight(Role):
def __init__(self, name='【圣光骑士】'): # 把子类角色名作为默认参数
Role.__init__(self, name) # 利用了父类的初始化函数
self.life = self.life * 5 # 骑士有5份血量
self.attack = self.attack * 3 # 骑士有3份攻击力
# 职业克制关系
def fight_buff(self, opponent, str1, str2):
if opponent.name == '【暗影刺客】':
self.attack = int(self.attack * 1.5)
print('『%s』【圣光骑士】对 『%s』【暗影刺客】说：“让无尽光芒制裁你的堕落！”' % (str1, str2))
class Assassin(Role):
def __init__(self, name='【暗影刺客】'):
Role.__init__(self, name)
self.life = self.life * 3
self.attack = self.attack * 5
# 职业克制关系
def fight_buff(self, opponent, str1, str2):
if opponent.name == '【精灵弩手】':
self.attack = int(self.attack * 1.5)
print('『%s』【暗影刺客】对 『%s』【精灵弩手】说：“主动找死，就别怪我心狠手辣。”' % (str1, str2))
class Bowman(Role):
def __init__(self, name='【精灵弩手】'):
Role.__init__(self, name)
self.life = self.life * 4
self.attack = self.attack * 4
# 职业克制关系
def fight_buff(self, opponent, str1, str2):
if opponent.name == '【圣光骑士】':
self.attack = int(self.attack * 1.5)
print('『%s』【精灵弩手】对 『%s』【圣光骑士】说：“骑着倔驴又如何？你都碰不到我衣服。”' % (str1, str2))
# 创建一个类，可生成3V3并展示：可分为：欢迎语→随机生成→展示角色
class Game():
def __init__(self):
self.players = [] # 存玩家顺序
self.enemies = [] # 存敌人顺序
self.score = 0 # 比赛积分
self.i = 0 # 记轮次
# 依次执行以下函数
self.game_start() # 欢迎语
self.born_role() # 随机生成6个角色
self.show_role() # 展示角色
self.order_role() # 排序并展示
self.pk_role() # 让双方 Pk 并展示结果
self.show_result() # 展示最终结局
# 欢迎语
def game_start(self):
print('------------ 欢迎来到“炼狱角斗场” ------------')
print('在昔日的黄昏山脉，奥卢帝国的北境边界上，有传说中的“炼狱角斗场”。')
print('鲜血与战斗是角斗士的归宿，金钱与荣耀是角斗士的信仰！')
print('今日，只要你【你的队伍】能取得胜利，你将获得一笔够花500年的财富。')
time.sleep(2)
print('将随机生成【你的队伍】和【敌人队伍】！')
input('\n狭路相逢勇者胜，请按任意键继续。\n')
# 随机生成6个角色
def born_role(self):
for i in range(3):
self.players.append(random.choice([Knight(), Assassin(), Bowman()]))
self.enemies.append(random.choice([Knight(), Assassin(), Bowman()]))
# 展示角色
def show_role(self):
print('----------------- 角色信息 -----------------')
print('你的队伍：')
for i in range(3):
print('『我方』%s 血量：%s 攻击：%s' %
(self.players[i].name, self.players[i].life, self.players[i].attack))
print('--------------------------------------------')
print('敌人队伍：')
for i in range(3):
print('『敌方』%s 血量：%s 攻击：%s' %
(self.enemies[i].name, self.enemies[i].life, self.enemies[i].attack))
print('--------------------------------------------')
input('请按回车键继续。\n')
# 排序并展示
def order_role(self):
order_dict = {}
for i in range(3):
order = int(input('你想将 %s 放在第几个上场？(输入数字1~3)' % self.players[i].name))
order_dict[order] = self.players[i]
self.players = []
for i in range(1, 4):
self.players.append(order_dict[i])
print('\n你的队伍出场顺序是：%s、%s、%s'
% (self.players[0].name, self.players[1].name, self.players[2].name))
print('敌人队伍出场顺序是：%s、%s、%s'
% (self.enemies[0].name, self.enemies[1].name, self.enemies[2].name))
# 让双方 Pk 并展示结果
def pk_role(self):
for i in range(3):
print('\n----------------- 【第%s轮】 -----------------' % (i + 1))
# 每一局开战前加buff
self.players[i].fight_buff(self.enemies[i], '我方', '敌方')
self.enemies[i].fight_buff(self.players[i], '敌方', '我方')
input('\n战斗双方准备完毕，请按回车键继续。')
print('--------------------------------------------')
while self.players[i].life > 0 and self.enemies[i].life > 0:
self.enemies[i].life -= self.players[i].attack
self.players[i].life -= self.enemies[i].attack
print('我方%s 发起了攻击，敌方%s 剩余血量 %s' %
(self.players[i].name, self.enemies[i].name, self.enemies[i].life))
print('敌方%s 发起了攻击，我方%s 剩余血量 %s' %
(self.enemies[i].name, self.players[i].name, self.players[i].life))
print('--------------------------------------------')
time.sleep(1)
if self.players[i].life <= 0 and self.enemies[i].life > 0:
print('\n很遗憾，我方%s 挂掉了！' % (self.players[i].name))
self.score -= 1
elif self.players[i].life > 0 and self.enemies[i].life <= 0:
print('\n恭喜，我方%s 活下来了。' % (self.players[i].name))
self.score += 1
else:
print('\n我的天，他们俩都死了啊！')
# 展示最终结局
def show_result(self):
input('\n请按回车查看最终结果。\n')
if self.score > 0:
print('【最终结果】\n你赢了，最终的财宝都归你了！')
elif self.score == 0:
print('【最终结果】\n你没有胜利，但也没有失败，在夜色中灰溜溜离开了奥卢帝国。')
else:
print('【最终结果】\n你输了。炼狱角斗场又多了几具枯骨。')
game = Game()
结果：
------------ 欢迎来到“炼狱角斗场” ------------
在昔日的黄昏山脉，奥卢帝国的北境边界上，有传说中的“炼狱角斗场”。
鲜血与战斗是角斗士的归宿，金钱与荣耀是角斗士的信仰！
今日，只要你【你的队伍】能取得胜利，你将获得一笔够花500年的财富。
将随机生成【你的队伍】和【敌人队伍】！
狭路相逢勇者胜，请按任意键继续。
----------------- 角色信息 -----------------
你的队伍：
『我方』【圣光骑士】 血量：620 攻击：129
『我方』【暗影刺客】 血量：399 攻击：160
『我方』【圣光骑士】 血量：515 攻击：120
--------------------------------------------
敌人队伍：
『敌方』【暗影刺客】 血量：369 攻击：155
『敌方』【精灵弩手】 血量：520 攻击：180
『敌方』【暗影刺客】 血量：411 攻击：205
--------------------------------------------
请按回车键继续。
你想将 【圣光骑士】 放在第几个上场？(输入数字1~3)1
你想将 【暗影刺客】 放在第几个上场？(输入数字1~3)3
你想将 【圣光骑士】 放在第几个上场？(输入数字1~3)2
你的队伍出场顺序是：【圣光骑士】、【圣光骑士】、【暗影刺客】
敌人队伍出场顺序是：【暗影刺客】、【精灵弩手】、【暗影刺客】
----------------- 【第1轮】 -----------------
『我方』【圣光骑士】对 『敌方』【暗影刺客】说：“让无尽光芒制裁你的堕落！”
战斗双方准备完毕，请按回车键继续。
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【暗影刺客】 剩余血量 176
敌方【暗影刺客】 发起了攻击，我方【圣光骑士】 剩余血量 465
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【暗影刺客】 剩余血量 -17
敌方【暗影刺客】 发起了攻击，我方【圣光骑士】 剩余血量 310
--------------------------------------------
恭喜，我方【圣光骑士】 活下来了。
----------------- 【第2轮】 -----------------
『敌方』【精灵弩手】对 『我方』【圣光骑士】说：“骑着倔驴又如何？你都碰不到我衣服。”
战斗双方准备完毕，请按回车键继续。
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【精灵弩手】 剩余血量 400
敌方【精灵弩手】 发起了攻击，我方【圣光骑士】 剩余血量 245
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【精灵弩手】 剩余血量 280
敌方【精灵弩手】 发起了攻击，我方【圣光骑士】 剩余血量 -25
--------------------------------------------
很遗憾，我方【圣光骑士】 挂掉了！
----------------- 【第3轮】 -----------------
战斗双方准备完毕，请按回车键继续。
--------------------------------------------
我方【暗影刺客】 发起了攻击，敌方【暗影刺客】 剩余血量 251
敌方【暗影刺客】 发起了攻击，我方【暗影刺客】 剩余血量 194
--------------------------------------------
我方【暗影刺客】 发起了攻击，敌方【暗影刺客】 剩余血量 91
敌方【暗影刺客】 发起了攻击，我方【暗影刺客】 剩余血量 -11
--------------------------------------------
很遗憾，我方【暗影刺客】 挂掉了！
请按回车查看最终结果。
【最终结果】
你输了。炼狱角斗场又多了几具枯骨。
文章出处登录后可见！
已经登录？立即刷新
