Functions

Both A and R are true and R is the correct explanation of A.

Explanation
Functions in Python can take input values as parameters, perform operations on them, and return output if needed using the return statement. A function in Python can return multiple values using a single return statement by separating the values with commas.

A is true but R is false.

Explanation
Positional arguments are those arguments in a function call that match the number and order of arguments as defined in the function definition. During a function call, the argument list can contain positional arguments first, followed by default arguments if there are any.

Both A and R are true but R is not the correct explanation of A.

Explanation
Local variables have a limited scope and are accessible only within the function or block where they are defined. On the other hand, global variables have a broader scope and can be accessed from any part of the program, including functions and blocks.

A is false but R is true.

Explanation
When a variable shares the same name both locally within a function and globally outside it, the Python interpreter treats them differently based on the scope where they are accessed. Local variables, declared within a function, are accessible only within that function and don't affect the global variable of the same name. The interpreter prioritizes the local variable over the global one within the function's scope. However, globally declared variables are accessible throughout the program, and their value can be modified or accessed from any function or block.

A is true but R is false.

Explanation
Built-in functions are developed and defined by language programmers and provided within the framework of the programming language itself. They are designed to perform specific tasks and are not tied to any particular module or object. In Python, built-in functions are part of the built-in namespace and are accessible throughout the program without the need to import specific modules.

Both A and R are true and R is the correct explanation of A.

Explanation
Positional arguments in Python must be passed in the same order as their respective parameters in the function definition. This means that the first argument passed will be assigned to the first parameter, the second argument to the second parameter, and so on. As positional arguments are those arguments in a function call that match the number and order of arguments as defined in the function definition.

def

Reason — Functions in Python are defined as per the following format :

def function_name(parameters):
    statements

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

return

Reason — The return statement in a function specifies the value to be sent back to the calling function and also signifies the end of the function's execution.

void functions

Reason — Functions that do not return any value are known as void functions because they do not produce any output or result that can be used in the calling code.

local

Reason — A variable created or defined within a function body is classified as a local variable because it is only accessible and usable within that specific function and the other blocks contained under it.

default

Reason — Default arguments are used with implicit values that are used if no value is provided when calling the function. This is because default arguments are predefined values assigned to parameters in a function.

return

Reason — The return statement is used by functions to communicate information back to the caller. It allows functions to send a specific value or result back to the code that called the function, which can then be used for further processing or operations.

x is now 50

Reason — The output of the program will be x is now 50. This is because the variable x inside the func function is a local variable, so any changes made to it inside the function do not affect the global variable x defined outside the function. Therefore, after calling the func function, the value of x remains unchanged and is still 50 when printed.

A function execution instance that calls another execution instance of the same function

Reason — Recursion is defined as a function execution instance that calls another execution instance of the same function. In recursive functions, the function calls itself, creating a chain of function calls where each instance of the function invokes another instance until a termination condition is met.

num*fact (num-1)

Reason — The fact function is designed to calculate the factorial of a given number through recursion. It checks if the input num is zero; if so, it returns 1 as the factorial of 0 is defined as 1. Otherwise, it recursively calls itself with the argument num-1, reducing num with each call until reaching 0, which serves as the base case to stop recursion. During each recursive call, the function multiplies the current num by the factorial of num-1, effectively computing the factorial of the original input number through successive multiplications until the base case is reached.

Every recursive function must have a return value.

Reason — The statement "Every recursive function must have a return value" is false because recursive functions in Python don't necessarily have to return a value.

100

Reason — Initially, the function fun is called with the argument 45. Since 45 is less than 100, the else block is executed, and fun is called recursively with the argument fun(n+11). This leads to another recursive call fun(56), as 45 + 11 = 56. Again, since 56 is less than 100, the else block is executed, and another recursive call fun(n+11) is made with n = 67. This process continues until n exceeds 100, at which point the base case is triggered.

Program gets into an infinite loop

Reason — When the base condition in a recursive program is not properly defined, the recursive calls continue indefinitely without a stopping criterion. This leads to an infinite loop where the program keeps executing recursive calls without making progress towards a termination point.

A program having multiple functions is considered better designed than a program without any functions because:

