python开发学习笔记之六（面向对象）

面向对象引入：

　　现在有一个这样的需求：做汽水。

　　在之前的学习中，我们怎样处理这种类似的问题呢？思考一下，哦，不就是分步骤做嘛，把复杂的问题简单化，分成一个一个的步骤，就像机器人，流水线一样，先干什么后干什么，然后干什么，最后再干什么。于是这个问题就可以分解成这几个步骤：

　　制作汽水瓶———制作汽水————把汽水灌入汽水瓶————封口————贴标签————打包装箱

　　这就是一套完整的汽水制作生产线，这就是典型的面向过程的程序设计思路。

　　面向过程的优缺点：

　　　　优点：复杂问题流程化，进而简单化。将问题分解成步骤，逐个步骤进行处理

　　　　缺点：针对性太强，一套方法只适用于一种需求，代码的可重用性太低，只适用于一些一旦写好不进行修改的场景。

　　而面向对象是站在上帝角度来看待问题，上面做汽水的流水线，就可以看做是一个对象。这个对象可以做汽水瓶，可以做汽水，可以灌装，等等一系列的操作。

　　对象的概念就是：特征与技能的结合体（人就是个对象，人有名字年龄性别，这是特征；人会吃饭睡觉学习，这是技能。）

　　面向对象的优缺点：

　　　　优点：提高了代码的扩展性，对某个对象进行修改，可以影响到整个代码体系

　　　　缺点：编程的复杂度提高，无法准确地预测最终结果。 适用于需求不断变化的场景

 

类与对象：

---

　　类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体

　　现实世界中，先有对象，后有类：

#在现实世界中，站在老男孩学校的角度：先有对象，再有类
对象1：李坦克
    特征:
        学校=oldboy
        姓名=李坦克
        性别=男
        年龄=18
    技能：
        学习
        吃饭
        睡觉

对象2：王大炮
    特征:
        学校=oldboy
        姓名=王大炮
        性别=女
        年龄=38
    技能：
        学习
        吃饭
        睡觉

对象3：牛榴弹
    特征:
        学校=oldboy
        姓名=牛榴弹
        性别=男
        年龄=78
    技能：
        学习
        吃饭
        睡觉


现实中的oldboy学生类
    相似的特征:
        学校=oldboy
    相似的技能：
        学习
        吃饭
        睡觉

　　在程序中，先定义类，后实例化出对象：

class Student：
    school = 'oldboy'  # 相同的特征
    def __init__(self, name, age, sex)  # 各自的特征
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self):  # 相似的技能
        print('eating...')
    def learn(self):
        print('learning...')
    def sleep(self)
        print('sleeping...')

 　　上面的代码就是定义了一个学生类

　　获得对象就是通过类实例化出来

