Classes, part Deux. Three Groups. CSE 231, Rich Enbody. Users Programmers Class Designers 11/11/13. Michigan State University CSE 231, Fall 2013

Size: px

Start display at page:

Download "Classes, part Deux. Three Groups. CSE 231, Rich Enbody. Users Programmers Class Designers 11/11/13. Michigan State University CSE 231, Fall 2013"

Alice Rich
5 years ago
Views:

1 , part Deux CSE 231, Rich Enbody Three Groups Users Programmers Class Designers 1

2 Getters and Setters getters: methods that fetch the value setters: methods set a value 2

3 GetterSetter Example Why do this? OOP: controlling access to an instance as the designer intended. 3

4 Why not to do this? Have to create all those functions. Pythonistas want to do dot access, (easier to read). Compromise: propname = property(fget=getfn, fset=setfn, fdel=delfn) propname is now a variable in the instance with three associated functions. 4

5 Read Only: for any property, you can fail to set the fset portion, meaning it becomes read only. (You could also make it write only, though that would be kind of weird.) Circle Example 5

6 Setup We create three properties: radius, area and circumference We also create three hidden variables to hold values: radius, area and circumference Access goes through the 3 properties, backed by the three hidden variables. Radius Only the radius property can be changed. Updating radius updates the other two. You can t change area and circumference as they are readonly 6

7 Caution! You cannot do the following def get_radius(self):! return self.radius # no! radius = property(fget=get_radius)! Infinite regress! Property is the external interface, vars are the internal interface. Result Programmer can use standard interface (dot reference) to variables. Designer can place restrictions on access to variables. Designer can refactor the code later without changing the interface. More readable code. 7

8 Remember, we said there were three factors that distinguished an Object Oriented Programming language: o encapsulation o inheritance o polymorphism We are still at encapsulation We said that encapsulation: hid details of the implementation so the program was easier to read and write provides modularity, so objects can be reused in other contexts provides an interface (the methods) that is the approved way to deal with the class 8

9 A new aspect we should have is consistency: a new class should respond to standard messages in a way that is consistent with how other data structures behaved. Consider a rational number class. It should respond to: o construction o printing o arithmetic ops (+, -, *, /) o comparison ops (<, >, <=, >=) 9

10 If we define the class in a consistent way, the following program should work: = (1,2) r2 = (3,4) # constructor # addition print(r3) # print if ( <= r2): # comparison r2 = r2 - # subtraction just like any other number By building the class in a consistent way, we can make a new instance of look like any other number syntactically. The instance responds to all the normal function calls. 10

11 How can that work? Python can distinguish which operator to use based on types. Python provides special function names that represent the action of standard operations in the language. A class is essentially a new type when we make an instance of a class, we have made an object of a particular type 1.36 is a float my_instance=myclass(), my_instance is a type of myclass 11

12 Python does not have a type associated with any variable, since each variable is allowed to reference any object. However, we can ask any variable what type it presently references. This is called introspection. Python introspection ops type(variable) returns its type (as an object) isinstance(variable,type) returns a Boolean indicating if the variable is of that type. 12

13 Introspection Example So what does va+var2 mean? it depends The + operation has two operands. What are their types? Python uses introspection to find the type and then select the correct operator. 13

14 What does va+var2 do? with two strings, we get concatenation with two integers, we get addition with an integer and a string we get: Traceback (most recent call last): File "<pyshell#9>", line 1, in <module> 1+'a' TypeError: unsupported operand type(s) for +: 'int' and 'str' The plus operator is overloaded: the operation depends on the types involved 14

15 Some Python operators can be overloaded. o Like all the special class operations, the names use two underlines before and after the name o They come in two general classes: numeric type operations (+,-,<,>,print etc.) container operations ([ ], iterate, len, etc.) lets look at one first class MyClass(object): # other defs, including def (self,arg2): # do something v1 = MyClass() v2 = MyClass() v1 + v2 15

16 v1+v2 maps to v1 + v2 v1.(v2) def (self,arg2): v1 is bound to self, v2 bound to other parameter Number Class 16

17 Simple Number class A is represented by two numbers, the numerator and the denominator. We can apply many of the numeric operators to. Simple Number class A is represented by two numbers, the numerator and the denominator. class (object): """ number class""" def (self, numer, denom=1): """numer: numerator, denom: denominator "" self.numer = numer self.denom = denom def 17

18 Constructing an instance class (object): """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) Constructing an instance class (object): """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) s N.S. self numer denom 18

19 Constructing an instance class (object): """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): = (3,4) r2 = (1,2) s N.S. self s N.S. numer denom Constructing an instance class (object): in constructor! """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) s N.S. self numer denom 19

20 Constructing an instance class (object): in constructor! """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) s N.S. self Constructing an instance class (object): in constructor! """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) s N.S. self 20

21 Constructing an instance class (object): in constructor! """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) s N.S. self Constructing an instance class (object): in constructor! """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) 21

22 Constructing an instance class (object): in constructor! """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) s N.S. self numer denom Constructing an instance class (object): in constructor! """ number class""" def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") self.numer = numer self.denom = denom def (self,f): s N.S. = (3,4) r2 = (1,2) s N.S. self 22

