Implémentation d'une sous-table (affichage dans une table): conception d'une relation de classe

Question

J'utilise Python 3, mais la question n'est pas vraiment liée au langage spécifique. J'ai class Table qui implémente une table avec une clé primaire. Une instance de cette classe contient les données réelles (qui sont très volumineuses).

Je souhaite autoriser les utilisateurs à créer une sous-table en fournissant un filtre pour les lignes de la table. Je ne veux pas copier la table, donc je prévoyais de garder dans la sous-table juste le sous-ensemble des clés primaires de la table parent.

De toute évidence, la sous-table est juste une vue dans la table parent; cela changera si la table parent change, deviendra invalide si la table parent est détruite, et perdra certaines de ses lignes si elles sont supprimées de la table parente. [EDIT: pour clarifier, si la table parente est modifiée, je me fiche de ce qui arrive à la sous-table; tout comportement est correct.]

Comment connecter les deux classes? Je pensais:

class Subtable(Table): 
    def __init__(self, table, filter_function): 
    # ... 

Mon hypothèse était que Subtable garde l'interface de Table, sauf légèrement les méthodes remplace héritées juste pour vérifier si la ligne est Est-ce une bonne mise en œuvre.? Le problème est, je ne sais pas comment initialiser l'instance Subtable étant donné que je ne veux pas copier l'objet de table qui lui est passé. Est-ce même possible?

Aussi je pensais donner class Table une méthode d'instance qui renvoie Subtable instance; mais cela crée une dépendance de Table sur Subtable, et je suppose qu'il est préférable d'éviter?

Answer 1

Je vais utiliser ce qui suit (j'ai omis beaucoup de méthodes telles que genre, qui fonctionnent très bien dans cet arrangement, la gestion des erreurs aussi omis):

class Table: 
    def __init__(self, *columns, pkey = None): 
     self.pkey = pkey 
     self.__columns = columns 
     self.__data = {} 

    def __contains__(self, key): 
     return key in self.__data 

    def __iter__(self): 
     for key in self.__order: 
      yield key 

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

    def items(self): 
     for key in self.__order: 
      yield key, self.__data[key] 

    def insert(self, *unnamed, **named): 
     if len(unnamed) > 0: 
      row_dict = {} 
      for column_id, column in enumerate(self.__columns): 
       row_dict[column] = unnamed[column_id] 
     else: 
      row_dict = named 
     key = row_dict[self.pkey] 
     self.__data[key] = row_dict 

class Subtable(Table): 
    def __init__(self, table, row_filter): 
     self.__order = [] 
     self.__data = {} 
     for key, row in table.items(): 
      if row_filter(row): 
       self.__data[key] = row 

Essentiellement, je copie primaire clés uniquement et créer des références aux données qui leur sont liées. Si une ligne de la table parent est détruite, elle existera toujours dans la sous-table. Si une ligne est modifiée dans la table parent, elle est également modifiée dans la sous-table. C'est très bien, car mes exigences étaient "tout ce qui se passe quand la table parent est modifiée".

Si vous constatez des problèmes avec cette conception, faites le moi savoir s'il vous plaît.