python str, pour un objet

Tout en essayant de comprendre comment BeautifulSoup fonctionne, j'ai d'ailleurs appris la __str__ méthode (je suis nouveau sur python). Donc, si je n'ai pas tort alors la __str__ méthode contribue à façonner la manière dont la classe sera représentée si imprimé. Par exemple:

class Foo:
    def __str__(self):
        return "bar"

>>> x = Foo()
>>> print x
bar

Droit? Donc affirmer que j'ai raison, est-il possible de remplacer le __str__ méthode d'une liste de dictionnaires? Je veux dire que dans la classe Foo vous avez:

class Foo:
   def __init__(self):
      self.l = [{"Susan": ("Boyle", 50, "alive")}, {"Albert": ("Speer", 106, "dead")}]

Maintenant, est-il possible d'avoir le résultat suivant?

>>> x = Foo()
>>> print x.l
"Susan Boyle is 50 and alive. Albert Speer is 106 and dead."

MODIFIER

Considérant agf solution, comment puis-je accéder au dictionnaire une fois de plus? Je veux dire, si je définis __str__ méthode, puis apparemment je doit définir quelque chose d'autre pour récupérer le dictionnaire comme il est. Veuillez considérer l'exemple suivant:

class PClass(dict):
    def __str__(self):
        # code to return the result that I want 

class Foo:
    def __init__(self):
        self.l = PClass({"Susan": ["Boyle", ........ })

>>> x = Foo()
>>> print x.l 
# result that works great
>>> y = x.l["Susan"] # this would not work. How can I achieve it?

Pas sans sous-classement dict, pas.
Non, même si vous pouvez certainement la conception de votre Foo classe pour stocker les informations d'une manière qui permettrait d'impression. Vous ne pouvez pas modifier une liste de __str__ méthode; il est intégré.
Par ailleurs, si vous souhaitez en savoir plus sur __str__ et des méthodes similaires, je suggère la lecture par exemple, cet article. Ces méthodes sont appelées "magie" des membres de la ou des méthodes.
merci beaucoup je vais le lire tout de suite
Est-ce un cas d'utilisation de descripteurs?

OriginalL'auteur Shaokan | 2011-08-22

python

Vous avez besoin d'une classe de l'élément que vous êtes d'impression.

from itertools import chain

class PrintableList(list): # for a list of dicts
    def __str__(self):
        return '. '.join(' '.join(str(x) for x in
            chain.from_iterable(zip((item[0], 'is', 'and'), item[1])))
                for item in (item.items()[0] for item in self)) + '.'

class PrintableDict(dict): # for a dict
    def __str__(self):
        return '. '.join(' '.join(str(x) for x in
            chain.from_iterable(zip((item[0], 'is', 'and'), item[1])))
                for item in self.iteritems()) + '.'

class Foo:
   def __init__(self):
      self.d = PrintableDict({"Susan": ("Boyle", 50, "alive"), 
                              "Albert": ("Speer", 106, "dead")})

class Bar:
   def __init__(self):
      self.l = PrintableList([{"Susan": ("Boyle", 50, "alive")}, 
                              {"Albert": ("Speer", 106, "dead")}])

foo = Foo()
print self.d
bar = Bar()
print self.l

merci, cela résout mon cas 🙂
félicitations pour 10k par la route 🙂
Merci. J'ai perdu ma connexion internet pendant quelques minutes, mais maintenant, je fixe donc le __str__ fonctionne réellement pour l'exemple (non pas que ce qui compte)
s'il vous plaît pouvez-vous voir mon montage dans la question d'origine?
Vous avez besoin de regarder en arrière à votre question encore une fois :). Vous avez eu un liste des dictionnaires, de sorte que vous ne pouvez pas y accéder par le nom. Si vous souhaitez accéder, par leur nom, vous avez besoin pour rendre le tout un dictionnaire. Il n'a rien à voir avec la méthode de chaîne.

OriginalL'auteur agf

Une autre alternative est de remplacer __getattribute__, qui vous permet de personnaliser la façon dont les attributs sont retournés:

class Foo(object):
    def __init__(self):
        self.l = [{"Susan": ("Boyle", 50, "alive")}, {"Albert": ("Speer", 106, "dead")}]

    def __getattribute__(self, name):
        return PrintableList(l)
        attr = super(Foo, self).__getattribute__(name)
        items = sum([x.items() for x in attr], [])
        return ' '.join([' '.join([k, v[0], 'is', str(v[1]), 'and', v[2] + '.']) for k,v in items])

>>> f = Foo()
>>> print f.l
<<< Susan Boyle is 50 and alive. Albert Speer is 106 and dead.

C'est également une approche intéressante. Merci!
+1 que vous n'avez pas à définir une nouvelle classe et de se soucier de sous-classement et d'autres choses. Vous pouvez également utiliser une valeur par défaut -- toujours une bonne idée

OriginalL'auteur zeekay

Vous pouvez définir __str__ pour votre classe Foo pour revenir à ce que vous voulez:

class Foo():
    def __init__(self):
        self.l = [{"Susan": ("Boyle", 50, "alive")}, {"Albert": ("Speer", 106, "
dead")}]
    def __str__(self):
        ret_str = ""
        for d in self.l:
            for k in d:
                ret_str += "".join([k, " ", d[k][0], " is ", str(d[k][1]), " and
 ", d[k][2], ". "])
        return ret_str

foo = Foo()
print foo

résultats dans:

Susan Boyle est de 50 et vivant. Albert Speer est de 106 et de la mort.

OriginalL'auteur GreenMatt

Vous devez vous connecter pour publier un commentaire.