Python - 类的定义和用法
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
-------------
推荐阅读
-
通过 Vue 中的 v-bind 增强样式控制--(通过 v-bind 操作类和操作样式属性的详细说明,附示例和代码)
-
C++ 学习笔记 ----8, 掌握类和对象 (VII) ---- 构建稳固的接口
-
从 opencv-python 开始学习 opencv - 利用图像界面进行绘图和鼠标交互的图形用户界面功能
-
大数据-164 Apache Kylin Cube 优化案例 1 派生维度的定义和比较 超级详细
-
[C++ 核心编程] 注释 4.1.2 结构和类的区别
-
第一:C# 嵌入 Python 脚本进行图像处理并返回 C# 的构思和实现。
-
Java - 数组的定义和使用
-
Spring Boot 异步任务、任务调度和异步请求线程池的用法和原理
-
Redis 的应用和 Redis 工具类的打包
-
Python 阅读 pdf 中的文本和表格