Working with functions

Type A: Short Answer Questions/Conceptual Questions

Question 1: A program having multiple functions is considered better designed

than a program without any functions. Why?
Answer: A program having multiple functions is considered better designed than a
program without any functions because

1. It makes program handling easier as only a small part of the program is dealt
with at a time, thereby avoiding ambiguity.
2. It reduces program size.
3. Functions make a program more readable and understandable to a
programmer thereby making program management much easier.

Question 2: What all information does a function header give you about the
function ?
Answer: Function header is the first line of function definition that begins with
keyword def and ends with a colon (:), specifies the name of the function and its
parameters.

Question 3: What do you understand by flow of execution?

Answer: Flow of execution refers to the order in which statements are executed
during a program run.

Question 4: What are arguments ? What are parameters ? How are these two
terms different yet related ? Give example.
Answer: Arguments — The values being passed through a function-call statement
are called arguments.
Parameters — The values received in the function definition/header are called
parameters.
Arguments appear in function call statement whereas parameters appear in
function header. The two terms are related because the values passed through
arguments while calling a function are received by parameters in the function
definition.

For example :

def multiply(a, b):

print(a * b)
multiply(3, 4)

Here, a and b are parameters while 3, 4 are arguments.

Question 5: What is the utility of: (i) default arguments, (ii) keyword arguments ?
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 6: Explain with a code example the usage of default arguments and
keyword arguments.
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")

Output

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

Output

Alice 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 7: Describe the different styles of functions in Python using appropriate

examples.
Answer: The different styles of functions in Python are as follows :

1. 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.
 2. 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.

3. 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 8: Differentiate between fruitful functions and non-fruitful functions.

Answer:

Fruitful functions Non-fruitful functions

Functions returning some value are Functions that does not return any value are called
called as fruitful functions. as non-fruitful functions.

They are also called as non-void

They are also called as void functions.
functions.

They have return statements in the They may or may not have a return statement, but if
syntax : return<value>. they do, it typically appears as per syntax : return

Fruitful functions return some computed Non-fruitful functions return legal empty value of
result in terms of a value. Python, which is None, to their caller.

Question 9: Can a function return multiple values ? How ?

Answer: Yes, a function can return multiple values. To return multiple values from
a function, we have to ensure following things :

1. The return statement inside a function body should be of the form :

return
<value1/variable1/expression1>,<value2/variable2/expression2>
,....

2. The function call statement should receive or use the returned values in one of
the following ways :

(a) Either receives the returned values in form a tuple variable.

(b) Or we can directly unpack the received values of tuple by specifying the same
number of variables on the left-hand side of the assignment in function call.

Question 10: What is scope ? What is the scope resolving rule of Python ?
Answer: Scope refers to part(s) of program within which a name is legal and
accessible. When we access a variable from within a program or function, Python
follows name resolution rule, also known as LEGB rule. When Python encounters a
name (variable or function), it first searches the local scope (L), then the enclosing
scope (E), then the global scope (G), and finally the built-in scope (B).

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

Local variable Global variable

A local variable is a variable defined within a A global variable is a variable defined in the
function. 'main' program.

They are only accessible within the block in They are accessible from anywhere within th
which they are defined. program, including inside functions.

These variables have local scope. These variables have global scope.

The lifetime of a local variable is limited to the Global variables persist throughout the entire
block of code in which it is defined. Once the execution of the program. They are created
execution exits that block, the local variable is when the program starts and are only
destroyed, and its memory is released. destroyed when the program terminates.

Question 12: When is global statement used ? Why is its use not recommended ?
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 13: Write the term suitable for following descriptions:

(a) A name inside the parentheses of a function header that can receive a value.

(b) An argument passed to a specific parameter using the parameter name.

(c) A value passed to a function parameter.

(d) A value assigned to a parameter name in the function header.

(e) A value assigned to a parameter name in the function call.

(f) A name defined outside all function definitions.

(g) A variable created inside a function body.

Answer: (a) Parameter

(b) Keyword argument

(c) Argument

(d) Default value

(e) Keyword argument

(f) Global variable

(g) Local variable

Question 14: What 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.
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.

Type B: Application Based Questions

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

total = 0
def sum(arg1, arg2):
total = arg1 + arg2
print("Total :", total)
return total
sum(10, 20)
print("Total :", total)

Output

Total : 30
Total : 0

Explanation

1. There is an indentation error in second line.

