CODEWITHSUNDEEP
pythonpython-2.7
cap
cap

Reputation: 377

Static methods for recursive functions within a class?

I'm working with nested dictionaries on Python (2.7) obtained from YAML objects and I have a couple of questions that I've been trying to get an answer to by reading, but have not been successful. I'm somewhat new to Python.

One of the simplest functions is one that reads the whole dictionary and outputs a list of all the keys that exist in it. I use an underscore at the beginning since this function is later used by others within a class.

    class Myclass(object):

    @staticmethod
    def _get_key_list(d,keylist):
        for key,value in d.iteritems():
            keylist.append(key)
            if isinstance(value,dict):
                Myclass._get_key_list(d.get(key),keylist)
        return list(set(keylist))

    def diff(self,dict2):
        keylist = []
        all_keys1 = self._get_key_list(self.d,keylist)
        all_keys2 = self._get_key_list(dict2,keylist)
        ... # More code

Question 1: Is this a correct way to do this? I am not sure whether it's good practice to use a static method for this reason. Since self._get_key_list(d,keylist) is recursive, I dont want "self" to be the first argument once the function is recursively called, which is what would happen for a regular instance method.

I have a bunch of static methods that I'm using, but I've read in a lot of places thay they could perhaps not be good practice when used a lot. I also thought I could make them module functions, but I wanted them to be tied to the class.

Question 2: Instead of passing the argument keylist to self._get_key_list(d,keylist), how can I initialize an empty list inside the recursive function and update it? Initializing it inside would reset it to [] every time.

Upvotes: 1

Views: 615

Answers (2)

chepner
chepner

Reputation: 532033

I would eliminate keylist as an explicit argument:

def _get_keys(d):
    keyset = set()
    for key, value in d.iteritems():
        keylist.add(key)
        if isinstance(value, dict):
            keylist.update(_get_key_list(value))
    return keyset

Let the caller convert the set to a list if they really need a list, rather than an iterable.

Often, there is little reason to declare something as a static method rather than a function outside the class.

If you are concerned about efficiency (e.g., getting lots of repeat keys from a dict), you can go back to threading a single set/list through the calls as an explicit argument, but don't make it optional; just require that the initial caller supply the set/list to update. To emphasize that the second argument will be mutated, just return None when the function returns.

def _get_keys(d, result):
    for key, value in d.iteritems():
        result.add(key)
        if isinstance(value, dict):
            _get_keys(value, result)

result = set()
_get_keys(d1, result)
_get_keys(d2, result)
# etc

Upvotes: 1

blhsing
blhsing

Reputation: 106995

There's no good reason to make a recursive function in a class a static method unless it is meant to be invoked outside the context of an instance.

To initialize a parameter, we usually assign to it a default value in the parameter list, but in case it needs to be a mutable object such as an empty list in this case, you need to default it to None and the initialize it inside the function, so that the list reference won't get reused in the next call:

class Myclass(object):
    def _get_key_list(self, d, keylist=None):
        if keylist is None:
            keylist = []
        for key, value in d.iteritems():
            keylist.append(key)
            if isinstance(value, dict):
                self._get_key_list(d.get(key), keylist)
        return list(set(keylist))

    def diff(self, dict2):
        all_keys1 = self._get_key_list(self.d)
        all_keys2 = self._get_key_list(dict2)
        ...  # More code

Upvotes: 0

Related Questions