23 Constructing an instance class (object): in constructor """ number class""" in constructor! def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") s N.S. self.numer = numer self.denom = denom def (self,f): = (3,4) r2 = (1,2) s N.S. self Constructing an instance class (object): in constructor """ number class""" in constructor! def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") s N.S. self.numer = numer self.denom = denom def (self,f): = (3,4) r2 = (1,2) r2 23

24 Addition of s class (object): in constructor """ number class""" in constructor! def (self,numer,denom=1): """numer: numerator, denom: denominator "" print("in constructor") s N.S. self.numer = numer self.denom = denom def (self,f): = (3,4) r2 = (1,2) r3 =.(r2) r2 Addition of s def (self, f): in constructor print('in add') in constructor! thelcm = lcm(self.denom,f.denom) thesum = (thelcm/self.denom*self.numer)+\ (thelcm/f.denom * f.numer) s N.S. return (thesum,thelcm) r2 = (3,4) r2 = (1,2) r3 =.(r2) s N.S. self f 24

25 Addition of s def (self, f): in constructor print('in add') in constructor! thelcm = lcm(self.denom,f.denom) thesum = (thelcm/self.denom*self.numer)+\ (thelcm/f.denom * f.numer) s N.S. return (thesum,thelcm) r2 = (3,4) r2 = (1,2) r3 =.(r2) s N.S. self f Addition of s in constructor def (self, f): in constructor print('in add') in add! thelcm = lcm(self.denom,f.denom) thesum = (thelcm/self.denom*self.numer)+\ (thelcm/f.denom * f.numer) s N.S. return (thesum,thelcm) r2 = (3,4) r2 = (1,2) r3 =.(r2) s N.S. self f thelcm thesum 25

26 Addition of s in constructor in constructor def (self, f): in constructor add print('in add') in constructor! thelcm = lcm(self.denom,f.denom) thesum = (thelcm/self.denom*self.numer)+\ (thelcm/f.denom * f.numer) return (thesum,thelcm) = (3,4) r2 = (1,2) r2 r3 numer 5 denom 4 Operators (self,f2) sub (self,f2) (self,num,denom=1) str (self) repr (self) eq (self,f2) 26

27 Subtraction of s def sub (self, f): """return the difference """ thelcm = lcm(self.denom,f.denom) thediff = (thelcm/self.denom * self.numer) - \ (thelcm/f.denom * f.numer) return (thediff,thelcm) = (3,4) r2 = (1,2) r2 = r2 r2 r3 numer 5 denom 4 Subtraction of s def sub (self, f): """return the difference """ thelcm = lcm(self.denom,f.denom) thediff = (thelcm/self.denom * self.numer) - \ (thelcm/f.denom * f.numer) return (thediff,thelcm) = (3,4) r2 = (1,2) r2 = r2 r2 = r2. sub () r2 r3 numer 5 denom 4 sub s N.S. self f thelcm thediff 27

28 Subtraction of s def sub (self, f): """return the difference """ thelcm = lcm(self.denom,f.denom) thediff = (thelcm/self.denom * self.numer) - \ (thelcm/f.denom * f.numer) return (thediff,thelcm) numer -1 = (3,4) r2 = (1,2) r2 = r2 r2 = r2. sub () r2 r3 numer 5 denom 4 sub s N.S. self f thelcm thediff Subtraction of s def sub (self, f): """return the difference """ thelcm = lcm(self.denom,f.denom) thediff = (thelcm/self.denom * self.numer) - \ (thelcm/f.denom * f.numer) return (thediff,thelcm) numer -1 = (3,4) r2 = (1,2) r2 = r2 r2 = r2. sub () r2 r3 numer 5 denom 4 28

29 Printing of s def str (self): """return the number as a string""" print('in str') return str(self.numer) + '/' + str(self.denom) numer -1 = (3,4) r2 = (1,2) r2 = r2 print(r2) r2 r3 numer 5 denom 4 Printing of s def str (self): """return the number as a string""" print('in str') return str(self.numer) + '/' + str(self.denom) numer -1 = (3,4) r2 = (1,2) r2 = r2 print(r2) print(r2. str() ) r2 r3 numer 5 denom 4 str s N.S. self 29

30 str v.s. repr str called by print and by str( ) repr called by shell Often the same: define str, have repr call str def repr (self): return self. str () Equality of s def eq (self, f): """compare the number and """ print('in eq') f1 = self.reduce() f2 = f.reduce() return f1.numer == f2.numer and \ f1.denom == f2.denom numer -1 if == r3: r2 r3 numer 5 denom 4 30

31 Equality of s def eq (self, f): """compare the number and """ print('in eq') f1 = self.reduce() f2 = f.reduce() return f1.numer == f2.numer and \ f1.denom == f2.denom numer -1 if == r3: if. eq (r3): r2 r3 numer 5 denom 4 eq s N.S. self f f1 f2 Operators (self,r2) sub (self,r2) (self,num,denom=1) str (self) repr (self) eq (self,r2) 31

32 eq and compares When we compare two fractions, we have to be sure that we are comparing the reduced form of the fraction For example, 1/2==2/4 should come back True Should we always reduce the result in our operations? Can you write? mul! div! lt! gt! 32

33 Problems to think about These don t work. Why? = (1,2) + 1 # fails, how to fix? 1 + # fails for a different # reason, how to fix? 33

What is a class? Responding to messages. Short answer 7/19/2017. Code Listing 11.1 First Class. chapter 11. Introduction to Classes

What is a class? Responding to messages. Short answer 7/19/2017. Code Listing 11.1 First Class. chapter 11. Introduction to Classes chapter 11 Code Listing 11.1 First Class Introduction to Classes What is a class? If you have done anything in computer science before, you likely will have heard the term object oriented programming (OOP)