1 #chapter 3.1
   2 #class average program with counter-controled repetition
   3 
   4 #initialization phase
   5 total = 0   #sum of grades
   6 gradeCounter = 1    #number of grades entered
   7 
   8 #processing phase
   9 while gradeCounter <= 10:
  10     grade = raw_input("Enter grade:")
  11     grade = int(grade)
  12     total = total + grade
  13     gradeCounter = gradeCounter + 1
  14 
  15 #termination phase
  16 average = float(total) / 10     #covert integer to float
  17 print "Class average is", average

   1 #chapter3.2
   2 #Class average program with sentinel-controlled repetition
   3 
   4 #initialization phase
   5 total = 0   #sum of grade
   6 gradeCounter = 0    #number of grades entered
   7 
   8 #processing phase
   9 grade = raw_input("Enter grade,-1 to end:") #get one grade
  10 grade = int(grade)
  11 
  12 while grade !=-1:
  13     total = total + grade
  14     gradeCounter = gradeCounter + 1
  15     grade = raw_input("Enter grade,-1 to end:")
  16     grade = int(grade)
  17 
  18 #termination phase
  19 if gradeCounter != 0:
  20     average = float(total) / gradeCounter
  21     print "Class average is", average
  22 else:
  23     print "No grade were entered"

   1 #chapter 3.3
   2 #Analysis of examination results
   3 
   4 #initialize variables
   5 passes = 0
   6 failures = 0
   7 studentCounter = 1
   8 
   9 #process 10 students
  10 while studentCounter <= 10:
  11     result = raw_input("Enter result(1=pass,2=fail):")
  12     result = int(result)
  13 
  14     if result == 1:
  15         passes = passes + 1
  16     else:
  17         failures = failures + 1
  18 
  19     studentCounter = studentCounter + 1
  20 
  21 #termination phase
  22 print "Passed", passes
  23 print "Failed", failures
  24 
  25 if passes > 8:
  26     print "Raise tuition"

   1 #chapter 4.1
   2 #Recursive factorial function.
   3 
   4 def factorial(number):
   5     if number <=1:
   6         return 1
   7     else:
   8         return number * factorial(number - 1)   #recursive call
   9 
  10 for i in range(11):
  11     print "%2d! = %d" % (i, factorial(i))

   1 #chapter4.2
   2 #Recursive fibonacci function  0,1,1,2,3,5,8,13,21
   3 
   4 def fibonacci(n):
   5     if n == 0 or n == 1:
   6         return n
   7     else:
   8         return fibonacci(n - 1) + fibonacci(n - 2)
   9 
  10 number = int(raw_input("Enter the integer:"))
  11 
  12 if number > 0:
  13     result = fibonacci(number)
  14     print "Fibonacci(%d) = %d" % (number, result)
  15 else:
  16     print "Cannot find the fibonacci of a negative number"

   1 #chapter 5.1
   2 #Unpacking sequences
   3 
   4 #create sequences
   5 aString = "abc"
   6 aList = [1,2,3]
   7 aTuple = ("a","b",1)
   8 
   9 #unpacking sequences
  10 print "unpacking string..."
  11 first,second,third = aString
  12 print "String values:", first,second,third
  13 
  14 print "\nunpacking list..."
  15 first,second,third = aList
  16 print "List values:",first,second,third
  17 
  18 print "\nunpacking tuple..."
  19 first,second,third = aTuple
  20 print "Tuple values:",first,second,third
  21 
  22 #swapping two values
  23 x = 3
  24 y = 4
  25 
  26 print "\nBefore swapping:x = %d,y = %d" % (x,y)
  27 x,y = y,x   #swapping variables
  28 print "After swapping:x = %d, y = %d" % (x,y)

   1 #chapter 7.1
   2 #Simple definition of class Time.
   3 
   4 class Time:
   5     """Time abstract data type definition"""
   6     def __init__(self):
   7         """Initializes hour,minute and second to zero"""
   8         self.hour = 0
   9         self.minute = 0
  10         self.second = 0
  11 
  12     def printMilitray(self):
  13         """Prints object of class Time in military format"""
  14         print "%.2d:%.2d:%.2d" % (self.hour,self.minute,self.second)
  15 
  16     def printStandard(self):
  17         """Prints object of class Time in standard format"""
  18 
  19         standardTime = ""
  20 
  21         if self.hour == 0 or self.hour == 12:
  22             standardTime += "12:"
  23         else:
  24             standardTime += "%d:" % (self.hour % 12)
  25 
  26         standardTime += "%.2d:%.2d" % (self.minute,self.second)
  27 
  28         if self.hour < 12:
  29             standardTime += "AM"
  30         else:
  31             standardTime += "PM"
  32 
  33         print standardTime

   1 #chapter 7.2
   2 #Class Time with accessor methods.
   3 
   4 class Time:
   5     """Class Time with accessor methods"""
   6 
   7     def __init__(self):
   8         """Time constructor initializes each data member to zero"""
   9 
  10         self.__hour = 0     #private value,change to _Time__hour.
  11         self._minute = 0    #public value
  12         self._second = 0
  13 
  14     def setTime(self,hour,minute,second):
  15         """Set values of hour,minute,and second"""
  16 
  17         self.setHour( hour )
  18         self.setMinute( minute )
  19         self.setSecond( second )
  20 
  21     def setHour( self,hour):
  22         """Set hour value"""
  23 
  24         if 0 <= hour < 24:
  25             self._hour = hour
  26         else:
  27             raise ValueError,"Invalid hour value: %d" % hour
  28 
  29     def setMinute( self,minute ):
  30         """Set minute value"""
  31 
  32         if 0 <= minute < 60:
  33             self._minute = minute
  34         else:
  35             raise ValueError,"Invalid minute value: %d" % minute
  36 
  37     def setSecond ( self,second ):
  38         """Set second value"""
  39 
  40         if 0 <= senond <60:
  41             self._second = second
  42         else:
  43             raise ValueError,"Invalid second value: %d" % second
  44 
  45     def getHour( self ):
  46         """Get hour value"""
  47 
  48         return self._hour
  49 
  50     def getMinute( self ):
  51         """Get minute value"""
  52 
  53         return self._minute
  54 
  55     def getSecond( self ):
  56         """Get second value"""
  57 
  58         return self._second
  59 
  60     def printMilitray(self):
  61         """Prints object of class Time in military format"""
  62         print "%.2d:%.2d:%.2d" % (self._hour,self._minute,self._second)
  63 
  64     def printStandard(self):
  65         """Prints object of class Time in standard format"""
  66 
  67         standardTime = ""
  68 
  69         if self._hour == 0 or self._hour == 12:
  70             standardTime += "12:"
  71         else:
  72             standardTime += "%d:" % (self._hour % 12)
  73 
  74         standardTime += "%.2d:%.2d" % (self._minute,self._second)
  75 
  76         if self._hour < 12:
  77             standardTime += "AM"
  78         else:
  79             standardTime += "PM"
  80 
  81         print standardTime

   1 #chapter 7.3
   2 #Class Time with default constructor.
   3 #use private value
   4 
   5 class Time:
   6     """Class Time with accessor methods"""
   7 
   8     def __init__(self, hour = 0, minute = 0, second = 0):
   9         """Time constructor initializes each data member to zero"""
  10 
  11         self.setTime( hour, minute, second )
  12 
  13     def setTime(self, hour, minute, second):
  14         """Set values of hour,minute,and second"""
  15 
  16         self.setHour( hour )
  17         self.setMinute( minute )
  18         self.setSecond( second )
  19 
  20     def setHour( self,hour):
  21         """Set hour value"""
  22 
  23         if 0 <= hour < 24:
  24             self.__hour = hour
  25         else:
  26             raise ValueError,"Invalid hour value: %d" % hour
  27 
  28     def setMinute( self,minute ):
  29         """Set minute value"""
  30 
  31         if 0 <= minute < 60:
  32             self.__minute = minute
  33         else:
  34             raise ValueError,"Invalid minute value: %d" % minute
  35 
  36     def setSecond ( self,second ):
  37         """Set second value"""
  38 
  39         if 0 <= senond <60:
  40             self.__second = second
  41         else:
  42             raise ValueError,"Invalid second value: %d" % second
  43 
  44     def getHour( self ):
  45         """Get hour value"""
  46 
  47         return self.__hour
  48 
  49     def getMinute( self ):
  50         """Get minute value"""
  51 
  52         return self.__minute
  53 
  54     def getSecond( self ):
  55         """Get second value"""
  56 
  57         return self.__second
  58 
  59     def printMilitray(self):
  60         """Prints object of class Time in military format"""
  61         print "%.2d:%.2d:%.2d" % (self.__hour,self.__minute,self.__second)
  62 
  63     def printStandard(self):
  64         """Prints object of class Time in standard format"""
  65 
  66         standardTime = ""
  67 
  68         if self.__hour == 0 or self.__hour == 12:
  69             standardTime += "12:"
  70         else:
  71             standardTime += "%d:" % (self.__hour % 12)
  72 
  73         standardTime += "%.2d:%.2d" % (self.__minute,self.__second)
  74 
  75         if self.__hour < 12:
  76             standardTime += "AM"
  77         else:
  78             standardTime += "PM"
  79 
  80         print standardTime

   1 #chapter 7.4
   2 #Class Employee with class attribute count
   3 
   4 class Employee:
   5     """Represents an employee"""
   6 
   7     count = 0   #class attribute
   8 
   9     def __init__( self,first,last ):
  10         """Initializes firstName,lastName and increments count"""
  11 
  12         self.firstName = first
  13         self.lastNmae = last
  14 
  15         Employee.count += 1     #increment class attribute
  16 
  17         print "Employee constructor for %s ,%s" % (self.lastNmae,self.firstName)
  18 
  19     def __del__( self ):
  20         """Decrements count and prints message"""
  21 
  22         Employee.count -= 1     #decrement class attribute
  23 
  24         print "Eemployee destructor for %s, %s" % ( self.lastNmae, self.firstName )

   1 #chapter 8.1
   2 #Representation of phone number in USA format: (xxx) xxx-xxxx.
   3 
   4 class PhoneNumber:
   5     """Simple class to represent phone number in USA format"""
   6 
   7     def __init__( self, number ):
   8         """Accepts string in form (xxx) xxx-xxxx"""
   9 
  10         self.areaCode = number[ 1:4 ]   #3-digit area code
  11         self.exchange = number[ 6:9 ]   #3-digit exchange
  12         self.line = number[ 10:14 ]     #4-digit line
  13 
  14     def __str__( self ):
  15         """Informal string representation"""
  16 
  17         return "(%s) %s-%s" % (self.areaCode, self.exchange, self.line)
  18 
  19 def test():
  20     newNumber = raw_input("Enter phone in the form(123) 456-7890:")
  21     phone = PhoneNumber ( newNumber )
  22     print "the phone number is:"
  23     print phone     #invokes phone.__str__()
  24 
  25 if __name__ == "__main__":
  26     test()

   1 #chapter8.2
   2 #Class Time with customized attribute access.
   3 
   4 class Time:
   5     """Class Time with customized attribute access"""
   6 
   7     def __init__( self, hour = 0, minute = 0, second = 0 ):
   8         """Time constructor initializes each data member to zero"""
   9 
  10         self.hour = hour        #each statement invokes __setattr__
  11         self.minute = minute
  12         self.second = second
  13 
  14     def __setattr__( self, name, value ):
  15         """Assigns a value to an attribute"""
  16 
  17         if name == "hour":
  18             if 0 <= value < 24:
  19                 self.__dict__[ "_hour" ] = value
  20             else:
  21                 raise ValueError, "Invalid hour value: %d" % value
  22         elif name == "minute" or name == "second":
  23                 if 0 <= value < 60:
  24                     self.__dict__[ "_" + name ] = value
  25                 else:
  26                    raise ValueError, "Invalid %s value: %d" % ( name, value )
  27         else:
  28             self.__dict__[ name ] = value
  29 
  30     def __getattr__( self, name ):
  31         """Performs lookup for unrecognized attribute name"""
  32 
  33         if name == "hour":
  34             return self._hour
  35         elif name == "minute":
  36             return self._minute
  37         elif name == "second":
  38             return self._second
  39         else:
  40             raise AttributeError, name
  41 
  42     def __str__( self ):
  43         """Returns Time object string in military format"""
  44 
  45         return "%.2d:%.2d:%.2d" % ( self._hour, self._minute,self._second )

   1 #chapter 9.1
   2 #derived class inheriting from a base class.
   3 
   4 import math
   5 
   6 class Point:
   7     """Class that represents geometric point"""
   8 
   9     def __init__( self, xValue = 0, yValue = 0 ):
  10         """Point constructor takes x and y coordinates"""
  11 
  12         self.x = xValue
  13         self.y = yValue
  14 
  15 class Circle(Point):
  16     """Class that repesents a circle"""
  17 
  18     def __init__( self, x = 0, y = 0, radiusValue = 0.0 ):
  19         """Circle constructor takes x and y coordinates of center point and radius"""
  20 
  21         Point.__init__( self, x, y )    #call base-class constructor
  22         self.radius = float( radiusValue )
  23 
  24     def area ( self ):
  25         """Computes area of a Circle"""
  26 
  27         return math.pi * self.radius ** 2
  28 
  29 #main program
  30 
  31 #examine classes Point and Circle
  32 print "Point bases:",Point.__bases__
  33 print "Circle bases:",Circle.__bases__
  34 
  35 #demonstrate class relationships with built-in function issubclass
  36 print "\nCircle is a subclass of Point:", issubclass(Circle, Point)
  37 print "Point is a subclass of Circle:", issubclass(Point, Circle)
  38 
  39 point = Point(30,50)    #create Point object
  40 circle = Circle(120,89,2.7) #create Circle object
  41 
  42 #demonstrate object relationship with built-in function isinstance
  43 print "\ncircle is a Point object:", isinstance( circle, Point )
  44 print "point is a Circle object:", isinstance( point, Circle )
  45 
  46 #print Point and Circle object
  47 print "\npoint members:\n\t", point.__dict__
  48 print "circle members:\n\t", circle.__dict__
  49 
  50 print "\nArea of circle is :", circle.area()

   1 #chapter9.2
   2 #Overriding base-class methods
   3 
   4 class Employee:
   5     """Class to represent an employee"""
   6 
   7     def __init__( self, first, last ):
   8         """Employee constructor takes first and last name"""
   9 
  10         self.firstName = first
  11         self.lastName = last
  12 
  13     def __str__( self ):
  14         """String representation of an Employee"""
  15 
  16         return "%s %s" % ( self.firstName, self.lastName )
  17 
  18 class HourlyWorker ( Employee ):
  19     """Class to represent an employee paid by hour"""
  20 
  21     def __init__( self, first, last, initHours, initWage ):
  22         """Constructor for HourlyWorker,takes first and last name,
  23         initial number of hours and initial wage"""
  24 
  25         Employee.__init__( self, first, last )
  26         self.hours = float( initHours )
  27         self.wage = float( initWage )
  28 
  29     def getPay( self ):
  30         """Calculates HourlyWorker's weekly pay"""
  31 
  32         return self.hours * self.wage
  33 
  34     def __str__( self ):
  35         """String representation of HourlyWorker,overriding \
  36         the __str__ method of Employee """
  37 
  38         print "HourlyWorker.__str__ is executing"
  39 
  40         return "%s is an hourly worker with pay of $%.2f" % \
               ( Employee.__str__( self ), self.getPay() )
  41         #Employee.__str__( self ) call the base class to print firstName and lastName.
  42         #self.getPay() a new function.
  43 
  44 #main program
  45 
  46 hourly = HourlyWorker("bob", "smith", 40.0, 10.00 )
  47 
  48 #invoke __str__ method several ways
  49 print "Calling __str__ several ways ..."
  50 print hourly    #invoke __str__ implicitly
  51 print hourly.__str__()  #invoke __str__ explicitly
  52 print HourlyWorker.__str__( hourly ) #explicit, unbound call

   1 #chapter9.3
   2 #Creating a class hierarchy with an abstract base class.
   3 
   4 class Employee:
   5     """Abstract base class Employee"""
   6 
   7     def __init__( self, first, last ):
   8         """Employee constructor,takes first name and last name\
   9         NOTE: Cannot create object of class Employee"""
  10 
  11         if self.__class__ == Employee:
  12             raise NotImplementedError, "Cannot create object of class Employee"
  13 
  14         self.firstName = first
  15         self.lastName = last
  16 
  17     def __str__( self ):
  18         """String representation of Employee"""
  19 
  20         return "%s %s" % ( self.firstName, self.lastName )
  21 
  22     def _checkPositive( self, value ):
  23         """Utility method to ensure a value is positive"""
  24 
  25         if value < 0:
  26             raise ValueError, "Attribute value (%s) must be positive" % value
  27         else:
  28             return value
  29 
  30     def earnings( self ):
  31         """Abstract method;derived classes must override"""
  32 
  33         raise NotImplementedError, "Cannot call abstract method"
  34 
  35 class Boss( Employee ):
  36     """Boss class, inherits from Employee"""
  37 
  38     def __init__( self, first, last, salary ):
  39         """Boss constructor,takes first and last names and salary"""
  40 
  41         Employee.__init__( self, first, last )
  42         self.weeklySalary = self._checkPositive( float( salary ) )
  43 
  44     def earnings( self ):
  45         """Compute the boss's pay"""
  46 
  47         return self.weeklySalary
  48 
  49     def __str__( self ):
  50         """String representation of Boss"""
  51 
  52         return "%17s: %s" % ( "Boss", Employee.__str__(self) )
  53 
  54 class CommissionWorker ( Employee ):
  55     """CommissionWorker class,inherits from Employee"""
  56 
  57     def __init__( self, first, last, salary, commission, quantity ):
  58         """CommissionWorker constructor,takes first and last names,\
  59         salary,commission and quantity"""
  60 
  61         Employee.__init__( self, first, last )
  62         self.salary = self._checkPositive( float( salary ))
  63         self.commission = self._checkPositive( float( commission))
  64         self.quantity = self._checkPositive( quantity )
  65 
  66     def earnings( self ):
  67         """Compute the CommissionWorker's pay"""
  68 
  69         return self.salary + self.commission * self.quantity
  70 
  71     def __str__( self ):
  72         """Srting representation of CommissionWorker"""
  73 
  74         return "%17s: %s" % ("Commission Worker", Employee.__str__( self ))
  75 
  76 class PieceWorker ( Employee ):
  77     """PieceWorker class,inherits from Employee"""
  78 
  79     def __init__( self, first, last, wage, quantity ):
  80         """PieceWorker constructor,takes first and last names,wage\
  81          per piece and quantity"""
  82 
  83         Employee.__init__( self, first,last )
  84         self.wagePerPiece = self._checkPositive( float( wage ) )
  85         self.quantity = self._checkPositive( quantity )
  86 
  87     def earnings( self ):
  88         """Compute PieceWorker's pay"""
  89 
  90         return self.quantity * self.wagePerPiece
  91 
  92     def __str__( self ):
  93         """Srting representation of PieceWorker"""
  94 
  95         return "%17s: %s" % ( "PieceWorker", Employee.__str__( self ) )
  96 
  97 class HourlyWorker( Employee ):
  98     """HourlyWorker class, inherits from Employee"""
  99 
 100     def __init__( self, first, last, wage, hours ):
 101         """HourlyWorker constructor,takes first and last names,wage \
 102         per hour and hours worked"""
 103 
 104         Employee.__init__( self, first, last )
 105         self.wage = self._checkPositive( float( wage ) )
 106         self.hours = self._checkPositive( float( hours ) )
 107 
 108     def earnings( self ):
 109         """Compute HourlyWorker's pay"""
 110 
 111         if self.hours <= 40:
 112             return self.wage * self.hours
 113         else:
 114             return 40 * self.wage + ( self.hours - 40 ) * self.wage * 1.5
 115 
 116     def __str__( self ):
 117         """Srting representation of HourlyWorker"""
 118 
 119         return "%17s: %s" % ( "HourlyWorker", Employee.__str__( self ) )
 120 
 121 #main program
 122 
 123 #create list of Employee
 124 employees = [ Boss( "John", "Smith", 800.00 ),
 125              CommissionWorker( "Sue", "Jones", 200.0, 3.0, 150 ),
 126              PieceWorker( "Bob", "Lewis", 2.5, 200 ),
 127              HourlyWorker( "Karem", "Price", 13.75, 40 ) ]
 128 
 129 #print Employee and compute earnings
 130 for employee in employees:
 131     print "%s earned $%.2f" % ( employee, employee.earnings() )

   1 #chapter 9.4
   2 #Class Employee with a static method.
   3 
   4 class Employee:
   5     """Employee class with static method isCrowded"""
   6 
   7     numberOfEmployees = 0   #number of Employee created
   8     maxEmployees = 10       #maximun number of comfortable employees
   9 
  10     def isCrowded():
  11         """Static method returns true if the employee are crowded"""
  12 
  13         return Employee.numberOfEmployees > Employee.maxEmployees
  14 
  15 #create static method
  16     isCrowded = staticmethod( isCrowded )
  17 
  18     def __init__( self, firstName, lastName ):
  19         """Employee constructor,takes first and last names"""
  20 
  21         self.first = firstName
  22         self.last = lastName
  23         Employee.numberOfEmployees += 1
  24 
  25     def __del__( self ):
  26         """Employee destructor"""
  27 
  28         Employee.numberOfEmployees -= 1
  29 
  30     def __str__( self ):
  31         """String representation of Employee"""
  32 
  33         return "%s %s" % (self.first, self.last)
  34 
  35 #main program
  36 
  37 def main():
  38     answers = [ "No", "Yes" ]   #responses to isCrowded
  39     employeeList = []           #list of objects of class Employee
  40 
  41     #call static method using class
  42     print "Employee are crowded?",
  43     print answers [ Employee.isCrowded() ]
  44 
  45     print "\nCreating 11 objects of class Employee..."
  46 
  47     #create 11 objects of class Employee
  48     for i in range(11):
  49         employeeList.append( Employee( "John","Doe" + str(i) ) )
  50 
  51     #call static method using object
  52 
  53     print "Employee are crowded?",
  54     print answers [ employeeList[i].isCrowded() ]
  55 
  56     print "\nremoving one employee..."
  57     del employeeList[0]
  58 
  59     print "Employees are crowded?", answers [ Employee.isCrowded() ]
  60 
  61 if __name__ == "__main__":
  62         main()

   1 #chapter 9.5
   2 #Class that defines method __getattribute__
   3 
   4 class DemoAccess( object ):
   5     """class to demonstrate when method __getattribute__ executes"""
   6 
   7     def __init__(self):
   8         """demoaccess constructor,initializes attribute value"""
   9 
  10         self.value = 1
  11 
  12     def __getattribute__( self, name ):
  13         """Executes form every attribute access"""
  14 
  15         print "__getattribute__ executing..."
  16         print "\nClient attempt to access attribute:",name
  17 
  18         return object.__getattribute__( self, name )
  19 
  20     def __getattr__( self, name ):
  21         """Executes when client access attribute not in __dict__"""
  22 
  23         print "__getattr__ executing..."
  24         print "\tClient attempt to access non-existent attribute:", name
  25 
  26         raise AttributeError, "Object has no attribute %s " % name

   1 #chapter 9.6
   2 #simple class with slots
   3 
   4 class PointWithoutSlots:
   5     """program can add attribute to objects of this class"""
   6 
   7     def __init__( self, xValue = 0.0, yValue = 0.0 ):
   8 
   9         self.x = float( xValue )
  10         self.y = float( yValue )
  11 
  12 class PointWithSlots( object ):
  13     """program cannot add attribute to objects of this class"""
  14 
  15 #PointWithSlots objects can contain only attributes x and y
  16     __slots__ = [ "x", "y" ]
  17 
  18     def __init__( self, xValue = 0.0, yValue = 0.0 ):
  19 
  20         self.x = float( xValue )
  21         self.y = float( yValue )
  22 
  23 #main program
  24 
  25 def main():
  26     noSlots = PointWithoutSlots()
  27     slots = PointWithSlots()
  28 
  29     for point in [ noSlots, slots ]:
  30         print "\nProcessing an object of class", point.__class__
  31 
  32         print "The current value of point.x is:", point.x
  33         newValue = float( raw_input("Eenter new x coordinate:") )
  34         print "Attempting to set new x-coordinate value..."
  35 
  36 #logic error: create new attribute called X, instead of changing the value of attribute X
  37         point.X = newValue
  38 
  39 #output unchanged attribute x
  40         print "the new value of point.x is :", point.x
  41 
  42 if __name__ == "__main__":
  43     main()

   1 #chapter 9.7
   2 #Class Time with properties
   3 
   4 class Time( object ):
   5     """Class Time with hour, minute and second properties"""
   6 
   7     def __init__( self, hourValue, minuteValue, secondValue ):
   8         """Time constructor,takes hour, minute and second"""
   9 
  10         self.__hour = hourValue
  11         self.__minute = minuteValue
  12         self.__second = secondValue
  13 
  14     def __str__( self ):
  15         """String representation of an object of class Time"""
  16 
  17         return "%.2d:%.2d:%.2d" % ( self.__hour, self.__minute, self.__second )
  18 
  19     def deleteValue( self ):
  20         """Delete method for Time properties"""
  21 
  22         raise TypeError, "Cannot delete attribute"
  23 
  24     def setHour( self, value ):
  25         """set method for hour attribute"""
  26 
  27         if 0 <= value < 24:
  28             self.__hour =value
  29         else:
  30             raise ValueError, "Hour (%d) must be in range 0-23, inclusive" % value
  31 
  32     def getHour( self ):
  33         """get method for hour attribute"""
  34 
  35         return self.__hour
  36 
  37 #create hour property.can use "time.hour = 11" to set the hour's value or "print time.hour" to print hour's value.
  38     hour = property( getHour,setHour,deleteValue, "hour" )
  39 
  40     def setMinute( self, value ):
  41         """set method for minute attribute"""
  42 
  43         if 0 <= value < 60:
  44             self.__minute =value
  45         else:
  46             raise ValueError, "Minute (%d) must be in range 0-59, inclusive" % value
  47 
  48     def getMinute( self ):
  49         """get method for minute attribute"""
  50 
  51         return self.__minute
  52 
  53 #create minute property
  54     minute = property( getMinute, setMinute, deleteValue, "minute" )
  55 
  56     def setSecond( self, value ):
  57         """set method for second attribute"""
  58 
  59         if 0 <= value < 60:
  60             self.__second =value
  61         else:
  62             raise ValueError, "Second (%d) must be in range 0-59, inclusive" % value
  63 
  64     def getSecond( self ):
  65         """get method for second attribute"""
  66 
  67         return self.__second
  68 
  69 #create second property
  70     second = property( getSecond, setSecond, deleteValue, "second" )

   1 #chapter 10.1
   2 #Label demonstration.
   3 
   4 from Tkinter import *
   5 
   6 class LabelDemo( Frame ):
   7     """Demonstrate Labels"""
   8 
   9     def __init__( self ):
  10         """Create three labels and pack them"""
  11 
  12         Frame.__init__( self,)  #initializes Frame object
  13 
  14 #frame fills all available space
  15         self.pack( expand = YES, fill = BOTH )
  16         self.master.title( "myLabel" )
  17 
  18         self.Label1 = Label( self, text = "Label with text" )
  19 #resize frame to accommodate Label
  20         self.Label1.pack()
  21 
  22         self.Label2 = Label( self, text = "Labels with text and bitmap" )
  23 
  24 #insert Lable1 against left side of frame
  25         self.Label2.pack( side = LEFT )
  26 
  27 #using default bitmap image as label
  28         self.Label3 = Label( self, bitmap = "warning" )
  29         self.Label3.pack( side = LEFT )
  30 
  31 def main():
  32     LabelDemo().mainloop()  #starts event loop
  33 
  34 if __name__ == "__main__":
  35     main()

   1 # chapter 10.2
   2 #Entry components and event binding demostration
   3 
   4 from Tkinter import *
   5 from tkMessageBox import *
   6 
   7 class EntryDemo( Frame ):
   8 
   9     def __init__( self ):
  10         """create,pack and bind events to four Entrys"""
  11 
  12         Frame.__init__( self )
  13         self.pack( expand = YES, fill = BOTH )
  14         self.master.title( "Testing Entry Components")
  15         self.master.geometry( "325x100" )    #width X length
  16 
  17         self.frame1 = Frame( self )
  18         self.frame1.pack( pady = 5 )
  19 
  20         self.text1 = Entry( self.frame1, name = "text1" )
  21 
  22 #bind the Entry component to event
  23         self.text1.bind( "<Return>", self.showContents )
  24         self.text1.pack( side = LEFT, padx = 5 )
  25 
  26         self.text2 = Entry( self.frame1, name = "text2" )
  27 
  28 #insert text into Entry component text2
  29         self.text2.insert( INSERT, "Enter text here" )
  30         self.text2.bind( "<Return>", self.showContents )
  31         self.text2.pack( side = LEFT, padx = 5 )
  32 
  33         self.frame2 = Frame( self )
  34         self.frame2.pack ( pady = 5 )
  35 
  36         self.text3 = Entry( self.frame2, name = "text3" )
  37         self.text3.insert( INSERT, "uneditable text field")
  38 
  39 #probibit user from altering text in Entry component text3
  40         self.text3.config( state =DISABLED )
  41         self.text3.bind( "<Return>", self.showContents )
  42         self.text3.pack( side = LEFT, padx = 5 )
  43 
  44 #text in Entry component text4 appears as *
  45         self.text4 = Entry( self.frame2, name = "text4", show = "*" )
  46         self.text4.insert( INSERT, "Hidden text" )
  47         self.text4.bind( "<Return>",self.showContents )
  48         self.text4.pack( side = LEFT,padx = 5 )
  49 
  50     def showContents( self,event ):
  51         """disaplay the contents of the Entry"""
  52 
  53 #acquire name of Entry component that generated event
  54         theName = event.widget.winfo_name()
  55 
  56 #acquire contents of Entry component that generated event
  57         theContents = event.widget.get()
  58         showinfo( "Message",theName + ":" + theContents )
  59 
  60 def main():
  61     EntryDemo().mainloop()
  62 
  63 if __name__ == "__main__":
  64     main()

   1 #chapger10.3
   2 #Button demonstration
   3 
   4 from Tkinter import *
   5 from tkMessageBox import *
   6 
   7 class PlainAndFancy( Frame ):
   8     """Create one plain and one fancy button"""
   9 
  10     def __init__( self ):
  11         """Create two buttons,pack them and bind events"""
  12 
  13         Frame.__init__( self )
  14         self.pack( expand = YES , fill = BOTH )
  15         self.master.title( "Buttons" )
  16 
  17         #create button with text
  18         self.plainButton = Button( self, text = "Plain Button", fg = "red", bg = "blue", command = self.pressedPlain )
  19         self.plainButton.bind( "<Enter>", self.rolloverEnter )
  20         self.plainButton.bind( "<Leave>", self.rolloverLeave )
  21         self.plainButton.pack( side = LEFT, padx = 5, pady = 5 )
  22 
  23         #create button with image
  24         self.myImage = PhotoImage( file = "c:\logo1.gif" )
  25         self.fancyButton = Button( self, image = self.myImage, bg = "blue", command = self.pressedFancy )
  26         self.fancyButton.bind( "<Enter>", self.rolloverEnter )
  27         self.fancyButton.bind( "<Leave>", self.rolloverLeave )
  28         self.fancyButton.pack( side = LEFT, padx = 5, pady = 5 )
  29 
  30     def pressedPlain( self ):
  31         showinfo( "Message", "You pressed:Plain Button" )
  32 
  33     def pressedFancy( self ):
  34         showinfo( "Message", "You pressed:Fancy Button" )
  35 
  36     def rolloverEnter ( self, event ):
  37         event.widget.config( relief = GROOVE )
  38 
  39     def rolloverLeave ( self, event ):
  40         event.widget.config( relief = RAISED )
  41 
  42 def main():
  43     PlainAndFancy().mainloop()
  44 
  45 if __name__=="__main__":
  46     main()

   1 #chapter10.4
   2 #Checkbuttons demostration.
   3 
   4 from Tkinter import *
   5 
   6 class CheckFont( Frame ):
   7     """An area of text with Checkbutton controlled font"""
   8 
   9     def __init__( self ):
  10         """Create an Entry and two Checkbuttons"""
  11 
  12         Frame.__init__( self )
  13         self.pack( expand = YES, fill = BOTH )
  14         self.master.title( "Checkbutton Demo" )
  15 
  16         self.frame1 = Frame( self )
  17         self.frame1.pack()
  18 
  19         self.text = Entry( self.frame1, width = 40, font = "Arial 10" )
  20         self.text.insert ( INSERT, "Watch the font style change" )
  21         self.text.pack( padx = 5, pady = 5 )
  22 
  23         self.frame2 = Frame( self )
  24         self.frame2.pack()
  25 
  26         #Create boolean variable
  27         self.boldOn = BooleanVar()
  28 
  29         #Create "Bold" checkbutton
  30         self.checkBold = Checkbutton( self.frame2, text = "Bold", variable = self.boldOn,
  31                                       command = self.changeFont )
  32         self.checkBold.pack( side = LEFT, padx = 5, pady = 5 )
  33 
  34         #Create boolean variable
  35         self.italicOn = BooleanVar()
  36 
  37         #Create "Italic" checkbutton
  38         self.checkItalic = Checkbutton ( self.frame2, text = "Italic", variable = self.italicOn,
  39                                          command = self.changeFont )
  40         self.checkItalic.pack( side = LEFT, padx =5, pady = 5 )
  41 
  42     def changeFont( self ):
  43         """Change the font based on selected Checkbuttons"""
  44 
  45         desiredFont = "Arial 10"
  46 
  47         if self.boldOn.get():
  48             desiredFont += " bold"
  49 
  50         if self.italicOn.get():
  51             desiredFont += " italic"
  52 
  53         self.text.config( font = desiredFont )
  54 
  55 def main():
  56     CheckFont().mainloop()
  57 
  58 if __name__ =="__main__":
  59     main()

   1 #chapter10.5
   2 #Radiobuttons demonstration.
   3 
   4 from Tkinter import *
   5 
   6 class RadioFont( Frame ):
   7     """An area of text with Radiobutton controlled font"""
   8 
   9     def __init__( self ):
  10         """Create an Entry and Four Radiobuttons"""
  11 
  12         Frame.__init__( self )
  13         self.pack( expand = YES, fill = BOTH )
  14         self.master.title( "Radiobutton Demo" )
  15 
  16         self.frame1 = Frame( self )
  17         self.frame1.pack()
  18 
  19         self.text = Entry( self.frame1, width = 40, font = "Arial 10" )
  20         self.text.insert( INSERT, "Watch the font style change" )
  21         self.text.pack( padx = 5, pady = 5 )
  22 
  23         self.frame2 = Frame( self )
  24         self.frame2.pack()
  25 
  26         fontSelections = [ "Plain", "Bold", "Italic", "Bold/Italic" ]
  27         self.chosenFont = StringVar()
  28 
  29         #initial selection
  30         self.chosenFont.set( fontSelections [ 0 ] )
  31 
  32         #create group of Radiobutton components with same variable
  33         for style in fontSelections:
  34             aButton = Radiobutton( self.frame2, text = style, variable = self.chosenFont,
  35                                value = style, command = self.changeFont )
  36             aButton.pack( side = LEFT, padx = 5, pady = 5 )
  37 
  38     def changeFont( self ):
  39         """change the font based on selected Radiobutton"""
  40 
  41         desiredFont = "Arial 10"
  42 
  43         if self.chosenFont.get() == "Bold":
  44             desiredFont += " bold"
  45         elif self.chosenFont.get == " Italic":
  46             desiredFont += " italic"
  47         elif self.chosenFont.get() == "Bold/Italic":
  48             desiredFont += " bold italic"
  49 
  50         self.text.config( font = desiredFont )
  51 
  52 def main():
  53     RadioFont().mainloop()
  54 
  55 if __name__ == "__main__":
  56     main()