LUCTURE -4- March 12, 2018
Functions Returning Values & Functions Arguments:
Content: Function return value. Function return multiple values. Python Function Arguments
In the previous lecture we learned:
Return Values
In our previous examples, we used a return statement in the function , we can see that it is not mandatory to have a return statement. But what will be returned, if we don't explicitly give a return statement. Let's see:
def no_return(x,y): c = x + y
res = no_return(4,5) print(res)
If we start this little script, None will be printed, i.e. the special value None will be returned by a return-less function. None will also be returned, if we have just a return in a function without an expression: def empty_return(x,y): c = x + y return
res = empty_return(4,5) print(res)
Otherwise the value of the expression following return will be returned. In the next example will be printed:
def return_sum(x,y): c = x + y return c
res = return_sum(4,5) print(res)
Return Multiple Values
Python also has the ability to return multiple values from a function call, something missing from many other languages. In this case the return values should be a comma-separated list of values and Python then constructs a tuple and returns this to the caller, e.g.
def square(x,y): return x*x, y*y t = square(2,3) print(t) # Produces (4,9) # Now access the tuple with usual operations
An alternate syntax when dealing with multiple return values is to have Python "unwrap" the tuple into the variables directly by specifying the same number of variables on the left-hand side of the assignment as there are returned from the function, e.g. def square(x,y): return x*x, y*y xsq, ysq = square(2,3) print(xsq) # Prints 4 print(ysq) # Prints 9
Python Function Arguments:
In Python, you can define a function that takes variable number of arguments. You will learn to define such functions using default, keyword and arbitrary arguments.
o Python Default Arguments
o Python Keyword Arguments o Python Arbitrary Arguments In user-defined function topic, we learned about defining a function and calling it. Otherwise, the function call will result into an error. Here is an example.
Output
Hello Monica, Good morning!
Here, the function greet() has two parameters.
Since, we have called this function with two arguments, it runs smoothly and we do not get any error.
If we call it with different number of arguments, the interpreter will complain. Below is a call to this function with one and no arguments along with their respective error messages.
>>> greet("Monica") # only one argument TypeError: greet() missing 1 required positional argument: 'msg'
>>> greet() # no arguments
TypeError: greet() missing 2 required positional arguments: 'name' and 'msg'
Variable Function Arguments
Up until now functions had fixed number of arguments. In Python there are other ways to define a function which can take variable number of arguments.
Three different forms of this type are described below.
Python Default Arguments
Function arguments can have default values in Python.
We can provide a default value to an argument by using the assignment operator (=). Here is an example.
In this function, the parameter name does not have a default value and is required (mandatory) during a call.
On the other hand, the parameter msg has a default value of "Good morning!". So, it is optional during a call. If a value is provided, it will overwrite the default value.
Any number of arguments in a function can have a default value. But once we have a default argument, all the arguments to its right must also have default values.
This means to say, non-default arguments cannot follow default arguments. For example, if we had defined the function header above as:
def greet(msg = "Good morning!", name):
We would get an error as:
SyntaxError: non-default argument follows default argument
Python Keyword Arguments
When we call a function with some values, these values get assigned to the arguments according to their position.
For example, in the above function greet(), when we called it as greet("Bruce","How do you do?"), the value "Bruce" gets assigned to the argument name and similarly "How do you do?" to msg.
Python allows functions to be called using keyword arguments. When we call functions in this way, the order (position) of the arguments can be changed. Following calls to the above function are all valid and produce the same result.
>>> # 2 keyword arguments
>>> greet(name = "Bruce",msg = "How do you do?")
>>> # 2 keyword arguments (out of order)
>>> greet(msg = "How do you do?",name = "Bruce")
>>> # 1 positional, 1 keyword argument
>>> greet("Bruce",msg = "How do you do?") As we can see, we can mix positional arguments with keyword arguments during a function call. But we must keep in mind that keyword arguments must follow positional arguments.
Having a positional argument after keyword arguments will result into errors. For example the function call as follows: greet(name="Bruce","How do you do?")
Will result into error as:
SyntaxError: non-keyword arg after keyword arg
Python Arbitrary Arguments
Sometimes, we do not know in advance the number of arguments that will be passed into a function.
Python allows us to handle this kind of situation through function calls with arbitrary number of arguments.
In the function definition we use an asterisk (*) before the parameter name to denote this kind of argument. Here is an example:
Output
Hello Monica Hello Luke Hello Steve Hello John
Here, we have called the function with multiple arguments. These arguments get wrapped up into a tuple before being passed into the function. Inside the function, we use a for loop to retrieve all the arguments back.
Python Program to Make a Simple Calculator:
To understand this example, you should have the knowledge of following Python programming topics:
Python Functions Python Function Arguments Python User-defined Functions
Code: ''' Program make a simple calculator that can add, subtract, multiply and divide using functions '''
# This function adds two numbers def add(x, y): return x + y
# This function subtracts two numbers def subtract(x, y): return x - y
# This function multiplies two numbers def multiply(x, y): return x * y
# This function divides two numbers def divide(x, y): return x / y print("Select operation.") print("1.Add") print("2.Subtract") print("3.Multiply") print("4.Divide")
# Take input from the user choice = input("Enter choice(1/2/3/4):") num1 = int(input("Enter first number: ")) num2 = int(input("Enter second number: ")) if choice == '1': print(num1,"+",num2,"=", add(num1,num2)) elif choice == '2': print(num1,"-",num2,"=", subtract(num1,num2)) elif choice == '3': print(num1,"*",num2,"=", multiply(num1,num2)) elif choice == '4': print(num1,"/",num2,"=", divide(num1,num2)) else: print("Invalid input")
Output Select operation. 1.Add 2.Subtract 3.Multiply 4.Divide Enter choice(1/2/3/4): 3 Enter first number: 15 Enter second number: 14 15 * 14 = 210