call special function when DataFrame is called upon custom class - python-3.x

Question

I have the following classes:
class Result(UserDict):
"""Implements a especial version of dictionary, that will return the keys
ordered in the initialized way"""
def __init__(self, keys_order, items):
super().__init__(self)
self.__keys_order = keys_order
self.data = items
def __repr__(self):
attributes = ["{}:{}".format(_stringify(k), _stringify(self.data[k])) for k in self.keys()]
return "{}".format(", ".join(attributes))
def keys(self):
return [key for key in self.__keys_order]
class Results(UserList):
"""Implements a especial kind of list, that has a method to_df"""
def to_df(self):
return pd.DataFrame(self.data, columns=self.data[0].keys())
In this way, when I print an instance of Result, it will show it with the keys in the desired way (determined by keys_order). Also, the class Results implements the method to_df, which returns a pandas DataFrame with the columns ordered by the keys.
I know for example that if I want the len(results) function to behave in a especial way, I have to implement the __len__ method in it, in a similar way, is it possible to implement a special method so when pd.DataFrame(results) is called upon a results instance it will call to_df method instead? so I have the columns ordered by the keys.

Answer 1

You could have your Result class inherit not just from UserDict but also from pd.DataFrame. Then you just have to define the _data attribute of your class to be what you want the class to hand to pd.DataFrame(), i.e. the pd.DataFrame that you want to be constructed.
class Result(UserDict, pd.DataFrame):
"""Implements a especial version of dictionary, that will return the keys
ordered in the initialized way"""
def __init__(self, keys_order, items):
super().__init__(self)
self.__keys_order = keys_order
self.data = items
self._data = pd.DataFrame(self.data, columns=self.data[0].keys())
This becomes evident when looking at the source code of the pd.DataFrame class:
def __init__(self, data=None, index=None, columns=None, dtype=None,
copy=False):
if data is None:
data = {}
if dtype is not None:
dtype = self._validate_dtype(dtype)
if isinstance(data, DataFrame):
data = data._data
upon calling the __init__ method, which is what you are effectively doing when you use pd.DataFrame(results), it will check if results is an instance of DataFrame. If it is, then it will just set data to be results._data. Alternatively your results class could also inherit from dict, in which case the dict constructor would be called inside the __init__:
elif isinstance(data, dict):
mgr = self._init_dict(data, index, columns, dtype=dtype)
Here the excerpt from self._init_dict that would be called in your case:
else:
keys = list(data.keys())
if not isinstance(data, OrderedDict):
keys = _try_sort(keys)
columns = data_names = Index(keys)
arrays = [data[k] for k in keys]
So you have to define a keys() method for your class that returns the keys (which you already have), as well as __getitem__, so that data[k] in the last line returns the values of column k.