Die damit verbundenen magischen Methoden benutzerdefinierter Sequenzen ermöglichen es den von uns erstellten Klassen, die Eigenschaften von Sequenzen zu haben, sodass sie genau wie die in Python integrierten Sequenzen (Dikt, Tupel, Liste, Zeichenfolge usw.) verwendet werden können.
Wenn Sie diese Funktion implementieren möchten, müssen Sie die entsprechenden Protokolle von Python befolgen. Bei der sogenannten Vereinbarung handelt es sich um einen vereinbarten Inhalt. Wenn Sie beispielsweise die Iteration in einer Klasse implementieren möchten, müssen Sie zwei magische Methoden implementieren: __iter__, next (__new__ in python3.x). __iter__ sollte ein Objekt zurückgeben, das die nächste Methode implementieren muss, die normalerweise self selbst zurückgibt. Die nächste Methode muss bei jedem Aufruf das nächste Element zurückgeben und die StopIteration-Ausnahme auslösen, wenn die Elemente erschöpft sind.
Tatsächlich besteht der Kern der for-Schleife darin, zuerst die __iter__-Methode des Objekts aufzurufen, dann wiederholt die nächste Methode des von der __iter__-Methode zurückgegebenen Objekts aufzurufen, anzuhalten, wenn die StopIteration-Ausnahme ausgelöst wird, und die Ausnahme zu behandeln intern sehen wir also, dass keine Ausnahme ausgelöst wird.
Diese Beziehung ähnelt einer Schnittstelle. Wenn Sie die magischen Methoden in den vorherigen Artikeln überprüfen, können Sie feststellen, dass die von vielen integrierten Funktionen erhaltenen Ergebnisse die Rückgabewerte der entsprechenden magischen Methoden sind.
Die folgenden magischen Methoden sind verwandt:
•__len__(selbst)
• Gibt die Länge des Containers zurück. Sowohl veränderliche als auch unveränderliche Container müssen es implementieren, es ist Teil des Protokolls.
•__getitem__(self, key)
• Definieren Sie das Verhalten, das durch die Verwendung von self[key] beim Zugriff auf ein Element erzeugt wird. Dies ist auch Teil des Protokolls für veränderliche und unveränderliche Container. Ein TypeError wird ausgelöst, wenn der Schlüssel vom falschen Typ ist; ein KeyError wird ausgelöst, wenn der Schlüssel keinen geeigneten Wert hat.
•__setitem__(self, key, value)
• Definieren Sie das Verhalten, das durch die Verwendung von self[key] = value erzeugt wird, wenn einem Element ein Wert zugewiesen wird. Dies ist auch Teil des Mutable-Container-Protokolls. Darüber hinaus werden in entsprechenden Situationen auch KeyError und TypeError generiert.
•__delitem__(self, key)
• Definieren Sie das Verhalten, das auftritt, wenn ein Element gelöscht wird. (z. B. del self[key]). Dies ist Teil des veränderlichen Containerprotokolls. Wenn Sie einen ungültigen Schlüssel verwenden, muss eine entsprechende Ausnahme ausgelöst werden.
•__iter__(self)
•Gibt einen Container-Iterator zurück. In vielen Fällen wird ein Iterator zurückgegeben, insbesondere wenn die integrierte iter()-Methode aufgerufen wird und wenn die for x in container:-Methode für eine Schleife verwendet wird. Iteratoren sind selbst Objekte und müssen eine __iter__-Methode definieren, die self zurückgibt.
•__umgekehrt__(selbst)
• Implementieren Sie das Verhalten, wenn reversed() aufgerufen wird. Die umgekehrte Version der Sequenz sollte zurückgegeben werden. Implementieren Sie es nur, wenn die Sequenz geordnet ist, beispielsweise eine Liste oder ein Tupel.
•__contains__(self, item)
• Definiert das Verhalten beim Ein- und Nichteinrufen, um zu testen, ob ein Mitglied existiert. Dies ist vom Protokoll nicht vorgeschrieben, Sie können es aber nach Ihren eigenen Anforderungen umsetzen. Wenn __contains__ nicht definiert ist, iteriert Python über die Sequenz und gibt True zurück, wenn der erforderliche Wert gefunden wird.
•__missing__(self, key)
•Es wird in Unterklassen von dict verwendet. Es definiert das Verhalten, das auftritt, wenn auf einen Schlüssel zugegriffen wird, der nicht im Wörterbuch vorhanden ist. (Wenn ich zum Beispiel ein Wörterbuch d habe und d["george"] verwendet wird, wenn „george“ kein Schlüssel im Wörterbuch ist, wird d.__missing__("george") aufgerufen.)
Hier ist ein Codebeispiel:
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 FalseHier erstellen wir eine Klasse, die ein Wörterbuch simuliert. Der Schlüssel ist für die Speicherung von Schlüsseln verantwortlich, und der Wert ist für die Speicherung von Werten verantwortlich Zweck der Simulation eines Wörterbuchs.
Werfen wir zunächst einen Blick auf die Methode __len__, da diese Methode theoretisch die Länge des Containers zurückgeben muss. Die Länge aller zurückgegebenen Listen ist gleich. Hier wähle ich die Rückgabe der Schlüssellänge.
Dann gibt es noch die Methode __getitem__. Diese Methode ruft a.__getitem__('scolia') auf, wenn a['scolia']. Mit anderen Worten, diese Methode definiert die Erfassung von Elementen. Meine Idee besteht darin, zuerst den in der Schlüsselliste erstellten Index zu finden, dann den Index zu verwenden, um das entsprechende Element in der Werteliste zu finden, und es dann zurückzugeben. Um es dann weiter als Wörterbuch zu tarnen, habe ich den möglicherweise ausgelösten ValueError abgefangen (die Ausnahme, die ausgelöst wird, wenn das Element nicht in der Schlüsselliste enthalten ist) und ihn als KeyError getarnt, wenn das Wörterbuch den Schlüssel nicht finden kann.
Theoretisch können Sie einen unveränderlichen Container erhalten, solange die beiden oben genannten Methoden implementiert sind. Aber ich fühlte mich unzufrieden und expandierte weiter.
__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魔法方法-自定义序列详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。
