Object Oriented Programming python

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è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[i]

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[i] = 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é

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