Python __str__ et listes

En Java, si j'appelle List.toString (), il appellera automatiquement la méthode toString () sur chaque objet à l'intérieur de List. Par exemple, si ma liste contient les objets o1, o2 et o3, list.toString () ressemblerait à ceci:

"[" + o1.toString() + ", " + o2.toString() + ", " + o3.toString() + "]"

Existe-t-il un moyen d'obtenir un comportement similaire en Python? J'ai implémenté une méthode __str __ () dans ma classe, mais lorsque j'imprime une liste d'objets, en utilisant:

print 'my list is %s'%(list)

ça ressemble à quelque chose comme ça:

[<__main__.cell instance at 0x2a955e95f0>, <__main__.cell instance at 0x2a955e9638>, <__main__.cell instance at 0x2a955e9680>]

comment puis-je faire en sorte que python appelle automatiquement mon __str__ pour chaque élément de la liste (ou dict d'ailleurs)?

L'appel de chaîne sur une liste python appelle la __repr__méthode sur chaque élément à l'intérieur. Pour certains articles, __str__et __repr__sont les mêmes. Si vous voulez ce comportement, faites:

def __str__(self):
    ...
def __repr__(self):
    return self.__str__()

Vous pouvez utiliser une compréhension de liste pour générer une nouvelle liste avec chaque élément str () 'd automatiquement:

print([str(item) for item in mylist])

Deux choses simples que vous pouvez faire, utiliser la mapfonction ou utiliser une compréhension.

Mais cela vous donne une liste de chaînes, pas une chaîne. Vous devez donc également joindre les chaînes ensemble.

s= ",".join( map( str, myList ) )

ou

s= ",".join( [ str(element) for element in myList ] )

Ensuite, vous pouvez imprimer cet objet de chaîne composite.

print 'my list is %s'%( s )

Selon ce que vous souhaitez utiliser cette sortie, peut __repr__-être peut-être plus approprié:

import unittest

class A(object):
    def __init__(self, val):
        self.val = val

    def __repr__(self):
        return repr(self.val)

class Test(unittest.TestCase):
    def testMain(self):
        l = [A('a'), A('b')]
        self.assertEqual(repr(l), "['a', 'b']")

if __name__ == '__main__':
    unittest.main()

Je suis d'accord avec la réponse précédente sur l'utilisation de la compréhension de liste pour ce faire, mais vous pouvez certainement cacher cela derrière une fonction, si c'est ce qui fait flotter votre bateau.

def is_list(value):
    if type(value) in (list, tuple): return True
    return False

def list_str(value):
    if not is_list(value): return str(value)
    return [list_str(v) for v in value]

Juste pour le plaisir, j'ai créé list_str () récursivement str () tout ce qui est contenu dans la liste.

Quelque chose comme ça?

a = [1, 2 ,3]
[str(x) for x in a]
# ['1', '2', '3']

Cela devrait suffire.

Lors de l'impression de listes ainsi que d'autres classes de conteneurs, les éléments contenus seront imprimés en utilisant __repr__, car il __repr__est destiné à être utilisé pour la représentation d'objet interne. Si nous appelons: help(object.__repr__)cela nous dira:

Help on wrapper_descriptor:

__repr__(self, /)
    Return repr(self).

Et si nous l'appelons, help(repr)il affichera:

Help on built-in function repr in module builtins:

repr(obj, /)
    Return the canonical string representation of the object.

    For many object types, including most builtins, eval(repr(obj)) == obj.

Si __str__est implémenté pour un objet et __repr__ne l'est pas repr(obj), la sortie par défaut est générée, comme print(obj)si aucune de celles-ci n'est implémentée.

Donc, le seul moyen est de mettre en œuvre __repr__pour votre classe. Une façon possible de le faire est la suivante:

class C:           
    def __str__(self):
        return str(f"{self.__class__.__name__} class str ")

C.__repr__=C.__str__       
ci = C()    


print(ci)       #C class str 
print(str(ci))  #C class str 
print(repr(ci)) #C class str 

La sortie que vous obtenez est simplement le nom du module de l'objet, le nom de la classe, puis l'adresse mémoire en hexadécimal car la __repr__fonction n'est pas remplacée.

__str__est utilisé pour la représentation sous forme de chaîne d'un objet lors de l'utilisation de print. Mais puisque vous imprimez une liste d'objets et que vous n'effectuez pas une itération sur la liste pour appeler la strméthode pour chaque élément, il imprime la représentation des objets.

Pour que la __str__fonction soit appelée, vous devez faire quelque chose comme ceci:

'my list is %s' % [str(x) for x in myList]

Si vous remplacez la __repr__fonction, vous pouvez utiliser la méthode d'impression comme vous l'étiez auparavant:

class cell:
    def __init__(self, id):
        self.id = id
    def __str__(self):
        return str(self.id) # Or whatever
    def __repr__(self):
        return str(self) # function invoked when you try and print the whole list.

myList = [cell(1), cell(2), cell(3)]
'my list is %s' % myList

Ensuite, vous obtiendrez " my list is [1, 2, 3]" comme sortie.