interpolazione stringa di pitone

Question

Cosa potrebbe generare il seguente comportamento?

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

Ma:

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

Maggiori informazioni:

• mia msg oggetto ereditato da unicode.
• i metodi __str__/__unicode__/__repr__ sono stati sovrascritti per restituire la stringa 'my message'.
• l'oggetto msg è stato inizializzato con la stringa 'another message'.
• questo è in esecuzione su Python 2.5
• la variabile msg non è stato cambiato tra i test
• questo è in realtà reale doctest che sta realmente dando questi risultati.

vorrei una soluzione che corrisponde a questo doctest, con il minimo sforzo (soprattutto intorno alla successione):

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

Grazie per tutti i suggerimenti.

Non mi sento questo aiuterà più, ma per i lettori più curiosi (e pythonist avventurosi), ecco l'attuazione dell'oggetto:

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) 

questo modo creiamo il msg oggetto:

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

Zope versione dei pacchetti e il codice usati sono:

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

EDIT INFORMAZIONI:

• aggiunto/aggiornato i nomi dei metodi che sono stati sovrascritto
• aggiunto qualche informazione in più (versione di Python, e informazioni minori)
• ha aggiornato alcune informazioni errate (la classe di `msg` è basata sulla classe` unicode` e non `basestring`)
• aggiunto l'implementazione effettiva ione della classe utilizzata

Answer 1

Aggiornamento 2: Si prega di trovare la risposta originale, compreso un semplice esempio di una classe esibendo il comportamento descritto dal PO, sotto la barra orizzontale. Per quanto mi è stato in grado di supporre nel corso della mia inchiesta sulle fonti di Python (v. 2.6.4):

Il file Include/unicodeobject.h contiene quanto segue alle linee (n.436-7 nella mia (un po 'vecchio) checkout):

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

Questo è utilizzato in tutto il luogo nel codice di formattazione, che, per quanto posso dire, significa che durante la formattazione di stringhe, qualsiasi oggetto che eredita da unicode verrà raggiunto in modo che il suo buffer di stringa unicode possa essere utilizzato direttamente, senza chiamare alcun metodo Python. Che è buono per quanto riguarda le prestazioni, ne sono sicuro (e molto in linea con la congettura di Juergen in un commento su questa risposta).

Per la domanda dell'OP, questo probabilmente significa che far funzionare le cose come l'OP vorrebbe che fossero possibili solo se qualcosa come l'idea della classe wrapper di Anurag Uniyal è accettabile per questo particolare caso d'uso. Se non lo è, l'unica cosa che mi viene in mente ora è di avvolgere oggetti di questa classe in str/unicode ovunque siano interpolati in una stringa ... ugh. (Spero sinceramente mi manca solo una soluzione più pulita che qualcuno indicherà in un minuto!)

---

(Aggiornamento: Questo è stato inviato circa un minuto prima che il PO compreso il codice della sua classe, ma lo lascio comunque (1) per la congettura/tentativo iniziale di una spiegazione al di sotto del codice, (2) per un semplice esempio di come produrre questo comportamento (Anurag Uniyal ne ha fornito un altro chiamando il costruttore unicode direttamente, al contrario di via super), (3) nella speranza di poter modificare in seguito qualcosa per aiutare l'OP nell'ottenere il comportamento desiderato.)

Ecco un esempio di una classe che in realtà funziona come quello che il PO descrive (Python 2.6.4, che fa produrre un deprecazione avvertimento - /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 paio di interazioni in 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 

Apparentemente stringa di interpolazione considera questo oggetto come un esempio di unicode (chiamando direttamente l'unicode attuazione __str__), mentre le altre funzioni trattano come un esempio di Foo. In che modo ciò accade internamente e perché funziona così e se si tratta di un bug o di una funzionalità, davvero non lo so.

Per quanto riguarda come risolvere l'oggetto dell'Op ... Bene, come faccio a sapere senza vedere il suo codice ??? Dammi il codice e prometto di pensarci! Ok, ci sto pensando ... Nessuna idea finora.

Answer 2

Così problema è di classe come a qualcosa di seguito si comporta stranamente

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 

questa stampa

my message 
my message 
another message 

io non sono sicuro perché questo accade o come risolvere il problema, ma un tentativo molto grezzo avvolgendo msg, ma non sono sicuro che vi aiuterà nel problema del PO

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 

uscita:

my message 
my message 
my message 

Answer 3

Penso che il problema sia che si sta tentando di estendere un built-in. I metodi Magic __ non vengono richiamati per i builtin.Penso che si dovrà fare una sorta di avvolgente e-delega, come questo (non testato) (forse Anurag mi ha battuto al punzone):

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) 

Update 1 - sembra che __ metodi fare ottenere chiamato per sottoclassi di comandi incorporati

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

Quindi c'è sicuramente una certa incoerenza in corso ...