Working with Functions

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
A function is a subprogram that acts on data and often returns a value. It is a self-contained unit of code that performs a specific task within a larger program. Functions are defined within a program and can be called upon to execute a specific set of instructions when needed.

(b)

Both Assertion and Reason are true but Reason is not the correct explanation of Assertion.

Explanation
In a function call, any parameter cannot have a default value unless all parameters appearing on its right have their default values. Hence, non-default arguments cannot follow default arguments in a function call. Python supports three types of formal arguments :

1. Positional arguments
2. Default arguments
3. keyword arguments

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
When a parameter in a function header has a default value, it means that if no value is provided for that parameter during the function call, the default value will be used. This effectively makes the parameter optional in the function call. When calling a function with default arguments, we have the option to either provide values for those arguments or omit them, in which case the default values will be used.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
Variables declared inside a function are typically local to that function, meaning they exist only within the scope of the function and they can only be accessed and used within the function in which they are declared.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
In Python, if a variable is not declared inside a function but is declared at a higher scope level (e.g., in the global scope or an enclosing scope), the function can still access and use that variable. Since Python follows the LEGB rule, variables declared at higher scope levels can be accessed within functions.

(b)

Both Assertion and Reason are true but Reason is not the correct explanation of Assertion.

Explanation
A default parameter is a parameter in a function definition that has a predefined value. When we call a function with default parameters, if we don't provide a value for a parameter, the default value specified in the function header will be used instead.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
Inside a function, you assign a value to a name which is already there in global scope, Python won't use the global scope variable because it is an assignment statement and assignment statement creates a variable by default in current environment. That means a local variable having the same name as a global variable hides the global variable in its function.

(c)

Assertion is true but Reason is false.

Explanation
If the arguments in a function call statement match the number and order of arguments as defined in the function definition, such arguments are called positional arguments. During a function call, the argument list first contains positional argument followed by default arguments because any parameter cannot have a default value unless all parameters appearing on its right have their default values.

None object

Reason — The default return value for a function that does not return any value explicitly is None.

def

Reason — The function in Python is defined as per following syntax :

def function_name(parameters):
    statements

According to this format, function definition begins with keyword def.

a stack

Reason — A stack is the area of memory, which stores the parameters and local variables of a function call.

1. Colon is missing at the end of function header.
2. There is no error.
3. The variable x is not defined.
4. def keyword at the beginning and colon at the end of function header are missing.

The corrected function definitions are:

1.  def main():  
        print("hello")

2.  def func2():  
        print(2 + 3)  

3.  def compute(x):  
        print (x * x)  

4.  def square(a):  
        return a * a 

None

Reason — The default return value for a function that does not return any value explicitly is None.

both function name and parameter list

Reason — 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.

def

Reason — The function in Python is defined as per following format :

def function_name(parameters):
    statements

According to this format, function definition begins with keyword def.

a stack

Reason — A stack is the area of memory, which stores the parameters and local variables of a function call.

return number

Reason — The syntax of return statement is :
return <value>
According to this, the correct return statement is return number.

def f(a = 1, b = 1, c = 2):

Reason — In a function header, any parameter cannot have a default value unless all parameters appearing on its right have their default values.

You can pass positional arguments in any order.

Reason — Positional arguments are passed to a function based on their positions in the function call statement. The first positional argument in the function call is assigned to the first parameter in the function definition, the second positional argument is assigned to the second parameter, and so on.

Positional parameters must occur to the right of Default parameters.

Reason — The positional parameters must occur to the left of default parameters because in a function header, any parameter cannot have a default value unless all parameters appearing on its right have their default values.

Local keyword is used to change value of a local variable in a global scope.

Reason — If you need to modify a local variable in global scope, you do so by passing it as an argument to a function and/or returning a modified value from the function.

test(1, 2, 3, 4)
test(a = 1, b = 2, c = 3, d = 4)

Reason —

1. The function call test(1, 2, 3, 4) passes four positional arguments 1, 2, 3, and 4 to the function.
2. The function call test(a = 1, b = 2, c = 3, d = 4) passes four keyword arguments, explicitly stating the parameter names (a, b, c, d) and their corresponding values.

test(a = 1, 2, 3, 4)
test(a = 1, b = 2, c = 3, 4)

Reason — In both of these function call test(a = 1, 2, 3, 4) and test(a = 1, b = 2, c = 3, 4), the syntax is incorrect because when using keyword arguments, all arguments following the first one must also be specified with keyword arguments.

Calc(Y = 25)

Reason — The function call statement must match the number and order of arguments as defined in the function definition. Here, the X positional argument is missing.

A global variable

Reason — A global variable is a variable declared in top level segment (__main__) of a program and usable inside the whole program and all blocks contained within the program.

A local variable

Reason — A local variable is a variable declared in a function-body and it can be used only within this function and the other blocks contained under it.

indentation error

Reason — The line a = a * 2 should be indented backwards otherwise it will give an error.

8

Reason — The code defines a function named print_double that takes one parameter x. Inside the function, it calculates 2 raised to the power of x using the exponentiation operator **, and then prints the result. So, when we call print_double(3), we're passing 3 as an argument to the function. The function calculates 2 ** 3, which is 8, and prints the result.

L E G B

Reason — When you 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).

default arguments

Reason — A default argument is an argument with a default value in the function header, making it optional in the function call. The function call may or may not have a value for it.

False

Reason — In a function header, any parameter cannot have a default value unless all parameters appearing on its right have their default values. Hence, non-default arguments cannot follow default argument.

True

Reason — A default parameter is a parameter having default value in the function header.

True

Reason — The first line of function definition that begins with keyword def and ends with a colon (:), which specifies the name of the function and its parameter is called function header.

False

Reason — Variables that are listed within the parentheses of a function header are called parameters.

True

Reason — The Python interpreter starts the execution of a program from top-level statements. The top-level statements are part of main program, __main__ .

False

Reason — A default parameter in function header becomes optional in function call. Function call may or may not have value for default parameters.

True

Reason — The default values for parameters are considered only if no value is provided for that parameter in the function call statement.

True

Reason — A Python function may return multiple values i.e., more than one value from a function.

True

Reason — A void function do not return a value but they return a legal empty value of Python i.e., None to its caller.

False

Reason — Variables defined inside functions have only local scope. This means that they are only accessible within the function in which they are defined.

True

Reason — Inside a function, you assign a value to a name which is already there in a global scope, Python won't use the global scope variable because it is an assignment statement and assignment statement creates a variable by default in current environment. That means a local variable having the same name as that of a global variable, hides the global variable in its function.

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.

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.

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

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.

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

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

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)

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.

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.

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

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

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.

(a) Parameter

(b) Keyword argument

(c) Argument

(d) Default value

(e) Keyword argument

(f) Global variable

(g) Local variable

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.

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

Total : 30
Total : 0

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.

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

6
21

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 [].

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

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.

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

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

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.

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.

The function addEm prints nothing when called.

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.

1
1
1

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

1
10
1

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.

1
10
10

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.

Hellothere!

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.

The code raises an error when executed.

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.

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.

def fun():
    return 

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.

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

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

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)

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

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

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

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.

15

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.

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.

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)

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

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.

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

5
7
9
4
-1
-4

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.

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

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.

[23, 35, 47, [49]]
23 35 47 [49]
True

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.

25*50!100!25

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