组合、菱形继承问题、派生的两种方式、多态与多态性

有些东西错过就错过了，否则你又能如何？？？

1、组合

什么是组合

组合就是一个类的对象具备某一个属性，该属性的值是指向另外一个类的对象

为何用组合

组合也是用来解决类与类之间代码冗余问题的

如何用组合

class OldboyPeople:
 school = 'oldboy'

 def __init__(self, name, age, sex):
  self.name = name
  self.age = age
  self.sex = sex

class OldboyStudent(OldboyPeople):
 def __init__(self,name,age,sex,stu_id):
  OldboyPeople.__init__(self,name,age,sex)
  self.stu_id=stu_id

 def choose_course(self):
  print('%s is choosing course' %self.name)

class OldboyTeacher(OldboyPeople):

 def __init__(self, name, age, sex, level):
  OldboyPeople.__init__(self,name,age,sex)
  self.level=level

 def score(self,stu,num):
  stu.score=num
  print('老师[%s]为学生[%s]打分[%s]' %(self.name,stu.name,num))


stu1=OldboyStudent('猪哥',19,'male',1)
tea1=OldboyTeacher('egon',18,'male',10)

stu1.choose_course()
tea1.score(stu1,100)
print(stu1.__dict__)

class Course:
 def __init__(self,name,period,price):
  self.name=name
  self.period=period
  self.price=price

 def tell_info(self):
  msg="""
  课程名：%s
  课程周期：%s
  课程价钱：%s
  """ %(self.name,self.period,self.price)
  print(msg)

class OldboyPeople:
 school = 'oldboy'

 def __init__(self, name, age, sex):
  self.name = name
  self.age = age
  self.sex = sex

class OldboyStudent(OldboyPeople):
 def __init__(self,name,age,sex,stu_id):
  OldboyPeople.__init__(self,name,age,sex)
  self.stu_id=stu_id

 def choose_course(self):
  print('%s is choosing course' %self.name)

class OldboyTeacher(OldboyPeople):

 def __init__(self, name, age, sex, level):
  OldboyPeople.__init__(self,name,age,sex)
  self.level=level

 def score(self,stu,num):
  stu.score=num
  print('老师[%s]为学生[%s]打分[%s]' %(self.name,stu.name,num))

# 创造课程
python=Course('python全栈开发','5mons',3000)
linux=Course('linux运维','5mons',800)
# python.tell_info()
# linux.tell_info()


# 创造学生与老师
stu1=OldboyStudent('猪哥',19,'male',1)
tea1=OldboyTeacher('egon',18,'male',10)


# 将学生、老师与课程对象关联/组合
stu1.course=python
tea1.course=linux

stu1.course.tell_info()
tea1.course.tell_info()

2、菱形继承问题

菱形继承

当一个子继承多个父类时，多个父类最终继承了同一个类，称之为菱形继承

菱形继承的问题

python2区分经典类与新式类，如果子的继承是一个菱形继承，那么经典类与形式的区别为？

经典类下查找属性：深度优先查找

新式类下查找属性：广度优先查找

class G(object):
 # def test(self):
 #  print('from G')
 pass

class E(G):
 # def test(self):
 #  print('from E')
 pass

class B(E):
 # def test(self):
 #  print('from B')
 pass

class F(G):
 # def test(self):
 #  print('from F')
 pass

class C(F):
 # def test(self):
 #  print('from C')
 pass

class D(G):
 # def test(self):
 #  print('from D')
 pass

class A(B,C,D):
 def test(self):
  print('from A')
 # pass

obj=A()
print(A.mro())
# obj.test() #A->B->E-C-F-D->G-object

3、派生的两种方式

在派生的新方法中重用父类功能的两种方式

方式一：与继承无关

指名道姓法，直接用：类名，函数名

class OldboyPeople:
 school = 'oldboy'

 def __init__(self, name, age, sex):
  self.name = name
  self.age = age
  self.sex = sex

class OldboyStudent(OldboyPeople):
 def __init__(self,name,age,sex,stu_id):
  OldboyPeople.__init__(self,name,age,sex)
  self.stu_id=stu_id

 def choose_course(self):
  print('%s is choosing course' %self.name)

方式二：严格以来继承属性查找关系

super()会得到一个特殊的对象，该对象就是专门用来访问父类中的属性的(按照继承的关系）

super().__init__（不用为self传值）

注意：super的完整用法是super(自己的类名，self)，在python2中需要写完整，而python3中可以简写为super（）

class OldboyPeople:
 school = 'oldboy'

 def __init__(self, name, age, sex):
  self.name = name
  self.age = age
  self.sex = sex

class OldboyStudent(OldboyPeople):
 def __init__(self,name,age,sex,stu_id):
  # OldboyPeople.__init__(self,name,age,sex)
  super().__init__(name,age,sex)
  self.stu_id=stu_id

 def choose_course(self):
  print('%s is choosing course' %self.name)


stu1=OldboyStudent('猪哥',19,'male',1)
print(stu1.__dict__)

print(OldboyStudent.mro())


class A:
 def f1(self):
  print('A.f1')

class B:
 def f2(self):
  super().f1()
  print('B.f2')

class C(B,A):
 pass

obj=C()
print(C.mro()) #C-》B->A->object
obj.f2()

4、多态与多态性

什么是多态，

多态指的是同一种事物的多种形态

水-冰、水蒸气、液态水

动物-人、狗、猪

为何要用多态

多态性：继承同一个类的子类中有相同的方法名

那么子类产生的对象就可以不用考虑具体的类型而直接调用功能

如何用：

import abc

class Animal(metaclass=abc.ABCMeta):
 @abc.abstractmethod
 def speak(self):
  pass
 @abc.abstractmethod
 def eat(self):
  pass

# Animal() #强调：父类是用来指定标准的，不能被实例化

class People(Animal):
 def speak(self):
  print('say hello')

 def eat(self):
  pass

class Dog(Animal):
 def speak(self):
  print('汪汪汪')

 def eat(self):
  pass
class Pig(Animal):
 def speak(self):
  print('哼哼哼')

 def eat(self):
  pass



peo1=People()
dog1=Dog()
pig1=Pig()


peo1.speak()
dog1.speak()
pig1.speak()

def my_speak(animal):
 animal.speak()

my_speak(peo1)
my_speak(dog1)
my_speak(pig1)


l=[1,2,3]
s='helllo'
t=(1,2,3)

print(l.__len__())
print(s.__len__())
print(t.__len__())

# def len(obj):
#  return obj.__len__()

print(len(l)) # l.__len__()
print(len(s)) #s.__len__()

print(len(t))

python

python推崇的是鸭子类型，只要你叫的声音像鸭子，并且你走路的样子也像鸭子，那你就是鸭子

class Disk:
 def read(self):
  print('disk read')

 def write(self):
  print('disk wirte')


class Process:
 def read(self):
  print('process read')

 def write(self):
  print('process wirte')
class File:
 def read(self):
  print('file read')

 def write(self):
  print('file wirte')

obj1=Disk()
obj2=Process()
obj3=File()

obj1.read()
obj1.write(）