On 12/13/2010 11:47 PM, Steven D'Aprano wrote:
Karim wrote:
Hello all,
I am seeking for information about the template pattern applied to
python.
Could you explain some implementation or anything else? it would be
helpful.
Design patterns are means to an end, not an end in themselves. You
shouldn't say "I want to use the template pattern", you should say "I
want to solve this problem, what solution is appropriate?" and then
only use the template pattern if it is appropriate.
Steven, thank you for answering ;o)
I don't want to use this pattern absolutely. But I discussed this topic
with a C++ programmer.
He wanted to translate part of C++ code in python that implements this
pattern in C++.
I already have implemented a Strategy pattern in python to read
different file format into
my database and generate different output format file like the code below:
class Input(object):
"""The basic Input class, leaving out the details of the algorithm."""
def __init__( self, strategy ):
self.strategy = strategy
self.lastRead = None
def read(self, filePath):
"""Load into database memory an input file.
@arg: filePath - string - The input file path.
@return: The created database object.
"""
self.lastRead = self.strategy.read()
return self.lastRead
class InputStrategy( object ):
"""This InputStrategy class is an abstract interface to various
read strategy objects.
"""
def read(self, filePath):
"""Abstract method to load into database memory an input file.
@arg: filePath - string - The input file path.
@return: The created database object.
"""
raise NotImplementedError
By the way, I use NotImplementedError in my abstract method of the
abstract class. You are using TypeError exception.
Is there a general rule for that? NotImplementedError is ok?
I knew from Java experience that template method pattern is only a kind
of particular case of Stategy where you delegate
parts of algorithm by abstract methods overriding. Indeed the base class
implements some common features and let
derived classes implement particular parts by polymorphism.
Now with your example, I don't understand why he had problems to
implement from C++ ?
Or perhaps is he mixing it with C++ feature template <class T> ?!
In any case, the template design pattern is one of the simpler design
patterns. Here's an example, adapted from Wikipedia's article on the
Template Method Pattern:
class AbstractGame:
"""An abstract class that is common to several games in which
players play against the others, but only one is playing at a
given time.
"""
def __init__(self, *args, **kwargs):
if self.__class__ is AbstractGame:
raise TypeError('abstract class cannot be instantiated')
def playOneGame(self, playersCount):
self.playersCount = playersCount
self.initializeGame()
j = 0
while not self.endOfGame():
self.makePlay(j)
j = (j + 1) % self.playersCount
self.printWinner()
def initializeGame(self):
raise TypeError('abstract method must be overridden')
def endOfGame(self):
raise TypeError('abstract method must be overridden')
def makePlay(self, player_num):
raise TypeError('abstract method must be overridden')
def printWinner(self):
raise TypeError('abstract method must be overridden')
Now to create concrete (non-abstract) games, you subclass AbstractGame
and override the abstract methods.
class Chess(AbstractGame):
def initializeGame(self):
# Put the pieces on the board.
...
def makePlay(player):
# Process a turn for the player
...
etc.
One more Thanks for you example Steven!
Regards
Karim
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
http://mail.python.org/mailman/listinfo/tutor
