My rule of thumb: __repr__ is for developers, __str__ is for customers.

Unless you specifically act to ensure otherwise, most classes don't have helpful results for either:

>>> class Sic(object): pass

... 

>>> print str(Sic())

<__main__.Sic object at 0x8b7d0>

>>> print repr(Sic())

<__main__.Sic object at 0x8b7d0>

>>> 

As you see -- no difference, and no info beyond the class and object's id. If you only override one of the two...:

>>> class Sic(object): 

...   def __repr__(object): return 'foo'

... 

>>> print str(Sic())

foo

>>> print repr(Sic())

foo

>>> class Sic(object):

...   def __str__(object): return 'foo'

... 

>>> print str(Sic())

foo

>>> print repr(Sic())

<__main__.Sic object at 0x2617f0>

>>> 

as you see, if you override __repr__, that's ALSO used for __str__, but not vice versa.

Other crucial tidbits to know: __str__ on a built-on container uses the __repr__, NOT the __str__, for the items it contains. And, despite the words on the subject found in typical docs, hardly anybody bothers making the __repr__ of objects be a string that eval may use to build an equal object (it's just too hard, AND not knowing how the relevant module was actually imported makes it actually flat out impossible).

So, my advice: focus on making __str__ reasonably human-readable, and __repr__ as unambiguous as you possibly can, even if that interferes with the fuzzy unattainable goal of making __repr__'s returned value acceptable as input to __eval__!

__repr__: representation of python object usually eval will convert it back to that object

__str__: is whatever you think is that object in text form

e.g.

>>> s="""w'o"w"""

>>> repr(s)

''w\'o"w''

>>> str(s)

'w'o"w'

>>> eval(str(s))==s

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  File "<string>", line 1

    w'o"w

       ^

SyntaxError: EOL while scanning single-quoted string

>>> eval(repr(s))==s

True

In short, the goal of __repr__ is to be unambiguous and __str__ is to be
readable.

Here is a good example:

>>> import datetime

>>> today = datetime.datetime.now()

>>> str(today)

'2012-03-14 09:21:58.130922'

>>> repr(today)

'datetime.datetime(2012, 3, 14, 9, 21, 58, 130922)'

Read this documentation for repr:

repr(object)

Return a string containing a printable representation of an object. This is the same value yielded by conversions (reverse
quotes). It is sometimes useful to be able to access this operation as
an ordinary function. For many types, this function makes an attempt
to return a string that would yield an object with the same value when
passed to eval(), otherwise the representation is a string enclosed in
angle brackets that contains the name of the type of the object
together with additional information often including the name and
address of the object. A class can control what this function returns
for its instances by defining a __repr__() method.

Here is the documentation for str:

str(object='')

Return a string containing a nicely printable
representation of an object. For strings, this returns the string
itself. The difference with repr(object) is that str(object) does not
always attempt to return a string that is acceptable to eval(); its
goal is to return a printable string. If no argument is given, returns
the empty string, ''.

What is the difference between __str__ and __repr__ in Python?

__str__ (read as "dunder (double-underscore) string") and __repr__ (read as "dunder-repper" (for "representation")) are both special methods that return strings based on the state of the object.

__repr__ provides backup behavior if __str__ is missing.

So one should first write a __repr__ that allows you to reinstantiate an equivalent object from the string it returns e.g. using eval or by typing it in character-for-character in a Python shell.

At any time later, one can write a __str__ for a user-readable string representation of the instance, when one believes it to be necessary.

__str__

If you print an object, or pass it to format, str.format, or str, then if a __str__ method is defined, that method will be called, otherwise, __repr__ will be used.

__repr__

The __repr__ method is called by the builtin function repr and is what is echoed on your python shell when it evaluates an expression that returns an object.

Since it provides a backup for __str__, if you can only write one, start with __repr__

Here's the builtin help on repr:

repr(...)

    repr(object) -> string



    Return the canonical string representation of the object.

    For most object types, eval(repr(object)) == object.

That is, for most objects, if you type in what is printed by repr, you should be able to create an equivalent object. But this is not the default implementation.

Default Implementation of __repr__

The default object __repr__ is (C Python source) something like:

def __repr__(self):

    return '<{0}.{1} object at {2}>'.format(

      self.__module__, type(self).__name__, hex(id(self)))

That means by default you'll print the module the object is from, the class name, and the hexadecimal representation of its location in memory - for example:

<__main__.Foo object at 0x7f80665abdd0>

This information isn't very useful, but there's no way to derive how one might accurately create a canonical representation of any given instance, and it's better than nothing, at least telling us how we might uniquely identify it in memory.

How can __repr__ be useful?

Let's look at how useful it can be, using the Python shell and datetime objects. First we need to import the datetime module:

import datetime

If we call datetime.now in the shell, we'll see everything we need to recreate an equivalent datetime object. This is created by the datetime __repr__:

>>> datetime.datetime.now()

datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)

