PYTHON QUESTIONBANK With Answer
PYTHON QUESTIONBANK With Answer
1. What is an algorithm?
Algorithm is an ordered sequence of finite, well defined, unambiguous instructions for
completing a task. It is an English-like representation of the logic which is used to solve
the problem. It is a step- by-step procedure for solving a task or a problem. The steps must be
ordered, unambiguous and finite in number.
5. Write the pseudo code to calculate the sum and product of two numbers and display it.
INITIALIZE variables sum, product, number1, number2 of type real
PRINT “Input two numbers”
1
READ number1, number2
sum = number1 + number2
PRINT “The sum is “, sum
COMPUTE product = number1 * number2
PRINT “The Product is “, product
END program
6. How does flow of control work?
Control flow (or flow of control) is the order in which individual statements, instructions or
function calls of an imperative program are executed or evaluated. A control flow statement is
a statement in which execution results in a choice being made as to which of two or more
paths to follow.
7. What is a function?
Functions are "self-contained" modules of code that accomplish a specific task. Functions
usually "take in" data, process it, and "return" a result. Once a function is written, it can be used
over and over and over again. Functions can be "called" from the inside of other functions.
8. Write the pseudo code to calculate the sum and product displaying the answer on the
monitor screen.
INITIALIZE variables sum, product, number1, number2 of type real
PRINT “Input two numbers”
READ number1, number2
sum = number1 + number2
PRINT “The sum is “, sum
COMPUTE product = number1 * number2
PRINT “The Product is “, product
END program
2
12. Give an example of iteration.
a=0
for i from 1 to 3 // loop three times
{
a=a+i // add the current value of i to a
}
print a // the number 6 is printed (0 + 1; 1 + 2; 3 + 3)
3
18. List out the simple steps to develop an algorithm.
Algorithm development process consists of five major steps.
Step 1: Obtain a description of the problem.
Step 2: Analyze the problem.
Step 3: Develop a high-level algorithm.
Step 4: Refine the algorithm by adding more detail.
Step 5: Review the algorithm.
Recursion Iteration
Function calls itself until the base condition is Repetition of process until the condition fails.
reached.
Only base condition (terminating condition) is It involves four steps: initialization, condition,
specified. execution and updation.
It keeps our code short and simple. Iterative approach makes our code longer.
It is slower than iteration due to overhead of Iteration is faster.
maintaining stack.
It takes more memory than iteration due to Iteration takes less memory.
overhead of maintaining stack.
A complex task can be broken down into Recursive calls are expensive (inefficient) as
simpler sub-problems using recursion. they take up a lot of memory and time.
Sequence generation is easier with recursion Recursive functions are hard to debug.
than using some nested iteration.
1 The process is repeated until the The function calls itself until the base condition is
condition fails. satisfied.
3 It is faster It is slower
Step 1: Start
Step 2: Read number n
Step 3: Call factorial(n)
Step 4: Print factorial f
Step 5: Stop
factorial(n)
Step 1: Initialize f=1,i=1
Step 2: Repeat step 2.1 and 2.2 until i<=n
Step 2.1: f= f*i
Step 2.2: Increment i by 1 (i=i+1)
Step 3: Return f
5
Example: Recursive algorithm for factorial of number
Step 1: Start
Step 2: Read number n
Step 3: Call factorial(n)
Step 4: Print factorial f
Step 5: Stop
factorial(n)
Step 1: If n==1 then return 1
Step 2: Else
f=n*factorial(n-1)
Step 3: Return f
Algorithm:
Step 1: Start
Step 2: Initialize the value of result, r=1.
Step 3: Repeat step4 for 4 times
Step 4: calculate r=r*2
Step 5: Print the value of r
Step 6: Stop
6
Flowchart:
7
FOR i=1 to n
GET numlist elements
ENDFOR
SET maximum = numlist[0]
FOR i in numlist
IF (n > maximum)
maximum = n
ENDIF
ENDFOR
PRINT maximum
END
Pseudocode
START
Procedure Hanoi(disk, source, dest, aux)
IF disk = = 0, THEN
move disk from source to dest
ELSE
Hanoi(disk - 1, source, aux, dest)
move disk from source to dest
Hanoi(disk - 1, aux, dest, source)
END IF
END Procedure
6. a) What is flowchart?
8
c) Draw a flowchart to count and print from1 to 10.
7. a) Write an algorithm and give the flowchart to find the net salary of an employee.
Algorithm:
Step 1: Start
Step 2 : Read the basic salary
Step 3 : IF the basic is greater than or equal to 4000 ELSE Goto Step 4
Step 3.1 : DA= 0.32 * basic (Dearness Allowance)
Step 3.2: HRA= 0.15*basic (House Rent Allowance)
Step 3.3: CCA = 325 (City Compensatory Allowance)
Step 3.4: Net Salary = basic+DA+HRA+CCA
Step 4 : Print the Net Salary
Step 5 : Stop
9
b) Write an algorithm and give the pseudo code to guess an integer number in a range.
Algorithm:
step 1: Start the program
step 2: Read an 'n' number
step 3: Read an Guess number
step 4: if Guess> n; print "Your Guess too high" Step 5: elif Guess <n ; print "Your Guess
too low" step 6: elif Guess = = n; print "Good job"
Step 7: else print"Nope "
Step :8 Stop the program
Pseudocode:
BEGIN
READ n
READ Guess = 20
IF Guess> n
print"Your Guess too High" elif Guess< n
print "Your Guess too low" elif Guess = = 20
print "Good Job"
ELSE
print"Nope"
10
Step 3: READ Number of element in sorted list as N
Step 4: SET i=0
Step 5: IF i<N THEN go to step 6 ELSE go to step 9
Step 6: READ Sorted list element as List[i]
Step 7: i=i+1
Step 8: go to step 5
Step 9: READ Element to be insert as X
Step 10: SET i=N-1
Step 11: IF i>0 AND X<List[i] THEN go to step 12 ELSE go to step 15
Step 13: i=i-1
Step 14: go to step 11
Step 15: List[i+1]=X
Step 16: Stop
11
UNIT II
DATA TYPES, EXPRESSIONS, STATEMENTS
PART- A (2 Marks)
1. What is meant by interpreter?
An interpreter is a computer program that executes instructions written in a programming
language. It can either execute the source code directly or translate the source code in a first step into
a more efficient representation and executes this code.
6. Define a variable and write down the rules for naming a variable.
A name that refers to a value is a variable. Variable names can be arbitrarily long. They can
contain both letters and numbers, but they have to begin with a letter. It is legal to use uppercase
letters, but it is good to begin variable names with a lowercase letter.
12
Eg 1: Message = 'And now for something completely different'
Eg 2: n = 17
11.What is an expression?
An expression is a combination of values, variables, and operators. An expression is evaluated
using assignment operator.
Examples: Y=x + 17
12. What do you mean by an operand and an operator? Illustrate your answer with relevant
example.
An operator is a symbol that specifies an operation to be performed on the operands. The data
items that an operator acts upon are called operands. The operators +, -, *, / and ** perform addition,
subtraction, multiplication, division and exponentiation.
Example: 20+32
In this example, 20 and 32 are operands and + is an operator.
13. What is the order in which operations are evaluated? Give the order of precedence.
The set of rules that govern the order in which expressions involving multiple operators and
operands are evaluated is known as rule of precedence. Parentheses have the highest precedence
followed by exponentiation. Multiplication and division have the next highest precedence followed
by addition and subtraction.
13
16. What is function call?
A function is a named sequence of statements that performs a computation. When we define a
function, we specify the name and the sequence of statements. Later, we can “call” the function by its
name called as function call.
14
Eg:
>>> minute = 59
>>> minute / 60.0
0.983333333333
1. What is the role of an interpreter? Give a detailed note on python interpreter and
interactivemode of operation.
$ python
>>>
Once the Python interpreter is started, you can issue any command at the command prompt ">>>".
For example,let us print the "Hello World" statement:
>>> print "Hello World"
Hello World
In the interactive Python interpreter the print is not necessary:
Typing an end-of-file character (Ctrl+D on Unix, Ctrl+Z on Windows) at the primary prompt causes
the interpreter to exit with a zero exit status. If that doesn’t work, you can exit the interpreter by
typing the following command: quit().
15
When commands are read from a tty, the interpreter is said to be in interactive mode. In this mode it
prompts for the next command with the primary prompt, usually three greater-than signs (>>>); for
continuation lines it prompts with the secondary prompt, by default three dots (...). The interpreter
prints a welcome message stating its version number and a copyright notice before printing the first
prompt:
Continuation lines are needed when entering a multi-line construct. As an example, take a look at
this if statement:
>>> the_world_is_flat = 1
>>> if the_world_is_flat:
... print "Be careful not to fall off!"
2. (a) List down the rules for naming the variable with example.
A variable is a name that refers to a value. An assignment statement creates new variables and
gives them values:
Variable names can be arbitrarily long. They can contain both letters and numbers, but they
have to begin with a letter. It is legal to use uppercase letters, but it is a good idea to
begin variable names with a lowercase letter .
The underscore character, _, can appear in a name. It is often used in names with multiple
words, such as my_name or variable_name.
If you give a variable an illegal name, you get a syntax error:
(b) List down the different types of operators with suitable examples.
➢ Operators are the constructs which can manipulate the value of operands
➢ Consider the expression 4 + 5 = 9. Here, 4 and 5 are called operands and +
iscalled operator
➢ Types of operators
o Arithmetic Operators
o Comparison Operators
o Logical Operators
o Assignment Operator
o Membership Operator
o Identity Operator
o Bitwise Operator
o
3. What do you mean by rule of precedence? List out the order of precedence and
demonstrate indetail with example.
When more than one operator appears in an expression, the order of evaluation depends on the rules
of precedence. For mathematical operators, Python follows mathematical convention. The acronym
PEMDAS is a useful way to remember the rules,
16
• Parentheses have the highest precedence and can be used to force an expression to evaluate in the
order you want. Since expressions in parentheses are evaluated first,
2 * (3-1) is 4, and (1+1)**(5-2) is 8.
You can also use parentheses to make an expression easier to read, as in (minute * 100) / 60, even if
it doesn’t change the result.
• Exponentiation has the next highest precedence, so 2**1+1 is 3, not 4 and 3*1**3 is 3, not 27.
• Multiplication and Division have the same precedence, which is higher than Addition and
Subtraction, which also have the same precedence. So 2*3-1 is 5, not 4, and 6+4/2 is 8, not 5.
• Operators with the same precedence are evaluated from left to right (except exponentiation).
So in the expression degrees / 2 * pi, the division happens first and the result is multiplied by pi. To
divide by 2π, you can use parentheses or write degrees / 2 / pi.
4. Explain the role of function call and function definition with example.
A function is a named sequence of statements that performs a computation. When you define
a function, you specify the name and the sequence of statements. Later, you can “call” the
function by name.
>>> type(32)
<type 'int'>
The name of the function is type. The expression in parentheses is called the argument of the
function. The result, for this function, is the type of the argument. A function “takes” an
argument and “returns” a result. The result is called the return value.
Type conversion functions
Python provides built-in functions that convert values from one type to another. The int function
takes any value and converts it to an integer, if it can, or complains otherwise:
>>> int('32')
32
>>> int('Hello')
int can convert floating-point values to integers, but it doesn’t round off; it chops off the
fraction part:
>>> int(3.99999)
3
>>> int(-2.3)
-2
This statement creates a module object named math. If you print the module object, you
get some information about it:
The module object contains the functions and variables defined in the module. To access
one of the functions,specify the name of the module and the name of the
function, separated by a dot (also known as a period). This format is called dot notation.
The first example uses log10 to compute a signal-to-noise ratio in decibels (assuming that
signal_power and noise_power are defined). The math module also provides log, which
computes logarithms base e.
The second example finds the sine of radians. The name of the variable is a hint that sin
and the other trigonometric functions (cos, tan, etc.) take arguments in radians. To convert
from degrees to radians, divide by 360 and multiply by 2π:
>>> degrees = 45
>>> radians = degrees / 360.0 * 2 * math.pi
>>> math.sin(radians)
0.707106781187
The expression math.pi gets the variable pi from the math module. The value of this
variable is an approximation of π, accurate to about 15 digits.
18
6. Write a Python program to swap two
variables.
x= 5
y = 10
# create a temporary variable and swap the values
temp = x
x=y
y = temp
print("The value of x after swapping:”,x))
print("The value of y after swapping:”,y))
# calculate fahrenheit
fahrenheit = (celsius * 1.8) + 32
print('%0.1f degree Celsius is equal to %0.1f degree Fahrenheit' %(celsius,fahrenheit))
19
UNIT III
CONTROL FLOW, FUNCTIONS AND STRINGS
PART- A (2 Marks)
20
Finally, the not operator negates a Boolean expression, so not(x > y) is true if x > y is false,
that is, if x is less than or equal to y. Non-zero number is said to be true in Boolean expressions.
6. What is conditional execution?
The ability to check the condition and change the behavior of the program accordingly is called
conditional execution. Example: If statement:
The simplest form of if statement is:
Syntax:
if
statement:
Eg:
if x > 0:
print 'x is positive'
The boolean expression after ‘if’ is called the condition. If it is true, then the indented
statement gets executed. If not, nothing happens.
elif is an abbreviation of “else if.” Again, exactly one branch will be executed. There is no limit on
the number of elif statements. If there is an else clause, it has to be at the end, but there doesn’t have
to be one.
22
Eg:
def circle_area(xc, yc, xp, yp):
radius = distance(xc, yc, xp, yp)
result = area(radius)
return result
14.What is recursion?
The process in which a function calls itself directly or indirectly is called recursion and the
corresponding function is called as recursive function.
Eg:
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
15.Explain global and local scope.
The scope of a variable refers to the places that we can see or access a variable. If we define a
variable on the top of the script or module, the variable is called global variable. The variables that
are defined inside a class or function is called local variable.
Eg:
def my_local():
a=10
print(“This is local variable”)
Eg:
a=10
def my_global():
print(“This is global variable”)
23
17.Define string immutability.
Python strings are immutable. ‘a’ is not a string. It is a variable with string value. We can’t
mutate the string but can change what value of the variable to a new string.
Program: Output:
a = “foo” #foofoo
# a now points to foo #foo
b=a It is observed that ‘b’ hasn’t changed even
# b now points to the same foo that a points to though ‘a’ has changed.
a=a+a
# a points to the new string “foofoo”, but b points
to the same old “foo”
print a
print b
18.Mention a few string functions.
s.captilize() – Capitalizes first character of string
s.count(sub) – Count number of occurrences of sub in string
24
Eg:Program: Output:
import string upper => MONTY PYTHON'S FLYING
text = "Monty Python's Flying Circus" CIRCUS
print "upper", "=>", string.upper(text) lower => monty python's flying circus
print "lower", "=>", string.lower(text) split => ['Monty', "Python's", 'Flying', 'Circus']
print "split", "=>", string.split(text) join => Monty+Python's+Flying+Circus
print "join", "=>", string.join(string.split(text), replace => Monty Java's Flying Circus
"+") find => 6 -1
print "replace", "=>", string.replace(text, count => 3
"Python", "Java")
print "find", "=>", string.find(text, "Python"),
string.find(text, "Java")
print "count", "=>", string.count(text, "n")
25
Operator Name Expression Example Output
> Greater than x>y 54>18 True
< Less than x<y 54<18 False
== Equal to x==y 54==18 False
!= Not equal to x!=y 54!=18 True
>= Greater than or x>=y 54>=18 True
equal to
<= Less than or x <=y 54<=18 False
equal to
26
2. Explain conditional alternative and chained conditional.
The simplest form of if statement is:
Syntax:
if
statement:
Eg:
if x > 0:
print 'x is positive'
The boolean expression after ‘if’ is called the condition. If it is true, then the indented
statement gets executed. If not, nothing happens. if statements have the same structure as
function definitions: a header followed by an indented body. Statements like this are called
compound statements. There is no limit on the number of statements that can appear in the
body, but there has to be at least one. Occasionally, it is useful to have a body with no
statements .In that case, you can use the pass statement, which does nothing.
if x < 0:
pass # need to handle negative values!
Alternative execution (if-else):
A second form of if statement is alternative execution, in which there are two possibilities and
the condition determines which one gets executed. The syntax looks like this:
Eg:
if x%2 == 0:
print 'x is even'
else:
print 'x is odd'
If the remainder when x is divided by 2 is 0, then we know that x is even, and the program
displays a message to that effect. If the condition is false, the second set of statements is
executed. Since the condition must be true or false, exactly one of the alternatives will be
executed. The alternatives are called branches, because they are branches in the flow of
execution.
Chained conditionals(if-elif-else):
Sometimes there are more than two possibilities and we need more than two
branches. Oneway to express a computation like that is a chained conditional:
Eg:
if x < y:
print 'x is
less than y'elif x >
y:
print 'x is greater than y'
27
else:
print 'x and y are equal'
elif is an abbreviation of “else if.” Again, exactly one branch will be executed. There is no limit on
the number of elif statements. If there is an else clause, it has to be at the end, but there doesn’t have
to be one.
Eg:
if choice == 'a':
draw_a()
Each condition is checked in order. If the first is false, the next is checked, and so on. If one of them
is true, the corresponding branch executes, and the statement ends. Even if more than one condition is
true, only the first true branch executes.
28
Sometimes it isuseful to have multiple return statements, one in each branch of a conditional:
def absolute_value(x):
if x < 0:
return -x
else:
return x
4. Write a Python program to find the square root of a number.
approx = 0.5 * n
better = 0.5 * (approx + n/approx)
while better != approx:
approx = better
better = 0.5 * (approx + n/approx)
print(approx)
5. Explain RECURSION.
The process in which a function calls itself directly or indirectly is called recursion and the
corresponding function is called as recursive function. Using recursive algorithm, certain
problems can be solved quite easily. Examples of such problems are Towers of Hanoi (TOH),
Inorder/Preorder/Postorder Tree Traversals, DFS of Graph, etc.
Python program:
# take input from the user
num = int(input("Enter a number: "))
def fact(n):
if n == 1:
return n
else:
return n*fact(n-1)
print(“Factorial of n numbers is :%d” %(fact(n)))
This form of dot notation specifies the name of the method, upper, and the name of the string to
apply the method to, word. The empty parentheses indicate that this method takes no argument. A
method call is called an invocation ; in this case, we would say that we are invoking upper on the
word. As it turns out, there is a string method named find that is remarkably similar to the function
we wrote:
>>> word = 'banana'
>>> index = word.find('a')
>>> print index
1
In this example, we invoke find on word and pass the letter we are looking for as a parameter.
Actually, the find method is more general than our function; it can find substrings, not just
characters:
>>> word.find('na')
2
It can take as a second argument the index where it should start:
>>> word.find('n', 3)
4
And as a third argument the index where it should stop:
>>> name ='bob'
>>> name.find('b', 1, 2)
-1
This search fails because b does not appear in the index range from 1 to 2 (not including 2).
32
8. Explain string module.
The string module contains number of useful constants and classes, as well as some deprecated
legacy functions that are also available as methods on strings.
Eg:
import string
text = "Monty Python's Flying Circus"
print "upper", "=>", string.upper(text)
print "lower", "=>", string.lower(text)
33
10. Write a Python program to find the exponentiation of a number.
print("Calculation of X^Y")
x=int(input("Enter X Value :"))
y=int(input("Enter Y Value :"))
powered = x
if y == 0:
powered=1
else:
while y > 1:
powered *= x
y -= 1
print(powered)
35
UNIT IV LISTS, TUPLES AND DICTIONARIES
Part-A (2 Marks)
1. What is list?
A list is an ordered set of values, where each value is identified by an index. The values that make up
a list are called its elements. Lists are similar to strings, which are ordered sets of characters, except
that the elements of a list can have any type.
2. Solve a)[0] * 4 and b) [1, 2, 3] * 3.
>>> [0] * 4 [0, 0, 0, 0]
>>> [1, 2, 3] * 3 [1, 2, 3, 1, 2, 3, 1, 2, 3]
3.Let list = [’a’, ’b’, ’c’, ’d’, ’e’, ’f’]. Find a) list[1:3] b) t[:4] c) t[3:] .
>>> list = [’a’, ’b’, ’c’, ’d’, ’e’, ’f’]
>>> list[1:3] [’b’, ’c’]
>>> list[:4] [’a’, ’b’, ’c’, ’d’]
>>> list[3:] [’d’, ’e’, ’f’]
4. Mention any 5 list methods.
append() ,extend () ,sort(), pop(),index(),insert and remove()
Python represents all its data as objects. Some of these objects like lists and dictionaries are mutable,
i.e., their content can be changed without changing their identity. Other objects like integers, floats,
strings and tuples are objects that cannot be changed.
Example:
>>> numbers = [17, 123]
>>> numbers[1] = 5
>>> print numbers [17, 5]
7. What is aliasing in list? Give an example.
An object with more than one reference has more than one name, then the object is said to be
aliased. Example: If a refers to an object and we assign b = a, then both variables refer to the same
object:
>>> a = [1, 2, 3]
>>> b = a
>>> b is a True
8. Define cloning in list.
In order to modify a list and also keep a copy of the original, it is required to make a copy of
the list itself, not just the reference. This process is called cloning, to avoid the ambiguity of the word
“copy”.
36
9. Explain List parameters with an example.
Passing a list as an argument actually passes a reference to the list, not a copy of the list. For
example, the function head takes a list as an argument and returns the first element:
def head(list):
return list[0]
output:
>>> numbers = [1, 2, 3]
>>> head(numbers)
10. Write a program in Python to delete first element from a list.
def deleteHead(list): del list[0]
Here’s how deleteHead is used:
>>> numbers = [1, 2, 3]
>>> deleteHead(numbers)
>>> print numbers [2, 3]
11. Write a program in Python returns a list that contains all but the first element of the given
list.
def tail(list):
return list[1:]
Here’s how tail is used:
>>> numbers = [1, 2, 3]
>>> rest = tail(numbers)
>>> print rest [2, 3]
37
Example:
>>> eng2sp = {} # empty dictionary
>>> eng2sp[’one’] = ’uno’
38
PART B (16 MARKS)
1. Explain in detail about lists, list operations and list slices.
A list is an ordered set of values, where each value is identified by an index. The values that make up a list
are called its elements. Lists are similar to strings, which are ordered sets of characters, except that the
elements of a list can have any type. There are several ways to create a new list. The simplest is to enclose
the elements in square brackets ([and]):
[10, 20, 30, 40]
The following list contains a string, a float, an integer, and (mirabile dictu) another list:
A list within another list is said to be nested. Lists that contain consecutive integers are common, so Python
provides a simple way to create them:
LIST OPERATIONS
LIST SLICES
If we omit the first index, the slice starts at the beginning. If we omit the second, the slice goes to the end.
So if we omit both, the slice is a copy of the whole list.
39
Since lists are mutable, it is often useful to make a copy before performing operations that fold, spindle or
mutilate lists. A slice operator on the left side of an assignment can update multiple elements:
>>> list[1] = 17
>>> list
[2, 17, 'usurp', 9.0, 'n']
We can assign new values to slices of the lists, which don't even have to be the same length:
It's even possible to append items onto the start of lists by assigning to an empty slice:
Similarly, you can append to the end of the list by specifying an empty slice after the end:
40
[3.14, 2.71, 2, 'opportunistic', 'elk', 'n', 'four', 'score']
The right-hand side of a list assignment statement can be any iterable type:
With slicing you can create copy of list since slice returns a new list:
Note, however, that this is a shallow copy and contains references to elements from the original list, so be
careful with mutable types:
>>> list_copy[2].append('something')
>>> original
[1, 'element', ['something']]
Non-Continuous slices
It is also possible to get non-continuous parts of an array. If one wanted to get every n-th occurrence of a
list, one would use the :: operator. The syntax is a:b:n where a and b are the start and end of the slice to be
operated upon.
2. Explain in detail about list methods and list loops with examples.
Python provides methods that operate on lists. Some of the methods are
• Append()
• Extend()
• Sort()
• Pop()
>>> t.append('d')
>>> t1.extend(t2)
This example leaves t2 unmodified. sort arranges the elements of the list from low to high:
>>> t.sort()
Remove the item in the list at the index i and return it. If i is not given, remove the the last item in the list and
return it.
42
>>> list = [1, 2, 3, 4]
>>> a = list.pop(0)
>>> list
[2, 3, 4]
>>> a
List methods are all void; they modify the list and return None.
LIST LOOPS
Here are two functions that both generate ten million random numbers, and return the sum of the numbers.
They both work.
import random
joe = random.Random()
def sum1():
""" Build a list of random numbers, then sum them """ # Generate one random ˓→number
xs = []
for i in range(10000000):
num = joe.randrange(1000 )
xs.append(num) # Save it in our list
tot = sum(xs)
return tot
def sum2():
""" Sum the random numbers as we generate them """
tot = 0
for i in range(10000000):
num = joe.randrange(1000)
tot += num
return tot
print(sum1())
print(sum2())
Unlike strings, lists are mutable, which means we can change their elements. Using the bracket operator on
the left side of an assignment, we can update one of the elements:
43
>>> print fruit [’pear’, ’apple’, ’orange’]
We can also remove elements from a list by assigning the empty list to them:
>>> list[1:3] = []
And we can add elements to a list by squeezing them into an empty slice at the desired location:
Tuple assignment
It is often useful to swap the values of two variables. With conventional assignments, you have to use a
temporary variable. For example, to swap a and b:
>>> temp = a
>>> a = b
>>> b = temp
>>> a, b = b, a
The left side is a tuple of variables; the right side is a tuple of expressions. Each value is assigned to its
respective variable. All the expressions on the right side are evaluated before any of the assignments. The
number of variables on the left and the number of values on the right have to be the same:
>>> a, b = 1, 2, 3
44
ValueError: too many values to unpack More generally, the right side can be any kind of sequence (string,
list or tuple). For example, to split an email address into a user name and a domain, you could write:
The return value from split is a list with two elements; the first element is assigned to uname, the second to
domain.
>>> temp = a
>>> a = b
>>> b = temp
>>> a, b = b, a
The left side is a tuple of variables; the right side is a tuple of expressions. Each value is assigned to its
respective variable. All the expressions on the right side are evaluated before any of the assignments. The
number of variables on the left and the number of values on the right have to be the same:
>>> a, b = 1, 2, 3
ValueError: too many values to unpack More generally, the right side can be any kind of sequence (string,
list or tuple). For example, to split an email address into a user name and a domain, you could write:
The return value from split is a list with two elements; the first element is assigned to uname, the second to
domain.
45
5. Is it possible to return tuple as values? Justify your answer with an example.
Yes, it is possible to return tuple as values. Example: Functions can return tuples as return values. For
example, we could write a function that swaps two parameters:
return y, x
Then we can assign the return value to a tuple with two variables:
a, b = swap(a, b)
In this case, there is no great advantage in making swap a function. In fact, there is a danger in trying to
encapsulate swap, which is the following tempting mistake:
x, y = y, x
If we call this function like this: swap(a, b) then a and x are aliases for the same value. Changing x inside
swap makes x refer to a different value, but it has no effect on a in main. Similarly, changing y has no effect
on b. This function runs without producing an error message, but it doesn’t do what we intended. This is an
example of a semantic error.
The built-in function divmod takes two arguments and returns a tuple of two values, the quotient and
remainder. You can store the result as a tuple:
>>> t = divmod(7, 3)
Here is an example of a function that returns a tuple: def min_max(t): return min(t), max(t) max and min are
built-in functions that find the largest and smallest elements of a sequence. min_max computes both and
returns a tuple of two values.
A dictionary is like a list, but more general. In a list, the indices have to be integers; in a dictionary they can
be (almost) any type. You can think of a dictionary as a mapping between a set of indices (which are called
46
keys) and a set of values. Each key maps to a value. The association of a key and a value is called a key-
value pair or sometimes an item. As an example, we’ll build a dictionary that maps from English to Spanish
words, so the keys and the values are all strings.
The function dict creates a new dictionary with no items. Because dict is the name of a built-in function,
you should avoid using it as a variable name.
The squiggly-brackets, {}, represent an empty dictionary. To add items to the dictionary, you can use
square brackets: >>> eng2sp['one'] = 'uno' This line creates an item that maps from the key 'one' to the value
'uno'. If we print the dictionary again, we see a key-value pair with a colon between the key and value:
This output format is also an input format. For example, you can create a new dictionary with three items:
The order of the key-value pairs is not the same. In fact, if you type the same example on your computer,
you might get a different result. In general, the order of items in a dictionary is unpredictable. But that’s not
a problem because the elements of a dictionary are never indexed with integer indices. Instead, you use the
keys to look up the corresponding values:
The key 'two' always maps to the value 'dos' so the order of the items doesn’t matter. If the key isn’t in the
dictionary, you get an exception:
The len function works on dictionaries; it returns the number of key-value pairs:
>>> len(eng2sp)
The in operator works on dictionaries; it tells you whether something appears as a key in the dictionary
(appearing as a value is not good enough).
47
To see whether something appears as a value in a dictionary, you can use the method values, which returns
the values as a list, and then use the in operator:
True
The in operator uses different algorithms for lists and dictionaries. For lists, it uses a search algorithm, as in
Section 8.6. As the list gets longer, the search time gets longer in direct proportion. For dictionaries, Python
uses an algorithm called a hashtable that has a remarkable property: the in operator takes about the same
amount of time no matter how many items there are in a dictionary
Dictionary operations
The del statement removes a key-value pair from a dictionary. For example, the following dictionary
contains the names of various fruits and the number of each fruit in stock:
>>> inventory = {’apples’: 430, ’bananas’: 312, ’oranges’: 525, ’pears’: 217}
>>> print inventory {’oranges’: 525, ’apples’: 430, ’pears’: 217, ’bananas’: 312}
If someone buys all of the pears, we can remove the entry from the dictionary:
Or if we’re expecting more pears soon, we might just change the value associated with pears:
>>> inventory[’pears’] = 0
>>> print inventory {’oranges’: 525, ’apples’: 430, ’pears’: 0, ’bananas’: 312}
The len function also works on dictionaries; it returns the number of key-value pairs:
>>> len(inventory) 4
A method is similar to a function—it takes arguments and returns a value— but the syntax is different. For
example, the keys method takes a dictionary and returns a list of the keys that appear, but instead of the
function syntax keys(eng2sp), we use the method syntax eng2sp.keys().
This form of dot notation specifies the name of the function, keys, and the name of the object to apply the
48
function to, eng2sp. The parentheses indicate that this method has no parameters. A method call is called an
invocation; in this case, we would say that we are invoking keys on the object eng2sp.
The values method is similar; it returns a list of the values in the dictionary:
The items method returns both, in the form of a list of tuples—one for each key-value pair:
The syntax provides useful type information. The square brackets indicate that this is a list. The parentheses
indicate that the elements of the list are tuples. If a method takes an argument, it uses the same syntax as a
function call. For example, the method has key takes a key and returns true (1) if the key appears in the
dictionary:
>>> eng2sp.has_key(’one’)
True
>>> eng2sp.has_key(’deux’)
False
If you try to call a method without specifying an object, you get an error. In this case, the error message is
not very helpful:
List comprehensions provide a concise way to create lists. It consists of brackets containing an expression
followed by a for clause, then zero or more for or if clauses. The expressions can be anything, i.e., all kinds of
objects can be in lists. The result will be a new list resulting from evaluating the expression in the context of
the for and if clauses which follow it. The list comprehension always returns a result list.
Syntax
The list comprehension starts with a '[' and ']', to help you remember that the result is going to be a list.
49
This is equivalent to:
for item in list:
if
conditional:
expression
List comprehension is a method to describe the process using which the list should be created. To do that, the
list is broken into two pieces. The first is a picture of what each element will look like, and the second is what
is done to get it.
For instance, let's say we have a list of words:
listOfWords = ["this","is","a","list","of","words"]
To take the first letter of each word and make a list out of it using list comprehension:
List comprehension supports more than one for statement. It will evaluate the items in all of the objects
sequentially and will loop over the shorter objects if one object is longer than the rest.
List comprehension supports an if statement, to only include members into the list that fulfill a certain
condition:
50
9. Write a Python program for a) selection sort b) insertion sort.
SELECTION SORT:
PROGRAM:
least = i
least = k
def swap( A, x, y ):
tmp = A[x]
A[x] = A[y]
A[y] = tmp
aList = [54,26,93,17,77,31,44,55,20]
selectionsort(aList)
print(aList)
Insertion sort:
def insertionSort(alist):
currentvalue = alist[index]
position = index
alist[position]=alist[position-1]
position = position-1
alist[position]=currentvalue
alist = [54,26,93,17,77,31,44,55,20]
51
insertionSort(alist)
print(alist)
def mergeSort(alist):
print("Splitting
",alist) if
len(alist)>1:
mid = len(alist)//2
lefthalf =
alist[:mid]
righthalf =
alist[mid:]
mergeSort(lefthal
f)
mergeSort(righth
alf) i=0
j=0
k=
0
while i < len(lefthalf) and j <
len(righthalf): if lefthalf[i] <
righthalf[j]:
alist[k]=lefthal
f[i] i=i+1
else:
alist[k]=righthal
f[j] j=j+1
k=k+1
while i <
len(lefthalf):
alist[k]=lefthalf
[i] i=i+1
k=k+1
while j <
len(righthalf):
alist[k]=righthalf
[j] j=j+1
k=k+1
print("Merging
",alist)
alist = [54,26,93,17,77,31,44,55,20]
52
mergeSort(alist)
print(alist)
Quicksort:
from random import randrange def
lst[pivot]store_index = start
for i in xrange(start,
lst[end]:
lst[i]store_index += 1
lst[store_index]return store_index
def sort(lst):
quick_sort(lst, 0, len(lst) - 1)
return lst
print sort([345,45,89,569,23,67,56,90,100])
53
11. Write a Python program to implement histogram.
def histogram( items ):
for n in items:
output = ''
times = n
while( times > 0 ):
output += '*'
times = times - 1
print(output)
histogram([2, 3, 6, 5])
UNIT V
FILES, MODULES AND PACKAGES
PART- A (2 Marks)
1. What is a text file?
A text file is a file that contains printable characters and whitespace, organized in to
lines separated by newline characters.
2. Write a python program that writes “Hello world” into a file.
f =open("ex88.txt",'w')
f.write("hello world")
f.close()
3. Write a python program that counts the number of words in a file.
f=open("test.txt","r")
content =f.readline(20)
words =content.split()
print(words)
4. What are the two arguments taken by the open() function?
The open function takes two arguments : name of the file and the mode of operation.
Example: f = open("test.dat","w")
5. What is a file object?
A file object allows us to use, access and manipulate all the user accessible files. It maintains
the state about the file it has opened.
6. What information is displayed if we print a file object in the given program?
f= open("test.txt","w")
print f
The name of the file, mode and the location of the object will be displayed.
7. What is an exception?
Whenever a runtime error occurs, it creates an exception. The program stops execution and
prints an error message. For example, dividing by zero creates an exception:
print 55/0
ZeroDivisionError: integer division or modulo
54
8. What are the error messages that are displayed for the following exceptions?
a. Accessing a non-existent list item
b. Accessing a key that isn’t in the dictionary
c. Trying to open a non-existent file
a. IndexError: list index out of range
b. KeyError: what
c. IOError: [Errno 2] No such file or directory: 'filename'
9. What are the two parts in an error message?
The error message has two parts: the type of error before the colon, and speci_cs about the
error after the colon.
10. How do you handle the exception inside a program when you try to open a non-existent
file?
filename = raw_input('Enter a file name: ')
try:
f = open (filename, "r")
except IOError:
print 'There is no file named', filename
11. How does try and execute work?
The try statement executes the statements in the first block. If no exception occurs, then except
statement is ignored. If an exception of type IOError occurs, it executes the statements in the except
branch and then continues.
12. What is the function of raise statement? What are its two arguments?
The raise statement is used to raise an exception when the program detects an error. It takes two
arguments: the exception type and specific information about the error.
13. What is a pickle?
Pickling saves an object to a file for later retrieval. The pickle module helps to translate almost any
type of object to a string suitable for storage in a database and then translate the strings back in to
objects.
14. What are the two methods used in pickling?
The two methods used in pickling are pickle.dump() and pickle.load(). To store a data structure,
dump method is used and to load the data structures that are dumped , load method is used.
15. What is the use of the format operator?
The format operator % takes a format string and a tuple of expressions and yields a string that
includes the expressions, formatted according to the format string.
16. What are modules?
A module is simply a file that defines one or more related functions grouped together. To reuse the
functions of a given module, we need to import the module.
Syntax: import <modulename>
17. What is a package?
Packages are namespaces that contain multiple packages and modules themselves. They are simply
directories.
Syntax: from <mypackage> import <modulename>
55
18. What is the special file that each package in Python must contain?
Each package in Python must contain a special file called init .py
19. How do you delete a file in Python?
The remove() method is used to delete the files by supplying the name of the file to be deleted as
argument.
Syntax: os.remove(filename)
20. How do you use command line arguments to give input to the program?
Python sys module provides access to any command-line arguments via sys.argv. sys.argv is the list
of command-line arguments. len(sys.argv) is the number of command-line arguments.
56
3. Write a python program to count number of lines, words and characters in a text file.
def wordCount():
cl=0
cw=0
cc=0
f=open("ex88.txt","r")
for line in f:
words=line.split()
cl +=1
cw +=len(words)
cc +=len(line)
print('No. of lines:',cl)
print('No. of words:',cw)
print('No. of characters:',cc)
f.close()
57
6. Write a Python program to implement stack operations using modules.
Module definition:
def getStack():
return[]
def isempty(s):
if s==[]:
return True
else:
return False
def top(s):
if isempty(s):
return None
else:
return s[len(s)-1]
def push(s,item):
s.append(item)
def pop(s):
if isempty(s):
return None
else:
item=s[len(s)-1]
del s[len(s)-1]
return item
import stack
def today():
mystack=stack.getStack()
for item in range(1,7):
stack.push(mystack,item)
print('Pushing',item,'to stack')
print ('Stack items')
while not stack.isempty(mystack):
item=stack.pop(mystack)
print('Poping',item,'from stack')
58
7. Write a program to illustrate multiple modules.
import wordcount,ex12,ex97
def test():
wordcount.wordCount()
def test2():
ex12.inputNumber()
def test3():
ex97.fun()
ex97.py:
def fun():
try:
x = float(raw_input("Your number: "))
inverse = 1.0 / x
except ValueError:
print "You should have given either an int or a float"
except ZeroDivisionError:
print "Infinity"
ex12.py:
def inputNumber () :
x = input ('Pick a number: ')
if x == 17 :
raise ValueError, '17 is a bad number'
return x
wordcount.py:
def wordCount():
cl=0
cw=0
cc=0
f=open("ex88.txt","r")
for line in f:
words=line.split()
cl +=1
cw +=len(words)
cc +=len(line)
59
print('No. of lines:',cl)
print('No. of words:',cw)
print('No. of characters:',cc)
f.close()
60