¿Cómo imprimir objetos de clase usando print ()?

Estoy aprendiendo las cuerdas en Python. Cuando bash imprimir un objeto de la clase Foobar usando la función print() , obtengo una salida como esta:

  

¿Hay alguna manera de configurar el comportamiento de impresión (o la representación de cadena ) de una clase y sus objetos ? Por ejemplo, cuando llamo a print() en un objeto de clase, me gustaría imprimir sus miembros de datos en un formato determinado. ¿Cómo lograr esto en Python?

Si está familiarizado con las clases de C ++, se puede lograr lo anterior para el ostream estándar agregando el friend ostream& operator << (ostream&, const Foobar&) un friend ostream& operator << (ostream&, const Foobar&) para la clase.

 >>> class Test: ... def __repr__(self): ... return "Test()" ... def __str__(self): ... return "member of Test" ... >>> t = Test() >>> t Test() >>> print(t) member of Test 

El método __str__ es lo que sucede cuando lo imprime, y el método __repr__ es lo que sucede cuando usa la función repr() (o cuando lo mira con el indicador interactivo). Si este no es el método más python , me disculpo, porque todavía estoy aprendiendo, pero funciona.

Si no se proporciona el método __str__ , Python imprimirá el resultado de __repr__ en __repr__ lugar. Si define __str__ pero no __repr__ , Python usará lo que ve arriba como __repr__ , pero seguirá usando __str__ para imprimir.

Como mencionó Chris Lutz , esto está definido por el método __repr__ en su clase.

De la documentación de repr() :

Para muchos tipos, esta función intenta devolver una cadena que produciría un objeto con el mismo valor cuando se pasa a eval() ; de lo contrario, la representación es una cadena encerrada entre paréntesis angulares que contiene el nombre del tipo de objeto. con información adicional que a menudo incluye el nombre y la dirección del objeto. Una clase puede controlar lo que esta función devuelve para sus instancias definiendo un __repr__() .

Dada la siguiente prueba de clase:

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

… actuará de la siguiente manera en el shell de Python:

 >>> t = Test(123, 456) >>> t  >>> print repr(t)  >>> 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 

Si no se define el método __str__ , print(t) (o print(str(t)) ) usará el resultado de __repr__

Si no se __repr__ método __repr__ , entonces se usa el valor predeterminado, que es bastante equivalente a ..

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

Una forma genérica que se puede aplicar a cualquier clase sin un formato específico se podría hacer de la siguiente manera:

 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__) 

Y entonces,

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

produce

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

Solo para agregar mis dos centavos a la respuesta de @dbr, a continuación hay un ejemplo de cómo implementar esta oración de la documentación oficial que ha citado:

“[…] para devolver una cadena que produciría un objeto con el mismo valor cuando se pasa a eval (), […]”

Dada esta definición de clase:

 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=%sb=%s" % (self._a, self._b) def __repr__(self): return 'Test("%s","%s")' % (self._a, self._b) 

Ahora, es fácil serializar la instancia de la clase Test :

 x = Test('hello', 'world') print 'Human readable: ', str(x) print 'Object representation: ', repr(x) print y = eval(repr(x)) print 'Human readable: ', str(y) print 'Object representation: ', repr(y) print 

Entonces, ejecutando el último fragmento de código, obtendremos:

 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") 

Pero, como dije en mi último comentario: ¡más información está aquí !

Necesitas usar __repr__ . Esta es una función estándar como __init__ . Por ejemplo:

 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 

Si estás en una situación como @Keith, puedes probar:

 print a.__dict__ 

Va en contra de lo que consideraría un buen estilo, pero si solo estás tratando de depurar, debería hacer lo que quieras.

Para Python 3:

Si el formato específico no es importante (por ejemplo, para la depuración) simplemente herede de la clase de impresión a continuación. No es necesario escribir código para cada objeto.

Inspirado por esta respuesta.

 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) 

Una versión más bonita de respuesta por @ usuario394430

 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) 

Produce una bonita lista visual de los nombres y valores.

  name = my_name symbol = some_symbol number = 3 

Una versión aún más elegante (gracias Ruud) ordena los elementos:

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

Ya hay muchas respuestas en este hilo, pero ninguna de ellas me ayudó particularmente, tuve que resolverlo yo mismo, así que espero que esta sea un poco más informativa.

Solo debes asegurarte de tener paréntesis al final de tu clase, por ejemplo:

 print(class()) 

Aquí hay un ejemplo de código de un proyecto en el que estaba trabajando:

 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") 

Para imprimir mi clase de Hidrógeno, utilicé lo siguiente:

 print(Hydrogen()) 

Tenga en cuenta que esto no funcionará sin los paréntesis al final de hidrógeno. Son necesarios.

Espero que esto ayude, avísame si tienes más preguntas.

simplemente use el método especial “__str__” dentro de su clase. Por ej.

Adiprogtwigdor de clase:

 def __init__(self, name): self.company_name = name def __str__(self): return "I am the Founder of Adiprogrammer!" 

yash = Adiprogrammer (“Aaditya”)

imprimir (yash)

Nada de esto realmente me ayuda. No quiero cambiar la definición de mi objeto original solo para imprimir. IOW: No quiero usar herencia o incluso poner estas funciones str en mi clase. Eso significaría que tendría que cambiar todas las clases que quiero depurar. En su lugar, prefiero tener una Clase e imprimir todo el contenido de la clase. IOW: tener algo como

 class Address( ): __init__( self ) self.mName = 'Joe' self.mAddress = '123 Easy Street' a = Address() print a or print printClass( a ) 

Esto imprimiría algo como:

  Class Address contains: mName = 'Joe' mAddress = '123 Easy Street' 

Agradable y simple en el uso y una idea donde no tengo que cambiar las definiciones de los objetos originales. Si tengo que crear una pequeña función que deconstruya el objeto, estaría bien con eso. Ya que simplemente puedo llamar a la función que sabe cómo hacerlo. Puedo usarlo en línea sin cambiar la definición de las clases originales.