Python Programming: An Introduction To Computer Science

Transcription

1 Pytho Programmig: A Itroductio To Computer Sciece Chapter 10 Defiig Classes Pytho Programmig, 2/e 1

2 Objectives To appreciate how defiig ew classes ca provide structure for a complex program. To be able to read ad write Pytho class defiitios. To uderstad the cocept of ecapsulatio ad how it cotributes to buildig modular ad maitaiable programs. Pytho Programmig, 2/e 2

3 Objectives To be able to write programs ivolvig simple class defiitios. To be able to write iteractive graphics programs ivolvig ovel (programmer desiged) widgets. Pytho Programmig, 2/e 3

4 Quick Review of Objects I the last three chapters we ve developed techiques for structurig the computatios of the program. We ll ow take a look at techiques for structurig the data that our programs use. So far, our programs have made use of objects created from pre-defied class such as Circle. I this chapter we ll lear how to write our ow classes to create ovel objects. Pytho Programmig, 2/e 4

5 Quick Review of Objects I chapter five a object was defied as a active data type that kows stuff ad ca do stuff. More precisely, a object cosists of: 1. A collectio of related iformatio. 2. A set of operatios to maipulate that iformatio. Pytho Programmig, 2/e 5

6 Quick Review of Objects The iformatio is stored iside the object i istace variables. The operatios, called methods, are fuctios that live iside the object. Collectively, the istace variables ad methods are called the attributes of a object. Pytho Programmig, 2/e 6

7 Quick Review of Objects A Circle object will have istace variables such as ceter, which remembers the ceter poit of the circle, ad radius, which stores the legth of the circle s radius. The draw method examies the ceter ad radius to decide which pixels i a widow should be colored. Pytho Programmig, 2/e 7

8 Quick Review of Objects The move method will chage the value of ceter to reflect the ew positio of the circle. All objects are said to be a istace of some class. The class of a object determies which attributes the object will have. A class is a descriptio of what its istaces will kow ad do. Pytho Programmig, 2/e 8

9 Quick Review of Objects New objects are created from a class by ivokig a costructor. You ca thik of the class itself as a sort of factory for stampig out ew istaces. Cosider makig a ew circle object: mycircle = Circle(Poit(0,0),20) Circle, the ame of the class, is used to ivoke the costructor. Pytho Programmig, 2/e 9

10 Quick Review of Objects mycircle = Circle(Poit(0,0), 20) This statemet creates a ew Circle istace ad stores a referece to it i the variable mycircle. The parameters to the costructor are used to iitialize some of the istace variables (ceter ad radius) iside mycircle. Pytho Programmig, 2/e 10

11 Quick Review of Objects mycircle = Circle(Poit(0,0), 20) Oce the istace has bee created, it ca be maipulated by callig o its methods: mycircle.draw(wi) mycircle.move(dx,dy) Pytho Programmig, 2/e 11

12 Caoball Program Specificatio Let s try to write a program that simulates the flight of a caoball or other projectile. We re iterested i how far the caoball will travel whe fired at various lauch agles ad iitial velocities. Pytho Programmig, 2/e 12

13 Caoball Program Specificatio The iput to the program will be the lauch agle (i degrees), the iitial velocity (i meters per secod), ad the iitial height (i meters) of the caoball. The output will be the distace that the projectile travels before strikig the groud (i meters). Pytho Programmig, 2/e 13

14 Caoball Program Specificatio The acceleratio of gravity ear the earth s surface is roughly 9.8 m/s/s. If a object is throw straight up at 20 m/s, after oe secod it will be travelig upwards at 10.2 m/s. After aother secod, its speed will be.4 m/s. Shortly after that the object will start comig back dow to earth. Pytho Programmig, 2/e 14

15 Caoball Program Specificatio Usig calculus, we could derive a formula that gives the positio of the caoball at ay momet of its flight. However, we ll solve this problem with simulatio, a little geometry, ad the fact that the distace a object travels i a certai amout of time is equal to its rate times the amout of time (d = rt). Pytho Programmig, 2/e 15

16 Desigig the Program Give the ature of the problem, it s obvious we eed to cosider the flight of the caoball i two dimesios: it s height ad the distace it travels. Let s thik of the positio of the caoball as the poit (x, y) where x is the distace from the startig poit ad y is the height above the groud. Pytho Programmig, 2/e 16

17 Desigig the Program Suppose the ball starts at positio (0,0), ad we wat to check its positio every teth of a secod. I that time iterval it will have moved some distace upward (positive y) ad some distace forward (positive x). The exact distace will be determied by the velocity i that directio. Pytho Programmig, 2/e 17

