Programmation Orientée Objet sous Python

*format+[]

input : a=input("entrer un nombre réel")

type : int float str bool (True,False,None) a=float(a).....

print : 1.print("la somme : ",a,"+",b,"=",a+b)

2. Print ("a is %s, b is %s" %(a,b))

str() : convertire un nombre en chaine de
caractere

*Dans le binaire :decalage gauche : << /decalage droite >> : bin(value<<2)

 Chaine de caractere
Les chaînes de caractères brutes Path= r "c:/folder " :

* Repéter chaine de caractere Print("a"* 5) :aaaaa

L'opérateur % pi = 3.14252 print("%.2f"%pi) 3.14
Les opérateurs de comparaisons entre chaînes 1."dv"<"b" false
de caractères 2. "d"<"ff"<" fff"
== !=<=
L'opérateur [] Positive s[0] k
S= khouloud Negatives[-1] d
S[2 :] ouloud
S[2 :4] Ou
S[ : : 2] kolu
S[1 :-1 :2] huod
nombre des lettre len(exemple)

Capitalisation "toto".capitalize() 1 lettre majuscule

Count "toto".count("o") Nombre de reputer une sou
chaine
Endwith "toto.dd".endwith(".dd") Si termine true si non false
Index "khou toto".index("to") Position ‘5’
Lower "HELLO".lower() Tous les lettres minuscule
Replace "toto".reolace(“o“,“a“) Remplacer
Split "12-20".split(“-“) Decouper selon un
separateur
Starwith "fffe".starwith(“ffe“) Si commence true si non
false
Strip " de la ".strip() Sup espace debut et fin
Upper " toto".upper() Tout lettre majuscule

Pour appeler une fonction manipulant une chaîne

pour appeler une méthode à partir d'une chaîne

