替换__str__方法，在列表中的对象蟒蛇

Question

这看来似乎应该是简单的：

我想要一个 list 像任何其他的 list, ，除非它有一个不同的 .__str__ 法。

1. 试图设置的 object.__str__ = foo 结果，在一个只读错误
2. 尝试类 list 意味着你需要的一些方式将现有的 list 一个实例子类。这需要复制的所有属性手动(一个巨大的痛苦)，或者以某种方式复制他们的所有自动的，这我不知道如何做。
3. 尝试写一个包装的 list 对象意味着我必须要找出一些的方式发送的所有邮件到包裹的对象除了 .__str__ 我处理我自己的方法。不知道如何做到这一点。

任何替代办法或解决方案#2或3极大的赞赏。谢谢！

Answer 1

这个解决方案的工作没有一个包装。和工作，如果你加入两个名单的增加。任何操作，修改名单本身的工作，如预期的那样。只有职能返回复的列表，如：排序，reveresed将返回的地蟒蛇的名单是好的。排和反向另一方面工作的清单本身并将保留类型。

class myList(list):
    def __new__(cls, data=None):
        obj = super(myList, cls).__new__(cls, data)
        return obj

    def __str__(self):
        return 'myList(%s)' % list(self)

    def __add__(self, other):
        return myList(list(self) + list(other))

>>> l = myList(range(5))
>>> print l
myList([0, 1, 2, 3, 4])
>>> print l + [1, 2]
myList([0, 1, 2, 3, 4, 1, 2])
>>> l.sort()
>>> print l
myList([0, 1, 2, 3, 4])

Answer 2

如果你想要复盖 __str__ 对于其它的容器(例如， tuple)，可以利用多个继承：

class PrettyStr(object):
    def __str__(self):
        ret = ''

        if isinstance(self, (list, tuple)):
            ret = ''.join(str(elem) for elem in self)
        else:
            pass  # handle other types here

        return ret


class MyList(PrettyStr, list):
    pass


class MyTuple(PrettyStr, tuple):
    pass


if __name__ == "__main__":
    print MyList([1, 2, 3, 4])
    print MyTuple((1, 2, 3, 4))

Answer 3

你可以延长的列表类和复盖：

class myList(list):
  def __str__(self):
    # do something
    return "something"

编辑：删除不正确答案的一部分，建议动态代替 __str__ 名单上的对象，这是不允许在执行蟒蛇的名单。

Answer 4

我是一个Java程序员，但我认为这是你想要什么(测试python2.6):

>>> class myList(list):
...   def __str__(self):
...     return "aaa"
...
>>> def myListWrapper(list):
...   return myList(list)
...
>>> a = [1, 2, 3]
>>> type(a)
<type 'list'>
>>> b = myListWrapper(a)
>>> type(b)
<class '__main__.myList'>
>>> print(a)
[1, 2, 3]
>>> print(b)
aaa

Answer 5

class MyList(list):
     def __str__(self):
             return "foo"

str(MyList([1, 2, 3]))

'foo'

str(MyList(list([1, 2, 3])))

'foo'

我早些时候的评论作一回答。正如你可以看到列表中接受的任何顺序在其构造。

Answer 6

这就提出了问题：为什么你想要复盖__str__方法？

不它能更好地为创建一个类封你的对象？

class MyContainer(object):
    def __init__(self, list):
        self.containedList = list

    def __str__(self):
        print('All hail Python')

这样你就不必担心转换你的对象，或复制这些属性，或任何责任。(通过的方式，如何昂贵的是列表(longlist)?它是一个聪明的副本，或者一个愚蠢的"让我们重新建立一个列表目的是从一个迭代?")

如果在某一点上看，它看起来复杂，难以做你想做的，它可能意味着你这样做是错误的：p

Answer 7

多关于包装的清单？

>>> class StrList(object):
    def __init__(self, data=None):
        self._data = data or []
    def __str__(self):
        return "StrList!"
    def __getattr__(self, attr):
        if attr == "_data":
            return self.__dict__[attr]
        return getattr(self._data, attr)
    def __setattr__(self, key, val):
        if key == "_data":
            self.__dict__[key] = val
        else:
            setattr(self._data, key, val)
    def __getitem__(self, index):
        return self._data[index]
    def __setitem__(self, index, value):
        self._data[index] = value


>>> l = StrList(range(3))
>>> print l
StrList!
>>> l[0]
0
>>> for x in l:
    print x


0
1
2
>>> l[0] = "spam"
>>> l.append("egg")
>>> print list(l)
['spam', 1, 2, 'egg']
>>> 

Answer 8

Ex = ["a", 2, 4] #our_list
Ex(-1) = "xuxu_beleza" #the_name_of_your_list(index) = new_item 
Print(Ex) 
["a", 2, "xuxu_beleza"] #our_new_list

**list[index] = new_item**