Is there a way in Python to return a value via an output parameter?

Question

Some languages have the feature to return values using parameters also like C#. Let’s take a look at an example:

class OutClass
{
    static void OutMethod(out int age)
    {
        age = 26;
    }
    static void Main()
    {
        int value;
        OutMethod(out value);
        // value is now 26
    }
}

So is there anything similar in Python to get a value using parameter, too?

Answer 1

Python can return a tuple of multiple items:

def func():
    return 1,2,3

a,b,c = func()

But you can also pass a mutable parameter, and return values via mutation of the object as well:

def func(a):
    a.append(1)
    a.append(2)
    a.append(3)

L=[]
func(L)
print(L)   # [1,2,3]

Answer 2

You mean like passing by reference?

For Python object the default is to pass by reference. However, I don't think you can change the reference in Python (otherwise it won't affect the original object).

For example:

def addToList(theList):   # yes, the caller's list can be appended
    theList.append(3)
    theList.append(4)

def addToNewList(theList):   # no, the caller's list cannot be reassigned
    theList = list()
    theList.append(5)
    theList.append(6)

myList = list()
myList.append(1)
myList.append(2)
addToList(myList)
print(myList)   # [1, 2, 3, 4]
addToNewList(myList)
print(myList)   # [1, 2, 3, 4]

Answer 3

Pass a list or something like that and put the return value in there.

Answer 4

In addition, if you feel like reading some code, I think that pywin32 has a way to handle output parameters.

In the Windows API it's common practice to rely heavily on output parameters, so I figure they must have dealt with it in some way.

Answer 5

You can do that with mutable objects, but in most cases it does not make sense because you can return multiple values (or a dictionary if you want to change a function's return value without breaking existing calls to it).

I can only think of one case where you might need it - that is threading, or more exactly, passing a value between threads.

def outer():
    class ReturnValue:
        val = None
    ret = ReturnValue()
    def t():
        # ret = 5 won't work obviously because that will set
        # the local name "ret" in the "t" function. But you
        # can change the attributes of "ret":
        ret.val = 5

    threading.Thread(target = t).start()

    # Later, you can get the return value out of "ret.val" in the outer function