MSc (COMPUTER SCIENCE) III Semester (CBCS)

PYTHON PROGRAMMING

Unit - I
Python is object oriented programming language that was developed by Guido vas
Rossum and first released in 1991. It is a multi paradigm high level general purpose
scripting language.
 Python supports multiple programming paradigms (models) like structured
programming, object oriented programming and functional programming. So it is
called a multi-paradigm language.
 Python is user friendly and can be used to develop application software like text
editors, music players etc. so, it is called high level language.
 Python has several built-in libraries. There are also many third party libraries with
the help of all these libraries we develop almost anything with python. So, it is
called General purpose language.
 Finally, python programs are executed line by line(interpreted). So, it is called a
Scripting Language.
Features:
1. Easy-to-learn: Python has few keywords, simple structure, and a clearly defined
syntax. This allows the student to pick up the language quickly.
2. Easy-to-read: Python code is more clearly defined and visible to the eyes.
3. Easy-to-maintain: Python's source code is fairly easy-to-maintain.
4. A broad standard library: Python's bulk of the library is very portable and
cross-platform compatible on UNIX, Windows, and Macintosh.
5. Interactive mode: Python has support for an interactive mode which allows
interactive testing and debugging snippets of coed
6. Portable: Python can run on a wide variety of hardware platforms and has the
same interface on all platforms.
7. Extendable: You can add low-level modules to the python interpreter. These
modules enable programmers to add to or customize their tools to be more
efficient
8. Databases: Python provides interfaces to all major commercial databases.
9. GUI Programming: Python supports GUI applications that can be created and
ported to many system calls, libraries and windows systems, such as Windows
MFC, Macintosh, and the X Window system of Unix.
10. Scalable: Python provides a better structure and support for large programs than
shell scripting.

How a Program Works

A computer’s CPU can only understand instructions that are written in machine
language. Because people find it very difficult to write entire programs in machine
language, other programming languages have been invented.
Programs are usually stored on a secondary storage device such as a disk drive.
When you install a program on your computer, the program is typically copied to your
Page 1
computer’s disk drive from a CD-ROM, or perhaps downloaded from a website.
Although a program can be stored on a secondary storage device such as a disk drive,
it has to be copied into main memory, or RAM, each time the CPU executes it.
For example, suppose you have a word processing program on your computer’s disk.
To execute the program you use the mouse to double-click the program’s icon. This
causes the program to be copied from the disk into main memory.
Then, the computer’s CPU executes the copy of the program that is in main memory.

When a CPU executes the instructions in a program, it is engaged in a process that is

known as the fetch-decode-execute cycle. This cycle, which consists of three steps, is
repeated for each instruction in the program. The steps are:
1. Fetch: A program is a long sequence of machine language instructions. The first
step of the cycle is to fetch, or read, the next instruction from memory into the
CPU.
2. Decode A machine language instruction is a binary number that represents a
command that tells the CPU to perform an operation. In this step the CPU decodes
the instruction that was just fetched from memory, to determine which operation
it should perform.
3. Execute The last step in the cycle is to execute, or perform, the operation.

Keywords
Each high-level language has its own set of predefined words that the programmer
must use to write a program. The words that make up a high-level programming
language are known as key words or reserved words. Each key word has a specific
meaning, and cannot be used for any other purpose.
The Python key words
and del from None True
as elif global nonlocal try
assert else if not while
break except import or with
class False in pass yield
continue finally is raise def
for lambda return

Compilers and Interpreters:

Because the CPU understands only machine language instructions, programs that are
written in a high-level language must be translated into machine language.
Depending on the language that a program has been written in, the programmer will
use either a compiler or an interpreter to make the translation.
Compiler: A compiler is a program that translates a high-level language program
into a separate machine language program. The machine language program can then
be executed any time it is needed.
This is shown in the below figure.
1. High leve language program Compiler Machine language program

Page 2
 Can be executed anytime

2. High level language program CPU

Without using compiler

Interpreter: The Python language uses an interpreter, which is a program that

both translates and executes the instructions in a high-level language program. As
the interpreter reads each individual instruction in the program, it converts it to
machine language instructions and then immediately executes them. This process
repeats for every instruction in the program. This is shown in the below figure.
Data Type Conversion:
When you perform a math operation on two operands, the data type of the result
will depend on the data type of the operands. Python follows these rules when
evaluating mathematical expressions:
 When an operation is performed on two int values, the result will be an int.
 When an operation is performed on two float values, the result will be a float.
 When an operation is performed on an int and a float, the int value will be
 temporarily converted to a float and the result of the operation will be a float. (An
expression that uses operands of different data types is called a mixed-type
expression.)
Example(typeconvert.py) Output:
def main(): Enter yearly salary: 65721
year_sal=float(input("Enter yearly salary:")) Monthly salary is: 5476.75
monthly_sal=year_sal/12
print("Monthly salary is:",monthly_sal)
main()

Page 3
 More About Data Output:
1. Breaking Long Statements into Multiple Lines:
Python allows you to break a statement into multiple lines by using the line
continuation character, which is a backslash (\). You simply type the backslash
character at the point you want to break the statement, and then press the Enter key.
Here is a print function call that is broken into two lines with the line continuation
character:
Example:
print('We sold', units_sold, \
'for a total of', sales_amount)
The line continuation character that appears at the end of the first line tells the
interpreter that the statement is continued on the next line.
2. Suppressing the print Function’s Ending Newline:
The print function normally displays a line of output. For example, the following three
tatements will produce three lines of output:
print('One')
print('Two')
print('Three')
Each of the statements shown here displays a string and then prints a newline
character. You do not see the newline character, but when it is displayed, it causes
the output to advance to the next line.If you do not want the print function to start a
new line of output when it finishes displaying its output, you can pass the special
argument end=' ' to the function, as shown in the following code:
print('One', end=' ')
print('Two', end=' ')
print('Three')
Notice that in the first two statements, the argument end=' ' is passed to the print
function.This specifies that the print function should print a space instead of a newline
character at the end of its output. Here is the output of these statements: One Two
Three
3. Specifying an Item Separator:
When multiple arguments are passed to the print function, they are automatically
separated by a space when they are displayed on the screen. Here is an example,
demonstrated in interactive mode:
>>> print('One', 'Two', 'Three') press Enter
One Two Three
>>>
if you do not want a space printed between the items, you can pass the argument
sep=''
to the print function, as shown here:
>>> print('One', 'Two', 'Three', sep=’*’) press Enter

Page 4
 OneTwoThree
>>>
You can also use this special argument to specify a character other than the space to
separate multiple items. Here is an example:
>>> print('One', 'Two', 'Three', sep='*') press Enter
One*Two*Three
>>>
4. Escape Characters:
An escape character is a special character that is preceded with a backslash (\),
appearing inside a string literal. When a string literal that contains escape characters
is printed, the escape characters are treated as special commands that are embedded
in the string.
For example, \n is the newline escape character. When the \n escape character is
printed,it isn’t displayed on the screen. Instead, it causes output to advance to the
next line. For example, look at the following statement:
print('One\nTwo\nThree')
When this statement executes, it displays
One
Two
Three
Escape Character Effect
\n Causes output to be advanced to the next line.
\t Causes output to skip over to the next horizontal tab position.
\' Causes a single quote mark to be printed.
\" Causes a double quote mark to be printed.
\\ Causes a backslash character to be printed.
5. Displaying Multiple Items with the + Operator:
Normally, the + operator is used to add two numbers. When the + operator is used
with two strings, however, it performs string concatenation. This means that it
appends one string to another. For example, look at the following statement:
print('This is ' + 'one string.')
This statement will print
This is one string.
String concatenation can be useful for breaking up a string literal so a lengthy call to
the print function can span multiple lines. Here is an example:
print('Enter the amount of ' + \
'sales for each day and ' + \
'press Enter.')
This statement will display the following:
Enter the amount of sales for each day and press Enter.
Page 5
 Designing a Program
Programs must be carefully designed before they are written. During the design
process, programmers use tools such as pseudo code and flowcharts to create models
of programs.
The Program Development Cycle:
The process of creating a program that works correctly typically requires the five
phases. The entire process is known as the program development cycle.

Let’s take a closer look at each stage in the cycle.

1. Design the Program: All professional programmers will tell you that a program
should be carefully designed before the code is actually written. When
programmers begin a new project, they never jump right in and start writing
code as the first step. They start by creating a design of the program.
2. Write the Code: After designing the program, the programmer begins writing
code in a high-level language such as Python. Each language has its own rules,
known as syntax that must be followed when writing a program. A language’s
syntax rules dictate things such as how key words, operators, and punctuation
characters can be used. A syntax error occurs if the programmer violates any of
these rules.
3. Correct Syntax Errors: If the program contains a syntax error, or even a
simple mistake such as a misspelled keyword, the compiler or interpreter will
display an error message indicating what the error is. Virtually all code contains
syntax errors when it is first written, so the programmer will typically spend
some time correcting these. Once all of the syntax errors and simple typing
mistakes have been corrected, the program can be compiled and translated into
a machine language program (or executed by an interpreter, depending on the
language being used).
4. Test the Program: Once the code is in an executable form, it is then tested to
determine whether any logic errors exist. A logic error is a mistake that does not
prevent the program from running, but causes it to produce incorrect results.
(Mathematical mistakes are common causes of logic errors.)
5. Correct Logic Errors: If the program produces incorrect results, the
programmer debugs the code. This means that the programmer finds and
corrects logic errors in the program. Sometimes during this process, the
programmer discovers that the program’s original design must be changed. In
this event, the program development cycle starts over, and continues until no
errors can be found.
Page 6
More about the Design Process:
The process of designing a program is arguably the most important part of the cycle.
The process of designing a program can be summarized in the following two steps:
1. Understand the task that the program is to perform:
It is essential that you understand what a program is supposed to do before you
can determine the steps that the program will perform. Typically, a professional
programmer gains this understanding by working directly with the customer. We
use the term customer to describe the person, group, or organization that is
asking you to write a program.
To get a sense of what a program is supposed to do, the programmer usually
interviews the customer. During the interview, the customer will describe the task
that the program should perform, and the programmer will ask questions to
uncover as many details as possible about the task.
The programmer studies the information that was gathered from the customer
during the interviews and creates a list of different software requirements. A
software requirement is simply a single task that the program must perform in
order to satisfy the customer. Once the customer agrees that the list of
requirements is complete, the programmer can move to the next phase.
2. Determine the steps that must be taken to perform the task:
Once you understand the task that the program will perform, you begin by
breaking down the task into a series of steps. Dividing a task into set of well-
defined logical steps is called Algorithm. The steps in this algorithm are
sequentially ordered. Step1 should be performed before step2 , and so on. Once
an algorithm is created, which lists all of the logical steps that must be taken to
perform the task.
Algorithm: For adding two numbers
Step1: Take two values
Step2: add two values
Step3: display the result
Of course, this algorithm is not ready to be executed on the computer. The
steps in this list have to be translated into code. Programmers commonly use two
tools to help them accomplish this: pseudocode and flowcharts.
1. Pseudocode:
The word "pseudo" means fake, so pseudocode is fake code. It is an informal
language that has no syntax rules, and is not meant to be compiled or executed.
Instead, programmers use pseudocode to create models of programs. Because
programmers do not have to worry about syntax errors while writing pseudocode,
they can focus all of their attention on the program’s design. Once a satisfactory
design has been created with pseudocode, the pseudocode can be translated
directly to actual code.
Pseudocode : for adding two numbers:
Declare three variables a,b,sum
Input the values for a,b variables

Page 7
 sum  a+b
Print sum
2. Flow chart: Flowcharting is another tool that programmers use to design
programs. A flowchart is a diagram that graphically depicts the steps that take
place in a program.
Flowchart for adding two numbers:

Input, Processing, and Output

Computer programs typically perform the following three-step process:
1. Input is received.
2. Some process is performed on the input.
3. Output is produced.
Input is any data that the program receives while it is running. One common form of
input is data that is typed on the keyboard. Once input is received, some process,
such as a mathematical calculation, is usually performed on it. The results of the
process are then sent out of the program as output.
The below Figure illustrates these three steps in the pay calculating program. The
number of hours worked and the hourly pay rate are provided as input. The program
processes this data by multiplying the hours worked by the hourly pay rate. The
results of the calculation are then displayed on the screen as output.

Comments
Comments are short notes placed in different parts of a program, explaining how
those parts of the program work. Although comments are a critical part of a program,
they are ignored by the Python interpreter. Comments are intended for any person
reading a program’s code, not the computer.
In Python you begin a comment with the # character. When the Python interpreter
sees a # character, it ignores everything from that character to the end of the line.
Ex: comments.py

Page 8
 # This program displays a person's
# name and address.
print('Mahesh')
print('Gandhi Nagar')
print('Rajanna Sircilla')
In the above program, First two lines are Comment lines which are ignored by the
python interpreter. So, the output will be:
Output:
Mahesh
Gandhi Nagar
Rajanna Sircilla

Variables
Programs use variables to access and manipulate data that is stored in memory. A
variable is a name that represents a value in the computer’s memory. For example, a
program that calculates the sales tax on a purchase might use the variable name
tax to represent that value in memory. When a variable represents a value in the
computer’s memory, we say that the variable references the value.
Variable naming rules: Although we are allowed to make up our own names for
variables, we must follow these rules.
 We cannot use one of python’s keywords as a variable name.
 A variable name cannot contain spaces.
 The first character must be one of the letters a through z , A through Z or an
underscore character ( _ ).
 After the first character we may use the letters a through , A through Z, the Digits
0 through 9 or underscore.
 Uppercase and Lower case letters are distinct.
In addition to following these rules, you should always choose names for your
variables that give an indication of what they are used for. For example, a variable
that holds the temperature might be named temperature, and a variable that holds a

car’s speed might be named speed. You may be tempted to give variables names like
x and b2, but names like these give no clue as to what the variable’s purpose is.
Sample Variable Names

Page 9
Creating Variables with Assignment Statements
We use an assignment statement to create a variable and make it reference a piece of
data. Here is an example of an assignment statement: age = 25

An assignment statement is written in the following general format:

