eval(repr(object)) hardly ever works

[Matthew Wilson]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.

For example it doesn't work for instances of the object class:

In [478]: eval(repr(object()))
------------------------------------------------------------
File "<string>", line 1
<object object at 0xf233e8>
^
SyntaxError: invalid syntax

It seems to work for types like integers and dictionaries and lists,
but not for much else.

Any thoughts?

 

[Hardcoded Software]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.

For example it doesn't work for instances of the object class:

In [478]: eval(repr(object()))
------------------------------------------------------------
File "<string>", line 1
<object object at 0xf233e8>
^
SyntaxError: invalid syntax

It seems to work for types like integers and dictionaries and lists,
but not for much else.

Any thoughts?

I don't think that repr() is for eval(). repr() is for outputting a
string that represent the object and is not ambiguous. Example: print
'foo' == print u'foo' but print repr('foo') != print repr(u'foo')

 

[skip]

Matthew> I understand that idea of an object's __repr__ method is to
Matthew> return a string representation that can then be eval()'d back
Matthew> to life, but it seems to me that it doesn't always work.

No, where it's convenient that property is desirable. It's not a
hard-and-fast rule though. Some objects (think open files) it would be
impossible (or nearly so) to generate a representation which captured the
state of the object. For others (basic types or containers of them), it's
pretty easy.

Matthew> It seems to work for types like integers and dictionaries and
Matthew> lists, but not for much else.

Matthew> Any thoughts?

Sure, if you want to save and restore objects, pickle or marshal them.
Don't rely on repr().

Skip

 

[Steve Holden]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.

For example it doesn't work for instances of the object class:

In [478]: eval(repr(object()))
------------------------------------------------------------
File "<string>", line 1
<object object at 0xf233e8>
^
SyntaxError: invalid syntax

It seems to work for types like integers and dictionaries and lists,
but not for much else.

That's intentional. Would you have it return the code of all the methods
when you take the repr() of a class?

regards
Steve

 

[Matthew Wilson]

That's intentional. Would you have it return the code of all the methods
when you take the repr() of a class?

I don't think that would be required. Couldn't you return a string with
a call to the constructor inside? That's what sets.Set seems to do:

In [510]: from sets import Set

In [511]: s = Set()

In [512]: s.add('baloney')

In [513]: repr(s)
Out[513]: "Set(['baloney'])"

In [514]: eval(repr(s))
Out[514]: Set(['baloney'])

regards
Steve

PS: I read your python web programming book a few years ago.

 

[Fredrik Lundh]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.

when in doubt, read the language reference:

"If at all possible, this should look like a valid Python
expression that could be used to recreate an object with
the same value (given an appropriate environment). If this
is not possible, a string of the form "<...some useful
description...>" should be returned.

http://pyref.infogami.com/__repr__

</F>

 

[Donn Cave]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.

For example it doesn't work for instances of the object class:

In [478]: eval(repr(object()))
------------------------------------------------------------
File "<string>", line 1
<object object at 0xf233e8>
^
SyntaxError: invalid syntax

It seems to work for types like integers and dictionaries and lists,
but not for much else.

I don't think that repr() is for eval(). repr() is for outputting a
string that represent the object and is not ambiguous. Example: print
'foo' == print u'foo' but print repr('foo') != print repr(u'foo')

Right, but that eval() idea dies hard. The document excerpt
quoted in an earlier followup, for __repr__, now admits that it
might not be possible ... but then the documentation for __str__
right below it says "differs from __repr() in that it does not
have to be a valid Python expression". There's plenty of evidence
in the standard libraries that people understand these two functions,
but they certainly have arrived at that understanding from some
other route than reading the documentation.

Donn Cave, (e-mail address removed)

 

[sjdevnull]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.

Just to reinforce something Skip mentioned:

If you're looking for a way to serialize an object into a string, and
then later turn that string back into an object, you probably want the
pickle module (the marshal module is similar but is really intended for
internal use; unless you know exactly why you're picking one over the
other, using pickle is probably the right call).

http://docs.python.org/lib/module-pickle.html

 

[Tal Einat]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.
[snip]

Any thoughts?

This is actually an interesting issue when you're working with Python
interpreters. For example, an object with a simple repr() which is code
to create an identical object is easy to use as a key in a dictionary.

I ran into this a while back when I was tinkering with IDLE's
auto-completion module, and ended up writing some code which checks if
an object's repr() is "reversible" or not.

- Tal
reduce(lambda m,x:[m+s[-1] for i,s in enumerate(sorted(m))],
[[chr(154-ord(c)) for c in '.&-&,l.Z95193+179-']]*18)[3]

 

[Dustan]

I understand that idea of an object's __repr__ method is to return a
string representation that can then be eval()'d back to life, but it
seems to me that it doesn't always work.

For example it doesn't work for instances of the object class:

In [478]: eval(repr(object()))
------------------------------------------------------------
File "<string>", line 1
<object object at 0xf233e8>
^
SyntaxError: invalid syntax

It seems to work for types like integers and dictionaries and lists,
but not for much else.

Any thoughts?

You have to write the code to return a proper representation.