python12周学习笔记

封装，继承，多态

封装是面向对象编程的三大特征之一。

封装有两方面含义
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())
90
继承

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(“飞翔”)

dog = Dog()
dog.eat()
dog.drink()
dog.swim()
吃饭
喝水
游泳

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 ChilClass(ParentClassC, ParentClassD):
pass
重写 overwriting
如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重写从而提供自定义的实现，重写的方式为:在子类中定义与父类中同名的属性或方法(包括装饰器)。

子类重写父类的属性后，通过子类或其实例对象只能访问子类中重写后的属性，而无法再访问父类中被重写的属性。

子类重写父类的方法后，通过子类或其实例对象只能调用子类中重写后的方法，而无法再调用父类中被重写的方法。

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):
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

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

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

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())
[<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’>)

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()调用父类中被重写的方法时，在父类中搜索方法的顺序于以该子类为最底层类对象的类继承树的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 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()
super(C,self).f()

d = D()
d.f()
A.f

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(A,self).f()

d = D()
d.f()

AttributeError Traceback (most recent call last)
in ()
1 d = D()
----> 2 d.f()

in f(self)
13 class D(B,C):
14 def f(self):
—> 15 super(A,self).f()

AttributeError: ‘super’ object has no attribute ‘f’

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(D,self).f()

d = D()
d.f()
B.f

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
多态——在不考虑对象类型的情况下使用对象

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
###Python是动态语言，在调用函数时不会检查参数的类型

###动态语言的多态崇尚"鸭子类型”:当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。

############在鸭子类型中，我们并不关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

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

######鸭子类型:

###如果一只生物走起路来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么它就可以被当作鸭子。 也就是说，它不关注对象的类型，而是关注对象具有的行为。