Python User Defined Functions

Python User Defined Functions

Functions are generally defined for the piece of code which is repeatedly used across many places in a project. Functions are also defined to separate complex processing from the main code. Broadly there are two type of functions in Python:

• Named Functions
  • Parameterized Named Functions
    • Functions with default parameter
    • Functions that return value
    • Functions with unlimited parameters
    • Functions with unlimited Key-Value parameters
  • Non-Parameterized Named Functions
• Lambda(Anonymous) Functions

➠ Named Functions: Name functions can be either parameterized(with parameter) or non-parameterized(with no parameter). Named functions must be defined using 'def' keyword.

Syntax:

Non-Parameterized Function
def <function_name>():
    some_code
    some_code
    [return something] #Optional


Parameterized Function 
def <function_name>(parameter1[,parameter2]):
    some_code
    some_code
    [return something] #Optional

• Non-Parameterized Function: These are functions where no parameters are defined by users and works standalone. Processing/calculations may be static or by reading system values in these functions.

  
  Example 1: 
  def multipleOf3():
      for i in range(1,16):
          if i%3==0:
              print(i)
  
  >>> multipleOf3()
  Output: 
  3
  6
  9
  12
  15
  

  
  
• Parameterized Function: These are Functions where users can pass parameters and perform processing using those parameters.
  • Simple Examples:

    
    Example 1: 
    def my_function(fname):
      print( "Hello " + fname)
    
    >>> my_function('Dbmstutorials')
    Output: Hello Dbmstutorials
    
    
    
    Example 2: Multiple parameters
    def add_two_numbers(num1, num2):
      print( num1 + num2)
    
    >>> add_two_numbers(3,7)
    Output: 10
    

  • Default Parameter: When default parameter is/are defined then those values are passed as parameter to the function when user does not pass any value.

    
    Example 1:
    def my_function(country = "India"):
      print("I am from " + country)
    
    >>> my_function()
    Output: I am from India
    
    >>> my_function('USA')
    Output: I am from USA
    

  • Return Value: Functions can be defined to return processed values as output.

    
    Example 1:
    def my_function_add_2(num):
      return num+2
    
    >>> my_function_add_2(3)
    Output: 5
    
    
    
    Example 2: Return multiple values as Tuple
    def my_function_add_2(num):
      return num+2, num
    
    >>> my_function_add_2(3)
    Output: (5, 3)
    

  • Unlimited Parameters: Python provides a way to define unlimited parameters for user functions using asterik(*) followed by variable name. All the passed parameters will be available to function as a Tuple to use appropriately.

    
    Example 1: Here instead of arg, any identifier can be defined
    def my_function_unlimited_arguments(*arg):
        cnt=1
        for i in arg:
          print("Parameter "+str(cnt)+": "+str(i))
          cnt = cnt+1
    
    >>> my_function_unlimited_arguments('a',5,'dbms',6)
    Output: 
    Parameter 1: a
    Parameter 2: 5
    Parameter 3: dbms
    Parameter 4: 6
    

  • Unlimited Key-Value Parameters: Python also provides a way to define unlimited key value parameters for user functions using double asterik(**) followed by variable name. All the passed parameters will be available to function as a Dictionary to use appropriately.

    
    Example 1:
    def my_function_unlimited_kv_arguments(**kvargs):
        for i in kvargs:
          print("Key "+str(i)+", Value:"+str(kvargs[i]))
    
    >>> my_function_unlimited_kv_arguments(a ='Apple', b ='One', Pie ='3.14')
    Output: 
    Key a, Value:Apple
    Key b, Value:One
    Key Pie, Value:3.14
    
    
    >>> my_function_unlimited_kv_arguments(a ='Apple',  1='One' , Pie ='3.14')
    Output: 
      File "<stdin>", line 1
    SyntaxError: keyword can't be an expression

    Note: key passed as parameter must be valid identifier, for example only numbers can be passed as key and it will fail error(keyword can't be an expression).

➠ Lambda(Anonymous) Functions: Anonymous functions are functions which are defined without name. Named functions must be defined using 'def' keyword while Anonymous function must be defined with 'lambda' keyword. Lambda functions are very useful and powerful one liner functions.

Syntax:

Lambda Function
var_name = lambda <comma separated parameters> : [direct calculations which will be returned as output]

• Simple Examples:

  
  Example 1:
  x = lambda a : a + 10
  
  >>> print(x(5))
  Output: 15
  
  
  
  Example 2: With 2 parameters
  x = lambda a, b : a * b
  
  >>> print(x(5, 6))
  Output: 30
  

• Complex Example: Lambda functions combined with Named functions

  
  Example 3:
  def multiplier_with_lambda(num):
    return lambda a : a * num
  
  
  >>> doubleData = multiplier_with_lambda(2)
  >>> print(doubleData(11))
  Output: 22
  
  >>> multiplier_with_lambda(11)(2)
  Output: 22
  
  
  >>> tripleData = multiplier_with_lambda(3)
  >>> print(tripleData(11))
  Output: 33
  
  >>> multiplier_with_lambda(11)(3)
  Output: 33