Object Oriented Programming python

vike681

Object Oriented Programming python

　　new concepts of the object oriented programming :
　　class
　　encapsulation
　　inheritance
　　polymorphism
　　the three features of an object are : identity, state and behaviora class is an abstraction which regroup objects who have the same attributes and the same methods.
　　an object is then an instance of the corresponding class, and it is distinguished from the other instances by its identity and the value of its attributes.
　　an attribute or a method is privates if their use is forbidden outside of the class.
　　an attribute or a method is public if their use is allowed outside of the class.
　　getter : public method, to return an attribute’s value.
　　setter : public method, to save an attribute’s value
　　inheritance : relation of specialisation / generalization between two class. it indicates that a class named daughter class specialised another class called mother class. i.e. which own the same methods and attributes of the mother class plus some more which are its own.
　　ascending : if we use the generalization way, we can find identical attributes and methods in different classes, the inheritance allow you to factor them in order to simplify the creation and the maintenance of the code.
　　descending : if we use the specialisation way, we create specialised classes for a normal one. the level we want. this is a common way when we want to use again some classes.
　　multiple inheritance : a normal class can own multiple mother class.
　　some difficulties may appear when the mother classes own some methods that have the same name and that are not redefine inside the daughter class.
　　polymorphism(多态性) : a mechanism which allows a subprogram to redefine a method it inherit and for which it will keep the same signature.
　　depending on the context, the program will choose the right method.
　　the code may be generated more easily. we can call the same named methods but they will produce a deferent effect depending on the type of the object.
　　variables in python
　　python basic type :
　　int : integers
　　float : decimals
　　complex(复数) : complex
　　bool : booleans
　　str : strings
　　dynamic typing :
　　before using a variable you do not need to explicitly declare its type, the interpreter takes care of that.
　　this will be done as soon as you assign a value to this variable.
　　strong typing :
　　available operations on a variable totally depend on its type.
　　implicit type conversions to perform certain operations are prohibited.
　　syntax : myVariable = value
　　syntax : var1, var2, … = val1, val2,…
　　one can always check the type of a variable with the command “type”
　　e.g. : type(myVariable)
　　using the console mode, one can display the content of a variable just by typing in its name.
　　to make a display on the console from a script, and / or to perform more sophisticated displays we will need the print command.
　　syntax : print(expr_1, expr_2, …, sep = ‘ ‘, end = ‘\n’)
　　note : sep shows what will separate these expressions, by default it is a space. end states that will be displayed at the end after all the expressions, by default it is a return line.(\n)
　　eg : age = 30
　　print(“I am”, age, “years old and in two years I will be “, age+2, “years old”)
　　e.g. : print(“des”, “traits”, ”bas”, ”pour”, ”séparer”, sep’_’)
　　print(“et”, “des”, “plus”, “a”, “la”, “suite”, sep=‘_’, end=‘+++’)
　　print(“et la fin”)
　　input
　　syntax : var = input(expression)
　　note : expression is optional, it is just used to make a display on the input line. what the user will input will be assigned to a var as a string.
　　eg : a = input
　　12
　　print(a, type(a))
　　b = eval(input(“enter a number : “))
　　enter a number : >? 12
　　print(b, type(b))
　　conditional structure
　　comparison operators :
　　< <= > >= == !=
　　logical operator :
　　or
　　and
　　not
　　syntax of a simple test :
　　if conditional :
　　block of statements to execute if the conditional is true
　　eg : x = eval(input))
　　if x < 0 :
　　x = -x
　　print(x)
　　note : blocks of instructions are defined in two ways : (previous line ends with a colon “:” / the entire block is intended according to the instructions preceding and following it.
　　syntax of a test with an alternatives :
　　if conditional :
　　block of statements to execute if the conditional is true
　　else :
　　block of statements to execute if the conditional is true
　　eg : n = eval(input())
　　if n%2 == 0 :
　　print(“the number entered is even”)
　　else :
　　print(“the number entered is odd”)
　　syntax of a test with several alternatives :
　　if conditional :
　　block of statements to execute if the conditional is true
　　elif otherConditional :
　　block of statements to execute if the conditional is true
　　else :
　　block of statements to execute if the conditional is true
　　eg :x = eval(input())
　　if x < 0 :
　　print(“the number entered is strictly negative “)
　　elif x > 0 :
　　print(“the entered number is strictly positive”)
　　else :
　　print(“the number entered is zero”)
　　iterative structure
　　range
　　syntax : range(start, end, step)
　　note : this function produces a range of values from start(included) to end(not included) with a specified step. the default start and step are 0 and 1 respectively.
　　eg : range(6)
　　eg : range(3.6)
　　eg : range(3,10,2)
　　eg : range(6,0,-1)
　　for
　　syntax : for var in range(start, end, step) :
　　block of instructions to be repeated while var takes the values of the range defined by range.
　　eg : n = eval(input())
　　for i in range(1,11) :
　　print(i, ’*’, n, ’=‘, n*i)
　　eg : for i in range(20, -1, -2) :
　　print(i)
　　while
　　syntax : while conditional :
　　block of instructions to be excited until the conditional is true
　　eg : x = eval(input())
　　n = 0 while n+1 <= x :
　　n+=1
　　print(“la par tie enti&egrave;re de”, x, “est”, n)
　　subroutine
　　procedures
　　syntax : def myProcedure(para1, para2, …, paraN) :
　　Instruction bloc of the procedure
　　eg : def rectangle(x,y) :
　　print( >>perimeter : “,2*(x+y)”,”.area :”, x*y)
　　e.g. : def displayGoldenNum() :
　　print((1+sprt(5))/2)
　　functions
　　syntax : def myFunction(para1, para2, …, paraN) :
　　instruction bloc of the function
　　return value
　　eg : def cube(x) :
　　return x*x*x
　　eg : deg calculMiniMaxi(x,y) :
　　id x < y :
　　return x,y
　　else :
　　return y,x
　　e.g. : print(cube(5))
　　a,b = 5, -2
　　min, max = calculMiniMaxi(a,cube(b))
　　print(“Minimum : “, min, “, Maximum :”, max)
　　duck typing
　　eg : def addition(x,y) :
　　return x + y
　　print(addition(666,1))
　　print(addition(“Brown”, ’Sugar’))
　　default parameters
　　eg : def rectangle(x=3, y=1) :
　　print(  >> perimeter : “, 2*(x+y), >>area :”, x+y)
　　rectangle(0) (result is 8,3)
　　rectangle(2) (result is 6,2)
　　rectangle(7,5) (result is 24,35)
　　immutable parameters(不变的）
　　local and global variables
　　eg : def sommeEntiers(n) :
　　somme = 0
　　for i in range)n+1) :
　　somme += i
　　return somme
　　modules of functions(extension file “.py” that contains subroutines.)
　　project structure
　　three methods to import a module :
　　from NameOfAModule import *
　　from NameOfAModule import aFunction
　　import NameOfAModule
　　sequential data structures
　　sequence concept
　　following elements accessible by position.
　　each element, except the first, has a predecessor and except the last one, a successor.
　　access an element
　　mySequence[wantedPosition]
　　the three main types of sequences :
　　the lists(whose elements are arbitrary and changeable)
　　syntax of the declaration of a list :
　　myEmptyList= [ ]
　　myListWithOneElement= [ ]
　　myListe= [element1, element2, …, elementN]
　　e.g. : myList = [2, -3, [‘xox’, 69],11]
　　print(myList) result is [2, -3, [‘xox’, 69],11]
　　print(myList[-1]) result is 11
　　myList[1] = 666
　　print(myList[1]) result is 666
　　print(myList[2] [0] [1]) result is o
　　N-Tuples(whose elements are arbitrary and unchangeable)
　　syntax of the declaration of N-tuples :
　　myEmptyTuple= ()
　　myTupleWithOneElement= (element)
　　myTuple= (element1, element2, …, elementN)
　　e.g. : myTuple=(2.718, 3.14, 1.414)
　　print(myTuple) result is (2.718, 3.14, 1.414)
　　print(myTuple[2]) result is 1.414
　　myTuple[2] = 1.732 result is error
　　s
　　s[i:j] : from i(included) to j(excluded).
　　s[i:j:k] : from j(included) to j(excluded) step by k.
　　eg : t = (7, -3, 2, 11, 666, -1975)
　　t[3:] result is (11, 666, -1975)
　　t[1:4] result is (-3, 2, 11)
　　t[1::2] result is (-3, 11, -1975)
　　t[23] result is error
　　x in s
　　x not in s
　　s + t
　　s * n or n * s
　　len(s)
　　min(s)
　　max(s)
　　s.count(x)
　　s.index(x)
　　iterating over the elements :
　　for x in enumerate(mySequence) :
　　对x的操作
　　eg : l = [-2, 3, 11]
　　for x in l :
　　print(x**2)
　　iterate over the pairs(index, element)
　　for i, x in mySequence :
　　对x和i的操作
　　e.g. : str = "Alex is the best"
　　for index in range(len(str)) :
　　print(“The index : “, index, “and the letter is : “, str[index])
　　e.g. : str = "Alex is the best"
　　for index, letter in enumerate(str) :
　　print("The index :", index, "and the letter is :", letter)
　　lists
　　operations to edit a list :
　　s = x
　　s[i:j] = t
　　del(s[i:j])
　　s[i:j:k] = t
　　del(s[i:j:k])
　　e.g. : myList = [1,2,3,4,5]
　　myList[2:3] = (6,’x’,7)
　　print(myList)
　　myList[1:6:2] = ‘sup’
　　print(myList)
　　processing operations :
　　list(s)
　　s.append(x)
　　s.extend(t)
　　s.insert(i,x)
　　s.clear()
　　s.remove(x)
　　s.pop(i)
　　s.reverse()
　　s.sort()
　　e.g. : myList = [1,3,5]
　　myList.append(7)
　　print(myList)
　　myList.extend((8,11))
　　print(myList)
　　myList.remove(8)
　　myList.insert(4,9)
　　print(myList)
　　strings(whose elements are characters and are not editable)
　　pay attention to the initialisation of multi-dimentional lists.
　　e.g. : board = [ [0]*3 for i in range(4)]
　　print(board)
　　board[3][2] = 666
　　print(board)
　　e.g. : board = [ [0]*3]*4
　　print(board)
　　board[3][2] = 666
　　print(board)
　　e.g. : board = [ [0]*3 for i in range (4)]
　　board[3][2] = 666
　　for ligne in board :
　　for x in ligne :
　　print(x, ‘ ‘, end = ‘ ‘ )
　　print(‘\n’)
　　N-tuples
　　note : you can not modify the elements of a t-tuple, delete, add others.  a tuple pass&eacute;
　　operation to create a tuple :
　　e.g. : myTuple = tuple(my Sequence)  (turns a sequence into a tuple)
　　e.g. : myTuple = tuple(range(0, 9, 2))
　　myTuple
　　myTuple = tuple(“The Decemberist”)
　　myTuple
　　note : if we want to define a sequence of data that we do not want to change, use a tuple secure this. iterating over thhe elements of a t-tuple is a faster than those on a list. a function that returns “multiple values” actually returns a tuple.
　　a comment in python begins with “#”
　　from function import *(调用python的库函数)
　　from random import randint(调用randint)
　　how many bananas do you want to start with(add number required) 9
　　which player should  start ? computer = (2), you = (1) 1
　　there are 9 bananas remaining
　　how many bananas do you want to take ? (1, 2 or 3)
　　3
　　player took 3 bananas.
　　computer took 3 bananas.
　　there are 3 bananas remaining
　　how many bans do you want to take ? (1, 2 or 3)
　　2
　　player took 2 bananas.
　　computer took 3 bananas.
　　game over
　　class and objects
　　learn how to declare a class
　　know how to built an object and initialise its attributes
　　be able to manipulate the class members according to their visibilities
　　declare a class
　　syntax : class className:
　　“ ” “ class documentation ” ” ”
　　we can access to the documentation of a class by the command : className.__doc__
　　to create an object of an existing class
　　syntax : myObject = className()
　　e.g. : class account:
　　“ ” ” management of a bank account ” ” ”
　　myAccount = account()
　　print(myAcccount)
　　print(myAccount.__doc__)
　　adding dynamic attributes:
　　syntax : myObject.myAttribute = value
　　e.g. : class account:
　　“ ” ” management of a bank account ” ” ”
　　myAccount = account()
　　myAccount.name = “PersonnalAccount”
　　myAccount.number = 666
　　myAccount.balance = -1000
　　declaration of methods within a class
　　syntax : class className:
　　“ “ “ class documentation “ “ “
　　def method1(self, para1, para2,…) :
　　…
　　def method2(self, para1, para2,…) :
　　…
　　note : self refer to the current object.
　　e.g. : class account:
　　“ “ “ management of a bank account “ “ “
　　def credit(self, x) :      
　　self.balance += x
　　def showBalance(self):
　　print(“The balance is : “, self.balance)
　　myAccount = account( )
　　myAccount.name = >>PersonnalAccount”
　　myAccount.numbers = 6666
　　myAccount.balance = -1000
　　myAccount.credit(500)
　　myAccount.showBalance( )
　　declaration of a class method
　　syntax : class className:
　　“ “ “ class documentation “ “ “
　　@classmethod
　　def myClassMethod(cls, para1, …) :
　　…
　　eg :
　　access to a class method
　　syntax : myClass.myClassMethod(…)
　　syntax : anObject.myClassMethod(…)
　　e.g. : myAccount = account( )
　　account.numberAccount +=1
　　account.showNumberAccounts( )
　　myOtheraccount = account( )
　　account.numberAccount += 1
　　myOtheraccount.showNumberAccounts( )
　　
　　constructors and destructors
　　the method <<__init_->>
　　syntax of the declaration of the method:
　　class className:
　　“ “ “ class documentation “ “ “
　　def __init__(self, para1, para2, …) :
　　…
　　def method1(self, para1, para2, …) :
　　…
　　eg :
　　default value of the attributes
　　e.g. : class account:
　　“ “ “ management of a bank account “ “ “
　　def __init__(self, name = “person”, number = 666, value = 1000):
　　self.name = name
　　self.number = number
　　self.balance = value
　　def showBalance(self) :
　　print( >>The balance is : “, self.balance)
　　myAccount = account(“pro”,777,10000)
　　myAccount.showBalance( )
　　myOtherAccount = account( )
　　my      OtherAccount.showBalance( )
　　the method <<__del__>>
　　syntax of method declaration __del__ :
　　class className:
　　“ “ “ class documentation “ “ “
　　def __init__(self,para1,para2,…):
　　def __del__(self):
　　…
　　def method1(self,para1,para2,…):
　　…
　　encapsulation
　　syntax to declaw a private attributes :
　　def __init__(self, para1,para2,…):
　　publicAttribute = value
　　__privateAttribute = value
　　…
　　getter : a method returning the value of an attributes.
　　eg :
　　setter : a method fixing the value of an attribute.
　　eg :
　　
　　中文海战游戏
　　game
　　-player1 : player
　　-player2 : player
　　-current : int
　　-hasWinner
　　+initiation
　　+changeTurn
　　+playOneTurn
　　+checkWinner
　　player
　　-playerBoard : pB
　　-historyBoard : hB
　　-name : str
　　-fleet : Fleet
　　+play()
　　+fire()
　　+
　　board
　　-list[ ][ ] : str
　　-
　　+draw()
　　+
　　boat
　　-letter : str
　　-state : int
　　-state : bool
　　-list[x,y]
　　+checkSpace
　　+sendPosition
　　+
　　fleet
　　-coordinate[(1,1),(1,2),(1,3),(1,4),(1,5)]
　　-
　　+
　　
　　inheritance
　　simple inheritance
　　concept reminder
　　inheritance : relation of specialization/generalization between two classes. it indicate that a class named daughter class specialised another class called mother class, i.e. which own the same method and attributes of the mother class plus some which are its own.
　　general syntax
　　syntax of the declaration of an inheritance relationship :
　　class superClass:
　　“ “ “ a super class “ “ “
　　…
　　class subClass(superClass):
　　“ “ “ a subclass inheriting from the superclass” “ “
　　e.g. : class rectangle:
　　“ “ “ rectangle management “ “ “
　　…
　　class box(rectangle):
　　“ “ “ box management ” “ “
　　the protected visibility
　　public : attributes are accessible from anywhere.
　　private : attributes are accessible only within the class.
　　protected : attributes are limited to the class and its descendants.
　　syntax to declare an attribute protected :
　　during the implementation of the “__init__” method, we use a simple “_” before the name of the attribute:
　　def __init__(self,para1,para2,…):
　　publicAttribute = value
　　_protedtedAttribute = value
　　__privateAttribute = value
　　…
　　e.g. : class rectangle:
　　def __init__(self,x,y):
　　self._x = x
　　self._y = y
　　def surface(self):
　　return self._x*self._y
　　note : indeed, we will still be able to access the attribute from outside the class. in python, the declaration of a protected attribute with a visibility is only an indication towards the class users.
　　subclass constructor
　　first syntax : class subClass(superClass):
　　“ “ “ documentation of the subclass “ “ “
　　def __init__(self,para1,para2,…):
　　superClass.__init__(self,para1,…)
　　…
　　e.g. : a class box inheriting the previous rectangle class.
　　class box(rectangle):
　　def __init__(self,x,y,z):
　　rectangle.__init__(self,x,y)
　　self.__z = z
　　def volume(self):
　　return self._x*self._y*self.__z
　　photo = rectangle(3,4)
　　print(photo.surface())
　　weston = box(3,4,10)
　　print(weston.volume())
　　second syntax : class subClass(superClass):
　　“ “ “ documentation of the subclass “ “ “
　　def __init__(self,para1,para2,…):
　　super().__init__(para1,…)                                                                                       …
　　e.g. : class box(rectangle):
　　def __init__(self,x,y,z):
　　super().__init__(x,y)
　　self.__z = z
　　def volume(self):
　　return self._x*self._y*self._z
　　members transmission
　　back to the transmission of members(attributes and methods) according to their visibility.
　　e.g. : use of a public method of the parent class in the subclass.
　　class box(rectangle):
　　def __init__(self,x,y,x):
　　super().__init__(x,y)
　　self.__z = z
　　def volume(self):
　　return super().surface()*self.__z
　　e.g. : use of a public method of the parent class in the subclass.
　　class box(rectangle):
　　def __init__(self,x,y,z):
　　super().__init__(x,y)
　　self.__z = z
　　def volume(self):
　　return self.surface()*self.__z
　　e.g. : use of protected attributes of the superclass in the subclass.
　　class box(rectangle):
　　def __init__(self,x,y,z):
　　rectangle.__init__(self,x,y)
　　self.__z = z
　　def volume(self):
　　return self._x*self._y*self.__z
　　e.g. : impossible to use private attribute of the superclass in the subclass.
　　
　　
　　multiple inheritance
　　concept reminder
　　multiple inheritance : possibility for a class to have multiple superclass.
　　general syntax
　　syntax for the declaration of a multiple inheritance relationship :
　　class superClass1:
　　“ “ “ a super class “ “ “
　　class superClass2:
　　“ “ “ a super class “ “ “
　　class subClass(superClass1,superClass2,…):
　　“ “ “ a subclass inheriting from superClass1 and superClass2 “ “ “
　　e.g. : class carnivorous:
　　“ “ “ managements carnivorous “ “ “
　　…
　　class herbivorous:
　　“ “ “ managements of herbivorous “ “ “
　　class omnivorous(carnivorous,herbivorous):
　　“ “ “ management omnivores “ “ “
　　…
　　subclass constructor
　　note : the subclass constructor must make an explicit call to the manufacturers of mother classes to initialise the attributes inherited from them.
　　syntax of the constructor :
　　class subClass(superClass1,superClass2,…):
　　“ “ “ subclass documentation “ “ “
　　def __init__(self,para1,para2,…):
　　superClass1.__init__(self,para1,…)
　　superClass2.__init__(self,para1,…)
　　…
　　e.g. : class carnivorous:
　　def __init__(self,p):
　　self,_meatWeight = p
　　def nomNomNom(self):
　　print(<< I eat ”,self._meatWeight, << kg of stack everyday”)
　　class herbivorous:
　　def __init__(self,p):
　　self._herbWeight = p
　　def crunchCrunch(self):
　　print( << I eat “, self._herbWeight, << kg of herb everyday”)
　　e.g. : class omnivore(carnivorous,herbivorous):
　　def __init(self,mw,hw,h):
　　carnivorous.__init__(self,pv)
　　herbivorous.__init__(self,ph)
　　self.__human = h
　　eg : teddy = omnivore(10,5,False)
　　teddy.nomNomNom()
　　teddy.crunchCrunch()
　　search in the hierarchy
　　consider a multiple inheritance relationship type :
　　class subClass(superClass1,superClass2,superClass3…):
　　“ “ “ a subClass inheriting from superClass 2 and 3 “ “ “
　　…
　　note : if an object of class subClass called a method that does not belong to this class, the search will be from left to right in the list of parent classes. this means that we will look if the class “superClass1” has the method in question : if so, we apply this method and search is over. if not, consider the class “superClass2”.ect.
　　e.g. : class a:
　　“ “ “ a class a “ “ “
　　def example(self):
　　print(“I fount it in a”)
　　class b:
　　“ “ “ a class b” “ “
　　def example(self):
　　print(“I found it in b”)
　　class c(a,b):
　　“ “ “a class that inherits from c and b “ “ “
　　test = c()
　　test.example()
　　inheritance vs composition
　　the composition relationships
　　principle of composition relationship : it modelise an relationship between two instances of two classes. the object of the container class thus have an attribute that is an object of the contained class.
　　note : one can use a composition relationship between classes if you can establish a link of the type has or owns.
　　e.g. : a car has a license plate
　　a book owns pages.
　　a simple example
　　consider a class point with two attributes : abscissa(横坐标) ordinate（纵坐标）
　　we will then declare a class disk, which also possess two attributes : radius(a real number) center, which will be the object of class point.
　　e.g. : class point:
　　def __init__(self,x,y):
　　self.__x = x
　　self.__y= y
　　def getx(self):
　　return self.__x
　　def gety(self):
　　return self.__y
　　e.g. a disk class(圆类)
　　class disc:
　　def __init__(self,x,y,r):
　　self.__r = r
　　self.__center = point(x,y)
　　def surface(self):
　　return 3.14*self.__r**2
　　def getCenter(self):
　　return self.__center
　　cd = disc(-1,2,5)
　　print(“abscissa of the center:”, cd.getCenter().getx())
　　print(“ordinate of the center:”, cd.getCenter().gety())
　　note : abscissa is -1, ordinate is 2.
　　the inheritance in another way
　　in some cases it is quite possible technically to use composition relationship instead of an inheritance relationship. Instead of having a B class that inherits from a class A, we declare in b an attribute that will be an instance of class A.
　　Eg : class rectangle:
　　def __init__(self,x,y):
　　self.__x = x
　　self.__y = y
　　def surface(self):
　　return self.__x*self.__y
　　def getx(self):
　　return self.__x
　　def gety(self):
　　return self.__y
　　class boxBis:
　　def __init__(self,x,y,z):
　　self.base = rectangle(x.y)
　　self.__z = z
　　def volume(self):
　　return self.base.getx()*
　　self.base.gety()*self.__z
　　weston = boxBis(2,3,5)
　　print(Weston.base.surface())
　　print(Weston.volume())
　　note : the result is 6 and 30
　　what to choose?
　　The relationship between classes is in the shape like “is a “.  The relationship between classes is of the form “a one”.
　　Note : you may also prefer a composition relationship in order to respect the principle of encapsulation. The relationship of composition is also easier to maintain in the event of changer to the code.
　　
　　the concept of polymorphism
　　implement the polymorphism
　　adapt the usual operators to the classes that we are defining
　　present one of the flexibility of python : the duck typing
　　redefinition of the methods
　　concept reminder
　　polymorphism : mechanism that permit to a daughter class to redefine a method that she inherit ate from her mother class. this permit us to adapt the method’s treatment to the specification of the daughter class.
　　taking place
　　note : the polymorphism, i,e, the choice of the right method to use will automatically be made in function of object’s nature.
　　e.g. : class rectangle:
　　def __init__(self,x,y):
　　self._x = x
　　self._y = y
　　def surface(self):
　　return self._x*self._y
　　class paveDroit(rectangle):
　　def __init__(self,x,y,z):
　　super().__init__(x.y)
　　self.__z = z
　　def surface(self):
　　return 2*(self._x*self._y+self._x*self.__z+self._y*self.__z)
　　photo = rectangle(3,4)
　　print(photo.surface())
　　weston = paveDroit(3,4,10)
　　print(weston.surface())
　　operator overload
　　principle
　　when we create classes, it is natural to want to adapt the usual operators to be able to apply it on the objects.
　　when we say usual operators, we mean the logical and the arithmetic operators.
　　this creation of new version is called overload.
　　e.g. : for the class “rectangle”, we want for example, overload the “<” operator in order to classify the rectangles in function of the value of their surface.
　　or the “*” operator which will multiply the length and the width of the two rectangles in order to create a third one.
　　taking place
　　we will assume that the operator that we want to overload are like methods of the class.
　　the name of the method corresponding to an operator will be written like :
　　__NameOfTheOperator__
　　if the operator is unary(一元的)，the method will only have the current object in a parameter.
　　e.g. : def __NameOfTheOperator__(self):
　　…
　　if the operator is binary, the method will have the current object in a parameter and another object.
　　e.g. : def __NameOfTheOperator__(self,other):
　　…
　　operators arithmetics :
　　+ : __add__(self,other)
　　- : __sub__(self,other)
　　* : __mul__(self,other)
　　/ : __dv__(self,other)
　　// : __floordiv__(self,other)
　　% : __mod__(self,other)
　　** : __pow__(self,other)
　　+= : __iadd__(self,other)
　　-= : __isub__(self,other)
　　*= : __imul__(self,other)
　　/= : __idiv__(self,other)
　　//= : __ifloordiv__(self,other)
　　%= : __imod__(self,other)
　　**= : __ipow__(self,other)
　　some unary operators :
　　- : __neg__(self)
　　abs() : __abs__(self)
　　bin : __bin__(self)
　　oct : __oct__(self)
　　hex : __hex__(self)
　　logical operator :
　　< : __lt__(self,other)
　　<= : __le__(self,other)
　　> : __gt__(self,other)
　　>= : ge__(self,other)
　　== : __eq__(self,other)
　　!= : __ne__(self,other)
　　examples
　　e.g. : overload of the operator * and *=
　　class rectangle:
　　def __init__(self,x,y):
　　self.__x = x
　　self.__y = y
　　def surface(self):
　　return self.__x*self.__y
　　def __mul__(self,other):
　　return rectangle(self.__x*other.__x,self._y*other.__y)
　　def __imul__(self,other):
　　self= self*other
　　return self
　　a = rectangle(3,4)
　　b = rectangle(2,5)
　　c = a*b
　　print(c.surface())
　　c *= b
　　print(c.surface())
　　note : the result is 120 and 1200.
　　e.g. : overload of the operator < and ==
　　class rectangle:
　　def __init__(self,x,y):
　　self.__x = x
　　self.__y = y
　　def surface(self):
　　return self.__x*self.__y
　　def __lt__(self,other):
　　return self.surface() < other.surface()
　　def __eq__(self,other):
　　return self.__x == other.__x and self.__y == other.__y
　　a = rectangle(3,4)
　　b = rectangle(2,7)
　　print(a <b)
　　print(a == b)
　　note : the result is true and false.
　　exercise
　　in pycharm
　　the duck typing
　　principle
　　in python we don’t specify the type waited by the functions’ parameters(resp. method)
　　that imply that we can use a function with any type, with the condition that the operators of the function(resp.method) are compatible with the types of the parameters.
　　then, we care more about the behaviour of an object than his type.
　　if the method of an object are compatible with the requiree function’s operators, then the function can be apply on the object.
　　example
　　e.g. : class rectangle:
　　def __init__(self,x,y):
　　self.__x = x
　　self.__y = y
　　def surface(self):
　　return self.__x*self.__y
　　class disc:
　　def __init__(self,r):
　　self.__r = e
　　def surface(self):
　　return 3.14*self.__r**2
　　def painting(object):
　　return 2*object.surface()
　　cd = disc(10)
　　photo = rectangle(20,15)
　　print =(painting(cd))
　　
　　print(painting(photo))
　　
　　
　　
　　12.9     16.00-19.00 —> exercise