CHAPTER 8:

DATA HANDLING

By:
Kshama Raut
PGT CS
K V Ambarnath
INTRODUCTION

 Data handling is used to handle the data which we use

in the programming
 It contails:
▪ Data Types
▪ Mutable and Immutable
▪ Operators
▪ Expressions
DATA TYPES

 Each and every value we enter in a variable have a data

type.
 It is provided by python interpreter as according data.
 Data Type specifies which type of value a variable can
store.
 type() function isused to determine a variable's type
in Python.
DATA TYPES

Data Types In Python

1. Number
2. String
3. Boolean
4. List
5. Tuple
6. Set
7. Dictionary
DATA TYPES

1. Number In Python:
 It is used to store numeric values

 Python has three numeric types:

1. Integers
2. Floating point numbers
3. Complex numbers.
DATA TYPES

a. Integers

Integers or int are positive or negative numbers with

no decimal point. Integers in Python 3 are of
unlimited size.
e.g.
Output :-
a= 100
100
b= -100 -100
c=1*20 200
print(a)
print(b)
print(c)
DATA TYPES

Type Conversion of Integer

int() function converts any data type to integer. e.g.

a = "101" # string
b=int(a) # converts string data type to integer.
c=int(122.4) # converts float data type to integer.
print(b)
print(c)
Run Code Output :-
101
122
DATA TYPES

b. Floating point numbers

It is a positive or negative real numbers with a decimal

point.
e.g. Output :-
101.2
a = 101.2 -101.4
b = -101.4 111.23
c = 111.23
print(a)
print(b)
print(c)
DATA TYPES

Type Conversion of Floating point numbers

float() function converts any data type to floating point number.
e.g.
a='301.4' #string
b=float(a) #converts string data type to floating point number.
c=float(121) #converts integer data type to floating point number.
print(b)
print(c)

Output :- 301.4
121.0
DATA TYPES

c. Complex numbers
Complex numbers are combination of a real and imaginary part.
Complex numbers are in the form of X+Yj , where X is a real part and Y
is imaginary part.
e.g.
a = complex(5) # convert 5 to a real part val and zero imaginary part
print(a)
b=complex(101,23) #convert 101 with real part and 23 as imaginary part
print(b)

