python面向对象之三大特性

Posted 蔠缬草

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python面向对象之三大特性相关的知识,希望对你有一定的参考价值。

继承

  先看个简单的例子了解一下继承。

技术分享图片
class Animal:   # 父类
    def __init__(self, name, age, department):
        self.name = name
        self.age = age
        self.department = department

    def running(self):
        print(%s可以奔跑!% self.name)


class Cat(Animal):   # 括号里放要继承的父类
    def __init__(self, name, age, department, tail):
        Animal.__init__(self, name, age, department)   # 即想使用父类的属性又有自己独有的属性,就在内部调用父类的__init__
        self.tail = tail    # 派生属性


class Mouse(Animal):
    def __init__(self, name, age, department, tail):
        super().__init__(name, age, department)   
        # super方法只在python3中有 相当于Animal.__init__(self, name, age, department)
        self.tail = tail


class Human(Animal):
    def __init__(self, name, age, department):
        Animal.__init__(self, name, age, department)

    def create(self):    # 派生方法
        print(%s可以创造!% self.name)


cat = Cat(Tom, 10, 猫科, 蓝色尾巴)
mouse = Mouse(Jerry, 7, 鼠科, 灰色尾巴)
human = Human(zzy, 24, 人科)
print(cat.name)   # Tom
print(mouse.tail)  # 灰色尾巴
cat.running()   # Tom可以奔跑!
human.create()  # zzy可以创造!
print(Human.mro())  # [<class ‘__main__.Human‘>, <class ‘__main__.Animal‘>, <class ‘object‘>]查看继承顺序
print(Human.__bases__)  # <class ‘__main__.Animal‘>查看继承的所有父类
继承

   通过上面的例子总结一下继承的特性:

"""
    继承:子类是父类的关系  作用:可以减少代码的重复
    通过 类名(父类名) 来进行继承,
    一个类可以单继承也可以多继承
    一个类可以被单个类继承,也可以被多个类继承
    父类中没有而子类中有的属性为 派生属性                      
    父类中没有而子类中有的方法为 派生方法
    单继承:
        对象调用时,先在子类里找,子类里有一定用子类里的,没有再去父类里面找
    多继承:
        在新式类中(python3中都是新式类),对象调用查找是按广度查找
        新式类,默认继承object
        在经典类中,对象调用查找是深度查找
        经典类,python2.7创建的默认类,继承object后变为新式类
"""

 

  研究一下继承的查找顺序:这里以python3为例

class D:
    def func(self):
        print(d)


class C(D):
    def func(self):
        print(c)


class B(D):
    def func(self):
        print(b)


class A(B, C):
    def func(self):
        print(a)


a = A()
a.func()  # a A类里有就找A类

# 注释掉A类里的func
a.func()   # b  A类里没有,先从括号中最左边的B类里找

# 注释掉B类里的func
a.func()   # c  B类里没有,判断通过C类也能找到B的父类D,会从C类先找

# 注释掉C类里的func
a.func()   # d  C类里没有,就找父类D

  上面的继承顺序可以看出:

"""
    广度查找:原则就是在没找到时,按继承层级找完每一个父类
    深度查找:原则是一条继承线路找到底才会找另外的线路
"""

 

  再看下super方法的本质:

class A(object):
    def func(self):
        print(A)


class B(A):
    def func(self):
        super().func()
        print(B)


class C(A):
    def func(self):
        super().func()
        print(C)


class D(B, C):
    def func(self):
        super().func()
        print(D)


b = D()
b.func()  # 打印顺序为 A C B D
# super的本质 :不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

 

封装

  封装 用于对代码的保护,使类中的隐藏属性和方法只有通过提供的公共访问方式来使用,而不能直接查。

  下面写个例子具体看下:

class Person:
    __keys = 量子编码规则   # 私有静态属性

    def __init__(self, name, password):
        self.name = name
        self.__password = password  # __属性  定义私有属性

    def __get_password(self):  # __方法  定义私有方法
        return self.__password   # 只能在内部访问

    def login(self, name, passwd):  # 提供公共访问方法
        if name == self.name and passwd == self.__get_password():
            print(登陆成功)


person = Person(zzy, zzy123)
# print(person.__password)  # 报错 显示Person类找不到__password
# print(person._Person__password)  # zzy123  在外部通过  _类名__属性名 也能查看私用属性,但是不能这样用!
person.login(zzy, zzy123)  # 登陆成功

  那子类能否继承父类的私有属性呢?

class Foo:
    __key = 123


class Son(Foo):
    print(Foo.__key)   # 报错  子类不能继承父类的私用属性

 

多态

"""
    多态:指一类事物有多种形态,python天生支持多态。
    python中推崇鸭子类型,即看起来用起来都很像,但却没有任何约束关系,是一种自我约束行为。比如list和tuple
        优点:松耦合,相似类之间不会有任何影响
        缺点:自我约束,随意性太强
"""

   例子

class Holy:
    def cure(self, HP):
        HP += 100
        return 血量为%s% HP


class Discipline:
    def cure(self, HP):
        HP += 100
        return 血量为%s% HP


def cure(obj, HP):   # 在强数据类型语言中,obj必须要指定数据类型,在Python中就可以是多种形态的
    return obj.cure(HP)


# 这里的Discipline类和Holy类就很相似,就可以当同一个事物去使用
holy = Holy()
discipline = Discipline()
print(cure(holy, 20))
print(cure(discipline, 10))

 

以上是关于python面向对象之三大特性的主要内容,如果未能解决你的问题,请参考以下文章

19.Python面向对象之:三大特性:继承,封装,多态。

Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)

python面向对象三大特性之继承多态

Python之面向对象继承详解以及面向对象三大特性

Python面向对象三大特性之封装

面向对象之:三大特性:继承(已讲),封装,多态