*Float :age= float(input("taper age ")

*int :age= int(input("taper age ")
* Range :for i range(0,5)
*State=True ;
state is True ;
 Les listes

1. Declaration 1.D=[10,20,13,True,“khou“]
2.
numbers = []
for i in range(10):
num= int(input("...."))
numbers.append(num)
2. la taille de la liste a=len(D)
3. Not in : si ne trouve pas donne true 20 not in D
4. Append :ajouter dans la liste D.append(60)
5. insert :ajouter a la troisieme position D.insert(2,25) :
6. Del :suprimer la 3 eme valleur del D[2]
(tableu commence par 0)
7. Pop :suprimer la 3 eme valleur D.pop(2)
8. Pop :suprimer la dernieur valleur D.pop()
9. remove :la valleur 20 (n est pas la D.remove(20)
position)
10. supprimer tous D.clear
11. Parcourir une liste de données Methode 1 :
for value in D :
print( value)
Methode 2
Index=0
Length=len(D)
While index<length :
value=D[index]
Index +=1
Print(value)

data[12 10 40 60] Data[1 :3] :10 40

Data[ : 3] 12 10 40
Data [ 2 : ] 40 60

data[12 10 40 60] del data [1 :3] sup 10 et 40

del data [1 :3 :2] pas 2 :12 40
data[ : : 2] 12 40
data [1 : :2] 10 60

inserte une liste2 a la fin d un autre liste 1 Liste1.extend(liste2)

Data[1,-2....] P=[x for x in data if x>0] 1 ....

P=[x*2 for x in data if x>0] 1*2,...
A=[x *2 for x in data ] 2,-4,...
 Copy =[x for x in data] 1,-2,.....
Copy= list(data) 1,-2,.....

Enumerate : Methode 1 :
Liste 1[a,b,....]
for i,elt in enumerate (liste1) :
print(“a lindice{} se trouve{}. “.format(i,elt))

Methode 2:
Liste 1[a,b,....]
for elt in enumerate (liste1) :
print(elt)
(0, “a“) ......

Liste de 2Dimension

Declaration n1 : Liste=[
[1,2]
[4,5].....
]

Declaration2 liste_2d = []
for i in range(nb_lignes):
ligne = []
for j in range(nb_colonnes):
valeur = int(input(f"Saisissez la valeur
[{i}][{j}] : "))
ligne.append(valeur)
liste_2d.append(ligne)
for ligne in liste_2d:
print(ligne)
* Convertir une chaine en liste

Chain=“ bonjour mama“

Chain.split(“ “)

*Convertir une liste en chaine

Liste=[“bonjour“,“mama“]

“ “.join(liste)

-- -----------------------Les tuples---------------------------------------------------------
1 –mon_tuple=(1,4,5)

2- fonction tuple

def mon_tuple ()

retenu 3,4

a= mon_tuple () 3,4

b,c= mon_tuple () b =3 c=4

3 pour obtenir un valleur tuple : b= mon_tuple [0] ....

4-Comme une liste, il est possible de parcourir un tuple avec une boucle for.

for i in tuple :

print (i)

Les dictionnaire

Declaration 1.mon_dictionnaire={clé:valeur,clé:valeur,….}

2.mon_dictionnaire={} #dictionnaire vide

ajouter a la dictionneur : mon_dictionnaire[clé]= valleur

parcourir un dictionnaire : items() 1.nbr_de_rous=[“voiture “:4, “velo“ :1,...]

for i in nbr_de_rous.item() :
print(i)
: (voitur,4)
(velo,1 )

2. for clé,valleur in nbr_de_rous.item() :

print(“element “ ,cle, “vaut“,valleur)
element voiture vaut 1
cle seront des tuples mon_dict{}
mon_dict[‘a’,1]=val1
mon_dict[‘b’,1]=val2.......
mon_dict[‘a’,2]=val01
mon_dict[‘b’,2]=val02.......

Supprimer des clés d un dictionnaire del mon_dic[clé] ou bien mon_dic.pop(clé)

 Les fichiers

'r' : ouverture en lecture (Read).

'w' : ouverture en écriture (Write).

'a' : ouverture en écriture en mode ajout (Append).

open mon_fichier=open(“fichier.txt“,“r“)

Close mon_fichier.close()

Lire mon_fichier=open(“fichier.txt“,“r“)

contenu=mon_fichier.read()
print(contenu)

Écriture dans un fichier :sauf chaine de mon_fichier=open(“fichier.txt“,“w“)

caracter (les nombre doit convertir) mon_fichier.write(“........“)

Pour éviter les erreurs avec les fichiers et être with open (“fichier.txt“,“r“) as mon_fichier :
sure de les fermer texte = mon_fichier.read()

Enregistrer des objets dans des fichiers import pickle

module pickle with open (“fichier.txt“,“wb“) as fichier :
mon_pickler=pickle.Pickler(fichier)

enregistrer un ou plusieurs objets dans un score={

fichier avec pickle “j“ : 5,
“i“ : 8, ......
}
with open (“donnees “,“wb“) as
mon_fichier :
mon_pickler=pickle.Pickler(fichier)
mon_pickler.dump(score)

Récupérer nos objets enregistrés avec with open (“donnees “,“wb“) as

pickler mon_fichier :

mon_depickler=pickle.UnPickler(fichier)
a= mon_depickler.load()

Boucle

If, elif ,else If a<0 and .... :

 print(...)
elif a>0 :
......
else :
.......
While While i<10 :
............
For for element in sequence
(for lettre in chaine :)

Creation d un fonction

*Creation d un fonction def nom-de-fonction(parametre1=..,2,...) :

bloc d instruction

*appelle de fonction nom_de_fonction(12)

fonction lambda :foction courte f=lambda x :x*x
modules : Utiliser une même fonction dans #carre dans puissance
plusieurs programmes différents def carre(val)
resultat=val**2
return resultat
Utilisation :
1. from puissance import carre
a=2
u=carre(a)
2. from puissance import*
c=carre(a)
3. import puissance
c=puissance.carre(a)

Package : ressembler les different module def foction1(a)

retenue a**2
utiliser
importe package1.module1
u= package1.module1.fonction1(3)
 ------------------------------- Script/Module-------------------------------------------------------------

Module :import ......

script : def foction1(a)

retenue a**2

utiliser doit utiliser dans le main :

if __name__=“__main__“ :

a=fonction1(c)...

--------------------------------------Les Exceptions-----------------------------------------------------------

a=impot(....)

try :

a=int(a)

assert a<2

except ValueError :

print(“ value nexiste pas“)

except AssertionError :

print(“ a>2“)

------------------NameError,TypeError,ZeroDivisionError
 Les classes

*Declaration class class nom_class:

*constrecteur def __init__(self,a,b):

self.a= a

self.i =b
Encapsulation class nom_class:
pour une attribut privé doit __
def __init__(self,x,y)#declaration

self.__x =x

self.__y =y

#methode

def exemple(self,a,b) :
self.__x= self.__x+a
utilisation
a=nom_de_class(2,5) # x,y
a.exemple(3,5) #a,b

* constructeur Get /set class nom_class:

def __init__(self,x,y)#declaration

self.__x =x

self.__y =y

#get

def getNom(self) :
return self.__x
#set
def set_x(self,x) :
self.__x=x
utilisation
a=nom_de_class(2,5) # x,y
print(....,a.get_x())
a.set_x(5)

@property :comme get et set @property

def x(self) :
return self.__x
 @x.setter
def x(self,x) :
self.__x=x
utilisation
print(....,a. x)
a. x=..

Class methode :cls class nom_class:

a=0

def __init__(self):

nom_class.a+=1

#methode

def nom_methode(cls) :

print(“...{}.....“ .format(cls.a))

Nom_methode=classmethode(nom_methode

*Static methode () :vide class nom_class:

def nom_methode() :

#instruction

utilisation

Nom_methode=staticmethode(nom_methode)

*Les méthodes spéciales 1. #méthode spéciale repr

1 méthode spéciale repr :affiché l'objet def __repr__():
quand on tape directement son nom return("a"+ self.a+" b "+str(self.v))
2 méthode spéciale str :afficher objet avec 2. #méthode spéciale str
print def__str__(self) :
3 méthode spéciale del:quand objet supprimer mess= "a"+self.a+.....
return(mess)
3. #méthode spéciale del
def__del__(self) :
Print(“.....“)

1 a.__contains__(b) #asq ce treouve b in liste a

2 a.__len__()#lengh
-------------------------- L'héritage--------------------------------------------------

class nom_de_class(nome_de_class_herite) :

def __init__(self,a,b ,n):

nome_de_class_herite.__init__(self,a,b)

self.n=n

return f"{super().__str__()}, Diabète: {self.diabete}, Hyper tension: {self.hyper_tension}"

*str(self.n) :convertire en chain de caracter

* def __init__(self, nom, prenom, date_naissance, adresse, diabete=False,

hyper_tension=False):

super().__init__(nom, prenom, date_naissance, adresse)

self.diabete = diabete

self.hyper_tension = hyper_tension

*def __str__(self):

return f"{super().__str__()}, Diabète: {self.diabete}, Hyper tension:

{self.hyper_tension}"

* def lire_patient():

personne = lire_personne()

diabete = input("La personne est-elle diabétique ? (Oui/Non) : ").lower() == "oui"

hyper_tension = input("La personne a-t-elle de l'hypertension ? (Oui/Non) : ").lower() ==

"oui"

return mes_classes.Patient(personne.nom, personne.prenom, personne.date_naissance,

personne.adresse, diabete, hyper_tension)
* if __name__ == "__main__":

* personnes = []

patients = []

while True:

choix = input("Voulez-vous ajouter une personne (P) ou un patient (A) ? (P/A) :

").upper()

* if choix == "P":

personne = lire_personne()

personnes.append(personne)

elif choix == "A":

patient = lire_patient()

patients.append(patient)

else:

break

* print("\nListe des personnes :")

for personne in personnes:

print(personne)

print("\nListe des patients :")

for patient in patients:

print(patient)