# python – How to print instances of a class using print()?

## The Question :

585 people think this question is useful

I am learning the ropes in Python. When I try to print an object of class Foobar using the print() function, I get an output like this:

<__main__.Foobar instance at 0x7ff2a18c>



Is there a way I can set the printing behaviour (or the string representation) of a class and its objects? For instance, when I call print() on a class object, I would like to print its data members in a certain format. How to achieve this in Python?

If you are familiar with C++ classes, the above can be achieved for the standard ostream by adding a friend ostream& operator << (ostream&, const Foobar&) method for the class.

688 people think this answer is useful
>>> class Test:
...     def __repr__(self):
...         return "Test()"
...     def __str__(self):
...         return "member of Test"
...
>>> t = Test()
>>> t
Test()
>>> print(t)
member of Test



The __str__ method is what happens when you print it, and the __repr__ method is what happens when you use the repr() function (or when you look at it with the interactive prompt). If this isn’t the most Pythonic method, I apologize, because I’m still learning too – but it works.

If no __str__ method is given, Python will print the result of __repr__ instead. If you define __str__ but not __repr__, Python will use what you see above as the __repr__, but still use __str__ for printing.

141 people think this answer is useful

As Chris Lutz mentioned, this is defined by the __repr__ method in your class.

From the documentation of repr():

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.

Given the following class Test:

class Test:
def __init__(self, a, b):
self.a = a
self.b = b

def __repr__(self):
return "<Test a:%s b:%s>" % (self.a, self.b)

def __str__(self):
return "From str method of Test: a is %s, b is %s" % (self.a, self.b)



..it will act the following way in the Python shell:

>>> t = Test(123, 456)
>>> t
<Test a:123 b:456>
>>> print repr(t)
<Test a:123 b:456>
>>> print(t)
From str method of Test: a is 123, b is 456
>>> print(str(t))
From str method of Test: a is 123, b is 456



If no __str__ method is defined, print(t) (or print(str(t))) will use the result of __repr__ instead

If no __repr__ method is defined then the default is used, which is pretty much equivalent to..

def __repr__(self):
return "<%s instance at %s>" % (self.__class__.__name__, id(self))



62 people think this answer is useful

A generic way that can be applied to any class without specific formatting could be done as follows:

class Element:
def __init__(self, name, symbol, number):
self.name = name
self.symbol = symbol
self.number = number

def __str__(self):
return str(self.__class__) + ": " + str(self.__dict__)



And then,

elem = Element('my_name', 'some_symbol', 3)
print(elem)



produces

__main__.Element: {'symbol': 'some_symbol', 'name': 'my_name', 'number': 3}



31 people think this answer is useful

If you’re in a situation like @Keith you could try:

print(a.__dict__)



It goes against what I would consider good style but if you’re just trying to debug then it should do what you want.

13 people think this answer is useful

Just to add my two cents to @dbr’s answer, following is an example of how to implement this sentence from the official documentation he’s cited:

“[…] to return a string that would yield an object with the same value when passed to eval(), […]”

Given this class definition:

class Test(object):
def __init__(self, a, b):
self._a = a
self._b = b

def __str__(self):
return "An instance of class Test with state: a=%s b=%s" % (self._a, self._b)

def __repr__(self):
return 'Test("%s","%s")' % (self._a, self._b)



Now, is easy to serialize instance of Test class:

x = Test('hello', 'world')
print 'Object representation: ', repr(x)
print

y = eval(repr(x))
print 'Object representation: ', repr(y)
print



So, running last piece of code, we’ll get:

Human readable:  An instance of class Test with state: a=hello b=world
Object representation:  Test("hello","world")

Human readable:  An instance of class Test with state: a=hello b=world
Object representation:  Test("hello","world")



But, as I said in my last comment: more info is just here!

13 people think this answer is useful

A prettier version of response by @user394430

class Element:
def __init__(self, name, symbol, number):
self.name = name
self.symbol = symbol
self.number = number

def __str__(self):
return  str(self.__class__) + '\n'+ '\n'.join(('{} = {}'.format(item, self.__dict__[item]) for item in self.__dict__))

elem = Element('my_name', 'some_symbol', 3)
print(elem)



Produces visually nice list of the names and values.

<class '__main__.Element'>
name = my_name
symbol = some_symbol
number = 3



An even fancier version (thanks Ruud) sorts the items:

def __str__(self):
return  str(self.__class__) + '\n' + '\n'.join((str(item) + ' = ' + str(self.__dict__[item]) for item in sorted(self.__dict__)))



12 people think this answer is useful

You need to use __repr__. This is a standard function like __init__. For example:

class Foobar():
"""This will create Foobar type object."""

def __init__(self):
print "Foobar object is created."

def __repr__(self):
return "Type what do you want to see here."

a = Foobar()

print a



11 people think this answer is useful

For Python 3:

If the specific format isn’t important (e.g. for debugging) just inherit from the Printable class below. No need to write code for every object.

class Printable:
def __repr__(self):
from pprint import pformat
return "<" + type(self).__name__ + "> " + pformat(vars(self), indent=4, width=1)

# Example Usage
class MyClass(Printable):
pass

my_obj = MyClass()
my_obj.msg = "Hello"
my_obj.number = "46"
print(my_obj)



2 people think this answer is useful

There are already a lot of answers in this thread but none of them particularly helped me, I had to work it out myself, so I hope this one is a little more informative.

You just have to make sure you have parentheses at the end of your class, e.g:

print(class())



Here’s an example of code from a project I was working on:

class Element:
def __init__(self, name, symbol, number):
self.name = name
self.symbol = symbol
self.number = number
def __str__(self):
return "{}: {}\nAtomic Number: {}\n".format(self.name, self.symbol, self.number

class Hydrogen(Element):
def __init__(self):
super().__init__(name = "Hydrogen", symbol = "H", number = "1")



To print my Hydrogen class, I used the following:

print(Hydrogen())



Please note, this will not work without the parentheses at the end of Hydrogen. They are necessary.

Hope this helps, let me know if you have anymore questions.