Python面向对象编程——__init()_

隐式基类object

每个python类都隐式继承object

全文代码实例实现：枚举扑克牌的花色和牌面值

一、_init()__方法：对象初始化

　　显示而非隐式：__init()__应显示展示初始化变量

　　对象被实例化时，先创建一个空对象，然后再调用__init()__对对象内部变量或其他内容进行初始化

二、_init()__方法用例：

　　（一）基类实现初始化

 
 1 class Card:

 2     def __init__(self, rank, suit):

 3         self.rank = rank

 4         self.suit = suit

 5         self.hard, self.soft = self._points()

 6

 7

 8 class NumberCard(Card):

 9     def _points(self):

10         return int(self.rank), int(self.rank)

11

12

13 class AceCard(Card):

14     def _points(self):

15         return 1, 11

16

17

18 class FaceCard(Card):

19     def _points(self):

20         return 10, 10

三个子类共享公共初始化逻辑
多态：三个子类对_points(self)都有不同的功能实现

　　改进：子类实现__init()__方法

 1 class Card:

 2     def __init__(self, rank, suit, hard, soft):

 3         self.rank = rank

 4         self.suit = suit

 5         self.hard = hard

 6         self.soft = soft

 7

 8

 9 class NumberCard(Card):

10     def __init__(self, rank, suit):

11         super().__init__(str(rank), suit, rank, rank)

12

13

14 class AceCard(Card):

15     def __init__(self, rank, suit):

16         super().__init__('A', suit, 1, 11)

17

18

19 class FaceCard(Card):

20     def __init__(self, rank, suit):

21         super().__init__({1: 'A', 11: 'J', 12: 'Q', 13: 'K'}[rank], suit, 10, 10)

super():用于子类要调用父类的同名方法时

单继承：

　　直接在同名函数中调用super().fun_name()

多继承：

　　直接在同名函数中调用super(要调用某父类的前一个类名, self).fun_name()

　　（二）创建常量清单

# 牌的字符与名称

class Suit:

    def __init__(self, name, symbol):

        self.name = name

        self.symbol = symbol

1 Club, Diamond, Heart, Spade = Suit('Club', 'C'), Suit('Diamond', 'D'),\

2                                   Suit('Heart', 'H'), Suit('Spade', 'S')

调用

二、工厂函数

实现工厂函数的两种途径

定义一个函数，返回不同类的对象
定义一个类，包含创建对象的方法

途径一：

 1 def card1(rank, suit):

 2     if rank == 1:

 3         return AceCard('A', suit)

 4     elif 2 <= rank <= 10:

 5         return NumberCard(str(rank), suit)

 6     elif rank == 11:

 7         return FaceCard('J', suit)

 8     elif rank == 12:

 9         return FaceCard('Q', suit)

10     elif rank == 13:

11         return FaceCard('K', suit)

上述函数实现了牌面值与花色的对应

三、使用映射和类来简化设计

　　（一）并行映射

1 def card2(rank, suit):

2     # 在集合中查找rank, 未查到到返回NumberCard

3     class_ = {1: AceCard, 11: FaceCard, 12: FaceCard, 13: FaceCard}.get(rank,

4                                                                         NumberCard)

5     rank_str = {1: 'A', 11: 'J', 12: 'Q', 13: 'K'}.get(rank, str(rank))

6     return class_(rank_str, suit)

　　缺点：映射键1、11、12、13逻辑重复，使用两次映射来获取牌面值和花色。重复的代码是多余的，提高了维护成本

　　（二）二元组映射

1 # 二元组映射

2 def card3(rank, suit):

3     class_, rank_str = {1: (AceCard, 'A'), 11: (FaceCard, 'J'), 12: (FaceCard, 'Q'),

4                         13: (FaceCard, 'K')}.get(rank, (NumberCard, str(rank)))

5     return class_(rank_str, suit)

　　（三）partial函数：偏函数

使用方法：调用函数fun_name(arg1,arg*.....)

　　fun_name1=partial(fun_name, arg1…)

　　fun_name1(arg*…) 偏函数

from functools import partial

def card4(rank, suit):

    part_class = {1: partial(AceCard, 'A'), 11: partial(FaceCard, 'J'),

                  12: partial(FaceCard, 'Q'), 13: partial(FaceCard, 'K')}\

                    .get(rank, partial(NumberCard, str(rank)))

    return part_class(suit)

　　（四）工厂流畅API

　　结合二元组映射实现API，该对象顺序调用

 1 class CardFactory:

 2     def rank(self, rank):

 3         self.class_, self.rank_str = {

 4                                 1: (AceCard, 'A'),

 5                                 11: (FaceCard, 'J'),

 6                                 12: (FaceCard, 'Q'),

 7                                 13: (FaceCard, 'K')

 8                                 }.get(rank, (NumberCard, str(rank)))

 9         return self

10

11     def suit(self, suit):

12         return self.class_(self.rank_str, suit)

巴特西

Python面向对象编程——init()方法

最新文章

热门文章

巴特西

Python面向对象编程——__init()__方法

最新文章

热门文章

Python面向对象编程——init()方法