A variable declared inside the function's body or in the local scope is known as local variable.

Lambda function can take any number of arguments and must return one value in the form of an expression.

In Variable Length arguments we can parse the arguments using two methods.
(i) Non keyword variable arguments
(ii) Keyword variable arguments

def function_name(*args):
function_body
return_statement

Arguments are used to call a function and there are primarily 4 types of functions. They are: Required arguments, Keyword arguments, Default arguments and Variable-length arguments.

Syntax:
def function_name (parameter(s) separated by comma):

Parameters are the variables used in the function definition whereas arguments are the values we pass to the function parameters.

A block within a block is called nested block. When the first block statement is indented by a single table space, the second block of statement is indented-by double tab spaces.

(i) Python stops calling recursive function after 1000 calls by default. 
(ii) So, it also allows you to change the limit using sys.setrecursionlimit (limit_value).
Example:
import sys
sys.setrecursionlimit(3000)
def fact(n):
         if n == 0:
         return 1
         else:
         return n * fact(n-1)
print(fact (2000))

(i)  A recursive function calls itself.
(ii) The condition that is applied in any recursive function is known as base condition.
(iii)  A base condition is must in every recursive function otherwise it will continue to execute like an infinite loop.

A variable with global scope can be used anywhere in the program. It can be created by defining a variable outside the scope of any function.

Scope of variable refers to the part of the program, where it is accessible, i.e., area where the variables can refer (use) it. The scope holds the current set of variables and their values. The two types of scopes - local scope and global scope.

Main advantages of functions are
(i) It avoids repetition and makes a high degree of code reusing.
(ii) It provides better modularity for your application.

(i) User defined functions.
(ii) Built in functions.
(iii) Lambda functions.
(iv) Recursion functions.

(i) Functions are named blocks of code that are designed to do specific job.
(ii) If you need to perform that task multiple times throughout your program, you just call the function dedicated to handling that task.