day 19

day 19 面向对象基础

01.什么是面向对象

一门编程思想
1. 核心是对象；
  
  对象指；特征(具体值)与技能(功能)的结合体，‘具体存在的事物’
  
  基于该思想编程，一种上帝式的思维方式，对事物具体的定义
  
  优点；可扩展性高
  
  缺点；编写程序的复杂程度要高于面向过程编程
面向过程编程：

核心是‘过程’

优点；逻辑清晰，复杂问题流程化

缺点；可扩展性差
优先使用面向过程还是对象
1. 面向过程和面向对象一起使用

02.类

现实世界中；对象是一个个具体存在的事物，类是由人类文明发展中抽象总结出来的。
程序中；必须先有类，再有对象，（通过定义好的类来产生对象）
如何定义类；先从现实世界中，基于一个个对象，总结出类。再在程序中定义出类

对象指；特征与技能的结合体，‘具体的事物’

类是指；一系列具有相同的特征和技能的结合体。

03.定义类的语法

class 用来定义类

类名；用来调用累，用来创造对象。#必须要用驼峰体来写

class 类名：
	对象相同的特征
  对象相同的技能
类名.__dict__方式只能获取类名称空间中的内容，无法修改
类名.特征或技能的方式对类内部进行修改
特征也称之为属性attribute
对象=类名+() 调用这个类，生成一个对象

定义类时；
1. 产生一个空的类的名称空间（执行内部的代码）
2. 把类内部的名字保存到该空间
3. 注意；类在定义阶段会执行类体内的代码

调用类时；

首先会产生一个空对象(只含有类的集体属性)，就是产生‘对象的名称空间’
会自动触发__init__.
会把对象本身和括号内的参数一并传给__init__函数.

# 例；使用__init__方法定义对象间不相同的属性值
class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def choose_course(self):
        print(f'{self.name} choosing course')

    def func(self):
        print('from func')

p1=OldboyStudent('lou',18,'x')
print(p1.func()) # 调用这个特征的func技能

04.对象与类的查找顺序

在外部调用这个对象的值时，对象名称空间——》类名称空间——》报错

05.对象的绑定方法的特殊之处

对象的绑定方法，就是由对象来调用类中的函数

类内部的函数主要是给对象使用的；

由类来调用该函数，这个函数就是一个普通的函数，需要几个参数就要传几个参数。
由对象来调用这个函数，会将对象本身当作第一个位置实参传入，调用时从第二个型参开始传（因为对象本事已经传入该函数，所以可以在函数内给改添加对象的私有属性，也可以更改和添加类的属性）

05.python中一切皆对象

通过 type() 方法查看得到的结果为< class XXX > 都是对象

类是一系列拥有相同属性和功能的对象集合体；

python中的各种数据类型，拥有相同的属性，一样的内置方法

定义一个列表，定义一个字典，定义一个函数，甚至定义一个类

都是在定义一个对象

int flaot str list tuple dict set bool python中一切皆对象（单独存在于一块内存地址中）

06.定义一个对战游戏

# 无脑版
'''
锐雯；
    初始装备；红药水；3 （每只回复125点生命值）  燃烧瓶；1 （每只造成250点伤害）
    生命值；(默认)414（+86/每造成200点伤害）    攻击力；54（+3/每造成200点伤害）   护甲；12（+3/每造成200点伤害）
    技能；突刺（造成150点伤害）     暴击加成；造成双倍伤害
盖伦；
    初始装备；红药水；3 （每只回复125点生命值）  燃烧瓶；1 （每只造成250点伤害）
    生命值；(默认)455（+96/每造成200点伤害）    攻击力；56（+3/每造成200点伤害）   护甲；19（+2/每造成200点伤害）
    技能；挥砍（造成130点伤害）
'''
import random

rj=[1,2,3]
red=125
molotov=250

