What is a Class? Short Answer. Responding to Messages. Everything in Python is an Object 11/8/2010

Transcription

1 The Practice of Computing Using PYTHON William Punch Richard Enbody Chapter 11 Introduction to Classes class Student(object): """Simple Student class.""" def init (self,first='', last='', id=0): # init instance self.firstnamestr = first self.lastnamestr = last self.idint = id def str (self): # string rep, e.g. for printing return "%s %s, ID:%s" % \ (self.firstnamestr, self.lastnamestr, self.idint) Copyright 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 1 2 What is a Class? Short Answer If you have done anything in computer science before, you likely will have heard the term object oriented programming (OOP) What is OOP, and why should I care? The short answer is that object oriented programming is a way to think about objects in a program (such as variables, functions, etc). A program becomes less a list of instructions and more a set of objects and how they interact. 3 4 Responding to Messages As a set of interacting objects, each object responds to messages sent to it. The interaction of objects via messages makes a high level description of what the program is doing. Everything in Python is an Object In case you hadn t noticed, everything in Python is an object. Thus Python embraces OOP at a fundamental level. Start! 5 6 1

2 OOP Helps in Software Engineering Software engineering is the discipline of managing code to ensure its long-term use. Remember, SE via refactoring: takes existing code and modifies it makes the overall code simpler, easier to understand doesn t change the functionality, only the form! More Refactoring Hiding the details of what the message entails means that changes can be made to the object and the flow of messages (and their results) can stay the same. Thus the implementation of the message can change but its intended effect stays the same. This is encapsulation. 7 8 OOP Principles Encapsulation: hiding design details to make the program clearer and more easily modified later. Modularity: the ability to make objects stand alone so they can be reused (our modules). I.e. the math module. Inheritance: create a new object by inheriting (like father to son) many object characteristics while creating or over-riding for this object. Polymorphism: (hard) Allow one message to be sent to any object and have it respond appropriately based on the type of object it is. Class versus Instance One of the harder things to understand is what a class is and what an instance of a class is. Consider the analogy of the cookie cutter and a cookie Template versus Exemplar The cutter is a template for stamping out cookies, the cookie is what is made each time the cutter is used. One template can be used to make an infinite number of cookies, each one just like the other. No one confuses a cookie for a cookie cutter, do they? Same in OOP You define a class as a way to generate new instances of that class. Both the instances and the classes are themselves objects. The structure of an instance starts out the same, as dictated by the class. The instances respond to the messages defined as part of the class

3 OK, a Different Tack Theory of Forms Ever hear of Plato? the second western philosopher B.C, in Greece (Athens) student of Socrates (the first western philosopher), teacher of Aristotle prolific writer and first of the Greek philosophers we have writings from Plato worried about the problem of universals. For example, Have you ever seen a perfect circle? Probably not; nearly any circle I were to draw (even given great care) would be flawed in some way So what is Circleness? Forms So if you have never seen a perfect circle, how do you know one when you see one? We assume that somehow we can compare our experiences to some universal (a perfect circle), but how can we compare to something we have never seen? Plato assumed there must be some universal concepts that we, as cognitive humans, could participate in (we could think about) that would allow us to compare particulars to universals. He called these universals the Forms And, um, How does that Help? Why a Class? In a way, OOP is related to a Form view of the world: instances are made in the image of its class though an instance may change (no longer be a perfect class instance) it is still an instance of the class (its form) See, ancient philosophy comes to the rescue! We make classes because we need more complicated, user-defined data types to construct instances we can use. Each class has potentially two aspects: the data (types, number, names) that each instance might contain the messages that each instance can respond to

