J'essaie de construire une classe qui hérite des méthodes de la liste de Python, mais aussi des choses supplémentaires sur le dessus ... il est probablement plus facile de montrer du code à ce stade ...
from collections import MutableSequence class HostList(MutableSequence): """A container for manipulating lists of hosts""" def __init__(self, data): super(HostList, self).__init__() if (data is not None): self._list = list(data) else: self._list = list() def __repr__(self): return "<{0} {1}>".format(self.__class__.__name__, self._list) def __len__(self): """List length""" return len(self._list) def __getitem__(self, ii): """Get a list item""" return self._list[ii] def __delitem__(self, ii): """Delete an item""" del self._list[ii] def __setitem__(self, ii, val): # optional: self._acl_check(val) return self._list[ii] def __str__(self): return str(self._list) def insert(self, ii, val): # optional: self._acl_check(val) self._list.insert(ii, val) def append(self, val): self.insert(len(self._list), val)
4 Réponses :
Utilisez Vous devriez vous retrouver avec quelque chose comme: p> isinstance code>
pour vérifier vos objets pour voir s'ils sont Instances de hôte code> et utilisez
Super code>
( par exemple super (hostlist, auto) .insert (...) code>) Pour utiliser la fonctionnalité de la liste
code>, plutôt que de le réimplanter vous-même.
Encore mieux, définissez une méthode statique as_host (x) code> qui renvoie
x code> s'il s'agit d'un hôte, sinon l'exception appropriée. Ensuite, les appels
Super code> deviennent une doublure.
Vous pouvez appeler la méthode code> de la liste code> à partir de votre méthode, avec super () code>. De cette façon, vous n'avez pas besoin de l'enflure avec les autres méthodes. P>
sauf si s'il y a une raison impérieuse pour que votre conteneur d'hostine d'hôte prend en charge complètement l'interface de conteneur mutable, je suggère d'utiliser un modèle A-un-un plutôt que IS-A. Vous aurez le fardeau supplémentaire de la consistance de type avec des opérations telles que la tranchée (renvoyer un conteneur d'hostlist plutôt qu'une liste). p>
Si vous pouvez éventuellement l'éviter, n'héritez pas de classes intégrées. (Vous peut em>, mais cela ne signifie pas que vous devrait em> sans raison vraiment convaincante) p>
Ces classes sont optimisées pour la vitesse et qui les hérite correctement assez fastidieuses, car vous finissez par avoir à remplacer presque tout. P>
héritage de collections.mutablesequence code> vous permet de mettre en œuvre quelques méthodes essentielles et d'obtenir une mise en œuvre robuste entièrement en vedette de l'API de séquence, sans toutes les bizarreries et les mises en garde qui viennent en héritage de
Liste code>. p>
Great Point +1 ... Après quelques luttes, je l'ai eu en train de travailler avec collections.Mutablequence code> ... merci!
Self = [] Code> Ne fait pas ce que vous pensez.
super (hostlist, auto) .__ init __ (auto) code> ferait le tour. Ce que votre code est réaffecté la variable (argument)
auto code> à
[] code>.
__ getItem __ code> retournera un objet de liste si une tranche est spécifiée. Vous pouvez modifier l'initialisateur vers
__ init __ (auto, l = aucun) code> qui utilisera une liste si fournie. Ensuite, dans
__ getItem __ code>, si II est un objet SLICE, puis renvoyez
hostlist (Self._List [II]) code>
En outre, vous n'avez pas nécessairement de définir la méthode
() code>, comme
mutablaisequence code> le fait déjà pour vous, à condition que vous avez défini l'insertion
() < / Code> Méthode (check hg.python.org/cpython/ Fichier / 3.4 / LIB / _Collections_abc.py # L711 Pour plus d'informations).
Pycharas me dit que vous avez manqué quelques méthodes abstraites:
__ iter __ () code> et
__ contient __ () code>.
Je ne suis pas sûr de comprendre pourquoi il se plaint ... STDLIB ''s
MutaBleSequence code> hérit de
séquence () code>
, qui inclut le__ iter __ () code> et
__ contient __ () code> méthodes.