__getitem__ 마법 방법은 색인

Question

고장 나는이 (강하게 간체) 예와 유사한 래퍼 클래스를 (대신 정의의) 지정 이 함수를 호출하여 최적화하고 하나의 함수 호출을 제거 할 수 있다고 생각했습니다.

class wrap(object): 
    def __init__(self): 
     self._data = range(10) 
     self.__getitem__ = self._data.__getitem__ 

그러나 후자의 버전으로 print w[2] 라인

TypeError: 'wrap' object does not support indexing

.

방법에 대한 직접 호출, 즉, print w.__getitem__(2)가, 두 경우 모두에서 작동 ...

왜 할당 버전은 색인을 허용하지 않습니다

?

Answer 1

특수 메서드 (본질적으로 양쪽 끝에 밑줄이 두 개인 경우)를 클래스에 정의해야합니다. 특수 메서드에 대한 internal lookup procedure은 인스턴스 dict를 완전히 건너 뜁니다. 무엇보다도, 이것은 당신이

class Foo(object): 
    def __repr__(self): 
     return 'Foo()' 

사용자가 정의한 __repr__ 방법은 repr(Foo)에 대한 Foo의 경우에 사용되지 않고 할 경우에 그렇다.

Answer 2

모든 유형에 대해 새 클래스를 만들어 실제로이를 해결할 수 있습니다. 이 기능을 투명하게 사용하려면 __new__이 필요합니다.

import weakref 


class BigWrap(object): 
    def __new__(cls, wrapped): 
     wrapped_type = type(wrapped) 
     print('Wrapping %s (%s)' % (wrapped, wrapped_type)) 
     # creates a new class, aka a new type 
     wrapper_class = type( # new_class = type(class name, base classes, class dict) 
      '%s_%s_%d' % (cls.__name__, wrapped_type.__name__, id(wrapped)), # dynamic class name 
      (
       cls, # inherit from wrap to have all new methods 
       wrapped_type, # inherit from wrap_type to have all its old methods 
      ), 
      { 
       '__getitem__': wrapped.__getitem__, # overwrite __getitem__ based on wrapped *instance* 
       '__new__': wrapped_type.__new__, # need to use wrapped_type.__new__ as cls.__new__ is this function 
      }) 
     cls._wrappers[wrapped_type] = wrapper_class # store wrapper for repeated use 
     return cls._wrappers[wrapped_type](wrapped) 

    # self is already an instance of wrap_<type(wrapped)> 
    def __init__(self, wrapped): 
     self.__wrapped__ = wrapped 

---

초기 "솔루션"

import weakref 
class wrap(object): 
    _wrappers = weakref.WeakValueDictionary() # cache wrapper classes so we don't recreate them 

    def __new__(cls, wrapped): 
    wrapped_type = type(wrapped) 
    print('Wrapping %s (%s)' % (wrapped, wrapped_type)) 
    try: 
     return object.__new__(cls._wrappers[wrapped_type]) # need to use object.__new__ as cls.__new__ is this function 
    except KeyError: 
     print('Creating Wrapper %s (%s)' % (wrapped, wrapped_type)) 
    # creates a new class, aka a new type 
    wrapper_class = type( # class name, base classes, class dict 
     '%s_%s' % (cls.__name__, wrapped_type.__name__), # dynamic class name 
     (cls,), # inherit from wrap to have all its method 
     {'__getitem__': wrapped_type.__getitem__}) # overwrite __getitem__ based on wrapped class 
    cls._wrappers[wrapped_type] = wrapper_class # store wrapper for repeated use 
    return cls._wrappers[wrapped_type](wrapped) 

    # self is already an instance of wrap_<type(wrapped)> 
    def __init__(self, wrapped): 
    self._data = wrapped 

것은 그러나 조심! 이렇게하면 래핑 된 클래스 '__getitem__을 사용하여 원하는대로 할 수 있습니다. 그러나 이것이 항상 의미있는 것은 아닙니다! 예를 들어, list.__getitem__은 실제로 CPython의 CAPI에 내장되며 다른 유형에는 적용 할 수 없습니다.

foo = wrap([1,2,3]) 
print(type(foo)) # __main__.wrap_list 
foo[2] 
--------------------------------------------------------------------------- 
TypeError         Traceback (most recent call last) 
<ipython-input-31-82791be7104b> in <module>() 
----> 1 foo[2] 

TypeError: descriptor '__getitem__' for 'list' objects doesn't apply to 'wrap_list' object