What is the meaning of %r?

What's the meaning of %r in the following statement?

print '%r' % (1)

I think I've heard of %s, %d, and %f but never heard of this.

Background:

In Python, there are two builtin functions for turning an object into a string: str vs. repr. str is supposed to be a friendly, human readable string. repr is supposed to include detailed information about an object's contents (sometimes, they'll return the same thing, such as for integers). By convention, if there's a Python expression that will eval to another object that's ==, repr will return such an expression e.g.

>>> print repr('hi')
'hi'  # notice the quotes here as opposed to...
>>> print str('hi')
hi

If returning an expression doesn't make sense for an object, repr should return a string that's surrounded by < and > symbols e.g. <blah>.

To answer your original question:

%s <-> str
%r <-> repr

In addition:

You can control the way an instance of your own classes convert to strings by implementing __str__ and __repr__ methods.

class Foo:

  def __init__(self, foo):
    self.foo = foo

  def __eq__(self, other):
    """Implements ==."""
    return self.foo == other.foo

  def __repr__(self):
    # if you eval the return value of this function,
    # you'll get another Foo instance that's == to self
    return "Foo(%r)" % self.foo

It calls http://docs.python.org/library/functions.html#repr">`repr()`</a> on the object and inserts the resulting string.

It prints the replacement as a string with repr().

Adding to the replies given above, '%r' can be useful in a scenario where you have a list with heterogeneous data type. Let's say, we have a list = [1, 'apple' , 2 , 'r','banana'] Obviously in this case using '%d' or '%s' would cause an error. Instead, we can use '%r' to print all these values.

The difference between %r and %s is, %r calls the repr() method and %s calls the str() method. Both of these are built-in Python functions.

The repr() method returns a printable representation of the given object. The str() method returns the "informal" or nicely printable representation of a given object.

In simple language, what the str() method does is print the result in a way which the end user would like to see:

name = "Adam"
str(name)
Out[1]: 'Adam'

The repr() method would print or show what an object actually looks like:

name = "Adam"
repr(name)
Out[1]: "'Adam'"

%s <=> str
%r <=> repr

%r calls repr() on the object, and inserts the resulting string returned by __repr__.

The string returned by __repr__ should be unambiguous and, if possible, match the source code necessary to recreate the object being represented.

A quick example:

class Foo:

    def __init__(self, foo):
        self.foo = foo


    def __repr__(self):
        return 'Foo(%r)' % self.foo

    def __str__(self):
        return self.foo

    
test = Foo('Text')

So,

in[1]: test
Out[1]: Foo('Text')


in[2]: str(test)
Out[2]: 'Text'

%s calls the __str()__ method of the selected object and replaces itself with the return value,

%r calls the __repr()__ method of the selected object and replaces itself with the return value.

See String Formatting Operations in the docs. Notice that %s and %d etc, might work differently to how you expect if you are used to the way they work in another language such as C.

In particular, %s also works well for ints and floats unless you have special formatting requirements where %d or %f will give you more control.

I read in "Learning Python the Hard Way", the author said that

> %r is the best for debugging, other formats are for displaying variables to users