subclassing Python types

[zzbbaadd]

I have read that you can derive from the base classes such as str,
list, dict.

I guess this would look like:

def MyString(str):
def MyList(list):
def MyDict(dict):
How do you access the data that is contained in the super class?

[Arnaud Delobelle]

On Aug 30, 8:00 pm, [e-mail] wrote:

I have read that you can derive from the base classes such as str,
list, dict.

I guess this would look like:

def MyString(str):
def MyList(list):
def MyDict(dict):

You mean

class MyString(str):
....

How do you access the data that is contained in the super class?

The same way that you access plain strings, lists or dicts: use the
methods of the super class.

HTH

PS: it is not so often a good idea to derive a class from these types.

--
Arnaud

[zzbbaadd]

On Aug 30, 12:13 pm, Arnaud Delobelle <[e-mail]:

On Aug 30, 8:00 pm, [e-mail] wrote:

I have read that you can derive from the base classes such as str,
list, dict.

I guess this would look like:

def MyString(str):
def MyList(list):
def MyDict(dict):

You mean

class MyString(str):
...

How do you access the data that is contained in the super class?

The same way that you access plain strings, lists or dicts: use the
methods of the super class.

I don't know what name I would use to call a method:
class MyString(str):
def __init__(strInput):
????? = strInput

[Wildemar Wildenburger]

zz******@aol.com wrote:

I have read that you can derive from the base classes such as str,
list, dict.

I guess this would look like:

def MyString(str):
def MyList(list):
def MyDict(dict):

Well, replace 'def' with 'class' and you're right.

How do you access the data that is contained in the super class?

This way:

>>class MyList(list):

.... def do_something(self):
.... self.append(3)
.... print self
....

>>l = MyList((1, 2))
l

[1, 2]

>>l.do_something()

[1, 2, 3]
That is: Whenever you want to refer to the value refer to self (that is,
refer to the instance of your class).

/W

[zzbbaadd]

On Aug 30, 12:18 pm, Wildemar Wildenburger
<[e-mail]:

[e-mail] wrote:

I have read that you can derive from the base classes such as str,
list, dict.

I guess this would look like:

def MyString(str):
def MyList(list):
def MyDict(dict):

Well, replace 'def' with 'class' and you're right.

How do you access the data that is contained in the super class?

This way:

>>class MyList(list):

... def do_something(self):
... self.append(3)
... print self
...

>>l = MyList((1, 2))
>>l

[1, 2]

>>l.do_something()

[1, 2, 3]

That is: Whenever you want to refer to the value refer to self (that is,
refer to the instance of your class).

/W

Ok, thanks.

So it's:
class MyString(str):
def __init__(self,strInput):
self = strInput

[Arnaud Delobelle]

On Aug 30, 8:24 pm, [e-mail] wrote:

On Aug 30, 12:18 pm, Wildemar Wildenburger

<[e-mail]:

[e-mail] wrote:

I have read that you can derive from the base classes such as str,
list, dict.

I guess this would look like:

def MyString(str):
def MyList(list):
def MyDict(dict):

Well, replace 'def' with 'class' and you're right.

How do you access the data that is contained in the super class?

This way:

>>class MyList(list):

... def do_something(self):
... self.append(3)
... print self
...

>>l = MyList((1, 2))
>>l

[1, 2]

>>l.do_something()

[1, 2, 3]

That is: Whenever you want to refer to the value refer to self (that is,
refer to the instance of your class).

/W

Ok, thanks.

So it's:
class MyString(str):
def __init__(self,strInput):
self = strInput

No. Well in this case it seems to work as the method str.__new__ is
called first which does what you intend to do in your example. But try
this:

>>class Upper(str):

.... def __init__(self, s):
.... self = s.upper()
....

>>Upper('camelot')

'camelot'

