return same type of object

[David Isaac]

Instances of MyClass have a method that
returns another instance. Ignoring the details
of why I might wish to do this, I could
return MyClass()
or
return self.__class__()

I like that latter better. Should I?
Should I do something else altogether?

Thanks,
Alan Isaac

 

[Bruno Desthuilliers]

Instances of MyClass have a method that
returns another instance.

This is usually known as a 'factory method'.

Ignoring the details
of why I might wish to do this, I could
return MyClass()
or
return self.__class__()

I like that latter better. Should I?

You do realise that both solutions are *not* strictky equilavent, do you?

class PsychoRigid(object):
def create(self):
return PsychoRigid()

class PsychoRigidChild(PsychoRigid):
pass

pr1 = PsychoRigidChild()
pr2 = pr1.create()
print "pr2 is a ", type(pr2)

class Virtual(object):
def create(self):
return self.__class__()

class VirtualChild(Virtual):
pass

vc1 = VirtualChild()
vc2 = vc1.create()
print "vc2 is a ", type(vc2)


My 2 cents...

 

[Steve Holden]

Instances of MyClass have a method that
returns another instance. Ignoring the details
of why I might wish to do this, I could
return MyClass()
or
return self.__class__()

I like that latter better. Should I?
Should I do something else altogether?

The latter solution is more Pythonic, IMHO, as it works for subclasses.

regards
Steve

 

[David Isaac]

This is usually known as a 'factory method'. You do realise that both

solutions are *not* strictky equilavent, do you?

Your point I believe is that after inheritance the factory method
in the subclass will still
return MyClass()
but will return an instance of the subclass if I
return self.__class__()

Right.

You did not comment further so I take it your view is that
each is fine, pick the one that gives the behavior you want.
But Steve suggests going with the latter.
Here is an (very crude) argument for going with the latter:
if you know you want an instance of MyClass(),
you can do that directly, but if you do this via a factory method,
then (after inheritance) the action of the factory method becomes obscured.

Does that make any sense?

Thanks,
Alan Isaac
of the factory

 

[Bruno Desthuilliers]

David Isaac a écrit :

solutions are *not* strictky equilavent, do you?

Your point I believe is that after inheritance the factory method
in the subclass will still
return MyClass()
but will return an instance of the subclass if I
return self.__class__()

Right.
Right.

You did not comment further so I take it your view is that
each is fine, pick the one that gives the behavior you want.

I did not comment because I don't know which behaviour is appropriate in
*your* case.

But Steve suggests going with the latter.

That's what I'd do too a priori.

Here is an (very crude) argument for going with the latter:
if you know you want an instance of MyClass(),
you can do that directly,

Sure, but that's another point. If you want an instance of a subclass of
MyClass, you can also do that directly !-)

MVHO is that in most cases, one would expect such a factory method to
play nicely with subclassing. But as I said, this is not a hard rule.

 

[Steve Holden]

David Isaac a écrit : [...]

But Steve suggests going with the latter.

That's what I'd do too a priori.

Believe it or not, I wasn't at the priory when I wrote that.

Sorry.

regards
Steve

 

[Bruno Desthuilliers]

David Isaac a écrit : [...]

But Steve suggests going with the latter.

That's what I'd do too a priori.

Believe it or not, I wasn't at the priory when I wrote that.

Steve, if it's a pun, I'm afraid I just don't get it...

Sorry.

<aol />