python开发面向对象基础：组合&继承

一，组合

组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合      人类装备了武器类就是组合

1.圆环，将圆类实例后传给圆环类

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 #circle，圆类
 from math import pi
 class Circle:
     def __init__(self,radius):
         self.radius = radius
     def perimeter(self):
         return 2 * pi * self.radius
     def area(self):
         return pi * self.radius **2

 # c1 = Circle(10)
 # print(c2.area())

 #圆环（不判断半径版本），就是圆的组合，利用了上面圆的类
 class Ring:
     def __init__(self,outside_radius,inside_radius):
         self.outside_circle = Circle(outside_radius)   #实例化一个圆形，作为self.outside_circle属性的值
         self.inside_circle = Circle(inside_radius)     #再实例化一个圆形
     def area(self):
         return self.outside_circle.area() - self.inside_circle.area()
     def perimeter(self):
         return self.inside_circle.perimeter() + self.outside_circle.perimeter()

 # r1 = Ring(20,10)     #这是傻瓜版本，没有考虑谁的半径大，谁是外圈内圈
 # print(r1.area())
 # print(r1.perimeter())

 #圆环（判断半径版本）
 class Ring:
     def __init__(self,outside_radius,inside_radius):
         outside_r = max(outside_radius,inside_radius)   #判断谁大谁是外环
         inside_r = min(outside_radius,inside_radius)    #
         self.outside_circle = Circle(outside_r)   #实例化一个圆形，作为self.outside_circle属性的值
         self.inside_circle = Circle(inside_r)     #再实例化一个圆形
     def area(self):
         return self.outside_circle.area() - self.inside_circle.area()
     def perimeter(self):
         return self.inside_circle.perimeter() + self.outside_circle.perimeter()

 # 将判断在实例化的时候判断
 # outer = input('外半径:')
 # inner = input('内半径:')
 # if outer.isdigit() and inner.isdigit() and int(outer) > int(inner):
 #     r1 = Ring(int(outer),int(inner))
 #     print(r1.perimeter())
 #     print(r1.area())

 # 将判断给类方法里面去判断
 # r1 = Ring(20,10)
 # print(r1.area())
 # print(r1.perimeter())

二，.多组合

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 # 老师 课程 生日
 # 第一种组合，在里面组合
 class Teacher:
     def __init__(self,name,salary,friend,course_name,course_period,course_price):
         self.name = name
         self.salary = salary
         self.bf = friend
         self.course = Course(course_name,course_period,course_price)   #这里实例化Course

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

 egg = Teacher('egon',200,'yuan','python','6months',20000)  #传入老师，课程的属性
 print(egg.bf)
 print(egg.course.name)     # egg.course就是Course的实例，相当于python

 # 第二种组合，在外面组合将课程先实例化后传入，适用于共性一样的
 class Teacher:
     def __init__(self, name, salary, friend, python):
         self.name = name
         self.salary = salary
         self.bf = friend
         self.course = python

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

 python = Course('python', '6months', 20000)
 #将python课程实例写这里，那么所有教Python的老师都可以这么写
 egg = Teacher('egon', 200, 'yuan', python)    #Python实例化后传入，就不需要每次传入很多参数，较少内存
 print(egg.bf)
 print(egg.course.name)

 # 第三种组合，在外面组合，适用于每个人都有的，但是又不一样的
 class Teacher:
     def __init__(self,name,salary,friend,python):
         self.name = name
         self.salary = salary
         self.bf = friend
         self.course = python

 class Birth:
     def __init__(self,year,month,day):
         self.year = year
         self.month = month
         self.day = day

 # egg = Teacher('egon', 200, 'yuan', 'python')
 # egg_birth = Birth(1965,2,2)
 # print(egg_birth.year)
 # 将整个生日类的东西给了交给了egg的birth，可以调用所有属性和方法
 # 如果写在老师类里面，那就太多了属性，代码就不易读
 # 重新定个新类，然后绑定给老师
 # egg.birth = egg_birth
 # print(egg.birth.year)

三，继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 # 子类会继承父类的所有属性和方法
 class Animal:      #父类  基类  超类
     def __init__(self,name,life_value,aggr):
         self.name = name
         self.life_value = life_value
         self.aggr = aggr

 class Person(Animal):  #子类  派生类
     pass

 class Dog(Animal): #子类  派生类
     pass

 egg = Person('egon',1000,50)
 print(egg.name)
 print(egg.aggr)

 # class Dad:pass
 # class Ma:pass
 # class Son1(Dad,Ma):pass    多继承
 # class Son2(Dad):pass

 # print(Son1.__bases__)    __bases__查看父类
 # print(Son2.__bases__)
 # print(Dad.__bases__)     --obj是所有类的鼻祖

3.1 继承与抽象

先抽象，在继承

抽象分成两个层次：

1.将奥巴马和梅西这俩对象比较像的部分抽取成类；

2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

3.2 经典类与新式类

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 #python2
 #class Dad:         #经典类  这个是不会集成obj的类
 #class Dag(object)  #新式类

 #python3
 #不存在经典类
 #class Dad  ==  class Dag(object) #新式类

