Python 매직 메소드 - 사용자 정의 시퀀스에 대한 자세한 설명

사용자 정의 시퀀스의 관련 매직 메서드를 사용하면 우리가 생성하는 클래스가 시퀀스의 특성을 갖게 되므로 Python의 내장 시퀀스(dict, tuple, list, string 등)처럼 사용할 수 있습니다.

이 기능을 구현하려면 Python의 관련 프로토콜을 따라야 합니다. 이른바 합의는 합의된 내용이다. 예를 들어, 클래스에서 반복을 구현하려면 __iter__ 및 next(python3.x의 __new__)라는 두 가지 매직 메서드를 구현해야 합니다. __iter__는 일반적으로 self 자체를 반환하는 next 메서드를 구현해야 하는 객체를 반환해야 합니다. next 메소드는 호출될 때마다 다음 요소를 반환해야 하며 요소가 소진되면 StopIteration 예외를 트리거해야 합니다.

사실 for 루프의 핵심은 객체의 __iter__ 메서드를 먼저 호출한 다음 __iter__ 메서드에서 반환된 객체의 다음 메서드를 반복적으로 호출하고 StopIteration 예외가 트리거되면 중지하고 예외를 처리하는 것입니다. 내부적으로는 예외가 발생하지 않는다는 것을 알 수 있습니다.

이 관계는 이전 기사의 매직 메소드를 검토하면 많은 내장 함수에서 얻은 결과가 해당 매직 메소드의 반환 값임을 알 수 있습니다.

관련 매직 메소드는 다음과 같습니다.

•__len__(자신)

• 컨테이너의 길이를 반환합니다. 가변 컨테이너와 불변 컨테이너 모두 이를 구현해야 하며 이는 프로토콜의 일부입니다.

•__getitem__(self, key)

• 항목에 액세스할 때 self[key]를 사용하여 생성되는 동작을 정의합니다. 이는 또한 변경 가능 및 불변 컨테이너에 대한 프로토콜의 일부입니다. 키의 유형이 잘못된 경우 TypeError가 발생하고, 키에 적합한 값이 없으면 KeyError가 발생합니다.

•__setitem__(자체, 키, 값)

• 항목에 값이 할당될 때 self[key] = value를 사용하여 생성되는 동작을 정의합니다. 이는 또한 변경 가능한 컨테이너 프로토콜의 일부입니다. 또한 해당 상황에서는 KeyError 및 TypeError도 생성됩니다.

•__delitem__(self, key)

• 항목이 삭제될 때 발생하는 동작을 정의합니다. (예: del self[키]). 이는 변경 가능한 컨테이너 프로토콜의 일부입니다. 잘못된 키를 사용하는 경우 적절한 예외가 발생해야 합니다.

•__iter__(자체)

•컨테이너 반복자를 반환합니다. 특히 내장 iter() 메서드가 호출되고 for x in 컨테이너: 메서드가 루프에 사용되는 경우 많은 경우 반복자가 반환됩니다. 반복자는 객체 자체이며 self를 반환하는 __iter__ 메서드를 정의해야 합니다.

•__reversed__(자체)

• reversed() 호출 시 동작을 구현합니다. 시퀀스의 반대 버전이 반환되어야 합니다. 목록이나 튜플과 같이 순서가 지정된 경우에만 구현하세요.

•__contains__(본체, 항목)

• 멤버 존재 여부를 테스트하기 위해 호출할 때와 호출하지 않을 때의 동작을 정의합니다. 이는 프로토콜에서 요구되는 것은 아니지만 사용자 고유의 요구 사항에 따라 구현할 수 있습니다. __contains__가 정의되지 않은 경우 Python은 시퀀스를 반복하고 필요한 값이 발견되면 True를 반환합니다.

•__missing__(자기, 열쇠)

