CS 112 Intro to Programming Basic OO Concepts

Transcription

1 CS 112 Intro to Programming Basic OO Concepts George Mason University

2 Building up to classes: Python Data Types Primitive Data Types: integer, floating point, boolean, None, etc Complex Data Types: Sequence: String, Tuple, List Mapping: Dictionary Class: User-created 2

3 DEFINING CLASSES

4 Making Our Own Types: Classes We can move beyond the existing types of our language. we're not restricted to using just int, float, str, list, tuple, set, dictionary, Each type can be thought of as a set of values: bool NoneType int person address = {True, False} = {None} = {,-2,-1,0,1,2, } =??? =???

5 Making Our Own Types: Classes We create our own new types with a class definition: a 'blueprint' of what is present for a value of this type: what pieces of data (variables inside) what behaviors (methods available)

6 Example Class Let's define a Person as having a name and an age: # define an entire new class of python values class Person: # method describing how to create any one new Person value def init ( self, name_param, age_param ): # store param to 'long-term' instance variables self. name = name_param self. age = age_param create a Person value (an object) by calling its constructor: george = Person("George",66) this actually calls the init definition, by using the class name Person. Note that the self parameter seems to have been supplied some other way!)

7 Classes in Python Class Definition (blueprint) class definition tells Python everything about the new data type Object Instantiation (creation) An object must be instantiated (created) from the class definition via the init method, to fill in instance variables, before it can be used. Object manipulation (use) Once object exists, we can read/update its data (access its instance variables), and use its behaviors (call its methods) 7

8 Class Definition A Python class definition contains: name (identifier) of the class optional: name of parent class. (often, just object) constructor (method named init ) defines, instantiates the instance variables methods (behavior)

9 Example: The Point class A Point is an (x,y) coordinate pair. data: the actual x, y values. methods: shift, vector_magnitude, etc. We define a Point class once, so that we can make lots of Point objects. our Point methods only work on Points (this is good)

10 Point class class Point: #constructor: how to make a Point. def init (self, xparam, yparam): # creates an x, and a y, for the object. self.x = xparam self.y = yparam init method: tells us how to create a Point object. all methods, not just constructor methods, have self as a first parameter. We must use self to access the object's data and methods from within the class's code

11 Constructor Methods constructor method is named init note: double underscores on both sides ( i n i t ) primary duty: assign values to the object's attributes must have at least one first formal parameter (name it self) may have as many more params as needed/desired. Calling a constructor (via the class name) tells Python to: instantiate (create) a new object of the class data type example: Point(1,2) set the object s initial state (run constructor's code) example: self.x becomes 1, self.y becomes 2. return a reference to the new object to the caller 11

12 Defining Attributes self.x is assigned to create the instance variable named x. re-assigns if we see another self.x assignment all instance variables ought to be added in the constructor. every single Point object we make has its own x, and its own y. class Point: #constructor: how to make a Point. def init (self, xparam, yparam): # creates an x, and a y, for the object. self.x = xparam self.y = yparam

13 Instance Variables We can make many objects from a single class definition. Each object is an instance of the class, so each variable that exists inside the object is called an instance variable. Class Person Address Popsicle Episode <Anything> example instance variables name, age, height state,zip, city, county, street, num color, flavor, size, is_frozen show_name, genre, season, ep_num, runtime <you choose what state is important for your program!> 13

14 POLL 9A class definitions

15 Practice Problem For each of the following, define a class, with its constructor, that represents it. A Student has a name, a student ID, and a GPA. A stop-light has a status which is "red", "green", or "amber". Come up with a good example class. When would it be helpful?

16 CREATING OBJECTS

17 Object Components objects contain two different things: attributes characteristics of the object (instance variables) behaviors actions of the object (methods) 17

18 Using These Types: Making Objects A class defines a new type. objects are the actual values of this type An object instantiates the class definition by calling the init method, supplying values for each parameter except for the first one (which is traditionally named self).

19 Example Objects >>> george_mason = Person("George",66) >>> william = Person("Bill Shakespeare",52) >>> >>> george_mason. age 66 >>> william. age 52 >>> george_mason. name 'George' >>> william. age = (william.age) >>> william. age 454

20 Understanding Objects as Values Each object is an instance of its class type. 5 is an instance of an int. So is 6. They behave differently when we use them. xs=[1,2,3] and ys=[4,5] both refer to lists but contain different data. The same methods are available on each list (such as append, extend, sort, etc), but they respond differently If we modify one, the other is not affected. we're only discussing values here (not aliases) two Person objects are both instances of the Person class. They may have different names, ages, etc. have same methods (b/c each is a Person).

21 Point Objects Create an object an instance of the class by calling the constructor. p1 = Point(1,2) #call constructor p2 = Point(3,4) #call constructor print ("point 1: ", p1.x, p1.y) print ("point 2: ", p2.x, p2.y) print(p1) point 1: 1 2 point 2: 3 4 < main.point object at 0x1005c9ad0> Access attributes with the dot-operator: Syntax: objectexpr. attribute Example: p1. x

