浅谈面向对象

大部份的编程语言里,都会有关于面向对象的概念.面向对象是一种编程思想,是抽象的概念,是换个视角看事物,换个方式去编程.

面向对象的优点:

　　>程序可扩展性

　　>代码重用性高

　　>灵活性高

面向对象的缺点:

　　>程序复杂度高

面向对象的概念:一切皆对象,然后将有相当特征的对象放进同一个集合,称作类,类里面包含属性和方法,例如:人类,性别是属性,吃喝拉撒是方法,掌握的技能也是方法.

如图所示:p1是一个对象,可以调用Person类中的eat方法和name,age属性.关于p1的属性和属性对应的值,在查找上是有顺序的,会先在p1自己内部找,找不到再去p1对应的类里找.

 英雄大乱斗

import random
import time


# 人物类
class Heros:

    def __init__(self, name, level, blood, atk, q_atk, w_atk, e_atc):
        self.name = name
        self.level = level
        self.blood = blood
        self.atk = atk
        self.q_atk = q_atk
        self.w_atk = w_atk
        self.e_atc = e_atc

    # 普通攻击
    def normo_att(self, enemy):
        enemy.blood -= self.atk
        print(f'{self.name}对{enemy.name}进行了,普通攻击,造成了{self.atk}点伤害.{enemy.name}剩余血量{enemy.blood}')

    # Q攻击
    def Q(self, enemy):
        enemy.blood -= self.q_atk
        print(f'{self.name}对{enemy.name}进行了,Q攻击,造成了{self.atk}点伤害.{enemy.name}剩余血量{enemy.blood}')

    # W攻击
    def W(self, enemy):
        enemy.blood -= self.w_atk
        print(f'{self.name}对{enemy.name}进行了,W攻击,造成了{self.atk}点伤害.{enemy.name}剩余血量{enemy.blood}')

    # E攻击
    def E(self, enemy):
        enemy.blood -= self.e_atc
        print(f'{self.name}对{enemy.name}进行了,E攻击,造成了{self.atk}点伤害.{enemy.name}剩余血量{enemy.blood}')


# 创建人物
h1 = Heros('鼬', 30, 3000, 300, 500, 600, 700)
h2 = Heros('大蛇丸', 20, 4000, 200, 400, 500, 600)
h3 = Heros('斑', 40, 6000, 600, 700, 800, 900)
h4 = Heros('带土', 20, 5000, 300, 500, 600, 700)
h5 = Heros('蝎', 20, 3500, 100, 200, 300, 400)

# 人物字典
HEROS_DIC = {
    1: h1,
    2: h2,
    3: h3,
    4: h4,
    5: h5,
}

# 攻击方式字典
atk_func = {
    1: Heros.normo_att,
    2: Heros.Q,
    3: Heros.W,
    4: Heros.E,
}
# 循环操作
while True:

    # 从人物字典中随机获取1个索引值,做为发动攻击人物的索引
    hero_index = random.randint(1, len(HEROS_DIC))

    # 随机获取发动攻击的人物
    hero = HEROS_DIC[hero_index]

    # 将被攻击人物,放进一个新字典,除自己外
    enemy_dic = {}
    new_key = 1
    for k, v in HEROS_DIC.items():
        if k != hero_index:
            enemy_dic[new_key] = v
            new_key += 1

    # 从被攻击人物字典中随机获取1个索引值,做为被攻击人物的索引
    enemy_index = random.randint(1, len(enemy_dic))

    # 获取被攻击人物
    enemy = enemy_dic[enemy_index]

    # 从攻击方式列表中,随机获取1个攻击方式的索引
    atk_index = random.randint(1, len(atk_func))

    # 将发动攻击的人物和被攻击人物放入攻击方式中
    atk_func[atk_index](hero, enemy)

    # 当被攻击方的血量小于等于0时,即判定被击杀
    if enemy.blood <= 0:
        print(f'{hero.name}击杀了{enemy.name}')
        break

    # 为了让过程更有趣一点,所以加入了0.5秒延迟:)
    time.sleep(0.5)

 英雄大乱斗进阶版

import random
import time


