Question 1

Question 4Find the errors in following function definitions : def main()  
     print ("hello")def func2():  
     print(2 + 3)def compute():   
     print (x * x)square (a)  
     return a * a

Accepted Answer

Colon is missing at the end of function header.There is no error.The variable x is not defined.def keyword at the beginning and colon at the end of function header are missing.The corrected function definitions are: def main():  
     print("hello") def func2():  
     print(2 + 3)   def compute(x):  
     print (x * x)   def square(a):  
     return a * a

Question 2

Question 5What is the utility of : (i) default arguments, (ii) keyword arguments ?

Accepted Answer

(i) Default arguments — Default arguments are useful in case a matching argument is not passed in the function call statement. They give flexibility to specify the default value for a parameter so that it can be skipped in the function call, if needed. However, still we cannot change the order of the arguments in the function call.(ii) Keyword arguments — Keyword arguments are useful when you want to specify arguments by their parameter names during a function call. This allows us to pass arguments in any order, as long as we specify the parameter names when calling the function. It also makes the function call more readable and self-explanatory.

Question 3

Question 6Explain with a code example the usage of default arguments and keyword arguments.

Accepted Answer

Default arguments — Default arguments are used to provide a default value to a function parameter if no argument is provided during the function call.For example :def greet(name, message="Hello"):
    print(message, name)

greet("Alice")          
greet("Bob", "Hi there")OutputHello Alice
Hi there Bob
In this example, the message parameter has a default value of "Hello". If no message argument is provided during the function call, the default value is used.Keyword arguments — Keyword arguments allow us to specify arguments by their parameter names during a function call, irrespective of their position.def person(name, age, city):
    print(name, "is", age, "years old and lives in", city)

person(age=25, name="Alice", city="New York")
person(city="London", name="Bob", age=30)OutputAlice is 25 years old and lives in New York
Bob is 30 years old and lives in London
In this example, the arguments are provided in a different order compared to the function definition. Keyword arguments specify which parameter each argument corresponds to, making the code more readable and self-explanatory.Both default arguments and keyword arguments provide flexibility and improve the readability of code, especially in functions with multiple parameters or when calling functions with optional arguments.

Question 4

Question 7Describe the different styles of functions in Python using appropriate examples.

Accepted Answer

The different styles of functions in Python are as follows :Built-in functions — These are pre-defined functions and are always available for use. For example:name = input("Enter your name: ")
name_length = len(name)
print("Length of your name:", name_length)In the above example, print(), len(), input() etc. are built-in functions.User defined functions — These are defined by programmer. For example:def calculate_area(length, width):
     area = length * width
     return area
length = 5
width = 3
result = calculate_area(length, width)
print("Area of the rectangle:", result)In the above example, calculate_area is a user defined function.Functions defined in modules — These functions are pre-defined in particular modules and can only be used when corresponding module is imported. For example:import math
num = 16
square_root = math.sqrt(num)
print("Square root of", num, ":", square_root)In the above example, sqrt is a function defined in math module.

Question 5

Question 11What is the difference between local and global variable ?

Accepted Answer

Local variableGlobal variableA local variable is a variable defined within a function.A global variable is a variable defined in the 'main' program.They are only accessible within the block in which they are defined.They are accessible from anywhere within the program, including inside functions.These variables have local scope.These variables have global scope.The lifetime of a local variable is limited to the block of code in which it is defined. Once the execution exits that block, the local variable is destroyed, and its memory is released.Global variables persist throughout the entire execution of the program. They are created when the program starts and are only destroyed when the program terminates.

Question 6

Question 12When is global statement used ? Why is its use not recommended ?

Accepted Answer

If we want to assign some value to the global variable without creating any local variable then global statement is used. It is not recommended because once a variable is declared global in a function, we cannot undo the statement. That is, after a global statement, the function will always refer to the global variable and local variable cannot be created of the same name. Also, by using global statement, programmers tend to lose control over variables and their scopes.

Question 7

Question 14What do you understand by local and global scope of variables ? How can you access a global variable inside the function, if function has a variable with same name.

Accepted Answer

Local scope — Variables defined within a specific block of code, such as a function or a loop, have local scope. They are only accessible within the block in which they are defined.Global scope — Variables defined outside of any specific block of code, typically at the top level of a program or module, have global scope. They are accessible from anywhere within the program, including inside functions.To access a global variable inside a function, even if the function has a variable with the same name, we can use the global keyword to declare that we want to use the global variable instead of creating a new local variable. The syntax is :global<variable name>For example:def state1():
    global tigers
    tigers = 15 
    print(tigers)
tigers = 95
print(tigers)
state1()
print(tigers)In the above example, tigers is a global variable. To use it inside the function state1 we have used global keyword to declare that we want to use the global variable instead of creating a new local variable.