2. The return statement should be indented inside function and it should not
end with semicolon.
3. Function call should not end with semicolon.

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

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

Output

6
21

Explanation

1. There should be a colon (:) at the end of the function definition line to
indicate the start of the function block.
2. Python's built-in function for generating sequences is range(), not
Range().
3. Python keywords like return should be in lowercase.
 4. When calling a function in python, the arguments passed to the function
should be enclosed inside parentheses () not square brackets [].

Question 2: Find 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)

Answer: Output

300 @ 200
300 @ 100
120 @ 100
300 @ 120

Explanation
1. Function Call is defined with two parameters P and Q with default values 40
and 20 respectively.
2. Inside the function Call, P is reassigned to the sum of its original value P and
the value of Q.
3. Q is reassigned to the difference between the new value of P and the original
value of Q.
4. Prints the current values of P and Q separated by @.
5. The function returns the final value of P.
6. Two variables R and S are initialized with values 200 and 100 respectively.
7. 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.
8. 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 3: Consider the following code and write the flow of execution for this.
Line numbers have been given for your reference.

1. def power(b, p):

2. y = b ** p
3. return y
4.
5. def calcSquare(x):
6. a = power(x, 2)
7. return a
8.
9. n = 5
10. result = calcSquare(n)
11. print(result)

Answer: The flow of execution for the above program is as follows :

1 → 5 → 9 → 10 → 5 → 6 → 1 → 2 → 3 → 6 → 7 → 10 → 11

Explanation: Line 1 is executed and determined that it is a function header, so

entire function-body (i.e., lines 2 and 3) is ignored. Line 5 is executed and
determined that it is a function header, so entire function-body (i.e., lines 6 and 7)
is ignored. Lines 9 and 10 are executed, line 10 has a function call, so control
jumps to function header (line 5) and then to first line of function-body, i.e., line 6, it
has a function call , so control jumps to function header (line 1) and then to first line
of function-body, i.e, line 2. Function returns after line 3 to line 6 and then returns
after line 7 to line containing function call statement i.e, line 10 and then to line 11.

Question 4: What will the following function return ?

def addEm(x, y, z):

print(x + y + z)

Answer: The function addEm will return None. The provided function addEm takes
three parameters x, y, and z, calculates their sum, and then prints the result.
However, it doesn't explicitly return any value. In python, when a function doesn't
have a return statement, it implicitly returns None. Therefore, the function addEm
will return None.

Question 5: What will the following function print when called ?

def addEm(x, y, z):

return x + y + z
print(x + y + z)

Answer: The function addEm prints nothing when called.

Explanation

1. The function addEm(x, y, z) takes three parameters x, y, and z.

2. It returns the sum of x, y, and z.
3. Since the return statement is encountered first, the function exits
immediately after returning the sum. The print statement after the return
statement is never executed. Therefore, it prints nothing.

Question 6(i): What will be the output of following program ?

num = 1
def myfunc():
return num
print(num)
print(myfunc())
print(num)

Answer: Output

1
1
1

Explanation

The code initializes a global variable num with 1. myfunc just returns this global
variable. Hence, all the three print statements print 1.

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)

Answer: Output

1
10
1

Explanation

1. num = 1 — This line assigns the value 1 to the global variable num.
2. def myfunc() — This line defines a function named myfunc.
3. print(num) — This line prints the value of the global variable num, which
is 1.
4. 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.
5. print(num) — This line prints the value of the global variable num, which
is still 1.

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)

Answer: Output

1
10
10
Explanation

1. num = 1 — This line assigns the value 1 to the global variable num.
2. def myfunc() — This line defines a function named myfunc.
3. print(num) — This line prints the value of the global variable num, which
is 1.
4. 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.
5. print(num) — This line prints the value of the global variable num again,
which is still 1.

Question 6(iv): What will be the output of following program ?

def display():
print("Hello", end='')
display()
print("there!")

Answer: Output

Hellothere!

Explanation: The 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 7: Predict the output of the following code :

a = 10
y = 5
def myfunc():
y = a
a = 2
print("y =", y, "a =", a)
print("a + y =", a + y)
return a + y
print("y =", y, "a =", a)
print(myfunc())
print("y =", y, "a =", a)

Answer: The code raises an error when executed.

Explanation: In the provided code, the global variables a and y are initialized to 10
and 5, respectively. Inside the myfunc function, the line a = 2 suggests that a is
a local variable of myfunc. But the line before it, y = a is trying to assign the
value of local variable a to local variable y even before local variable a is defined.
Therefore, this code raises an UnboundLocalError.

