Explore topic-wise InterviewSolutions in Current Affairs.

Output:

Inside add ( ) function x value is: 5.

In main x value is: 5

The return Statement

1. The return statement causes your function to exit and returns a value to its caller. The point of functions in general is to take inputs and return something.

2. The return statement is used when a function is ready to return a value to its caller. So, only one return statement is executed at run time even though the function contains multiple return statements.

3. Any number of ‘return’ statements are allowed in a function definition but only one of them is executed at run time.

def function _name (*args): 

function_body

return_statement

Nested Block:

A block within a block is called nested block. When the first block statement is indented by a single tab space, the second block of statement is indented by double tab spaces.

In Variable Length arguments we can pass the arguments using two methods.

1. Non keyword variable arguments

2. Keyword variable arguments

1. Required arguments

2. Keyword arguments

3. Default arguments

4. Variable – length arguments

Any Loop can be converted to recursive functions True

Program:

def printdata (name, age):

print (“Example – 3 Keyword arguments”)

print (“Name :” ,name)

print (“Age age)

return

# Now you can call printdata ( ) function

printdata (age = 25, name = “Gshan”)

Output:

Example – 3 Keyword arguments

Name: Gshan

Age: 25

Default Arguments

In Python the default argument is an argument that takes a default value if no value is provided in the function call. The following example uses default arguments, that prints default salary when no argument is passed, def printinfo(sal=3500):

Parameters are the variables used in the function definition whereas arguments are the values we pass to the function parameters

The default precision for fixed point number is 6

Rules of local variable: 

1. A variable with local scope can be accessed only within the function/block that it is created in. 

2. When a variable is created inside the function/block, the variable becomes local to it. 

3. A local variable only exists while the function is executing. 

4. The formate arguments are also local to function.

The value returned by a function may be used as an argument for another function in a nested manner. This is called composition. For example, if we wish to take a numeric value or an expression as a input from the user, we take the input string from the user using the function input ( ) and apply eval ( ) function to evaluate its value

1. Function blocks begin with the keyword “def ” followed by function name and parenthesis ( ).

2. Any input parameters or arguments should be placed within these parentheses when you define a function.

3. The code block always comes after a colon (:) and is indented.

4. The statement “return [expression]” exits a function, optionally passing back an expression to the caller. A “return” with no arguments is the same as return None

Def is used to define the function testpython():

1. User – defined Functions

2. Built – in Functions

3. Lambda Functions

4. Recursion Functions

(b) x % 4 = = 0

(a) (I) is correct and (II) is wrong

Output:

(i) 1. 13

2. 3.2

(ii) 1. 50

2. 36

(iii) <class 'str'>

(iv) 0b10000

(v). 1. CR (carriage return)

2. It moves the cursor to the beginning of same line 

(vi) 1. 8.2 

2. 18.0 

3. 0.510

4. 0.512

(vii) 1. B 

2. a 

3. A 

4. 6 

5. 10

(viii) 1. 0.125

2. 8.0

3. 1

bin ( ) returns the binary string prefixed with ob for the given integer number

(b) Local and global variables can be used in the same code

(b) Format ( )

The Ord ( ) function is the inverse of chr ( ) function.

(c) Without global keyword, we can modify the global variable

(a) Global keyword outside the function has no effect

Lambda functions cannot be used in combination with Print

(a) Required

Answer is (c) : (colon)

Def is used to begin the function block

A Function which calls itself is called as Recursion

A named blocks of code that are designed to do one specific job is called as Function

Return is used to exit a function block

Lambda is called anonymous un – named function

n = int (input(“Enter any year”))

if (n % 4 = = 0):

print “Leap year”

else:

print “Not a Leap year”

Output:

Enter any year 2001

Not a Leap year

There are 2 types of scopes

In python’s Print function supports variable length arguments.

If the return has no argument, None will be displayed as the last statement of the output.

Scope of Variables:

Scope of variable refers to the part of the program, where it is accessible, i.e., area where you can refer (use) it. We can say that scope holds the current set of variables and their values. The two types of scopes are local scope and global scope.

(I) Local scope:

A variable declared inside the function’s body or in the local scope is called as local variable

Rules of local variable:

1. A variable with local scope can be accessed only within the function/block that it is created in.

2. When a variable is created inside the function/block; the variable becomes local to it.

3. A local variable only exists while the function is executing.

4. The formate arguments are also local to function.

Example:

Create a Local Variable

def loc ( ):

y = 0 # local scope

print (y)

loc ( )

Output:

0

(II) Global Scope:

A variable, with global scope can be used anywhere in the program. It can be created by defining a variable outside the scope of any function/block.

Rules of global Keyword:

The basic rules for global keyword in Python are:

1. When we define a variable outside a function, it’s global by default. You don’t have to useglobal keyword.

2. We use global keyword to read and write a global variable inside a function.

3. Use of global keyword outside a function has no effect

Example:

Global variable and Local variable with same name 

x = 5 def loc ( ):

x = 10

print (“local x:” , x)

loc ( )

print (“global x:” , x)

Output:

local x: 10

global x: 5

In above code, we used same name ‘x’ for both global variable and local variable. We get different result when we print same variable because the variable is declared in both scopes, i.e. the local scope inside the function loc() and global scope outside the function loc ( ).

The output:- local x: 10, is called local scope of variable.

The output: – global x: 5, is called global scope of variable.

Lambda function can only access Global variables

It will change the global variable value outside the function also.

A block of code begins when a line is indented by 4 spaces usually

A Block is one or more lines of code,

Name of the function is followed by ( )

Non – keyword variable arguments are called Tuples

* is the symbol used to denote variable – length arguments

A block within a block is called Nested block.

The basic rules for global keyword in Python are:

1. When we define a variable outside a function, it’s global by default. You don’t have to use global keyword.

2. We use global keyword to read and write a global variable inside a function.

3. Use of global keyword outside a function has no effect

The arguments can be given in improper order in Keyword arguments.