Doesn't work (should be 'CAMELOT', shouldn't it?)!
To understand why it doesn't behave as you expect, and how to achieve
what you want, see "Overriding the __new__ method" in GvR's article
"Unifying types and classes in Python 2.2" (http://www.python.org/
download/releases/2.2.3/descrintro/#__new__).

HTH

--
Arnaud

[Steve Holden]

zz******@aol.com wrote:

On Aug 30, 12:13 pm, Arnaud Delobelle <[e-mail]:

>On Aug 30, 8:00 pm, [e-mail] wrote:

>>I have read that you can derive from the base classes such as str,
list, dict.
I guess this would look like:
def MyString(str):
def MyList(list):
def MyDict(dict):

You mean

class MyString(str):
...

>>How do you access the data that is contained in the super class?

The same way that you access plain strings, lists or dicts: use the
methods of the super class.

I don't know what name I would use to call a method:
class MyString(str):
def __init__(strInput):
????? = strInput

I think your understanding of Python needs to advance a little before
you start trying to do something like this. It's the __new__() method
you need to be overriding, not the __init__() method.

>>class MyString(str):

.... def __new__(cls, val):
.... return str.__new__(cls, val)
....

>>s = MyString("1234")
s

'1234'

>>type(s)

<class '__main__.MyString'>

>>>

regards
Steve
--
Steve Holden [phone] [phone]
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://del.icio.us/steve.holden
--------------- Asciimercial ------------------
Get on the web: Blog, lens and tag the Internet
Many services currently offer free registration
----------- Thank You for Reading -------------

[Arnaud Delobelle]

On Aug 30, 8:42 pm, Arnaud Delobelle <[e-mail]:
[...]

"Unifying types and classes in Python 2.2" (http://www.python.org/
download/releases/2.2.3/descrintro/#__new__).

That's:

http://www.python.org/download/relea...intro/#__new__

(damn google groups ;)
--
Arnaud

[Robert Kern]

zz******@aol.com wrote:

So it's:
class MyString(str):
def __init__(self,strInput):
self = strInput

That doesn't quite work. Assigning to "self" only reassigns the name inside the
function. It does not replace the object.

Instead, call the .__init__() method on str.

class MyString(str):
def __init__(self, strInput):
str.__init__(self, strInput)
# ... other stuff

--
Robert Kern

"I have come to believe that the whole world is an enigma, a harmless enigma
that is made terrible by our own mad attempt to interpret it as though it had
an underlying truth."
-- Umberto Eco

[Arnaud Delobelle]

On Aug 30, 8:44 pm, Robert Kern <[e-mail]:

[e-mail] wrote:

So it's:
class MyString(str):
def __init__(self,strInput):
self = strInput

That doesn't quite work. Assigning to "self" only reassigns the name inside the
function. It does not replace the object.

Instead, call the .__init__() method on str.

That won't do much as strings are immutable objects...
As pointed out by Steve Holden and me, str.__new__ is the way.
--
Arnaud

[Steve Holden]

Arnaud Delobelle wrote:

On Aug 30, 8:44 pm, Robert Kern <[e-mail]:

>[e-mail] wrote:

>>So it's:
class MyString(str):
def __init__(self,strInput):
self = strInput

That doesn't quite work. Assigning to "self" only reassigns the name inside the
function. It does not replace the object.

Instead, call the .__init__() method on str.

That won't do much as strings are immutable objects...
As pointed out by Steve Holden and me, str.__new__ is the way.

I suspect the OP is analogous to the drunk who was looking for his key
next to a lamp post. When a helper became exasperated with the lack of
results he started to question the drunk about where he'd dropped the
key. "Over there" says the drunk, pointing about twenty yards away.
"Then why are you looking over here?". Comes the reply:
"Because you can't see a bloody thing where I dropped it."

regards
Steve
--
Steve Holden [phone] [phone]
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://del.icio.us/steve.holden
--------------- Asciimercial ------------------
Get on the web: Blog, lens and tag the Internet
Many services currently offer free registration
----------- Thank You for Reading -------------