Python: может ли экземпляр класса оценить любой тип?

Question

Класс может действовать как строка через свой метод __str__ или как функцию через свой метод __call__. Может ли он действовать, как, скажем, список или кортеж?

class A (object): 
    def __???__ (self): 
     return (1, 2, 3) 

>>> a = A() 
>>> a * 3 
(1, 2, 3, 1, 2, 3, 1, 2, 3) 

EDIT ...

Вот лучший пример, чтобы помочь прояснить выше.

class Vector (object): 
    def __init__ (self): 
     self.vec = (1,2,3) 
    def __???__ (self): 
     # something like __repr__; non-string 
     return self.vec 

class Widget (object): 
    def __init__ (self): 
     self.vector = Vector() 

>>> w = Widget() 
>>> w.vector 
(1, 2, 3) # not a string representation (at least, before being repr'd here) 

В принципе, я хочу что-то вроде __repr__, которая не возвращает строку, а возвращает кортеж (или список), когда я просто ссылаться на имя, указывающее на экземпляр вектора, но я не хочу терять остальные возможности в экземпляре, такие как доступ к другим свойствам и методам. Я также не хочу использовать w.vector.vec, чтобы получить данные. Я хочу, чтобы вектор работал как атрибут кортежа w, но все же мог делать что-то вроде w.vector.whatever() или переопределять __mul__, чтобы я мог масштабировать вектор через w.vector * 5. Возможное?

Answer 1

В зависимости от того, что ваша цель, вы можете создать класс, который наследуется от встроенных классов как list или tuple:

>>> class A(tuple): 
...  def speak(self): 
...   print "Bark!" 
... 
>>> a = A((1,2,3)) # extra parens needed to distinguish single tuple arg from 3 scalar args 
>>> a * 3 
(1, 2, 3, 1, 2, 3, 1, 2, 3) 
>>> a.speak() 
Bark! 

Учитывая, что ваш случай использования в векторе, подклассифицирующий кортеж вполне может сделать трюк.

import math 

class Vector(tuple): 
    def magnitude(self): 
     return math.sqrt(self[0]*self[0]+self[1]*self[1]+self[2]*self[2]) 

Answer 2

Класс не действует как строка при вызове str. Он создает и возвращает NEW-строковый объект. В основном, когда вы звоните str(something) на объекте, это то, что происходит на самом деле:

a = str(someObject) 

a = someObject.__str__() 

Таким образом, функция str в принципе можно рассматривать как сделать это:

def str(variable): 
    return variable.__str__() 

То же самое верно, когда вы звоните list() , tuple(), set() и так далее. Если то, что я думаю, что вы спрашиваете, правильно:

tuple(), list() и set() все называют __iter__() метод класса, так что вы хотите сделать это:

class MyClass(object): 
    ... 
    def __iter__(self): 
     ... 
     return myIterable 

Answer 3

Для конкретного поведение в вашем примере (A*3 дает три конкатенированные копии данных в A), которые вы хотите реализовать оператором __mul__().

Например, они эквивалентны:

>>> a = [1,2,3] 
>>> a*3 
[1, 2, 3, 1, 2, 3, 1, 2, 3] 
>>> a.__mul__(3) 
[1, 2, 3, 1, 2, 3, 1, 2, 3] 
>>> 

Вообще, если вы хотите реализовать тип последовательности вы должны реализовать все operations defined for sequence types. Вы должны определить -

• каких A[3] средства (__getitem__(), __setitem__())
• каких A[1:10] средства (__getslice__())
• каких for item in A: средства (__iter__())

и так далее.

Вот полный список методов, определенных на list с:

>>> pprint.pprint(dict(list.__dict__)) 
{'__add__': <slot wrapper '__add__' of 'list' objects>, 
'__contains__': <slot wrapper '__contains__' of 'list' objects>, 
'__delitem__': <slot wrapper '__delitem__' of 'list' objects>, 
'__delslice__': <slot wrapper '__delslice__' of 'list' objects>, 
'__doc__': "list() -> new empty list\nlist(iterable) -> new list initialized from iterable's items", 
'__eq__': <slot wrapper '__eq__' of 'list' objects>, 
'__ge__': <slot wrapper '__ge__' of 'list' objects>, 
'__getattribute__': <slot wrapper '__getattribute__' of 'list' objects>, 
'__getitem__': <method '__getitem__' of 'list' objects>, 
'__getslice__': <slot wrapper '__getslice__' of 'list' objects>, 
'__gt__': <slot wrapper '__gt__' of 'list' objects>, 
'__hash__': None, 
'__iadd__': <slot wrapper '__iadd__' of 'list' objects>, 
'__imul__': <slot wrapper '__imul__' of 'list' objects>, 
'__init__': <slot wrapper '__init__' of 'list' objects>, 
'__iter__': <slot wrapper '__iter__' of 'list' objects>, 
'__le__': <slot wrapper '__le__' of 'list' objects>, 
'__len__': <slot wrapper '__len__' of 'list' objects>, 
'__lt__': <slot wrapper '__lt__' of 'list' objects>, 
'__mul__': <slot wrapper '__mul__' of 'list' objects>, 
'__ne__': <slot wrapper '__ne__' of 'list' objects>, 
'__new__': <built-in method __new__ of type object at 0x1E1DACA8>, 
'__repr__': <slot wrapper '__repr__' of 'list' objects>, 
'__reversed__': <method '__reversed__' of 'list' objects>, 
'__rmul__': <slot wrapper '__rmul__' of 'list' objects>, 
'__setitem__': <slot wrapper '__setitem__' of 'list' objects>, 
'__setslice__': <slot wrapper '__setslice__' of 'list' objects>, 
'__sizeof__': <method '__sizeof__' of 'list' objects>, 
'append': <method 'append' of 'list' objects>, 
'count': <method 'count' of 'list' objects>, 
'extend': <method 'extend' of 'list' objects>, 
'index': <method 'index' of 'list' objects>, 
'insert': <method 'insert' of 'list' objects>, 
'pop': <method 'pop' of 'list' objects>, 
'remove': <method 'remove' of 'list' objects>, 
'reverse': <method 'reverse' of 'list' objects>, 
'sort': <method 'sort' of 'list' objects>}