Question 8: What is wrong with the following function definition ?

def addEm(x, y, z):

return x + y + z
 print("the answer is", x + y + z)

Answer: In the above function definition, the line print("the answer is", x
+ y + z) is placed after the return statement. In python, once a return statement
is encountered, the function exits immediately, and any subsequent code in the
function is not executed. Therefore, the print statement will never be executed.

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

Answer:

def fun():
return

Explanation

def 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 10: Consider the code below and answer the questions that follow :

def multiply(number1, number2):

answer = number1 * number2
print(number1, 'times', number2, '=', answer)
return(answer)
output = multiply(5, 5)

(i) When the code above is executed, what prints out ?

(ii) What is variable output equal to after the code is executed ?

Answer

(i) When the code above is executed, it prints:

5 times 5 = 25
(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 11: Consider 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 ?

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 12(a): Find the errors in code given below :

def minus(total, decrement)

output = total - decrement
print(output)
return (output)

Answer: The errors in the code are:

def minus(total, decrement) # Error 1

output = total - decrement
print(output)
return (output)

1. 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 12(b): Find the errors in code given below :

define check()
N = input ('Enter N: ')
i = 3
answer = 1 + i ** 4 / N
Return answer

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 3

1. The function definition lacks a colon at the end.

2. 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.
3. 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 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"):)

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 5

1. The second return statement in the alpha function (return n) is unreachable

because the first return statement return beta(string) exits the
function.
2. 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.
3. There should not be colon at the end in the function call.
4. In the function call beta(string = 'true'), there should be argument
for parameter n.
5. 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 13: Draw 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))

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

Question 14: Draw flow of execution for the above program.

Answer: The flow of execution for the above program is as follows :

1 → 6 → 9 → 12 → 1 → 2 → 3 → 4 → 6 → 7 → 9 → 10 → 12

Line 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.
Question 15: Find and write the output of the following python code :

a = 10
def call():
global a
a = 15
b = 20
print(a)
call()

Answer: Output

15
Explanation

1. a = 10 — This line assigns the value 10 to the global variable a.

2. def call() — This line defines a function named call.
3. a = 15 — Inside the call function, this line assigns the value 15 to the
global variable a. As global keyword is used earlier, this assignment
modifies the value of the global variable a.
4. b = 20 — Inside the call function, this line assigns the value 20 to a local
variable b.
5. print(a) — This line prints the value of the global variable a, which is 15.
This is because we've modified the global variable a inside the call function.

Question 16: In the following code, which variables are in the same scope ?

def func1():
a = 1
b = 2

def func2():
c = 3
d = 4
e = 5

Answer: In the code, variables a and b are in the same scope because they are
defined within the same function func1(). Similarly, variables c and d are in the
same scope because they are defined within the same function func2(). e being
a global variable is not in the same scope.

Question 17: Write a program with a function that takes an integer and prints the
number that follows after it. Call the function with these arguments :

4, 6, 8, 2 + 1, 4 - 3 * 2, -3 -2

Answer

1. def print_number(number):
2. next_number = number + 1
3. print("The number following", number, "is",
next_number)
4. print_number(4)
5. print_number(6)
6. print_number(8)
7. print_number(2 + 1)
8. print_number(4 - 3 * 2)
9. print_number(- 3 - 2)

Output

The print_number following 4 is 5

The print_number following 6 is 7
The print_number following 8 is 9
The print_number following 3 is 4
The print_number following -2 is -1
The print_number following -5 is -4

Explanation

1. def print_number(number) — This line defines a function

named print_number that takes one argument number.
2. next_number = number + 1 — Inside the print_number function, this
line calculates the next number after the input number by adding 1 to it and
assigns the result to the variable next_number.
3. print("The number following", number, "is",
next_number) — Inside the print_number function, this line prints a
message stating the number and its following number.
4. Then the print_number function is called multiple times with 4, 6, 8, 3 ,((4
- 3 * 2) = -2), ((-3-2) = -5) as arguments.

Question 18: Write a program with non-void version of above function and then
write flow of execution for both the programs.

Answer: The non-void version of above code is as shown below :

1. def print_number(number):
2. next_number = number + 1
3. return next_number
4. print(print_number(4))
5. print(print_number(6))
6. print(print_number(8))
7. print(print_number(2 + 1))
8. print(print_number(4 - 3 * 2))
9. print(print_number(-3 - 2))

