python创建型设计模式学习——工厂方法模式

应用情形

如果子类的某个方法要根据情况，来决定用什么类去实例化相关对象,可以考虑工厂方法模式。此模式可以单独使用，也可以再无法预知对象类型的时候使用，例如待初始化的对象类型要从文件中读入或者由用户输入。

参照书上例子，根据用户的调用，创建国际跳棋或者国际象棋的棋盘。

引入相关模块

import io
import itertools
import os
import sys
import tempfile
import unicodedata

定义棋盘常量

#跳棋、棋盘背景类型
BLACK, WHITE = ("BLANK", "WHITE")
#国际象棋，棋子类型
DRAUGHT, PAWN, ROOK, KNIGHT, BISHOP, KING, QUEEN = ("DRAUGHT", "PAWN",
        "ROOK", "KNIGHT", "BISHOP", "KING", "QUEEN")

最顶层调用代码

if __name__ == "__main__":
    main()

def main():
    checkers = CheckersBoard()
    print(checkers)
    chess = ChessBoard()
    print(chess)

根据平台定义控制台输出

if sys.platform.startswith("win"):
    def console(char, background):
        return char or " "
    sys.stdout = io.StringIO()
else:
    def console(char, background):
        return "\x1B[{}m{}\x1B[0m".format(
                43 if background == BLACK else 47, char or " ")

补充知识点

python 继承的实现：
一种是如上篇文章说的使用
class absClass(mateclass=abc.ABCMeta)
一种是在文档中直接说明
书上这个例子用到的方法：
凡是需要有子类重新实现的方法都抛出NotImplementedError异常。

抽象棋盘父类的实现：

class AbstractBoard:    
    def __init__(self,rows,columns):
        #创建一个rows行columns列的二维列表，并将元素初始化None
        #[[列1，列2，列3，.....],
        #[列1，列2，列3，.....],
        #[列1，列2，列3，.....],
        #       .....
        #]
        self.board = [[None for _ in range(columns)] for _ in range(rows)]
        #通过工厂方法populate_board()来实例化棋子
        self.populate_board()

    #定义工厂方法，由子类来实现，创建棋盘对象
    def populate_board(self):
        raise NotImplementedError()

    #打印棋盘，将由子类调用
    def __str__(self):
    squares = []
    for y,row in enumerate(self.board):
        for x, piece in enumerate(row):
            square = console(piece, BLANK if(y + x) % 2 else WHILE)
        squares.append("\n")
    return "".join(squares)

知识点补充 itertools 模块小结
http://www.wklken.me/posts/2013/08/20/python-extra-itertools.html
itertools.islice(iterable,start,stop,step):对迭代器做类似于切片操作
itertools.cycle(iterable)：无限迭代操作之一，将传入的迭代对象无限迭代
itertools.chain(iterable1,iterable2)：将两个可迭代对象连接合并

国际跳棋棋盘子类实现

class CheckersBoard(AbstractBoard):
    def __init__(self):
        self.populate_board()

    def populate_board(self):

        def black():
            return create_piece(DRAUGHT,BLANK)
        def white():
            return create_piece(DRAUGHT,WHITE)
        rows = (
            # 4 black rows
            (None, black()), (black(), None),
            (None, black()),(black(), None),
            # 2 blank rows
            (None, None), (None, None), 
            # 4 white rows
            (None, white()), (white(), None),
            (None, white()), (white(), None)
        )        
        #根据模板初始化棋盘列表  
        self.board = [list(itertools.islice(
            itertools.cycle(squares), 0, len(rows))) for squares in rows]

国际象棋棋盘类实现

class ChessBoard(AbstractBoard):

    def __init__(self):
        super.__init()__(8,8)

    #按照模板创建国际象棋棋盘
    def populate_board(self):
        for row, column in ((0, BLANK),(7, WHITE)):
            for columns ,kind in (((0, 7), ROOK), ((1, 6), KNIGHT), ((2, 5), BISHOP), ((3,), QUEEN), ((4,), KING)):
            for column in columns:
                    self.board[row][column] = create_piece(kind, color)
        for column in range(8):
            for row, color in ((1, BLACK), (6, WHITE)):
                self.board[row][column] = create_piece(PAWN, color)

棋子创建函数

def create_piece(kind, color):
    color = "White" if color == WHITE else "Black"
    name = {DRAUGHT: "Draught", PAWN: "ChessPawn", ROOK: "ChessRook",
            KNIGHT: "ChessKnight", BISHOP: "ChessBishop",
            KING: "ChessKing", QUEEN: "ChessQueen"}[kind]
    #这里使用动态创建实例的优雅（装逼）方式
    return globals()[color + name]()

知识点补充用内置函数type来创建类
Class = type(类型名称，含有基类名称的数组，含有类属性的字典)
globals()[类型名称] = Class
__slots__的用法，如果定义了slots，那么创建的实例中就不出现私有的dict,__slots__ = () 保证了实例中不会有任何数据
http://blog.csdn.net/tianqio/article/details/2374086

棋子父类

class Piece(str):
    __slots__ = ()

动态创建各种棋子类

for code in itertools.chain((0x26C0,0x26c2),range(0x2654, 0x2660)):
    char = chr(code)
    name = unicodedata.name(char).title().replace(" ", "")
    if name.endswith("sMan"):
        name = name[:-4]
    # 先写lambda表达式，然后用char填充外围lambda，创建new（）函数（相当于是创建并调用外围lambda，创建了new()函数
    new = (lambda char:lambda Class: Piece.__new__(Class, char))(char)
    # 所有的lambda函数都叫lambda，于是起个名字
    new.__name__ = "__new__"
    #创建类
    Class = type(name, (Piece,), dict(__slots=()), __new__=new)
    globals()[name] = Class

python创建型设计模式学习——工厂方法模式

应用情形

猜你喜欢