18 Desigig the Program Sice we are igorig wid resistace, x will remai costat through the flight. However, y will chage over time due to gravity. The y velocity will start out positive ad the become egative as the ball starts to fall. Pytho Programmig, 2/e 18

19 Desigig the Program Iput the simulatio parameters: agle, velocity, height, iterval. Calculate the iitial positio of the caoball: xpos, ypos Calculate the iitial velocities of the caoball: xvel, yvel While the caoball is still flyig: Update the values of xpos, ypos, ad yvel for iterval secods further ito the flight Output the distace traveled as xpos Pytho Programmig, 2/e 19

20 Desigig the Program Usig step-wise refiemet: def mai(): agle = eval(iput("eter the lauch agle (i degrees): ")) vel = eval(iput("eter the iitial velocity (i meters/sec): ")) h0 = eval(iput("eter the iitial height (i meters): ")) time = eval(iput("eter the time iterval betwee positio calculatios: ")) Calculatig the iitial positio for the caoball is also easy. It s at distace 0 ad height h0! xpos = 0 ypos = h0 Pytho Programmig, 2/e 20

21 Desigig the Program If we kow the magitude of the velocity ad the agle theta, we ca calculate yvel=velocity*si(theta)ad xvel=velocity*cos(theta). Pytho Programmig, 2/e 21

22 Desigig the Program Our iput agle is i degrees, ad the Pytho math library uses radias, so theta = (p*agle)/180. theta = (agle * pi)/180.0 xvel = vel * cos(theta) yvel = vel * si(theta) I the mai loop, we wat to keep updatig the positio of the ball util it reaches the groud: while ypos >= 0.0: We used >= 0 so the loop will start if the ball starts out o the groud. Pytho Programmig, 2/e 22

23 Desigig the Program Each time through the loop we wat to update the state of the caoball to move it time secods farther. Sice we assume there is o wid resistace, xvel remais costat. Say a ball is travelig at 30 m/s ad is 50 m from the firig poit. I oe secod it will be meters away. If the time icremet is.1 secod it will be *.1 = 53 meters. xpos = xpos + time * xvel Pytho Programmig, 2/e 23

24 Desigig the Program Workig with yvel is slightly more complicated sice gravity causes the y- velocity to chage over time. Each secod, yvel must decrease by 9.8 m/s, the acceleratio due to gravity. I 0.1 secods the velocity will be 0.1(9.8) =.98 m/s. yvel1 = yvel * time Pytho Programmig, 2/e 24

25 Desigig the Programs To calculate how far the caoball travels over the iterval, we eed to calculate its average vertical velocity over the iterval. Sice the velocity due to gravity is costat, it is simply the average of the startig ad edig velocities times the legth of the iterval: ypos = ypos + time * (yvel + yvel1)/2.0 Pytho Programmig, 2/e 25

26 Desigig Programs # cball1.py # Simulatio of the flight of a cao ball (or other projectile) # This versio is ot modularized. from math import pi, si, cos def mai(): agle = eval(iput("eter the lauch agle (i degrees): ")) vel = eval(iput("eter the iitial velocity (i meters/sec): ")) h0 = eval(iput("eter the iitial height (i meters): ")) time = eval(iput("eter the time iterval betwee positio calculatios: ")) mai() radias = (agle * pi)/180.0 xpos = 0 ypos = h0 xvel = vel * cos(radias) yvel = vel * si(radias) while ypos >= 0: xpos = xpos + time * xvel yvel1 = yvel * time ypos = ypos + time * (yvel + yvel1)/2.0 yvel = yvel1 prit("\distace traveled: {0:0.1f} meters.".format(xpos) Pytho Programmig, 2/e 26

27 Modularizig the Program Durig program developmet, we employed step-wise refiemet (ad top-dow desig), but did ot divide the program ito fuctios. While this program is fairly short, it is complex due to the umber of variables. Pytho Programmig, 2/e 27