Variable = expression
The equal sign (=) is known as the assignment operator. In the general format,
variable is the name of a variable and expression is a value, or any piece of code that
results in a value. After an assignment statement executes, the variable listed on the
left side of the (=) operator will reference the value given on the right side of the (=)
operator.
Ex: (variable_demo1.py)
# This program demonstrates a variable. Program output:
room = 503 I am staying in room number 503
print('I am staying in room number', room)
Variable Reassignment : Variables are called "variable" because they can reference
different values while a program is running. When you assign a value to a variable,
the variable will reference that value until you assign it a different value.
Ex: variable_demo2.py
# This program demonstrates variable reassignment.
# Assign a value to the dollars variable. Program output:
dollars = 2.75 I have 2.75 in my account.
print('I have', dollars, 'in my account.') But now I have 99.95 in my account!
# Reassign dollars so it references a different value.
dollars = 99.95
print('But now I have', dollars, 'in my account!')
Data Types and Literals
Python uses data types to categorize values in memory. When an integer is stored in
memory, it is classified as an int, and when a real number is stored in memory, it is
classified as a float. In addition to the int and float data types, Python also has a data
type named str, which is used for storing strings in memory. Python has five standard
data types:
 Numbers (int , float)
 String
 List
 Tuple
 Dictionary
A number that is written into a program’s code is called a numeric literal. When the
Python interpreter reads a numeric literal in a program’s code, it determines its data
type according to the following rules:
Page 10
 A numeric literal that is written as a whole number with no decimal point is
considered an int.
Examples are 7, 124, and 9.
 A numeric literal that is written with a decimal point is considered a float.
Examples are 1.5, 3.14159, and 5.0.

 A String literal that is written as enclosing with double quotation marks or single
quotation marks is considered a string.
Examples are "python", ‘programming’, and "language"
Ex: different_variable.py
# Create variables to reference different types of values.
rollno = 100 Program output:
name = “ vikas “ Roll No: 100
fee = 5000.00 Name: vikas
print(“Roll No :”,rollno) Fee: 5000.00
print(“Name:”,name)
print(“Fee:”,fee)
Python Basic Operators
Python has several operators that can be used to perform mathematical calculations.
They are
1. Arithmetic Operators or Math operators: Arithmetic operators are used to
perform mathematical operations like addition, subtraction, multiplication etc.

Symbol operation Description

+ Addition Adds two numbers

- Subtraction Subtracts one number from another

* Multiplication Multiplies one number by another

Divides one number by another and gives the

/ Division
result as a floating-point number

Divides one number by another and gives the

% Modulus
remainder

** Exponent Raises a number to a power

Divides one number by another and gives the

// Floor Division
result as an integer

2. Comparison (Relational) Operators: Comparison operators are used to

compare values. It either returns True or False according to the condition.

Symbol operation Description

If the values of two operands are equal, then the

== Equal to
condition becomes true.

Page 11
 If values of two operands are not equal, then
!= Not equal to
condition becomes true.

If the value of left operand is greater than the

> Greater than value of right operand, then condition becomes
true.

If the value of left operand is less than the value of

< Less than
right operand, then condition becomes true.

If the value of left operand is greater than or equal

Greater than or equal
>= to the value of right operand, then condition
to
becomes true.

If the value of left operand is less than or equal to

<= Less than or equal to the value of right operand, then condition becomes
true.

3. Assignment Operators: Assignment operators are used in Python to assign

values to variables.
Ex: x=10; here, x is a variable and it is assigned with 10.
4. Logical Operators: These operators are used to form compound conditions by
combining two or more relations.

Symbol operation Description

and Logical AND If both the operands are true then condition becomes true.

or Logical OR if either of the operands is true then condition becomes true.

if operand is false (complements the operand) then condition

not Logical NOT
is true

5. Bitwise Operators: Bitwise operator works on bits and performs bit by bit
operation.

Symbol operation Description

Operator copies a bit to the result if it exists in both

& Bitwise AND
operands

| Bitwise OR It copies a bit if it exists in either operand.

^ Bitwise XOR It copies the bit if it is set in one operand but not both.

~ Bitwise NOT It is unary and has the effect of 'flipping' bits.

Bitwise right The left operands value is moved right by the number of
>>
shift bits specified by the right operand.

Bitwise left The left operands value is moved left by the number of
<<
shift bits specified by the right operand.

6. Membership Operators: Python’s membership operators test for membership in

a sequence, such as strings, lists, or tuples.

Symbol Description
Page 12
 Evaluates to true if it finds a variable in the specified sequence and false
in
otherwise.

Evaluates to true if it does not finds a variable in the specified sequence

not in
and false otherwise.

7. Identity Operators: Identity operators compare the memory locations of two

objects.

Symbol Description

Evaluates to true if the variables on either side of the operator point to

is
the same object and false otherwise.

Evaluates to false if the variables on either side of the operator point to

is not
the same object and true otherwise.

Python Operators Precedence

Precedence is the priority order of an operator, if there are two or more operators in
an expression then the operator of highest priority will be executed first then higher,
and then high.

Operator Description

** Exponentiation (raise to the power)

~+- Complement, unary plus and minus

* / % // Multiply, divide, modulo and floor division

+- Addition and subtraction

>> << Right and left bitwise shift

& Bitwise 'AND'

^| Bitwise exclusive `OR' and regular `OR'

<= < > >= Comparison operators

<> == != Equality operators

= %= /= //= -= += *= **= Assignment operators

is is not Identity operators

in not in Membership operators

not or and Logical operators

Page 13
 Control Structures
Normally statements in a program are executed sequentially i.e, in the order in which
they are written. This is called sequential execution. Transferring control to a desired
location in a program is possible through control structure. Python allows many kind
of control structures which include:
1. Decision structures
i) Simple if
ii) If-else
iii) If-elif-else
iv) Nested decision structure
2. Repetition structures
i) While loop
ii) For loop
1. Decision Structures:
The if statement is used to create a decision structure, which allows a program to
have more than one path of execution. If statements are present in different forms in
python.
1. Simple if: The if statement causes one or more statements to execute only when
a Boolean expression or condition is true.
General format of if statement Flow chart Example(simpleif.py)
if condition: n=int(input("Enter a value: "))
statement if(n>0):
statement print(“positive number”)
etc

2. If-else: An if-else statement will execute one block of statements if its condition is
true, or another block if its condition is false.
General format of if–else statement Flow chart Example (exifelse.py)
if condition: a=int(input("Enter a value: "))
statement b=int(input("Enter b value: "))
statement if(a>b):
etc. print("a is big")
else: else:
statement print("b is big")
statement
etc.
3. The if-elif-else Statement: Python provides a special version of the decision
structure known as the if-elif-else statement. When this statement executes,
condition_1 is tested. If condition_1 is true, the block of statements that
immediately follow is executed, up to the elif clause. The rest of the structure is
ignored. If condition_1 is false, however, the program jumps to the very next elif
Page 14
 clause and tests condition_2. If it is true, the block of statements that immediately
follow is executed, up to the next elif clause. The rest of the structure is then
ignored. This process continues until a condition is found to be true, or no more
elif clauses are left. If no condition is true, the block of statements following the
else clause is executed.
General format of Flow chart Exam ple(exifelif.py)
if – elif-else statement a=int(input("Enter a value: "))
if condition_1: b=int(input("Enter b value: "))
statement c=int(input("Enter c value: "))
statement if(a>b and a>c):
etc. print("a is big")
elif condition_2: elif(b>c):
statement print("b is big")
statement else:
etc. print("c is big")
.
.
else:
statement
statement
etc.
4. Nested Decision Structures: To test more than one condition, a decision
structure can be nested inside another decision structure. Writing of if-else
statement in another if or else statement is called Nested decision structure. In
this, if the condition1 is false statement(s)-3 will be executed; otherwise it
continues to perform condition2. If condition2 is true, statement(s)-1 will be
executed. Otherwise statement(s)-2 will be executed.
General format of Flow chart Example(nested.py)
Nested decision structure:
if condition 1: if(a>b):
if condition 2: if(a>c):
Statement(s)-1 print("a is big")
else: else:
Statement(s)-2 print("c is big")
else: else:
Statement(s)-3 if(b>c):
Print("b is big")
else:
Print("c is big")

Page 15
 Repetition Structures:
A repetition structure causes a statement or set of statements to execute repeatedly.
There are two categories of loops:
1. condition-controlled loop
2. count-controlled loop
A condition-controlled loop uses a true/false condition to control the number of times
that it repeats. A count-controlled loop repeats a specific number of times. In Python
you use the while statement to write a condition-controlled loop, and you use the for
statement to write a count-controlled loop.
1. The while loop: a condition-controlled loop: A condition-controlled loop
causes a statement or set of statements to repeat as long as a condition is true. In
Python you use the while statement to write a condition-controlled loop. The while
loop gets its name from the way it works: while a condition is true, do some task.
The loop has two parts: (1) a condition that is tested for a true or false value, and
(2) a statement or set of statements that is repeated as long as the condition is
true.
General format of while Flow chart Example: (exwhile.py)
while condition: i=1
statement while(i<=10):
statement print(i)
etc. i=i+1

2. The for loop: a count-controlled loop: A count-controlled loop iterates a

specific number of times. In Python you use the for statement to write a count-
controlled loop. In Python, the for statement is designed to work with a sequence
of data items. When the statement executes, it iterates once for each item in the
sequence.
General format of for loop:
for variable in [value1, value2, etc.]:
statement
statement
etc.
In the for clause, variable is the name of a variable. Inside the brackets a
sequence of values appears, with a comma separating each value. The for
statement executes in the following manner: The variable is assigned the first
value in the list, and then the statements that appear in the block are executed.
Then, variable is assigned the next value in the list, and the statements in the
block are executed again. This continues until variable has been assigned the last
value in the list.
Example: (exfor.py):
list=[1,2,3,4]
for i in list:
print(i)

Page 16
 Using the range Function with the for Loop:
Python provides a built-in function named range that simplifies the process of writing
a count-controlled for loop. The range function creates a type of object known as an
iterable. An iterable is an object which is similar to a list. It contains a sequence of
values that can be iterated over with something like a loop.
Here is an example of a for loop that uses the range function:
for num in range(5):
print(num)
Notice that instead of using a list of values, we call to the range function passing 5 as
an argument. In this statement the range function will generate an iterable sequence
of integers in the range of 0 up to (but not including) 5. So, the above code prints : 0
to 4 numbers.
If you pass two arguments to the range function, the first argument is used as the
starting value of the sequence and the second argument is used as the ending limit.
Here is an example:
Example: Output:
for num in range(1, 5): 1
print(num) 2
3
4
If you pass a third argument to the range function, that argument is used as step
value. Instead of increasing by 1, each successive number in the sequence will
increase by the step value. Here is an example:
Example: Output:
for num in range(1, 10, 2): 1
print(num) 3
5
7
9

Calculating a running total

A running total is a sum of numbers that accumulates with each iteration of a loop.
The variable used to keep the running total is called an accumulator. Many
programming tasks require you to calculate the total of a series of numbers. For
example, suppose you are writing a program that calculates the sum of numbers
entered by the user.
Programs that calculate the total of a series of numbers typically use two elements:
• A loop that reads each number in the series.
• A variable that accumulates the total of the numbers as they are read.0

Page 17
Logic of Running Total:

The above flowchart shows the general logic of a loop that calculates a running total.
When the loop finishes, the accumulator will contain the total of the numbers that
were read by the loop. Notice that the first step in the flowchart is to set the
accumulator variable to 0. This is a critical step. Each time the loop reads a number,
it adds it to the accumulator. If the accumulator starts with any value other than 0, it
will not contain the correct total when the loop finishes.
Example program for calculating Running Total:
# this program calculates the series of numbers entered by the user.
def main( ): Output:
tot=0 Enter a number: 5
for i in range(1,4): Enter a number: 5
num=int(input(“Enter a number:”)) Enter a number: 2
tot=tot+num sum of 3 numbers is: 12
print(“sum of 3 numbers is:”+tot)
Comparing Strings:
Python allows you to compare strings. This allows you to create decision structures
that test the value of a string.
For example, look at the following code:
name1 = 'Vikas'
name2 = 'Vikky'
if name1 == name2:
print('The names are the same.')
else:
print('The names are NOT the same.')
The == operator compares name1 and name2 to determine whether they are
equal. Because the strings 'Vikas' and 'Vikky' are not equal, the else clause will
display the message 'The names are NOT the same.
In addition to determining whether strings are equal or not equal, you can also
determine whether one string is greater than or less than another string. This is a
useful capability because programmers commonly need to design programs that sort
strings in some order.

Page 18
 Boolean Variables:
A Boolean variable can reference one of two values: True or False. Boolean variables
are commonly used as flags, which indicate whether specific conditions exist. Boolean
variables are most commonly used as flags. A flag is a variable that signals when
some condition exists in the program. When the flag variable is set to False, it
indicates the condition does not exist. When the flag variable is set to True, it means
the condition does exist.
Here are examples of how we assign values to a boolean variable:
hungry = True
sleepy = False
Input Validation Loops:
Input validation is the process of inspecting data that has been input to a program, to
make sure it is valid before it is used in a computation. Input validation is commonly
done with a loop that iterates as long as an input variable references bad data.
One of the most famous sayings among computer programmers is “garbage in,
garbage out. This saying, sometimes abbreviated as GIGO, refers to the fact that
computers cannot tell the difference between good data and bad data. If a user
provides bad data as input to a program, the program will process that bad data and,
as a result, will produce bad data as output. Consider the following example.
Example (payroll.py):
def main():
hours = int(input('Enter the hours worked this week: '))
pay_rate = float(input('Enter the hourly pay rate: '))
gross_pay = hours * pay_rate
print('Gross pay: $', format(gross_pay, ',.2f'))

main()
Program Output:
Enter the hours worked this week: 400
Enter the hourly pay rate: 20
The gross pay is $8,000.00
In the above example, the user or clerk entered 400 instead of 40 hours worked in
the week. There are no 400 hours in a week. So, it produces wrong result.
For this reason, you should design your programs in such a way that bad input is
never accepted. When input is given to a program, it should be inspected before it is
processed. If the input is invalid, the program should discard it and prompt the user
to enter the correct data. This process is known as input validation.

Page 19
Logic containing an input validation loop:

Nested Loops:
A loop that is inside another loop is called a nested loop.
Syntax:
for iterating_var in sequence:
for iterating_var in sequence:
Statement(s)
Statement(s)
Example: (pattern.py) Output:
def main(): 1
for i in range(1,6): 1 2
for j in range(1,i+1): 1 2 3
print(j,end=" ") 1 2 3 4
print(end='\n') 1 2 3 4 5
main()
A final note on loop nesting is that you can put any type of loop inside of any other
type of loop. For example a for loop can be inside a while loop or vice versa.

