封装
封装有两方面的含义:
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("成绩必在100内")
s = Student()
s.get_score()
>>90
s = Student()
s.set_score(88)
print(s.get_score())
>>88
s.set_score(123)
>>ValueError: 成绩必在100内
继承
class Animal(object):
def eat(self):
print("吃饭")
def drink(self):
print("喝水")
class Dog(Animal):
def swim(self):
print("游泳")
dog = Dog()
dog.eat()
dog.drink()
dog.swim()
>>吃饭
喝水
游泳
class Bird(Animal):
def swim(self):
print("游泳")
bird = Bird()
bird.eat()
bird.drink()
bird.fly()
>>吃饭
喝水
飞
单继承:子类只有一个直接父类时称为单继承
假设子类和父类分别为ChildCLass和ParentCLass,子类继承父类的语法格式为:
class ChildCLass(ParentClass) :
pass
多继承:子类有多个直接父类时称为多继承
假设子类是ChildCLass,直接父类是Parentclass1, ParentClass2, … ParentClassn
子类继承父类的语法格式为:
class ChildClass (ParentClassl, ParentCLass2, … , ParentClassn):
pass
子类会继承所有父类(包括所有直接父类和所有间接父类)的所有属性和方法。
class ParentClassA(object):
ca=18
def im(self):
print("im()被调用了")
class ParentClassB(object):
__pca = 23
def __pim(self):
print("__pim()被调用了")
class ParentClassC (ParentClassA, ParentClassB) :
@classmethod
def cm(cls):
print("cm()被调用了")
class ParentClassD(object):
@staticmethod
def sm():
print("sm()被调用了")
class ChildClass(ParentClassC, ParentClassD):
pass
print(dir(ChildClass))
>>['_ParentClassB__pca', '_ParentClassB__pim', '__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', 'cm', 'im', 'sm']
子类可以添加父类中没有的属性和方法
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("cm()被调用了(父类)")
class ChildClass(ParentClass):
ca = "ca(子类)"
def __init__(self):
print("__init__()被调用了(子类)")
def im(self):
print("im()被调用了(子类)")
@classmethod
def cm(cls):
print("cm()被调用了(子类)")
cc = ChildClass()
print(ChildClass.ca)
print(cc.ca)
cc.im()
ChildClass.cm()
cc.cm()
>>__init__()被调用了(子类)
ca(子类)
ca(子类)
im()被调用了(子类)
cm()被调用了(子类)
cm()被调用了(子类)
父类中被重写的名为 *** 的方法,在子类重写后的方法中可以通过super().***()进行调用
class ParentClass(object):
ca = "ca(父类)"
def __init__(self):
print("__init__()被调用了(父类)")
def im(self):
print("im()被调用了(父类)")
@classmethod
def cm(cls):
print("cm()被调用了(父类)")
class ChildClass(ParentClass):
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()
print(ChildClass.ca)
print(cc.ca)
cc.im()
ChildClass.cm()
cc.cm()
>>__init__()被调用了(父类)
__init__()被调用了(子类)
ca(子类)
ca(子类)
im()被调用了(父类)
im()被调用了(子类)
cm()被调用了(父类)
cm()被调用了(子类)
cm()被调用了(父类)
cm()被调用了(子类)
MRO
全称是Method ResoLution Order (方法解析顺序) ,它指的是对于一颗类继承树, 当调用底层类对象所对应实例对象的方法时, Python解释器在类继承树上搜索方法的顺序。
对于一 棵类继承树,可以调用最底层类对象的方法mro()或访问最底层类对象的特殊属性mro ,获得这棵类继承树的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):
print("D.f")
d = D()
d.f()
>>D.f
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
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")
print(D.__mro__)
print(D.mro())
>>(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
class A(object):
def f(self):
print("A.f")
class B(A):
pass
class C(A):
pass
class D(B,C):
def f(self):
super().f()
d = D()
d.f()
>>A.f
在子类重写后的方法中通过super()调用父类中被重写的方法时,在父类中搜索方法的顺序于以该子类为最底层类对象的类继承树的MRO。
如果想调用指定父类中被重写的方法, 可以给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):
def f(self):
#super().f()
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 ParentClass1" )
class ChildClass2 (ParentClass):
def do_sth(self):
print("do_sth() in ParentClass2" )
def f(parent):
parent.do_sth()
f(ParentClass())
f(ChildClass1())
f(ChildClass2())
>>do_sth() in ParentClass
do_sth() in ParentClass1
do_sth() in ParentClass2
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
Python是动态语言,在调用函数时不会检查参数的类型
动态语言的多态崇尚"鸭子类型”:当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。
在鸭子类型中,我们并不关心对象是什么类型,到底是不是鸭子,只关心对象的行为。
在上面的程序中,我们并不关心变量parent所引用的对象是什么类型,到底是不是ParentClass或其子类类型,只关心变量parent所引用的对象是否有do_sth()这个方法。
鸭子类型:
如果一只生物走起路来像鸭子,游起泳来像鸭子,叫起来也像鸭子,那么它就可以被当作鸭子。 也就是说,它不关注对象的类型,而是关注对象具有的行为。