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 : [Link]("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 "[Link]".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("...."))
[Link](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 [Link](60)
5. insert :ajouter a la troisieme position [Link](2,25) :
6. Del :suprimer la 3 eme valleur del D[2]
(tableu commence par 0)
7. Pop :suprimer la 3 eme valleur [Link](2)
8. Pop :suprimer la dernieur valleur [Link]()
9. remove :la valleur 20 (n est pas la [Link](20)
position)
10. supprimer tous [Link]
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 [Link](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}] : "))
[Link](valeur)
liste_2d.append(ligne)
for ligne in liste_2d:
print(ligne)
* Convertir une chaine en liste

Chain=“ bonjour mama“

[Link](“ “)

*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(“[Link]“,“r“)

Close mon_fichier.close()

Lire mon_fichier=open(“[Link]“,“r“)

contenu=mon_fichier.read()
print(contenu)

Écriture dans un fichier :sauf chaine de mon_fichier=open(“[Link]“,“w“)

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

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

Enregistrer des objets dans des fichiers import pickle

module pickle with open (“[Link]“,“wb“) as fichier :
mon_pickler=[Link](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=[Link](fichier)
mon_pickler.dump(score)

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

pickler mon_fichier :

mon_depickler=[Link](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=[Link](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
[Link](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
 @[Link]
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: {[Link]}, 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)

[Link] = diabete

self.hyper_tension = hyper_tension

*def __str__(self):

return f"{super().__str__()}, Diabète: {[Link]}, 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([Link], [Link], personne.date_naissance,

[Link], 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()

[Link](personne)

elif choix == "A":

patient = lire_patient()

[Link](patient)

else:

break

* print("\nListe des personnes :")

for personne in personnes:

print(personne)

print("\nListe des patients :")

for patient in patients:

print(patient)