stu1 = Student('zhangsan','18,'男')

类的使用：

定义Student类：

class Student:
    school='oldboy'
    def learn(self):
        print('is learning')
        
    def eat(self):
        print('is eating')
    
    def sleep(self):
        print('is sleeping')

# 查看类的名称空间
　Student.__dict__

查看类中的属性：

　　Student.__dict__['school']   就可以获得类的数据属性，python 专用的属性访问方法是 Student.school

设置类中的属性：

　　增加属性：Student.county = 'China'　　修改属性：Student.school = 'OLDBOY'

删除类中的属性：

　　del Student.school

对象的使用：

先生成三个对象：

　　stu1 = Student()

　　stu2 = Student()

　　stu3 = Student()

这三个学生对象都有相同的学校和相同的技能，但是这三名学生也有各自独有的属性：姓名，年龄，性别，那么怎么个性化定制每个学生的信息呢？

这就用到了类内部的__init__方法，它在实例化出对象时就会执行，给对象创建出各自不同的属性

#  定义类

class Student:
    school = 'oldboy'
    
    def __init__(self, name, age, sex):  # 为对象定制各自的数据属性
        self.Name = name
        self.Age = age
        self.Sex = sex
    
    def eat(self):
        print('is eating...')
        
    def learn(self):
        print('is learning...')
        
    def sleep(self):
        print('is sleeping...')

#  实例化对象

stu1 = Student('zhangsan',18,'male')

它实例化的具体步骤是：先产生一个空对象，再通过__init__方法给空对象添加属性

查看对象的属性：

　　stu1.name

　　stu1.learn()

设置对象的属性：

　　增加属性：stu1.class_name = 'python开发'　　修改属性：stu1.name = 'lisi'

删除对象的属性：

　　del stu1.name

注意：在类中的数据属性是所有对象所直接共有的，是同一个id；而类中的函数属性是分别绑定到每个不同的对象，是不同的id.

当通过类调用类内部的方法时需要把对象当做参数传入函数：

　　Student.learn(stu1)

当实例化出一个对象时，对象会绑定类内的函数为对象自己的绑定方法。实际上，类内的函数属性就是给对象使用的

而通过对象来调用自己的绑定方法时，会自动把对象传入函数当做参数（谁来调用，就把谁当做参数传入函数）：

　　stu1.learn()

查找属性会先从对象自己内部查找属性，如果对象内部没有这个属性，就会从这个对象的类里去查找属性，类似与函数的局部变量与全局变量

补充：

　　1.站的角度不同，定义的类也不同

　　2.编程中可能定义现实生活中不存在的类，比如关系类，策略类等等

ps: python中一切皆对象,在python3中统一了类与类型的概念

练习一：

　　编写学生类，实例化一些学生对象，并加上计数器（属性），统计实例化的对象个数：

class Student:  # 生成学生类
    school = 'oldboy'
    count = 0  # 生成计数器
    def __init__(self, name, age, sex):
        self.Name = name
        self.Age = age
        self.Sex = sex
        Student.count += 1  # 每实例化一个对象把类的计数器加一


    def eat(self):
        print('is eating...')

    def learn(self):
        print('is learning...')

    def sleep(self):
        print('is sleeping...')


stu1 = Student('zhangsan', 18, 'male')
stu2 = Student('lisi', 28, 'female')
stu3 = Student('wangwu', 38, 'male')

print(Student.count)

练习二：

　　模仿LOL，生成游戏角色对象，角色可以互相攻击

class Garen:  # 定义盖伦类
    def __init__(self, nickname, hp, ap):
        self.nickname = nickname
        self.hp = hp
        self.ap = ap

    def attack(self, enemy):

        enemy.hp -= self.ap


class Reven:  # 定义瑞文类
    def __init__(self, nickname, hp, ap):
        self.nickname = nickname
        self.hp = hp
        self.ap = ap

    def attack(self, enemy):
        enemy.hp -= self.ap



g = Garen('草丛伦', 500, 30)

r = Reven('瑞雯雯', 300, 50)

print('r', r.hp)
g.attack(r)
print('r', r.hp)

　　看一下上面的代码，你会发现两个类内部的代码是一模一样的，那么如果再需要定义其他角色就要重复写同样的代码，怎么解决代码重复性的问题呢？

　　这就需要了解一个概念：

继承：

　　继承指的是类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代码重用问题

　　继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可以成为基类或超类，新建的类称为派生类或子类

class Hero:
    def __init__(self, nickname, hp, ap):
        self.nickname = nickname
        self.hp = hp
        self.ap = ap

    def attack(self, enemy):

        enemy.hp -= self.ap

class Garen(Hero):
    pass


class Reven(Hero):
    pass

g = Garen('草丛伦', 500, 30)

r = Reven('瑞雯雯', 300, 50)

print('r', r.hp)
g.attack(r)
print('r', r.hp)

上面的代可以写成这种形式，两个角色类可以继承英雄类，从而提高了代码的复用性。

单继承与多继承

　　在python中可以继承多个父类：

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

查看继承关系：

 SubClass1.__bases__

有了继承关系，通过对象去查找属性是就是这样：

对象本身——对象的类————类的父类——...

一层一层的查找，找到就不往上找了

派生：

　　子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己的属性为准。

class Riven(Hero):
    camp='Noxus'
    def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
        print('from riven')
    def fly(self): #在自己这里定义新的
        print('%s is flying' %self.nickname)

继承的实现原理

　　当定义一个类时，python会为这个类生成一个方法解释顺序mro列表，为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1. 子类会先于父类被检查
2. 多个父类会根据它们在列表中的顺序被检查
3. 如果对下一个类存在两个合法的选择,选择第一个父类

　　在Java和C#中子类只能继承一个父类，而Python中子类可以同时继承多个父类，如果继承了多个父类，那么属性的查找方式有两种，分别是：深度优先和广度优先

在python3中所有的类都是新式类，新式类就是在不指定继承关系的情况下，默认继承object类。在一系列的继承之后，最顶端的父类必然是object类

接下来思考一个问题，如果想在子类中想复用一下父类的方法，需要怎么办呢？

比如：

class Hero:
    def __init__(self, nickname, hp, ap):
        self.nickname = nickname
        self.hp = hp
        self.ap = ap
    def attack(self, enemy):
        enemy.hp -= self.ap

class Garen(Hero):
    def attack(self, enemy):
                                    #<---在这里重用父类的攻击方法
        print('Garen attack!')
    pass


class Reven(Hero):
    pass

g = Garen('草丛伦', 500, 30)
r = Reven('瑞雯雯', 300, 50)

那么你可能会想到下面这种方法：

class Hero:
    def __init__(self, nickname, hp, ap):
        self.nickname = nickname
        self.hp = hp
        self.ap = ap

    def attack(self, enemy):

        enemy.hp -= self.ap

class Garen(Hero):
    def attack(self, enemy):
        Hero.attack(self, enemy)       #<---在这里重用父类的攻击方法
        print('Garen attack!')
    pass


class Reven(Hero):
    pass



g = Garen('草丛伦', 500, 30)

r = Reven('瑞雯雯', 300, 50)

这种就是指名道姓的调用方法，不依赖于继承关系

第二种就是依赖于继承关系的 super() 方法：

class Hero:
    def __init__(self, nickname, hp, ap):
        self.nickname = nickname
        self.hp = hp
        self.ap = ap

    def attack(self, enemy):

        enemy.hp -= self.ap

class Garen(Hero):
    def attack(self, enemy):
        super().attack(enemy)      #<---在这里重用父类的攻击方法
        print('Garen attack!')
    pass


class Reven(Hero):
    pass



g = Garen('草丛伦', 500, 30)

r = Reven('瑞雯雯', 300, 50)

 组合：

　　组合指的就是是在一个类里以另一个类中的对象为数据属性，也就是什么“有”什么的关系：

举个上文中的例子：

>>> class Equip: #武器装备类
...     def fire(self):
...         print('release Fire skill')
... 
>>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
...     camp='Noxus'
...     def __init__(self,nickname):
...         self.nickname=nickname
...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
... 
>>> r1=Riven('锐雯雯')
>>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill

组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，

1.继承的方式

通过继承建立了派生类与基类之间的关系，它是一种'是'的所属关系，比如白马是马，人是动物。

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人

2.组合的方式

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的拥有关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3...

抽象类与归一化：

抽取子类比较相像的部分，统一规范类中的属性调用方法，这用到了一个叫 abc 的模块

import abc


class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def run(self):
        pass

    @abc.abstractmethod
    def eat(self):
        pass



class People(Animal):
    pass

class Pig(Animal):
    def run(self):
        print('pig is runing')

    def eat(self):
        print('pig is eating')

pig1 = Pig()
peo1 = People()

当People类没有用抽象类规范的方法时就会报错。通过抽象类实现了归一化的作用。

多态与多态性：