New inited instance of class?

[Samuel Kleiner]

Is there a builtin way of making making another instance of your own
class? I really expected type(self)(*arg s, **keywords) to work this way.
Currently i'm doing this:

def new(self,*args, **keywords):
from new import instance
s=instance(self .__class__)
if hasattr(D(),'__ init__'):
s.__init__(*arg s,**keywords)
return s

--
"You have to impress him! Be independent and plucky, but often do
things that are moronic and out of character!"
--50s Diana Dane to 90s Diana Dane

[Douglas Alan]

Samuel Kleiner <sa*@samuel-kleiners-computer.local> writes:

Is there a builtin way of making making another instance of your own
class? I really expected type(self)(*arg s, **keywords) to work this way.

Doesn't self.__class__( *args, **keywords) work?

|>oug

[Francis Avila]

Samuel Kleiner wrote in message ...

Is there a builtin way of making making another instance of your own
class?
You mean, from the inside (from one of the instance methods of the class)?

def new(self, *args, **kargs):
return self.__class__( *args, **kargs)
I really expected type(self)(*arg s, **keywords) to work this way.
Works for me. What traceback does it give you?
Currently i'm doing this:

def new(self,*args, **keywords):
from new import instance
s=instance(self .__class__)
if hasattr(D(),'__ init__'):
s.__init__(*arg s,**keywords)
return s

That's ugly.

--
Francis Avila

[Samuel Kleiner]

Francis Avila wrote:

Samuel Kleiner wrote in message ...

Is there a builtin way of making making another instance of your own
class?
You mean, from the inside (from one of the instance methods of the class)?

Yes.
def new(self, *args, **kargs):
return self.__class__( *args, **kargs)

This works. Thanks.

I really expected type(self)(*arg s, **keywords) to work this way.

Works for me. What traceback does it give you?

Not for me. I really want to call it as the function itself, and

type(self)(argu ment1,argument2 ,argument3)

fails with

Traceback (most recent call last):
File "<stdin>", line 139, in ?
File "<stdin>", line 78, in __add__
TypeError: instance() takes at most 2 arguments (3 given)

whereas

self.__class__( argument1,argum ent2,argument3)

does not

Currently i'm doing this:

[my code]

That's ugly.

Yes.

--
On an encouraging note, however, I found that throughout the source code,
extremely conservative coding practices and good error checking everywhere
means that our software does not crash when handling IPv6 addresses.
--Joe Loughry, Lockheed Martin Space and Strategic Missiles, RADIANT MERCURY

[Francis Avila]

Samuel Kleiner wrote in message ...

Not for me. I really want to call it as the function itself, and

type(self)(arg ument1,argument 2,argument3)

fails with

Traceback (most recent call last):
File "<stdin>", line 139, in ?
File "<stdin>", line 78, in __add__
TypeError: instance() takes at most 2 arguments (3 given)

Ah! You're using classic classes. Don't do that.

Observe:

class classic: pass
type(classic) <type 'classobj'> type(classic()) <type 'instance'> classic().__cla ss__ <class __main__.classi c at 0x00F58030>
class newstyle(object ): pass
type(newstyle) <type 'type'> type(newstyle() ) <class '__main__.newst yle'> newstyle().__cl ass__ <class '__main__.newst yle'>

If you're curious, look in the Python Language Reference at the old and new
style classes to see the differences. There's absolutely no advantage to
old style classes, so stop usin' 'em.

There's a grand old intro (by Guido) to new-style classes at python.org,
linked from "What's New" in the 2.3 docs. I keep hunting for that link: it
really should be in the distributed docs, because it's vital for
understanding the still poorly-documented new-style classes.
--
Francis Avila

[Samuel Kleiner]

Francis Avila wrote:

Ah! You're using classic classes. Don't do that.

Ok, thanks-

So can I make all my classes derive from object without
doing so explicitly- IE, without having to change every
single top-level class definition?

--
Loren ipsum dolor sit amet, consectetuer adipiscing elit, sed diam
nonummy nibh eusmod tincidunt ut laoreet dolore magna aliquam erat
volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation

[Francis Avila]

Samuel Kleiner wrote in message ...

Francis Avila wrote:

Ah! You're using classic classes. Don't do that.

Ok, thanks-

So can I make all my classes derive from object without
doing so explicitly- IE, without having to change every
single top-level class definition?

I doubt it. But I think sed or re could take care of that quite easily with
a search/replace.

Besides, "explicit is better than implicit." ;)
--
Francis Avila

[Peter Otten]

Samuel Kleiner wrote:

So can I make all my classes derive from object without
doing so explicitly- IE, without having to change every
single top-level class definition?

You can do it on a per-file basis by putting

__metaclass__ = type

once before the class definitions.

Peter

[Fredrik Lundh]

Francis Avila wrote:

If you're curious, look in the Python Language Reference at the old and new
style classes to see the differences. There's absolutely no advantage to
old style classes
except performance:

http://www.python.org/~jeremy/weblog/030506.html
it's vital for understanding the still poorly-documented new-style classes.

documentation may also be seen as an advantage, of course.

</F>

[Aahz]

In article <vt************ @corp.supernews .com>,
Francis Avila <fr***********@ yahoo.com> wrote:

If you're curious, look in the Python Language Reference at the old
and new style classes to see the differences. There's absolutely no
advantage to old style classes, so stop usin' 'em.

<raised eyebrow> In addition to the factors Fredrik mentioned, there's
also the issue that new-style classes are more of a moving target WRT
syntax and semantics; for complex uses, it can be tricky (or impossible)
to get the same code working the same way on both 2.2 and 2.3.

More than that, you *can't* use new-style classes for exceptions. So
please stop telling people to avoid classic classes.
--
Aahz (aa**@pythoncra ft.com) <*> http://www.pythoncraft.com/

Weinberg's Second Law: If builders built buildings the way programmers wrote
programs, then the first woodpecker that came along would destroy civilization.