• 类和对象


    面向对象和面向过程

    面向过程

    ​ 概念:就是把对一个问题的解决通过一系列过程的来实现的(例如我要从北京去上海,那我第一步要先去天津,第二步去山东。。。。最后到上海)

    ​ 优点:复杂问题流程化

    ​ 缺点:可扩展性差

    面向对象

    ​ 概念:就是把对一个问题的解决通过对象间的协作实现的(例如我要从北京去上海,给我一个车类,然后其他的就不管了,这个车类通过内部的行驶方法就能到达上海)

    ​ 优点:可扩展性高

    ​ 缺点:编写复杂

    类与对象

    定义类

    ​ class (关键字)类名:

    ​ pass

    产生对象

    ​ 对象 = 类名()

    1. 获取类的属性和方法

    2. 类.__dict__

    3. 类来调用属性和方法

      1. 通过dict来取(复杂,不用)

      2. 类名.属性/函数

    对象

    1. 对象来调用属性和方法

      对象.__dict__

    2. 对象来调用属性和方法

    ​ 对象.属性/方法

    产生对象(绑定方法,属性的查找顺序)

    1. 属性查找顺序

      先从对象自身查找----->类中找------>报错

    2. 对象赋属性

      方式一:

      ​ stu1 = Student()

      ​ stu1.name = ‘nick’

      方式二:(通过__init__)

      ​ 在类中定义该方法,方法上写一些参数

      ​ 在对象实例化产生对象时,在括号中传的值,会被传到__init__中

    3. 绑定方法:

      定义在类内部

      对象来调用,会自动把对象传过来,在方法内部就可以修改该对象

    一切皆对象

    实战小游戏

    主要是CF里面两个角色进行射击,攻击后血量减少,还可装备手榴弹

    class Siwate: #定义一个斯沃特类
        def __init__(self, name, gun='AK_47', armor = 28, aggrev = 329, life_value = 38888 ): # 绑定对象方法
            self.name = name
            self.gun = gun
            self.aggrev = aggrev
            self.armor = armor
            self.life_value = life_value
        def attack(self, emeny): # 攻击(我方攻击力减对方护甲)
            life_damage = self.aggrev - emeny.armor
            emeny.life_value -= life_damage
    
    class OMOH: #定义一个奥摩类
        def __init__(self, name,  gun='M4A1', armor = 24, aggrev = 300,  life_value = 33456  ): # 绑定对象方法
            self.name = name
            self.gun = gun
            self.armor = armor
            self.aggrev = aggrev
            self.life_value = life_value
        def attack(self, emeny):# 攻击(我方攻击力减对方护甲)
            life_damage = self.aggrev - emeny.armor
            emeny.life_value -= life_damage
    
    s1 = Siwate("斯沃特")
    o1 = OMOH('奥摩')
    
    print(f'{s1.name}攻击了{o1.name}, {o1.name}的生命值是{o1.life_value}')
    s1.attack(o1)
    print(f'{s1.name}攻击了{o1.name}, {o1.name}的生命值是{o1.life_value}')
    
    
    
    class Frag: # 扔手雷
        def __init__(self, aggressivity=10):
            self.aggressivity = aggressivity
        def update(last, now):
            now.aggrev += last.aggressivity #攻击力加成
        def attack(self, emeny): # 直接攻击对方血量减1000
            emeny.life_value -= 1000
    
    
    f1 = Frag()
    s1.f1 = f1 #这句话的意思就是s1的装备里面加一个新实例化的手雷对
    #象(简单来说就是s1装备手雷,第一个只是变量名)
    s1.f1.update(s1)
    s1.f1.attack(o1)
    print(f'{s1.name}攻击了{o1.name}, {o1.name}的生命值是{o1.life_value}')
    
    s1.attack(o1) # 使用手榴弹后,攻击值会加成,这时候伤害比原来大
    print(f'{s1.name}攻击了{o1.name}, {o1.name}的生命值是{o1.life_value}')
    
  • 相关阅读:
    Spring aop 实现异常拦截
    drf 视图家族
    算法与数据结构
    接口
    Kubernetes
    drf
    drf 序列化
    drf 内部模块
    drf 接口
    vue
  • 原文地址:https://www.cnblogs.com/michealjy/p/11415552.html
Copyright © 2020-2023  润新知