https://www.pythonforbeginners.

com/basics/python-functions-cheat-sheet

https://www.guru99.com/python-tutorials.html

https://www.tutorialaicsip.com/cs-xii/python-functions-class12/#:~:text=Python
%20functions%20class12-%20Returning%20values%20from%20function
%20A,not%20return%20a%20values%20is%20called%20void%20function.

1. Code re-usability: Lets say we are writing an application in Python where we

need to perform a specific task in several places of our code, assume that we
need to write 10 lines of code to do that specific task. It would be better to write
those 10 lines of code in a function and just call the function wherever needed,
because writing those 10 lines every time you perform that task is tedious, it
would make your code lengthy, less-readable and increase the chances of
human errors.

2. Improves Readability: By using functions for frequent tasks you make your
code structured and readable. It would be easier for anyone to look at the code
and be able to understand the flow and purpose of the code.

3. Avoid redundancy: When you no longer repeat the same lines of code
throughout the code and use functions in places of those, you actually avoiding
the redundancy that you may have created by not using functions.

Syntax of functions in Python

Function declaration:

def function_name(function_parameters):
function_body # Set of Python statements
return # optional return statement
Calling the function:

# when function doesn't return anything

function_name(parameters)
OR

# when function returns something

# variable is to store the returned value
variable = function_name(parameters)
Python Function example
Here we have a function add() that adds two numbers passed to it as
parameters. Later after function declaration we are calling the function twice in
our program to perform the addition.

def add(num1, num2):

return num1 + num2

sum1 = add(100, 200)

sum2 = add(8, 9)
print(sum1)
print(sum2)
Output:

300
17
Default arguments in Function
Now that we know how to declare and call a function, lets see how can we use
the default arguments. By using default arguments we can avoid the errors that
may arise while calling a function without passing all the parameters. Lets take
an example to understand this:

In this example we have provided the default argument for the second
parameter, this default argument would be used when we do not provide the
second parameter while calling this function.

# default argument for second parameter

def add(num1, num2=1):
return num1 + num2

sum1 = add(100, 200)

sum2 = add(8) # used default argument for second param
sum3 = add(100) # used default argument for second param
print(sum1)
print(sum2)
print(sum3)
Output:

300
 9
101
Types of functions
There are two types of functions in Python:
1. Built-in functions: These functions are predefined in Python and we need not
to declare these functions before calling them. We can freely invoke them as and
when needed.
2. User defined functions: The functions which we create in our code are user-
defined functions. The add() function that we have created in above examples is
a user-defined function.

We will cover more about these function types in the separate guides

When you started coding in Python, you'd have used the built-
in print() function in your Hello World! program 😀 and
the input() function to read in input from the user.
So long as you know how to use these functions, you don't have
to worry about how they've been implemented.
In programming, this is called abstraction. It lets you use
functions by calling the function with required arguments,
without having to worry about how they actually work.
There's a whole wealth of built-in functions in Python. In this
post, we shall see how we can define and use our own
functions. Let's get started!

Python Function Syntax

The following snippet shows the general syntax to define a
function in Python:

def function_name(parameters):
# What the function does goes here
return result
 You need to use the def keyword, give your function a name,
followed by a pair of parentheses, and end the line with a colon (:).
 If your function takes arguments, the names of the arguments
(parameters) are mentioned inside the opening and closing
parentheses.
 Please note that in function definition, the arguments that your
function consumes are referred to as parameters.
 When you call the function with specific values for these parameters,
they're called arguments or actual parameters. This is because
the arguments in the function call are the values used for the function's
parameters.
 Then, you begin an indented block. This is the body of the function
that describes what your function does.
 There's a return statement that returns the result of the operation on
the arguments. The return statement returns control to the point
where the function was originally called.
Note that the arguments and the return statement are optional.
This means that you could have a function that takes in no
arguments, and returns nothing. 😀
Let's now try to understand the above statements using simple
examples.

How to Create a Simple Function in Python

Let's now create a simple function in Python that greets the
user, as shown below:

def my_func():
print("Hello! Hope you're doing well")

As you can see, the function my_func():

 takes no arguments,
 returns nothing, and
 prints out "Hello! Hope you're doing well" whenever it's called.
Note that the above function definition is inert until the function
is triggered or called. Let's go ahead and call the
function my_func() and check the output.
my_func()

# Output
Hello! Hope you're doing well

How to Create a Function with Arguments in Python

Now, we shall modify the function my_func() to include
the name and place of the user.
def my_func(name,place):
print(f"Hello {name}! Are you from {place}?")
We can now call my_func() by passing in two strings for
the name and place of the user, as shown below.
my_func("Jane","Paris")

# Output
Hello Jane! Are you from Paris?
What happens if you specify the place first and then the name?
Let's find out.
my_func("Hawaii","Robert")