1. Program handling becomes easier: Only a small part of the program is dealt with at a time.
2. Code reusability: A Python function can be defined once and used many times. So, it results in code reuse, we don't need to write the same code more than once.
3. Compact code: While working with functions, a common set of code is written only once and can be called from any part of the program which reduces lines of code and programming overheads.
4. Easy updation: If we need to update a formula or expression, changes must be made everywhere it's used, risking errors. Using functions simplifies this by making changes in only one place (which is function itself).

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

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

The different types 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.

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

(a) Parameter

(b) Keyword argument

(c) Argument

(d) Keyword argument

(e) Global variable

(f) Local variable

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. It calculates their sum, which is 30, and then prints it. However, it doesn't explicitly return any value. In Python, when a function doesn't have a return statement, it implicitly returns None.

When the addEM() function is called or executed, there will be no output displayed because there is no print statement.

When the function addEM(x, y, z) is called with the values 20 for each of its parameters (x, y, and z), it calculates their sum (20 + 20 + 20), which equals 60. Since the function uses the return keyword to return this calculated sum, calling addEM(20, 20, 20) will return 60.

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
None
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. global num — Inside the myfunc function, this line declares that the variable num is a global variable, meaning it refers to the num variable defined outside the function.
4. num = 10 — Inside the myfunc function, this line changes the value of the global variable num to 10.
5. print(num) — This line prints the value of the global variable num, which is still 1 at this point as myfunc hasn't been called yet.
6. print(myfunc()) — This line calls the myfunc function. However, since the function doesn't have a return statement, it implicitly returns None, which is then printed.
7. print(num) — Finally, this line prints the value of the global variable num after the myfunc function has been called, which is now 10 due to the assignment inside the function.

Hello
bye!

1. def display(): — This line defines a function named display with no parameters.
2. print("Hello",) — Inside the display function, it prints the string "Hello".
3. display() — This line calls the display function, which then prints "Hello" due to the print statement inside the function.
4. print("bye!") — This line prints "bye!" on a new line.

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.

y= 5 a= 10
y= 10 a= 2
a+y 12
12
y= 5 a= 10

1. a = 10 — This line assigns the value 10 to the global variable a.
2. y = 5 — This line assigns the value 5 to the global variable y.
3. def myfunc(a): — This line defines a function named myfunc that takes a parameter a.
4. y = a — This line assigns the value of the parameter a (which is 10) to the local variable y within the function.
5. a = 2 — This line assigns the value 2 to the local variable a within the function, effectively shadowing the global variable a.
6. print("y=", y, "a=", a) — This line prints the values of the local variables y and a within the function.
7. print("a+y", a + y) — This line prints the sum of the local variables a and y within the function.
8. return a + y — This line returns the sum of the local variables a and y within the function.
9. print("y=", y, "a=", a) — This line prints the values of the global variables y and a outside the function.
10. print(myfunc(a)) — This line calls the myfunc function with the value of the global variable a (which is 10) as an argument and prints the returned value.
11. print("y=", y, "a=", a) — This line prints the values of the global variables y and a again.

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  #Error 3                        
    Return answer #Error 4

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. Parenthesis should be closed after input() function.
3. In Python, variable names are case-sensitive. So if we define a variable as 'I', we should use it consistently as 'I' throughout code.
4. The return statement should be in lowercase. If a variable is named 'Answer' (with an uppercase first letter), it should be used consistently with that casing throughout the program.

The corrected code is given below:

def check():
    N = int(input('Enter N:'))
    I = 3
    Answer = 1 + I ** 4 / N
    return Answer

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

Execution always begins at the first statement of the program. Statements are executed one at a time, starting from the top to the bottom. Function definition does not alter the flow of execution of a program, as the statement inside the function is not executed until the function is called. On a function call, instead of going to the next statement of the program, the control jumps to the body of the function, executes all statements of the function, starting from the top to the bottom and then comes back to the point where it left off.

Recursion refers to a programming technique in which a function calls itself either directly or indirectly.

The advantages of using recursion are as follows :

1. Recursion can simplify the solution to complex problems by breaking them down into smaller, more manageable sub-problems.
2. Recursive solutions often result in simple and concise code compared to iterative approaches, especially for problems that involve repeated patterns or structures.
3. Recursion can make code easier to understand.
4. Recursive functions can handle problems of variable size without requiring changes to the function itself, as long as the base case and recursive cases are properly defined.

