How does Python return multiple values from a function?

Since the return statement in getName specifies multiple elements:

def getName(self):   return self.first_name, self.last_name

Python will return a container object that basically contains them.

In this case, returning a comma separated set of elements creates a tuple. Multiple values can only be returned inside containers.

Let's use a simpler function that returns multiple values:

def foo(a, b):    return a, b

You can look at the byte code generated by using dis.dis, a disassembler for Python bytecode. For comma separated values w/o any brackets, it looks like this:

>>> import dis>>> def foo(a, b):...     return a,b        >>> dis.dis(foo)  2           0 LOAD_FAST                0 (a)              3 LOAD_FAST                1 (b)              6 BUILD_TUPLE              2              9 RETURN_VALUE

As you can see the values are first loaded on the internal stack with LOAD_FAST and then a BUILD_TUPLE (grabbing the previous 2 elements placed on the stack) is generated. Python knows to create a tuple due to the commas being present.

You could alternatively specify another return type, for example a list, by using []. For this case, a BUILD_LIST is going to be issued following the same semantics as it's tuple equivalent:

>>> def foo_list(a, b):...     return [a, b]>>> dis.dis(foo_list)  2           0 LOAD_FAST                0 (a)              3 LOAD_FAST                1 (b)              6 BUILD_LIST               2              9 RETURN_VALUE

The type of object returned really depends on the presence of brackets (for tuples () can be omitted if there's at least one comma). [] creates lists and {} sets. Dictionaries need key:val pairs.

To summarize, one actual object is returned. If that object is of a container type, it can contain multiple values giving the impression of multiple results returned. The usual method then is to unpack them directly:

>>> first_name, last_name = f.getName()>>> print (first_name, last_name)

As an aside to all this, your Java ways are leaking into Python :-)

Don't use getters when writing classes in Python, use properties. Properties are the idiomatic way to manage attributes, for more on these, see a nice answer here.

From Python Cookbook v.30

def myfun():    return 1, 2, 3

a, b, c = myfun()

Although it looks like myfun() returns multiple values, a tuple is actually being created. It looks a bit peculiar, but it’s actually the comma that forms a tuple, not the parentheses

So yes, what's going on in Python is an internal transformation from multiple comma separated values to a tuple and vice-versa.

Though there's no equivalent in java you can easily create this behaviour using array's or some Collections like Lists:

private static int[] sumAndRest(int x, int y) {    int[] toReturn = new int[2];    toReturn[0] = x + y;    toReturn[1] = x - y;    return toReturn;}

Executed in this way:

public static void main(String[] args) {    int[] results = sumAndRest(10, 5);    int sum  = results[0];    int rest = results[1];    System.out.println("sum = " + sum + "\nrest = " + rest);}

result:

sum = 15rest = 5

Here It is actually returning tuple.

If you execute this code in Python 3:

def get():    a = 3    b = 5    return a,bnumber = get()print(type(number))print(number)

Output :

<class 'tuple'>(3, 5)

But if you change the code line return [a,b] instead of return a,b and execute :

def get():    a = 3    b = 5    return [a,b]number = get()print(type(number))print(number)

Output :

<class 'list'>[3, 5]

It is only returning single object which contains multiple values.

There is another alternative to return statement for returning multiple values, use yield( to check in details see this What does the "yield" keyword do in Python?)

Sample Example :

def get():    for i in range(5):        yield inumber = get()print(type(number))print(number)for i in number:    print(i)

Output :

<class 'generator'><generator object get at 0x7fbe5a1698b8>01234