Python lec4

Swarup Kr Ghosh
MIS Group
IIM Calcutta
swarupg1@gmail.com

 Modules and Packages
 Classes and OOPs
 Operator Overloading
 Exceptions
7/21/2017 2Swarup Kr Ghosh

 The highest-level programming structure, which packages
program code and data for reuse
 Collection of stuff defined in separate files with .py extension
◦ Functions, classes and variables
 Each file is a module, and modules import other modules to use
 Items are imported using from or import
from module import function
function()
import module
module.function()

 Each module has its own namespace
◦ Can be used to organize variable names, i.e.
atom.position = atom.position - molecule.position
 Modules might also correspond to extensions
coded in external languages such as C, Java, or
C#

 Code reuse
◦ Routines can be called multiple times within a program
◦ Routines can be used from multiple programs
 System Namespace partitioning
◦ Group data together with functions used for that data
 Implementing shared services or data
◦ Can provide global data structure that is accessed by
multiple subprograms

import mymodule:
Brings all elements of mymodule
in, but must refer to as mymodule
>>> import module1
#Get module as a whole
>>> module1.printer('Hello
world!') #Qualify to get names
Hello world!
from mymodule import x:
Imports x from mymodule right
into this namespace
>>> from module1 import printer
#Copy out a variable
>>> printer('Hello world!')
#No need to qualify name
Hello world!
from mymodule import *:
Imports all elements of mymodule
into this namespace
>>> from module1 import *
#Copy out _all_ variables
>>> printer('Hello world!')
Hello world!

 Collection of modules in directory
 Must have __init__.py file
 May contain subpackages
 Import syntax:
◦ import dir1.dir2.mod
◦ from dir1.dir2.mod import x
◦ from dir1.dir2.mod import foo: print foo()
◦ from dir1.dir2 import mod: print mod.foo()
◦ import dir1.dir2.mod: print dir1.dir2.mod.foo()
◦ import dir1.dir2.mod as mod: print mod.foo()

 ‘import’ refer to load a file on request
 The files ‘a.py, b.py, c.py’ are chosen to be simple
text
def spam(text): # File b.py
print(text, 'spam')
import b # File a.py
b.spam('gumby') # Prints "gumby spam"

class name:
"documentation"
statements
-or-
class name(base1, base2, ...):
...
Most, statements are method definitions:
def name(self, arg1, arg2, ...):
...
May also be class variable assignments

 Instances of class
 A software item that contains variables and methods
x = Stack()
 To use methods of the instance, call using dot notation:
x.empty()
x.push(1)
x.empty()
x.push("hello")
x.pop()
 To inspect instance variables, use dot notation:
x.items

class Stack:
"A well-known data structure…"
def __init__(self): #constructor
self.items = []
def push(self, x):
self.items.append(x) #the sky is the limit
def pop(self):
x = self.items[-1] #what happens if it’s empty?
del self.items[-1]
return x
def empty(self):
return len(self.items) == 0 #Boolean result

 Object Oriented Design focuses on:
 Encapsulation:
◦ binding (or wrapping) code and data together into a single unit
is known as encapsulation
◦ dividing the code into a public interface, and a private
implementation of that interface
 Abstraction:
◦ hiding internal details and showing functionality, e.g.: phone
call, we don't know the internal processing
 Polymorphism:
◦ the ability to overload standard operators so that they have
appropriate behavior based on their context
◦ one task is performed by different ways
 Inheritance:
◦ the ability to create subclasses that contain specializations of
their parents

>>> class FirstClass: #Define a class object
def setdata(self, value): #Define class's methods
self.data = value #self is the instance
def display(self):
print(self.data) #self.data: per instance
>>> x = FirstClass() #Make two instances
>>> y = FirstClass() #Each is a new namespace
>>> x.setdata("King Arthur") #Call methods: self is x
>>> y.setdata(3.14159) #Runs: FirstClass.setdata()
>>> x.display() #self.data differs in each instance
King Arthur
>>> y.display() #Runs: FirstClass.display(y)
3.14159
7/21/2017Swarup Kr Ghosh 14

class atom(object):
def __init__(self,atno,x,y,z):
self.atno = atno
self.position = (x,y,z)
def symbol(self): #a class method
return Atno_to_Symbol[atno]
def __repr__(self): #overloads printing
return '%d %10.4f %10.4f %10.4f' %
(self.atno, self.position[0],
self.position[1],self.position[2])
>>> at = atom(6,0.0,1.0,2.0)
>>> print at
6 0.0000 1.0000 2.0000
>>> at.symbol()
'C'

 Overloaded the default constructor
 Defined class variables (atno, position) that are
persistent and local to the atom object
 Good way to manage shared memory:
◦ instead of passing long lists of arguments, encapsulate
some of this data into an object, and pass the object.
◦ much cleaner programs result
 Overloaded the print operator
 We now want to use the atom class to build
molecules........

class molecule:
def __init__(self,name='Generic'):
self.name = name
self.atomlist = []
def addatom(self,atom):
self.atomlist.append(atom)
def __repr__(self):
str = 'This is a molecule named %sn' % self.name
str = str+'It has %d atomsn' % len(self.atomlist)
for atom in self.atomlist:
str = str + `atom` + 'n'
return str

>>> mol = molecule('Water')
>>> at = atom(8,0.,0.,0.)
>>> mol.addatom(at)
>>> mol.addatom(atom(1,0.,0.,1.))
>>> mol.addatom(atom(1,0.,1.,0.))
>>> print mol
This is a molecule named Water
It has 3 atoms
8 0.000 0.000 0.000
1 0.000 0.000 1.000
1 0.000 1.000 0.000
 Note that the print function calls the atoms print function
◦ Code reuse: only have to type the code that prints an atom once;
this means that if you change the atom specification, you only
have one place to update.

class LimitedStack(FancyStack):
"fancy stack with limit on stack size"
def __init__(self, limit):
self.limit = limit
FancyStack.__init__(self) #base class constructor
def push(self, x):
assert len(self.items) < self.limit
FancyStack.push(self, x) #"super" method call

 Process by which one object acquires the properties of
another object
 E.g. First define Class FirstClass (previous e.g.)
>>> class SecondClass(FirstClass): #Inherits setdata
def display(self): #changes display
print('Current value = "%s"' % self.data)
>>> z = SecondClass()
>>> z.setdata(42) #Finds setdata in FirstClass
>>> z.display() #Finds overridden method in SecondClass
Current value = "42“
>>> x.display() #x is still a FirstClass instance (old message)
King Arthur

class ThirdClass(SecondClass): #Inherit from SecondClass
def __init__(self, value): #On "ThirdClass(value)"
self.data = value
def __add__(self, other): #On "self + other"
return ThirdClass(self.data + other)
def __str__(self): #On "print(self)", "str()"
return '[ThirdClass: %s]' % self.data
def mul(self, other): #In-place change: named
self.data *= other
>>> a = ThirdClass('abc') # __init__ called
>>> a.display() #Inherited method called
Current value = "abc"
>>> print(a) #__str__:returns display string
[ThirdClass: abc]
>>> b = a + 'xyz' #__add__:makes a new instance
>>> b.display() #b has all ThirdClass methods
Current value = "abcxyz"
>>> print(b) #__str__: returns display string
[ThirdClass: abcxyz]
>>> a.mul(3) #mul: changes instance in place
>>> print(a)
[ThirdClass: abcabcabc]

 Three attributes in Python:
 __init__: to create new instance of object
 __add__: to make a new instance when ‘+’ appear
in class
 __str__: to print the object (print string)

class Connection:
verbose = 0 #class variable
def __init__(self, host):
self.host = host #instance variable
def debug(self, v):
self.verbose = v #make instance
variable!
def connect(self):
if self.verbose: #class or instance
variable?
print ("connecting to", self.host)

 On use via instance (self.x), search order:
◦ (1) instance, (2) class, (3) base classes
◦ this also works for method lookup
 On assignment via instance (self.x = ...):
◦ always makes an instance variable
 Class variables "default" for instance variables
 But...!
◦ mutable class variable: one copy shared by all
◦ mutable instance variable: each instance its own

 Special kind of method that determines how an object
is initialized when created
class Person:
def __init__(self, name, job=None, pay=0):
#Const takes 3 arguments
self.name = name #Fill out fields when created
self.job = job #self is the new instance object
self.pay = pay
bob = Person('Bob Smith') #Test the class
sue = Person('Sue Jones', job='dev', pay=100000)
#Runs __init__ automatically
print(bob.name, bob.pay) #Fetch attached attributes
print(sue.name, sue.pay) #sue's and bob's attrs differ

 “Operator overloading” simply means intercepting
built-in operations in a class’s methods
 Classes can overload all Python expression operators
 Classes can also overload built-in operations such as
printing, function calls, attribute access, etc
 Overloading makes class instances act more like built-
in types
 Overloading is implemented by providing specially
named methods in a class

# File number.py
class Number:
def __init__(self, start): #On Number(start)
self.data = start
def __sub__(self, other): #On instance - other
return Number(self.data - other) #Result is a new instance
>>> from number import Number #Fetch class from module
>>> X = Number(5) #Number.__init__(X, 5)
>>> Y = X - 2 #Number.__sub__(X, 2)
>>> Y.data #Y is new Number instance
3

 An event occurs during the execution of program
 Disrupts normal flow of program’s instruction
 It must be handled
try:
statement1
statement2
…………
Except IOError:
statement

 Error handling
 Event notification
 Special-case handling
 Termination actions
 Unusual control flows

 try/except:
◦ Catch and recover from exceptions raised by Python, or
by programmer
 try/finally:
◦ Perform cleanup actions, whether exceptions occur or
not
 raise:
◦ Trigger an exception manually in your code
 assert:
◦ Conditionally trigger an exception in code

def kelTocel(t):
assert(t>=0), “so cool”
x=((t-273)*1.8)+32
print(“Result=“,x)
return
o/p: kelTocel(100)  -279.4000
kelTocel(-20)  assertionError
def kelTocel(t):
try:
assert(t>=0), “so cool”
x=((t-273)*1.8)+32
print(“Result=“,x)
except AssertionError:
print(“Give positive value")
return

def tem_convert(var):
try:
x=1/var
return(x)
except ZeroDivisionError:
print("argument dont match")
return

try:
f=open("kmean3.txt","w")
f.write("this is my test file")
finally:
print("Cant find file")
f.close()

Python lec4

More Related Content

What's hot (20)

Similar to Python lec4 (20)

Recently uploaded (20)

Python lec4