4 A First Class Constructor When a class is defined, a function is made with the same name as the class This function is called the constructor. By calling it, you can create an instance of the class. We can affect this creation (more later), but by default Python can make an instance. dir Function class myclass (object): pass myinstance = myclass() #call constructor dir(myinstance) [' class ', ' delattr ', ' dict ', ' doc ', ' format ', ' getattribute ', ' hash ', ' init ', ' module ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' setattr ', ' sizeof ', ' str ', ' subclasshook ', ' weakref '] Dot Reference We can refer to the attributes of an object by doing a dot reference, of the form: object.attribute The attribute can be a variable or a function. It is part of the object, either directly or by that object being part of a class. Examples print myinst.myval print a variable associated with the object myinst myinst.mymethod() call a method associated with the object myinst Variable versus method, you can tell by the parenthesis at the end of the reference

5 How to Make an Object-Local Value Once an object is made, the data is made the same way as in any other Python situation, by assignment. Any object can thus be augmented by adding a variable: myinst.instanceattribute = hello New Attribute Shown in dir dir(myinstance) [' class ', ' delattr ', ' dict ', ' doc ', ' format ', ' getattribute ', ' hash ', ' init ', ' module ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' setattr ', ' sizeof ', ' str ', ' subclasshook ', ' weakref, instanceattribute] A Class is a New Type Class Instance Relationship mylst = [1, 2, 3] type(mylst) => type< list > mystr = abc type(mystr) => type< str > class myclass (object): pass myinstance = myclass() type(myinstance) => type<class main.myclass> Instance Knows its Class Because each instance has as its type the class that it was made from, an instance remembers its class. This is often called the instance-of relationship

6 Scope Local in the Instance We saw in Chapter 7 how scope works. It works differently in the class system, taking advantage of the instance-of relationship. Assignment to the instance makes the variable local: class myclass(object): pass myinst = myclass() myinst.myvar = 12 print myinst.myvar # prints Look Up the Instance-Of Link If the attribute is not stored in the instance, Python looks up the instance-of link to see if it is stored in the associated class. Look in the Class class myclass(object): myvar = 100 myinst = myclass() print myinst.myvar # prints Local Assignment Before Class This mix can lead to some tricky stuff: class myclass(object): myvar = 100 Methods myinst = myclass() yourinst = myclass() myinst.myvar = -1 print myinst.myvar # prints -1 print yourinst.myvar# prints 100 myclass.myvar = 500 print myinst.myvar # prints -1 print yourinst.myvar# prints

7 class myclass (object): classattribute = 'world' Code Listing 11.2 def mymethod (self, param1): print '\nhello %s' % (param1) print 'The object calling this method is: %s' %\ str(self) self.instanceattribute = param1 myinstance = myclass() print "output of dir(myinstance):" print dir(myinstance) myinstance.mymethod('world') print "Instance has new attribute with value: %s" %\ myinstance.instanceattribute Method versus Function Discussed before, a method and a function are closely related. They are both small programs that have parameters, perform some operation and (potentially) return a value. The main difference is that methods are functions tied to a particular object. Difference in Calling Functions are called, methods are called in the context of an object: function: dosomething(param1) method: anobject.dosomething(param1) This means that the object that the method is called on is always implicitly a parameter! Difference in Definition Methods are defined inside the suite of a class. Methods always bind the first parameter in the definition to the object that called it. This parameter can be named anything, but traditionally it is named self: class myclass(object): def mymethod(self,param1): dosomething More on Self self is an important variable. In any method it is bound to the object that called the method. Through self, we can access the internal structure of the instance

8 Back to the example class myclass (object): classattribute = 'world' def mymethod (self, param1): print '\nhello %s' % (param1) print 'The object calling this method is: %s \ str(self) self.instanceattribute = param1 Binding self newinstance = myclass() newinstance.printit() def myclass (object): def printit(self): self is Bound for Us When a dot method call is made, the object that called the method is automatically assigned to self. We can use self to remember, and therefore refer, to the calling object. To reference any part of the calling object, we must always precede it with self. The method can be written generically, dealing with all calling objects through self Writing a class Code Listing