Page 20
 Functions: Introduction, Defining and Calling a Void Function, Designing a
Program to Use Functions, Local Variables, Passing Arguments to Functions,
UNIT Global Variables and Global Constants, Value-Returning Functions-
Generating Random Numbers, Writing Our Own Value- Returning
II Functions, The math Module, Storing Functions in Modules.
FILE AND EXCEPTIONS: Introduction to File Input and Output, Using
Loops to Process Files, Processing Records, Exceptions.
Functions
Function: A function is a group of statements that exist within a program for the
purpose of performing a specific task. Instead of writing a large program as one long
sequence of statements, it can be written as several small functions, each one
performing a specific part of the task. These small functions can then be executed in
the desired order to perform the overall task. This approach is sometimes called
divide and conquer because a large task is divided into several smaller tasks that are
easily performed.
Benefits of using Functions (or) Benefits of Modularizing a Program with
Functions:
1. Simpler Code: A program’s code tends to be simpler and easier to understand
when it is broken down into functions. Several small functions are much easier to
read than one long sequence of statements.
2. Code Reuse: Functions also reduce the duplication of code within a program. If a
specific operation is performed in several places in a program, a function can be
written once to perform that operation, and then be executed any time it is
needed. This benefit of using functions is known as code reuse because you are
writing the code to perform a task once and then reusing it each time you need to
perform the task.
3. Better Testing: When each task within a program is contained in its own
function, testing and debugging becomes simpler. Programmers can test each
function in a program individually, to determine whether it correctly performs its
operation. This makes it easier to isolate and fix errors.
4. Faster Development: Suppose a programmer or a team of programmers is
developing multiple programs. They discover that each of the programs perform
several common tasks, such as asking for a username and a password, displaying
the current time, and so on. It doesn’t make sense to write the code for these
tasks multiple times. Instead, functions can be written for the commonly needed
tasks, and those functions can be incorporated into each program that needs
them.
5. Easier Facilitation of Teamwork: Functions also make it easier for programmers
to work in teams. When a program is developed as a set of functions that each
performs an individual task, then different programmers can be assigned the job
of writing different functions.

Page 21
 Function Names:
Just as we name the variables that we use in a program, we also name the functions.
A function’s name should be descriptive enough so that anyone reading our code can
reasonably guess what the function does.
Rules for defining function names:
 You cannot use one of Python’s key words as a function name.
 A function name cannot contain spaces.
 The first character must be one of the letters a through z, A through Z, or an
underscore character (_).
 After the first character we may use the letters a through z or A through Z, the
digits 0 through 9, or underscores.
 Uppercase and lowercase characters are distinct.
Defining and Calling a void Function
Function: A function is a group of statements that exist within a program for the
purpose of performing a specific task.
Defining function: To create a function we write its definition. Here is the general
format of a function definition in Python:
def function_name():
statement
statement
etc.
The first line is known as the function header. It marks the beginning of the function
definition. The function header begins with the key word def, followed by the name of
the function, followed by a set of parentheses, followed by a colon.
Beginning at the next line is a set of statements known as a block. A block is simply a
set of statements that belong together as a group. These statements are performed
any time the function is executed.
Example for defining a function:
def display( ):
print(“I am in display method”)
print(“I will be executed when I called”)
This code defines a function named display. The display function contains a block with
two statements. Executing the function will cause these statements to execute.
Calling a Function: A function definition specifies what a function does, but it does
not cause the function to execute. To execute a function, we must call it.
Example for calling a function:
display( )
When a function is called, the interpreter jumps to that function and executes the
statements in its block.
Example(simplefunction.py): Output:
def display( ): I am in display method
Page 22
 print(“I am in display method”) I will be executed when I called
print(“I will be executed when I called”)
display( )
Indentation in Python
In Python, each line in a block must be indented. When you indent the lines in a
block, make sure each line begins with the same number of spaces. Otherwise an
error will occur. In an editor there are two ways to indent a line: (1) by pressing the
Tab key at the beginning of the line, or (2) by using the spacebar to insert spaces at
the beginning of the line. You can use either tabs or spaces when indenting the lines
in a block, but don’t use both. Doing so may confuse the Python interpreter and cause
an error.
IDLE, as well as most other Python editors, automatically indents the lines in a block.
When we type the colon at the end of a function header, all of the lines typed
afterward will automatically be indented. After we have typed the last line of the block
we press the Backspace key to get out of the automatic indentation.
Designing a Program to Use Functions
Programmers commonly use a technique known as top-down design to break down an
algorithm into functions. Flow charts are common tools for designing programs. In a
flowchart, a function call is shown with a rectangle that has vertical bars at each side.
The example shown below shows how we would represent a call to the message
function.

Consider the following example:

Page 23
In the below design, we can see how control of a program is transferred to a function
when it is called, and then returns to the part of the program that called the function
when the function ends.
Programmers commonly use a technique known as top-down design to break down an
algorithm into functions. The process of top-down design is performed in the following
manner:
 The overall task that the program is to perform is broken down into a series of
subtasks.
 Each of the subtasks is examined to determine whether it can be further broken
down into more subtasks. This step is repeated until no more subtasks can be
identified.
 Once all of the subtasks have been identified, they are written in code.
Flow chart for (two_functions.py)

Local Variables
The variables that are defined inside the functions are called as local variables. They
cannot be accessed by statements that are outside the function. Different functions
can have local variables with the same names because the functions cannot see each
other’s local variables.
An error will occur if a statement in one function tries to access a local variable that
belongs to another function. Local variables memory will be deallocated when it’s
function terminates.
Scope and Local Variables: A variable’s scope is the part of a program in which the
variable may be accessed. A variable is visible only to statements in the variable’s
scope. A local variable’s scope is the function in which the variable is created, no
statement outside the function may access the variable.
Example: (local.py):
def main( ):
getname( )
print(“hello”,name) # it causes error because local variable of getname.
# so, “name” variable visible to only getname( ).

