Python __str__ e listas

Em Java, se eu chamar List.toString (), ele chamará automaticamente o método toString () em cada objeto dentro da Lista. Por exemplo, se minha lista contiver objetos o1, o2 e o3, list.toString () seria algo assim:

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

Existe uma maneira de obter um comportamento semelhante em Python? Implementei um método __str __ () em minha classe, mas quando imprimo uma lista de objetos, usando:

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

parece algo assim:

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

como posso fazer com que o python chame meu __str__ automaticamente para cada elemento dentro da lista (ou dict para esse assunto)?

Chamar string em uma lista python chama o __repr__método em cada elemento interno. Para alguns itens, __str__e __repr__são iguais. Se você deseja esse comportamento, faça:

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

Você pode usar uma compreensão de lista para gerar uma nova lista com cada item str () 'd automaticamente:

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

Duas coisas fáceis que você pode fazer, usar a mapfunção ou usar uma compreensão.

Mas isso dá a você uma lista de strings, não uma string. Portanto, você também precisa juntar as cordas.

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

ou

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

Em seguida, você pode imprimir este objeto de string composto.

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

Dependendo da finalidade para a qual você deseja usar essa saída, talvez __repr__seja mais apropriado:

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()

Eu concordo com a resposta anterior sobre o uso de compreensões de lista para fazer isso, mas você certamente poderia esconder isso atrás de uma função, se é isso que faz seu barco flutuar.

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]

Apenas por diversão, fiz list_str () recursivamente str () tudo contido na lista.

Algo assim?

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

Isso deve bastar.

Ao imprimir listas, bem como outras classes de contêineres, os elementos contidos serão impressos usando __repr__, porque __repr__deve ser usado para representação de objetos internos. Se ligarmos: help(object.__repr__)ele nos dirá:

Help on wrapper_descriptor:

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

E se chamarmos help(repr), a saída será:

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.

Se __str__for implementado para um objeto e __repr__não for repr(obj), produzirá a saída padrão, assim como print(obj)quando nenhum desses for implementado.

Portanto, a única maneira é implementar __repr__para sua classe. Uma maneira possível de fazer isso é:

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 

A saída que você está obtendo é apenas o nome do módulo do objeto, o nome da classe e o endereço da memória em hexadecimal como o __repr__ função não é substituída.

__str__é usado para a representação de string de um objeto ao usar imprimir. Mas como você está imprimindo uma lista de objetos, e não iterando a lista para chamar o strmétodo para cada item, ele imprime a representação dos objetos.

Para ter a __str__função invocada, você precisa fazer algo assim:

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

Se você substituir a __repr__função, poderá usar o método de impressão como fazia antes:

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

Então você obterá " my list is [1, 2, 3]" como sua saída.