Python面向对象编程（3）

于 2019-05-17 22:57:36 发布
阅读量184 收藏
点赞数
文章标签： Python 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44440552/article/details/90301826
版权

从以下几方面介绍：封装，继承，重写，MRO，多态

封装

封装有两方面含义：
1、将数据（属性）和行为（方法）包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法
2、在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）以访问隐藏的信息。


class Student(object):
    def __init__(self):
        self.__score = 90
        
    def get_score(self):
        return self.__score
    
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError("成绩必须在0~100之间")
        
>>>s = Student()
>>>s.get_score()
90

>>>s = Student()
>>>s.set_score(88)
>>>print(s.get_score())   
88

>>>s.set_score(160)
ValueError: 成绩必须在0~100之间

继承

  • 当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到一个基类中，每个类对象特有的属性和方法还是在本类对象中定义，这样就可以访问基类中的属性和方法了。
  • 继承基类的每个类对象被称为派生类。基类也被称为父类或超类，派生类也被称为子类。
  • Python中所有类对象都继承自一个统一的基类：object。这就是为什么我们在定义类对象时要在类名后面加(object)。
#1
class Dog(object):
	def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")
	def swim(self):
        print("游泳")

#2
class Bird(Animal):
	def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")
    def fly(self):
        print("飞翔")
      
#把 1、2合并
class Animal(object):
    def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")
        
#继承        
class Dog(Animal):
    def swim(self):
        print("游泳")
        
class Bird(Animal):
    def fly(self):
        print("飞翔")

单继承：子类只有一个直接父类时称为单继承

class ChildClass(ParentClass):
	pass

多继承：子类有多个直接父类时称为多继承

class ChildClass(ParentClass1,ParentClass2,...):
	pass

子类汇集成所有父类（包括所有直接父类和所有间接父类）的所有属性和方法

#子类可以添加父类中没有的属性和方法

class BaseClass(object):
    ca_base = 5

    def im_base(self):
        print("im_base()被调用了")

class SubClass(BaseClass):
	ca_sub = 8

	def im_sub(self):
		print("im_sub()被调用了")

print(dir(SubClass))
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', 
'__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
 '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'ca_base', 'ca_sub', 'im_base', 'im_sub']

重写

方式：在子类中定义与父类中同名的属性或方法（包括装饰器）

class ParentClass(object):
    ca = "ca(父类)"
    
    def __init__(self):
        print("__init__()被调用了（父类）")
        
    def im(self):
        print("im()被调用了（父类）")
        
    @classmethod
    def cm(cls):
        print(print("cm()被调用了（父类）"))

        
class ChildClass(object):
    ca = "ca(子类)"
    
    def __init__(self):
        print("__init__()被调用了（子类）")    
    
    def im(self):
        print("im()被调用了（子类）")
     
    @classmethod
    def cm(cls):
        print("cm()被调用了（子类）")

>>>cc = ChildClass()
__init__()被调用了（子类）

>>>print(ChildClass.ca)
ca(子类)

>>>print(cc.ca)
ca(子类)

>>>cc.im()
im()被调用了（子类）

>>>ChildClass.cm()
cm()被调用了（子类）

>>>cc.cm()
cm()被调用了（子类）

父类中被重写的名为xxx的方法，在子类重写后的方法可以通过super().xxx()进行调用。

class ParentClass(object):
    ca = "ca(父类)"
    
    def __init__(self):
        print("__init__()被调用了（父类）")
        
    def im(self):
        print("im()被调用了（父类）")
        
    @classmethod
    def cm(cls):
        print(print("cm()被调用了（父类）"))

        
class ChildClass(object):
    ca = "ca(子类)"
    
    def __init__(self):
    	super().__init__()
        print("__init__()被调用了（子类）")    
    
    def im(self):
    	super().im()
        print("im()被调用了（子类）")
     
    @classmethod
    def cm(cls):
   		super().cm()
        print("cm()被调用了（子类）")

>>>cc = ChildClass()
__init__()被调用了（父类）
__init__()被调用了（子类）

>>>print(ChildClass.ca)
ca(子类)

>>>print(cc.ca)
ca(子类)

>>>cc.im()
im()被调用了（父类）
im()被调用了（子类）

>>>ChildClass.cm()
cm()被调用了（父类）
cm()被调用了（子类）

>>>cc.cm()
cm()被调用了（父类）
cm()被调用了（子类）

MRO

MRO的全称是Method Resolution Order（方法解析顺序）,它指的是对于一颗类继承树，当调用最底层类对象所对应实例对象的方法时，Python解释器在类继承树上搜索方法的顺序。

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    def f(self):
        print("B.f")
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B,C):
    def f(self):
        print("D.f")
        
>>>d = D()
>>>d.f()
D.f 


1) 
class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    def f(self):
        print("B.f")
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B,C):  
	pass
	
>>>d = D()
>>>d.f()
B.f 

2)
class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    pass
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B,C):  
	pass
	
>>>d = D()
>>>d.f()
C.f 


3)
class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    pass
        
class C(A):
    pass
        
class D(B,C):  
	pass
	
>>>d = D()
>>>d.f()
A.f

对于一颗类继承树，可以调用最底层类对象的方法mro()或访问最底层类对象的特殊属性__mro__获得这棵树的MRO。

>>>print(D.mro())
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]


>>>print(D.__mro__)
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

在子类重写后的方法中通过super()调用父类被重写的方法时，在父类中搜索方法的吮吸基于以盖子类为最底层类对象的类继承树的MRO。

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    def f(self):
        print("B.f")
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B,C):
    def f(self):
        super().f()
        
>>>d = D()
>>>d.f()
B.f

如果想调用指定父类中被重写的方法，可以给super()传入两个实参：super(a_type, obj),其中，第一个实参a_type是个类对象，第二个实参obj是个实例对象，这样被指定的父类是：obj所对应类对象的MRO中，a_type 后面 的那个类对象。

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    def f(self):
        print("B.f")
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B,C):
    super(B,self).f()
        
>>>d = D()
>>>d.f()
C.f

多态

指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法。

class ParentClass(object):
    def do_sth(self):
        print("do_sth() in ParentClass")
        
class ChildClass1(ParentClass):
    def do_sth(self):
        print("do_sth() in ChildClass1")
        
class ChildClass2(ParentClass):
    def do_sth(self):
        print("do_sth() in ChildClass2")
        
def f(parent):
    parent.do_sth()
    
>>>f(ParentClass())
do_sth() in ParentClass

>>>f(ChildClass1())
do_sth() in ChildClass1

>>>f(ChildClass2())    
do_sth() in ChildClass2


class SomeClass(object):
    def do_sth(self):
        print("do_sth() in SomeClass")
        
>>>f(SomeClass())
do_sth() in SomeClass


#如果子类中不存在指定名称的方法，回到父类中去查找，如果在父类中找到了，则调用父类中的方法。
class ChildClass3(ParentClass):
    pass

>>>f(ChildClass3())
do_sth() in ParentClass

在上面的程序中，我们并不关心变量Parent所引用的对象是什么类型，到底是不是ParentClass或其子类型，只关心变量parent所引用的对象是否有do_sth()这个方法。

yaoqinghao
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值