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

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?

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]

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]
myList = list()
myList.append(1)
myList.append(2)
addToList(myList)
print(myList)   # [1, 2, 3, 4]
addToNewList(myList)
print(myList)   # [1, 2, 3, 4]

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

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.

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