面向对象：继承，多态，封装

#继承
#多继承，广度优先

class A(object):
def test(self):
print(‘from A’)

class B(A):
# def test(self):
# print(‘from B’)
pass

class C(A):
# def test(self):
# print(‘from C’)
pass

class D(B):
# def test(self):
# print(‘from D’)
pass

class E©:
# def test(self):
# print(‘from E’)
pass
class F(D,E):
# def test(self):
# print(‘from F’)
pass
f1 = F()
f1.test()
print(F.bases) #(<class ‘main.D’>, <class ‘main.E’>) 查看继承的所有父类
print(F.base) #<class ‘main.D’> 查看从左到右继承的第一个父类
print(F.mro) #from A
#(<class ‘main.F’>, <class ‘main.D’>, <class ‘main.B’>, <class ‘main.E’>,
#<class ‘main.C’>, <class ‘main.A’>, <class ‘object’>)
#只有新式类才有这个属性可以查看线性列表,python3中的函数类是新式类

#新式类继承顺序:F->D->B->E->C->A
#python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表

#为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
#而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
#1.子类会先于父类被检查
#2.多个父类会根据它们在列表中的顺序被检查
#3.如果对下一个类存在两个合法的选择,选择第一个父类
#====================================================================================

class A(object):
def init(self,name):
self.name = name
print(self.name)

def run(self):
    print('测试测试测试')
    print(self.name)

class B(A):
def init(self,age):
self.age = age
super().init(‘王Sir’) #调用父类中的__init__方法
# super(B,self).init(‘王Sir’) #还有另外一种调用方法,跟上面一样

def test(self):
    super().run()      #调用父类中的run方法 self都不用写了
    print('test')

ret = B(‘22’)
ret.run()

#输出结果：
#王Sir
#测试测试测试
#王Sir

#=================================================================================================
class Animal:
def init(self,name,eat,drink,push,shit): #__init__函数就是初始化方法，定义初始参数属性
self.name=name
self.eat= eat
self.drink= drink
self.push= push
self.shit= shit
class Dog(Animal):
def cry(self):
print(’%s汪汪汪’%self.name) #在子类中可以使用父类继承的name
class Cat(Animal):
def cry(self):
print(’%s喵喵喵’%self.name)

teddy=Dog(‘泰迪’,‘吃’,‘喝’,‘拉’,‘撒’)
cat1=Cat(‘加菲’,‘吃’,‘喝’,‘拉’,‘撒’)
print(cat1.name) #调用属性无需添加（）
teddy.cry() #调用方法需要添加（），因为方法本质是函数

#输出结果为：
#加菲
#泰迪汪汪汪

#=================================================================================================
class Animal:
def init(self,name,eat,drink,push,shit):
self.name=name
self.eat= eat
self.drink= drink
self.push= push
self.shit= shit
def run(self):
print(’%s running’%self.name)
class Dog(Animal):
def cry(self):
super(Dog,self).run() #super(Dog,self).run() =Animal().run(self)=super().run() 执行父类的方法
print(’%s汪汪汪’%self.name)
class Cat(Animal):
def cry(self):
super().init() #执行父类的属性 　　　　
print(’%s喵喵喵’%self.name)

teddy=Dog(‘泰迪’,‘吃’,‘喝’,‘拉’,‘撒’)
cat1=Cat(‘加菲猫’,‘吃’,‘喝’,‘拉’,‘撒’)
print(cat1.name)
teddy.cry()

#输出结果为：
#泰迪
#泰迪 running
#泰迪汪汪汪

#=============================================================================================
#==============================================================================================
#多态

class Animal:
def run(self):
raise AttributeError(‘子类必须实现这个方法’)
class People(Animal):
def run(self):
print(‘the people is running’)
class Pig(Animal):
def run(self):
print(‘pig is walking’)
class Dog(Animal):
def run(self):
print(‘dog is running’)
peo=People()
pig=Pig()
dog=Dog()
#第一种方式调用
#peo.run()
#pig.run()
#dog.run()
#第二种方式调用：定义统一的接口
def func(object):
object.run()
func(peo)
func(pig)
func(dog)

#多态性：一种调用方式，不同的执行效果
#多态性：可以定义统一的接口，调用的逻辑都一样，执行的结果却不一样
#多态性依赖于：继承

#多态性的实质：实质就是定义了一个函数接口，在这个函数中定义了所有类通用的函数功能，只要传入参数（即对象名），
#函数调用执行就能得到不同的结果。上述即一种调用方式，不同的执行结果

#=======================================================================================================
#=======================================================================================================
#私有化封装 private

class People():
def init(self,name,age):
self.name=name
self.__age=age
def say(self):
print(self.name,self.__age)
zs=People(‘张三’,18)
print(zs.name)
zs.say()

#返回值为：
#张三
#张三 18

class A:
STATIC = ‘aaa’ # 正常的静态变量
__S = ‘caoyf’ # 私有的变量
def func(self):
print(A.__S) #在类的里面正常调用类的变量，如果在类的里面调用python会自动给我们进行变形，其实A.__S = A._A__S
#print(A.__S) # 使用此种方法调用会报错，因为私有变量原则上来讲不能在外部调用
print(A.dict) #使用这种方法打印时可以看到A.__S已经转移成’_A__S’了
print(A._A__S) #如果非要在外部调用可以使用此种方法。
A.__Cao = ‘aaaaaaa’ # 外部不能创建一个私有的变量
print(A.__Cao)
c = A()
c.func()

#返回值为：
#{‘module’: ‘main’, ‘STATIC’: ‘aaa’, ‘_A__S’: ‘caoyf’, ‘func’: <function A.func at 0x000001B0546E68C8>,
#‘dict’: <attribute ‘dict’ of ‘A’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘A’ objects>, ‘doc’: None}
#caoyf
#aaaaaaa
#caoyf

#私有的 只能在类的内部定义和使用，格式为__名字 如 ‘__s’
#在类外部使用私有静态变量 _类名__私有的名字 如 ‘_A__S’

#私有的名字 不能被子类继承 具体实例如下：
class B:
def init(self,name,pwd):
self.name = name
self.__pwd = pwd # 创建对象的私有属性
def get_pwd(self): # 创建一个方法
print(self.__pwd) # 查看pwd这个私有属性
b = B(‘caoyf’,‘123.com’)
b.get_pwd()
print(b._B__pwd) # 当在类外部的时候,我们也不能直接使用对象的私有属性
class C:
def __ppt(self): #创建一个私有的方法
print(‘ppt’)
def open(self):
self.__ppt()
print(‘打开文件’)
c = C()
c._C__ppt() # 不能直接调用
c.open()

#返回值为：
#123.com
#123.com
#ppt
#ppt
#打开文件