Computer Science: Class 11 — Chapter 7: Functions

• Increases Readability: Particularly for longer code, making the program better organized and easier to understand.
• Reduces Code Length: Eliminates the need to write duplicate code at multiple places, simplifying debugging.
• Increases Reusability: Functions can be called from other functions or programs, avoiding repetitive code blocks.
• Parallel Work Division: Work can be easily divided among team members and completed in parallel.

By dividing the program into independent blocks of code, we achieve modularity (Program 7-2):

  
    # Program 7-2: Calculate payable amount using user-defined functions
    def cyl(h, r):
    area_cyl = 2 * 3.14 * r * h
    return area_cyl
    def con(l, r):
    area_con = 3.14 * r * l
    return area_con
    def post_tax_price(cost):
    tax = 0.18 * cost
    net_price = cost + tax
    return net_price
    print("Enter values of cylindrical part of the tent in meters:")
    h = float(input("Height: "))
    r = float(input("Radius: "))
    csa_cyl = cyl(h, r)
    l = float(input("Enter slant height of the conical area in meters: "))
    csa_con = con(l, r)
    canvas_area = csa_cyl + csa_con
    print("Area of canvas = ", canvas_area, " m^2")
    unit_price = float(input("Enter cost of 1 m^2 canvas in rupees: "))
    total_cost = unit_price * canvas_area
    print("Total cost of canvas before tax = ", total_cost)
    print("Net amount payable (including tax) = ", post_tax_price(total_cost))
  

  
    def function_name([parameter_1, parameter_2, ...]):
    # Function Header
    set_of_instructions_to_be_executed
    [return value] # Function Body
  

• The items enclosed in square brackets [ ] are optional parameters.
• The function header always ends with a colon ( : ).
• The function name must be unique and follow the rules for naming identifiers.
• Statements outside the function indentation are not considered part of the function.

An argument is a value passed to the function during a function call, which is received by the corresponding parameter defined in the function header.

Demonstrating parameter identity and modification (Program 7-5):

  
    def incrValue(num):
    print("Parameter num has value:", num, "\nid =", id(num))
    num = num + 5
    print("num incremented by 5 is", num, "\nNow id is ", id(num))
    number = int(input("Enter a number: "))
    print("id of argument number is:", id(number))
    incrValue(number)
  

Python allows assigning a default parameter value to a parameter. If the function call does not provide an argument for that parameter, the predecided default value is used.

  
    def mixedFraction(num, deno = 1):
    remainder = num % deno
    if remainder != 0:
    quotient = int(num / deno)
    print("The mixed fraction=", quotient, "(", remainder, "/", deno, ")")
    else:
    print("The given fraction evaluates to a whole number")
  

• Rule of Trailing Parameters: All default parameters must be placed at the end of the parameter list. Any parameter to the right of a default parameter must also have a default value.
• Incorrect: def calcInterest(principal = 1000, rate, time = 5):
• Correct: def calcInterest(rate, principal = 1000, time = 5):

Functions that perform calculations and display results without returning a value are called void functions . Functions can return values using the return statement. Python functions can return multiple values packaged as a tuple .

  
    def calcAreaPeri(length, breadth):
    area = length * breadth
    perimeter = 2 * (length + breadth)
    return (area, perimeter) # Returns a tuple
  

The flow of execution is the order in which statements are executed. Execution always begins at the first statement of the program. Function definitions are parsed but their internal statements are not executed until the function is called.

A function must be defined before it is called. Calling a function before its definition raises a NameError :

  
    # Program 7-11: Raises NameError
    helloPython() # Function Call before definition
    def helloPython():
    print("I love Programming")
  

Built-in functions are always available in the Python interpreter without importing any module.

A module is a file containing a collection of related function definitions and statements. To use a module, it must be imported using the import statement.

1. The math Module: Contains mathematical functions that return float values.

• math.ceil(x) : Returns the smallest integer greater than or equal to x .
• math.floor(x) : Returns the largest integer less than or equal to x .
• math.fabs(x) : Returns the absolute value of float x .
• math.factorial(x) : Returns the factorial of positive integer x .
• math.gcd(x, y) : Returns the greatest common divisor of x and y .
• math.sqrt(x) : Returns the square root of x .

2. The random Module: Used for generating pseudo-random numbers.

• random.random() : Returns a random float in the range $[0.0, 1.0)$.
• random.randint(x, y) : Returns a random integer between x and y (inclusive).
• random.randrange([start], stop[, step]) : Returns a randomly selected element from the specified range.

3. The statistics Module: Provides functions for calculating mathematical statistics of numeric data.

• statistics.mean(x) : Calculates the arithmetic mean of sequence x .
• statistics.median(x) : Calculates the middle value of sequence x .
• statistics.mode(x) : Calculates the most common data point in sequence x .

Any Python file ( .py ) containing function definitions can be imported as a module. A docstring is a multiline comment enclosed in triple quotes ( """ ) placed at the beginning of a module or function to describe its purpose. It is stored in the __doc__ attribute.

  
    """
    basic_math Module
    *******************
    This module contains basic arithmetic operations.
    """
    def addnum(x, y):
    return x + y
    def subnum(x, y):
    return x - y
  

To access the docstring of an imported module:

  
    >>> import basic_math
    >>> print(basic_math.__doc__)
    basic_math Module
    *******************
    This module contains basic arithmetic operations.