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

poo python 3

Question

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

<__main__.Foobar instance at 0x7ff2a18c>

¿Hay alguna manera de establecer 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.

Answer 1

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 el contenido de toda 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.

Answer 2

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

Answer 3

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 hay necesidad de escribir código para cada objeto.

Inspirado por this 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)

Answer 4

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.

Answer 5

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=%s b=%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á here !

Answer 6

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}

Answer 7

Una versión más bonita de la 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.

<class ''__main__.Element''>
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__)))

Answer 8

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.

Answer 9

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

Clase Adiprogrammer:

def __init__(self, name):
    self.company_name = name

def __str__(self):
    return "I am the Founder of Adiprogrammer!"

yash = Adiprogrammer ("Aaditya")

imprimir (yash)

Answer 10

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

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

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

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

Si no se define ningún 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))

Answer 11

>>> 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 pitón , 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.