Output

5
7
9
4
-1
-4

Explanation

1. def print_number(number) — This line defines a function

named print_number that takes one argument number.
 2. next_number = number + 1 — Inside the print_number function, this
line calculates the next number after the input number by adding 1 to it and
assigns the result to the variable next_number.
3. return next_number — Inside the print_number function, this line
returns next_number.
4. Then the print_number function is called multiple times with 4, 6, 8, 3 ,((4
- 3 * 2) = -2), ((-3-2) = -5) as arguments.
The flow of execution for the above program with non-void version is as follows :

1→4→1→2→3→4→5→1→2→3→5→6→1→2→3→6→7→1
→2→3→7→8→1→2→3→8→9→1→2→3→9

Line 1 is executed and determined that it is a function header, so entire function-

body (i.e., line 2 and 3) is ignored. Then line 4 is executed and it has function call,
so control jumps to the function header (line 1) and then to first line of function-
body, i.e., line 2, function returns after line 3 to line containing function call
statement i.e., line 4. The next lines 5, 6, 7, 8, 9 have function calls so they repeat
the above steps.

The flow of execution for the void version program is as follows :

1→4→1→2→3→4→5→1→2→3→5→6→1→2→3→6→7→1
→2→3→7→8→1→2→3→8→9→1→2→3→9

Line 1 is executed and determined that it is a function header, so entire function-

body (i.e., line 2 and 3) is ignored. Then line 4 is executed and it has function call,
so control jumps to the function header (line 1) and then to first line of function-
body, i.e., line 2, function returns after line 3 to line containing function call
statement i.e., line 4. The next lines 5, 6, 7, 8, 9 have function calls so they repeat
the above steps.

Question 19(i): What is the output of following code fragments ?

def increment(n):
n.append([4])
return n
L = [1, 2, 3]
M = increment(L)
print(L, M)

Answer: Output

[1, 2, 3, [4]] [1, 2, 3, [4]]

Explanation: In the code, the function increment appends [4] to list n, modifying
it in place. When L = [1, 2, 3], calling increment(L) changes L to [1, 2, 3,
[4]]. Variable M receives the same modified list [1, 2, 3, [4]], representing L. Thus,
printing L and M results in [1, 2, 3, [4]], confirming they reference the same list.
Therefore, modifications made to list inside a function affect the original list passed
to the function.

Question 19(ii): What is the output of following code fragments ?

def increment(n):
n.append([49])
 return n[0], n[1], n[2], n[3]
L = [23, 35, 47]
m1, m2, m3, m4 = increment(L)
print(L)
print(m1, m2, m3, m4)
print(L[3] == m4)

Answer: Output

[23, 35, 47, [49]]

23 35 47 [49]
True

Explanation: The function increment appends [49] to list n and returns its first
four elements individually. When L = [23, 35, 47],
calling increment(L) modifies L to [23, 35, 47, [49]]. Variables m1, m2, m3,
and m4 are assigned the same list [23, 35, 47, [49]], representing the original list
L. Thus, printing L and m1, m2, m3, m4 yields [23, 35, 47, [49]]. The expression
L[3] == m4 evaluates to True, indicating that the fourth element of L is the same as
m4.

Question 20: What will be the output of the following Python code ?

V = 25
def Fun(Ch):
V = 50
print(V, end = Ch)
V *= 2
print(V, end = Ch)
print(V, end = "*")
Fun("!")
print(V)

1. 25*50!100!25
2. 50*100!100!100
3. 25*50!100!100
4. Error

Answer: 25*50!100!25
Explanation

1. V = 25 — initializes global variable V to 25.

2. print(V, end = "*") — Prints the global variable V (25) followed by an
asterisk without a newline.
3. Fun("!") — Calls the function Fun with the argument "!".
4. Inside function Fun, V = 50 initializes a local variable V within the function
with the value 50. This variable is different from the global variable V that
has the value 25.
5. print(V, end = Ch) — Prints the local variable V (50) followed by the
character passed as an argument to the function, which is "!".
6. V *= 2 — Multiplies the local variable V (50) by 2, making it 100.
7. print(V, end = Ch) — Prints the updated local variable V (100)
followed by the character "!".
8. The function Fun returns and the line print(V) is executed. It prints the
global variable V without any newline character. The global
variable V remains unchanged (25).