The disadvantages of using recursion are as follows :

1. It consumes more storage space because the recursive calls along with local variables are stored on the stack.
2. The computer may run out of memory if the recursive calls are not checked.
3. It is less efficient in terms of speed and execution time.

A recursive function is a function that calls itself directly or indirectly in order to solve a problem.

One advantage of using recursive functions is their ability to solve problems in a simple and concise manner.

The base case and recursive case are the two cases required in a recursive function.

Base case is the termination condition that defines when the recursion should stop. It prevents the function from infinitely calling itself and ensures that the recursion reaches a stopping point.

Recursive case is the case where the function calls itself with a modified input, moving towards the base case. It allows the function to break down the problem into smaller instances of the same problem until reaching the base case.

Yes, it is necessary to have a base case in a recursive function. Without a base case, the recursive function would continue calling itself indefinitely, leading to infinite recursion. This can cause the program to run out of memory and crash, resulting in an error. The base case provides a condition that stops the recursion, allowing the function to return a result and terminate.

The base case(s) in the given recursive function function1 are:

1. if n == 0: - This is the first base case, which returns a specific value (5) when n is equal to 0.

2. elif n == 1: - This is the second base case, which returns another specific value (8) when n is equal to 1.

These base cases provide termination conditions for the recursive function, ensuring that it stops calling itself when n reaches 0 or 1.

When a loop is executed repeatedly, it uses the same memory locations for variables and repeats the same unit of code. On the other hand, recursion allocates fresh memory space for each recursive call, avoiding the repetition of code and the reuse of memory locations for variables. Due to stack manipulation and the allocation of additional memory space, recursive functions often run slower and consume more memory than their iterative counterparts.

1. Memory Space: — Iterative solutions require less memory space because they reuse the same variables and memory locations for each iteration of the loop. Memory allocation is minimal, leading to efficient memory usage. On the other hand, recursive solutions require more memory space compared to iteration. This is because recursion involves creating a new stack for each recursive call, storing local variables and function calls. As a result, recursion can lead to higher memory consumption.
2. Speed: — Iterative solutions are faster in terms of execution speed compared to recursion. Since iteration involves a simple loop structure that directly manipulates variables, it results in faster execution times. On the other hand, recursive solutions are slower than their iterative counterparts due to the overhead of function calls and stack manipulation.

3
15

The code defines a function code(n) that takes a single argument n. Inside the function, if the input n is equal to 0, it prints "Finally", otherwise, it prints the value of n. When called with code(3), it passes the argument 3 to the function. Since 3 is not equal to 0, the function prints 3. Similarly, calling code(15) prints 15 as it also doesn't meet the condition for 0.

Finally
15

The code defines a function code(n) that takes a single argument n. Inside the function, if the input n is equal to 0, it prints "Finally", otherwise, it prints the value of n. In the first function call code(2-2), the expression 2-2 evaluates to 0, so the function prints "Finally". Conversely, in the second function call code(15), the value 15 is not equal to 0, so the function prints 15.

10

This code defines a function called code(n) that takes a single argument n. Inside the function, there's a conditional statement that checks if n is equal to 0. If n is indeed 0, it prints the string " Finally". Otherwise, it prints the value of n. When the function code(10) is called, it passes the argument 10 to the function. Since 10 is not equal to 0, the function prints 10.

10
7

This code defines a function code(n) that takes a single argument n. Inside the function, there's a conditional statement that checks if n is equal to 0. If n is indeed 0, it prints the string "Finally". Otherwise, it prints the value of n and then calculates and prints n-3. When the function code(10) is called, it passes the argument 10 to the function. Since 10 is not equal to 0, the function first prints 10 and then calculates and prints 10-3, which is 7.

The code will not print anything because it doesn't include a print statement. Instead, it returns a value without displaying it.

The code defines a recursive function express(x, n) that takes two arguments x, n. Inside the function, it checks for three conditions: if n is 0, it returns 1; if n is even (checked using the modulo operator), it recursively calls itself with x*x and n/2; and if n is odd, it recursively calls itself with x and n-1, then multiplies the result by x. When express(2, 5) is called, it eventually evaluates to 32 but does not print or display anything.