If we print a datetime object, we see a nice human readable (in fact, ISO) format. This is implemented by datetime's __str__:

>>> print(datetime.datetime.now())

2015-01-24 20:05:44.977951

It is a simple matter to recreate the object we lost because we didn't assign it to a variable by copying and pasting from the __repr__ output, and then printing it, and we get it in the same human readable output as the other object:

>>> the_past = datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)

>>> print(the_past)

2015-01-24 20:05:36.491180

How do I implement them?

As you're developing, you'll want to be able to reproduce objects in the same state, if possible. This, for example, is how the datetime object defines __repr__ (Python source). It is fairly complex, because of all of the attributes needed to reproduce such an object:

def __repr__(self):

    """Convert to formal string, for repr()."""

    L = [self._year, self._month, self._day, # These are never zero

         self._hour, self._minute, self._second, self._microsecond]

    if L[-1] == 0:

        del L[-1]

    if L[-1] == 0:

        del L[-1]

    s = ", ".join(map(str, L))

    s = "%s(%s)" % ('datetime.' + self.__class__.__name__, s)

    if self._tzinfo is not None:

        assert s[-1:] == ")"

        s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"

    return s

If you want your object to have a more human readable representation, you can implement __str__ next. Here's how the datetime object (Python source) implements __str__, which it easily does because it already has a function to display it in ISO format:

def __str__(self):

    "Convert to string, for str()."

    return self.isoformat(sep=' ')

Set __repr__ = __str__?

This is a critique of another answer here that suggests setting __repr__ = __str__.

Setting __repr__ = __str__ is silly - __repr__ is a fallback for __str__ and a __repr__, written for developers usage in debugging, should be written before you write a __str__.

You need a __str__ only when you need a textual representation of the object.

Conclusion

Define __repr__ for objects you write so you and other developers have a reproducible example when using it as you develop. Define __str__ when you need a human readable string representation of it.

Apart from all the answers given, I would like to add few points :-

1) __repr__() is invoked when you simply write object's name on interactive python console and press enter.

2) __str__() is invoked when you use object with print statement.

3) In case, if __str__ is missing, then print and any function using str() invokes __repr__() of object.

4) __str__() of containers, when invoked will execute __repr__() method of its contained elements.

5) str() called within __str__() could potentially recurse without a base case, and error on maximum recursion depth.

6) __repr__() can call repr() which will attempt to avoid infinite recursion automatically, replacing an already represented object with ....

On page 358 of the book Python scripting for computational science by Hans Petter Langtangen, it clearly states that

• The __repr__ aims at a complete string representation of the object;


• The __str__ is to return a nicely string for printing.

So, I prefer to understand them as

• repr = reproduce


• str = string (representation)

from the user point of view
although this is a misunderstanding i made when learning python.

A small but good example is also given on the same page as follows:

Example

In [38]: str('s')

Out[38]: 's'



In [39]: repr('s')

Out[39]: "'s'"



In [40]: eval(str('s'))

Traceback (most recent call last):



  File "<ipython-input-40-abd46c0c43e7>", line 1, in <module>

    eval(str('s'))



  File "<string>", line 1, in <module>



NameError: name 's' is not defined





In [41]: eval(repr('s'))

Out[41]: 's'

In all honesty, eval(repr(obj)) is never used. If you find yourself using it, you should stop, because eval is dangerous, and strings are a very inefficient way to serialize your objects (use pickle instead).

Therefore, I would recommend setting __repr__ = __str__. The reason is that str(list) calls repr on the elements (I consider this to be one of the biggest design flaws of Python that was not addressed by Python 3). An actual repr will probably not be very helpful as the output of print [your, objects].

To qualify this, in my experience, the most useful use case of the repr function is to put a string inside another string (using string formatting). This way, you don't have to worry about escaping quotes or anything. But note that there is no eval happening here.

To put it simply:

__str__ is used in to show a string representation of your object to be read easily by others.

__repr__ is used to show a string representation of the object.

Let's say I want to create a Fraction class where the string representation of a fraction is '(1/2)' and the object (Fraction class) is to be represented as 'Fraction (1,2)'

So we can create a simple Fraction class:

class Fraction:

    def __init__(self, num, den):

        self.__num = num

        self.__den = den



    def __str__(self):

        return '(' + str(self.__num) + '/' + str(self.__den) + ')'



    def __repr__(self):

        return 'Fraction (' + str(self.__num) + ',' + str(self.__den) + ')'







f = Fraction(1,2)

print('I want to represent the Fraction STRING as ' + str(f)) # (1/2)

print('I want to represent the Fraction OBJECT as ', repr(f)) # Fraction (1,2)

From http://pyref.infogami.com/__str__ by effbot:

__str__ "computes the "informal" string representation of an object. This differs from __repr__ in that it does not have to be a valid Python expression: a more convenient or concise representation may be used instead."