22 POLL 9B objects

23 Practice Problem In an interactive session, load your classes from before, and: Create two objects each of your Student and Stoplight classes. print some of their instance variables out modify the values of some instance variables print them again print the whole objects out how do they look? good, bad?

24 DEFINING METHODS

25 Defining Methods A method in our class implements functionality that is only appropriate upon an object of the class. They look a lot like function definitions indented inside of a class. Always have self as first parameter. Each object can use this method on its personal data (through self). The method may: access or update instance values return values based on instance values

26 Adding a Method class Point(object): #constructor, etc. def shift (self, xshift=0, yshift=0): self.x += xshift self.y += yshift the method accesses instance variables through self. values modified directly the "side effect" of calling the method is that x and y change values. no return statement present in our particular shift method, but just like functions, we always return something; return statements are normal in methods just as in functions. in this case, None is implicitly returned

27 Better Printing: provide str definition class Point: # init constructor, etc. def str (self): s = "Point("+str(self.x)+","+str(self.y)+")" return s >>>p1 = Point(1,2) >>>print(p1) Point(1,2) We are overloading the str() functionality. str() looks for the str method and calls it. this is an example of polymorphism: str() works on many types, with str definitions added in ad-hoc fashion.

28 Practice Problem add a go_to_origin method that changes a Point back to the origin. where does it go? what is its return type? how many arguments does it have? add a quadrant method, that returns a number from 1 to 4 based on which quadrant the Point is in. Return 0 if the point is on either axis. 1:(+,+). 2:(-,+). 3:(-,-). 4:(+,-). answer the three 's from the previous question.

29 Practice Problem Create an object of the Point class, and place it not at the origin. Call the shift and origin methods so that you can print subsequent calls to the quadrant method, and get a different answer each time. If you create three Point objects, how many integers were stored in memory? if you call origin() on one of the three Points, does this affect the other two Point objects?

30 Practice Problem add a vector_magnitude method that calculates the distance from the origin, returning the float value. add a slope method that accepts another Point argument, and calculates the slope from the self-point to the argument-point, returning that value.

31 Using a method p1 = Point(1,2) p2 = Point(3,4) print(p1) p1.shift(5,5) print(p1) p1.shift(yshift=3) print(p1) print("\np2:",p2) print("p2:",p2. str ()) print("p2:",str(p2)) Point(1,2) Point(6,7) Point(6,10) p2: Point(3,4) p2: Point(3,4) p2: Point(3,4) Both Point objects have their own state. p1 gets modified repeatedly, but p2 stays the same. They are separate values. Note: the self parameter's argument is p1 itself, so it doesn't show up in the ()'s. It shows up in front of the method name. All methods are called this way.

32 Various Ways to Display p2 = Point(3,4) print("p2:",p2. str ()) print("p2:",str(p2)) print("p2:",p2) p2: Point(3,4) p2: Point(3,4) p2: Point(3,4) we can manually call _str on our Point object if we want. str() looks for a definition of str to call print() calls str() all three have the same effect.

33 Practice Problem What is printed? p1 = Point(1,1) p2 = p1 p2.x = 2 print("first: ",p1) p3 = Point(3,3) p1 = Point(5,5) print("1: ",p1) print("2: ",p2) print("3: ",p3) first: Point(2,1) 1: Point(5,5) 2: Point(2,1) 3: Point(3,3) p2 is an alias for p1, and then p1 is reassigned to a different object memory.

34 Functions vs. Methods Functions define a conversion from arguments to returnvalue. sqrt(25) accepts argument, calculates/returns 5.0 Methods act upon objects of some particular type only, yet also accept arguments and calculate return value. Assumed that it might modify the object's state. You could always define a method as a function instead, but it's tidy to put methods where they belong avoid calling it on incorrect types of data. 34

35 POLL 9C methods

36 SCOPE, VISIBILITY

37 Scope and Methods Method parameters only exist during a particular call of the method. Instance variables' values live as long as the object lives (is accessible from any part of your code) Convention: name parameter and attribute the same. x and self.x are different. y and self.y also. class Point (object): def init (self, x, y): self.x = x self.y = y

38 A Need for Privacy Sometimes data is 'sensitive' either shouldn't be known outside an object, or at least shouldn't be directly modifiable by outsiders. a BankAccount object's balance shouldn't just be readily modifiable, it should only be accessed in controlled fashion: through methods.

39 Unsecure Account class Account: def init (self, start_bal=0): self.bal = start_bal def withdraw(self, amount): self.bal -= amount return amount def deposit(self, amount): self.bal += amount

40 Unsecure Attribute Usage a = Account(50) print(a.bal) a.withdraw(-100) print(a.bal)! a.bal = print(a.bal)!!! withdraw method is too trusting.! the bal attribute shouldn't be directly accessible, neither for reading or writing.

