Sorry, but I Just Don't Get It. I did search the 'net, I did read the
FAQ, but I'm too dumb to understand.
As far as I can gather, __str__ is just a representation of the
object. For instance:
class ServerConnection:
def __str__(self):
buf = "Server: " + self.name + "\n"
buf += "Sent bytes: " + str(self.sentBytes) + "\n"
buf += "Recv bytes: " + str(self.recvBytes) + "\n"
return buf
However, I don't understand what __repr__ should be. There's a phrase
in the documentation which makes it highly confusing for a beginner like
me: "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).". What does that mean? Does it mean that I
should return:
def __str__(self):
buf = "self.name=" + self.name + "\n"
buf += "self.sentBytes=" + str(self.sentBytes) + "\n"
buf += "self.recvBytes=" + str(self.recvBytes) + "\n"
return buf
..or is there some other "valid Python expression" format which I
have yet to encounter?
15  2908 
Jan Danielsson a écrit : Sorry, but I Just Don't Get It. I did search the 'net, I did read the
FAQ, but I'm too dumb to understand.
As far as I can gather, __str__ is just a representation of the
object.
.... yep, and this representation is built for human eyes. Don't
worry too much if it does not display every bit of information
contained in your object. Pretty printing rules ...
str(0.1)
0.1 str("it's a bad idea")
"it's a bad idea"
However, I don't understand what __repr__ should be.
It is an *exact* (if possible) description of the object's content,
nicely packaged into a string.
repr(0.1)
0.10000000000000001 repr("it's a bad idea")
'"it\'s a bad idea"'
There's a phrase
in the documentation which makes it highly confusing for a beginner like
me: "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).".
It means that the equality eval(repr(x)) == x should hold.
Cheers,
SB
Errata: str(0.1)
'0.1' str("it's a bad idea")
"it's a bad idea"
repr(0.1)
' 0.10000000000000001' repr("it's a bad idea")
'"it\'s a bad idea"'
SB
Well, It means that eval(repr(x)) == x if at all possible.
Basically:
repr('abc') -> 'abc'
str('abc') -> abc
You'll notice that 'abc' is a valid python expression for the string,
while abc is not a valid string expression.
Andreas
On Wed, Jun 15, 2005 at 02:46:04PM +0200, Jan Danielsson wrote: Sorry, but I Just Don't Get It. I did search the 'net, I did read the
FAQ, but I'm too dumb to understand.
As far as I can gather, __str__ is just a representation of the
object. For instance:
class ServerConnection:
def __str__(self):
buf = "Server: " + self.name + "\n"
buf += "Sent bytes: " + str(self.sentBytes) + "\n"
buf += "Recv bytes: " + str(self.recvBytes) + "\n"
return buf
However, I don't understand what __repr__ should be. There's a phrase
in the documentation which makes it highly confusing for a beginner like
me: "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).". What does that mean? Does it mean that I
should return:
def __str__(self):
buf = "self.name=" + self.name + "\n"
buf += "self.sentBytes=" + str(self.sentBytes) + "\n"
buf += "self.recvBytes=" + str(self.recvBytes) + "\n"
return buf
..or is there some other "valid Python expression" format which I
have yet to encounter?
--
http://mail.python.org/mailman/listinfo/python-list
Basically __repr__ should return a string representaion of the object,
and __str__ should return a user-friendly pretty string. So maybe:
class Person:
...
def __repr__(self):
return '<Person: %s, %d, %s>' % (self.name, self.age, self.sign)
def __str__(self):
return self.name
See this for a better explanation: http://www.faqts.com/knowledge_base/...d/1331/fid/241
Jan Danielsson wrote: Sorry, but I Just Don't Get It. I did search the 'net, I did read the
FAQ, but I'm too dumb to understand.
As far as I can gather, __str__ is just a representation of the
object. [snip]
However, I don't understand what __repr__ should be.
__repr__ shouldn't be anything, if you don't have an actual need for it.
Neither should __str__.
But if you have a need for something, and you're not sure which to use,
think of it this way. If you are trying to output a representation of
the object for use in debugging, such as in a debug log file, then use
__repr__ and make it look like whatever you want, but preferably
following the <Angle brackets convention> like all the builtin stuff.
If you have a need for some representation of the data to use in your
application for non-debugging purposes, such as perhaps to display data
to a user, or to write data to an output file, then __str__ is a good
candidate, and you can make it look like whatever you need.
Just don't waste your time defining either a __repr__ or a __str__ just
because those methods exist. That won't do anyone any good.
-Peter
In article <42********@griseus.its.uu.se>,
Jan Danielsson <ja************@gmail.com> wrote: Sorry, but I Just Don't Get It. I did search the 'net, I did read the
FAQ, but I'm too dumb to understand.
As far as I can gather, __str__ is just a representation of the
object.
No, it is not. It is a conversion to string. The result has
no trace of the original object, per se -- in principle, many
different kinds of object could yield the same result. Suppose
str(x) -> "42". Is x an int? a string? an XMLParseResult?
AnswerToLifeTheUniverseAndEverything? You don't want to know,
that's why you use str().
The "friendly" idea is vacuous if you look hard enough at it,
and won't really help.
However, I don't understand what __repr__ should be. There's a phrase
in the documentation which makes it highly confusing for a beginner like
me: "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).". What does that mean?
It's kind of a bad idea that the Python world isn't ready to
let go of yet.
repr() is really the representation of the object. If you
look at the result of repr(x), you should indeed see some
clue to the original object. I guess this is what gives
people the idea that str() is friendly, because as a rule
users are not interested in the original object -- but
there are exceptions, for example you may find the quotes
useful around a string, depending on the situation. The
object information also leads to the marshalling idea, but
of course this isn't (and can't be) implemented for many
objects so we can't expect this to work reliably with
random objects. The price we pay for the notion is mostly
in the "fix" for float repr, which now displays the float
in all its imprecise glory and routinely confounds people
who don't understand what that's about.
Donn Cave, do**@u.washington.edu
On Wednesday 15 June 2005 08:06 am, Sébastien Boisgérault wrote: Jan Danielsson a écrit : However, I don't understand what __repr__ should be.
It is an *exact* (if possible) description of the object's content,
nicely packaged into a string.
However, this is often not the case. Frequently __repr__ will
return something like this: import re
r = re.compile('\w+\d*')
r
<_sre.SRE_Pattern object at 0x401a89b0> str(r)
'<_sre.SRE_Pattern object at 0x401a89b0>' repr(r)
'<_sre.SRE_Pattern object at 0x401a89b0>'
So don't obsess over it. For many objects it isn't worth
the trouble, and for others, str() and repr() are sensibly the
same thing, but for some, the distinction is useful. That's
all.
--
Terry Hancock ( hancock at anansispaceworks.com )
Anansi Spaceworks http://www.anansispaceworks.com
Jan Danielsson wrote: Sorry, but I Just Don't Get It. I did search the 'net, I did read the
FAQ, but I'm too dumb to understand.
Say we define a string "s" as follows: s = 'hello'
If we print "s", we see its string form (__str__):
print s
hello
However, if we just examine "s", we see its representation (__repr__):
s
'hello'
This can be verified by calling str() and repr() on the string:
str(s)
'hello' repr(s)
"'hello'"
So, the result of repr() includes quotes, whereas the result of str()
does not. This has useful properties when the object is part of a more
complex structure. For instance, these two expressions print out the same:
[s, s]
['hello', 'hello'] print [s, s]
['hello', 'hello']
That's because, in either case, the repr() form is used. If Python only
had str(), we would probably expect str(s) = s, so we'd instead see
something like this imaginary snippet:
[s, s]
[hello, hello] repr([s, s])
'[hello, hello]'
So, the convention in Python is that repr() returns a string that, when
evaluated, returns the original object. This is not always easy or
possible to do, but if you can do it, your objects will print nicely
when nested within Python's built-in data structures. Python's actual
behavior is this:
repr([s, s])
"['hello', 'hello']"
And therefore:
eval(repr([s, s]))
['hello', 'hello']
Also worth noting is that if you define __repr__, the default behavior
of __str__ is to delegate to that definition, so if you only want to
define one, it's often more convenient to just define __repr__.
Dave
"Jan Danielsson" <ja************@gmail.com> wrote in message
news:42********@griseus.its.uu.se... Sorry, but I Just Don't Get It. I did search the 'net, I did read the
FAQ, but I'm too dumb to understand.
As far as I can gather, __str__ is just a representation of the
object. For instance:
class ServerConnection:
def __str__(self):
buf = "Server: " + self.name + "\n"
buf += "Sent bytes: " + str(self.sentBytes) + "\n"
buf += "Recv bytes: " + str(self.recvBytes) + "\n"
return buf
However, I don't understand what __repr__ should be. There's a phrase
in the documentation which makes it highly confusing for a beginner like
me: "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).". What does that mean? Does it mean that I
should return:
def __str__(self):
buf = "self.name=" + self.name + "\n"
buf += "self.sentBytes=" + str(self.sentBytes) + "\n"
buf += "self.recvBytes=" + str(self.recvBytes) + "\n"
return buf
..or is there some other "valid Python expression" format which I
have yet to encounter?
str() should be something that's meaningful to a human being when
it's printed or otherwise rendered. repr() should be something that
can round trip: that is, if you feed it into eval() it should reproduce
the object.
You can't always achieve either one, especially with very
complex objects, but that's the goal.
John Roth
Quoth "John Roth" <ne********@jhrothjr.com>:
....
| str() should be something that's meaningful to a human being when
| it's printed or otherwise rendered.
I can't believe how many people cite this explanation - meaningful,
friendly, pretty to a human being. What on earth does this mean,
that couldn't be said more unambiguously?
According to my impression of common applications for Python programs,
rarely would anyone be looking at the output for esthetic gratification.
I mean, imagine your users casting an appraising eye over the contours
of a phrase emitted by the program, and praising the rhythmic effect of
the punctuation it chose to use, or negative space created by tabs. heh.
Whether for human eyes or any destination, properly formed output will
carry the information that is required for the application, in a complete
and unambiguous way and in the format that is most readily processed,
and it will omit extraneous information. Are we saying anything other
than this?
Donn Cave, do**@drizzle.com
"Donn Cave" <do**@drizzle.com> wrote in message
news:1118898421.887013@yasure... Quoth "John Roth" <ne********@jhrothjr.com>:
...
| str() should be something that's meaningful to a human being when
| it's printed or otherwise rendered.
I can't believe how many people cite this explanation - meaningful,
friendly, pretty to a human being. What on earth does this mean,
that couldn't be said more unambiguously?
According to my impression of common applications for Python programs,
rarely would anyone be looking at the output for esthetic gratification.
I mean, imagine your users casting an appraising eye over the contours
of a phrase emitted by the program, and praising the rhythmic effect of
the punctuation it chose to use, or negative space created by tabs. heh.
Whether for human eyes or any destination, properly formed output will
carry the information that is required for the application, in a complete
and unambiguous way and in the format that is most readily processed,
and it will omit extraneous information. Are we saying anything other
than this?
I thought that's what I said. I fail to see how you derive any other
meaning from it. Possibly less verbiage and a concerete example
of how "meaningful" equates to "esthetics that obfustificate understanding"
and does not equate to "immediately useable, without having to wade
through a lot of irrelvant mental transformations" would help my
understanding.
John Roth
Donn Cave, do**@drizzle.com
In article <11*************@news.supernews.com>,
"John Roth" <ne********@jhrothjr.com> wrote: "Donn Cave" <do**@drizzle.com> wrote in message
news:1118898421.887013@yasure... Quoth "John Roth" <ne********@jhrothjr.com>:
...
| str() should be something that's meaningful to a human being when
| it's printed or otherwise rendered.
I can't believe how many people cite this explanation - meaningful,
friendly, pretty to a human being. What on earth does this mean,
that couldn't be said more unambiguously?
According to my impression of common applications for Python programs,
rarely would anyone be looking at the output for esthetic gratification.
I mean, imagine your users casting an appraising eye over the contours
of a phrase emitted by the program, and praising the rhythmic effect of
the punctuation it chose to use, or negative space created by tabs. heh.
Whether for human eyes or any destination, properly formed output will
carry the information that is required for the application, in a complete
and unambiguous way and in the format that is most readily processed,
and it will omit extraneous information. Are we saying anything other
than this?
I thought that's what I said. I fail to see how you derive any other
meaning from it. Possibly less verbiage and a concerete example
of how "meaningful" equates to "esthetics that obfustificate understanding"
and does not equate to "immediately useable, without having to wade
through a lot of irrelvant mental transformations" would help my
understanding.
Not sure if that's a question. Maybe I can state this more clearly.
Observation: Most who responded to this question offered an
explanation of __str__ like "friendly to a human being",
using one or more of meaningful, friendly or pretty. The
online manual uses "informal".
1. These words are woefully ambiguous, to be applied in computer
programming. While there may be some kind of absolute basis
for esthetic appreciation, that clearly doesn't apply here,
and terms like this have to be strictly relative to context
created by the application.
Summary: By itself, friendly to a human being is a vacuous
notion and doesn't help anyone.
2. If we attempt to support the explanation with a more rigorous
examination of the principles and how they'd apply to a string
conversion, it's hard to make this come out favoring str over
repr. In the end, they should both be meaningful and friendly,
by any uncontorted definition of those terms.
Summary: To the extent that they have any meaning, they are
probably applied incorrectly as an explanation of __str__.
So, among other conclusions, the documentation should be changed
to offer a more sensible explanation of __str__.
Donn Cave, do**@u.washington.edu
On 6/15/05, Peter Hansen <pe***@engcorp.com> wrote: __repr__ shouldn't be anything, if you don't have an actual need for it.
Neither should __str__.
Oh, I don't know. __str__ is so frequently useful in debugging and
logging that I always try and do something useful with it.
--
Cheers,
Simon B, si***@brunningonline.net, http://www.brunningonline.net/simon/blog/
Simon Brunning wrote: On 6/15/05, Peter Hansen <pe***@engcorp.com> wrote:__repr__ shouldn't be anything, if you don't have an actual need for it.
Neither should __str__.
Oh, I don't know. __str__ is so frequently useful in debugging and
logging that I always try and do something useful with it.
Interesting: for the same purpose, I would define __repr__.
But I still define it only when I actually care about the details, since
otherwise the default __repr__ is always there. Spending time figuring
out a potentially more useful __str__/__repr__ (how nice that we've
confused the issue of which to use, again! ;-) ) is not my idea of a
good use of time, what with YAGNI and all from XP...
-Peter __repr__ shouldn't be anything, if you don't have an actual need for
it. Neither should __str__.
Simon> Oh, I don't know. __str__ is so frequently useful in debugging
Simon> and logging that I always try and do something useful with it.
And sometimes __repr__ inherited from a base class doesn't tell you much.
If you inherit from gobject (the basic object in PyGtk), the repr is
something like
<Future object (__main__+Base) at 0x851384c>
That is, it identifies the class name, its inheritance hierarchy (Future ->
Base -> __main__ in this case) and its memory address. That's perhaps
useful by itself in some contexts, and I can understand that the PyGtk folks
couldn't really stuff more specific info in there, but it does nothing to
distinguish one instance's state from that of another.
Skip This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics
by: Jim Newton |
last post by:
hi all, does anyone know what print does if there is no __str__ method?
i'm trying ot override the __repr__. If anyone can give me some advice
it would be great to have.
I have defined a...
|
by: Dan Sommers |
last post by:
Hi,
I have a class whose objects represent physical quantities including
uncertainties and units, and I would like more control over the way they
print.
I have a __str__ method which outputs...
|
by: could ildg |
last post by:
What's the difference between __repr__ and __str__?
When will __repr__ be useful?
|
by: Jeffrey E. Forcier |
last post by:
I am attempting to write a class whose string representation changes
in response to external stimuli. While that effect is obviously
possible via other means, I attempted this method first and was...
|
by: Ben Finney |
last post by:
Howdy all,
The builtin types have __repr__ attributes that return something nice,
that looks like the syntax one would use to create that particular
instance.
The default __repr__ for custom...
|
by: Edward C. Jones |
last post by:
#! /usr/bin/env python
class A(list):
def __init__(self, alist, n):
list.__init__(self, alist)
self.n = n
def __str__(self):
return 'AS(%s, %i)' % (list.__str__(self), self.n)
|
by: Roc Zhou |
last post by:
Now I have to design a class that overload __getattr__, but after
that, I found the __repr__ have been affected. This is a simple
example model:
#!/usr/bin/env python
class test:
def...
|
by: Konstantinos Pachopoulos |
last post by:
Hi,
i have the following class:
===========================================
class CmterIDCmts:
def __init__(self,commiterID,commits):
self.commiterID_=long(commiterID)...
|
by: Charles Arthur |
last post by:
How do i turn on java script on a villaon, callus and itel keypad mobile phone
|
by: ryjfgjl |
last post by:
If we have dozens or hundreds of excel to import into the database, if we use the excel import function provided by database editors such as navicat, it will be extremely tedious and time-consuming...
|
by: emmanuelkatto |
last post by:
Hi All, I am Emmanuel katto from Uganda. I want to ask what challenges you've faced while migrating a website to cloud.
Please let me know.
Thanks!
Emmanuel
|
by: nemocccc |
last post by:
hello, everyone, I want to develop a software for my android phone for daily needs, any suggestions?
|
by: Hystou |
last post by:
There are some requirements for setting up RAID:
1. The motherboard and BIOS support RAID configuration.
2. The motherboard has 2 or more available SATA protocol SSD/HDD slots (including MSATA, M.2...
|
by: marktang |
last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However,...
|
by: Oralloy |
last post by:
Hello folks,
I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>".
The problem is that using the GNU compilers,...
|
by: jinu1996 |
last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven...
|
by: Hystou |
last post by:
Overview:
Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows...
| |