•dict의 하위 클래스에서 사용됩니다. 사전에 존재하지 않는 키에 액세스할 때 발생하는 동작을 정의합니다. (예를 들어 사전 d가 있고 "george"가 사전의 키가 아닐 때 d["george"]를 사용하는 경우 d.__missing__("george")가 호출됩니다.

다음은 코드 예입니다.

class Foo(object):
  def __init__(self, key, value):
    self.key = []
    self.value = []
    self.key.append(key)
    self.value.append(value)

  def __len__(self):
    return len(self.key)

  def __getitem__(self, item):
    try:
      __index = self.key.index(item)
      return self.value[__index]
    except ValueError:
      raise KeyError('can not find the key')

  def __setitem__(self, key, value):
    if key not in self.key:
      self.key.append(key)
      self.value.append(value)
    else:
      __index = self.key.index(key)
      self.value[__index] = value

  def __delitem__(self, key):
    try:
      __index = self.key.index(key)
      del self.key[__index]
      del self.value[__index]
    except ValueError:
      raise KeyError('can not find the key')

  def __str__(self):
    result_list = []
    for index in xrange(len(self.key)):
      __key = self.key[index]
      __value = self.value[index]
      result = __key, __value
      result_list.append(result)
    return str(result_list)

  def __iter__(self):
    self.__index = 0
    return self

  def next(self):
    if self.__index == len(self.key):
      self.__index = 0
      raise StopIteration()
    else:
      __key = self.key[self.__index]
      __value = self.value[self.__index]
      result = __key, __value
      self.__index += 1
      return result

  def __reversed__(self):
    __result = self.value[:]
    __result.reverse()
    return __result

  def __contains__(self, item):
    if item in self.value:
      return True
    else:
      return False

여기에서는 사전을 시뮬레이트하는 클래스를 만듭니다. 이 클래스는 내부적으로 두 개의 목록을 유지합니다. Key는 키 저장을 담당하고, 두 목록은 인덱스를 통해 일대일로 대응합니다. 사전을 시뮬레이션하는 목적.

먼저 __len__ 메서드를 살펴보겠습니다. 프로토콜에 따르면 이 메서드는 컨테이너의 길이를 반환해야 합니다. 왜냐하면 이 클래스는 두 목록의 길이가 같아야 하도록 설계되었기 때문입니다. 반환된 목록의 길이는 동일합니다. 여기서는 키의 길이를 반환하도록 선택했습니다.

그리고 __getitem__ 메소드가 있습니다. 이 메소드는 ['scolia']일 때 a.__getitem__('scolia')를 ​​호출합니다. 즉, 이 메서드는 요소 획득을 정의합니다. 여기서 내 생각은 먼저 키 목록에 내장된 인덱스를 찾은 다음 인덱스를 사용하여 값 목록에서 해당 요소를 찾은 다음 반환하는 것입니다. 그런 다음 이를 사전으로 위장하기 위해 발생할 수 있는 ValueError(항목이 키 목록에 없을 때 트리거되는 예외)를 포착하고 사전이 키를 찾을 수 없을 때 이를 KeyError로 위장했습니다.

이론적으로 위의 두 가지 방법만 구현하면 불변 컨테이너를 얻을 수 있습니다. 하지만 만족스럽지 못해서 계속 확장을 하게 됐어요.

__setitem__(self, key, value)方法定义了 a['scolia'] = 'good' 这种操作时的行为，此时将会调用a.__setitem__('scolia', 'good') 因为是绑定方法，所以self是自动传递的，我们不用理。这里我也模拟了字典中对同一个键赋值时会造成覆盖的特性。这个方法不用返回任何值，所以return语句也省略了。

__delitem__(self, key)方法定义了del a['scolia'] 这类操作时候的行为，里面的‘scolia'就作为参数传进去。这里也进行了异常的转换。

只有实现里以上四个方法，就可以当做可变容器来使用了。有同学可能发现并没有切片对应的魔法方法，而事实上，我也暂时没有找到先，这部分内容先搁着一边。

接下来的 __str__ 是对应于 str() 函数，在类的表示中会继续讨论，这里是为了 print 语句好看才加进去的，因为print语句默认就是调用str()函数。

__iter__和next方法在开头的时候讨论过了，这里是为了能让其进行迭代操作而加入的。

__reversed__(self)方法返回一个倒序后的副本，这里体现了有序性，当然是否需要还是要看个人。

__contains__实现了成员判断，这里我们更关心value列表中的数据，所以判断的是value列表。该方法要求返回布尔值。

下面是相应的测试：

a = Foo('scolia', 'good')
a[123] = 321
a[456] = 654
a[789] = 987
print a
del a[789]
print a
for x, y in a:
  print x, y
print reversed(a)
print 123 in a
print 321 in a

•__missing__(self, key)

class Boo(dict):
  def __new__(cls, *args, **kwargs):
    return super(Boo, cls).__new__(cls)

  def __missing__(self, key):
    return 'The key(%s) can not be find.'% key

测试：

b = Boo()
b['scolia'] = 'good'
print b['scolia']
print b['123']

 

当然你也可以在找不到 key 的时候触发异常，具体实现看个人需求。

以上这篇python魔法方法-自定义序列详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。