What will be the output of the following Python function?
len(["hello",2, 4, 6])
4
3
Error
6
What is the value of the following Python code?
>>>print(36 / 4)
9
9.0
4.0
Every recursive function must have a base case
Infinite recursion can occur if the base case isn’t properly mentioned
A recursive function makes the code easier to understand
Every recursive function must have a return value
What will be the output?
x = 10def fun(): global x x = 20fun()print(x)
10
20
None
What is the output of the following code ?
def fun(a, b=6): a=a+b print(a)fun(5, 4)
11
5
What will be the output of the following Python code?
def foo(k): k[0] = 1 q = [0] foo(q) print(q)
[0]
[1]
[1, 0]
[0, 1]
Calling one function from another function
Calling a function repeatedly from itself
Using nested loops
Using lambda functions
What is the output of below program ?
def say(message, times =1): print(message * times)say("Hello")say("Word",5)
Hello WordWordWordWordWord
Hello Word 5
Hello Word,Word,Word,Word,Word
Hello HelloHelloHelloHelloHello
#
&
*
**
In Module
In Class
In Another function
All of these
Arguments
Subroutines
Function
Definition
Can contain multiple statements
Can have only one expression
Must use return statement
Cannot take arguments
User Defined Function
Library Functions
Builtin Functions
All of the above
datetime
date
time
timedate
def foo(): total += 1 return totaltotal = 0print(foo())
0
1
error
none of the mentioned
Lists
Dictionary
String
All of the mentioned
Required arguments
Keyword arguments
Default arguments
Variable-length arguments
def foo(x): x = ['def', 'abc'] return id(x)q = ['abc', 'def']print(id(q) == foo(q))
True
False
A function that calls other function.
A function which calls itself.
Both A and B
None of the above
function_name()
call function_name()
ret function_name()
function function_name()
def foo(): return total + 1total = 0print(foo())
Segments
Modules
Units
All the above
Parameters
def fun(a,b=5,c=10): print(a+b+c)fun(2,c=20)
27
17
22
What will be the output of the following code snippet?
numbers = (4, 7, 19, 2, 89, 45, 72, 22)sorted_numbers = sorted(numbers)odd_numbers = [x for x in sorted_numbers if x% 2!=0]print(odd_numbers)
[7, 19, 45, 89]
[2, 4, 22, 72]
[4, 7, 19, 2, 89, 45, 72, 22]
[24, 7, 19, 22, 45, 72, 89]
The variables used inside function are called local variables.
The local variables of a particular function can be used inside other functions, but these cannot be used in global space.
The variables used outside function are called global variables.
In order to change the value of global variable inside function, keyword global is used.
It’s easier to code some real-world problems using recursion than non-recursive equivalent
Recursive functions are easy to debug
Recursive calls take up a lot of memory
Programs using recursion take longer time than their non-recursive equivalent
def foo(fname, val): print(fname(val))foo(max, [1, 2, 3])foo(min, [1, 2, 3])
3 1
1 3
Program gets into an infinite loop
Program runs once
Program runs n number of times where n is the argument given to the function
An exception is thrown
What will be the output of the following python program?
def addItem(listParam): listParam+=[1]mylist=[1,2,3,4]addItem(mylist)print(len(mylist))
8
2
;
: :
:
%
Recursive function can be replaced by a non-recursive function
Recursive functions usually take more memory space than non-recursive function
Recursive functions run faster than non-recursive function
Recursion makes programs easier to understand
Choose the correct function declaration of fun1() so that we can execute the following two function calls successfully.
fun1(25, 75, 55)fun1(10, 20)
def fun1(**kwargs)
def fun1(args*)
No, it is not possible in Python
def fun1(*data)
-1
def function function_name():
declare function function_name():
def function_name():
declare function_name():
A function that calls itself
A function execution instance that calls another execution instance of the same function
A class method that calls another class method
An in-built method that is automatically called
What is the output of the following code?
x = 50def func (x): x = 2func (x)print ('x is now', x)
x is now 50
x is now 2
x is now 100
Global Scope
Built-in Scope
Local Scope
Module Scope
def s(n1): print(n1) n1=n1+2n2=4s(n2)print(n2)
6 4
4 6
4 4
6 6
What is the output of this code?
def calc(x): r=2*x**2 return rprint(calc(5))
50
100
fun
function
def
define
(x**y)**z
(x**y) / z
(x**y) % z
(x**y)*z
example = "helle" print(example.rfind("e"))
Recursive Function
Lambda Function
Built-in Function
Generator Function
Making the code look clean
A complex task can be broken into sub-problems
Recursive calls take up less memory
Sequence generation is easier than a nested iteration
What will be the output of the following Python code ?
def display(b,n): while n>0: print(b,end='') n=n-1display('z',3)
zzz
zz
Infinite loop
break
pass
continue
none of these
def fun(a, b=5): print(a+b)fun(10, 20)
15
30
25
Increases code duplication
Reduces code reusability
Promotes code reusability and modularity
Makes program slower
lambda x => x+1
lambda(x): x+1
lambda x: x+1
def lambda(x): x+1