Non-keyword variable arguments are called tuples.

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.

(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))

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.

(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.

format ()

Returns the output based on the given format. 1. Binary format. Outputs the number in base 2. 2. Octal format. Outputs the number in base 8. 3. Fixed-point notation. Displays the number as a fixed-point number. The default precision is 6.

format (value [, format_spec])

x=14 y=25 print ('x value in binary :',format(x,'b')) print ('y value in octal :',format(y,'o')) print('y value in Fixed-point no ',format(y,'f')) Output: x value in binary: 1110 y value in octal: 31 y value in Fixed-point no: 25.000000

(i) Syntax - Variable-Length Arguments:
def function_name(*args):
function_body
return_statement
(ii) Example:
def printnos (*nos):
for n in nos:
print(n)
return
# now invoking theprintnos() function
print ('Printing two values')
printnos (1,2)
print ('Printing three values')
printnos (10,20,30)
Output:
Printing two values
1
2
Printing three values
10
20
30

(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.

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)

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.

# program to find fibonacci series
def fibo (n):
if n < = 1:
return n
else:
return (fibo (n - 1) + fibo (n - 2))
n = int (input ("Enter How manu terms"))
for i in range (n):
print (fibo (i))

# python program to find HCF
def HCF (x,y):
if(x > y):
s = y
else:
s = x
for I inrange (1, s + 1):
if ((x % I = = 0) and (y% i = = 0)):
hcf = i
return hcf
x = int (input ("Enter Number 1"))
y = int (input ("Enter Number 2"))
print (HCF (x, y))

(i) When a function calls itself is known as recursion.
(ii) Recursion works like loop but sometimes it makes more sense to use recursion than loop.
(iii) You can convert any loop to recursion. A recursive function calls itself.
(iv) Imagine a process would iterate indefinitely if not stopped by some condition is known as infinite iteration.
(v) The condition that is applied in any recursive function is known as base condition.
(vi) A base condition is must in every recursive function otherwise it will continue to execute like an infinite loop.
Overview of how recursive function works: 
(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.
Here is an exanmple of recursive function used to calculate factorial.
Example:
def fact(n):
if n == 0:
             return 1
else:
             return n * fact (n-1)
print (fact (0))
print (fact (5))
Output:
120

Program:
def lcm(x, y):
if x>y:
       greater = x
else:
       greater = y
while (True):
        if ((greater % x == 0) and (greater % y ==0))
        lcm = greater
        break
        greater + = 1
        return lcm
a = int (input ("Enter the first number:"))
b = int (input ("Enter the second number: "))
print ("The L.C.M of", a, "and", b, "is", lcm (a, b))
                      [OR]
Method II: (without using functions)
a = int (input ("Enter the first number:"))
b = int (input ("Enter the second number:"))
if a>b:
       mini a
else:
       min 1 = b
       while (1):
if (min 1% a 0 and mini 1% b=0):
print ("LCM is:", mini)
break
mini = min 1+1
Output:
Enter the first number: 15
Enter the second number: 20
LCM is: 60