Заменить __str__ метод на объект списка в Python

Question

Это кажется, что это должно быть просто:

Я хочу list, как и любой другой list, за исключением того, что имеет другой .__str__ метод.

1. Попытка установить object.__str__ = foo результатов в ошибке только для чтения
2. Пытаюсь подкласс list означает, что необходимо каким-то образом преобразовать существующий list к экземпляру подкласса. Для этого требуется либо копирование всех атрибутов вручную (огромная боль), либо как-то копирование их автоматически, что я не знаю, как это сделать.
3. Попытка написать обертку вокруг объекта list означает, что мне нужно выяснить способ отправки всех сообщений обернутому объекту, кроме .__str__, который я обрабатываю своим методом. Не знаю, как это сделать.

Любые альтернативы или решения # 2 или # 3 очень ценятся. Благодаря!

Answer 1

Это решение работает без обертки. И работает, если вы присоедините два списка, добавив. Любая операция, которая модифицирует сам список, будет работать должным образом. Только функции, возвращающие копию списка, например: sorted, reveresed, возвращают собственный список python, который является прекрасным. сортировка и реверс, с другой стороны, работают в самом списке и сохраняют тип.

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

Вы можете расширить класс списка и заменить его:

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

Edit: убрана неправильную часть ответа, который предложил динамически заменяющего __str__ на объект списка, который не допускается в реализации списков Python ,

Answer 3

Я программист Java, но я думаю, что это то, что вы хотите (проверено с Python 2.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 4

Как насчет упаковки список?

>>> 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 5

Что вызывает вопрос: почему вы хотите переопределить метод __str__?

Не было бы лучше создать класс для инкапсуляции вашего объекта?

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

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

Таким образом, вам не придется беспокоиться о преобразовании объекта или копирования атрибутов, или вообще. (кстати, насколько дорогой MyList (longlist)? Это интеллектуальная копия или немой «давайте воссоздать объект списка из итерабельного?»)

Если в какой-то момент вам будет сложно делать то, что вы пытаетесь это сделать, это может означать, что вы делаете это неправильно: p

Answer 6

Если вы хотите переопределить __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 7

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

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

'Foo'

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

'Foo'

Мои предыдущие комментарии в ответ. Как вы можете видеть, MyList принимает любую последовательность в своем конструкторе.

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