Generic dictionary

[Thorsten Kampe]

* Peter Otten (Sun, 20 Nov 2016 10:43:01 +0100)
> 
> Thorsten Kampe wrote:
> > 
> > I'd like to extend the dictionary class by creating a class that acts
> > like a dictionary if the class is instantiated with a dictionary and
> > acts like a "dictitem" ([(key1, value1), (key2, value2), ...]) if
> > instantiated with a list (that is dictitem).
> > 
> > The code (see extract at bottom) works well but it contains a lot of
> > "if this is a dictionary then do as a dictionary already does"
> > boilerplate code". How can I "inherit"(?)/"subclass"(?)/derive from
> > dict so I don't have to write the code for the dictionary case?
> 
> Hm.
> 
> def GenericDict(dict_or_items):
>     if isinstance(dict_or_items, dict):
>         return dict(dict_or_items)
>     else:
>         return SimpleGenericDictWithOnlyTheFalseBranchesImplemented(
>             dict_or_items
>         )

That would be a kind of factory function for the class?
 
> > ```
> > class GenericDict:
> >     """
> >     a GenericDict is a dictionary or a list of tuples (when the keys
> >     are not hashable)
> >     """
> >     def __init__(inst, generic_dict):
> >         inst._generic = generic_dict
> > 
> >     def __getitem__(inst, key):
> >         if isinstance(inst._generic, dict):
> >             return inst._generic[key]
> >         else:
> >             return inst.values()[inst.keys().index(key)]
> 
> It's not obvious why you'd ever want that. What's the use case?

The use case is an Equivalence class which creates a {invariant(x): 
[x, y, z] ...} dictionary. Since the Equivalence class should accept 
all kinds of key functions, I have to make sure that lists (which are 
not hashable), etc. can be handled as keys.

Treating a list of tuples as a substitute for a dictionary is a well 
established idiom (think list(dict.items()) and dict()).

The GenericDict class allows the Equivalence class to be agnostic 
regarding the underlying data structure. It tries to create a 
dictionary and if that fails uses a dictitem. All method calls are 
the same because that's handled by GenericDict.

Thorsten