Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Week 5-7 PYTHON CLASS Defining Classes • Class: A user-defined prototype for an object that defines a set of attributes that characterize any object of the class. • The attributes are data members (class variables and instance variables) and methods, accessed via dot notation. Classes • Class variable: A variable that is shared by all instances of a class. • Class variables are defined within a class but outside any of the class's methods. • Class variables aren't used as frequently as instance variables are. Classes • Data member: A class variable or instance variable that holds data associated with a class and its objects. • Function overloading: The assignment of more than one behavior to a particular function. The operation performed varies by the types of objects (arguments) involved. Classes • Instance variable: A variable that is defined inside a method and belongs only to the current instance of a class. • Instance: An individual object of a certain class. • An object obj that belongs to a class Circle, for example, is an instance of the class Circle. Classes • Instantiation : The creation of an instance of a class. • Method : A special kind of function that is defined in a class definition. • Object : A unique instance of a data structure that's defined by its class. • An object comprises both data members (class variables and instance variables) and methods. Classes • Operator overloading: The assignment of more than one function to a particular operator. Python Scopes and Namespaces • A namespace is a mapping from names to objects. • Most namespaces are currently implemented as Python dictionaries, but that’s normally not noticeable in any way (except for performance), and it may change in the future. Examples of Namespaces • Examples of namespaces are: the set of builtin names (containing functions such as: • abs() • built-in exception names) • the global names in a module • the local names in a function invocation. • In a sense the set of attributes of an object also form a namespace. Attribute • By the way, I use the word attribute for any name following a dot. • for example, in the expression • z.real • real is an attribute of the object z. cont • Namespaces are created at different moments and have different lifetimes. • The namespace containing the built-in names is created when the Python interpreter starts up, and is never deleted. • The global namespace for a module is created when the module definition is read in; normally, module namespaces also last until the interpreter quits. cont • The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception that is not handled within the function. Scope • A scope is a textual region of a Python program where a namespace is directly accessible. “Directly accessible” here means that an unqualified reference to a name attempts to find the name in the namespace. Scope • Although scopes are determined statically, they are used dynamically. • At any time during execution, there are at least three nested scopes whose namespaces are directly accessible: cont • the innermost scope, which is searched first, contains the local names • the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names • the next-to-last scope contains the current module’s global names • the outermost scope (searched last) is the namespace containing built-in names cont • If a name is declared global, then all references and assignments go directly to the middle scope containing the module’s global names. • To rebind variables found outside of the innermost scope, the nonlocal statement can be used; if not declared nonlocal, those variable are read-only Scopes and Namespaces Example • This is an example demonstrating how to reference the different scopes and namespaces, and how global and nonlocal affect variable binding: Example def scope_test(): def do_local(): spam = "localspam" def do_nonlocal(): nonlocal spam spam = "nonlocalspam" def do_global(): global spam spam = "globalspam" spam = "testspam" do_local() print("Afterlocalassignment:", spam) do_nonlocal() print("Afternonlocalassignment:", spam) do_global() print("Afterglobalassignment:", spam) scope_test() print("Inglobalscope:", spam) output • • • • • The output of the example code is: After local assignment: test spam After nonlocal assignment: nonlocal spam After global assignment: nonlocal spam In global scope: global spam Note • Note how the local assignment (which is default) didn’t change scope_test‘s binding of spam. The nonlocal assignment changed scope_test‘s binding of spam, and the global assignment changed the module-level binding. • You can also see that there was no previous binding for spam before the global assignment. A First Look at Classes • Classes introduce a little bit of new syntax, three new object types, and some new semantics. • Class Definition Syntax class ClassName: <statement-1> . . . <statement-N> Class Definition • Class definitions, like function definitions (def statements) must be executed before they have any effect. • You could conceivably place a class definition in a branch of an if statement, or inside a function. Class Definition • In practice, the statements inside a class definition will usually be function definitions, but other statements are allowed, and sometimes useful. • The function definitions inside a class normally have a peculiar form of argument list, dictated by the calling conventions for methods. cont • When a class definition is entered, a new namespace is created, and used as the local scope — thus, all assignments to local variables go into this new namespace. In particular, function definitions bind the name of the new function here. cont • When a class definition is left normally (via the end), a class object is created. • This is basically a wrapper around the contents of the namespace created by the class definition; we’ll learn more about class objects in the next section. • The original local scope (the one in effect just before the class definition was entered) is reinstated, and the class object is bound here to the class name given in the class definition header (ClassName in the example). cont • Class objects support two kinds of operations: attribute references and instantiation. • Attribute references use the standard syntax used for all attribute references in Python: obj.name. • Valid attribute names are all the names that were in the class’s namespace when the class object was created. • So, if the class definition looked like this: cont • class MyClass: """A simple example class""" i = 12345 def f(self): return ’helloworld’ cont • then MyClass.i and MyClass.f are valid attribute references, returning an integer and a function object, respectively. • Class attributes can also be assigned to, so you can change the value of MyClass.i by assignment. __doc__ is also a valid attribute, returning the docstring belonging to the class: "A simple example class". cont • Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. • For example (assuming the above class): • x = MyClass() • creates a new instance of the class and assigns this object to the local variable x. cont • The instantiation operation (“calling” a class object) creates an empty object. Many classes like to create objects with instances customized to a specific initial state. • Therefore a class may define a special method named __init__(), like this: • def __init__(self): self.data = [] cont • When a class defines an __init__() method, class instantiation automatically invokes __init__() for the newly-created class instance. • So in this example, a new, initialized instance can be obtained by: • x = MyClass() • Of course, the __init__() method may have arguments for greater flexibility. • In that case, arguments given to the class instantiation operator are passed on to __init__(). Self Keyword and Constructor • Methods are added to the class with def. • The first argument to a method is the class instance. • By convention it is spelled "self". • self is a reference to the instance. Think of it (i n part) as a reference to the container for the data or state for the object. Self • In many object-oriented programming languages, the instance is hidden in the method definitions. • These languages typically explain this by sayin g something like "The instance is passed as an implicit first argument to the method." Self • In Python, the instance is visible and explicit in method definitions. • You must explicitly declare the instance as the first parameter of each (instance) method. • This first parameter is (almost) always spelled "self". Self • The self variable must be explicitly listed as th e first argument to a method. • You could spell it differently from "self", but d on't do so. • Instance variables are referred to with "self.XX X". Constructor • The constructor for a class is a method named __init__. • Constructor is initialization method that Python calls when you create a new instance of this class. For example • >>> class Complex: … def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5) Instance Objects • The only operations understood by instance objects are attribute references. • There are two kinds of valid attribute names, data attributes and methods. • Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to. Instance Objects • For example, if x is the instance of MyClass created above, the following piece of code will print the value 16, without leaving a trace: • x.counter = 1 while x.counter < 10: x.counter = x.counter * 2 print(x.counter) del x.counter cont • The other kind of instance attribute reference is a method. A method is a function that “belongs to” an object. • In Python, the term method is not unique to class instances: other object types can have methods as well. cont • Valid method names of an instance object depend on its class. • By definition, all attributes of a class that are function objects define corresponding methods of its instances. • So in our example, x.f is a valid method reference, since MyClass.f is a function, but x.i is not, since MyClass.i is not. • But x.f is not the same thing as MyClass.f — it is a method object, not a function object. Method Objects • Usually, a method is called right after it is bound: • x.f() • In the MyClass example, this will return the string ’hello world’. • However, it is not necessary to call a method right away: x.f is a method object, and can be stored away and called at a later time. • For example: • xf = x.f • while True: print(xf()) • will continue to print hello world until the end of time. cont • What exactly happens when a method is called? • You may have noticed that x.f() was called without an argument above, even though the function definition for f() specified an argument. • What happened to the argument? • Surely Python raises an exception when a function that requires an argument is called without any — even if the argument isn’t actually used... cont • Actually, you may have guessed the answer: the special thing about methods is that the object is passed as the first argument of the function. In our example, the call x.f() is exactly equivalent to MyClass.f(x). • In general, calling a method with a list of n arguments is equivalent to calling the corresponding function with an argument list that is created by inserting the method’s object before the first argument. Examples class Basic: def __init__(self, name): self.name = name def show(self): print('Basic name: %s' % self.name) def test(): obj1 = Basic('Apricot') obj1.show() test() Running the code • Running the above example produces the followi ng: • Basic name: Apricot • Notice how in our example an argument to the c onstructor is saved as an instance variable. • An instance is created by "calling" the class. • For example: obj1 = Basic('Apricot'). • In addition to __init__ there are other special me thod names of the form cont • "__XXX__", which are used to customize class es and their instances. • These are described at Python Language Refe rence Example class Employee: 'Common base class for all employees' empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print("Total Employee %d" % Employee.empCount) def displayEmployee(self): print("Name : ", self.name, ", Salary: ", self.salary) Creating instance objects • To create instances of a class, you call the class using class name and pass in whatever arguments its __init__ method accepts. • "This would create first object of Employee class" • emp1 = Employee("Zara", 2000) • "This would create second object of Employee class" • emp2 = Employee("Manni", 5000) Accessing attributes • You access the object's attributes using the dot operator with object. Class variable would be accessed using class name as follows: emp1.displayEmployee() emp2.displayEmployee() print("Total Employee %d" % Employee.empCount) Putting all together #!/usr/bin/python class Employee: 'Common base class for all employees‘ empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print "Total Employee %d" % Employee.empCount cont def displayEmployee(self): print "Name : ", self.name, ", Salary: ", self.salary #"This would create first object of Employee class" emp1 = Employee("Zara", 2000) #"This would create second object of Employee #class" emp2 = Employee("Manni", 5000) emp1.displayEmployee() emp2.displayEmployee() print "Total Employee %d" % Employee.empCount cont • When the above code is executed, it produces the following result: • Name : Zara ,Salary: 2000 • Name : Manni ,Salary: 5000 • Total Employee 2 • You can add, remove or modify attributes of classes and objects at any time: cont • emp1.age = 7 # Add an 'age' attribute. emp1.age = 8 # Modify 'age' attribute. del emp1.age # Delete 'age' attribute. Destructor - Destroying Objects (Garbage Collection) • Python deletes unneeded objects (built-in types or class instances) automatically to free memory space. • The process by which Python periodically reclaims blocks of memory that no longer are in use is termed garbage collection. cont • Python's garbage collector runs during program execution and is triggered when an object's reference count reaches zero. • An object's reference count changes as the number of aliases that point to it changes. cont • An object's reference count increases when it's assigned a new name or placed in a container (list, tuple or dictionary). • The object's reference count decreases when it's deleted with del, its reference is reassigned, or its reference goes out of scope. • When an object's reference count reaches zero, Python collects it automatically. cont • • • • • • • • • • • • a = 40 # Create object <40> b=a # Increase ref. count of <40> c = [b] # Increase ref. count of <40> del a # Decrease ref. count of <40> b = 100 # Decrease ref. count of <40> c[0] = -1 # Decrease ref. count of <40> cont • You normally won't notice when the garbage collector destroys an orphaned instance and reclaims its space. • But a class can implement the special method __del__(), called a destructor, that is invoked when the instance is about to be destroyed. • This method might be used to clean up any nonmemory resources used by an instance. Example • This __del__() destructor prints the class name of an instance that is about to be destroyed: #!/usr/bin/python class Point: def __init__( self, x=0, y=0): self.x = x self.y = y def __del__(self): cont class_name = self.__class__.__name__ print(class_name, "destroyed“) pt1 = Point() pt2 = pt1 pt3 = pt1 print(id(pt1), id(pt2), id(pt3)) # prints the ids of the objects del pt1 del pt2 del pt3 cont • When the above code is executed, it produces following result: • 3083401324 3083401324 3083401324 • Point destroyed Using Classes in Python • • • • Example # ClassOne.py Class Calculator(Object): “Define a class to simulate a simple calculator” • def __init__(self): #start with zero self.current = 0 Using Classes in Python • def add(self, amount): • # add number to current • self.current += amount • def getCurrent(self): • return self.current Using Classes in Python • To Class Calculator() in the file ClassOne.py do the following: • Make sure all your files are in one directory • Put your code that want to use the Class Calculator() in another file. • Write the following in the other file • from ClassOne import * • # get all from file ClassOne Example • • • • from ClassOne import * myBuddy = Calculator() myBuddy.add(2) print(myBuddy.getCurrent()) Tip • Initializing vars: Only constant initializers for class variables are allowed (n = 1). To initialize variables with non-constant values, you must use the constructor. You cannot declare uninitialized variables. Function Overloading • There is no function overloading in Python. • Unlike Java, a Python function is specified by its name alone. • The number, order, names, or types of its arguments cannot be used to distinguish between two functions with the same name. • Two different functions can’t have the same name, even if they have different numbers of arguments. Function Overloading • Following table lists some generic functionality that you can override in your own classes: Function Overloading SN Method, Description & Sample Call 1 __init__ ( self [,args...] ) Constructor (with any optional arguments) Sample Call : obj = className(args) 2 _del__( self ) Destructor, deletes an object Sample Call : dell obj 3 __repr__( self ) Evaluatable string representation Sample Call : repr(obj) 4 __str__( self ) Printable string representation Sample Call : str(obj) 5 __cmp__ ( self, x ) Object comparison Sample Call : cmp(obj, x) Operator Overloading • Suppose you've created a Vector class to represent two-dimensional vectors, what happens when you use the plus operator to add them? Most likely Python will yell at you. • You could, however, define the __add__ method in your class to perform vector addition and then the plus operator would behave as per expectation: Example • #!/usr/bin/python class Vector: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return 'Vector (%d, %d)' % (self.a, self.b) def __add__(self,other): return Vector(self.a + other.a, self.b + other.b) v1 = Vector(2,10) v2 = Vector(5,-2) print v1 + v2 When the above code is executed, it produces the following result: Vector(7,8)