¿Cómo puedo elegir una representación de cadena personalizada para una clase en sí (no instancias de la clase)?

Considere esta clase:

class foo(object):
    pass

La representación de cadena predeterminada se parece a esto:

>>> str(foo)
"<class '__main__.foo'>"

¿Cómo puedo hacer que esta pantalla sea una cadena personalizada?

_{Consulte ¿Cómo imprimir instancias de una clase usando print()? para la pregunta correspondiente sobre las instancias de la clase.}

_{De hecho, esta pregunta es realmente un caso especial de esa, porque en Python, las clases también son objetos que pertenecen a su propia clase, pero no es directamente obvio cómo aplicar el consejo, ya que la “clase de clases” predeterminada es pre -definido.}

Implementar __str__() o __repr__() en la metaclase de la clase.

class MC(type):
  def __repr__(self):
    return 'Wahaha!'

class C(object):
  __metaclass__ = MC

print(C)

Usar __str__ si te refieres a una cadena legible, usa __repr__ para representaciones inequívocas.

Editar: Versión de Python 3

class MC(type):
  def __repr__(self):
    return 'Wahaha!'

class C(object, metaclass=MC):
    pass


print(C)

class foo(object):
    def __str__(self):
        return "representation"
    def __unicode__(self):
        return u"representation"

Si tienes que elegir entre __repr__ o __str__ ve por el primero, como por defecto implementación __str__ llamadas __repr__ cuando no estaba definido.

Ejemplo de Vector3 personalizado:

class Vector3(object):
    def __init__(self, args):
        self.x = args[0]
        self.y = args[1]
        self.z = args[2]

    def __repr__(self):
        return "Vector3([{0},{1},{2}])".format(self.x, self.y, self.z)

    def __str__(self):
        return "x: {0}, y: {1}, z: {2}".format(self.x, self.y, self.z)

En este ejemplo, repr devuelve de nuevo una cadena que se puede consumir/ejecutar directamente, mientras que str es más útil como salida de depuración.

v = Vector3([1,2,3])
print repr(v)    #Vector3([1,2,3])
print str(v)     #x:1, y:2, z:3

La respuesta aprobada de Ignacio Vázquez-Abrams es bastante correcta. Sin embargo, es de la generación Python 2. Una actualización para el actual Python 3 sería:

class MC(type):
  def __repr__(self):
    return 'Wahaha!'

class C(object, metaclass=MC):
    pass

print(C)

Si desea un código que se ejecute tanto en Python 2 como en Python 3, el seis el módulo lo tiene cubierto:

from __future__ import print_function
from six import with_metaclass

class MC(type):
  def __repr__(self):
    return 'Wahaha!'

class C(with_metaclass(MC)):
    pass

print(C)

Finalmente, si tiene una clase que desea tener una representación estática personalizada, el enfoque basado en clases anterior funciona muy bien. Pero si tiene varios, tendría que generar una metaclase similar a MC para cada uno, y eso puede volverse tedioso. En ese caso, llevar su metaprogramación un paso más allá y crear una fábrica de metaclases hace que las cosas sean un poco más limpias:

from __future__ import print_function
from six import with_metaclass

def custom_class_repr(name):
    """
    Factory that returns custom metaclass with a class ``__repr__`` that
    returns ``name``.
    """
    return type('whatever', (type,), {'__repr__': lambda self: name})

class C(with_metaclass(custom_class_repr('Wahaha!'))): pass

class D(with_metaclass(custom_class_repr('Booyah!'))): pass

class E(with_metaclass(custom_class_repr('Gotcha!'))): pass

print(C, D, E)

huellas dactilares:

Wahaha! Booyah! Gotcha!

La metaprogramación no es algo que generalmente necesite todos los días, pero cuando lo necesita, ¡realmente da en el clavo!

Solo agregando a todas las buenas respuestas, mi versión con decoración:

from __future__ import print_function
import six

def classrep(rep):
    def decorate(cls):
        class RepMetaclass(type):
            def __repr__(self):
                return rep

        class Decorated(six.with_metaclass(RepMetaclass, cls)):
            pass

        return Decorated
    return decorate


@classrep("Wahaha!")
class C(object):
    pass

print(C)

salida estándar:

Wahaha!

Los lados negativos:

1. no puedes declarar C sin superclase (no class C:)
2. C instancias serán instancias de alguna derivación extraña, por lo que probablemente sea una buena idea agregar un __repr__ para las instancias también.

Debido a que necesita una metaclase para hacer esto, pero necesita que la metaclase en sí tenga un parámetro, puede hacerlo con una metaclase que capture el nombre a través del alcance léxico.

Encuentro esto un poco más fácil de leer/seguir que algunas de las alternativas.

class type_: pass

def create_type(name):
    # we do this so that we can print the class type out
    # otherwise we must instantiate it to get a proper print out
    class type_metaclass(type):
        def __repr__(self):
            return f'<{name}>'

    class actual_type(type_, metaclass=type_metaclass):
        pass
    return actual_type

my_type = create_type('my_type')

print(my_type)
# prints "<my_type>"

Otra respuesta, con:

• decorador
• tipos (por lo que mantiene autocompletar en IDE)
• funciona a partir de v3.10

import typing


class ClassReprMeta(type):
    def __repr__(self):
        attrs_str = ", ".join(
            f"{key}={getattr(self, key)}"
            for key in dir(self)
            if not key.startswith("_")
        )

        return f"{self.__name__}({attrs_str})"


T = typing.TypeVar("T")


def printable_class(cls: T) -> T:
    """Decorator to make a class object printable"""
    return ClassReprMeta(cls.__name__, cls.__bases__, dict(cls.__dict__))


@printable_class
class CONFIG:
    FIRST = 1
    SECOND = 2


print(CONFIG)  # CONFIG(FIRST=1, SECOND=2)