Python Programming: Lists, Modules, Exceptions

Lists
 Creating Lists,
 Accessing the Elements of a List,
 Negative List Indices,
 List Slicing [Start: end], List Slicing with Step Size,
 Python Inbuilt Functions for Lists,
 The List Operator, List Comprehensions,
 List Methods, List and Strings, Splitting a String in List,
 Passing List to a Function, Returning List from a Function.
Prepared by Dr. C. Sreedhar

# Lists are used to store multiple items in a single variable.
# List items can be of similiar items, different items,duplicates
list1 = ["cse", "cst", "csbs"]
list2 = [10, 50, 60, 80, 40]
list3 = [True, False, False]
list4 = ["cse4a","cse4b","cse4a","ece"]
print(list1)
print(list2)
print(list3)
print(list4[1])
['cse', 'cst', 'csbs']
[10, 50, 60, 80, 40]
[True, False, False]
cse4b

# Accept list items from user uslng list() constructor
l1=input(list())
print(l1)
# Access the elements using index [ ] operator
print(list4[2])
cse4b
# Slicing the list using
#Name_of_Variable_of_a_List[Start_Index: End_Index]
['cse4b',
'cse4a']

Lists in python
 Lists are used to store multiple items in a single variable.
 List items can be of any data type. Example:
 list1 = ["cse", "cst", "csbs"]
 list2 = [10, 50, 60, 80, 40]
 list3 = [True, False, False]
 List allows duplicates. Example:
 cse4a = ["ram", "shyam", "ram", "sree", "dennis"]
 print(cse4a)
 List allows different data types. Example

Creating a list with w/o using constructor of the list class
 Lists can be created in Python with constructor and w/o constructor
Using list Constructor
 Create an empty list. L1 = list();
 Create a list with any three integer elements, such as 10, 20 and 30.
L2 = list([10,20,30])
 Create a list with three string elements, such as “Apple”, “Banana” and
“Grapes”. L3 = list([“Apple”,”Banana”,”Grapes”])
 Create a list using inbuilt range() function. L4 = list(range(0,6))
 Create a list with inbuilt characters X, Y and Z. L5=list(“xyz”)
 Create a list with any three integer elements, such as 10, 20 and 30.
L1=[10,20,30]

ACCESSING THE ELEMENTS OF A LIST
 index [] operator is used to access them. The syntax is:
Name_of_Variable_of_a_List[index]
 L1=([10,20,30,40,50])
>>> List1=[10,20,30,40,50,60]
>>> List1[-3]
Output
40

LIST SLICING [START: END]
 Name_of_Variable_of_a_List[Start_Index: End_Index]
>>> L1=([10,20,30,40,50])
>>> L1[1:4]
Output
20,30,40
>>> L1[2:5]
Output

LIST SLICING WITH STEP SIZE
 List_Name[Start_Index:End_Index:Step_Size]
>>>MyList1=[“CSE”,1,”CST”,2,”ECE”,3,”EEE”]
>>>New_List1=MyList1[0:6:2]
print(New_List1)
Output
[‘CSE’, ‘CST’, ‘ECE’] >>> List1=[“Python”,450,”C”,300,”,C++”,670]
>>> List1[0:6:3]
Output

PYTHON INBUILT FUNCTIONS FOR LIST

 + Operator: The concatenation operator is used to join two lists.
 a=[1,2,3] b=[4,5,6] a+b # [1, 2, 3, 4, 5, 6]
 * Operator: The multiplication operator is used to replicate the
elements of a list.
 List1=[10,20] List2=[20,30] List3=2*List1 #[10, 20, 10, 20]
 in Operator: The in operator used to determine whether an element
is in a list. It returns True if the element is present and False if the
element is absent in the list.
 List1= [10,20]
 >>> 40 in List1
 False
LIST OPERATOR Prepared by Dr. C. Sreedhar

LIST OPERATOR
 isOperator
 >>> A=’Microsoft’
 >>> B=’Microsoft’
 >>> A is B
 True
 >>> A=[‘A’,’B’,’C’]
 >>> B=[‘A’,’B’,’C’]
 >>> A is B #Check if two lists refer to the same Object
 False

del Operator
Lst=[10,20,30,40,50,60,70]
>>> del Lst[2] #Removes 3rd element from the List
>>> Lst
[10, 20, 40, 50, 60, 70]
Lst=[10,20,30,40,50,60,70]
>>> del Lst[-1]
>>> Lst #Removes last element from the List
[10, 20, 30, 40, 50, 60]
>>> Lst=[10,20,30,40,50,60,70]
>>> del Lst[2:5] #Removes element from index position 2 to 4
>>> Lst
[10, 20, 60, 70]
>>> Lst=[10,20,30,40,50,60,70]
>>> del Lst[:] #Removes all the element from the List
>>> Lst
[]s

