Lecture 5. Introduction to Python! Lecture 5

Transcription

1 Lecture 5 Introduction to Python Lecture 5

2 Summary OOP Concepts Object trees Classes Attributes Methods

3 OOP OOP Inheritance Composition Allows a class to inherit the characteristics and behaviour as another class, by extending it to provide specific needs Allows a class achieve a specific functionality by containing instances of another classes working together, instead of inherit it from other classes

4 What are classes? An instrument helping us to define new stuff that reflect real objects, but in a programatic way Classes are Python program units, as the modules and functions are. They are another way for packing data and logic.

5 Classes distinctions Classes are factories for generating multiple objects with distinct namespaces. Multiple instances Classes Operator overloading Customization via inhertiance Classes can define objects that respond differently to some sort of operations We can extend a class by redefining its attributes outside the class itself. Classes can build up namespaces hierarchies.

6 Essence of Python OOP The essence of Python OOP is: object.attribute In Python, the attributes are fetched based on the first occurrence of attribute, by looking in object, then in classes above if in the object tree, from bottom to top and from left to right.

7 Object tree Classes are factories for generating multiple objects with distinct namespaces. Superclasses Subclass Instances represent the concrete items in a program s domain

8 Object tree Impl2.w object.attribute Impll2 -> C1 -> C2 -> C3 Impl2 inherits the w attribute from C3 Impll1.x and Impl2.x inherits x from C1 because is lower than C2 Impll1.y and Impl2.y inherits x from C1 because C1 is the only place it appears Impll1.z and Impl2.z inherits z from C2 because C2 is in the left in the objects tree. Impll1.name and Impl2.name find name in themselves without climbing in the objects tree

9 Python OOP model Factories for generating objects Class Objects Python OOP Model Instance Objects

10 Classes properties 1 class statement creates a class object and assigns it a name 2 Assignments inside class statements creates class attributes 3 Class attributes provide object state and behaviour

11 First example class Item: def set_data(self, val): self.data = val def display(self): print(self.data) x = Item() y = Item() print(id(x)) print(id(y)) print(id(item)) print(type(x)) print(type(y)) print(type(item)) Output: <class ' main.item'> <class ' main.item'> <class 'type'> Item.set_data.display is-a is-a x.data y.data

12 Setting data x.set_data("pink Floyd") y.set_data(2016) x.display() y.display() Output: Pink Floyd 2016 is-a Item.set_data.display is-a Neither x, nor y have a set_data attribute, so that the search mechanism in the objects tree is activated x.data y.data

13 Inheritance class DerivedItem(Item): def display(self): print("from DerivedItem {}".format(self.data)) z = DerivedItem() z.set_data("deep Purple") z.display() Output: From DerivedItem Deep Purple Item.set_data.display z.set_data OVERRIDING DerivedItem.display z.data z.display z.data The specialisation introduced in DerivedItem class is completely external to Item class. Item class remained unchanged.

14 Classes are attributes in modules Item item.py DerivedItem deriveditem.py import item class DerivedItem(item.Item): OR from item import Item class DerivedItem(Item): One can define as many classes we want in a module. Classes respect the same rule we ve talked about when modules were studied.

