面向对象

Posted 2022-10-18 lulingjie

一、面向对象和面向过程的优缺点

	面向过程	面向对象
优点	复杂问题流程化，进而简单化	可扩展性高
缺点	可扩展性差	编写复杂

二、类与对象

2.1 定义类

一系列共同的属性和方法。eg：人类

class 关键字 类名:
    pass

假设我们要定义学生这样一个类，将下面一段代码中一系列共同的属性和方法提取出来写成代码。

‘‘‘
学生1:
    学校:老男孩
    姓名:李铁蛋
    性别:男
    年龄:18
    方法:
        选课
        学习
学生1:
    学校:老男孩
    姓名:jiayi
    性别:女
    年龄:20
    方法:
        选课
        学习
‘‘‘
---------------------------------------------------------------
class Student:
    school = ‘oldboy‘  #属性
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")

2.2 类

2.2.1获取类的属性和方法

类.__dict__

#定义一个学生类
class Student:
    school = ‘oldboy‘  #属性
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")
print(Student.__dict__)
-----------------------------------------------------------------------------------
‘__module__‘: ‘__main__‘, ‘school‘: ‘oldboy‘, ‘__init__‘: <function Student.__init__ at 0x000001BBBC6E1620>, ‘choose‘: <function Student.choose at 0x000001BBC3912C80>, ‘study‘: <function Student.study at 0x000001BBC3912D08>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Student‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Student‘ objects>, ‘__doc__‘: None

2.2.2类来调用属性和方法
-通过dict来调用（复杂，不用）

print(Student.__dict__)    #获取到的是一个字典
print(Student.__dict__[‘school‘])  #获取到的是学校这个属性
print(Student.__dict__[‘choose‘])   # 获取到的是一个函数地址，因为没有传参
Student.__dict__[‘choose‘](123)   #调用了choose函数
---------------------------------------------------------------
‘__module__‘: ‘__main__‘, ‘school‘: ‘oldboy‘, ‘choose‘: <function Student.choose at 0x0000017A47001620>, ‘sutdy‘: <function Student.sutdy at 0x0000017A4E213C80>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Student‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Student‘ objects>, ‘__doc__‘: None
oldboy
<function Student.choose at 0x0000017A47001620>
这是一个选课的方法   

? -类来调用属性和方法 （类名.属性/函数）

print(Student.school)
Student.choose(123)  #函数一定要传参
-----------------------------------------------------------
oldboy
这是一个选课的方法

2.3产生对象

类加括号,生成对象

对象 = 类名()

stu1=Student()  #学生1就是一个对象

2.4对象

2.4.1对象获取属性和方法

对象.__dict__

stu1=Student()  #产生对象
print(stu1.__dict__)    #此处为空字典是因为他没有是有的属性，还没有定义属性，所以是空字典
-----------------------------------------------------

2.4.2对象调用属性和方法

# 对象.属性/函数 
stu1=Student()
print(stu1.school)
stu2=Student()
print(stu2.school)
-------------------------------------------------------------
oldboy
oldboy

2.5 对象自己的属性和方法

stu1=Student()
stu1.name=‘jiayi‘   #对象自己定义的属性，也就是对象赋属性
stu1.school=‘xxxx‘    #对象自己定义的属性，也就是对象赋属性
print(stu1.name)
print(stu1.school)
print(stu1.__dict__)   #此时查看就不会为空字典
---------------------------------------------------
jiayi
xxxx
‘name‘: ‘jiayi‘, ‘school‘: ‘xxxx‘

三、对象的绑定方法

3.1 属性查找顺序

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

3.2 对象赋属性

• 方式一:

stu1 = Student()
stu1.name = ‘jiayi‘

• 方式二（通过__init__）:
  -在类中定义该方法,方法上写一些参数
  -在对象实例化产生对象时,在括号中传的值,会被传到__init__中

#定义类
class Student:
    school = ‘oldboy‘  #变量表示属性
    # __init__ 看好名字,不是__int__
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")
        
#产生对象
stu1=Student(‘jiayi‘)
#内部帮我们做了一些事:当我在实例化产生对象的时候,会自动调用__init__方法,完成对象的初始化
print(stu1.name)
stu2=Student(‘ypp‘)
print(stu2.name)
-----------------------------------------------------------
jiayi
ypp

3.3 绑定方法

-定义在类内部的方法:

-类来调用:就是一个普通函数,有几个参数就需要传几个参数

-对象来调用:它叫对象的绑定方法,第一个参数不需要传,自动传递

 #定义类