9 class Student(object): def init (self,first='', last='', id=0): self.firstnamestr = first self.lastnamestr = last self.idint = id def update(self,first='',last='',id=0): if first: self.firsnamestr = first if last: self.lastnamestr = last if id: self.idint = id def str (self): return "%s %s, ID:%s" % \ (self.firstnamestr, self.lastnamestr, self.idint) Constructor There are some special methods that have certain pre-defined roles for all classes. One of the first we will learn is a constructor. Constructor is called when an instance is made and provides the class designer the opportunity to set up the instance with variables, by assignment Calling a Constructor Special Python Keywords As mentioned, a constructor is called by using the name of the class as a function call (by adding () after the class name): myinst = myclass() Creates a new instance using myclass. Again, Python has special uses for keywords that begin and end with. so far we have seen the doc attributed of a function with a doc string. In classes, we will see more of these special values The init Method One of the special method names in a class is the constructor name, init. By assigning values in the constructor, every instance will start out with the same variables. You can also pass arguments to a constructor through its init method. def init (self,first='', last='', id=0): self.firstnamestr = first self.lastnamestr = last self.idint = id self is bound to the default instance as it is being made. If we want to add an attribute to that instance, we modify the attribute associated with self

10 Default Constructor If you don t provide a constructor then only the default constructor is provided. The default constructor does system stuff to create the instance, nothing more. You cannot pass arguments to the default constructor Every Class Should Have init By providing the constructor, we ensure that every instance, at least at the point of construction, is created with the same contents. This gives us some control over each instance. def str (self): Printing return "%s %s, ID:%s" % \ (self.firstnamestr, self.lastnamestr, self.idint) What happens when we call print myinst? This is assumed, by Python, to be a call to convert the instance to a string, which is the str method. In the method, myinst is bound to self, and printing then occurs using that instance Now There are Three Class Designer There are now three groups in our coding scheme: user programmer, class user programmer, class designer The class designer is creating code to be used by other programmers. In so doing, the class designer is making a kind of library that other programmers can take advantage of

11 OOP Helps in Software Engineering Point Class, Code Listings Software engineering is the discipline of managing code to ensure its long-term use. Remember, SE via refactoring: takes existing code and modifies it makes the overall code simpler, easier to understand doesn t change the functionality, only the form! More Refactoring Hiding the details of what the message entails means that changes can be made to the object and the flow of messages (and their results) can stay the same. Thus the implementation of the message can change but its intended effect stays the same. This is encapsulation. OOP Principles Encapsulation: hiding design details to make the program clearer and more easily modified later. Modularity: the ability to make objects stand alone so they can be reused (our modules). I.e. the math module. Inheritance: create a new object by inheriting (like father to son) many object characteristics while creating or over-riding for this object. Polymorphism: (hard) Allow one message to be sent to any object and have it respond appropriately based on the type of object it is We are Still at Encapsulation Features of encapsulation: - hid details of the implementation so that the program was easier to read and write - modularity: make an object so that it can be reused in other contexts - providing an interface (the methods) that are the approved way to deal with the class Private Values

12 Class Namespaces are Dicts The namespaces in every object and module is indeed a namespace. That dictionary is bound to the special variable dict. It lists all the local vals (variables, functions) in the object. Example Namespace class myclass(object): x = 100 def mymethod(param1=500): print param1 >>> myclass. dict.items() [(' module ', ' main '), ('mymethod', <function mymethod at 0x12200f0>), (' dict ', <attribute ' dict ' of 'myclass' objects>), ('x', 100), (' weakref ', <attribute ' weakref ' of 'myclass' objects>), (' doc ', None)] Private Variables in an Instance Many OOP approaches allow you to make a variable or function in an instance private. Private means not accessible by the class user, only the class developer. There are advantages to controlling who can access the instance values. Privacy in Python Python takes the approach We are all adults here. No hard restrictions. Provides naming to avoid accidents. Use in front of any variable This mangles the name to include the class, namely var becomes _class var. Still fully accessible, and the dict makes it obvious Privacy Example class myclass(object): def init (self,p1='firstparam',p2='secondpa ram'): self.var1=p1 self. var2=p2 myinst = myclass() myinst. dict.items() [('_myclass var2', 'secondparam'), ('var1', 'firstparam')] 71 12