On Sun, 20 Nov 2016 08:27 pm, 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).
I'm not sure exactly what you are trying to accomplish here. You want a
single class that sometimes behaves like a dict, and sometimes behaves like
a list? Not just any list, but specifically a list of tuples of two items.
Frankly, that sounds... weird. Generally speaking, classes don't behave
differently according to how they are created. Consider:
float(123) # int argument
float("123") # str argument
The object you get back is the same, regardless of whether the class was
instantiated from an int or a str. That's a general principle of Object
Oriented Programming: an object's behaviour should depend on *what it is*,
not where it came from.
> 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?
class MyDict(dict):
pass
inherits from dict. But that won't do what you want, since a dict doesn't
behave anything like a list of tuples. You'll have to over-ride
*everything*, filling your code with horrible stuff like this:
class MyDict(dict):
def __init__(self, *args, **kwargs):
super(MyDict, self).__init__(*args, **kwargs)
# Decide whether to act like a list or a dict.
if args and isinstance(args[0], dict):
self._act_like_dict = True
else:
self._act_like_dict = False
def __getitem__(self, key_or_index):
if self._act_like_dict:
# treat like a key
super(MyDict, self).__getitem__(key_or_index)
else:
# treat like an index
tmp = list(self.values())
return tmp[key_or_index]
def update(self, *args, **kwargs):
if self._act_like_dict:
super(MyDict, self).update(*args, **kwargs)
else:
raise TypeError('list doesn't support update')
def sort(self, *args, **kwargs):
if self._act_like_dict:
raise TypeError('dict doesn't support sort')
else:
# somehow re-implement list sorting for something
# which is like a dict
...
Etc. It would be a monstrous pain in the posterior to write, and confusing
to use. Are you sure you want this? The whole concept of a class that
behaves differently depending on how you create it feels to me like that
movie "The Fly".
I think that a better strategy would be to reconsider. Why not just write
your code to accept *either* a dict, or a list of tuples? Then you don't
have to invent some monstrous hybrid class that is like the product of an
awful teleportation accident.
--
Steve
“Cheer up,” they said, “things could be worse.” So I cheered up, and sure
enough, things got worse.
--
https://mail.python.org/mailman/listinfo/python-list