# Output
Hello Hawaii! Are you from Robert?
We get Hello Hawaii! Are you from Robert? – and this doesn't
make sense. 🙂What's causing this problem?
The arguments in the function call are positional arguments. This
means that the first argument in the function call is used as the
value of the first parameter (name)  and the second argument in
the function call is used as the value of the second parameter
( place )
See the code snippet below. Instead of specifying only the
arguments, we've mentioned the parameters and the values
they take.

my_func(place="Hawaii",name="Robert")

# Output
Hello Robert! Are you from Hawaii?
These are called keyword arguments. The order of arguments in
the function call does not matter so long as the names of the
parameters are correct.
How to Create a Function with Default Arguments in
Python
What if we had certain parameters that take a specific value
most of the time during the function calls?

Can we not do better than calling the function with the same
value for a particular parameter?

Yes we can do better, and that's what default arguments are

for! 😀
Let's create a function total_calc() that helps us calculate and
print out the total amount to be paid at a restaurant. Given
a bill_amount and the percentage of the bill_amount you
choose to pay as tip (tip_perc ), this function calculates the total
amount that you should pay.
Note how the function definition includes the default value of the
parameter tip_perc to be used when the user doesn't specify a
tip percentage.
Run the code snippet below.👇🏽 You now have your function
ready!

def total_calc(bill_amount,tip_perc=10):
 total = bill_amount*(1 + 0.01*tip_perc)
total = round(total,2)
print(f"Please pay ${total}")
Let's now call the function in a few different ways. The code
snippet below shows the following:

 When you call the function total_calc with only the bill_amount, by

default the tip percentage of 10 is used.
 When you explicitly specify the percentage tip, the tip percentage
mentioned in the function call is used.
# specify only bill_amount
# default value of tip percentage is used

total_calc(150)
# Output
Please pay $165.0

# specify both bill_amount and a custom tip percentage

# the tip percentage specified in the function call is used

total_calc(200,15)
# Output
Please pay $230.0

total_calc(167,7.5)
# Output
Please pay $179.53

How to Create a Function that Returns a Value in

Python
So far, we've only created functions that may or may not take
arguments and do not return anything. Now, let's create a
 simple function that returns the volume of a cuboid given
the length, the width, and the height.
def volume_of_cuboid(length,breadth,height):
return length*breadth*height

Recall that the return keyword returns control to the point

where the function was called. The function call is replaced with
the return value from the function.
Let's call the function volume_of_cuboid() with the necessary
dimension arguments, as shown in the code snippet below.
Note how we use the variable volume to capture the value
returned from the function.
volume = volume_of_cuboid(5.5,20,6)
print(f"Volume of the cuboid is {volume} cubic units")

# Output
Volume of the cuboid is 660.0 cubic units

How to Create a Function that Returns Multiple Values

in Python
In our earlier example, the function volume_of_cuboid() returned
only one value, namely, the volume of a cuboid given its
dimensions. Let's see how we can return multiple values from a
function.
 To return multiple values from a function, just specify the values to be
returned, separated by a comma.
 By default, the function returns the values as a tuple. If there
are N return values, we get an N-tuple.
Let's create a simple function cube() that returns the volume
and total surface area of a cube, given the length of its side.
def cube(side):
volume = side **3
surface_area = 6 * (side**2)
 return volume, surface_area
To verify that a tuple is returned, let's collect it in a
variable returned_values, as shown below:
returned_values = cube(8)
print(returned_values)

# Output
(512, 384)
Now, we shall unpack the tuple and store the values in two
different variables.
volume, area = cube(6.5)
print(f"Volume of the cube is {volume} cubic units and the total surface area
is {area} sq. units")

# Outputs
Volume of the cube is 274.625 cubic units and the total surface area is 253.5
sq. units

How to Create a Function that Takes a Variable

Number of Arguments in Python
Let's start by asking a few questions:

 What if we do not know the exact number of arguments beforehand?

 Can we create functions that work with a variable number of
arguments?
The answer is yes! And we'll create such a function right away.

Let's create a simple function my_var_sum() that returns the sum

of all numbers passed in as the argument. However, the
number of arguments could be potentially different each time
we call the function.
Notice how the function definition now has *args instead of just
the name of the parameter. In the body of the function, we loop
through args until we've used all the arguments. The
function my_var_sum returns the sum of all numbers passed in as
arguments.
def my_var_sum(*args):
sum = 0
for arg in args:
sum += arg
return sum
Let's now call the function my_var_sum() with a different number
of arguments each time and quickly check if the returned
answers are correct! 🙂
# Example 1 with 4 numbers
sum = my_var_sum(99,10,54,23)
print(f"The numbers that you have add up to {sum}")
# Output
The numbers that you have add up to 186

# Example 2 with 3 numbers

sum = my_var_sum(9,87,45)
print(f"The numbers that you have add up to {sum}")
# Output
The numbers that you have add up to 141

# Example 3 with 6 numbers

sum = my_var_sum(5,21,36,79,45,65)
print(f"The numbers that you have add up to {sum}")
# Output
The numbers that you have add up to 251