LIST COMPREHENSIONS
 List comprehension is used to create a new list from existing sequences
Normal Code
List1= [10, 20, 30, 40, 50]
for i in range(0,len(List1)):
List1[i]=List1[i]+5 # [15, 25, 35, 45, 55]
Using List Comprehension
List1= [10,20,30,40,50]
List1= [x+10 for x in List1] # [20, 30, 40, 50, 60]

Unit 4
• Modules: Reusing Code with Modules and Packages,
Understanding Python Modules, Everyday Module Usage,
Advanced Module Behavior, Combining Modules into
Packages
• Exceptions: When Something Goes Wrong, Classes of
Exceptions, A Final Note on Pythonic Exception Handling.
• File Handling: Need of File Handling, Text Input and
Output, The seek() Function, Binary Files, Accessing and
Manipulating Files and Directories on a Disk.

• os
– os.getcwd()
– os.fspath(path)
– os.getlogin()
• ipaddress:
–ipaddress.IPv4Address(address)
–ipaddress.IPv6Address(address)
• math:
– math.factorial(x)
– math.gcd(n1,n2)
– math.lcm(n1,n2)
– math.trunc(x)
– math.pow(x, y)
– math.pi
• random:
– random.randint(a,b)
– random.uniform(a,b)
• time:
– time.clock_gettime()
– time.clock_gettime_ns()
Module: Builtin Modules

Modules: Create and import
• 1. Open Python IDLE (Start --> Python IDLE)
• 2. File --> New File
• 3. ---- type the following code----
def greeting(name):
print("Hello, " + name)
• 4. Save with module1.py (in Desktop or any folder)
• 5. Pyhton IDLE ==> File --> New File
• 6. ------ type the following code ----
import module1
module1.greeting("CSE4A")
• 7. Save as runmodule.py (in Desktop or any folder)
• 8. In Python IDLE, click on Run --> Run Module
from <module_name> import *
from <module_name> import <name> as <alt_name>

module2.py
----------------------------------------------
def sum_list(lst):
print('Sum=',sum(lst))
---------------------------------------------
summodule.py
---------------------------------------------
import module2
l1=[10,20,30,40]
module2.sum_list(l1)
Modules: Create and import

In python, the inbuilt __import__() function helps
to import modules in runtime
Syntax:
__import__(name, globals, locals, fromlist, level)
Ex:
math_score = __import__('math', globals(), locals(), [], 0)
print(math_score.fabs(17.4))

Package
• A package is basically a directory with Python file
and file with the extension as _init_.py.
• Steps to create package:
– create a package (folder). The name of package, say, My _ First _ Package
– Create _ init _ .py file inside the created package My_First_Package.
– The directory should contain a file named _init_.py. This file can be empty or it
may contain valid Python code.
– create two different .py files, i.e. a.py and b.py with code
a.py
def call_A():
print(“This is first program”)
b.py
def call_B():
print(“This is second”)
>>> My_First_Package.a.call_A()
This is first program
>>> My_First_Package.b.call_B()
This is second
_init_.py
import My_First_Package.a
import My_First_Package.b

# GPREC/CSBS/__init__.py (Empty file)
# GPREC/CSBS/csbs4sem.py
print("In CSBS branch")
# GPREC/CSE/__init__.py
from . import cse4a
from . import cse4b
# GPREC/CSE/cse4a.py
print("In CSE 4A Class")
# GPREC/CSE/cse4b.py
print("In CSE 4B Class")
# GPREC/CSE/cse4c.py
print("In CSE 4C Class")
# world/__init__.py
from . import CSBS
from GPREC import CSE
import GPREC.CSE.cse4a
from GPREC.CSE import cse4b

Exceptions
• An exception is an event, which occurs during the execution of a program,
that disrupts the normal flow of the program's instructions.
• Exception: Base class for all exceptions
• ArithmeticError: Base class for all errors that occur for numeric calculation.
• OverflowError: Raised when a calculation exceeds maximum limit for a numeric type.
• FloatingPointError: Raised when a floating point calculation fails.
• ZeroDivisionError: Raised when division or modulo by zero takes place for numeric
• AttributeError: Raised in case of failure of attribute reference or assignment.
• EOFError: Raised when end of file is reached.
• ImportError: Raised when an import statement fails.
• IndexError: Raised when an index is not found in a sequence.
• EnvironmentError: Base class for all exceptions that occur outside Python environment.
• SyntaxError: Raised when there is an error in Python syntax.
• TypeError: Raised when an operation is attempted that is invalid for specified data type.

