Python——类（class）的定义及使用_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
类中定义的函数叫做“方法”
'''
1
2
3
4
5
6
7
8
9
10
11
12

总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象三大特性

面向对象的三大特性是指：封装、继承和多态。

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

#创建类
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）
1
2
3
4
5
6
7
8
9
10
11
12
13
14

self是一个形式参数，
当执行obj1=Foo('wupeiqi', 18)时，self等于obj1
当执行obj2=Foo('alex', 78)时，self等于obj2
1
2
3

所以，内容其实被封装到了对象 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)
1
2
3
4
5
6
7
8
9
10
11
12
13

结果：

chengd
18
python
99
1
2
3
4

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果：

chengd
18
python
99
1
2
3
4

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

运行结果：

----------------- 角色信息 -----------------
你的人物：
【枪弹专家】  血量：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
-------------
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43