class Riven:
    red_potion=3
    molotov_cocktails=1
    damage=54
    armor=12
    the_label='riven'
    jn=150
    dj = 0
    jy = 0
    sj_hf=86
    sj_js=3
    sj_hj=12
    def __init__(self,name,money=6300,life=414):
        self.name=name
        self.money=money
        self.life=life
    def attack(self):
        '''使用普通攻击'''
        aa = random.randint(1, 15)
        if aa in rj:
            g1.life-=(self.damage*2)-g1.armor
            self.jy+=(self.damage*2)-g1.armor
            if self.jy>=200:
                self.dj+=1
                self.jy-=200
                self.damage+=self.sj_js
                self.armor+=self.sj_hj
                self.life+=self.sj_hf
            return True,f'{self.name}触发暴击对{g1.name}造成{(self.damage*2)-g1.armor}点伤害'
        g1.life -= self.damage-g1.armor
        self.jy += self.damage - g1.armor
        if self.jy >= 200:
            self.dj += 1
            self.jy -= 200
            self.damage += self.sj_js
            self.armor += self.sj_hj
            self.life += self.sj_hf
        return True, f'{self.name}发动普通攻击对{g1.name}造成{self.damage-g1.armor}点伤害'

    def restore(self):
        '''使用红药水'''
        if self.red_potion>0:
            self.red_potion-=1
            self.life+=125
            return True,f'{self.name}使用一瓶红药水，生命值回复{red}点'
        return False,'你没有红药水了'
    def throwing(self):
        '''使用燃烧瓶'''
        if self.molotov_cocktails>0:
            self.molotov_cocktails-=1
            g1.life -= molotov-g1.armor
            self.jy += molotov-g1.armor
            if self.jy >= 200:
                self.dj += 1
                self.jy -= 200
                self.damage += self.sj_js
                self.armor += self.sj_hj
                self.life += self.sj_hf
            return True,f'{self.name}使用了一瓶燃烧瓶，对{g1.name}造成了{molotov-g1.armor}点伤害'
        return False,'你没有燃烧瓶了'
    def slashing(self):
        '''使用技能'''
        aa = random.randint(1, 4)
        if aa in rj:
            g1.life -= self.jn-g1.armor
            self.jy += self.jn-g1.armor
            if self.jy >= 200:
                self.dj += 1
                self.jy -= 200
                self.damage += self.sj_js
                self.armor += self.sj_hj
                self.life += self.sj_hf
            return True, f'{self.name}对{g1.name}发动技能造成{self.jn-g1.armor}点伤害'
        return True, f'{self.name}技能发动失败'


class Garen:
    red_potion=3
    molotov_cocktails=1
    damage=54
    armor=12
    the_label='garen'
    jn = 130
    dj = 0
    jy = 0
    sj_hf = 96
    sj_js = 3
    sj_hj = 19
    def __init__(self,name,money=5000,life=455):
        self.name=name
        self.money=money
        self.life=life
    def attack(self):
        '''使用普通攻击'''
        g1.life -= self.damage - g1.armor
        self.jy += self.damage - g1.armor
        if self.jy >= 200:
            self.dj += 1
            self.jy -= 200
            self.damage += self.sj_js
            self.armor += self.sj_hj
            self.life += self.sj_hf
        return True, f'{self.name}发动普通攻击对{r1.name}造成{self.damage - r1.armor}点伤害'
    def restore(self):
        '''使用红药水'''
        if self.red_potion>0:
            self.red_potion-=1
            self.life+=125
            return True,f'{self.name}使用一瓶红药水，生命值回复{red}点'
        return False,'你没有红药水了'
    def throwing(self):
        '''使用燃烧瓶'''
        if self.molotov_cocktails > 0:
            self.molotov_cocktails -= 1
            r1.life -= molotov - r1.armor
            self.jy += molotov - r1.armor
            if self.jy >= 200:
                self.dj += 1
                self.jy -= 200
                self.damage += self.sj_js
                self.armor += self.sj_hj
                self.life += self.sj_hf
            return True, f'{self.name}使用了一瓶燃烧瓶，对{r1.name}造成了{molotov - r1.armor}点伤害'
        return False, '你没有燃烧瓶了'
    def slashing(self):
        '''使用技能'''
        aa = random.randint(1, 4)
        if aa in rj:
            r1.life -= self.jn - r1.armor
            self.jy += self.jn - r1.armor
            if self.jy >= 200:
                self.dj += 1
                self.jy -= 200
                self.damage += self.sj_js
                self.armor += self.sj_hj
                self.life += self.sj_hf
            return True, f'{self.name}对{r1.name}发动技能造成{self.jn - r1.armor}点伤害'
        return True, f'{self.name}技能发动失败'

r1=Riven('riven1',7000,500)
g1=Garen('garen1',5000,450)

r1_dic={
    1:r1.attack,
    2:r1.restore,
    3:r1.throwing,
    4:r1.slashing
}
g1_dic={
    1:g1.attack,
    2:g1.restore,
    3:g1.throwing,
    4:g1.slashing
}
num=1
while True:
    print(f'第{num}回合')
    while True:
        r1a = random.randint(1, 4)
        flag,msg=r1_dic[r1a]()
        if flag:
            print(msg)
            print(f'{r1.name}；生命值为{r1.life}点；等级为{r1.dj}级；攻击力为{r1.damage}点；防御力为{r1.armor}点')
            break
    if g1.life<=0:
        print(f'{r1.name}获胜')
        break
    while True:
        g1a = random.randint(1, 4)
        flag,msg=g1_dic[g1a]()
        if flag:
            print(msg)
            print(f'{g1.name}；生命值为{g1.life}点；等级为{g1.dj}级；攻击力为{g1.damage}点；防御力为{g1.armor}点')
            break
    if r1.life<=0:
        print(f'{g1.name}获胜')
        break
    num+=1