Output :-
(5+0j)
(101+23j)
DATA TYPES
2. String In Python:
A string is a sequence of characters. In python we can create string using single ('
') or double quotes (" ").Both are same in python.
e.g.
str='computer science'
print('str-', str) # print string
print('str[0]-', str[0]) # print first char 'h'
print('str[1:3]-‘,str[1:3]) # print string from postion 1 to 3 'ell'
print('str[3:]-',str[3:]) # print string staring from 3rd char 'llo
world'
print('str *2-',str *2 ) # print string two times
print("str +'yes'-",str +'yes') # concatenated string
Output
str- computer science str[0]- c
str[1:3]- om
str[3:]- puter science
str *2- computer sciencecomputer science
str +'yes'- computer scienceyes
DATA TYPES

Iterating through string

e.g.
str='comp sc'
for i in str:
print(i)

Output
c
o
m
p

s
c
DATA TYPES

3. Boolean In Python:

It is used to store two possible values either true or false

e.g.
str="comp sc"
boo=str.isupper() # test if string contains
upper case
print(boo)

Output
False
DATA TYPES
4. List In Python:
 List are collections of items and each item has its own
index value.
 It is ordered sequence of values.
 Values of list enclosed in square bracket.
 It contain items Homogeneous(same) or e.g. of list
Hetrogeneous(different) list =[6,9]
list[0]=55
 It is mutable(changeable data type. print(list[0])
Ex : print(list[1])
OUTPUT
F=[1,2.5,”abc] 55
9
DATA TYPES

5. Tuple In Python
 Tuple are also collections of items and each item
has its own index value.
 It is also ordered sequence of values.
 Values of tuple enclosed in round bracket.
 It also contain items Homogeneous(same) or
Hetrogeneous(different)
 It is immutable(not changeable) data type
e.g. of tuple
tup=(66,99)
Tup[0]=3 # error message will be
DATA TYPES
6. Set In Python
 It is an unordered collection of unique and
immutable (which cannot be modified)items.

e.g.
set1={11,22,33,22}
print(set1)

Output
{33, 11, 22}
DATA TYPES
7. Dictionary In Python
It is an unordered collection of items and each item consist of a
key and a value.
e.g.
dict = {'Subject': 'comp sc', 'class': '11'} print(dict)
print ("Subject : ", dict['Subject'])
print ("class : ", dict.get('class'))

Output
{'Subject': 'comp sc', 'class': '11'}
Subject : comp sc
class : 11
Mutable and Immutable Types
In Python, Data Objects are categorized in two types-
• Mutable (Changeable)
• Immutable (Non-Changeable)
Look at following statements carefully p
= 10
q=p
r = 10
they will represent 10, 10, 10
Now, try to change the values p
= 17
r=7
q =9
did the values actually change?
Answer is NO. Because here values are objects and p, q, r are their
reference name. To understand it, lets see the next slide.
Mutable and Immutable Types

Variables and Values

An important fact to know is-
– In Python, values are actually objects.
– And their variable names are actually
10
their reference names. REFERENCE
OBJECT
VARIABLE
Supposeweassign10toavariableA. A =
10
Here, value 10 is an object and A is its reference name.
Mutable and Immutable Types
REFERENCE
VARIABLE
Variables and Values
If we assign 10 to a variable B, B
will refer to same object.
10
Here, we have two variables,
but with same location. REFERENCE OBJECT
VARIABLE
Now, if we change value of B like
B=20
Then a new object will be created with a 20
new location 20 and this object will be
referenced by B. 10
Mutable and Immutable Types

Following data types comes under mutable and

immutable types-
• Mutable (Changeable) – lists, dictionaries and sets.

• Immutable (Non-Changeable) – integers, floats,

Booleans, strings and tuples.
Variable Internals

The Type of an Object

• Pay attention to the following command-

>>>a=4
>>>type(4)
<class ’int’> here 4 is an object and its class is int
>>>type(a)
<class ‘int’> here a is referring to the object which is of int
class.
Variable Internals
The Value of an Object

• Pay attention to the following command-

>>>print(4)
4
>>>print(a)
4 here value output is coming via print()
• Pay attention to the following command
>>>id(4)
1817668720
>>>id(a)
1817668720

Here value 4 and variable a are showing same id which means 4 is an

object being referenced by ‘a ‘ that’s why they are keeping same id.
Expressions

• Python has following types of expression –

• Arithmetic Expressions like a+b, 5-4 etc.
• Relational Expressions like a>b, a==b etc.
• Logical Expressions like a>b and a>c , a or b etc.
• String Expressions like “Pankaj” + “Kumar” etc.
Type conversion
The process of converting the value of one data type (integer, string, float, etc.) to
another data type is called type conversion.

 Python has two types of type conversion.

 Implicit Type conversion
 Explicit Type conversion

 Implicit Type Conversion:

In Implicit type conversion, Python automatically converts one data type
to another data type. This process doesn't need any user involvement.
num_int = 12
num_flo = 10.23 OUTPUT
num_new = num_int + num_flo ('datatype of num_int:', <type 'int'>)
print("datatype of num_int:",type(num_int)) ('datatype of num_flo:', <type 'float'>) ('Value
print("datatype of num_flo:",type(num_flo)) of num_new:', 22.23)
('datatype of num_new:', <type 'float'>)
print("Value of num_new:",num_new)
print("datatype of num_new:",type(num_new))
Type conversion
Explicit Type Conversion:
In Explicit Type Conversion, users convert the data type of an object to required
data type. We use the predefined functions like int(),float(),str() etc.
e.g.
num_int = 12
num_str = "45"
print("Data type of num_int:",type(num_int))
print("Data type of num_str before Type Casting:",type(num_str))
num_str = int(num_str)
print("Data type of num_str after Type Casting:",type(num_str))
num_sum = num_int + num_str
print("Sum of num_int and num_str:",num_sum)
print("Data type of the sum:",type(num_sum))

OUTPUT
('Data type of num_int:', <type 'int'>)
('Data type of num_str before Type Casting:', <type 'str'>) ('Data
type of num_str after Type Casting:', <type 'int'>) ('Sum of
num_int and num_str:', 57)
('Data type of the sum:', <type 'int'>)
Type Casting
• As we know, in Python, an expression may be consists of
mixed datatypes. In such cases, python changes data types of
operands internally.
This process of internal data type conversion is called implicit type
conversion.
• One other option is explicit type conversion which is like-
<datatype>(identifier)
For ex
a=“4”
b=int(a)
Another ex
If a=5 and b=10.5 then we can convert a to float. Like
d=float(a)
In python, following are the data conversion functions-
(1) int ( ) (2) float( ) (3) complex( ) (4) str( ) (5) bool( )
TypeconversionandTypecasting

The basic difference between type conversion and type

casting, i.e. typeconversionis made “automatically” by
compiler whereas, type casting is to be “explicitly done” by
the programmer. ... When the two types are compatible
with each other, then the conversion of
one type to other is done automatically by the compiler.
Working with MATH Module of
Python
 Python provides math module to work for all
mathematical works. We need to write following
statement in our program.
import math

output of this program will be 5.0

To get to know functions of a module, give following command- >>>dir (math)
DEBUGGING

 Debugging means the process of finding errors ,finding

reasons of errors and techniques of their fixation
 An error, also known as a bug, is a programming code that
prevents a program from its successful interpretation.
 Errors are of three types –
• Compile Time Error
• Run Time Error
• Logical Error
DEBUGGING
Compile time error :
A compile-time error is an error that occurs when a program is being compiled. These
errors are basically of 2 types –
 Syntax Error :
Violation of formal rules of a programming language results in syntax error.
syntax errors such as
omitting a required semicolon,
using an undeclared variable,
using a keyword for the name of a variable.
For ex:
>>> a=5
>>> c=a+b
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
c=a+b
NameError: name 'b' is not defined
 Semantics Error:
Semantics refers to the set of rules which sets the meaning of statements. A
meaningless statement results in semantics error.
For ex: x*y=z
DEBUGGING

Logical Error
If a program is not showing any compile time error or run
time error but not producing desired output, it may be
possible that program is having a logical error.
Some example-
• Use a variable without an initial value.
• Provide wrong parameters to a function
• Use of wrong operator in place of correct operator
required for operation X=a+b (here – was required in
place of + as per requirement
DEBUGGING
Logical errors –logicalerrors causetheprogramtobehaveincorrectly,but they do not
usually crash the program. Unlike a program with syntax errors, a program with logic errors can
be run, but it does not operate as intended. Consider the following example of an logical error:
x = float(input('Enter a number: ')) y
= float(input('Enter a number: ')) z =
x+y/2
print ('The average of the two numbers you have entered is:',z)
The example above should calculate the average of the two numbers the user enters. But,
because of the order of operations in arithmetic (the division is evaluated before addition)
the program will not give the right answer:
Enter a number: 3
Enter a number: 4
The average of the two numbers you have entered is: 5.0
>>>
To rectify this problem, we will simply add the parentheses: z = (x+y)/2
Now we will get the right result:
>>>
Enter a number: 3
Enter a number: 4
The average of the two numbers you have entered is: 3.5
>>>
DEBUGGING

Run time Error :

These errors are generated during a program execution due to
resource limitation.
Python is having provision of checkpoints to handle these errors.
For ex
a=10
b=int(input(“enter a number”))
c=a/b
Value of b to be entered at run time and user may enter 0 at run
time,that may cause run time error,because any number can’t be
devided by 0
DEBUGGING

Run time Error

In Python, try and except clauses are used to handle an
exception/runtime error which is known as exception
handling
try: # code with probability of exception will be written here.
a=10
b=int(input(“enter a number”))
c=a/b
except: #code to handle exception will be written here. print(“devide
by zero erro”)
Available exception in python
Exception Name Description

IOError This exception generates due to problem in input or output.

NameError This exception generates due to unavailability of an identifier
IndexError This exception generates when subscript of a sequence is out of range

ImportError This exception generates due to failing of import statement.

TypeError This exception generates due to wrong type used with an operator or a function.

ValueError This exception generates due to wrong argument passed to a function.

ZeroDivisionErro r This exception generates when divisor comes to zero.

OverFlowError This exception generates when result of a mathematical calculation exceeds the
limit.
KeyError This exception generates due to non-availability of key in mapping of dictionary

FOFError This exception generates when end-of-file condition comes without reading input
of a built in function.
DEBUGGING

 In python debugging can be done through

• Print line debugger
• Debugging tool
DEBUGGING
Print line debugger – At various points in your code, insert print statements
that log the state of the program
• You will probably want to print some strings with some variables
• You could just join things together like this:
>>>x=9
>>>print ('Variable x is equal to ' + str(x))
Output : Variable x is equal to 9
• … but that gets unwieldy pretty quickly
• The format function is much nicer:
>>>x=3
>>>y=4
>>>z=9
>>>print ('x, y, z are equal to {}, {}, {}'.format(x,y,z))
Output : x, y, z are equal to 6, 4, 8
DEBUGGING

Print line debugger

• Python Debugger: pdb
– insert the following in your program to set a breakpoint
– when your code hits these lines, it’ll stop running and
launch an interactive prompt for you to inspect variables,
step through the program, etc.

import pdb
pdb.set_trace()

n to step to the next line in the current function s

to step into a function
c to continue to the next breakpoint
you can also run any Python command, like in the interpreter
DEBUGGING
Create a.py file with below code and run it in python use n to step
next line.
num_list = [500, 600, 700]
alpha_list = ['x', 'y', 'z']
import pdb
pdb.set_trace() #debugging code def
nested_loop():
for number in num_list:
print(number)
for letter in alpha_list:
print(letter)
if name == ' main ':
nested_loop()
While executing above code whole program will be traced.
Another way is to invoke the pdb module from the command line.
DEBUGGING
Debugger tool
Another technique for removing an error is code tracing.
In this technique, lines are to be executed one by one and
their effect on variables is to be observed. Debugging tool or
debugger tool is provided in Python for this.
In Python3.6.5, to make debugger
tool available, click on debugger
option in debug menu.
DEBUGGING

Debugger tool
Then, a box will be opened and a message will come
saying DEBUG ON

Then, we will open our program from file menu and will run it.
DEBUGGING
Debugger tool
Then after it will be shown like this in debugger

Click on STEP button for each line execution one by one and result will be displayed in
output window. When we will get wrong value, we can stop the program there and can
correct the code.