Question 8

Question 1(a)What are the errors in following codes ? Correct the code and predict output :total = 0;
    def sum(arg1, arg2): 
    total = arg1 + arg2;
    print("Total :", total) 
return total;
sum(10, 20);
print("Total :", total)

Accepted Answer

total = 0
def sum(arg1, arg2):  
    total = arg1 + arg2
    print("Total :", total) 
    return total
sum(10, 20)
print("Total :", total)OutputTotal : 30
Total : 0
ExplanationThere is an indentation error in second line.The return statement should be indented inside function and it should not end with semicolon.Function call should not end with semicolon.

Question 9

Question 1(b)What are the errors in following codes ? Correct the code and predict output :def Tot(Number) #Method to find Total
    Sum = 0
    for C in Range (1, Number + 1): 
        Sum += C
        RETURN Sum
print (Tot[3])  #Function Calls
print (Tot[6])

Accepted Answer

def Tot(Number): #Method to find Total
    Sum = 0
    for C in range(1, Number + 1): 
        Sum += C
    return Sum
print(Tot(3))  #Function Calls
print(Tot(6))Output6
21
ExplanationThere should be a colon (:) at the end of the function definition line to indicate the start of the function block.Python's built-in function for generating sequences is range(), not Range().Python keywords like return should be in lowercase.When calling a function in python, the arguments passed to the function should be enclosed inside parentheses () not square brackets [].

Question 10

Question 2Find and write the output of the following python code :def Call(P = 40, Q = 20):
    P = P + Q
    Q = P - Q 
    print(P, '@', Q)
    return P
R = 200
S = 100
R = Call(R, S)
print(R, '@', S) 
S = Call(S)
print(R, '@', S)

Accepted Answer

Output300 @ 200
300 @ 100
120 @ 100
300 @ 120
ExplanationFunction Call is defined with two parameters P and Q with default values 40 and 20 respectively.Inside the function Call, P is reassigned to the sum of its original value P and the value of Q.Q is reassigned to the difference between the new value of P and the original value of Q.Prints the current values of P and Q separated by @.The function returns the final value of P.Two variables R and S are initialized with values 200 and 100 respectively.The function Call is called with arguments R and S, which are 200 and 100 respectively. Inside the function, P becomes 200 + 100 = 300 and Q becomes 300 - 100 = 200. So, 300 and 200 are printed. The function returns 300, which is then assigned to R. Therefore, R becomes 300.S = Call(S) — The function Call is called with only one argument S, which is 100. Since the default value of Q is 20, P becomes 100 + 20 = 120, and Q becomes 120 - 20 = 100. So, 120 and 100 are printed. The function returns 120, which is then assigned to S. Therefore, S becomes 120.

Question 11

Question 6(ii)What will be the output of following program ?num = 1
def myfunc():
    num = 10
    return num
print(num)
print(myfunc())
print(num)

Accepted Answer

Output1
10
1
Explanationnum = 1 — This line assigns the value 1 to the global variable num.def myfunc() — This line defines a function named myfunc.print(num) — This line prints the value of the global variable num, which is 1.print(myfunc()) — This line calls the myfunc function. Inside myfunc function, num = 10 defines a local variable num and assigns it the value of 10 which is then returned by the function. It is important to note that the value of global variable num is still 1 as num of myfunc is local to it and different from global variable num.print(num) — This line prints the value of the global variable num, which is still 1.

Question 12

Question 6(iii)What will be the output of following program ?num = 1
def myfunc():
    global num
    num = 10
    return num
print(num)
print(myfunc())
print(num)

Accepted Answer

Output1
10
10
Explanationnum = 1 — This line assigns the value 1 to the global variable num.def myfunc() — This line defines a function named myfunc.print(num) — This line prints the value of the global variable num, which is 1.print(myfunc()) — This line calls the myfunc function. Inside the myfunc function, the value 10 is assigned to the global variable num. Because of the global keyword used earlier, this assignment modifies the value of the global variable num to 10. The function then returns 10.print(num) — This line prints the value of the global variable num again, which is still 1.

Question 13

Question 6(iv)What will be the output of following program ?def display():
    print("Hello", end='')
display()
print("there!")

Accepted Answer

OutputHellothere!
ExplanationThe function display prints "Hello" without a newline due to the end='' parameter. When called, it prints "Hello". Outside the function, "there!" is printed on the same line due to the absence of a newline.

Question 14

Question 9Write a function namely fun that takes no parameters and always returns None.

Accepted Answer

def fun():
    return Explanationdef fun():
    return 
r = fun()
print(r)The function fun() returns None. When called, its return value is assigned to r, which holds None. Then print(r) outputs None.

Question 15