class Student:
    school = ‘oldboy‘  #变量表示属性
    # __init__ 看好名字,不是__int__
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")

        
stu1=Student(‘李铁蛋‘)
stu1.study()
-------------------------------
李铁蛋

3.4 一切皆对象

python中,字典,列表字符串....都是对象

类即类型 eg:字典类

#类实例化产生对象
ll=list([1,2,3])
#对象调用对象的绑定方法,修改对象自己
ll.append(5)
print(ll)
print(type(ll))
--------------------------------------------------------------
[1, 2, 3, 5]
<class ‘list‘>

四、锐雯大战盖伦大战小游戏

import random
#诺克萨斯类
class Noxus:
    def __init__(self,name,
                 aggressivity=54,
                 life_value=414,
                 money=1600,
                 armor=3,
                 grade=1):
        self.name=name
        self.aggressivity=aggressivity+grade*2.75
        self.life_value=life_value+grade*86
        self.money=money
        self.armor=armor
    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value
        print(f‘‘‘
                r1.name普通攻击了g1.name
                造成了damage_value伤害
                g1.name还剩enemy.life_value血量
                ‘‘‘)
#德玛西亚类
class Demacia:
    def __init__(self,name,
                 aggressivity=58,
                 life_value=455,
                 money=500,
                 armor=10,
                 grade=1):
        self.name=name
        self.aggressivity=aggressivity+grade*3.5
        self.life_value=life_value+grade*96
        self.money=money
        self.armor=armor
    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value
        print(f‘‘‘
                g1.name普通攻击了r1.name
                造成了damage_value伤害
                r1.name还剩enemy.life_value血量
                ‘‘‘)

class BlackCleaver:
    def __init__(self,price=475,aggrev=9,life_value=100):
        self.price=price
        self.aggrev=aggrev
        self.life_value=life_value
    def update(self,obj):
        obj.money-=self.price #减钱
        obj.aggressivity+=self.aggrev #加攻击
        obj.life_value+=self.life_value #加生命值
    def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
        obj.life_value-=100 #假设火烧的攻击力是100
print(‘锐雯和盖伦会随机攻击，会随机施放装备主动，满级为18级‘)
r_grade_choice=int(input(‘请输入锐雯的等级‘))
r_money_choice=int(input(‘请输入锐雯的金钱‘))
g_grade_choice=int(input(‘请输入盖伦的等级‘))
g_money_choice=int(input(‘请输入盖伦的金钱‘))
r1=Noxus(‘锐雯‘,grade=r_grade_choice,money=r_money_choice)
g1=Demacia(‘盖伦‘,grade=g_grade_choice,money=g_money_choice)
b1=BlackCleaver()
def fight():
    while True:
        i=random.randint(1,5)
        if r1.life_value<0 or g1.life_value<0:
            break
        if i %2==0:
            r1.attack(g1)
            if i==2:
                r1.b1.fire(g1)
                print(f‘‘‘
                        r1.name施放装备主动
                        造成了100伤害
                        g1.name还剩g1.life_value血量
                        ‘‘‘)
        else:
            g1.attack(r1)
            if i==1:
                g1.b1.fire(r1)
                print(f‘‘‘
                        g1.name施放装备主动
                        造成了100伤害
                        r1.name还剩r1.life_value血量
                        ‘‘‘)
    if r1.life_value<0:
        print(‘Demacia victory‘)
    elif g1.life_value<0:
        print(‘Noxus victory‘)

print(f‘锐雯的攻击力,生命值,金钱r1.aggressivity,r1.life_value,r1.money‘)
print(f‘盖伦的攻击力,生命值,金钱g1.aggressivity,g1.life_value,g1.money‘)
choice=input(‘是否购买多兰之刃(￥475),攻击力9点/把，生命值100/把，主动技能喷火造成真实伤害100点,y/n‘)
if choice==‘y‘:
    while True:
        if r1.money > b1.price:
            r1.b1=b1
            b1.update(r1)
        else:
            break
    while True:
        if g1.money > b1.price:
            g1.b1=b1
            b1.update(g1)
        else:
            break
    print(f‘购买后锐雯的攻击力,生命值,金钱r1.aggressivity,r1.life_value,r1.money‘)
    print(f‘购买后盖伦的攻击力,生命值,金钱g1.aggressivity,g1.life_value,g1.money‘)
    fight()
elif choice==‘n‘:
    while True:
        i=random.randint(1,5)
        if r1.life_value<=0 or g1.life_value<=0:
            break
        if i %2==0:
            r1.attack(g1)
        else:
            g1.attack(r1)
    if r1.life_value<=0:
        print(‘Demacia victory‘)
    elif g1.life_value<=0:
        print(‘Noxus victory‘)