One aspect that is missing in other answers. It's true that in general the pattern is:

• Goal of __str__: human-readable


• Goal of __repr__: unambiguous, possibly machine-readable via eval
  

Unfortunately, this differentiation is flawed, because the Python REPL and also IPython use __repr__ for printing objects in a REPL console (see related questions for Python and IPython). Thus, projects which are targeted for interactive console work (e.g., Numpy or Pandas) have started to ignore above rules and provide a human-readable __repr__ implementation instead.

str - Creates a new string object from the given object.

repr - Returns the canonical string representation of the object.

The differences:

str():

• makes object readable


• generates output for end-user

repr():

• needs code that reproduces object


• generates output for developer

"A basic requirement for a Python object is to provide usable 

 string   representations of itself, one used for debugging and

 logging, another for presentation to end users. That is why the  

 special methods __repr__ and __str__ exist in the data model."

From the book: Fluent Python

Excellent answers already cover the difference between __str__ and __repr__, which for me boils down to the former being readable even by an end user, and the latter being as useful as possible to developers. Given that, I find that the default implementation of __repr__ often fails to achieve this goal because it omits information useful to developers.

For this reason, if I have a simple enough __str__, I generally just try to get the best of both worlds with something like:

def __repr__(self):

    return '{0} ({1})'.format(object.__repr__(self), str(self))

>>> print(decimal.Decimal(23) / decimal.Decimal("1.05"))

21.90476190476190476190476190

>>> decimal.Decimal(23) / decimal.Decimal("1.05")

Decimal('21.90476190476190476190476190')

When print() is called on the result of decimal.Decimal(23) / deci- mal.Decimal("1.05") the raw number is printed; this output is in string form which can be achieved with __str __(). If we simply enter the expression we get a decimal.Decimal output—this output is in representational form which can be achieved with __repr __(). All Python objects have two output forms. String form is designed to be human-readable. Representational form is designed to produce output that if fed to a Python interpreter would (when possible) re- produce the represented object

One important thing to keep in mind is that container's __str__ uses contained objects' __repr__.

>>> from datetime import datetime

>>> from decimal import Decimal

>>> print (Decimal('52'), datetime.now())

(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 51, 26, 185000))

>>> str((Decimal('52'), datetime.now()))

"(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 52, 22, 176000))"

Python favors unambiguity over readability, the __str__ call of a tuple calls the contained objects' __repr__, the "formal" representation of an object. Although the formal representation is harder to read than an informal one, it is unambiguous and more robust against bugs.

So much clearer
from blog

str is like toString. created so you can print the data
repr is like serialize, or pickle. How do i recreate this object if i need to do so using eval()

>>> import datetime

>>> now = datetime.datetime.now() 

>>> str(now)

'2015-04-04 20:51:31.766862'

>>> repr(now)

'datetime.datetime(2015, 4, 4, 20, 51, 31, 766862)'

>>mydate = eval(repr(now))

In a nutshell:

class Demo:

  def __repr__(self):

    return 'repr'

  def __str__(self):

    return 'str'



demo = Demo()

print(demo) # use __str__, output 'str' to stdout



s = str(demo) # __str__ is used, return 'str'

r = repr(demo) # __repr__ is used, return 'repr'



import logging

logger = logging.getLogger(logging.INFO)

logger.info(demo) # use __str__, output 'str' to stdout



from pprint import pprint, pformat

pprint(demo) # use __repr__, output 'repr' to stdout

result = pformat(demo) # use __repr__, result is string which value is 'str'

Understand __str__ and __repr__ intuitively and permanently distinguish them at all.

__str__ return the string disguised body of a given object for readable of eyes
__repr__ return the real flesh body of a given object (return itself) for unambiguity to identify.

See it in an example

In [30]: str(datetime.datetime.now())

Out[30]: '2017-12-07 15:41:14.002752'

Disguised in string form

As to __repr__

In [32]: datetime.datetime.now()

Out[32]: datetime.datetime(2017, 12, 7, 15, 43, 27, 297769)

Presence in real body which allows to be manipulated directly.

We can do arithmetic operation on __repr__ results conveniently.

In [33]: datetime.datetime.now()

Out[33]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521)

In [34]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521) - datetime.datetime(2

    ...: 017, 12, 7, 15, 43, 27, 297769)

Out[34]: datetime.timedelta(0, 222, 443752)

if apply the operation on __str__

In [35]: '2017-12-07 15:43:14.002752' - '2017-12-07 15:41:14.002752'

TypeError: unsupported operand type(s) for -: 'str' and 'str'

Returns nothing but error.

Another example.

In [36]: str('string_body')

Out[36]: 'string_body' # in string form



In [37]: repr('real_body')

Out[37]: "'real_body'" #its real body hide inside

Hope this help you build concrete grounds to explore more answers.

__repr__ is used everywhere, except by print and str when a __str__is defined