Python面向对象编程进阶

Python面向对象编程进阶

一、OOP三大特征之一：封装
1.1封装概念
为了保证数据安全性，降低代码的耦合度
将具有统一功能或者相关代码块进行高度抽象的处理过程
主要表现形式就是将一段代码块高度抽象成一个函数，一个类或类方法
1.2访问修饰符
为了更好地保护数据，Python提供了三种访问权限级别:公有、私有和受保护
①公有修饰的变量和方法，类的内部或外部均可调用访问。即为大家公共的数据。
②私有修饰的变量和方法，仅供类内部使用，本类外部无法访问调用。即不开放数据。
③受保护修饰的变量和方法，在程序中只有本类及其子类可以调用。即受限的数据。
1.3访问修饰符的使用
Python编程语言很巧妙地使用下划线+标识符的命名规则，实现了对变量和方法的访问控制。
①标识符开头无下划线，该变量或方法为公有权限(即类内外均可访问谓用)
self.name or def show(self)
②标识符开头双下划线，该变量或方法为私有权限(即仅类内部自己可以访问调用)
self. name or def __show(self)
③标识符开头单下划线，该变量或方法为保护权限(即类本身及其子类可以访问调用)
self. name or def _show(self)

注意：外界无法访问私有方法和私有属性，但可以在类内部方法私有方法和私有属性。
二、OOP三大特征之一：继承
2.1继承extends
子类可以继承父类，面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。
优点：1，增加了类的耦合性（耦合性不宜多，宜精）。
2，减少了重复代码。
3，使得代码更加规范化，合理化。
注意：在继承关系下，子类将会拥有父类全部的方法（即父类方法可在子类对象中访问调用）
2.2继承语法

在继承实现中，在字类小括号中写入父类的名称，可以继承父类的方法，直接通过对象调用，可以重写父类方法，也可以写子类自己的方法。

注意：在子类中可以使用父类中受保护的方法，不能使用父类中的私有的方法。
2.3多重继承
①Python的类可以继承多个类，不像很多高级编程语言Java和C#那样只能继承一 个类(单根语系) .
②特别注意:在Python2.x版本中，类如果继承了多个类，那么其对象调用寻找方法的方式有两种。分别是:深度优先（经典类）和广度优先（新式类）.
③在Python3.x版本中经典类和新式类都是统一按广度优先来继承的。
如果没有父类，则默认继承object，mro()函数：在执行方法的时候，搜索方法的顺序，尽量避免方法名相同的情况，实现多继承的方式，在子类的括号中写出所有要继承的类。
2.4继承下的super（）概述
在Python面向对象的继承特征下，若子类需调用父类的方法，则需要使用super（）来实现。
在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照MRO（Method Resolution Order）（代表了类继承的顺序）：方法解析顺序进行的。
推荐使用super().方法，不建议使用 类名.方法
2.5 super（）遇到__init__（）
在继承体系中，init()起用来初始化对象的，在父子类关系中父类的__init__()必须要显示调用才能执行，super().init(参数)

思考:
1.在整个继承体系中当创建D对象的时候，A的构造方法有没有被调用???
D中显示调用了A的构造方法就会被调用。
2.init__和__new 的区 别是什么???
构造方法包括创建对象和初始化对象，在python当中，分为两步执行：先执行__new__方法，然后执行__init__方法;__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值。__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例，是个静态方法。

三、OOP三大特征之一：多态
3.1多态
本质上python没有多态
Python中崇尚“鸭子类型”
鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。
四、案例：
4.1封装实例

""" 定义一个标准的对象 """
""" 定义出商品类 """
class Product(object):
    #创建对象
    def __init__(self):
        #商品ID，商品名称，商品价格
        self.__pid = None
        self.__pname = None
        self.__pprice = None
        pass
    #重写__str__
    def __str__(self):
        print("{0} , {1} , {2}".format(self.__pid , self.__pname , self.__pprice))
        #一定要记得return
        return ""
        pass
    @property
    def pid(self):
        return self.__pid
        pass
    @pid.setter
    def pid(self,value):
        self.__pid = value
        pass
    @pid.getter
    def pid(self):
        return self.__pid
        pass
    @property
    def pname(self):
        return self.__pname
        pass
    @pname.setter
    def pname(self, value):
        self.__pname = value
        pass
    @pname.getter
    def pname(self):
        return self.__pname
        pass
    @property
    def pprice(self):
        return self.__pprice
        pass
    @pprice.setter
    def pprice(self, value):
        self.__pprice = value
        pass
    @pprice.getter
    def pprice(self):
        return self.__pprice
        pass
    pass
if __name__ == "__main__":
    p = Product()
    p.pid = 111
    p.pname = "siri"
    p.pprice = 999
    print(p)
    print("------ 生成10个商品 ------")
    #生成10个商品
    def generatorP():
        for i in range(10):
            p = Product()
            p.pid = i + 1
            p.pname = "商品 %s"  %(i + 1)
            p.pprice = i * 1000
            #将生成好的商品放入到内存中
            yield p
            pass
        pass
    #迭代商品
    for p in generatorP():
        print(p)
        pass
    pass

4.2继承实例

""" 继承 """
"""在继承实现中，在字类小括号中写入父类的名称，可以继承父类的方法，直接通过对象调用，可以重写父类方法，也可以写子类自己的方法"""
class Animal():
    #这里提取的是狗和猫的特性
    def chi(self):
        print("{0}吃东西".format(self.name))
        pass
    def he(self):
        print("{0}喝东西".format(self.name))
        pass
    def wan(self):
        print("{0}玩".format(self.name))
        pass
    def say(self):
        print("{0}在叫~~~~".format(self.name))
        pass
    def _protectedMethod(self):
        print("Animal中受保护的方法")
        pass
    def __privateMethod(self):
        print("Animal中私有的方法")
        pass
    pass
"""狗继承动物类"""
class Dog(Animal):
    def __init__(self , name):
        self.name = name
        pass
    def yao(self):
        print("{0}会咬人".format(self.name))
        pass
    pass
"""猫继承动物类"""
class Cat(Animal):
    def __init__(self , name):
        self.name = name
        pass
    def zhua(self):
        print("{0}会抓人".format(self.name))
        pass
    pass
if __name__ == "__main__":
    dog = Dog("dog")
    dog.say()
    dog.chi()
    dog.he()
    dog.wan()
    dog.yao()
    dog._protectedMethod()
    # 在字类中可以使用父类中受保护的方法，不能使用父类中的私有的方法
    #AttributeError: 'Dog' object has no attribute '__privateMethod'
    #dog.__privateMethod()
    print("--" * 20)
    cat = Cat("cat")
    cat.say()
    cat.chi()
    cat.he()
    cat.wan()
    cat.zhua()
    cat._protectedMethod()
    pass

4.3多继承实例

class A(object):
    def __chi(self):
        print("吃独食。。。")
        pass
    def SPEAK(self):
        print("A中的SAY方法")
        pass
    def say(self):
        print("A中的SAY方法")
        pass
    pass
class SonA(A):
    pass
#没写父类默认继承object
class B():
    def say(self):
        print("B中的SAY方法")
        pass
    def run(self):
        print("这是B 中的RUN方法")
        pass
    pass
class Zi(SonA ,B):
    def learn(self):
        print("good good study")
        pass
    pass
if __name__ == "__main__":
    zi = Zi()
    zi.learn()
    zi.run()
    #AttributeError: 'Zi' object has no attribute '__chi'
    # zi.__chi()
    zi.say()
    print(Zi.mro())
    pass