四，派生

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 #继承
 class Pet:
     def eat(self):
         pass
     def sleep(self):
         pass
     def drink(self):
         pass

 class Cat(Pet):            #Pet类的一个派生类，也叫子类
     def catch(self):pass   #Pet类的一个派生方法

 class Dog(Pet):
     def watch_door(self):pass

 # 中华气死猫 = Cat()
 # 中华气死猫.catch()
 # 中华气死猫.eat()

 #1.人狗大战继承版本
 class Animal:      #父类  基类  超类
     def __init__(self,name,life_value,aggr):
         self.name = name
         self.life_value = life_value
         self.aggr = aggr  #攻击力
     def eat(self):
         self.life_value += 10

 class Person(Animal):  #子类  派生类
     def attack(self,enemy):    #人的派生方法
         enemy.life_value -= self.aggr

 class Dog(Animal): #子类  派生类
     def bite(self,person):   #狗的派生方法
         person.life_value -= self.aggr

 # egg = Person('gon',100,10)
 # dahei = Dog('dahei',200,20)
 # print(dahei.life_value)
 # dahei.eat()
 # print(dahei.life_value)
 # print(egg.life_value)
 # dahei.bite(egg)
 # print(egg.life_value)

 #2.如果属性多，增加对象属性，又要用父类的又要用自己的
 class Animal:      #父类  基类  超类
     def __init__(self,name,life_value,aggr):
         self.name = name
         self.life_value = life_value
         self.aggr = aggr  #攻击力
     def eat(self):
         self.life_value += 10

 class Person(Animal):  #子类  派生类
     def __init__(self,money):
         self.money = money   #派生属性
     def attack(self,enemy):    #人的派生方法
         enemy.life_value -= self.aggr

 class Dog(Animal): #子类  派生类
     def __init__(self,breed):
         self.breed = breed
     def bite(self,person):   #狗的派生方法
         person.life_value -= self.aggr

 # ha2 = Dog('牛头梗',20000,100)
 # 报错 _ __init__() takes 2 positional arguments but 4 were given
 # 在继承中，如果子类有的方法就执行子类的，如果没有执行父类的
 # 本例中子类有自己的Init方法，需要2个参数，加上self算一个，当然这个不需要传

 #3.有父类的对象属性，又有子类的属性，super方法来更改__init__
 class Animal:      #父类  基类  超类
     def __init__(self,name,life_value,aggr):
         self.name = name
         self.life_value = life_value
         self.aggr = aggr  #攻击力
     def eat(self):
         self.life_value += 10

 class Person(Animal):  #子类  派生类
     def __init__(self,money,name,life_value,aggr):
         super().__init__(name,life_value,aggr)
         self.money = money   #派生属性

     def attack(self,enemy):    #人的派生方法
         enemy.life_value -= self.aggr

 class Dog(Animal): #子类  派生类
     def __init__(self,breed,name,life_value,aggr):
         # Animal.__init__(self,name,life_value,aggr)        #让子类执行父类的方法，就是父类名.方法名(参数)，连self也得传(经典类的继承)
         super().__init__(name,life_value,aggr)          #super关键字——新式类，跟上面的经典类效果一样
         # super(Dog,self).__init__(name,life_value,aggr)  #super关键字关键字——新式类解释上面的写法跟经典类一样，只是简化了
         self.breed = breed
     def bite(self,person):   #狗的派生方法
         person.life_value -= self.aggr

 # dahei = Dog('狼','dahei',2000,100)
 # print(dahei.life_value)

 #4.有父类的对象属性，又有子类的属性，super方法
 class Animal:      #父类  基类  超类
     def __init__(self,name,life_value,aggr):
         self.name = name
         self.life_value = life_value
         self.aggr = aggr  #攻击力
     def eat(self):
         self.life_value += 10

 class Person(Animal):  #子类  派生类
     def __init__(self,money,name,life_value,aggr):
         super().__init__(name,life_value,aggr)   #
         self.money = money   #派生属性

     def attack(self,enemy):    #人的派生方法
         enemy.life_value -= self.aggr

 class Dog(Animal): #子类  派生类
     def __init__(self,breed,name,life_value,aggr):
         #Animal.__init__(self,name,life_value,aggr)   #让子类执行父类的方法，就是父类名.方法名(参数)，连self也得传
         super().__init__(name,life_value,aggr)  #super关键字——新式类
         #super(Dog,self).__init__(name,life_value,aggr)  #super关键字关键字——新式类
         self.breed = breed
     def bite(self,person):   #狗的派生方法
         person.life_value -= self.aggr

     def eat(self):       # 父类方法的重写
         super().eat()     #子类执行父类的eat方法，如果没有的话，就会执行下面代码，也可以在外面引用
         print('dog is eating~~~ ')

 dahei = Dog('狼', 'dahei', 2000, 100)
 print(dahei.life_value)
 dahei.eat()
 super(Dog,dahei).eat()   #父类方法的重写，在外面引用父类的方法，dahei就是self
 print(dahei.life_value)

 # 父类方法的重写不推荐用，因为这样还不如直接改了父类