28 Modularizig the Program def mai(): agle, vel, h0, time = getiputs() xpos, ypos = 0, h0 xvel, yvel = getxycompoets(vel, agle) while ypos >= 0: xpos, ypos, yvel = updatecaoball(time, xpos, ypos, xvel, yvel) prit("\distace traveled: {0:0.1f} meters.".format(xpos) It should be obvious what each of these helper fuctios does based o their ame ad the origial program code. Pytho Programmig, 2/e 28

29 Modularizig the Program This versio of the program is more cocise! The umber of variables has bee reduced from 10 to 8, sice theta ad yvel1 are local to getxycompoets ad updatecaoball, respectively. This may be simpler, but keepig track of the caoball still requires four pieces of iformatio, three of which chage from momet to momet! Pytho Programmig, 2/e 29

30 Modularizig the Program All four variables, plus time, are eeded to compute the ew values of the three that chage. This gives us a fuctio with five parameters ad three retur values. Yuck! There must be a better way! Pytho Programmig, 2/e 30

31 Modularizig the Program There is a sigle real-world caoball object, but it requires four pieces of iformatio: xpos, ypos, xvel,x ad yvel. Suppose there was a Projectile class that uderstood the physics of objects like caoballs. A algorithm usig this approach would create ad update a object stored i a sigle variable. Pytho Programmig, 2/e 31

32 Modularizig the Program Usig our object-based approach: def mai(): agle, vel, h0, time = getiputs() cball = Projectile(agle, vel, h0) while cball.gety() >= 0: cball.update(time) prit("\distace traveled: {0:0.1f} meters.".format(cball.getx())) mai() To make this work we eed a Projectile class that implemets the methods update, getx, ad gety. Pytho Programmig, 2/e 32

33 Example: Multi-Sided Dice A ormal die (sigular of dice) is a cube with six faces, each with a umber from oe to six. Some games use special dice with a differet umber of sides. Let s desig a geeric class MSDie to model multi-sided dice. Pytho Programmig, 2/e 33

34 Example: Multi-Sided Dice Each MSDie object will kow two thigs: How may sides it has. It s curret value Whe a ew MSDie is created, we specify, the umber of sides it will have. Pytho Programmig, 2/e 34

35 Example: Multi-Sided Dice We have three methods that we ca use to operate o the die: roll set the die to a radom value betwee 1 ad, iclusive. setvalue set the die to a specific value (i.e. cheat) getvalue see what the curret value is. Pytho Programmig, 2/e 35

36 Example: Multi-Sided Dice >>> die1 = MSDie(6) >>> die1.getvalue() 1 >>> die1.roll() >>> die1.getvalue() 5 >>> die2 = MSDie(13) >>> die2.getvalue() 1 >>> die2.roll() >>> die2.getvalue() 9 >>> die2.setvalue(8) >>> die2.getvalue() 8 Pytho Programmig, 2/e 36

37 Example: Multi-Sided Dice Usig our object-orieted vocabulary, we create a die by ivokig the MSDie costructor ad providig the umber of sides as a parameter. Our die objects will keep track of this umber iterally as a istace variable. Aother istace variable is used to keep the curret value of the die. We iitially set the value of the die to be 1 because that value is valid for ay die. That value ca be chaged by the roll ad setroll methods, ad retured by the getvalue method. Pytho Programmig, 2/e 37

38 Example: Multi-Sided Dice # msdie.py # Class defiitio for a -sided die. from radom import radrage class MSDie: def iit (self, sides): self.sides = sides self.value = 1 def roll(self): self.value = radrage(1, self.sides+1) def getvalue(self): retur self.value def setvalue(self, value): self.value = value Pytho Programmig, 2/e 38

39 Example: Multi-Sided Dice Class defiitios have the form class <class-ame>: <method-defiitios> Methods look a lot like fuctios! Placig the fuctio iside a class makes it a method of the class, rather tha a stad-aloe fuctio. The first parameter of a method is always amed self, which is a referece to the object o which the method is actig. Pytho Programmig, 2/e 39

40 Example: Multi-Sided Dice Suppose we have a mai fuctio that executes die1.setvalue(8). Just as i fuctio calls, Pytho executes the followig four-step sequece: mai suspeds at the poit of the method applicatio. Pytho locates the appropriate method defiitio iside the class of the object to which the method is beig applied. Here, cotrol is trasferred to the setvalue method i the MSDie class, sice die1 is a istace of MSDie. Pytho Programmig, 2/e 40

41 Example: Multi-Sided Dice The formal parameters of the method get assiged the values supplied by the actual parameters of the call. I the case of a method call, the first formal parameter refers to the object: self = die1 value = 8 The body of the method is executed. Pytho Programmig, 2/e 41

42 Example: Multi-Sided Dice Cotrol returs to the poit just after where the method was called. I this case, it is immediately followig die1.setvalue(8). Methods are called with oe parameter, but the method defiitio itself icludes the self parameter as well as the actual parameter. Pytho Programmig, 2/e 42

43 Example: Multi-Sided Dice The self parameter is a bookkeepig detail. We ca refer to the first formal parameter as the self parameter ad other parameters as ormal parameters. So, we could say setvalue uses oe ormal parameter. Pytho Programmig, 2/e 43

44 Example: Multi-Sided Dice Pytho Programmig, 2/e 44

45 Example: Multi-Sided Dice Objects cotai their ow data. Istace variables provide storage locatios iside of a object. Istace variables are accessed by ame usig our dot otatio: <object>.<istace-var> Lookig at setvalue, we see self.value refers to the istace variable value iside the object. Each MSDie object has its ow value. Pytho Programmig, 2/e 45

46 Example: Multi-Sided Dice Certai methods have special meaig. These methods have ames that start ad ed with two _ s. iit is the object cotructor. Pytho calls this method to iitialize a ew MSDie. iit provides iitial values for the istace variables of a object. Pytho Programmig, 2/e 46

47 Example: Multi-Sided Dice Outside the class, the costructor is referred to by the class ame: die1 = MSDie(6) Whe this statemet is executed, a ew MSDie object is created ad iit is executed o that object. The et result is that die1.sides is set to 6 ad die1.value is set to 1. Pytho Programmig, 2/e 47

48 Example: Multi-Sided Dice Istace variables ca remember the state of a particular object, ad this iformatio ca be passed aroud the program as part of the object. This is differet tha local fuctio variables, whose values disappear whe the fuctio termiates. Pytho Programmig, 2/e 48

49 Example: The Projectile Class This class will eed a costructor to iitialize istace variables, a update method to chage the state of the projectile, ad getx ad gety methods that ca report the curret positio. I the mai program, a caoball ca be created from the iitial agle, velocity, ad height: cball = Projectile(agle, vel, h0) Pytho Programmig, 2/e 49

50 Example: The Projectile Class The Projectile class must have a iit method that will use these values to iitialize the istace variables of cball. These values will be calculated usig the same formulas as before. Pytho Programmig, 2/e 50

51 Example: The Projectile Class class Projectile: def iit (self, agle, velocity, height): self.xpos = 0.0 self.ypos = height theta = pi * agle / self.xvel = velocity * cos(theta) self.yvel = velocity * si(theta) We ve created four istace variables (self.???). Sice the value of theta is ot eeded later, it is a ormal fuctio variable. Pytho Programmig, 2/e 51

52 Example: The Projectile Class The methods to access the X ad Y positio are straightforward. def gety(self): retur self.ypos def getx(self): retur self.xpos Pytho Programmig, 2/e 52

53 Example: The Projectile Class The last method is update, where we ll take the time iterval ad calculate the update X ad Y values. def update(self, time): self.xpos = self.xpos + time * self.xvel yvel1 = self.yvel * time self.ypos = self.ypos + time * (self.yvel + yvel1) / 2.0 self.yvel = yvel1 yvel1 is a temporary variable. Pytho Programmig, 2/e 53

54 Data Processig with Class A class is useful for modelig a real-world object with complex behavior. Aother commo use for objects is to group together a set of iformatio that describes a perso or thig. Eg., a compay eeds to keep track of iformatio about employees (a Employee class with iformatio such as employee s ame, social security umber, address, salary, etc.) Pytho Programmig, 2/e 54

55 Data Processig with Class Groupig iformatio like this is ofte called a record. Let s try a simple data processig example! A typical uiversity measures courses i terms of credit hours, ad grade poit averages are calculated o a 4 poit scale where a A is 4 poits, a B is three, etc. Pytho Programmig, 2/e 55

56 Data Processig with Class Grade poit averages are geerally computed usig quality poits. If a class is worth 3 credit hours ad the studet gets a A, the he or she ears 3(4) = 12 quality poits. To calculate the GPA, we divide the total quality poits by the umber of credit hours completed. Pytho Programmig, 2/e 56

57 Data Processig with Class Suppose we have a data file that cotais studet grade iformatio. Each lie of the file cosists of a studet s ame, credit-hours, ad quality poits. Adams, Hery Comptewell, Susa DibbleBit, Dey Joes, Jim Smith, Frak Pytho Programmig, 2/e 57

58 Data Processig with Class Our job is to write a program that reads this file to fid the studet with the best GPA ad prit out their ame, credithours, ad GPA. The place to start? Creatig a Studet class! We ca use a Studet object to store this iformatio as istace variables. Pytho Programmig, 2/e 58

59 Data Processig with Class class Studet: def iit (self, ame, hours, qpoits): self.ame = ame self.hours = float(hours) self.qpoits = float(qpoits) The values for hours are coverted to float to hadle parameters that may be floats, its, or strigs. To create a studet record: astudet = Studet( Adams, Hery, 127, 228) The coolest thig is that we ca store all the iformatio about a studet i a sigle variable! Pytho Programmig, 2/e 59

60 Data Processig with Class We eed to be able to access this iformatio, so we eed to defie a set of accessor methods. def getname(self): retur self.ame def gethours(self): retur self.hours def getqpoits(self): retur self.qpoits def gpa(self): retur self.qpoits/self.hours For example, to prit a studet s ame you could write: prit astudet.getname() Pytho Programmig, 2/e 60

61 Data Processig with Class How ca we use these tools to fid the studet with the best GPA? We ca use a algorithm similar to fidig the max of umbers! We could look through the list oe by oe, keepig track of the best studet see so far! Pytho Programmig, 2/e 61

62 Data Processig with Class Get the file ame from the user Ope the file for readig Set best to be the first studet For each studet s i the file if s.gpa() > best.gpa set best to s Prit out iformatio about best Pytho Programmig, 2/e 62

63 Data Processig with Class # gpa.py # Program to fid studet with highest GPA class Studet: def iit (self, ame, hours, qpoits): self.ame = ame self.hours = float(hours) self.qpoits = float(qpoits) def getname(self): retur self.ame def gethours(self): retur self.hours def mai(): fileame = iput("eter ame the grade file: ") ifile = ope(fileame, 'r') best = makestudet(ifile.readlie()) for lie i ifile: s = makestudet(lie) if s.gpa() > best.gpa(): best = s ifile.close() prit("the best studet is:", best.getname()) prit ("hours:", best.gethours()) prit("gpa:", best.gpa()) if ame == ' mai ': mai() def getqpoits(self): retur self.qpoits def gpa(self): retur self.qpoits/self.hours def makestudet(ifostr): ame, hours, qpoits = ifostr.split("\t") retur Studet(ame, hours, qpoits) Pytho Programmig, 2/e 63

64 Ecapsulatig Useful Abstractios Defiig ew classes (like Projectile ad Studet) ca be a good way to modularize a program. Oce some useful objects are idetified, the implemetatio details of the algorithm ca be moved ito a suitable class defiitio. Pytho Programmig, 2/e 64

65 Ecapsulatig Useful Abstractios The mai program oly has to worry about what objects ca do, ot about how they are implemeted. I computer sciece, this separatio of cocers is kow as ecapsulatio. The implemetatio details of a object are ecapsulated i the class defiitio, which isulates the rest of the program from havig to deal with them. Pytho Programmig, 2/e 65

66 Ecapsulatig Useful Abstractios Oe of the mai reasos to use objects is to hide the iteral complexities of the objects from the programs that use them. From outside the class, all iteractio with a object ca be doe usig the iterface provided by its methods. Pytho Programmig, 2/e 66

67 Ecapsulatig Useful Abstractios Oe advatage of this approach is that it allows us to update ad improve classes idepedetly without worryig about breakig other parts of the program, provided that the iterface provided by the methods does ot chage. Pytho Programmig, 2/e 67

68 Puttig Classes i Modules Sometimes we may program a class that could useful i may other programs. If you might be reusig the code agai, put it ito its ow module file with documetatio to describe how the class ca be used so that you wo t have to try to figure it out i the future from lookig at the code! Pytho Programmig, 2/e 68

69 Module Documetatio You are already familiar with # to idicate commets explaiig what s goig o i a Pytho file. Pytho also has a special kid of commetig covetio called the docstrig. You ca isert a plai strig literal as the first lie of a module, class, or fuctio to documet that compoet. Pytho Programmig, 2/e 69

70 Module Documetatio Why use a docstrig? Ordiary commets are igored by Pytho Docstrigs are accessible i a special attribute called doc. Most Pytho library modules have extesive docstrigs. For example, if you ca t remember how to use radom: >>> import radom >>> prit radom.radom. doc radom() -> x i the iterval [0, 1). Pytho Programmig, 2/e 70

71 Module Documetatio Docstrigs are also used by the Pytho olie help system ad by a utility called PyDoc that automatically builds documetatio for Pytho modules. You could get the same iformatio like this: >>> import radom >>> help(radom.radom) Help o built-i fuctio radom: radom(...) radom() -> x i the iterval [0, 1). Pytho Programmig, 2/e 71

72 Module Documetatio To see the documetatio for a etire module, try typig help(module_ame)! The followig code for the projectile class has docstrigs. Pytho Programmig, 2/e 72

73 Module Documetatio # projectile.py """projectile.py Provides a simple class for modelig the flight of projectiles.""" from math import pi, si, cos class Projectile: """Simulates the flight of simple projectiles ear the earth's surface, igorig wid resistace. Trackig is doe i two dimesios, height (y) ad distace (x).""" def iit (self, agle, velocity, height): """Create a projectile with give lauch agle, iitial velocity ad height.""" self.xpos = 0.0 self.ypos = height theta = pi * agle / self.xvel = velocity * cos(theta) self.yvel = velocity * si(theta) Pytho Programmig, 2/e 73

74 Module Documetatio def update(self, time): """Update the state of this projectile to move it time secods farther ito its flight""" self.xpos = self.xpos + time * self.xvel yvel1 = self.yvel * time self.ypos = self.ypos + time * (self.yvel + yvel1) / 2.0 self.yvel = yvel1 def gety(self): "Returs the y positio (height) of this projectile." retur self.ypos def getx(self): "Returs the x positio (distace) of this projectile." retur self.xpos Pytho Programmig, 2/e 74

75 Workig with Multiple Modules Our mai program ca import from the projectile module i order to solve the origial problem! # cball4.py # Simulatio of the flight of a cao ball (or other projectile) # This versio uses a separate projectile module file from projectile import Projectile def getiputs(): a = eval(iput("eter the lauch agle (i degrees): ")) v = eval(iput("eter the iitial velocity (i meters/sec): ")) h = eval(iput("eter the iitial height (i meters): ")) t = eval(iput("eter the time iterval betwee positio calculatios: ")) retur a,v,h,t def mai(): agle, vel, h0, time = getiputs() cball = Projectile(agle, vel, h0) while cball.gety() >= 0: cball.update(time) prit("\distace traveled: {0:0.1f} meters.".format(cball.getx()) Pytho Programmig, 2/e 75

76 Workig with Multiple Modules If you are testig a multi-module Pytho program, you eed to be aware that reloadig a module may ot behave as you expect. Whe Pytho first imports a give module, it creates a module object that cotais all the thigs defied i the module (a amespace). If a module imports successfully (o sytax errors), subsequet imports do ot reload the module. Eve if the source code for the module has bee chaged, re-importig it ito a iteractive sessio will ot load the updated versio. Pytho Programmig, 2/e 76

77 Workig with Multiple Modules The easiest way start a ew iteractive sessio for testig wheever ay of the modules ivolved i your testig are modified. This way you re guarateed to get a more recet import of all the modules you re usig. Pytho Programmig, 2/e 77

78 Widgets Oe very commo use of objects is i the desig of graphical user iterfaces (GUIs). Back i chapter 5 we talked about GUIs beig composed of visual iterface objects kow as widgets. The Etry object defied i our graphics library is oe example of a widget. Pytho Programmig, 2/e 78

79 Example Program: Dice Roller Let s build a couple useful widgets! Cosider a program that rolls a pair of six-sided dice. The program will display the dice graphically ad provide two buttos, oe for rollig the dice ad oe for quittig the program. Pytho Programmig, 2/e 79

80 Example Program: Dice Roller There are two kids of widgets: buttos ad dice. The two buttos will be examples of the Butto class, while the dice images will be provided by dieview. Pytho Programmig, 2/e 80

81 Buildig Buttos Most moder GUIs have buttos with 3- dimesioal look ad feel. Our simple graphics package does ot have the machiery to produce buttos that appear to depress as they are clicked. All we ca do is report back where the mouse was clicked after the click has bee completed. Pytho Programmig, 2/e 81

82 Buildig Buttos Our buttos will be rectagular regios i a graphics widow where user clicks ca ifluece the behavior of the ruig applicatio. We eed a way to determie whether a butto has bee clicked. It would be ice to be able to activate ad deactivate (gray-out) idividual buttos. Pytho Programmig, 2/e 82

83 Buildig Buttos Costructor Create a butto i a widow. We will specify the widow, locatio/size of the butto, ad the label o the butto. Activate Set the state of the butto to active. Deactivate Set the state of the butto to iactive. Pytho Programmig, 2/e 83

84 Buildig Buttos Clicked Idicate if the butto was clicked. If the butto is active, this method will determie if the poit clicked is iside the butto regio. The poit will have to be set as a parameter to the method. getlabel Returs the label strig of a butto. This is provided so that we ca idetify a particular butto. Pytho Programmig, 2/e 84

85 Buildig Buttos To support these operatios, our buttos will eed a umber of istace variables. For example, buttos are draw as a rectagle with some text cetered o it. Ivokig the activate ad deactivate methods will chage the appearace of the buttos. Pytho Programmig, 2/e 85

86 Buildig Buttos Savig the Rectagle ad Text objects as istace variables meas we will be able to cotrol the width of the outlie ad color of the label. Let s try writig these methods ad build up a list of possible istace variables! Oce we have the list, we ca write the costructor to iitialize them. Pytho Programmig, 2/e 86

87 Buildig Buttos I activate, we ca sigal a butto is active by makig its outlie thicker ad makig the label text black. def activate(self): "Sets this butto to 'active'. " self.label.setfill('black') self.rect.setwidth(2) self.active = True Remember, self refers to the butto object. Our costructor will have to iitialize self.label as a appropriate Text object ad self.rect as a rectagle object. Self.active also has a Boolea istace variable to remember whether or ot the butto is curretly iactive. Pytho Programmig, 2/e 87

88 Buildig Buttos The code for deactivate is very similar: def deactivate(self): "Sets this butto to 'iactive'." self.label.setfill('darkgrey') self.rect.setwidth(1) self.active = 0 Pytho Programmig, 2/e 88

89 Buildig Buttos Let s work o the clicked method. The graphics package has the getmouse method to see if ad where the mouse has bee clicked. If a applicatio eeds to get a butto click, it will have to first call getmouse ad the see which butto, if ay, the poit is iside of. Pytho Programmig, 2/e 89

90 Buildig Buttos pt = wi.getmouse() if butto1.clicked(pt): # Do butto1 stuff elif butto2.clicked(pt): # Do butto2 stuff elif butto3.clicked(pt): # Do butto3 stuff The mai job of the clicked method is to determie whether a give poit is iside the rectagular butto. Pytho Programmig, 2/e 90

91 Buildig Buttos The poit is iside the butto if its x ad y coordiates lie betwee the extreme x ad y values of the rectagle. This would be easiest if the butto object had the mi ad max values of x ad y as istace variables. Pytho Programmig, 2/e 91

92 Buildig Buttos def clicked(self, p): "RETURNS true if butto active ad p is iside retur self.active ad \ self.xmi <= p.getx() <= self.xmax ad \ self.ymi <= p.gety() <= self.ymax For this fuctio to retur True, all three parts of the Boolea expressio must be true. The first part esures that oly active buttos will retur that they have bee clicked. The secod ad third parts esure that the x ad y values of the poit that was clicked fall betwee the boudaries of the rectagle. Pytho Programmig, 2/e 92

93 Buildig Buttos The oly part that is left is to write the costructor: def iit (self, wi, ceter, width, height, label): """ Creates a rectagular butto, eg: qb = Butto(myWi, Poit(30,25), 20, 10, 'Quit') """ w,h = width/2.0, height/2.0 x,y = ceter.getx(), ceter.gety() self.xmax, self.xmi = x+w, x-w self.ymax, self.ymi = y+h, y-h p1 = Poit(self.xmi, self.ymi) p2 = Poit(self.xmax, self.ymax) self.rect = Rectagle(p1,p2) self.rect.setfill('lightgray') self.rect.draw(wi) self.label = Text(ceter, label) self.label.draw(wi) self.deactivate() Buttos are positioed by providig a ceter poit, width, ad height. Pytho Programmig, 2/e 93

94 Buildig Dice The purpose of the DieView class is to graphically display the value of a die. The face of the die is a square/rectagle, ad the pips/spots o the die are circles. As before, the DieView class will have a costructor ad a method. Pytho Programmig, 2/e 94

95 Buildig Dice costructor Create a die i a widow. We will specify the widow, the ceter poit of the die, ad the size of the die as parameters. setvalue Chage the view to show a give value. The value to display will be passed as a parameter. Pytho Programmig, 2/e 95

96 Buildig Dice Clearly, the hardest part of this will be to tur o the pips o the die to represet the curret value of the die. Oe approach is to pre-place the pips, ad make them the same color as the die. Whe the spot is tured o, it will be redraw with a darker color. Pytho Programmig, 2/e 96

97 Buildig Dice A stadard die will eed seve pips -- a colum of three o the left ad right sides, ad oe i the ceter. The costructor will create the backgroud square ad the seve circles. setvalue will set the colors of the circles based o the value of the die. Pytho Programmig, 2/e 97

98 Buildig Dice # dieview.py # A widget for displayig the value of a die from graphics import * class DieView: """ DieView is a widget that displays a graphical represetatio of a stadard six-sided die.""" def iit (self, wi, ceter, size): """Create a view of a die, e.g.: d1 = GDie(myWi, Poit(40,50), 20) creates a die cetered at (40,50) havig sides of legth 20.""" # first defid some stadard values self.wi = wi self.backgroud = "white" # color of die face self.foregroud = "black" # color of the pips self.psize = 0.1 * size # radius of each pip hsize = size / 2.0 # half of size offset = 0.6 * hsize # distace from ceter to outer pip Pytho Programmig, 2/e 98

99 Buildig Dice # create a square for the face cx, cy = ceter.getx(), ceter.gety() p1 = Poit(cx-hsize, cy-hsize) p2 = Poit(cx+hsize, cy+hsize) rect = Rectagle(p1,p2) rect.draw(wi) rect.setfill(self.backgroud) # Create 7 circles for stadard pip locatios self.pip1 = self. makepip(cx-offset, cy-offset) self.pip2 = self. makepip(cx-offset, cy) self.pip3 = self. makepip(cx-offset, cy+offset) self.pip4 = self. makepip(cx, cy) self.pip5 = self. makepip(cx+offset, cy-offset) self.pip6 = self. makepip(cx+offset, cy) self.pip7 = self. makepip(cx+offset, cy+offset) self.setvalue(1) Pytho Programmig, 2/e 99

100 Buildig Dice def makepip(self, x, y): """Iteral helper method to draw a pip at (x,y)""" pip = Circle(Poit(x,y), self.psize) pip.setfill(self.backgroud) pip.setoutlie(self.backgroud) pip.draw(self.wi) retur pip def setvalue(self, value): """ Set this die to display value.""" # tur all pips off self.pip1.setfill(self.backgroud) self.pip2.setfill(self.backgroud) self.pip3.setfill(self.backgroud) self.pip4.setfill(self.backgroud) self.pip5.setfill(self.backgroud) self.pip6.setfill(self.backgroud) self.pip7.setfill(self.backgroud) Pytho Programmig, 2/e 100

101 Buildig Dice # tur correct pips o if value == 1: self.pip4.setfill(self.foregroud) elif value == 2: self.pip1.setfill(self.foregroud) self.pip7.setfill(self.foregroud) elif value == 3: self.pip1.setfill(self.foregroud) self.pip7.setfill(self.foregroud) self.pip4.setfill(self.foregroud) elif value == 4: self.pip1.setfill(self.foregroud) self.pip3.setfill(self.foregroud) self.pip5.setfill(self.foregroud) self.pip7.setfill(self.foregroud) elif value == 5: self.pip1.setfill(self.foregroud) self.pip3.setfill(self.foregroud) self.pip4.setfill(self.foregroud) self.pip5.setfill(self.foregroud) self.pip7.setfill(self.foregroud) else: self.pip1.setfill(self.foregroud) self.pip2.setfill(self.foregroud) self.pip3.setfill(self.foregroud) self.pip5.setfill(self.foregroud) self.pip6.setfill(self.foregroud) self.pip7.setfill(self.foregroud) Pytho Programmig, 2/e 101

102 Buildig Dice Thigs to otice: The size of the spots beig 1/10 of the size of the die was determied by trial ad error. We defie ad calculate various attributes of the die i the costructor ad the use them i other methods ad fuctios withi the class so that if we wated to chage the appearace, all those values ad the code to go with them is i oe place, rather tha throughout the class. Pytho Programmig, 2/e 102

103 Buildig Dice makepip is a helper fuctio to draw each of the seve pips o the die. Sice it is oly useful withi DieView, it s appropriate to make it a class method. It s ame starts with to idicate that its use is private to the class ad is ot iteded to be used outside the class. Pytho Programmig, 2/e 103

104 The Mai Program # roller.py # Graphics program to roll a pair of dice. Uses custom widgets # Butto ad GDie. from radom import radrage from graphics import GraphWi, Poit from butto import Butto from dieview import DieView def mai(): # create the applicatio widow wi = GraphWi("Dice Roller") wi.setcoords(0, 0, 10, 10) wi.setbackgroud("gree2") # Draw the iterface widgets die1 = DieView(wi, Poit(3,7), 2) die2 = DieView(wi, Poit(7,7), 2) rollbutto = Butto(wi, Poit(5,4.5), 6, 1, "Roll Dice") rollbutto.activate() quitbutto = Butto(wi, Poit(5,1), 2, 1, "Quit") Pytho Programmig, 2/e 104

105 The Mai Program # Evet loop pt = wi.getmouse() while ot quitbutto.clicked(pt): if rollbutto.clicked(pt): value1 = radrage(1,7) die1.setvalue(value1) value2 = radrage(1,7) die2.setvalue(value2) quitbutto.activate() pt = wi.getmouse() mai() # close up shop wi.close() Pytho Programmig, 2/e 105

106 The Mai Program The visual iterface is built by creatig the two DieViews ad two Buttos. The roll butto is iitially active, but the quit butto is deactivated. This forces the user to roll the dice at least oce. The evet loop is a setiel loop that gets mouse clicks ad processes them util the user clicks o the quit butto. Pytho Programmig, 2/e 106

107 The Mai Program The if withi the loop esures that the dice are rolled oly whe the user clicks the roll butto. Clickig a poit that is ot iside ay butto causes the loop to iterate without doig aythig. Pytho Programmig, 2/e 107