try:
<body>
except <ExceptionType1>:
<handler1>
except <ExceptionTypeN>:
<handlerN>
except:
<handlerExcept>
else:
<process_else>
finally:
<process_finally>

try:
num1,num2 = eval(input("Enter two numbers,separated by a comma:"))
result = num1 / num2
print("Result is", result)
except ZeroDivisionError:
print("Division by zero is error !!")
except SyntaxError:
print("Comma is missing. Enter nos separated by comma like this 1, 2")
except:
print("Wrong input")
else:
print("No exceptions")
finally:
print("This will execute no matter what“)

try:
a = [1, 2, 3]
print (a[3])
except LookupError:
print ("Index out of bound error.")
else:
print ("Success")

try:
age= int(input())
assert (age>0 and age<100)
# True: moves to the next line ie., print age; False: returns Assertion Error
except AssertionError:
print("Not valid age.")
except:
print("Invalid data entered")
else:
print("Age is:",age)

try:
age= int(input("Enter your age:"))
if age<0:
raise ValueError
except ValueError:
print("Age cannot be less than zero.")
else:
print("Age is:",age)

Format:
<file variable> = open(<file name>, "r")
Example:
filename = input("Enter name of input file: ")
inputFile = open(filename, "r")
Python File handling

Modes Description
r Opens a file for reading only, default mode.
rb Opens a file for reading only in binary format.
r+ Opens a file for both reading and writing
rb+ Opens a file for both reading and writing in binary format
w Opens a file for writing only. Overwrites the file if the file exists.
Wb Opens a file for writing only in binary format. Overwrites the file if the file exists
w+ Opens a file for both writing and reading, Overwrites file if file exists

Example:
file2 = open(“cse4a.txt", "wb")
print ("Name of the file: ", file2.name)
print ("Closed or not : ", file2.closed)
print ("Opening mode : ", file2.mode)
This would produce following result:
Name of the file: foo.txt
Closed or not : False
Opening mode : wb

Reading contents from file
inputFileName = input("Enter name of input file:")
inputFile = open(inputFileName, "r")
print("Opening file", inputFileName, " for reading.")
for line in inputFile:
sys.stdout.write(line)
inputFile.close()
print("Completed reading of file", inputFileName)

Alternate way to read contents from file
inputFileName = input ("Enter name of input file: ")
line = inputFile.readline()
while (line != ""):
sys.stdout.write(line)
line = inputFile.readline()
inputFile.close()
print("Completed reading of file", inputFileName)

Writing contents
fo = open(“cse4a.txt", "wb")
fo.write("Welcome to CSE4A n");
fo.close()

Writing contents from one file into another
inputFileName = input("Enter file name to read grades from: ")
outputFileName = input("output filename to write GPA's to: ")
outputFile = open(outputFileName, "w")
print("Opening file", outputFileName, " for writing.")
gpa = 0

seek()
• seek() function is used to change the position
of the File Handle to a given specific position.

Unit 5
Object-Oriented Programming:
• Class, Objects and Inheritance: Defining Classes, The
Selfparameter and Adding Methods to a Class,
• Display Class Attributes and Methods, Special Class Attributes,
Accessibility, The __init__ Method (Constructor),
• Passing an Object as Parameter to a Method, __del__()
(Destructor Method), Class Membership Tests,
• Method Overloading, Operator Overloading, Inheritance, The
Object Class.

Class and attributes
class Example :
x = 10
print(Example.x)
class Example:
x = 10
y = 20
print(Example.x)
print(Example.y)

Class and method
class Example:
x=10
y=20
def show(obj):
print("x=",obj.x)
print("y=",obj.y)
Example.show=classmethod(Example.show)
Example.show()

Constructor
class Student:
count = 0
def __init__(self):
Student.count = Student.count + 1
s1=Student()
s2=Student()
s3=Student()
print("Total students:",Student.count)

Class and Object
class Student:
def __init__(self, name, percentage):
self.name = name
self.percentage = percentage
def show(self):
print("Name:", self.name,“percentage:", self.percentage)
stud = Student("Sreedhar", 90)
stud.show()

Data encapsulation
class Employee:
def __init__(self, name, empid):
self.name = name
self.empid = empid
def show(self):
print("Name: ", self.name, "and ID:", self.empid)
E = Employee("Sreedhar", 6666)
print(E.name)
print(E.empid)

Class attributes
class MyClass(object):
var = 10
def set_val(self):
self.b = 100
ob1 = MyClass()
print(ob1.var) # This will fetch the class attribute 10.
ob1.set_val()
print(ob1.b) # This will fetch the class attribute 100

Class constructor: Example
class gprecclass:
def __init__ (self, section):
# self allows to attach parameter to the class
self.section =section
p = gprecclass("CSE4A")
print(p.section)

__init__ method: Constructor
class MyNum(object):
def __init__(self):
print("Calling __init__() constructor!n")
self.val = 0
def increment(self):
self.val = self.val + 1
print(self.val)
dd = MyNum()
dd.increment() # will print 1
dd.increment() # will print 2

Constructor
class Rectangle(object):
def __init__(self, l, w):
self.length = l
self.width = w
def area(self):
return self.length*self.width
a = Rectangle(2,10)
print(a.area())

Methods
class Circle:
pi = 3.14
def __init__(self, radius=1):
self.radius = radius
self.area = radius * radius * Circle.pi
def setRadius(self, new_radius):
self.radius = new_radius
self.area = new_radius * new_radius * self.pi
def getCircumference(self):
return self.radius * self.pi * 2
c = Circle()
print('Radius is: ',c.radius)
print('Area is: ',c.area)
print('Circumference is:
',c.getCircumference())

Class and methods
class Subject:
def __init__(self, name, id):
self.id = id
self.name = name
def display(self):
print("Subject ID:%d Name:%s”%(self.id, self.name))
ppy = Subject("Python Programming", 101)
ds = Subject("Data Structures", 102)
ppy.display()
ds.display()

Public access modifier
class Bank:
def __init__(self, name, pin):
# public data members
self.bankname = name
self.bankpin = pin
# public member function
def displaypin(self):
# accessing public data member
print("Pincode: ", self.bankpin)
obj = Bank("Union Bank", 518007)
print("Bank Name: ", obj.bankname)
obj.displaypin()

Private specifier
class Bank:
bankname="SBI"
__custname = None # privatemember
__custage = 20
__custbranch = None
def __init__(self, name, age, branch):
self.__custname = name
self.__custage = age
self.__custbranch = branch
# private member function
def __displayDetails(self):
print("Customer Name: ", self.__custname)
print("Customer Age: ", self.__custage)
print("Cust Branch: ", self.__custbranch)
# public member function
def accessPrivateFunction(self):
# accessing private member function
self.__displayDetails()
obj = Bank("Sree", 25, "SN Colony")
print(obj.bankname)
obj.accessPrivateFunction()

Inheritance
class Base:
def func1(self):
print('This is Base class')
class Derived(Base):
def func2(self):
print('This is Derived class')
obj = Derived()
obj.func1()
obj.func2()

Inheritance
class Date(object):
def get_date(self):
print("2022-05-3")
class Time(Date):
def get_time(self):
print("14:10:00")
dt = Date()
dt.get_date()
print("----------“)
tm = Time()
tm.get_time()
tm.get_date()

Multiple Inheritance
class A(object):
def method1(self):
print("doing this in A")
class B(A):
pass
class C(object):
def method1(self):
print("doing this in C")
class D(B, C):
pass
d_instance = D()
d_instance.method1()
print("nPrint the Method Resolution Order")
print(D.mro())

Method Overloading
class Person:
def M1(self, name=None):
if name is not None:
print('Name: ' + name)
else:
print('Default name ')
obj = Person()
obj.M1()
obj.M1('ABCDEF‘)

Method Overloading
class A:
def __init__(self, a):
self.a = a
# adding two objects
def __add__(self, o):
return self.a + o.a
ob1 = A(10)
ob2 = A(30)
ob3 = A("CSE4A")
ob4 = A(" ECE4A")
print(ob1 + ob2)
print(ob3 + ob4)

Operator Overloading
import math
class Circle:
def __init__(self, radius):
self.__radius = radius
def setRadius(self, radius):
self.__radius = radius
def getRadius(self):
return self.__radius
def area(self):
return math.pi * self.__radius ** 2
def __add__(self, circle_object):
return Circle(self.__radius + circle_object.__radius)
def __lt__(self, circle_object):
return (self.__radius < circle_object.__radius)
def __gt__(self, circle_object):
return (self.__radius > circle_object.__radius)
def __str__(self):
return "Circle area = " + str(self.area())
c1 = Circle(20)
c2 = Circle(30)
c3 = c1 + c2
print(c1.getRadius())
print(c1 < c2)
print(c3 > c2)
print(str(c1))
print(str(c2))
print(str(c3))

Python Programming: Lists, Modules, Exceptions

In this document

More Related Content

What's hot

Similar to Python Programming: Lists, Modules, Exceptions

More from Sreedhar Chowdam

Recently uploaded

Python Programming: Lists, Modules, Exceptions