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

隐式基类object

每个python类都隐式继承object

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

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

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

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

二、_init()__方法用例：

　　（一）基类实现初始化

 
 1 class Card:
    def __init__(self, rank, suit):
        self.rank = rank
        self.suit = suit
        self.hard, self.soft = self._points()


class NumberCard(Card):
    def _points(self):
        return int(self.rank), int(self.rank)


class AceCard(Card):
    def _points(self):
        return 1, 11


class FaceCard(Card):
    def _points(self):
        return 10, 10

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

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

class Card:
    def __init__(self, rank, suit, hard, soft):
        self.rank = rank
        self.suit = suit
        self.hard = hard
        self.soft = soft


class NumberCard(Card):
    def __init__(self, rank, suit):
        super().__init__(str(rank), suit, rank, rank)


class AceCard(Card):
    def __init__(self, rank, suit):
        super().__init__('A', suit, 1, 11)


class FaceCard(Card):
    def __init__(self, rank, suit):
        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

Club, Diamond, Heart, Spade = Suit('Club', 'C'), Suit('Diamond', 'D'),
                                  Suit('Heart', 'H'), Suit('Spade', 'S')

二、工厂函数

实现工厂函数的两种途径

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

途径一：

def card1(rank, suit):
    if rank == 1:
        return AceCard('A', suit)
    elif 2 <= rank <= 10:
        return NumberCard(str(rank), suit)
    elif rank == 11:
        return FaceCard('J', suit)
    elif rank == 12:
        return FaceCard('Q', suit)
    elif rank == 13:
        return FaceCard('K', suit)

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

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

　　（一）并行映射

def card2(rank, suit):
    # 在集合中查找rank, 未查到到返回NumberCard
    class_ = {1: AceCard, 11: FaceCard, 12: FaceCard, 13: FaceCard}.get(rank,
                                                                        NumberCard)
    rank_str = {1: 'A', 11: 'J', 12: 'Q', 13: 'K'}.get(rank, str(rank))
    return class_(rank_str, suit)

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

　　（二）二元组映射

# 二元组映射
def card3(rank, suit):
    class_, rank_str = {1: (AceCard, 'A'), 11: (FaceCard, 'J'), 12: (FaceCard, 'Q'),
                        13: (FaceCard, 'K')}.get(rank, (NumberCard, str(rank)))
    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，该对象顺序调用

class CardFactory:
    def rank(self, rank):
        self.class_, self.rank_str = {
                                1: (AceCard, 'A'),
                                11: (FaceCard, 'J'),
                                12: (FaceCard, 'Q'),
                                13: (FaceCard, 'K')
                                }.get(rank, (NumberCard, str(rank)))
        return self

    def suit(self, suit):
        return self.class_(self.rank_str, suit)