True is returned by check(8).

The provided code defines a recursive function check(n) that takes single argument. Inside the function, it checks if a given number n is less than or equal to 1, in which case it returns True. If n is even (i.e., divisible by 2 without a remainder), the function recursively calls itself with n/2. If n is odd, it recursively calls itself with n/1 (which effectively does not change n). However, the condition n/1 doesn't modify n and leads to an infinite recursion for odd numbers greater than 1, causing the function to keep calling itself indefinitely without reaching a base case.

Yes, there is a error in the provided code. If we evaluate check(3), it will result in an infinite recursion and eventually lead to an error.

This happens because when check(3) is called, the function first checks if n is less than or equal to 1, which is not the case. Since n is odd (i.e., n % 2 == 1), it enters the else block and calls check(n/1) which leads to the same value of n being passed recursively to the function without any change. As a result, the function keeps calling itself with the same value of n, leading to an infinite loop of recursion.

1.

12 6 3 1 1 2 4 2 1 

2.

10 5 2 1 3 1 1 

3.

7 3 1 1 2 

The provided code defines a recursive function Fn(n) that prints the value of n and then checks if n is less than 3. If n is less than 3, the function returns n. Otherwise, it recursively calls itself with n//2 (integer division by 2) and subtracts the result of another recursive call with n//3 (integer division by 3).

The error in the provided code is that inside the else block the value of p is modified after the recursive call. This leads to an infinite recursion because p remains the same in each recursive call, never reaching the base case (p == 0) and causing the program to enter an infinite loop.

The corrected code is:

def recur(p):
    if p == 0:
        print("##")
    else:
        recur(p - 1)

In this corrected version, p is decremented by 1 in each recursive call, ensuring that the recursive process eventually reaches the base case where p == 0 and terminates the recursion.

(a) abs()

(b) pow(x, y)

(c) math.fabs()

(a) lstrip()

(b) isupper()

(c) isspace()

True

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

False

Reason — Variables declared inside a function in Python are called local variables. These variables are local to that function and can only be accessed within that function's scope.

False

Reason — Once a function is defined in Python, it can be called multiple times from different places in a program. Functions are reusable blocks of code, and their purpose is to be called and executed whenever needed.

True

Reason — Value returning functions in Python compute a value and return it to the caller. These functions are called from within an expression where their returned value is used for further computation, assignment, or comparison.

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.

False

Reason — Python allows defining functions without specifying any arguments. These functions are known as functions with no parameters or parameterless functions.

False

Reason — Parameters specified within a pair of parentheses in a function definition are called formal parameters. These serve as placeholders for the values that will be passed to the function when it is called. Formal parameters are specified in the function definition and act as variables within the function's scope.

True

Reason — In Python, a function is used by invoking it through a function call. This involves using the function's name followed by parentheses (), which may contain arguments if the function requires any. The function call executes the code inside the function's body and then returns to the point in the code where the function was called from.

False

Reason — Built-in functions in Python are pre-defined functions that are part of the Python programming language itself. These functions are included in the Python standard library and are available for use without users needing to create them. Users can also create their own functions, which are called user-defined functions.

True

Reason — The function header starts with def keyword, followed by the function name and any parameters enclosed in parentheses. It ends with a colon (:) to indicate the beginning of the function's code block. The syntax for defining a function in Python is as follows: def function_name(parameters):.

False

Reason — When a loop is executed repeatedly, it uses the same memory locations for variables and repeats the same unit of code. On the other hand, recursion allocates fresh memory space for each recursive call, avoiding the repetition of code and the reuse of memory locations for variables. Due to stack manipulation and the allocation of additional memory space, recursive functions often run slower and consume more memory than their iterative counterparts.

True

Reason — Recursion is defined as defining anything in terms of itself. In other words, it is a method in which a function calls itself one or more times in its body.

True

Reason — Functions can alter only mutable data types because mutable data types in Python can be modified in-place, meaning their internal state can be changed by functions. This includes data types like lists, dictionaries, and sets. On the other hand, immutable data types, such as strings, tuples, and numbers, cannot be altered in-place.