41 Approach to Privacy: Private Attributes/Methods attributes whose identifiers begin with a doubleunderscore are private: the dot-operator access doesn't work from outside the object. unfortunately, Python does allow the programmer to access the private attribute, or private method, via the underscore-classname-attribute name. Example: a SafeAccount object's bal can be accessed outside of the object with accountexpr. _SafeAccount bal

42 Better (Private) Attribute Usage class SafeAccount: def init (self, start_bal=0): self. bal = start_bal def withdraw(self, amount): if amount>0 and self. bal>=amount: self. bal -= amount return amount return 0 def deposit(self, amount): self. bal += max(0,amount) def current_balance(self): return self. bal

43 Secure Attribute Usage a = SafeAccount(50) print(a.current_balance()) a.withdraw(-100) print(a.current_balance()) a.deposit(-100) print(a.current_balance()) #errors (unallowed): # a.bal = # a. bal = #allowed, circumvents privacy: print(a._safeaccount bal) Python still creates underscore-classnameattribute as an attribute, so it's not truly private. This is Python's "we're all adults" approach. Makes it harder, but not impossible, to access it.

44 Practice Problems Thoughts: did making bal private make withdraw or deposit safer? preclude *any* abuses of bank accounts? add a pin number to the bank account. should it be private? how might we use it? (not a simple answer)

45 Recipe: Using OO in Python Choose your data representations when starting up a new project. Some of these choices may mean you create new classes. Add attributes and behaviors to the class definitions, so that they are useful for your particular project. Create objects of this class while implementing your project, instead of just using lists, tuples, etc.??? PROFIT

46 BASICS OF OBJECT-ORIENTED PROGRAMMING

47 Object Oriented Programming In this style, the programmer tries to model the system by defining what objects exist, and how they behave A program is then essentially making the right objects, and then watching them interact or create other objects.

48 Object Oriented Programming create classes for relevant structures of a project. define objects' state/behavior as variables and methods. create objects for everything that interacts, let them interact to model the world.

49 Encapsulation Encapsulation means using barriers or boundaries to keep related things together, and unrelated things apart from each other. Attributes and behaviors are enclosed (encapsulated) within the logical boundary of the object entity In structured or procedural systems, data and code are typically maintained as separate entities (e.g., functions here, and specific lists of data over there) In OO systems, each object contains the data (attributes) and the code (behaviors) that operates upon those attributes 49

50 Abstraction Encapsulation implements the concept of abstraction: details associated with object sub-components are enclosed and hidden within the logical boundary of the object user of object only sees the abstract perspective offered by the object Note - In Python, encapsulation is merely a programming convention other languages (e.g., Java) enforce the concept more rigorously. 50

51 Encapsulation Putting related values and related code (methods) together gives us encapsulation. Good organization always helps! Centralizing definitions means we have one place to make modifications.

52 INHERITANCE

53 Inheritance We can create class definitions out of other classes, adding more variables and more methods. Promotes code reuse by allowing more specific sub-classes to be derived from more generic super-classes defines child class and parent class relations. 53

54 Inheritance child inherits attributes/behaviors of parent may add additional attributes/behaviors thus making the child more specific The child-class type is a subtype of the parentclass type. Every object of child class is still a value of the parent class type. a Student is a Person. A Cat is an Animal. (similar idea:) every int can be represented as a float, but not vice versa. 54

55 Inheritance - example generic attributes/behaviors here: VIN, color, year, etc.; accelerate, brake, etc. Vehicle more specialized attributes/behaviors: 4-wheel drive, towing hitch, etc.; engage 4-wheel drive, open_trunk, etc. Car Truck very specialized details: bed canopy; rear seat DVD player; operate_winch; etc. Pickup SUV 55

56 Aggregation Aggregation is the collecting of other (possibly complex) values. An object can have other objects as data, just like a list can have other lists as items inside of it. Person Behaviors Name addr Objects may declare and instantiate other objects as attributes 56 String Behaviors "George" Address Behaviors city zip Aggregate Objects

57 Aggregation - example Do not confuse: inheritance relationships with aggregate relationships Monitor Each aggregate unit can in turn contain other aggregate units Desktop Computer Base Unit Mother Board A Desktop Computer can contain aggregate units as attributes Disk Drive 57

58 Inheritance vs Aggregation "IS-A": Inheritance embodies the "is-a" relationship: A Student "is a" Person; a Truck "is a" Vehicle. "HAS-A": Aggregation embodies the "has-a" relationship: A Student "has a" GPA. A Car "has a" Wheel.

59 Exceptions Revisited Exception classes heavily utilize an inheritance hierarchy. We can create our own exception classes, add our own useful variables, methods, etc. We can extend existing classes to piggyback on the appropriate exception handling code. go visit our Exceptions slides for more info on making Exception classes.