面对对象--继承

一:什么是继承:

      在opp程序设计中, 当我们定义一个class的时候, 可以从某个现有的class继承, 新的class称为子类(Subclass),而被继承的class称为基类, 父类或者超类

      

 1 class Card: #定义了一个父类
 2     def __init__(self, rank, suit): #rank poker的序号  suit class Suit的对象
 3         self.rank = rank #poker 的序号
 4         self.suit = suit #Suit类有两个属性 'Club', '♣' 
 5         print(self.rank, self.suit.name, self.suit.symbol)
 6 class NumberCard(Card): #当序号是数字的时候调用这个类
 7     def __init__(self, rank, suit):
 8         super(NumberCard, self).__init__(str(rank), suit) #继承父类种的__init__构建函数
 9 
10 class AceCrad(Card): #当序号为A时候调用
11     def __init__(self, rank, suit):#这里还有一种不写init构建函数就会自动去父类,以及超类去找
12         super().__init__('A', suit)
13 class FaceCrad(Card): #当序号为JQK的时候调用
14     def __init__(self, rank, suit):
15         super().__init__({11:'J', 12:'Q', 13:'K'}[rank], suit)
16 
17 class Suit:
18     '''四种花色的构建'''
19     def __init__(self, name, symbol):
20         self.name = name
21         self.symbol = symbol
22 
23 
24 # 梅花, 方片, 红心, 黑桃  实例化一个花色的对象
25 Club, Diamond, Heart, Speade = Suit('Club', ''), Suit('Diamond', ''), Suit('Heart', ''), Suit('Spade', '')

    程序分析:这是一个poker类的创建, 代码来自python面对对象指南一书修改。 

        1:程序构建了卡牌的类, 一副扑克有52个牌,13种数字, 4种花色。 13种数字纯数字有2到10 ,其他AJQK

        2:那么就定义了3个类分别创建纯数字, A, JQK。 他们统一继承父类Card

        3:最后创建了一个类构建四种花色

  

1 def card10(rank, suit):#定义一个函数接收两个参数 牌号, 花色类对象(每种花色一个对象)
2     if rank == 1: return AceCrad(rank, suit)
3     elif 2<= rank < 11: return NumberCard(rank, suit)
4     elif 11<= rank < 14: return FaceCrad(rank, suit)
5     else:
6         raise Exception('Rank out of range')
7 deck10 = [card10(rank, suit)
   for rank in range(1,14)
     for suit in (Club, Diamond, Heart, Speade)] #列表推导式实现52张牌的实例化

二:子类和父类的关系

  2.1 继承: 父类, 超类, 基类

     子类: 也叫派生类

   父类中所有的属性和方法都可以被子类使用, 在子类中调用方法时,先在子类的对象空间找, 找不到就会父类,子类找到的,父类方法则不会运行。

   2.2 我们如何执行父类方法

     1:父类名 和 方法名

     2:super :super()自动传进去self, 加点执行父类中的方法

      

1 class A:
2     def __init__(self):
3         print('来了吗')
4     def func(self):
5         print('super加点执行父类的方法')
6 class B(A):
7     def __init__(self):
8         super().func()
9 b = B() #super加点执行父类的方法

      3:slef 

          当self去掉用那个方法时候, 不要看self在哪个类里, 要看self是传进来的那个类, 先去自己的类去找, 找不到再去父类

      4:继承与派生

         子类在父类的基础上又创建了自己的方法和属性

         父类有的子类没有, 子类对象就会直接调用父类的方法和属性,父类有子类也有始终调用自己的。

      5:抽象类:规范的编程模式

        可能会在工作中使用抽象类的规则,看一些源码的时候别人使用抽象类,它是一种规范, 基本上不会去实现功能, 不能被实例

       规范:多人开发, 复杂的需求, 后期的扩展, 这时候就需要一种编程规范, 抽象类可以帮助我们更好的管理。

三:新式类

  在python 3.x 版本中所有的类都是新式类,新式类都有一个默认的父类:object

  

 1 class Up:
 2     def fun(self):
 3         print('Up')
 4 class Down(Up):
 5     def fun(self):
 6         super().fun()
 7         print('Down!')
 8 class Left(Up):
 9     def fun(self):
10         super().fun()
11         print('Left!')
12 class Right(Down, Left):
13     def fun(self):
14         super().fun()
15         print('Right')
16 Right().fun() #Up-->Left->Down -->Right
17 print(Right.mro()) #[<class '__main__.Right'>, <class '__main__.Down'>, <class '__main__.Left'>,\
<class '__main__.Up'>, <class 'object'>]

 

   新式类中:

      1:所有的多继承关系寻找方法发的顺序  遵循广度优先算法

      2:继承object

      3:mro(对象寻找方法的顺序, 严格按照mro寻找)

      4:super:super不是单纯的找父类, 而是遵循mro顺序的 

  经典类:

      1:python 2.x 

      2:不主动继承object

      3:经典类在父类中的方法的过程中 遵循 深度优先搜索(一条路走到黑)

      4:不提供mro方法和super

 

 

 

     

posted @ 2018-08-28 14:40  雷文轩  阅读(196)  评论(0编辑  收藏  举报