# 人物类
class Heros:

    def __init__(self, name, level, blood, atk, q_atk, w_atk, e_atc):
        self.name = name
        self.level = level
        self.blood = blood
        self.atk = atk
        self.q_atk = q_atk
        self.w_atk = w_atk
        self.e_atc = e_atc

    # 普通攻击
    def normo_att(self, enemy):
        enemy.blood -= self.atk
        print(f'{self.name} 对 {enemy.name} 进行了,普通攻击,造成了 {self.atk} 点伤害. {enemy.name} 剩余血量 {enemy.blood}')

    # Q攻击
    def Q(self, enemy):
        enemy.blood -= self.q_atk
        print(f'{self.name} 对 {enemy.name} 进行了,Q攻击,造成了 {self.atk} 点伤害. {enemy.name} 剩余血量 {enemy.blood}')

    # W攻击
    def W(self, enemy):
        enemy.blood -= self.w_atk
        print(f'{self.name} 对 {enemy.name} 进行了,W攻击,造成了 {self.atk} 点伤害. {enemy.name} 剩余血量 {enemy.blood}')

    # E攻击
    def E(self, enemy):
        enemy.blood -= self.e_atc
        print(f'{self.name} 对 {enemy.name} 进行了,E攻击,造成了 {self.atk} 点伤害. {enemy.name} 剩余血量 {enemy.blood}')


# 创建人物
h1 = Heros('鼬', 30, 3000, 300, 500, 600, 700)

h2 = Heros('大蛇丸', 20, 4000, 200, 400, 500, 600)

h3 = Heros('斑', 40, 6000, 600, 700, 800, 900)

h4 = Heros('带土', 20, 5000, 300, 500, 600, 700)

h5 = Heros('蝎', 20, 3500, 100, 200, 300, 400)

# 人物字典
HEROS_DIC = {
    1: h1,
    2: h2,
    3: h3,
    4: h4,
    5: h5,
}

# 攻击方式字典
atk_func = {
    1: Heros.normo_att,
    2: Heros.Q,
    3: Heros.W,
    4: Heros.E,
}

# 存放已经战死的人物
dead_heros = set()

# 循环操作
while True:

    # 从人物字典中随机获取1个索引值,做为发动攻击人物的索引
    hero_index = random.randint(1, len(HEROS_DIC))

    # 判断人物是否已经战死
    if hero_index in dead_heros:
        continue

    # 获取发动攻击的人物
    hero = HEROS_DIC[hero_index]

    # 将被攻击人物,放进一个新字典,除自己外且未战死
    enemy_dic = {}

    new_key = 1

    for k, v in HEROS_DIC.items():

        if k != hero_index and (k not in dead_heros):
            
            #创建1个列表
            enemy_dic[new_key] = []

            enemy_dic[new_key].append(v)
            
            #将人物原始的键存放起来
            enemy_dic[new_key].append(k)

            new_key += 1

    # 从被攻击人物字典中随机获取1个索引值,做为被攻击人物的索引
    enemy_index = random.randint(1, len(enemy_dic))

    # 获取被攻击人物
    enemy = enemy_dic[enemy_index][0]

    # 从攻击方式列表中,随机获取1个攻击方式的索引
    atk_index = random.randint(1, len(atk_func))

    # 将发动攻击的人物和被攻击人物放入攻击方式中
    atk_func[atk_index](hero, enemy)

    # 当被攻击方的血量小于等于0时,即判定被击杀
    if enemy.blood <= 0:
        print('
', "*" * 20, f'{hero.name}击杀了{enemy.name}', '*' * 20, '
')

        # 将战死人物,加入已经战死人物列表中
        dead_heros.add(enemy_dic[enemy_index][1])

    # 若只剩1个人物则为胜者,打印输出
    if len(dead_heros) == len(HEROS_DIC) - 1:

        # 打印已经战死的人物
        for i in dead_heros:
            print(f'{HEROS_DIC[i].name}战死!
')

        # 打印最后站着的人
        for k, v in HEROS_DIC.items():
            if k not in dead_heros:
                print('
', "*" * 20, f'最后站着的人是:{HEROS_DIC[k].name}', '*' * 20, '
')
                break
        break
    #为了让程序更有趣,加入了延迟:)
    time.sleep(0.1)