cadena de python interpolación

Question

¿Qué podría generar el siguiente comportamiento?

>>> print str(msg) 
my message 
>>> print unicode(msg) 
my message 

Pero:

>>> print '%s' % msg 
another message 

Más información:

• mi objetivo msg se hereda de unicode.
• los métodos __str__/__unicode__/__repr__ se anularon los métodos para devolver la cadena 'my message'.
• el objeto msg se inicializó con la cadena 'another message'.
• esto se está ejecutando en Python 2.5
• la variable msg no fue cambiado entre las pruebas
• Esto es realmente verdadero doctest que está realmente dando a estos resultados.

me gustaría una solución que coincida con este doctest, con un mínimo esfuerzo (especialmente alrededor de la herencia real):

>>> print '%s' % msg 
my message 

Gracias por todas las sugerencias.

no siento que esto ayudará más, pero para los lectores curiosos (y pythonist aventurero), aquí está la implementación del objeto:

class Message(zope.i18nmessageid.Message): 

    def __repr__(self): 
     return repr(zope.i18n.interpolate(self.default, self.mapping)) 

    def __str__(self): 
     return zope.i18n.interpolate(self.default, self.mapping) 

    def __unicode__(self): 
     return zope.i18n.interpolate(self.default, self.mapping) 

Esto es como creamos msg objeto:

>>> msg = Message('another message', 'mydomain', default='my message') 

Zope paquetes de la versión y el código utilizado son:

• zope.i18n-3.4.0 (interpolation() method code)
• zope.i18nmessageid-3.4.3 (Message class code)

EDITAR INFORMACIÓN:

• añadido/modificado los nombres de los métodos que se han anulado
• añade algo más de información (versión pitón, e información menor)
• actualizó alguna información incorrecta (la clase de `msg` se basa en la clase` unicode` y no `basetring`)
• agregó la implementación real ion de la clase utilizada

Answer 1

Actualización 2: Por favor, encontrar la respuesta original, incluyendo un simple ejemplo de una clase que presenta el comportamiento descrito por el OP, debajo de la barra horizontal. En cuanto a lo que pude suponer en el curso de mi investigación sobre las fuentes de Python (v 2.6.4):

El archivo Include/unicodeobject.h contiene lo siguiente en las líneas (nos.436-7 en mi (algo antigua) de pago):

#define PyUnicode_AS_UNICODE(op) \            
     (((PyUnicodeObject *)(op))->str) 

Esto se utiliza por todo el lugar en el código de formato, que, por lo que yo puedo decir, significa que durante el formateo de cadenas, cualquier objeto que hereda de unicode se alcanzará para que su búfer de cadena unicode se pueda usar directamente, sin llamar a ningún método de Python. Lo cual es bueno en lo que respecta al rendimiento, estoy seguro (y muy en línea con la conjetura de Juergen en un comentario sobre esta respuesta).

Para la pregunta del OP, esto probablemente signifique que hacer que las cosas funcionen de la manera en que el OP les gustaría solo puede ser posible si algo como la idea de la clase contenedora de Anurag Uniyal es aceptable para este caso de uso particular. Si no es así, lo único que viene a mi mente ahora es envolver objetos de esta clase en str/unicode donde sea que se interpongan en una cadena ... ugh. (Espero sinceramente acabo me falta una solución más limpia, que alguien va a señalar en un minuto!)

---

(Actualización: Este fue publicada alrededor de un minuto antes de la OP incluido el código de su clase, pero lo dejo aquí de todos modos (1) para la conjetura/intento inicial de una explicación debajo del código, (2) para un ejemplo simple de cómo producir este comportamiento (Anurag Uniyal ya ha proporcionado otro que llama al constructor unicode directamente, a diferencia de super), (3) con la esperanza de poder editar posteriormente algo para ayudar al OP a obtener el comportamiento deseado.)

Este es un ejemplo de una clase que en realidad funciona como lo describe el OP (Python 2.6.4, lo hace producir una advertencia de desaprobación - /usr/bin/ipython:3: DeprecationWarning: object.__init__() takes no parameters):

class Foo(unicode): 
    def __init__(self, msg): 
     super(unicode, self).__init__(msg) 
    def __str__(self): return 'str msg' 
    def __repr__(self): return 'repr msg' 
    def __unicode__(self): return u'unicode msg' 

Un par de interacciones en IPython:

In [12]: print(Foo("asdf")) 
asdf 

In [13]: str(Foo("asdf")) 
Out[13]: 'str msg' 

In [14]: print str(Foo("asdf")) 
-------> print(str(Foo("asdf"))) 
str msg 

In [15]: print(str(Foo("asdf"))) 
str msg 

In [16]: print('%s' % Foo("asdf")) 
asdf 

al parecer cadena de interpolación trata este objeto como una instancia de unicode (llamando directamente a la implementación de unicode__str__), mientras que las otras funciones tratan como una instancia de Foo. Cómo esto sucede internamente y por qué funciona así y si es un error o una característica, realmente no lo sé.

En cuanto a cómo solucionar el objeto del OP ... Bueno, ¿cómo podría saber sin ver su código ??? ¡Dame el código y prometo pensarlo! Ok, estoy pensando en ello ... No tengo ideas hasta el momento.

Answer 2

Así problema es clase como a algo más adelante se comporta extrañamente

class Msg(unicode): 
    def __init__(self, s): 
     unicode.__init__(self, s) 

    __unicode__ = __repr__ = __str__ = lambda self: "my message" 

msg = Msg("another message") 
print str(msg) 
print unicode(msg) 
print "%s"%msg 

este imprime

my message 
my message 
another message 

No estoy seguro de por qué sucede esto o cómo solucionarlo, pero un intento muy crudo envolviendo msg, pero no estoy seguro que le ayudará en la solución de OP

class MsgX(object): 
    def __init__(self, s): 
     self._msg = Msg(s) 

    __unicode__ = __repr__ = __str__ = lambda self: repr(self._msg) 

msg = MsgX("another message") 
print str(msg) 
print unicode(msg) 
print "%s"%msg 

de salida:

my message 
my message 
my message 

Answer 3

Creo que su problema es que está tratando de ampliar un built-in. Los métodos Magic __ no reciben llamadas para builtins.Creo que tendrá que hacer algún tipo de envoltura-and-delegado, como esto (no probado) (tal vez Anurag me ganó de mano):

class Message(object): 

    def __init__(self, strvalue, domain, default='my message'): 
     self.msg = zope.i18nmessageid.Message(strvalue,domain,default) 

    def __getattr__(self,attr): 
     return getattr(self.msg,attr) 

    def __repr__(self): 
     return repr(zope.i18n.interpolate(self.msg.default, self.msg.mapping)) 

    def __str__(self): 
     return zope.i18n.interpolate(self.msg.default, self.msg.mapping) 

    def __unicode__(self): 
     return zope.i18n.interpolate(self.msg.default, self.msg.mapping) 

Actualización 1 - parece que __ métodos hacer ser llamado para subclases de órdenes internas

>>> class Z(int): 
... def __add__(self,other): return self*other 
... def __str__(self): return "***" 
... 
>>> a = Z(100) 
>>> a + 2 
200 
>>> a 
100 
>>> str(a) 
'***' 
>>> "%s" % a 
'***' 

Así que no hay duda alguna inconsistencia pasando ...