Question 11Consider the code below and answer the questions that follow :def multiply(number1, number2):
    answer = number1 * number2
    return(answer)
    print(number1, 'times', number2, '=', answer)
output = multiply(5, 5)(i) When the code above is executed, what gets printed ?(ii) What is variable output equal to after the code is executed ?

Accepted Answer

(i) When the code above is executed, it will not print anything because the print statement after the return statement won't execute. Therefore, the function exits immediately after encountering the return statement.(ii) After the code is executed, the variable output is equal to 25. This is because the function multiply returns the result of multiplying 5 and 5, which is then assigned to the variable output.

Question 16

Question 12(a)Find the errors in code given below :def minus(total, decrement)  
    output = total - decrement                              
    print(output)
    return (output)

Accepted Answer

The errors in the code are:def minus(total, decrement) # Error 1  
    output = total - decrement                              
    print(output)
    return (output)There should be a colon at the end of the function definition line.The corrected code is given below:def minus(total, decrement): 
    output = total - decrement
    print(output)
    return (output)

Question 17

Question 12(b)Find the errors in code given below :define check()
    N = input ('Enter N: ') 
    i = 3                                             
    answer = 1 + i ** 4 / N                              
    Return answer

Accepted Answer

The errors in the code are:define check() #Error 1
    N = input ('Enter N: ') #Error 2
    i = 3                                             
    answer = 1 + i ** 4 / N                              
    Return answer #Error 3The function definition lacks a colon at the end.The 'input' function returns a string. To perform arithmetic operations with N, it needs to be converted to a numeric type, such as an integer or a float.The return statement should be in lowercase.The corrected code is given below:def check():
    N = int(input('Enter N:'))
    i = 3
    answer = 1 + i ** 4 / N
    return answer

Question 18

Question 12(c)Find the errors in code given below :def alpha (n, string = 'xyz', k = 10) :
    return beta(string)
    return n

def beta (string)
    return string == str(n)

print(alpha("Valentine's Day"):)
print(beta(string = 'true'))
print(alpha(n = 5, "Good-bye"):)

Accepted Answer

The errors in the code are:def alpha (n, string = 'xyz', k = 10) :
    return beta(string)
    return n #Error 1

def beta (string) #Error 2
    return string == str(n)

print(alpha("Valentine's Day"):) #Error 3
print(beta(string = 'true')) #Error 4
print(alpha(n = 5, "Good-bye"):) #Error 5The second return statement in the alpha function (return n) is unreachable because the first return statement return beta(string) exits the function.The function definition lacks colon at the end. The variable n in the beta function is not defined. It's an argument to alpha, but it's not passed to beta explicitly. To access n within beta, we need to either pass it as an argument or define it as a global variable.There should not be colon at the end in the function call.In the function call beta(string = 'true'), there should be argument for parameter n.In the function call alpha(n = 5, "Good-bye"), the argument "Good-bye" lacks a keyword. It should be string = "Good-bye".The corrected code is given below:def alpha(n, string='xyz', k=10):
    return beta(string, n)

def beta(string, n):
    return string == str(n)

print(alpha("Valentine's Day"))
print(beta(string='true', n=10))
print(alpha(n=5, string="Good-bye"))

Question 19

Question 13Draw the entire environment, including all user-defined variables at the time line 10 is being executed.1. def sum(a, b, c, d):
2.      result = 0
3.      result = result + a + b + c + d 
4.      return result
5. 
6. def length():
7.      return 4
8. 
9. def mean(a, b, c, d):
10.     return float(sum(a, b, c, d))/length()
11. 
12. print(sum(a, b, c, d), length(), mean(a, b, c, d))

Accepted Answer

The environment when the line 10 is being executed is shown below :

Question 20

Question 14Draw flow of execution for the above program.

Accepted Answer

The flow of execution for the above program is as follows :1 → 6 → 9 → 12 → 1 → 2 → 3 → 4 → 6 → 7 → 9 → 10 → 12Line 1 is executed and determined that it is a function header, so entire function-body (i.e, lines 2, 3, 4) is ignored.Then line 6 is executed and determined that it is a function header, so entire function-body (i.e, line 7) is ignored, Line 9 is executed and determined that it is a function header, so entire function-body (i.e, line 10) is ignored. Then line 12 is executed and it has a function calls, so control jumps to the function header (line 1) and then first line of function-body, i.e, line 2, function returns after line 4 to function call line (line 12) and then control jumps to line 6, it is a function header and then first line of function-body, i.e., line 7, function returns after line 7 to function call line (line 12) and then control jumps to line 9, it is a function header and then first line of function-body, i.e., line 10, function returns after line 10 to function call line 12.

Working with Functions

Checkpoint 31

Type A Short Answer Questionsconceptual Questions

Type B Application Based Questions