Python, best way to return/handle complex data from a method

I need to handle a bunch of similar but exclusively ca开发者_如何学Golled function from a single method. e.g. (maybe not a great example)

class Util(object):
    def method1(self):
        return "method1", [1,2,3]

    def method2(self):
        return "method2", {"1":4, "2":5, "3":6}

    def method3(self):
        return [1,2,3], "method3", {"1":4, "2":5, "3":6}

    def call_method(self, method_func):
        if method_func.__name__ == "method1":
            (name, dict_values) = self.method_func()
        if method_func.__name__ == "method2":
            (name, list_values) = self.method_func()
        if method_func.__name__ == "method3":
            (list_values, name, dict_values) = self.method_func()
        # How best to manage a return for 3 optional, but not inter-dependent values?
        return name, dict_values, list_values

if __name__ = "__main__":
    u = Util()
    (name, dict_values, list_values) = u.call_method(Util.method1)

The call_method() return is what I'm trying to visualize here. I've got a bunch of exclusive sub-calls I need to make and I need to massage them into something that can be returned.

Would it be easier to just stuff them into Util class member variables? And whoever implements u.call_method() will simply need to know what to look for?

Before anyone complains about the design in the first place, it's not mine. I simply need to expose a consistent API and an interested to hear opinons on how to handle a return like this. It's not easily normalized, and though a missing trailing return value will pass the Runtime, a leading one won't.

Any tips would be great! Thank you.

---

namedtuple is very Pythonic alternative for returning "nameless" tuples

http://docs.python.org/library/collections.html#collections.namedtuple

This way the caller does not need to extract all tuple members if it needs read only some of them.

---

If you need to group several values often an approach is using a dictionary... i.e. changing your code to:

...
def method1(self):
    return {"name": "method 1",
            "list": [1, 2, 3]}

Something that is possible in Python is to use an object instead of a dictionary to make the code nicer to read:

class Bunch:
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

...
def method1(self):
    return Bunch(name="method1",
                 list=[1, 2, 3])

so that the caller can use result.name instead of result["name"].

Another option that recently got standardized in Python is the NamedTuple.

---

If you can modify the methods:

class Util(object):
    def method1(self):
        return "method1", [1,2,3], None

    def method2(self):
        return "method2", None, {"1":4, "2":5, "3":6}

    def method3(self):
        return "method3", [1,2,3], {"1":4, "2":5, "3":6}

    def call_method(self, method_func):
        return method_func(self)    

if __name__ == "__main__":
    u = Util() 
    (name, dict_values, list_values) = u.call_method(Util.method1)
    # better:
    print u.method1()

And if you can not change:

class Util(object):
    def method1(self):
        return "method1", [1,2,3]

    def method2(self):
        return "method2", {"1":4, "2":5, "3":6}

    def method3(self):
        return "method3", [1,2,3], {"1":4, "2":5, "3":6}

    def call_method(self, method_func):
        results = method_func(self) 
        name = list_ = dict_ = None   
        for obj in results:
            if isinstance(obj, string):
               name = obj
            elif isinstance(obj, list):
               list_ = obj
            elif isinstacne(obj, dict):
               dict_ = obj
        return name, dict_, list_

if __name__ == "__main__":
    u = Util() 
    (name, dict_values, list_values) = u.call_method(Util.method1)