When defining functions there are multiple things that need to be noted;
(i) Function blocks begin with the keyword "def" followed by function name and parenthesis ().
(ii) If any input parameters are present should be placed within these parentheses when you define a function.
(iii) The code block always comes after colon(:) and is indented.
(iv) The statement "return [expression]" exits a function, optionally passing back an expression to the caller. A "return" with no arguments is the same as return None.

(i) Recursive function is called by some external code.
(ii) If the base condition is met then the program gives meaningful output and exits.
(iii) Otherwise, function does some required processing and then calls itself to continue recursion.

(i) The value returned by a function may be used as an argument for another function in a nested manner.
(ii) This is called composition, For example, if we wish to take a numeric value or an expression as a input from the user, we take the input string from the user using the function input() and apply eval() function to evaluate its value.

Code:
n=int(input("Enter the year"))
if(y%4==0):
         print ("Leap Year")
else:
         print ("Not a Leap Year")
Output:
Enter the year      2012
Leap Year

S.No ceil ( ) floor ( ) (i) Returns the smallest integer greater than or equal to x. Returns the largest integer less than or equal to x. (ii) Syntax: math. ceil (x) Syntax: math.floor (x)

If we modify the global variable, we can see the change on the global variable outside the function also.
Example:
x=0                                                                                     # global variable
def add():
       global x
        x=x+5                                                                         # increment by 5
     print ("Inside add() function x value is:",x)
  add()
  print ("In main x value is:", x)
Output:
Inside add() function x value is: 5
In main x value is: 5                                                          #value of x changed outside the function

Rules of global Keyword: The basic rules for global keyword in Python are:
(i) When we define a variable outside a function, it's global by default. you don't have to use global keyword.
(ii) We use global keyword to modify the value of the global variable inside a function.
(iii) Use of global keyword outside a function has no effect.

Rules of local variable:
(i) A variable with local scope can be accessed only within the function/block that it is created in.
(ii) When a variable is created inside the function the variable becomes local to it.
(iii) A local variable only exists while the function is executing.
(iv) The formal parameters are also local to function.