面向对象基础

1、面向过程的程序设计
优点:复杂的问题流程化，进而简单化
缺点:可扩展性差

2、面向对象程序设计
优点:可扩展性强
缺点:编程的复杂性高

3、类与对象
在现实世界中:肯定是先有对象，后又类
在程序中:务必保证先定义类，后产生对象


对象:特征与技能的结合体
类:一系列对象相似的特征与相似的技能的结合体

定义类:

class luffystudent:
    school = "luffycity" # 数据属性

    def learn(self):     # 函数属性
        print("is learning")

    def eat(self):       # 函数属性
        print("is eatting")

    def sleep(self):     # 函数属性
        print("is sleepping")

注意:
1、类中可以有任意python代码，这些代码在类定义阶段便会执行，因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过oldboystudent.__dict__查看
2、类中定义的名字，都是类的属性，点是访问属性的语法。
3、对于经典类来说我们可以通过该字典操作类名称空间的名字，但新式类有限制

类的使用:
luffystudent.school #查
luffystudent.school='luffy' #改
luffystudent.x=1 #增
del luffystudent.x #删

类的调用(实例化，得到程序中的对象)
stu1 = luffystudent()
stu2 = luffystudent()
stu2 = luffystudent()

stu1、stu2、stu3被称为对象


__init__方法:
此方法是在产生对象之后才会执行，只用来为对象进行初始化操作，可以有任意的代码，但是不能拥有返回值。

class luffystudent:
    school = "luffycity" # 数据属性

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

    def learn(self):     # 函数属性
        print("is learning")

    def eat(self):       # 函数属性
        print("is eatting")

    def sleep(self):     # 函数属性
        print("is sleepping")

stu1 = luffystudent("xu", 18, "man")
stu2 = luffystudent("chong", 20, "man")
stu3 = luffystudent("guang", 21, "man")

当对象产生后，stu1就会被赋给self

对象的调用:
对象的名称空间可以用stu1.__dict__查看，查询结果为{'name': 'xu', 'age': 18, 'sex': 'man'}

stu1.name 查，与stu1.__dict__['name']相同
stu1.name = 'dashuaige' 改与stu1.__dict__['name']='dashuaige'相同
stu1.course = 'python' #增，等同于s2.__dict__['course']='python'
del s2.course #删，等同于s2.__dict__.pop('course')

注意:
1、站的角度不同，定义出的类是截然不同的；
2、现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类等；
3、有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类

属性查找:
类有两种属性:1、数据属性 2、函数属性
数据属性是所有对象共享的
print(id(luffystudent.school))

print(id(stu1.school)) #4377347328
print(id(stu2.school)) #4377347328
print(id(stu3.school)) #4377347328

类的函数属性是绑定给对象使用的,称为绑定到对象的方法
在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

绑定方法:

class luffystudent:
    school = "luffycity" # 数据属性

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

    def learn(self):     # 函数属性
        print("%s is learning" %self.name)

    def eat(self):       # 函数属性
        print("%s is eatting" %self.name)

    def sleep(self):     # 函数属性
        print("%s is sleepping" %self.name)

stu1 = luffystudent("xu", 18, "man")
stu2 = luffystudent("chong", 20, "man")
stu3 = luffystudent("guang", 21, "man")

对绑定方法进行调用:
luffystudent.learn(stu1) #xu is learning
luffystudent.learn(stu2) #chong is learning
luffystudent.learn(stu3) #guang is learning

类中定义的函数（没有被任何装饰器装饰的）是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数

stu1.learn()  等同于luffystudent.learn(stu1)
stu2.learn()  等同于luffystudent.learn(stu2)
stu3.learn()  等同于luffystudent.learn(stu3)

1、绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）
2、绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self

最后在python中，一切皆为对象。

 

练习1：编写一个学生类，产生一堆学生对象。
要求：
    有一个计数器（属性），统计总共实例了多少个对象

class student:
    school = "luffycity"
    count = 0
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        student.count += 1

    def learn(self):
        print('%s is learning' %self.name)

stu1 = student('xu', 17, 'man')
stu2 = student('chong', 15, 'man')
stu3 = student('guang', 22, 'man')
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)

print(stu1.count)
print(stu2.count)
print(stu3.count)

练习2：模仿王者荣耀定义两个英雄类， (10分钟)
要求：
1、英雄需要有昵称、攻击力、生命值等属性；
2、实例化出两个英雄对象；
3、英雄之间可以互殴，被殴打的一方掉血，血量小于0则判定为死亡。

class gailun:
    def __init__(self, name, aggresivity, life_value):
        self.aggresivity = aggresivity
        self.name = name
        self.life_value = life_value

    def attack(self, obj):
        obj.life_value -= self.aggresivity
        if obj.life_value <= 0:
            print('%s 死亡' %obj.name)
            return true
        else:
            print("%s被攻击, 生命值为:%s" %(obj.name, obj.life_value))
            return false

class ruiwen:
    def __init__(self, name, aggresivity, life_value):
        self.aggresivity = aggresivity
        self.name = name
        self.life_value = life_value

    def attack(self, obj):
        if obj == self:
            print("不能攻击自身")

        obj.life_value -= self.aggresivity

        if obj.life_value <= 0:
            print('%s 死亡' %obj.name)
            return true
        else:
            print("%s被攻击,生命值为:%s" %(obj.name, obj.life_value))
            return false

            
gailun = gailun("盖伦", 20, 100)
ruiwen = ruiwen("锐雯", 10, 150)

gailun.attack(ruiwen)