What does !r do in str() and repr()?
Question: According to the [Python 2.7.12
documentation](https://docs.python.org/2/tutorial/inputoutput.html#fancier-
output-formatting):

> `!s` (apply `str()`) and `!r` (apply `repr()`) can be used to convert the
> value before it is formatted.
>  
>  
>     >>> import math
>     >>> print 'The value of PI is approximately {}.'.format(math.pi)
>     The value of PI is approximately 3.14159265359.
>     >>> print 'The value of PI is approximately {!r}.'.format(math.pi)
>     The value of PI is approximately 3.141592653589793.
>  

Interestingly, the converted value is the output of `repr()`, rather than
`str()`.

    
    
    >>> str(math.pi)
    '3.14159265359'
    >>> repr(math.pi)
    '3.141592653589793'
    

So what does "convert the value" mean here? Making it less human-readable?


Answer: In order to format something _in_ a string, a string representation of that
something must first be created. "convert the value" is basically talking
about how the string representation is to be constructed. In python, there are
two fairly natural choices to get a string representation of something ...
`str` and `repr`. `str` is generally a little more human friendly, `repr` is
generally more precise. Perhaps the [official
documentation](https://docs.python.org/3/reference/datamodel.html#object.__repr__)
is the best place to go looking for the difference:

> `object.__repr__(self)`  
>
>
>   * Called by the `repr()` built-in function to compute the “official”
> string representation of an object. 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.
> The return value must be a string object. If a class defines `__repr__()`
> but not `__str__()`, then `__repr__()` is also used when an “informal”
> string representation of instances of that class is required.
>
>   * This is typically used for debugging, so it is important that the
> representation is information-rich and unambiguous.
>
>

>
> `object.__str__(self)`  
>
>
>   * Called by str(object) and the built-in functions format() and print() to
> compute the “informal” or nicely printable string representation of an
> object. The return value must be a string object.
>
>   * This method differs from `object.__repr__()` in that there is no
> expectation that `__str__()` return a valid Python expression: a more
> convenient or concise representation can be used.
>
>   * The default implementation defined by the built-in type object calls
> `object.__repr__()`.
>
>

In `str.format`, `!s` chooses to use `str` to format the object whereas `!r`
chooses `repr` to format the value.

The difference can easily be seen with strings (as `repr` for a string will
include outer quotes).:

    
    
    >>> 'foo {}'.format('bar')
    'foo bar'
    >>> 'foo {!r}'.format('bar')
    "foo 'bar'"
    

What the difference between these two methods really depends critically on the
objects being formatted. For many objects (e.g. those that don't override the
`__str__` method), there will be no difference in the formatted output.

