###################### 16.1.1 Using a class instance as a structure or record class Circle: pass myCircle = Circle() myCircle.radius = 5 print 2 * 3.

14 * myCircle.radius #### class Circle: # By convention, "self" is always the name of the first argument of __init__ . "self" will be # set to the newly created circle instance, when __init__ is run. def __init__(self): self.radius = 1 ###################### 16.3 Methods class Circle: def __init__(self): self.radius = 1 def area(self): return self.radius * self.radius * 3.14159 #### class Circle: def __init__(self, radius): # Note the two uses of radius here! "self.radius" is the instance variab le called 'radius'. "radius" # by itself is the local function variable called 'radius'. The two are not the same! In practice, we'd # probably call the local function variable something like 'r' or 'rad', to avoid any possibility of confusion. self.radius = radius def area(self): return self.radius * self.radius * 3.14159 ###################### 16.4 Class variables class Circle: pi = 3.14159 def __init__(self, radius): self.radius = radius def area(self): return self.radius * self.radius * Circle.pi ###################### 16.5 Class methods ------------------------------- File circle.py ------------------------------"""circle module: contains the Circle class.""" class Circle: """Circle class"""

# Variable containing a list of all circles which have been created. allCircles = [] pi = 3.14159 def __init__(self, r=1): """Create a Circle with the given radius""" self.radius = r self.__class__.allCircles.append(self) def area(self): """determine the area of the Circle""" return self.__class__.pi * self.radius * self.radius # This is a top-level function (not in the Circle class). def totalArea(): total = 0 for c in Circle.allCircles: total = total + c.area() return total ###################### 16.6 Inheritance class Square: def __init__(self, side=1): # "side" is the length of any side of the square. self.side = side #### class Square: def __init__(self, side=1, x=0, y=0): self.side = side self.x = x self.y = y class Circle: def __init__(self, radius=1, x=0, y=0): self.radius = radius self.x = x self.y = y #### class Shape: def __init__(self, x, y): self.x = x self.y = y # This line says 'Square' inherits from 'Shape' class Square(Shape): def __init__(self, side=1, x=0, y=0): # Must make an explicit call to the __init__ method of 'Shape' Shape.__init__(self, x, y) self.side = side # This line says 'Circle' inherits from 'Shape' class Circle(Shape): def __init__(self, r=1, x=0, y=0): # Must make an explicit call to the __init__ method of 'Shape' Shape.__init__(self, x, y)

self.radius = r #### class Shape: def __init__(self, x, y): self.x = x self.y = y def move(self, deltaX, deltaY): self.x = self.x + deltaX self.y = self.y + deltaY ###################### 16.7 Inheritance with class and instance variables class P: z = "Hello" def setP(self): self.x = "Class P" def printP(self): print self.x class C(P): def setC(self): self.x = "Class C" def printC(self): print self.x ###################### 16.8 Private variables and private methods class Mine: def __init__(self): self.x = 2 # Define __y as private by using leading double underscores. self.__y = 3 def printY(self): print self.__y ###################### 16.9 Scoping rules and namespaces for class instances """cs module: class scope demonstration module.""" mv ="module variable: mv" def MF(): return "module function (can be used like a class method in other languages) : MF()" class SC: scv = "superclass class variable: self.scv" __pscv = "private superclass class variable: no access" def __init__(self): self.siv = "superclass instance variable: self.siv (but use SC.siv for a ssignment)" self.__psiv = "private superclass instance variable: no access" def SM(self): return "superclass method: self.SM()" def __SPM(self): return "superclass private method: no access"

class C(SC): cv = "class variable: self.cv (but use C.cv for assignment)" __pcv = "class private variable: self.__pcv (but use C.__pcv for assignment) " def __init__(self): SC.__init__(self) self.__piv = "private instance variable: self.__piv" def M2(self): return "method: self.M2()" def __PM(self): return "private method: self.__PM()" def M(self, p="parameter: p"): lv = "local variable: lv" self.iv = "instance variable: self.xi" print "Access local, global and built-in namespaces directly" print "local namespace:",locals().keys() print p # parameter print lv # instance variable print "global namespace:",globals().keys() print mv # module variable print MF() # module function print "Access instance, class, and superclass namespaces through 'self'" print "Instance namespace:",dir(self) print self.iv # instance variable print self.__piv # private instance variable print self.siv # superclass instance variable print "Class namespace:",dir(C) print self.cv # class variable print self.M2() # method print self.__pcv # private class variable print self.__PM() # private module print "Superclass namespace:",dir(SC) print self.SM() # superclass method print self.scv # superclass variable through the instance ###################### 16.10 Destructors and memory management class SpecialFile: def __init__(self, fileName): self.__file = open(fileName, 'w') self.__file.write('***** Start Special File *****\n\n') def write(self, str): self.__file.write(str) def writelines(self, strList): self.__file.writelines(strList) def __del__(self): print "entered __del__" self.close() def close(self): if self.__file: self.__file.write('\n\n***** End Special File *****') self.__file.close() self.__file = None

def test(): f = SpecialFile('testfile') f.write('111111\n') f.close() #### class Circle: def __init__(self, name, parent): self.__name = name self.__parent = parent self.__child = None if parent: parent._child = self def cleanup(self): self.__child = self.__parent = None def __del__(self): print "__del__ called on", self.__name def test1(): a = Circle("a", None) b = Circle("b", a) def test2(): c = Circle("c", None) d = Circle("d", c) d.cleanup() #### def test3(x): try: c = Circle("c", None) d = Circle("d", c) if x == 1: print "leaving test3 via a return" return if x == 2: print "leaving test3 via an exception" raise RuntimeError print "leaving test3 off the end" finally: d.cleanup()