Explore topic-wise InterviewSolutions in .

for i in range(105, 8, -7):

print i

for i in range(10, 301, 10):

print i

i=5

while i <= 100:

print i

i = i + 5

for i in range(88, 9, -8)

print i

i=1

while i < 100:

if i % 4 == 2:

print i, “mod”, 4 , “= 2”

i = i +1

for i in range(100):

if i % 2 == 0:

print i, “is even”

else :

print i, “is odd”

Ordinarily, each print statement produces one line of output. You can end the print statement with a trailing ’ to combine the results of multiple print statements into a single line.

Operator precedence rules* make the expression to be interpreted as 2 + (3*4) hence the result is 14.

raw_input() takes the input as a string whereas input() basically looks at what the user enters, and automatically determines the correct type. We use the input function when you are expecting an integer from the end-user, and raw_input when you are expecting a string.

char = ""

print “Press Tab Enter to stop ...”

for iteration in range(99):

if not char == ‘\t’:

print “Continue?”

char = raw_input()

i=0

while i < 10:

j=0

while j < i:

print '$’

print"

for i in range(10, 250, 50):

print i

a=25

while a < 500:

print a

a = a + 25

a = 90

while a > 9:

print a

a = a-9

1. len(str)

2. str.capitalize()

3. ch.isalnum()

4. str.upper()

5. str.replace(old,new)

1. find

2. index

Price *Qty, float, Address one, do

Illegal variables or functions name is as below: 

Days * Rent, do, 2Clients, For and Grant Total Because of being either keyword or including space or operator or starting with an integer.

1. random ()

2. math ()

The function round() is used to convert a fractional number into whole as the nearest next whereas the function floor() is used convert to the nearest lower whole number, 

e.g., round (5.8) = 6, round (4.1) = 5 and floor (6.9) = 6, floor (5.01) = 5

Total * Tax, class, 3rd Row, finally

1. math

2. pickle

1. pickle

2. math

14 times will Python execute the code inside the following while loop.

Python uses two strategies for memory allocation- 

(i) Reference counting 

(ii) Automatic garbage collection 

Reference Counting: works by counting the number of times an object is referenced by others in the system. When an object’s reference count reaches zero, Python collects it automatically. 

Automatic Garbage Collection: Python schedules garbage collection based upon a threshold of object allocations and object deallocations. When the number of allocations minus the number of deallocations is greater than the threshold number, the garbage collector is run and the unused blocks of memory are reclaimed.

Names declared with global keyword have to be referred at the file level. This is because of the global scope. If no global statement is being used the variable with the local scope is accessed. 

Hence, in the above code, the statement succeeding the statement global x informs Python to increment the global variable x 

Hence, the output is 6 i.e. 5 + 1 which is also the value for global x. When x is reassigned with the value 3 the local x hides the global x and hence 3 printed. 

(2 marks for explaining the output) (Only 1 mark for explaining global and local namespace.)

A tuple is immutable whereas a list is mutable. 

A tuple cannot be changed whereas a list can be changed internally. 

A tuple uses parentheses (()) whereas a list uses square brackets ([]). 

tuple initialization: a = (2, 4, 5) 

list initialization: a = [2, 4, 5]

An array holds the fixed number of values. The list is of variable-length – elements can be dynamically added or removed An array holds values of a single type. List in Python can hold values of a mixed data type.

find (sub[,start[,end]]) This function is used to search the first occurrence of the substring in the given string. It returns the index at which the substring starts. It returns -1 if the substring doesn’t occur in the string.

(eg) str = “computer” -

str.findf("om”) → 1

Python counts from the end (right) if negative indices are given.

(eg) S = “Hello”

print S[:-3] >> He

print S[-3:] >> llo

The slice[n:m] operator extracts subparts from a string. It doesn’t include the character at index m.

(eg) S = “Hello World”

print s[0:4] → Hell

“not in” is a membership operator. It evaluates to true if it does not finds a variable/string in the specified sequence. Otherwise it evaluates to false,

(eg) S = “Hello World”

if “Hell” not in S:

print “False”

will print False.

“in” is a membership operator. It evaluates to true if it finds a variable/string in the specified sequence : Otherwise i+evaluates to false.

(eg) S = “Hello World"

if “Hell” in S:

print “True”

will print True.

0 times will Python execute the code inside the following while loop.

It is easier to use since we need not remember the order of the arguments. We can specify the values for only those parameters which we want, and others have default values.

If there is a function with many parameters and we want to specify only some of them in function call, then value for such parameters can be provided by using their names instead of the positions. These are called keyword argument.

(eg) def simpleinterest(p, n=2, r=0.6)

' def simpleinterest(p, r=0.2, n=3)

Python allowes function arguments to have default values; if the function is called without the argument, the argument gets its default value.

1. using import

Syntax:

import[,...]

Example:

import math, cmath

2. using from

Syntax:

fromimport[, ,.. ,]

Example:

from fib. import fib, fib2.

// is Integer or Floor division whereas / is normal division

(eg) 7.0 // 2 → 3.0

7.0/2 → 3.5

or, and, not are the logical operators of Python.

True two values of the same data types can be equal.

6 times is the while loop executed.

9 times is the for loop executed.