15 Attributes class rec: pass rec.name = 'Monty' rec.age = 33 print(rec.name) print(rec.age) a = rec() b = rec() print(a.name) print(a.age) print(b.name) print(b.age) print(rec. dict.keys()) print(a. dict.keys()) print(b. dict.keys()) a.name = 'Pink Floyd' a.age = 50 print(a.name) print(a.age) print(b.name) print(b.age) print(a. dict.keys()) Output: Monty 33 Monty 33 Monty 33 dict_keys([' doc ', ' weakref ', ' module ', ' dict ', 'age', name']) dict_keys([]) dict_keys([]) Pink Floyd 50 Monty 33 dict_keys(['age', 'name'])

16 Class example class Person: def init (self, name, job, pay): self.name = name self.job = job self.pay = pay person = Person("Monty Python", "humour", 1000) print(person.name) print(person.job) print(person.pay) class Person: def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay person = Person("Monty Python", "humour", 1000) new_person = Person("Pink Floyd") print(person.name) print(person.job) print(person.pay) print(new_person.name) print(new_person.job) print(new_person.pay) Monty Python humour 1000 Monty Python humour 1000 Pink Floyd None 0 constructor state information Output: Output: testing the code called automatically when the instance is created

17 Importing or running the Python module Like any other Python file, it can be launched from the command line also, but also when the file is imported as a module. from command line from import >>> import person Monty Python humour 1000 Pink Floyd None 0 In both cases, one can notice some unwanted output, the print statements after the class definition.

18 Fixing the module import class Person: def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay if name ==' main ': person = Person("Monty Python", "humour", 1000) new_person = Person("Pink Floyd") print(person.name) print(person.job) print(person.pay) print(new_person.name) print(new_person.job) print(new_person.pay) Output: >>> import person >>>

19 Adding new methods to the class class Person: def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay def getlastname(self): return self.name.split()[-1] def setraise(self, percent): self.pay = int(self.pay * (1 + percent)) if name ==' main ': person = Person("Monty Python", "humour", 1000) person.setraise(.30) print(person.name) print(person.getlastname()) print(person.job) print(person.pay) Monty Python Python humour 1300 Output: methods are normal functions attached to classes, designed to process instances of those classes

20 Operator overloading (1) Having the Person class, suppose we want to display info about the instance of that class class Person: def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay def getlastname(self): return self.name.split()[-1] def setraise(self, percent): self.pay = int(self.pay * (1 + percent)) if name ==' main ': person = Person("Monty Python", "humour", 1000) print(person.name) Output: < main.person object at 0x1016e1fd0> This information is not too useful to us

21 Operator overloading (2) Having the person class, suppose we want to display info about the instance of that class class Person: def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay def getlastname(self): return self.name.split()[-1] def setraise(self, percent): self.pay = int(self.pay * (1 + percent)) def str (self): return "[ Person: {}, {} ]".format(self.name, self.job) if name ==' main ': person = Person("Monty Python", "humour", 1000) print(person) Output: [ Person: Monty Python, humour ] This information is now more useful The str method is run automatically every time when an instance is converted in its print string

22 Attributes Attributes are all the data stored by the objects in the non-method scope Owned by particular instances of a class Each instance has its own value of it Data Attributes Attributes The most common kind of attribute Owned by particular instances of a class Class Attributes All class instances share the same value Good for class-wide constants and counters for class instances Analogy with the static variables in other languages

23 Data Attributes class Person: def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay inside a class, refer to the data attributes by using self: self.name created and initialised in the init method

24 Class attributes class Person: count_ref = 0 def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay def getlastname(self): return self.name.split()[-1] def setraise(self, percent): self.pay = int(self.pay * (1 + percent)) def str (self): return "[ Person: {}, {} ]".format(self.name, self.job) def increment_count_ref(self): self. class.count_ref += 1 if name ==' main ': person_one = Person("Monty Python", "humour", 1000) person_two = Person("Pink Floys", "music") print(person_one.count_ref) print(person_two.count_ref) person_one.increment_count_ref() print(person_one.count_ref) print(person_two.count_ref) Output: All instances of a class share one copy of a class attribute Class attributes are defined outside of any method Because there is one attribute per class and not per instance, they are accessed different, like: self. class.attribute

25 Customization by inheritance Let s refine our class definition by defining another class, this time more specialised, called Manager, for which we replace the setraise method with a new one, in which after setting the pay attribute, a bonus will be added. Approach 1 (bad) class Manager(Person): def setraise(self, percent, bonus=0.10): self.pay = int(self.pay * (1 + percent + bonus)) Approach 2 (good) class Manager(Person): def setraise(self, percent, bonus=0.10): Person.setRaise(self, percent + bonus) A class method can be called through an instance: instance.method(args ) but it is automatically translated by Python to class.method(instance, args )

26 Customization by inheritance class Person: count_ref = 0 def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay def getlastname(self): return self.name.split()[-1] def setraise(self, percent): self.pay = int(self.pay * (1 + percent)) def str (self): return "[ Person: {}, {}, {} ]".format(self.name, self.job, self.pay) def increment_count_ref(self): self. class.count_ref += 1 class Manager(Person): def setraise(self, percent, bonus=0.10): Person.setRaise(self, percent + bonus) if name ==' main ': person_one = Person("Monty Python", "humour", 1000) person_two = Manager("Pink Floyd", "music", 1000) person_one.setraise(.20) person_two.setraise(.20) print(person_one) print(person_two) Output: [ Person: Monty Python, humour, 1200 ] [ Person: Pink Floyd, music, 1300 ]

27 Polymorphism class Person: count_ref = 0 def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay def getlastname(self): return self.name.split()[-1] def setraise(self, percent): self.pay = int(self.pay * (1 + percent)) def str (self): return "[ Person: {}, {}, {} ]".format(self.name, self.job, self.pay) def increment_count_ref(self): self. class.count_ref += 1 class Manager(Person): def setraise(self, percent, bonus=0.10): Person.setRaise(self, percent + bonus) if name ==' main ': person_one = Person("Monty Python", "humour", 1000) person_two = Manager("Pink Floyd", "music", 1000) person_three = Person("Sherlock Holmes", "detective", 2000) for obj in (person_one, person_two, person_three): obj.setraise(.20) print(obj) Output: [ Person: Monty Python, humour, 1200 ] [ Person: Pink Floyd, music, 1300 ] [ Person: Sherlock Holmes, detective, 2400 ] Python runs the appropriate setraise() method for every object in the provided tuple, regardless of the object s type

28 Customizing constructors Let s improve the Manager class now, by providing the job name automatically, by redefining its init method. class Person: count_ref = 0 def init (self, name, job=none, pay=0): self.name = name self.job = job self.pay = pay def getlastname(self): return self.name.split()[-1] def setraise(self, percent): self.pay = int(self.pay * (1 + percent)) def str (self): return "[ Person: {}, {}, {} ]".format(self.name, self.job, self.pay) def increment_count_ref(self): self. class.count_ref += 1 class Manager(Person): def init (self, name, pay): Person. init (self, name, 'manager', pay) def setraise(self, percent, bonus=0.10): Person.setRaise(self, percent + bonus) if name ==' main ': person_one = Person("Monty Python", "humour", 1000) person_two = Manager("Pink Floyd", 1000) person_three = Person("Sherlock Holmes", "detective", 2000) for obj in (person_one, person_two, person_three): obj.setraise(.20) print(obj) Output: [ Person: Monty Python, humour, 1200 ] [ Person: Pink Floyd, manager, 1300 ] [ Person: Sherlock Holmes, detective, 2400 ] Python calls init method only once, at the construction time, by looking in the class tree, and taking the lowest one. If an upper init method in the class tree is needed, it must be manually called

29 Special data items Attribute Description doc class module dict Variable for documentation string for class Variable which gives a reference to the class from any instance of it Variable which gives a reference to the module in which the particular class is defined The dictionary that is actually the namespace for a class, but not its superclasses

30 Deleting instances When you are done with an instance, there is no need to delete it explicitly Python has an automatic garbage collector Python automatically detects when all references to a block of memory are becoming out-of-scope, then frees that memory by invoking the garbage collector There is no explicit destructor method in Python classes