Multiple Return Values
00:00 In this lesson and the next, you’ll see how you can use Python to mimic some of the functionality other programming languages provide using pass by reference.
00:09 I’ll be following Marius’s tutorial a little more closely for a while, so feel free to follow along as well if that’s what you’d like to do, I’ll still, however, do my examples in C++ instead of C#.
00:23 Hopefully, I’ve successfully demonstrated some advantages to pass by reference. Now you’ll see how Python can be used to implement some of those most significant advantages.
00:35 First, you’ll look at object duplication, or rather the lack thereof.
00:40 You saw how by using pass by reference, you can avoid the issue of memory duplication and the time involved in copying a complex object or structure from an argument variable to a parameter variable.
00:54 But Python does almost the same thing. When you use an object as an argument, the parameter name is bound to that same object. Python doesn’t make a copy of the object, even for the simplest data types, so that benefit is already provided by Python’s pass by assignment mechanism.
01:15 So, let’s take a look at another: creating multiple return values. As I’ve mentioned, many languages allow only for a single return value from a function.
01:27 So programmers of that language have had to improvise if they need two or more different pieces of information given back from a function to the calling environment.
01:37 So what they would usually do is use the actual return value for one of them and pass another variable argument by reference and let the function give it a value, which is then retained and can be used once the function ends.
01:53 As an example, consider a program that’s to create a personalized greeting and update a count of how many times it’s been used. Here’s a version in C++. It takes one parameter, the name, to personalize the greeting, and then a reference parameter to update the count of how many times the function has been called.
You can see the ampersand (
&) in front of the word
counter to indicate that this is being passed by reference. A greeting is created by appending the provided name to the word
02:32 The counter is incremented, and since this was provided using pass by reference, the associated argument variable will be incremented by this statement as well.
The greeting is then returned. This
main() function shows how it’s used. It creates a counter variable called
count, which will keep track of how many times the function is called.
It is passed as the second argument in the function call. First in a function call that’s going to create a greeting for
"Alice", which is then printed using C++’s
cout statement. And then in one for Bob, it also displays the value of
count after each greeting.
03:21 I can show you this working in a terminal window. First, I’ll compile it for you, then I’ll run it.
Here’s the greeting for Alice and then the updated value of
count, the greeting for Bob, and the updated value of
03:51 How would things work in Python? Well first, let’s look at what doesn’t work. This function in Python is nearly a line-by-line version of what you saw in C++.
As you can see, the function
greet() takes two parameters, increments the counter, and returns the personalized greeting. The script creates a counter variable called
count, prints the greeting personalized for Alice, passing
count as the second parameter, displaying the value of
count, then doing the same for Bob. Let’s take a look at this when it runs.
04:39 We see that count wasn’t updated. Why not?
Because the statement
counter += 1 is an assignment statement, Python computes the value of
counter using its current value plus
1, creates a new object with that computed value, then assigns—or rather, binds—that new object with the parameter variable
The parameter variable no longer has any connection with the original object it was bound to. The variable
count in the script is still bound to that object with a value of
0 and was unaffected by the parameter
counter being bound to a new object. Again, this is pass by assignment. By assignment,
counter was bound to the same object that
count was bound to, but that was only until it was changed to be bound to something else. Its connection, or reference, to that original object was gone.
05:47 Of course, you don’t have to do this in Python because Python allows you to return multiple values. So you can, in a single return statement, return the personalized greeting and the incremented value of how many times the function has been called packed in a tuple.
So here is the newer version of the
greet() function but with the same script using it. If I run it,
I see the updated value of
counter is being returned, but the variable
count isn’t being updated to use it. Also, printing the return value of this function is now displaying the entire tuple and not just the greeting that we had before.
06:44 The script needs to be modified to unpack the returned tuple so it can save the updated count. This new script now unpacks the returned tuple by storing each element to a separate variable.
The greeting is saved to the variable
greeting and the updated counter value is saved back to the variable
count. After displaying that information, the script then calls
greet() a second time, this time for
count variable is passed to that function call, and again, the return tuple is unpacked, saving the new greeting to
greeting, and saving the updated counter value back to
count. By the way, the only significance about saving the second greeting back to the same
greeting variable is because the script no longer needs the greeting for
"Alice". It’s already used it.
What you want to be watching is how the
count variable is being used as an argument and the variable to save the modified counter from the returned tuple.
greet() returns the greeting and counter. The personalized greeting gets saved in the variable
greeting, which is then printed.
count is then printed. That happens for both
And there, you can see the desired output. We print the greeting for
"Alice", the updated
count, the greeting for
"Bob", and the updated
08:25 This is actually the exact same output the original C++ version of the program had.
08:35 Assigning return values to variables is the best way to achieve the same results as passing by reference in Python. You’ll see this again later. But next, you’ll look at how pass by reference can work with functions that return different things based on certain conditions within the function and how Python can be used to do that as well.
Become a Member to join the conversation.