Home     |     .Net Programming    |     cSharp Home    |     Sql Server Home    |     Javascript / Client Side Development     |     Ajax Programming

Ruby on Rails Development     |     Perl Programming     |     C Programming Language     |     C++ Programming     |     IT Jobs

Python Programming Language     |     Laptop Suggestions?    |     TCL Scripting     |     Fortran Programming     |     Scheme Programming Language


 
 
Cervo Technologies
The Right Source to Outsource

MS Dynamics CRM 3.0

Python Programming Language

Good idea to use a class as function with __new__?


Hi,

I am implementing som code generation and want to to use some variant
of the template method pattern.

What I came up with is to have a class with the common part
in a method and the subclasses can then override the Customize methods
to do their own special part.

Now to the question I use the __new__ to return the result instead
of the instance. So that the class is used as an function.

So insted of having.

a = Template()
result = a.__TemplateMethod(preifix="foo")

I can write:

result = Template(prefix="foo")

class Template(object):

   def __init__(cls, *args, **kwds):
      pass

   def __new__(cls, *args, **kwds):
      obj = super(Template, cls).__new__(cls, *args, **kwds)
      return obj.__TemplateMethod(*args, **kwds)

   def Customize1(self, prefix="hello", *args, **kwds):
      return prefix+"1\n"

   def Customize2(self, prefix="hello", *args, **kwds):
      return prefix+"2\n"

   def __TemplateMethod(self, *args, **kwds):
      result = ""
      result += self.Customize1(*args, **kwds)
      result += self.Customize1(*args, **kwds)
      return result

b = Template("foo")

print b

En Mon, 28 May 2007 09:17:30 -0300, glomde <tbr@yahoo.com> escribi:

> I am implementing som code generation and want to to use some variant
> of the template method pattern.

> What I came up with is to have a class with the common part
> in a method and the subclasses can then override the Customize methods
> to do their own special part.

> Now to the question I use the __new__ to return the result instead
> of the instance. So that the class is used as an function.

It works, and I don't see any big problems, but I don't *like* that.
I'd use __call__ instead; that is, write __new__ and __init__ normally -if  
you need them at all- and move the magic to __call__:

     def __call__(self, *args, **kwds):
        return self.__TemplateMethod(*args, **kwds)

x = Template()(prefix="foo")
or perhaps:
x = Template(prefix="foo")()

I think the extra () improves readability - it's clear that x comes from a  
function call, it's not a Template instance as one would expect from your  
original code.
And depending on the application, you could keep the instances and call  
them with different arguments - with the original code you always create a  
new instance just to discard it immediately.

--
Gabriel Genellina

Thanks for the reply. I was considering __call__ but in my case it is
really something
that will be discarded immediately. And right now it is is implemented
as function
where I have arguments to send in which customize functions something
like:

def Template(self, func1=Customize1, func2= Customize2, *args,
**kwds):
    func1(*args, **kwds)
    func2(*args, **kwds)

So I just wanted to organize it a little bit nicer and be able to
subclass instead of
sending in function pointers. But that had the same interface.

But you are right the extra () does make it clearer, so I probably go
for that.

Cheers,

/T

Add to del.icio.us | Digg this | Stumble it | Powered by Megasolutions Inc