Page 24
def getname( ):
Name = input(“Enter ur name:”)
main( )
Passing Arguments to Functions
An argument is any piece of data that is passed into a function when the function is
called. A parameter is a variable that receives an argument that is passed into a
function. The following example explains how to pass arguments to functions.
Example:(arguments.py):
def main( ):
a=int(input(“Enter a number:”)
b=int(input(“Enter b number:”)
print(“ Addition of two numbers:”)
add(a,b)

def add(x,y):
sum=x+y
Print(“addition of x,y is:”,sum)

main( )
In the above program, a,b are arguments which are passed to called function add
and x,y are parameters which are received the values coming from calling function.
Making Changes to Parameters
When an argument is passed to a function in Python, the function parameter variable
will reference the argument’s value. However, any changes that are made to the
parameter variable will not affect the argument. The following program demonstrates
it.
Example(changeparameter.py):
def main():
value=70
print("The argument value in main:",value)
change_me(value)
print("after changing the parameter value in change_me:",value)

def change_me(value):
print("I am going to change the value:",value)
value=10
print("the parameter value in change me:",value)

main()

Page 25
In the above program, the reassingnment changes the “value” variable inside the
change_me function but it does not affect the value variable in main.
Program Output:
The argument value in main: 70
I am going to change the value: 70
the parameter value in change me: 10
after changing the parameter value in change_me: 70
Global Variables and Global Constants
Global variables:
When a variable is created by an assignment statement that is written outside
all the functions in a program file, the variable is called global variable. A global
variable can be accessed by any statement in the program file, including the
statements in any function.
Example:( global.py): Output:
Value=10 #gloabal variable global variable value is: 10
def main():
Print(“global variable value is:”,value)
main()
In the above example, “value” is global variable. So, inside the main() we
accessed it directly. Global variables can be accessed directly in any functions in the
program.
Reasons for most of the programmers avoid using global variables:
Most programmers agree that you should restrict the use of global variables, or not
use them at all. The reasons are as follows:
 Global variables make debugging difficult. Any statement in a program file can
change the value of a global variable. If you find that the wrong value is being
stored in a global variable, you have to track down every statement that accesses
it to determine where the bad value is coming from. In a program with thousands
of lines of code, this can be difficult.
 Functions that use global variables are usually dependent on those variables. If
 you want to use such a function in a different program, most likely you will have to
redesign it so it does not rely on the global variable.
 Global variables make a program hard to understand. A global variable can be
modified by any statement in the program. If you are to understand any part of
the program that uses a global variable.
Global constants: A global constant is a global name that references a value that
cannot be changed. Because a global constant’s value cannot be changed during the
program’s execution, you do not have to worry about many of the potential hazards
that are associated with the use of global variables.
Although the Python language does not allow you to create true global constants, you
can simulate them with global variables. If you do not declare a global variable with

Page 26
B.Sc (Computer Science) V Semester Programming with Python

the global key word inside a function, then you cannot change the variable’s
assignment inside that function.
Example(global2.py): Output:
x=5 sum: 20
y=2 # global constant subtraction: 8
def main():
global x
x=10 #changing the global variable value
y=10 #local variable to main
print("sum",(x+y))
show()
def show():
print("subtraction:",x-y) #y is global constant it’s value is 2 and x is global variable.
main()
Value-Returning Functions:
A value-returning function is a special type of function. It is like a simple function
in the following ways.
 It is a group of statements that perform a specific task.
 When you want to execute the function, you call it.
When a value-returning function finishes, however, it returns a value back to the part
of the program that called it. The value that is returned from a function can be used
like any other value: it can be assigned to a variable, displayed on the screen, used in
a mathematical expression.
Writing Your Own Value-Returning Functions:
A value-returning function has a return statement that returns a value back to
the part of the program that called it. Here is the general format of a value-returning
function definition in Python:
def function_name():
statement
statement
etc.
return expression
The first line is known as the function header. The function header begins with the
key word def, followed by the name of the function, followed by a set of parentheses,
followed by a colon.
Beginning at the next line is a set of statements known as a block. In value-returning
function block one of the statement should be a return statement.
The value of the expression that follows the keyword return will be sent back to the
part of the program that called the function. This can be any value, variable, or
expression that has a value.

Page 27
Example(returnfunction.py): Output:
def main():` enter a number: 5
a=int(input("enter a number:")) enter b number: 5
b=int(input("enter b number:")) sum: 10
c=add(a,b)
print("sum:",c)
def add(a,b):
c=a+b
return c
main()
In the above program, add function returns a value which is assigned in ‘c’ variable of
main function.
Standard Library Functions and the import Statement
Python, as well as most other programming languages, comes with a standard library
of functions that have already been written for you. These functions, known as library
functions, make a programmer’s job easier because they perform many of the tasks
that programmers commonly need to perform. In fact, you have already used several
of Python’s library functions. Some of the functions that you have used are print,
input, and range. Python has many other library functions.
Some of Python’s library functions are built into the Python interpreter. If you want to
use one of these built-in functions in a program, you simply call the function. This is
the case with the print, input, range etc.
Many of the functions in the standard library, however, are stored in files that are
known as modules. These modules, which are copied to your computer when you
install Python, help organize the standard library functions. For example, functions for
performing math operations are stored together in a module, functions for working
with files are stored together in another module, and so on.
In order to call a function that is stored in a module, you have to write an import
statement at the top of your program. An import statement tells the interpreter the
name of the module that contains the function. For example, one of the Python
standard modules is named math. The math module contains various mathematical
functions that work with floating-point numbers. If you want to use any of the math
module’s functions in a program, you should write the following import statement at
the top of the program:
import math
This statement causes the interpreter to load the contents of the math module into
memory and makes all the functions in the math module available to the program.
Because you do not see the internal workings of library functions, many programmers
think of them as black boxes. The term “black box” is used to describe any
mechanism that accepts input, performs some operation (that cannot be seen) using
the input, and produces output.

Page 28
 Fig. A library function viewed as a black box

Generating Random Numbers

Random numbers are useful for lots of different programming tasks. The following are
just a few examples.
 Random numbers are commonly used in games. For example, computer games
that let the player roll dice use random numbers to represent the values of the
dice.
 Random numbers are useful in simulation programs. In some simulations, the
computer must randomly decide how a person, animal, insect, or other living
being will behave. Formulas can be constructed in which a random number is used
to determine various actions and events that take place in the program.
 Random numbers are useful in statistical programs that must randomly select data
for analysis.
 Random numbers are commonly used in computer security to encrypt sensitive
data.
Library functions for working with random numbers:
Python provides several library functions for working with random numbers. These
functions are stored in a module named random in the standard library. To use any of
these functions you first need to write this import statement at the top of your
program:
import random
The following are the library functions for working with random numbers:
1. randint( ): This function is used to generate random integer numbers. Because
the randint function is in the random module, we will need to use dot notation to
refer to it in our program. In dot notation, the function’s name is
random.randint. On the left side of the dot (period) is the name of the module,
and on the right side of the dot is the name of the function.
The following interactive session depicts using randint function.
Example:
>>> import random
>>> number=random.randint(1,100)
>>> print(number)
7
>>>
In the above example, randint function returns a random integer number between
1 to 100
2. randrange( ):The randrange function takes the same arguments as the range
function.The difference is that the randrange function does not return a list of
values. instead, it returns a randomly selected value from a sequence of values.

Page 29
 Example of randrange function which having single argument:
>>> import random
>>> number=random.randrange(10)
>>> print(number)
9
>>>
In the above interactive session, The randrange function will return a randomly
selected number from the sequence of values 0 up to, but not including, the
ending limit 10.
Example of randrange function which having two arguments:
>>> import random
>>> number=random.randrange(5,20)
>>> print(number)
8
In the above interactive session, The randrange function will return a randomly
selected number from the sequence of values 5 up to, but not including, the
ending limit 20.
Example of randrange function which having three arguments:
>>> import random
>>> number=random.randrange(0,101,10)
>>> print(number)
31
>>>
In the above interactive session, the randrange function returns a randomly
selected value from the following sequence of numbers:
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
3. random( ): The random function returns a random floating-point number. You do
not pass any arguments to the random function. When you call it, it returns a
random floating point number in the range of 0.0 up to 1.0.
The following interactive session depicts the random() function:
>>> import random
>>> number=random.random()
>>> print(number)
0.8106100877945103
>>>
4. uniform( ) : The uniform function also returns a random floating-point number,
but allows you to specify the range of values to select from.
The following interactive session depicts the uniform() function:
>>> import random
>>> number=random.uniform(0.1,1.2)

Page 30
 >>> print(number)
0.8829074535237236
>>>
The math Module
The math module in the Python standard library contains several functions that are
useful for performing mathematical operations. These functions typically accept one
or more values as arguments, perform a mathematical operation using the
arguments, and return the result. To use the functions of math module in our
program, we have to import it. The following table lists the functions in math module.
Math Module Function Description
acos(x) Returns the arc cosine of x, in radians.
asin(x) Returns the arc sine of x, in radians.
atan(x) Returns the arc tangent of x, in radians.
ceil(x) Returns the smallest integer that is greater than or equal to x.
cos(x) Returns the cosine of x in radians.
degrees(x) Assuming x is an angle in radians, the function returns the
angle converted to degrees.
exp(x) Returns ex
floor(x) Returns the largest integer that is less than or equal to x.
hypot(x, y) Returns the length of a hypotenuse that extends from (0, 0)
to (x, y).
log(x) Returns the natural logarithm of x.
log10(x) Returns the base-10 logarithm of x.
radians(x) Assuming x is an angle in degrees, the function returns the
angle converted to radians.
sin(x) Returns the sine of x in radians.
sqrt(x) Returns the square root of x.
tan(x) Returns the tangent of x in radians.
Example:(exmath.py) Output:
import math sin(x) : -0.99
def main(): cos(x) : -0.45
print("sin(x) :",format(math.sin(30),'.2f')) tan(x) : 1.62
print("cos(x) :",format(math.cos(90),'.2f')) floor(x) : 3
print("tan(x) :",format(math.tan(45),'.2f')) ceil(x) : 4
print("floor(x) :",math.floor(3.7)) log(x) : 2.08
print("ceil(x) :",math.ceil(3.7)) log10(x) : 2.00
print("log(x) :",format(math.log(8),'.2f')) sqrt(x) : 4.0
print("log10(x) :",format(math.log10(100),'.2f'))
print("sqrt(x) :",math.sqrt(16))
main()
Page 31
 Storing Functions in Modules
A module is simply a file that contains Python code. When you break a program into
modules, each module should contain functions that perform related tasks. Modules
make it easier to reuse the same code in more than one program. If you have written
a set of functions that are needed in several different programs, you can place those
functions in a module. Then, you can import the module in each program that needs
to call one of the functions.
For example, following are the two modules:
Example1 (module): circle.py Example2 (module): rectangle.py
import math def area(length,breadth):
def area(radius): return length*breadth
return math.pi*radius**2 def perimeter(length,breadth):
def circumference(radius): return 2*(length+breadth)
return 2*math.pi*radius
The above two modules has certain functions that are useful to calculate area of
circle, circumference of a circle, area of rectangle and perimeter of a rectangle.
Let us use those functions from circle and rectangle modules in our following
program:
Exmodule.py
import circle
import rectangle
def main():
print("area of circle is:",format(circle.area(3.0),'.2f'))
print("area of rectangle is:",rectangle.area(2,3))
print("perimeter of rectangle is:",rectangle.perimeter(3,2))
main()
Output:
area of circle is: 28.27
area of rectangle is: 6
perimeter of rectangle is: 10
Files
Introduction to File Input and Output:
Programmers usually refer to the process of saving data in a file as “writing data to”
the file. When a piece of data is written to a file, it is copied from a variable in RAM to
the file. The term output file is used to describe a file that data is written to. It is
called an output file because the program stores output in it.
The process of retrieving data from a file is known as “reading data from” the file.
When a piece of data is read from a file, it is copied from the file into RAM, and
referenced by a variable. The term input file is used to describe a file that data is read
from. It is called an input file because the program gets input from the file.
There are always three steps that must be taken when a file is used by a program.
Page 32
1. Open the file: Opening a file creates a connection between the file and the
program. Opening an output file usually creates the file on the disk and allows the
program to write data to it. Opening an input file allows the program to read data
from the file.
2. Process the file: In this step data is either written to the file (if it is an output
file) or read from the file (if it is an input file).
3. Close the file: When the program is finished using the file, the file must be
closed. Closing a file disconnects the file from the program.
Types of Files:
In general, there are two types of files: text and binary. Python allows you to work
with text and binary files.
A text file contains data that has been encoded as text, using a scheme such as
ASCII or Unicode. Even if the file contains numbers, those numbers are stored in the
file as a series of characters. As a result, the file may be opened and viewed in a text
editor such as Notepad.
A binary file contains data that has not been converted to text. The data that is
stored in a binary file is intended only for a program to read. As a consequence, you
cannot view the contents of a binary file with a text editor.
File Access Methods:
Most programming languages provide two different ways to access data stored in a
file: sequential access and direct access.
In sequential access file, you access data from the beginning of the file to the end
of the file. If you want to read a piece of data that is stored at the very end of the file,
you have to read all of the data that comes before it—you cannot jump directly to the
desired data. This is similar to the way cassette tape players work. If you want to
listen to the last song on a cassette tape, you have to either fast-forward over all of
the songs that come before it or listen to them. There is no way to jump directly to a
specific song.
In direct access file (which is also known as a random access file), you can jump
directly to any piece of data in the file without reading the data that comes before it.
This is similar to the way a CD player or an MP3 player works. You can jump directly
to any song that you want to listen to.
File operations:
1. Opening a File: We use the open function in Python to open a file. The open
function creates a file object and associates it with a file on the disk. Here is the
general format of how the open function is used:
file_variable = open(filename, mode)
In the general format:
 file_variable - is the name of the variable that will reference the file object.
 Filename - is a string specifying the name of the file.
 Mode - is a string specifying the mode (reading, writing, etc.) in which the file
will be opened.

Page 33
The following table lists the some of file opening modes for working with files.
Mode Description
'r' Open a file for reading only. The file cannot be changed or written to.
'w' Open a file for writing. If the file already exists, erase its contents. If it
does not exist, create it.
'a' Open a file to be written to. All data written to the file will be appended to
its end. If the file does not exist, create it.
2. Writing Data to a File: Once you have opened a file, we use the file object’s
methods to perform operations on the file. If we want to write data to a file, file
objects have a method named write that can be used to write data to a file. Here
is the general format of how you call the write method:

file_variable.write(string)
In the format, file_variable is a variable that references a file object, and string is
a string that will be written to the file. The file must be opened for writing (using
the 'w' or 'a' mode). Otherwise, an error will occur.
3. Reading Data from a File: If a file has been opened for reading (using the 'r'
mode) we can use the file object’s read method to read its entire contents into
memory. When you call the read method, it returns the file’s contents as a string.
Here is the general format of how we call the read method:
file_contents=file_variable.read( )
In the format, file_contents is a variable which stores the entire file contents
returned by file object’s read method.
4. Closing a File: After all operations are performed on a file, we should close it. To
do so, we should call file object’s close method. Closing a file disconnects the file
from the program. In some systems, failure to close an output file can cause a loss
of data. Here is the general format of how we call the close method:
file_variable.close( )
The following two example programs for writing and reading data from a file named:
vikas.txt
filewrite.py
fileread.py
def main(): def main():
fv=open('vikas.txt','w') fv=open('vikas.txt','r')
fv.write('COURSES OFFERED \n') file_contents=fv.read()
fv.write('-----------------------\n') fv.close()
fv.write('BSc(MPCs)\n') print(file_contents)
fv.write('BSc(MStCs)\n') main()
fv.write('BSc(MCCs)\n') fileread.py output:
fv.close()
print("file successfully copied")
main()
Page 34
filewrite.py output:
file successfully copied
Using Loops to Process Files
Although some programs use files to store only small amounts of data, files are
typically used to hold large collections of data. When a program uses a file to write or
read a large amount of data, a loop is typically involved. For example, look at the
code in following Program .
This program gets sales amounts for a series of days from the user and writes those
amounts to a file named sales.txt. The user specifies the number of days of sales data
he or she needs to enter. In the sample run of the program, the user enters sales
amounts for five days.
Example (writefile.py)
def main():
num_days = int(input('For how many days do you have sales? '))
sales_file = open('sales.txt', 'w')
for count in range(1, num_days + 1):
sales = float(input('Enter the sales for day #', str(count) + ': '))
sales_file.write(str(sales) + '\n')
sales_file.close()
print('Data written to sales.txt.')

main()
Program output:
For how many days do you have sales? 3
Enter the sales for day #1: 1000
Enter the sales for day #2: 2000
Enter the sales for day #3: 1500
Data written to sales.txt.
Reading a File with a Loop and Detecting the End of the File
If we need to write a program that read all of the amounts in the sales.txt file and
calculates their total. We can use a loop to read the items in the file, but we need a
way of knowing when the end of the file has been reached. In python, the readline()
method returns an empty string(‘ ‘) when it has attempted to read beyond the end of
a file. This makes it possible to write while loop that determines when the end of a file
has been reached. Following program reads and displays all of the values in the
sales.txt.
Example( readfile.py)
def main(): Output:
sales_file = open('sales.txt', 'r') 1000
line = sales_file.readline() 2000
while line != '': 1500
Page 35
 amount = float(line)
print(format(amount, '.2f'))
line = sales_file.readline()
sales_file.close()
main()
Using Python’s for Loop to Read Lines
The Python language also allows you to write a for loop that automatically reads line
in a file without testing for any special condition that signals the end of the file. The
loop does not require a priming read operation, and it automatically stops when the
end of the file has been reached. When you simply want to read the lines in a file, one
after the other, this technique is simpler and more elegant than writing a while loop
that explicitly tests for an end of the file condition. Here is the general format of the
loop:
for variable in file_object:
statement
statement
etc.
In the general format, variable is the name of a variable and file_object is a variable
that references a file object. The loop will iterate once for each line in the file. The
first time the loop iterates, variable will reference the first line in the file (as a string),
the second time the loop iterates, variable will reference the second line, and so forth.
Example(readfor.py) Output:
def main(): 1000
sales_file = open('sales.txt', 'r') 2000
for line in sales_file: 1500
amount = float(line)
print(format(amount, '.2f'))
sales_file.close()
main()

Processing records
When data is written to a file, it is often organized into records and fields. A record is
a
complete set of data that describes one item, and a field is a single piece of data
within a record. For example, suppose we want to store data about employees in a
file. The file will contain a record for each employee. Each record will be a collection of
fields, such as name,ID number, and department. This is illustrated in the following
figure.

Page 36
Each time you write a record to a sequential access file, you write the fields that
make up the record, one after the other. For example, The following figure shows a
file that contains three employee records. Each record consists of the employee’s
name, ID number, and department.

The following program shows how employee records can be written to a file.
def main():
num_emps = int(input('How many employee records do you want to create? '))
emp_file = open('employees.txt', 'w')
for count in range(1, num_emps + 1):
print('Enter data for employee #', count, sep='')
name = input('Name: ')
id_num = input('ID number: ')
dept = input('Department: ')
emp_file.write(name + '\n')
emp_file.write(id_num + '\n')
emp_file.write(dept + '\n')
print()
emp_file.close()
print('Employee records written to employees.txt.')

main()
program output:
How many employee records do you want to create? 3
Enter data for employee #1
Name: Richards
ID number: 4258
Department: science

Enter data for employee #2

Name: Martin
ID number: 4586
Department: Marketing

Enter data for employee #3

Name: John

Page 37
ID number: 5468
Department: production
Employee records written to employees.txt.
When we read a record from a sequential access file, we read the data for each field,
one after the other, until we have read the complete record. The following program
demonstrates how we can read the employee records in the employee.txt file.
Example (readfile.py) Output:
def main(): Name: Richards
emp_file = open('employees.txt', 'r') ID: 4258
name = emp_file.readline() Dept: science
while name != '':
id_num = emp_file.readline() Name: Martin
dept = emp_file.readline() ID: 4586
name = name.rstrip('\n') Dept: Marketing
id_num = id_num.rstrip('\n')
dept = dept.rstrip('\n') Name: John
print('Name:', name) ID: 5468
print('ID:', id_num) Dept: production
print('Dept:', dept)
print()
name = emp_file.readline()
emp_file.close()

main()
Exceptions
Exception:
An exception is an error that occurs while a program is running, causing the program
to abruptly halt.
Exception handler:
Python, like most modern programming languages, allows us to write code that
responds to exceptions when they are raised, and prevents the program from
abruptly crashing. Such code is called an exception handler, and is written with the
try/except statement. There are several ways to write a try/except statement, but the
following general format shows the simplest variation:
try:
statement
statement
etc.
except ExceptionName:
statement
Page 38
 statement
etc.
First the key word try appears, followed by a colon. Next, a code block appears which
we will refer to as the try suite. The try suite is one or more statements that can
potentially raise an exception.
After the try suite, an except clause appears. The except clause begins with the key
word except, optionally followed by the name of an exception, and ending with a
colon. Beginning on the next line is a block of statements that we will refer to as a
handler.
When the try/except statement executes, the statements in the try suite begin to
execute. The following describes what happens next:
 If a statement in the try suite raises an exception that is specified by the
ExceptionName in an except clause, then the handler that immediately follows the
except clause executes. Then, the program resumes execution with the statement
immediately following the try/except statement.
 If a statement in the try suite raises an exception that is not specified by the
ExceptionName in an except clause, then the program will halt with a traceback
error message.
 If the statements in the try suite execute without raising an exception, then any
except clauses and handlers in the statement are skipped and the program
resumes execution with the statement immediately following the try/except
statement.
The following program handles ZeroDivisionError exception:
def main(): Output:
try: Enter a number: 5
a=int(input("Enter a number:")) Enter b number: 0
b=int(input("Enter b number:")) zero division error
c=a/b
print(c)
except ZeroDivisionError:
print("zero division error")

main()
Handling Multiple Exceptions
In many cases, the code in a try suite will be capable of throwing more than one type
of exception. In such a case, you need to write an except clause for each type of
exception that you want to handle.
The following program reads the contents from sales.txt. Each line in the file contains
sales amount for one month, and it has several lines. Here is the contents:
1000.00
2000.00
1500.00
Page 39
Example( multipleExcept.py) Output
def main(): total amount: 4,500.00
total = 0.0
try:
infile = open('sales.txt', 'r')
for line in infile:
amount = float(line)
total += amount
infile.close()
print(format(total, ',.2f'))
except IOError:
print('An error occured trying to read the file.')
except ValueError:
print('Non-numeric data found in the file.')
except:
print('An error occured.')

main()
The try suite contains code that can raise different types of exceptions. For example:
 In the above program, we are trying to open sales.txt file in read mode. If it does
not exist, it raises IOError Exception. Then, control jumps to IOError except
clause.
 The float function can raise a ValueError exception if the line variable references a
string that cannot be converted to a floating-point number (an alphabetic string,
for example). Then, control jumps to ValueError except clause.
 If try suit raises other than above mention exceptions, control jumps to except
clause.
Using One except Clause to Catch All Exceptions
Sometimes you might want to write a try/except statement that simply catches any
exception that is raised in the try suite, and, regardless of the exception’s type,
responds the same way. You can accomplish that in a try/except statement by writing
one except clause that does not specify a particular type of exception.
Example( multipleExcept.py)
def main(): Output
total = 0.0 total amount: 4,500.00
try:
infile = open('sales.txt', 'r')
for line in infile:
amount = float(line)
total += amount
Page 40
 infile.close()
print(format(total, ',.2f'))
except:
print('An error occured.')

main()
Above example program, handles any exception raised by try suit, regardless of type
with a single except clause.
Displaying an Exception’s Default Error Message
When an exception is thrown, an object known as an exception object is created in
memory. The exception object usually contains a default error message pertaining to
the exception. When you write an except clause, you can optionally assign the
exception object to a variable, as shown here:
Syntax:
except ValueError as err:
Example (defaulter.py):

def main():
try:
hours = int(input('How many hours did you work? '))
pay_rate = float(input('Enter your hourly pay rate: '))
gross_pay = hours * pay_rate
print('Gross pay: $', format(gross_pay, ',.2f'), sep='')
except ValueError as err:
print(err)

main()
program output1: program output2:
How many hours did you work? 10 How many hours did you work? 10

Enter your hourly pay rate: two hundred Enter your hourly pay rate: 200
could not convert string to float: 'two hundred' Gross pay: $2,000.00
The else Clause
The try/except statement may have an optional else clause, which appears after all
the except clauses. Here is the general format of a try/except statement with an else
clause:
try:
statement
statement
etc.
except ExceptionName:
Page 41
 statement
statement
etc.
else:
statement
statement
etc.
The block of statements that appears after the else clause is known as the else suite.
The statements in the else suite are executed after the statements in the try suite,
only if no exceptions were raised. If an exception is raised, the else suite is skipped.
Example (elseExcept.py)
def main(): Output
total = 0.0 total amount: 4,500.00
try:
infile = open('sales.txt', 'r')
for line in infile:
amount = float(line)
total += amount
infile.close()
print(format(total, ',.2f'))
except IOError as err:
print(err)
else:
print(‘total:’,format(total,’,.2f’)

main()
The finally Clause
The try/except statement may have an optional finally clause, which must appear
after all the except clauses. Here is the general format of a try/except statement with
a finally clause:
try:
statement
statement
etc.
except ExceptionName:
statement
statement
etc.
finally:

Page 42
 statement
statement
etc.
The block of statements that appears after the finally clause is known as the finally
suite.The statements in the finally suite are always executed after the try suite has
executed and after any exception handlers have executed. The statements in the
finally suite execute whether an exception occurs or not. The purpose of the finally
suite is to perform cleanup operations, such as closing files or other resources. Any
code that is written in the finally suite will always execute, even if the try suite raises
an exception.
Example (demofinally.py)
def main(): Output
total = 0.0 total amount: 4,500.00
try: file closed
infile = open('sales.txt', 'r')
for line in infile:
amount = float(line)
total += amount
infile.close()
print(format(total, ',.2f'))
except IOError as err:
print(err)
finally:
infile.close()
print(“file closed”)

main( )

Page 43
 Unit- III
Sequences
A sequence is an object that contains multiple items of data. The items that are in a
sequence are stored one after the other. Python provides various ways to perform
operations on the items that are stored in sequences. There are several different types of
sequential objects in python. They are
i) Lists
ii) Tuples
iii) Dictionaries
iv) Sets
There are two fundamental sequence types: lists & tuples. Both lists and tuples are
sequences that can hold various types of data. The difference between lists and tuples
is simple. A list is mutable, which means that a program can change its contents, but
a tuple is immutable, which means that once it is created, its contents cannot be
changed.
Lists
Introduction to lists:
A list is an object that contains multiple data items. Lists are mutable, which means
that their contents can be changed during a program execution. Lists are dynamic
data structures, meaning that items may be added it them or removed from them.
We can use indexing, slicing and various methods to work with lists in a program.
Creating a list:
A list is an object that contains multiple data items. Each item that is stored in a list is
called an element.
Example:
Numbers=[10,20,30,40,50]
Names=[‘srinu’,’vikas’,’ajay’]
Stud_info=[1,’vikas’,1200.00]
Printing or accessing list Elements:
Example:
stud_info=[1,’vikas’,1200.00]
 Printing all elements from a list
Print(stud_info) Output: [1,’vikas’,1200.00]
 Accessing individual elements from lilst
Print(stud_info[1]) Output: vikas

Page 44
 Accessing individual elements from list using –ve index value
Print(stud_info[-1]) Output:1200.00 [Note: -1 referes last element]
Print(stud_info[-2]) Output: vikas
List ():
Python has a built-in function called list() That can convert certain types of objects to
a list
Example:
i) num1=list(range(5)) -> [0,1,2,3,4]
ii) num2=list(range(1,5)) -> [,1,2,3,4]
iii) num3=list(range(0,50,5)) -> [0,5,10,15,20,25,30,35,40,45]
The repetition operator:
The repetition operator makes multiple copies of a list and joins them all together.
Here is the general format.
List *n
In the general format, list is a list and n is the number of copies to make
Example:
>>> nums=[1,2,3]*3
>>> print(nums) Output: [1,2,3,1,2,3,1,2,3]
when the operand on the left side of the * symbol is a sequence (such as a list) and
the operand on the right side is an integer, it becomes the repetition operator.
Iterating over a list with the for loop:
In python, we can use for loop to access all elements from a list object. Following
program explains how to access all the elements from the list using for loop.
Example:
nums=[10,20,30,40,50]
For i in nums:
print(i)
Output: 10,20,30,40,50
Accessing list elements using Indexing:
Another way that we can access the individual elements in a list is with an index.
Each element in a list has an index that specifies its position in the list. Indexing
starts at ‘0’. So the index of the first element is ‘0’, the index of the second element is
1 and so on. The index of the last element in a list is number of elements in the list
minus one.
Example:
Accessing individual elements from the list using it’s index values:
i=0
nums=[10,20,30,40,50]
while(i<5):
print(nums[i])
i=i+1 Output: 10 20 30 40 50
Page 45
The ‘len’ function:
The python has a built-in function named len() that returns the length of a sequence,
such as a list
Example: Output:
nums=[10,20,30,40,50] 5
length=len(nums)
print(length)
Lists are mutable:
Lists in python are mutable, which means their elements can be changed.
Example1:
nums=[10,20,30,40,50]
nums[0]=5
Print(num) Output: 5 20 30 40 50
Example2:
NUM_DAYS=5
def main():
sales=[0]*NUM_DAYS
print(“Enter the sales for each day:”)
for i in range(0, NUM_DAYS):
print(“Day”, i+1, “:”, end=” “)
sales[i]=float(input())
print(“Here are the values we entered “)
for i in range (NUM_DAYS):
print(sales[i])
main()
Output:
Enter the sales for each day: Here are values we entered
Day1: 1000 1000.0
Day2: 2000 2000.0
Day3:3000 3000.0
Day4:4000 4000.0
Day5:5000 5000.0

Page 46
Concatenating lists
Concatenating means joining two things together, we can use the ‘+’ operator to
concatenate two lists
Example1:
>>>List1=[10,20,30]
>>>List2=[40,50,60]
>>>List3= list1+list2
>>>Print(list3) Output: 10 20 30 40 50 60
Example2:
>>>List1=[‘vikas’, ‘mahesh’, ‘srikanth’]
>>>List1+=[‘vishnu’, ‘kranthi’,’vijay’]
>>>print(List1)
Output:
[vikas,mahesh,srikanth,vishnu,kranthi,vijay]
List slicing:
A slice is a span of items that are taken from a sequence. When we take a slice from
list, we get span of elements from within the list. To get a slice of a list, we write an
expression in the following general format
List_name[start:end]
In the general format, start is the index of the first element in the slice, and end is
the index marking the end of the slice. The expression returns a list containing a copy
of the elements from start upto end
Example1:
>>>days=[‘mon’,’tue’,’wed’,’thurs’,’fri’,’sat’,’sun’]
>>>Print(days[2:5] Output: [wed, thurs, fri]
Example2:
>>>nums=[10,20,30,40,50,60,70,80]
>>>print(nums[:4] Output: 10 20 30 40
Example3:
>>>nums=[10,20,30,40,50,60,70,80]
print(nums[2:] Output: 30 40 50 60 70 80
Example4:
nums=[10,20,30,40,50,60,70,80]
print(nums[:-5]) Output: 10 20 30
Finding items in lists with the ‘in’ operator:
In python, we can use the in operator to determine whether an item is contained in a
list. Here is the general format of an expression written with the ‘in’ operator to
search for an item in a list. Here is the general format.
item in list
In the general format, item is the item for which we searching and list is a list. The
Page 47
expression returns true if item is found in the list or false otherwise
Example:
def main():
stud_names=[‘vishnu’, ‘kranthi’, ‘srikanth’]
search=input(“Enter a name that ur searching for:”)
if search in stud_names:
print(search, “ is found in the list”)
else:

print(search, “ is not found in the list”)

main()
Output:
Enter a name that ur searching for: srikanth
srikanth is found in the list
List methods and useful built-in functions
Python provides some built-in functions that are useful for working with lists.
1. Append(item) : It Adds an item to the end of the list.
General Format: list.append(item)
Example: Output:
>>>names=[‘vikas’,’kranthi’] [‘vikas’,’kranthi’,’ajay’]
>>>names.append(‘ajay’)
>>>print(names)
2. index(item): It Returns the index of the first element whose value is equal to
item. A value error exception is raised if item is not found in list.
General Format: list.index(item)
Example: Output:
>>>names=[‘vikas’,’kranthi’,’ajay’] kranthi
>>>print(names[1])
3. insert(index, item):It Inserts item into the list at the specified index. When an
item is inserted into a list the list expanded in size to accommodate the new item.
The item was previously at the specified index and all the items after it are shifted
by one position towards the end of the list.
General Format: list.insert(index,item)
Example: Output:
>>>names=[‘vikas’,’kranthi’,’ajay’] [‘vikas’,’aravind’,’kranthi’,’ajay’]
>>>names.insert(1,’aravind’)
>>>print(names)
4. sort():It Sort the items in the list so they appear in ascending order.
General Format: list.sort()
Example:
>>>names=[‘vikas’,’aravind’,’kranthi’,’ajay’]
Page 48
 >>>names.sort() Output:
>>>print(names) [‘ajay’,’aravind’,’kranthi’,’vikas’]
5. remove(item):It Removes the first occurrence of the item from the list. A value
error exception raised if item is not found in the list.
General Format: list.remove(item)
Example: Output:
>>>names=[‘vikas’,’aravind’,’kranthi’,’ajay’] [‘vikas’,’aravind’,’kranthi’]
>>>names.remove(‘ajay’)
>>>print(names)
6. reverse():It Reverses the order of the items in the list.
General Format: list.reverse()
Example: Output:
>>>names=[‘vikas’,’aravind’,’kranthi’,’ajay’] [‘ajay’,’kranthi’,’aravind’,’vikas’]
>>>names.reverse()
>>>print(names)
The del statement
The remove method that removes only a specified item from a list, If that item is in
the list. Some situations might require that we remove an element from a specific
index, regardless of the item that is stored at that index. This can be done with the
del statement
Example( listdel.py):
def main():
list=[1,2,3,4,5,6,7,8]
print("Before deleting the element in the list:")
print(list)
del list[2]
print("after deleting an item from the list")
print(list)
main()
Output:
Before deleting the element in the list:
[1, 2, 3, 4, 5, 6, 7, 8]
after deleting an item from the list
[1, 2, 4, 5, 6, 7, 8]
The min and max functions
Python has two built-in functions named min and max that work with sequences.
1. min(): The min() function accepts a sequence, such as a list, as an argument and
returns the item that has the lowest value in the sequence
Example: Output
>>>num_list=[17,15,9,2,18,20] minimum value:2
Page 49
 >>>print(“minimum value:”,min(num_list))
2. max(): The max() function accepts a sequence, such as a list, as an argument
and returns the item that has the highest value in the sequence
Example: Output
>>>num_list=[17,15,9,2 ,18,20] maxiimum value:20
>>>print(“maximum value:”,max(num_list))
Copying lists
To make a copy of a list, we must copy the list’s elements
Example: Output:
>>>list1=[1,2,3,4] [1,2,3,4]
>>>list2=list1
>>>print(list2)
[Note: In the above program, the list1 and list2 variables reference the same list in
memory]
Suppose we wish to make a copy of the list, so that list1 and list2 reference two
separate but identical lists. One way to do this with a loop that copies each element of
the list
Example: Output:
def main(): after appending elements from list1 to list2:
list1=[1,2,3,4] [1, 2, 3, 4]
list2=[]
for item in list1:
list2.append(item)
print("after appending elements from list1 to list2:")
print(list2)

main()
To accomplish the same task of above program, simply we have to use concatenation
operator
Example: Output:
>>>list1=[1,2,3,4] [1,2,3,4]
>>>list2=[]
>>>list2=list2+list1
>>>print(list2)

Processing lists:
Python allows us to process the data held in list in different ways.
Example : NUM_EMP=3
def main()

Page 50
 hours=[0]*NUM_EMP
for item in range(NUM_EMP):
print("Enter the hour worked by employee:",item+1,':',sep=' ',end=' ')
hours[item]=float(input())
pay_rate=float(input("Enter hourly pay rate:"))
for item in range(NUM_EMP):

gross_pay=hours[item]*pay_rate
print("Gross pay for employee",item+1,':',format(gross_pay),'.2f')
main()
Output:
Enter the hour worked by employee: 1 : 5
Enter hourly pay rate:100
Enter the hour worked by employee: 2 : 6
Enter hourly pay rate:100
Enter the hour worked by employee: 3 : 4
Enter hourly pay rate:100
Gross pay for employee 1 : 500.00
Gross pay for employee 2 : 600.00
Gross pay for employee 3 : 400.00
Totaling the values in a list
Assuming a list contains numeric values, to calculate the total of those values we use
a loop with an accumulator variable. The loop steps through the list, adding the value
of each element to the accumulator.
Example: Output
def main(): total:21
tot=0
list=[1,2,3,4,5,6]
for i in range(len(list)):
tot=tot+list[i]
print(“total:”, tot)
main()
Averaging the value in a list:
The first step in calculating the average of the values in a list is to get the total of the
value. The second step is to divide the total by the number of elements in the list
Example: Output
def main(): average of elements in the list:80
marks=[80,80,80,80,80,80]

Page 51
 total=0
for i in marks:
total=total+i
average=total/len(marks)
print(“average of elements in the list:”,format(average,’.2f’))
main()

Passing a list an argument to a function

We can easily pass a list an argument to a function. This gives us the ability to put
many of the operations that we perform on a list in their own functions.
Example: Output:
def main(): total: 15
list1=[1,2,3,4,5]
get_list(list1)
def get_list(value_list):
total=0
for i in value_list:
total=total+i
print("total:",total)

main()
Returning a list from a function
A function can return a reference to a list. This gives us the ability to write a function
that creates a list and adds elements to it and then returns a reference to the list.so,
other parts of the programs can work with it.
Example: Output:
def main(): Enter an element:10
numbers=get_list() Do u want to add another element (y/n):y
print(numbers) Enter an element:20
def get_list(): Do u want to add another element (y/n):y
list1=[] Enter an element:30
choice='y' Do u want to add another element (y/n):n
while(choice=='y' or choice=='Y'): [10, 20, 30]
item=int(input("Enter an element:"))
list1.append(item)
choice=input("Do u want to add another element (y/n):")
return list1
main()
Working with lists and files
Some tasks may require us to save the contents of a list to a file so the data can be
used at a later time. Like wise some situations may require us to read the data from a
Page 52
file into a list. For example
Suppose we have a file that contains a set of values that appear in random order
and we want to sort the values. One technique for sorting the values in the file would
be to read them into a list. Call the list’s sort method. And then write the values in
the list back to the file.

Saving the contents of a list to a file is a straight forward procedure. In fact, python
file objects have a method named writelines that writes an entire list to a file. A
drawback to the writelines method, However, is that it doesn’t automatically write a
new line(“\n”) at the end of each item.
Example: Output:
def main() file successfully copied from list
cities=[‘thangallapally’,’sircilla’,’hyd’,’warangal’]
list_write=open(‘cities.txt’,’w’)
list_write.writelines(cities)
list_write.close()
print(“file successfully copied from list”)
main()
[Note: After this program executes, the cities.txt file will contain the following line-
‘thangallapally’,’sircilla’,’hyd’,’warangal’]
An alternative approach is to use the for loop to iterate through the list. Writing each
element with a terminating new line character
Example:
def main():
cities=[‘thangallapally’,’sircilla’,’hyd’,’warangal’]
list_write=open(‘cities.txt’,’w’)
for item in cities:
list_write.write(item+’\n’)
list_write.close()
main()
Example: Reading data from cities.txt file:
def main():
list_write=open(‘cities.txt’,’r’)
cities=list_write.readline()
index=0
while(index<len(cities)):
cities[index]=cities[index].rstrip(‘\n’)
index=index+1 Output:
print(cities) [‘thangallapally’,’sircilla’,’hyd’,’warangal’]
main()
Two dimensional lists:

Page 53
A two dimensional list is a list that has other lists as its elements
Example:
>>>names=[[‘v’,’vikas’],[‘s’,’srikanth’],[‘a’,’ajay’]]
>>>Print(names)
Output:
[[‘v’,’venkat’],[‘s’,’srikanth’],[‘a’,’ajay’]]
Two dimensional list representation
Col1 col2 col3

Row0

Row1

Row2

Each row indicates a list, each column indicates element in a list

Example: Output:
import random [[11, 76, 88], [2, 93, 38], [27, 12, 28]]
rows=3
col=3
def main():
rand_num=[[0,0,0],[0,0,0],[0,0,0]]
for i in range(rows):
for j in range(col):
rand_num[i][j]=random.randint(1,100)
print(rand_num)
main()

Tuples
A tuple is a sequence very much like a list the primary difference between tuples and
lists is that tuples are immutable. That means that once a tuple is created, it can’t be
changed. When we create a tuple, we enclose it elements in a set of parenthesis.
Example: Output:
>>>nums=(1,2,3,4,5) (1,2,3,4)
>>>print(nums)
Accessing individual elements from a tuple:
Example: Output:
>>> names=('vikas', 'kranthi', 'shiva') vikas
>>> for item in names: kranthi
print(item) shiva
Accessing individual elements from tuple using index:
Example: Output:
>>> names=('vikas', 'kranthi', 'shiva') vikas
>>> for i in range(len(names)): kranthi
Page 54
 print(names[i]) shiva
[Note: if a tuple has single item we should place , (comma) after the item otherwise
it can be treated as simple datatype]
Converting between lists and tuples:
Example: Output:
>>>nums=(1,2,3,4) (1,2,3,4)
>>>num=list(nums) (1,2,3,4)
>>>print(nums)
>>>print(num)

Strings
String is a set of characters. Python provides a wide verity of tools and programming
techniques that we can used to examine and manipulate strings.
Accessing the individual characters in a string:
python provides two techniques that we can use in python to access the individual
characters in a string.
1. using the for loop
2. indexing
1. Using the for loop: one of the easiest ways to access the individual characters in
a string is to use the for loop. Here is the general format.
for variable in string:
statements
statements
etc.
In the general format, variable is the name of a variable and string is either a string
literal or a variable that references a string. Each time the loop iterates, variable will
reference a copy of a character in string, beginning with the first character.
Example1: Output:
>>> name='Ram' R
>>> for ch in name: a
print(ch) m
Example2: Output:
def main(): enter sentence: animation

count=0 count of 'i' in a string: 2

sentence=input('enter sentence:')
for ch in sentence:
if(ch=='i'):
count=count+1
print("count of 'i' in a string:",count)
main()

Page 55
2. Indexing: another way that we can access individual characters in a string is with
an index. Each character in a string has an index that specifies its position in the
string. Indexing starts at zero, so the index of first character is zero, the index of the
second character is 1 and so on. The index of the last character in a string is less than
the no.of characters in the string.
Example: Output:
>>> name='Ram' R
>>> for i in range(len(name)): a
print(name[i]) m
IndexError exception:
an indexError exception will occur if we try to use an index that is out of range for a
particular string.
Example:
>>> name='Ram'
>>>print(name[4])
The above code raises IndexError exception because of an index i.e out of range for a
particular string 'Ram'.
The length function: len()
The length function (len()) can also be used to get the length of a string.
Example: Output:
>>>name='Ram' 3
>>>print(len(name))
String concatenation:
A common operation that performed on string is concatenation or appending one
string to the end of another string. For concatenation operation we use the operator
called plus(+)
Example1: Output:
>>> name="srikanth"+" kumar" srikanth kumar
>>> print(name)
Example2: Output:
>>>firstname="srikanth" srikanth kumar
>>>name=firstname+" kumar"
>>>print(name)
Example3: Output:
>>>name="srikanth" + “ “ +"kumar" srikanth kumar
>>>print(name)
Strings are immutable:
In python strings are immutable, which means that once they are created, can’t be
changed. Some operations, such as concatenation, give the impression that they
modify strings but in reality they don’t.
Example:(immute.py) Output:
Page 56
def main(): srikanth kumar
name="srikanth"
name=name+" kumar"
print(name)
main()
String slicing:
When we take a slice from a string, we get a span of characters from within the
string. String slices are also called as substrings
To get a slice of a string, we write an expression in the following general format
String[start:end]
In the general format start is the index of the first character in the slice, and end is
the index marking the end of the slice.
Example:
>>> sentence="vikas degree college"
>>> print(sentence[ :5])
vikas
>>> print(sentence[6:13])
degree
>>> print(sentence[13: ])
college
>>>
Testing, searching and manipulating strings:
Testing strings with in and not in:
In python, we can use the in operator to determine whether one string is contained in
another string.
General format: string1 in string2
String1 and string2 can be either string literals or variables referencing strings. The
expression returns true if string1 is found in string2
Example:( testing.py) Output:
sentence="India is my country" string is found
substring="country"
if substring in sentence:
print("string is found")
else:
print("string is not found")
String methods
Strings in python have numerous methods which are used for performing the
following types of operations.
 Testing the values of strings
 Performing various modifications
Page 57
  Searching for substring and replacing sequences of characters.
Stringvar.method(arguments)
In general format, stringvar is a variable that references a string, method is the name
of the method that being called, arguments is one or more arguments being passed
to the method.
String testing methods
1. isalnum(): It returns true if the string contains only alphabetic letters or digits
and is at least one character in length. Returns false otherwise.
General format: stringvar.isalnum()
Example: Output:
>>> input_string="vikas" string contains alphanumeric constants
>>> if(input_string.isalnum()):
print("string contains alphanumeric constants")
2. isalpha(): It return true if the string contains only alphabetic letters, and is at
least one character in length. Returns false otherwise.
General format: stringvar.isalpha()
Example: Output:
>>> input_string="vikas" string contains alphanumeric constants
>>> if(input_string.isalpha()):
print("string contains alphabetic letters")
3. isdigit(): It return true if the string contains only numeric digits and is at least
one character in length. Returns false otherwise.
General format: stringvar.isdigit()
Example: Output:
>>> input_string="7091" string contains digits
>>> if(input_string.isdigit()):
print("string contains digits")
4. islower(): It return true if all of the alphabetic letters in the string are lowercase,
and the string contains at least one alphabetic letter. Returns false otherwise.
General format: stringvar.islower()
Example: Output:
>>> input_string="vikas" string contains lower case letters
>>> if(input_string.islower()):
print("string contains lower case letters")
5. isupper(): It return true if all of the alphabetic letters in the string are uppercase,
and the string contains at least one alphabetic letter. Returns false otherwise.
General format: stringvar.isupper()
Example: Output:
>>> input_string="vikas" string contains upper case letters
>>> if(input_string.isupper()):

Page 58
6. isspace(): It return true if the string contains only write space characters, and is
at least one character in length. Returns false otherwise (white space characters
are spaces, new lines \n, tabs\t).
General format: stringvar.isspace()
Example: Output:
>>> input_string="\n" string contains white space characters
>>> if(input_string.isspace()):
print("string contains white space characters")
String modification methods:
Although strings are immutable, meaning they can be modified, they do have a
number of methods that return modified versions of themselves.
1. lower(): It returns a copy of the string with all alphabetic letters converted to
lowercase.
General format: stringvar.lower()
Example: Output:
>>> name="VIKAS" VIKAS in lower case: vikas
>>> print(name,'in lower case:',name.lower())
2. upper(): It returns a copy of the string with all alphabetic letters converted to
uppercase.
General format: stringvar.upper()
Example: Output:
>>> name="vikas" vikas in upper case: VIKAS
>>> print(name,'in upper case:',name.lower())
3. lstrip():It returns a copy of the string with all leading white space characters are
removed. leading white space characters are spaces, New lines and tabs that
appears at the beginning of the string.
General format: stringvar.upper()
Example: Output:
>>> name="\n vikas" vikas
>>> print(name.lstrip())
4. lstrip(char): The char argument is a string containing a character. It returns a
copy of the string with all instances of char that appear at the beginning of the
string removed.
General format: stringvar.lstrip(char)
Example:
>>> name="vikas" Output:
>>> print(name.lstrip(‘v’)) ikas
5. rstrip():It returns a copy of the string with all trailing white space characters are
removed. Trailing white space characters are spaces,new lines(\n) and tabs(\t)
that appears at the end of the string.
General format: stringvar.rstrip()
Page 59
 Example: Output:
>>> name="vikas\n " vikas
>>> print(name.rstrip())
6. rstrip(char): The char argument is a string containing a character. It returns a
copy of the string with all instances of char that appear at the ending of the string
removed.
General format: stringvar.lstrip(char)
Example:
>>> name="vikas" Output:
>>> print(name.rstrip(‘s’)) vika
Searching and replacing:
Programs commonly need to search for substrings or strings that appear within other
strings. To perform searching and replacing operations on strings, python provides
following methods.
1. endswith(substring): The substring argument is a string. The method returns
true if the string ends with substring.
General format: stringvar.endswith(substring)
Example:
>>> name="string.py" Output
>>> if(name.endswith('.py')): python file
print("python file")
2. find(substring): The substring argument is a string. The method returns the
lowest index in the string where substring is found. If substring is not found, the
method returns -1.
General format: stringvar.find(substring)
Example: Output
>>> name="vikas degree college" substring found at:6
>>> position=name.find("degree")
>>> if(position!=-1):
print("substring found at:",position)
3. replace(old,new): The old and new arguments are both strings. The method
returns a copy of the string with all instances of old replaced by new.
General format: stringvar.replace(old,new)
Example: Output:
>>> name="vikas degree college" vikas PG college
>>> print(name.replace('degree','PG'))
4. startwith(substring): The substring argument is a string. The method returns
true if the string starts with substring.
General format: stringvar.startwith(substring)
Example:
>>> name="string.py" Output
Page 60
 >>> if(name.endswith('string')): string type of file
print("string type of file")
String Example program
Creating login.py module: (login.py):
def login_generate(firstname,lastname,idnumber):
set1=firstname[0:3]
set2=lastname[0:3]
set3=idnumber[-3: ]
login=set1+set2+set3
return login
def valid_password(password):
correct_length=False
has_upper=False
has_lower=False
has_digit=False
valid=False
if(len(password)>=7):
correct_length=True
for ch in password:
if(ch.isupper()):
has_upper=True
if (ch.islower());
has_lower=True
if(ch.isdigit()):
has_digit=True
if(correct_length and has_upper and has_lower and has_digit):
valid=True
return valid

using login.py module in our program : (mainlogin.py)

import login Output:
def main(): Enter password: vikas007
password=input("Enter password:") you entered valid password

while not login.valid_password(password):

password=input("plz reenter valid password")
print("you entered valid password")

main()

Page 61
Repetition operator

We have already learned how to duplicate a list with repetition operator(*). The
repetition operator works with strings as well.
General format: string_to_copy *n
The repetition operator creates a string that contains ‘n’ repeated copies of string_to
_copy
Example1: Output:
>>> mystring='v'*5 vvvvv
>>> print(mystring)
Example2: Output:
>>> print("hello" *5) hellohellohellohellohello
Splitting a string
Strings in python have a method called split that returns a list containing the words in
the string. By default the split method uses spaces as separators. We can specify a
different separator by passing it as an argument to the split method.
Example1: Output:
def main(): ['one', 'two', 'three', 'four']
exstring="one two three four"
split_string=exstring.split()
print(split_string)
main()
Example2: Output:
def main(): date: 25
date_string=”25-10-2018” month:10
date_list=date_string.split('-') year: 2018
print("date:",date_list[0])
print("month:",date_list[1])
print("year:",date_list[2])
main()

Dictionary and sets

Dictionary
 The dictionary is an object which stores a collection of data. Each element that is
stored in a dictionary has two parts: a key and a value.
 Dictionary elements are commonly referred to as key value pairs.
 When we want to retrieve a specific value from a dictionary. We can use the key
that is associated with that value.
Creating a dictionary:
Page 62
We can create a dictionary by enclosing the elements inside a set of curly braces({}).
An element consist of a key, followed by a colon(:), followed by a value. The elements
are separated by commas(,)
Example:
phonebook={'vikas':'9848657683','vishnu':'9987876745','vishal':'9912345578'}
The above statement creates a dictionary and assigns it to the phonebook variable.
The dictionary contains the following three elements
 The first element is 'vikas':'9848657683'. In this element the key is vishnu and the
value is 9848657683.
 The second element is 'vishnu':'9987876745'. In this element the key is vishnu
and the value is 9987876745.
 The third element is 'vishal':'9912345578'. In this element the key is vishal and
the value is 9912345578.
Rules for creating a Dictionary:
 The value in a dictionary can be objects of any type, but the keys must be
immutable objects.
 Keys can be strings, integers, floating point values or tuples.
 Keys can’t be lists or any other type of immutable objects.
Retrieving a value from a dictionary
The elements in a dictionary are not stored in any particular order. So, the order in
which the elements are displayed is different than the order in which they were
created. As a result, we can’t use a numeric index to retrieve a value by its position
from a dictionary instead. We use a key to retrieve a value.
Example: To retrieve all elements from phonebook
>>> phonebook={'vikas':'9848657683','vishnu':'9987876745','vishal':'9912345578'}
>>> print(phonebook)
Output:
{'vikas': '9848657683', 'vishal': '9912345578', 'vishnu': '9987876745'}
To retrieve a value from a dictionary, we simply write an expression in the following
General format:
dictionary_name[key]
In the general format, dictionary_name is the variable that references the dictionary
and key is a key. If the key exists in the dictionary, the expression returns the value
that is associated with the key. If the key doesn’t exist, keyError exception is raised.

Page 63
Example:
>>> phonebook={'vikas':'9848657683','vishnu':'9987876745','vishal':'9912345578'}
>>> print('vikas') Output: 9848657683
Adding elements to an existing dictionary
Dictionaries are mutable objects. We can add new key-value pairs to a dictionary with
an assignment statement in the following general format:
Dictionary-name[key]=value
In the general format dictionary name is the variable that references the dictionary
and key is a key. If key already exists in the dictionary, it associated value will be
changed to value. If the key doesn’t exist, it will be added to the dictionary along with
value as its associated value
Example1:
>>> phonebook={'vikas':'9848657683','vishal':'9987876745','vishnu':'9912345578'}
>>> phonebook['vishnu']='9556677880'
>>> print(phonebook)
Output: {'vikas': '9848657683', 'vishnu': '9556677880', 'vishal': '9987876745'}
Deleting elements:
We can delete an existing key-value pair from a dictionary with the del statement
General format:
del dictionary-name[key]
In the general format, dictionary-name is the variable that references the dictionary
and key is a key. After the statement executes, the key and its associated value will
be deleted from the dictionary. If the key doesn’t exist, a KeyError exception is raised
Example:
>>> phonebook={'vikas':'9848657683','vishal':'9987876745','vishnu':'9912345578'}
>>>del phonebook['vishal'] Output:
>>>print(phonebook) {'vikas':'9848657683','vishnu':'9912345578'}
To prevent a KeyError exception from being raised, we should use the in operator to
determine whether a key exist before we try to delete and its associated value.
Example:
>>> phonebook={'vikas':'9848657683','vishal':'9987876745','vishnu':'9912345578'}

>>> if('vishal' in phonebook): Output:

del phonebook['vishal'] {'vikas':'9848657683','vishnu':'9912345578'}
print(phonebook)
Using the in and not in operator to test for a value in a dictionary:
A KeyError exception is raised if we try to retrieve a value from a dictionary using a
non-existent key. To prevent such an exception, we can use the in operator or not-in
operator

Page 64
In operator: This is used to determine whether a key exists before we try to use it
to retrieve a value
Example:
>>> phonebook={'vikas':'9848657683','vishnu':'9987876745','vishal':'9912345578'}
>>> if('vishal' in phonebook): Output:
print(phonebook['vishal']) 9912345578
Not-in operator: this is used to determine whether a key doesn’t exist in a
dictionary.
Example:
>>> phonebook={'vikas':'9848657683','vishnu':'9987876745','vishal':'9912345578'}
>>> if('virat' not in phonebook):
print(“key is not found”)
Getting the no.of elements in the dictionary:
We can use the built-in len functions to get the no.of elements in a dictionary.
Example:
>>> phonebook={'vikas':'9848657683','vishal':'9987876745','vishnu':'9912345578'}
>>> num_elements=len(phonebook) Output:
>>> print(num_elements) 3
Mixing data types in a dictionary:
The keys in a dictionary must be immutable objects, but their associated values can
be any type of object. That can be lists, strings, integers, floating point values.
Example1:
>>> names={'vikas':[90.95,89],'vishal':[89,78,76],'vishnu':[67,87,90]}
>>> print(names)
Output: {'vikas': [90.95, 89], 'vishal': [89, 78, 76], 'vishnu': [67, 87, 90]}
Example2:
The values that are stored in a single dictionary can be of different types. For
example,One element’s value might be a string, anther element’s value might be an
integer. The keys can be of different types too, as long as they are immutable.
>>> mixed_up={'one':1,2:'two',(1,2):[1,2]} Output:
>>> print(mixed_up) {(1, 2): [1, 2], 'one': 1, 2: 'two'}

Creating an empty dictionary:

Sometimes we need to create an empty dictionary and then add an empty list as the
program executes. We can use an empty set of curly braces to create an empty
dictionary
Example:
>>> names={ } Output:
>>> names['vikas']=1 {'vikas': 1, 'vishal': 2, 'vishnu': 3}
>>> names['vishal']=2

Page 65
>>> names['vishnu']=3
>>> print(names)
Using the for loop to iterate over a dictionary:
We can use the for loop to iterate over all the keys in a dictionary.
General format:
for var in dictionary:
statement
statement
etc.
In the general format, var is the name of a variable and dictionary is the name of the
dictionary. This loop iterates once for each element in the dictionary. Each time the
loop iterates var is assigned a key.
Example1: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} vikas
>>> for key in age: vishal
print(key) vishnu
Example2: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} 20
>>> for key in age: 21
print(age[key]) 23
Dictionary methods:
Dictionary objects have several methods that are described below
1. clear():The clear method deletes all the elements in a dictionary leaving the
dictionary empty.
General format: dictionary.clear()
Example: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} {}
>>> age.clear()
>>> print(age)
2. get():The get method is used to get the value associated with a specified key. If
the key is not found, the method doesn’t raise an exception. Instead, returns a
default value.
General format: dictionary.get(key,default)
Example: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} 21
>>> value=age.get('vishal','key not found')
>>> print(value)
3. items():The items method returns all of a dictionary’s keys and their associated
values. They are returned as a special type of sequence known as a dictionary

Page 66
 view. Each element in the dictionary view is a tuple. Each tuple contains a key and
its associated value.
General format: dictionary.items()
Example1:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23}
>>> age_info=age.items() Output:
>>> print(age_info) dict_items([('vikas', 20), ('vishal', 21), ('vishnu', 23)])
We can use the for loop to iterate over the tuples in the sequence.
Example2: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} vikas 20
>>> for key,value in age.items(): vishal 21
print(key,value) vishnu 23
4. keys():The keys() method returns all of a dictionary’s keys as a dictionary
view(tuple), which is a type of sequence. Each element in the dictionary view is a
key from the dictionary.
General format: dictionary.keys()
Example:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} Output:
>>> print(age.keys()) dict_keys(['vikas', 'vishal', 'vishnu'])
5. pop():The pop method returns the value associated with a specified key and
removes that key- value pair from the dictionary. If the key is not found, the
method returns a default value.
General format: dictionary.pop(key,default)
Example1: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} 21
>>> print(age.pop('vishal','key not found'))
Example2: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} key not found
>>> print(age.pop('vikky','key not found'))
6. popitem():The popitem method returns a randomly selected key-value pair, and
it removes that key-value pair from the dictionary. The key-value pair returned as
a tuple.
General format: dictionary.popitem()
We can use an assignment statement to assign the returned key and value to
individual variables.
General format:
k,v= dictionary.popitem()
Example:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23}
>>> key,value=age.popitem() Output:
>>> print(key,value) vikas 20

Page 67
7. values():The values method returns all a dictionary’s values (without their keys)
as a dictionary view, which is a type of sequence. Each element in the dictionary
view is a value from the dictionary.
General format: dictionary.values()
Example1: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} dict_values([20, 21, 23])
>>> print(age.values())
We can use for loop to iterate over the sequence that is returned from the values
method.
Example2: Output:
>>> age={'vikas': 20, 'vishal': 21, 'vishnu':23} 20
>>> for values in age.values(): 21
print(values) 23
Dictionary Example program : Program: (Birthdays.py)
Look_up=1 Output:
add=2 iend name and their birthdays:
change=3
delete=4 1.look_up
Quit=5 2.add
def main(): 3.change
birthdays={ } 4.delete
choice=get_menulist() 5.quit
if(choice==1): Enter valid choice:2
look_up(birthdays) enter ur frnd name:vikas
elif(choice==2): Enter ur frnd birthday:10-11-1998
add(birthdays) {'vikas': '10-11-1998'}
elif(choice==3):
change(birthdays)
elif(choice==4):
delete(birthdays)
else:
print("end of a program")

def add(birthdays):
name=input("enter ur frnd name:")
bday=input("Enter ur frnd birthday:")
if name not in birthdays:
birthdays[name]=bday
else:

Page 68
 print("name already exist")
print(birthdays)

def change(birthdays):
name=input("enter ur frnd name:")
bday=input("Enter birthday")
if name in birthdays:
birthday[name]=bday
else:
print("name not found")
print(birthdays)

def get_menulist():
choice=0
print("Friend name and their birthdays:")
print(" ")
print("1.look_up")
print("2.add")
print("3.change")
print("4.delete")
print("5.quit")
while(choice<Look_up or choice>Quit):
choice=int(input("Enter valid choice:"))
return choice
def look_up(birthdays):
name=input("enter name of ur frnd:")
bday=birthdays.get(name,'not found')
print(bday)
def delete(birthdays):
name=input("enter ur frnd name:")
if name in birthdays:
del birthdays[name]
else:
print("name not found")
print(birthdays)
main()

Page 69
B.Sc (Computer Science) V Semester Programming with Python

Sets
Set:
 A set is an object that stores a collection of data in the same way as mathematical
sets.
 All the elements in a set must be unique. No two elements can have the same
value.
 Sets are unordered, which means that the elements in a set are not stored in any
particular order.
 The elements that are stored in a set can be of different data type.
Creating a set:
To create a set, we have to call the built-in function called set()
Example:
myset=set()
After this statement executes, the myset variable will reference an empty set. We can
also pass one argument to the set function. The argument that we pass must be an
object that contains iterable elements, such as a list, a tuple or a string. The
individual elements of the object that we pass as an argument become elements of
the set.
Example1: Output:
>>> myset=set(['a','b','c','d']) {'d', 'c', 'a', 'b'}
>>> print(myset)
Example2: Output:
>>> myset=set("vikas") {'s', 'a', 'k', 'i', 'v'}
>>> print(myset)
Example3: Output:
>>> myset=set((1,2,3,4)) {1, 2, 3, 4}
>>> print(myset)
Set can’t contain duplicate elements. If we pass an argument containing duplicate
elements to the set function only one of the duplicated elements will appear in the set
Example4:
Output:
>>> myname=set("college") {'o', 'l', 'c', 'g', 'e'}
>>> print(myname)
Adding elements to a set:
Sets are mutable objects. So, we can add items to them and remove items from
them. We use the add method to add an element to a set
Example: Output:
>>> myset=set() {1, 2, 3}
>>> myset.add(1)
>>> myset.add(2)
>>> myset.add(3)
Page 70
B.Sc (Computer Science) V Semester Programming with Python
>>> print(myset)
We can add group of elements to a set all at one time, with the update(). When we
call the update method as an argument, we pass an objects that contains iterable
elements, such as a list, string or another set.
Example1: Output:
>>> myset=set([1,2,3]) {1, 2, 3, 4, 5, 6}
>>> myset.update([4,5,6])
>>> print(myset)
Example2: Output:
>>> myset=set([1,2,3]) {1, 2, 3, 'a', 'i', 's', 'k', 'v'}
>>> myset.update("vikas")
>>> print(myset)
Removing elements from a set:
we can remove an item from a set with either the remove method or the discard
method. We pass the item that we want to remove as an argument to either method,
and that item is removed from the set. The only difference between the two methods
is how they behave when the specified item is not found in the set. The remove
method raises a KeyError exception, but the discard method doesn’t raise an
exception.
Example1: Output:
>>> myset=set([1,2,3]) {1, 3}
>>> myset.remove(2)
>>> print(myset)
we can clear the elements of a set by calling the clear method.
Example2: Output:
>>> myset=set([1,2,3]) set()
>>> myset.clear()
>>> print(myset)
Getting the number of elements in a set:
As with lists, tuples and dictionaries, we can use the len function to get the number of
elements in a set.
Example: Output:
>>>myset=set([1,2,3,4]) 4
>>>print(len(myset))

Using the for loop to iterate a set:

we can use the for loop to iterate all the elements in a set
General format:
for var in set:
statement(s)
etc
Page 71
B.Sc (Computer Science) V Semester Programming with Python
In the general format ‘var’ is the name of a variable and set is the name of a set .This
loop iterates once for each element in the set and each time the loop iterates ‘var’ is
assigned an element.
Example: Output:
>>> myset=set(['vikas','vishal','vishnu']) vikas
>>> for name in myset: vishal
print(name) vishnu
Using the ‘in’ and ‘not in ‘ operators to test for a value in a set
we can use in operator to determine whether a value exists in a set
Example:
>>> myset=set(['vikas','vishal','vishnu']) Output:
>>> if('vishal' in myset): Element found
print("Element found")
we can also use not in operator to determine if a value doesn’t exist in a set.
>>> myset=set(['vikas','vishal','vishnu']) Output:
>>> if('vikky' not in myset): Element not found
print("Element not found")
Finding the union of sets:
The union of two sets is a set that contains all the elements of both sets. In python,
we can call the union method to get the union of two sets.
General format:
set1.union(set2)
In the general format, set1 and set2 are sets. This method returns a set that contains
the elements of both set1 and set2.
Example: Output:
>>> set1=set([1,2,3]) {1, 2, 3, 4}
>>> set2=set([2,3,4])
>>> set3=set1.union(set2)
>>> print(set3)
We can also use the ‘|’ operator to find the union of two sets.
General format:
set1|(set2)
In the general format set1 & set2 are sets. The expression returns a set that contains
the elements of both set1 and set2.
Example: Output:
>>> set1=set([1,2,3]) {1, 2, 3, 4}
>>> set2=set([2,3,4])
>>> set3=set1|set2
>>> print(set3)

Page 72
B.Sc (Computer Science) V Semester Programming with Python

Finding the intersection of sets:

The intersection of two sets is a set that contains only the elements that are found in
both sets. In python, we can call the intersection method to get the intersection of
two sets.
General format:
set1.intersction(set2)
In the general format set1 and set2 are sets the method returns a set that contains
the elements that are found in both set1 and set2
Example: Output:
>>> set1=set([1,2,3]) {2, 3}
>>> set2=set([2,3,4])
>>> set3=set1.intersection(set2)
>>> print(set3)
We can also use & operator to find the intersection of two sets.
General format:
set1 & set2
In the general format, set1 and set2 are sets.The expression returns a set that
contains the elements that are found in both set1 and set2.
Example: Output:
>>> set1=set([1,2,3]) {2, 3}
>>> set2=set([2,3,4])
>>> set3=set1 & set2)
>>> print(set3)
Finding the difference of sets:
The difference of set1 and set2 are the elements that appear in set1 but don’t appear
in set2. In python, we can call the difference method to get the difference of two sets.
General format:
set1.difference(set2)
In the general format, set1 and set2 are sets. The method returns a set that contains
the elements that are found in set1 but not in set2
Example: Output:
>>> set1=set([1,2,3]) {1}
>>> set2=set([2,3,4])
>>> set3=set1.difference(set2)
>>> print(set3)
We can also uses the ‘-‘ operator to find the difference of two sets.
General format:
set1-set2
In the general format set1 and set2 are sets. The method returns a set that contains
the elements that are found in set1 but not in set2
Page 73
B.Sc (Computer Science) V Semester Programming with Python

Example: Output:
>>> set1=set([1,2,3]) {1}
>>> set2=set([2,3,4])
>>> set3=set1- set2
>>> print(set3)
Finding the symmetric difference of sets:
The symmetric of two sets is a set that contains the elements that are not shared by
the sets. In other words, it is the elements that are in one set but not in both. In
python, we can call the symmetric_difference method to get the symmetric difference
of two sets.
General format:
set1.symmetric_difference(set2)
In the general format set1 and set2 are sets. The method returns a set that contains
the elements that are found in either set1 or set2 but not both sets.
Example: Output:
>>> set1=set([1,2,3]) {1, 4}
>>> set2=set([2,3,4])
>>> set3=set1.symmetric_difference(set2)
>>> print(set3)
We can also use the operator ‘^’ to find the difference of two sets
General format:
set1^set2
In the general format, set1 and set2 are sets. The expression returns a set that
contains the elements that are found in either set1 or set2 but not in both sets.
Example: Output:
>>> set1=set([1,2,3]) {1, 4}
>>> set2=set([2,3,4])
>>> set3=set1 ^ set2
>>> print(set3)
Finding subsets and super sets
Subsets: In python, we can call the issubset method to determine whether one set is
a subset of anther
General format:
set2.issubset(set1)
In the general format set1 and set2 are sets. The method returns true if set2 is a
subset of set1, otherwise it returns false.
Example: Output:
>>> set1=set([1,2,3,4]) True
>>> set2=set([2,3])
>>> print(set2.issubset(set1))
Page 74
B.Sc (Computer Science) V Semester Programming with Python

We can also use ‘<=’ to determine whether one set is a subset of anther.
General format:
set2<=set1
In the general format set1 and set2 are sets. The expression returns true if set2 is
subset of set1. Otherwise, returns fasle.
Example: Output:
>>> set1=set([1,2,3,4]) True
>>> set2=set([2,3])
>>> print(set2<=set1)
Supersets: In python we can call the issuperset method to determine whether one
set is a superset of another.
General format:
set1.issuperset(set2)
In the general format, set1 and set2 are sets, the method returns true if set1 is
superset of set2. Otherwise it returns false.
Example: Output:
>>> set1=set([1,2,3,4]) True
>>> set2=set([2,3])
>>> print(set1.issuperset(set2))
We can also use ‘>=’ operator to determine whether one set is a super set of another.
General format: set1>=set
In the general format set1 and set2 are sets. The expression returns true if set1 is
superset of set2. Otherwise, returns fasle.
Example: Output:
>>> set1=set([1,2,3,4]) True
>>> set2=set([2,3])
>>> print(set1>=set2)
Serializing objects
Serializing objects:
Serializing an object is the process of converting the object to a stream of bytes that
can be saved to a file for later retrieval. In python, the process of serializing an object
is referred to as pickling. The python standard library provides a module named
pickle, which has various functions for serializing or pickling objects.
Once we import the pickle module. We perform the following steps to pickle an object
 We open a file for binary writing.
 We call the pickle module’s dump method to pickle the object and write it to the
specified file.
 After we have pickled all the objects that we want to save to the file, we close the
file.

Page 75
B.Sc (Computer Science) V Semester Programming with Python

To open a file for binary writing we use ‘wb’ as the mode when we call the open
function.
Example for opening a mydata.txt in binary writing mode:
output_file=open(‘vikas.txt’,’wb’)
Once we have opened a file for binary writing. We call the pickle’s module’s dump
function.
General format:
pickle.dump(object, file)
In the general format, object is a variable that references the object. We want to
pickle, and file is a variable that references a file object. After the function executes
the object referred by object will be serialized and return to the file.
Example:( pickle.py)
import pickle
phonebook={'vikas':'9848657683','vishal':'9987876745','vishnu':'9912345578'}
output_file=open('vikas.txt','wb')
pickle.dump(phonebook,output_file) Output:
output_file.close() contents are copied
print("contents are copied")
To open a file for binary reading, we use ‘rb’ as the mode when we call the open
function.
Example for opening a mydata.txt in reading binary mode:
input_file=open(‘vikas.txt’,’rb’)
Once we have opened a file for binary reading. We call the pickle module’s load
function
General format: pickle.load(file)
in the general format, object is a variable, and file is a variable that references a file
object. After the function executes, the object variable will references an object that
was retrieved from the file and unpickled.
Example:( unpickle.py)
import pickle
input_file=open('vikas.txt','rb')
pb=pickle.load(input_file)
input_file.close()
print(pb)
Output:
{'vikas': '9848657683', 'vishnu': '9912345578', 'vishal': '9987876745'}
Recursion
Recursion: Recursion is a way of programming or coding a problem, in which a
function calls itself one or more times in its body. Usually, it is returning the return
value of this function call. If a function definition fulfills the condition of recursion. We
call this function a recursive function.

Page 76
B.Sc (Computer Science) V Semester Programming with Python

Example: Output:
def main(): welcome to world
message(5) welcome to world

def message(times): welcome to world

if(times>0): welcome to world
message(times-1) welcome to world
print("welcome to world")
main()
In the above program, the message function in this program contains an if statement
that controls the repetition as long as the times parameter is greater than zero. The
message “welcome to world” is displayed and then the function calls itself again but
with a smaller argument.
Problem solving with recursion:
A problem can be solved with recursion if it can be broken down into smaller
problems that are identical in structure to the overall problem. If a programmer
designs a recursive algorithm. Generally that recursive function works as follows:
 If the problem can be solved now without recursion, then the function solves it and
returns.
 If the problem can’t be solved now, then the function reduces it to a smaller but
similar problem and calls itself to solve the smaller problem.
In order to apply this approach, first we identify at least one case in which the
problem can be solved without recursion. This is known as the base case. Second, we
determine a way to solve the problem in all other circumstances using recursion. This
is called the recursive case. In the recursive case, we must always reduce the
problem to smaller version of the original problem. By reducing the problem with each
recursive call, the base case will eventually be reached and the recursion will stop.
Example: (factorial.py)
def main(): Output:
num=int(input("enter a number:")) enter a number:5
fact=factorial(num) factorial of a num:120
print("factorial of a num:",fact)

def factorial(num):
if(num==0):
return 1
else:
return num*factorial(num-1)

main()

Page 77
 Direct and indirect recursion:
If recursive function or function that directly call themselves, it is called as direct
recursion. There is also the possibility of creating indirect recursion in a program. This
occurs when function A calls function B, which intern calls function A. there can even
be several functions involved in the recursion. For example, function A could call
function B which could call function C, which calls function A.
Examples of recursive algorithms:
1. Algorithm for sum of list elements using recursion
def main():
numbers=[1,2,3,4,5,6,7,8,9]
my_sum=range_sum(numbers,2,5)
print("the sum of items 2 through 5 is: ",my_sum)

def range_sum(num_list,start,end):
if(start>end):
return 0
else:
return num_list[start]+range_sum(num_list, start+1,end)

main() [Output: the sum of items 2 through 5 is:18]

In the above program, range_sum that takes the following arguments. A list that
contains the range of elements to be summed. An integer specifying the index of
the starting item in the range and an integer specifying the index of the ending
item in the range.
i. The function base case is executed when the start parameter is greater than the
end parameter. If this is true, the function returns the value ‘0’. Otherwise, the
function executes the recursive case
2. The Fibonacci series: Algorithm
i. Some mathematical problems are designed to be solved recursively. Only one
well known example is the calculation of Fibonacci numbers. They are in
following sequence
0 1 1 2 3 5 8 13
ii. Each number in the series is the sum of two previous numbers.
iii. The Fibonacci series can be defined as follows:
1. If n=0 then fib(n)=0
2. If n=1 then fib(n)=1
3. If n>1 then fib(n)=fib(n-1)+fib(n-2)
Fibonacci algorithm:
def main():
print("first 10 Fibonacci numbers:")

Page 78
 for numbers in range(0,10):
print(fib(numbers))

def fib(n):
if(n==0):
return 0
elif(n==1):
return 1
else:
return fib(n-1)+fib(n-2)
main()
Output: 0 1 1 2 3 5 8 13
In the above program “fib” function has two base cases: when n=0 and when n=1.
Either case, the function returns a value without making a recursive call. When two
base conditions are false, recursive function will be executed.
3. Algorithm for finding the greatest common divisor:
One of the example of recursion is the calculation of the greatest common
divisor(GCD) of two numbers.
The GCD of two positive integers x and y is determined as follows:
i. If ‘x’ can be evenly divided by ‘y’, then GCD of (x,y)=y
ii. Otherwise, GCD(x,y)= gcd(y, remainder of x/y)
GCD algorithm
def main():
num1=int(input("enter an integer"))
num2=int(input("enter an integer"))
print("the greatest divisor of two numbers is:",gcd(num1,num2))
def gcd(x,y):
if(x%y==0):
return y
else:
return gcd(y,x%y)
main()
Output:
enter an integer18
enter an integer47
the greatest divisor of two numbers is: 2

Page 79
 The Towers of Hanoi
The Towers of Hanoi is a mathematical game that is often used in computer science
to illustrate the power of recursion. The game uses three pegs and a set of discs with
holes through their centers. The discs are stacked on one of the pegs as shown in the
figure.

Notice that the discs are stacked on the leftmost peg, in order of size with the largest
disc at the bottom. Here, our job is to move the disks from the first peg to the third
peg. The third peg can be used as temporary holder.
We should follow the following rules to move the disks from first peg to third peg.
1. Only one disk may me moved at a time.
2. A disk can not be placed on the top of a smaller disk.
Towers of Hanoi algorithm:
def main():
num_discs = 3
from_peg = 1
to_peg = 3
temp_peg =2
move_discs(num_discs, from_peg, to_peg, temp_peg)
print('All the pegs are moved!')

def move_discs(num, from_peg, to_peg, temp_peg):

if num > 0:
move_discs(num - 1, from_peg, temp_peg, to_peg)
print('Move a disc from peg', from_peg, 'to peg', to_peg)
move_discs(num - 1, temp_peg, to_peg, from_peg)
main()
Output:
Move a disc from peg 1 to peg 3
Move a disc from peg 1 to peg 2
Move a disc from peg 3 to peg 2
Move a disc from peg 1 to peg 3
Move a disc from peg 2 to peg 1
Move a disc from peg 2 to peg 3
Move a disc from peg 1 to peg 3
All the pegs are moved!

Page 80
 Recursion vs looping
There are several reasons not to use recursion. Recursive function calls are
certainly less efficient than loops. Each time a function is called, the system incurs
(get) overhead that is not necessary with a loop. Also, in many cases a solution using
a loop is more evident than recursive solution. In fact, the majority of repetitive
programming tasks are best done with loops.
Some problems however are more easily solved with recursion than with a loop. For
example, the mathematical definition of the GCD formula is well suited to a recursive
approach. If a recursive solution is evident for a particular problem and the recursive
algorithm doesn’t slow system performance, then recursion would be good to design
choice. If a problem is more easily solved with a loop, however we should take that
approach.

Page 81