Formation Python

-------APPRENDE PYTHO-----PRATIQUE--LE 06 MARS 2015 PAR Oscar KALONJI
--Declaration
Pour declarer
e valeur
Ex: mon_Nom =
mon_Nom =
mon_Nom =
des variables-une variable, il suffit d'crire le nom du variable et l'affecter un

"oscar"
'oscar'
"""oscar"""
numero = 0997083058
chiffre = 23
a = 2
b = 3
--Opration sur les variables-Comme d'abitude avec ces signes : +, -, *, /, %, //(division entire).
Ex: 1 + 2 = 3
chiffre = chiffre +3
chiffre +=3
a = b = c = 5
a,b = c,d
--Utiliser le \n pour le saut des lignes ou le ... sur des longues instructions
Ex : ma_Phrase = """je suis un bonhomme qui est prtentieux ...
... et qui veut tout connaitre car cela est mon souci...
... Nous aimons ce qui nous ressemble"""
Ex2 : 7 + 5 - 2 * (9 * 2 / 3 + (6*3 -10)/5)...
...+ 8 - 2 / 4 - 6 / 2 + 120 * ...
...5 / 3 *(23/50)
...4//2 = 2
...4/2 = 2.0
---UTILISATION DES FONCTIONS--Pour ressortir ou connaitre le type d'une variable, il suffit d'utiliser la fonc
tion type()
Ex : mon_Nom = "oscar"
type(mon_Nom) = str ou string
numero = 0997083058
type(numero) = int ou integer
nombre= 52.6
type(nombre) = float ou flottant
Pour afficher le contenu d'une variable en python, on utilise la fonction Print(
)
Ex : je demande l'ordinateur travers mon programme python de m'afficher mon nume
ro
Je veux ecrire : Print("mon numero est ",numero)
Ex : je veux qu'on m'affiche mon nom
Pour cela je veux noter : Print("on m'appele sous le nom de ",mon_Nom)
---LES STRUCTURES CONDITIONNELLES-------CONDITION AVEC IF-----a = 5 # affectation de la valeur 5 la variable a
if a > 0 : # on test si la variable est suprieur 0 (le : sont indispendisable aprs

la condition)
print(a, est rellement suprieur 0)
a = 5
b = 8
if a > o:
b = b + a
print("a = ",a, " , b = ", b)
age = 20
if age > 18 :
print("majeur")
else:
print("mineur")
temp = 0
if temp > 0:
print("il fait chaud")
elif temp < 0:
print("il fait vraiment froid")
else:
print("il fait beau vivre")
NB:l'indentation est une notion trs importante avec python car il annonce l'inter
preteur le debut et la fin d'une instruction et surtout dans le condition. Amuse
z-vous bien.
--test de l'etat d'eau--degree = 45
if degree >= 30 :
print("a c'est du vrai vapeur")
elif degree < 30 and degree >= 0:
print("l'eau est l'etat liquide")
elif degree < 0 and degree >= -15:
print("l'eau est l'etat solide")
else :
print("Anormal")
majeur = true
mineur = false
if majeur is not true:
print("vous etes mineur")*
else:
print("majeur")
NB: les conditions qui se trouve entre if et : sont appeles PREDICAT. Quelques opr
ateurs savoir : and, or, not et is not, ==, !=.
------FIRST--EXERCICE-----Le but de notre programme est de dterminer si une anne saisie par l'utilisateur es
t
bissextile. Il s'agit d'un sujet trs pris des enseignants en informatique quand il
s'agit
d'expliquer les conditions. Mille pardons, donc, ceux qui ont dj fait cet exercice
dans un autre langage mais je trouve que ce petit programme reprend assez de thme
s
abords dans ce chapitre pour tre rellement intressant.

Je vous rappelle les rgles qui dterminent si une anne est bissextile ou non (vous a
llez
peut-tre mme apprendre des choses que le commun des mortels ignore).
Une anne est dite bissextile si c'est un multiple de 4, sauf si c'est un multiple
de 100.
Toutefois, elle est considre comme bissextile si c'est un multiple de 400.
---------RESOLUTION-----------------PROGRAMME TESTANT SI UNE ANNEE EST BISSEXTILE OU NON------------------------------CONCEPTEUR Oscar KALONJI------------------------annee = 2014 #affectation de la valeur la variable annee
if (annee % 4)==0 and (annee % 100)!=0:
print(annee," est une anne bissextile")
elif (annee % 100) == 0 and (annee % 400) == 0:
print(annee, " est une anne bissextile")
elif (annee % 4)!= 0 and (annee % 100) == 0 and (annee % 400) == 0:
print(annee, "est une anne bissextile")
elif (annee % 4)!= 0 and (annee % 100) == 0 and (annee % 400) != 0:
print(annee, " n'est pas une anne bissextile")
else:
-------- RESOLUTION N2-----------------------PROGRAMME TESTANT SI UNE ANNEE EST BISSEXTILE OU NON---------------------------------CONCEPTEUR Oscar KALONJI----------------------------annee = input("Saisissez l'anne : ")
annee = int(int)
if (annee % 4)==0 and (annee % 100)!=0:
print(annee," est une anne bissextile")
elif (annee % 100) == 0 and (annee % 400) == 0:
print(annee, " est une anne bissextile")
elif (annee % 4)!= 0 and (annee % 100) == 0 and (annee % 400) == 0:
print(annee, "est une anne bissextile")
elif (annee % 4)!= 0 and (annee % 100) == 0 and (annee % 400) != 0:
else:
----------------RESOLUTION DE L'ENSEIGNANT-----------------------# Programme testant si une anne, saisie par l'utilisateur ,
# est bissextile ou non
annee = input (" Saisissez une anne : ") # On attend que l'utilisateur saisisse l
'ann e qu 'il dsire tester
annee = int( annee ) # Risque d'erreur si l'utilisateur n'a pas saisi un nombre
bissextile = False # On cre un boolen qui vaut vrai ou faux
# selon que l'ann e est bissextile ou non
if annee % 400 == 0:
bissextile = True
elif annee % 100 == 0:
bissextile = False
elif annee % 4 == 0:
bissextile = True
else :
bissextile = False
if bissextile : # Si l'ann e est bissextile
print ("L'ann e saisie est bissextile .")
else :
print ("L'anne saisie n'est pas bissextile .")

--------------SECONDE RESOLUTION AVCE OPTIMISATION DU CODE------------------annee = input (" Saisissez une anne : ") # On attend que l'utilisateur saisisse l
'anne qu 'il d sire tester
annee = int( annee ) # Risque d'erreur si l'utilisateur n'a passaisi un nombre
if annee % 400 == 0 or ( annee % 4 == 0 and annee % 100 != 0):
print ("L'anne saisie est bissextile .")
else :
print ("L'anne saisie n'est pas bissextile .")
---------------NOTIONS DES BOUCLES----------------------------------WHILE-------------a = b = 1
while a <= 10
res = a * b
print(res, " = ", a, " * ",b)
a += 1
b += 1
----------------FOR-------------------mot = input("saisissez votre phrase pour les voyelles : ")
for lettre in mot:
if lettre in "ieuaoy":
print(lettre)
else:
print(*)
---------------WHILE avec BREAK---------------while 1:
lettre = input("Saisir la lettre Q pour quitter : ")
if lettre =="Q":
print("Fin du programme")
break
-------------------WHILE AVEC CONTINUE------------------i = 1
while i < 1000:
if (i % 3) == 0:
print(i, " est un diviseur de 3")
i +=4
continue
print(i,"n'est pas un multiple de 3")
i +=1
--------------------------------------------------------------FONCTION-------------------------------------------------------------------------EX : def table (nb):
i = 0
while i <= 10:
print(i," * ",nb," = ",nb * i)
i+=1
-----------------------EX2 :def table_par_7 ():
nb = 7
i = 0
while i <= 10:
print(i," * ",nb," = ",nb * i)
i+=1
Synthaxe d'une fonction : def Nom_fonction (paramettre1, paramettre2, paramettre
n):
instruction1
instructionn
...
-----------------UTILISATION DE L INSTRUCTION RETURN------------------def carre(nb):
return nb * nb
----------------UTILISER DE FONCTION LAMBDA-------------------f = lambda x : x * x
# si vous saisissez par exemple f(5), la fonction vous renvoie 25 donc il vous c
alcule x * x cad 5 * 5 = 25
--------------------------UTILISATION DE MODULE-------------------------L'instruction "import" sert d'appeler un module et il doit tre suivit du nom du m
odule
EX : import math
math.sqrt #cette notion ncessite d'avoir des connaissances dans les modul
es et leurs fonctions. pour plus d'information tapez help ("math")
Toute fois, vous pouvez aussi utilser cette synthaxe pour appeler un module qui
contient plusieurs fonctions.
from nom_module import *
from nom_module import nom_fonction
-------------------------UTILISATION DES PACKAGES---------------------- Crer un dossier au non de package;
- crer un fichier __init__.py;
- crer vos modules.
----------------------GESTION DES EXCEPTIONS--------------------------Il s'agit de gerer les erreurs generes par l'interpreteur des commandes.
---Utilisation de TRY------------EX:
import os
annee = input("Saisir l'anne : ")
try :
annee = int(annee)
except :
print("vous n'aviez pas saisi un chiiffre")
os.system("pause")
Vous pouvez utilisez d'autres mots cls pour perfectionner votre bloc try.... exce
pt comme :
- except en prcisant le nom, type ou quoi de l'erreur;
- en utilisant except ... else ou except ... finally ou encore try ... pass.
--------------------LES ASSERTIONS------------------------Les assertions sont un moyen simple de s'assurer, avant de continuer, qu'une con
dition est respecte.
var = 5
assert var == 5
assert var == 8
ou encore
EXEMPLE 2
annee = input("Saisir une anne > 0 : ")
try :
annee = int(annee)
assert <= 0:
except :
print("Vous n'avez pas saisi un nombre")
finally: ("Vous n'aviez pas saisi un bon nombre")
import os
annee = input("Saisir l'anne : ")
try :
annee = int(annee)
if annee <= 0:
raise ValueError("le nombre saisi est < zero ")
except :
print("vous n'aviez pas saisi un chiiffre")
os.system("pause")
On peut intercepter les erreurs (ou exceptions) leves par notre code grce aux bloc
s
try except.
La syntaxe d'une assertion est assert test:.
Les assertions lvent une exception AssertionError si le test choue.
On peut lever une exception grce au mot-cl raise suivi du type de l'exception.
----------------------RESOLUTION DU TP----------------------------------------------------CONCEPTEUR Oscar KALONJI LE 26-03-2015--------------------i = 1
while i <= 50:
i +=1
print("
APPLICATION Zcasino 1.0
")
print("
----------------------")
print("
")
from random import randrange#nous appelons la fonction de probabilit
from math import ceil#appelle de la fonction qui renvoie les valeurs absolue
s
from os import system
print("
")
print("
Bienvenu au Casino Zcasino, Bonne chanc")
choix_numero = input("Saisir votre numro magique : ")
choix_numero = int(choix_numero)
somme_mise = input("Saisir le montant pour parier : ")
somme_mise = int(somme_mise)
numero_gagnant = randrange(50)
choix_numero_paire = choix_numero % 2
numero_gagnant_paire = numero_gagnant % 2
montant_gagne = 0
montant_gagne = int(montant_gagne)
if choix_numero == numero_gagnant :
mont_gagne = (somme_mise * 3)
print("Quelle chance!!!!!!
Vous venez de gagner un montant de ",mont
_gagne)
elif numero_gagnant_paire == 1 and choix_numero_paire == 1:
moitie_somme = ceil(somme_mise / 2)
mont_gagne = (somme_mise + moitie_somme)
print("Chanceux!!!! Vous avez gagner 50% de votre somme de mise soit u
n montant de ",mont_gagne)
else:
print("Desol!!!!!!!! Vous avez perdu mais vous pouvez retentez votre chan
ce, Courage!!!!")
continue
system("pause")
------------------------------------CONCEPTEUR Oscar KALONJI-------------------------------------------------#Ce programme Zcasino vous permet de raliser votre grand rve de devenir grand
#vous introduisez votre numero et la somme pour parier et du cout vous pouvez de
venir grand
#Oeuvre de Chaptal Oscar KALONJI le 26/03/2015
i = 1
while i <= 50:
i +=1
print("
")
print("
----------------------")
print("
")
from random import randrange
from math import ceil
print("
Bienvenu au Casino Zcasino, Bonne chance!!!!")
montant_gagne = 0
_gagne," Fc")
n montant de ",mont_gagne," Fc")
else:
ce, Courage!!!!")
continue
system("pause")
-------------------------------concepteur Oscar KALONJI--------------------------------------#Ce programme Zcasino vous permet de raliser votre grand
#vous introduisez votre numero et la somme pour parier et
venir grand
i = 1
while i <= 50:
i +=1
print("
print("
----------------------print("
")
rve de devenir grand

du cout vous pouvez de
")
")
print("
if choix_numero >=50:
print("vous avez introduit un faux numero suprieur 50"," ",choix_numero)
system("pause")
break
montant_gagne = 0
_gagne," Fc")
else:
ce, Courage!!!!")
continue
system("pause")
----------------------------------RESOLUTION DE L'ENSEIGNANT--------------------------------------------# Ce fichier abrite le code du ZCasino , un jeu de roulette adapt
import os
# Dclaration des variables de dpart
argent = 1000 # On a 1000 $ au dbut du jeu
continuer_partie = True # Boolen qui est vrai tant qu'on doit
# continuer la partie
print (" Vous vous installez la table de roulette avec ", argent, "$.")
while continuer_partie : # Tant qu 'on doit continuer la partie
# on demande l'utilisateur de saisir le nombre sur
# lequel il va miser
nombre_mise = -1
while nombre_mise < 0 or nombre_mise > 49:
nombre_mise = input (" Tapez le nombre sur lequel vous voulez miser ( en
tre 0 et 49) : ")
# On convertit le nombre mis
try :
nombre_mise = int( nombre_mise )
except ValueError :
print (" Vous n'avez pas saisi de nombre ")
nombre_mise = -1
continue
if nombre_mise < 0:
print ("Ce nombre est n gatif ")
if nombre_mise > 49:
print ("Ce nombre est sup rieur 49")
# prsent , on s lectionne la somme miser sur le nombre
mise = 0
while mise <= 0 or mise > argent :

mise = input (" Tapez le montant de votre mise : ")
# On convertit la mise
try :
mise = int( mise )
except ValueError :
print (" Vous n'avez pas saisi de nombre ")
mise = -1
continue
if mise <= 0:
print ("La mise saisie est n gative ou nulle .")
if mise > argent :
print (" Vous ne pouvez miser autant , vous n'avez que", argent , "$
")
# Le nombre mis et la mise ont t s lectionn s par
# l'utilisateur , on fait tourner la roulette
numero_gagnant = randrange (50)
print ("La roulette tourne ... ... et s'arr te sur le num ro", numero_gagnant
)
# On tablit le gain du joueur
if numero_gagnant == nombre_mise :
print ("Flicitations ! Vous obtenez ", mise * 3, "$ !")
argent += mise * 3
elif numero_gagnant % 2 == nombre_mise % 2: # ils sont de la mme couleur
mise = ceil ( mise * 0.5)
print (" Vous avez mis sur la bonne couleur . Vous obtenez ", mise , "$")
argent += mise
else :
print ("Dsol l'ami , c'est pas pour cette fois . Vous perdez votre mise ."
)
argent -= mise
# On interrompt la partie si le joueur est ruin
if argent <= 0:
print (" Vous tes ruin ! C'est la fin de la partie .")
continuer_partie = False
else :
# On affiche l'argent du joueur
print (" Vous avez pr sent ", argent , "$")
quitter = input (" Souhaitez - vous quitter le casino (o/n)? ")
if quitter == "o" or quitter == "O":
print (" Vous quittez le casino avec vos gains .")
continuer_partie = False
# On met en pause le syst me ( Windows )
os. system (" pause ")
------------------------RESOLUTION CORRIGEE Oscar KALONJI
-------------------#Ce programme Zcasino vous permet de raliser votre grand
#vous introduisez votre numero et la somme pour parier et
venir grand
i = 1
while i <= 50:
i +=1
print("
print("
----------------------print("
")
LE 27/03/2015--------rve de devenir grand

du cout vous pouvez de
")
")
print("
choix_numero = 60
quitter = True
while choix_numero < 0 or choix_numero > 49:
try:
except ValueError:
print("Vous avez introduit un faux numero")
choix_numero = -1
contiue
if choix_numero < 0:
print("Vous avez saisi un nombre ngatif")
elif choix_numero > 50:
print("Vous avez saisi un numero suprieur 49")
else:
print("")
print("Waiting... la roulette tourne... ... est s'arrte sur le numero",numero
_gagnant)
montant_gagne = 0
_gagne," Fc")
else:
ce, Courage!!!!")
reponse = "O"
print("Voulez-vous continuer ?(O/N)")
reponse = input("Repondez par O pour le Oui et N pour le Non : ")
while reponse == "n" or reponse == "N":
quitter = False
break
if reponse == "n" or reponse == "N":
break
system("pause")
-----------------------------------------------------------------------------------------------------------------------------------------------------------------NOTIONS OBJET AVEC PYTHON--------------------------------------un objet est une structure de donnes, comme les variables, qui peut contenir elle
-mme d'autres variables et fonctions.
NB: pour mettre une chaine en miniscule, il suffit d'utiliser le module ou la fo
nction LOWER.
EX: chaine = "NE CRIE PAS TRES FORT"
print(chaine.lower())
Donc l'objet est issu d'une classe, or la classe a des methodes(fonctions) donc
l'objet herite des methodes(fonctions) de la classe mre.
Pour une methode, notez : objet.methode()
EX : chaine.lower()
Voici quelques methodes : upper(pour obtenir le majuscule), capitalize(obtenir l

e majuscule pour la lettre), strip(pour eliminer les espaces).
EX : chaine = " ne crie pas fort!"
chaine.upper()
chaine.strip()
chaine.capitalize()
chaine.upper().center(20) ---------pour obtenir le majuscule et centrer
le mot.
---------------------FORMATER UNE CHAINE---------------------------------EX :
nom = "oscar"
postnom = "KALONJI"
age = 55
print("je m'appele {0} {1}, ag de {2} ans, vous connaissez maintenant, je
disais {0} {1}, {2} ans")
EX2:
chaine = " {nom}, {n_av}, {n_quart}, {n_com}".format(nom = "oscar",n_av
= "bubanji",n_quart = "18",n_com = "diulu")
print(chaine)
print("Merci")
system("pause")
------------------------------------SELECTION D'UNE CHAINE----------------------------------------EX :
nom = "kalonji"
nom[0:2] // resultat vous aurez "ka" donc vous selectionner les elemen
ts qui se trouve de l'indice 0 l'indice 1, 2 exclut.
nom[2:len(nom)]
nom = "B" + nom[1:]
----------------------------LA CONCATENATION-------------------EX1 :
nom = "oscar"
prenom = "KALONJI"
print(nom + prenom)
EX2 :
age = 21
print("j'ai ",age," ans")
EX3 :
nom = "oscar"
prenom = "KALONJI"
age = 21
print(nom + prenom + " " + str(age))
------------------------------------------------PARCOURIR PAR INDICE-------------------------EX1: mot = "vous ne connaissez jusque l rien"
print(mot[0],mot[8],mot[5],mot[4],mot[-1]) // la valeur entre crochet perme
t d'acceder l'indice de la lettre (la lecture commence par l'indice 0).
len(mot) //vous donne le nombre total de la chaine ou sa longueur.
EX2 :
mot = input("Saisissez votre phrase : ")
i = 0
while len(mot) > i:
print(mot[i])
i += 1
print("votre phrase saisie avait ", len(mot)," caractres")
system("pause")
Pour remplacer une lettre, voil l'exemple :

mot = "lac"
mot = "B" + mot[0:]
Vous pouvez utiliser les methodes tels que COUNT, REPLACE et FIND (compter, remp
lacer et trouver).
-------------------------------LES LISTES ET TUPPLES-------------------------------------Les listes en python sont des objets capable de contenir d'autres( on les appell
e encore des sequences).
Synthaxe de cration d'une liste
ma_liste = list() // la classe list est instanci
pour avoir les objets listes.
Ex :
liste_numero = list(1,3,5,7,9)
liste_nom = [oscar,chaptal,lascar]
Pour ajouter des elements la liste, il faut utiliser la methode APPEND et pour i
nserer les elements, il faut utiliser la methode INSERT. les deux methodes deman
de
l'utilisateur des indices.
EX :
liste_nom = ["kalonji", "kabongo", "kazadi", "kalenga", "kabangu", "kapi
nga", "kabedi"]
liste_nom.append("tshisuaka") // ajouter le nom la fin de la liste
liste_nom.insert(1,"kadima") // ajoute l'element l'indice 1
liste_nom.append("mbelu","kabeya")
liste_nom.insert(2,"tshieba")
print(liste_nom)
Pour concatener une liste, utiliser la methode Extend ou le signe + ou +=.
EX :
liste_nom = [1,2,3,4]
liste_num = [5,6,7,8]
liste_concatener = liste_nom + liste_num
liste_num.extend(liste_nom)
liste_num += liste_nom
print(liste_concatener,liste_num) // le resultat est le meme. je vous c
onseille de tester le code.
Pour effacer ou deleter un element de la sequence(liste) ou une variable, il suf
fit d'utiliser la methode REMOVE ou le mot cl DEL.
EX :
liste_nom = [1,2,3,4]
liste_num = [5,6,7,8]
liste_concatener = liste_nom.remove(1) + liste_num.remove(6)
del liste_nom # del efface la variable
liste_num.remove(8)#remove retire un element de la liste l'indice donn.
Pour parcourir une squence ou une liste, la methode est la meme que le parcourt d
es caractres
EX :
import os
liste_nom = [1,2,3,4,5,6,7,8,9,0]
i = 0
while i <= len(liste_nom):
print("vous etes sur le chiffre ",i)
i +=1
os.system
import os
liste_nom = [1,2,3,4,5,6,7,8,9,0]
for a in liste_nom :
print(a) // a est une variable qui prend par defaut le
valeur de la sequence, vous pouvez mettre n'importe quel mot ou caractere.
os.system
--------------------------------------------------------------UTILISATION DE LA
FONCTION ENUMATE---------------------------------------------------------------EX :
liste_nom = [1,2,3,4,5,6,7,8,9,0]
for i, elt in enumate(liste_nom):
print("A l'indice {} se trouve la liste {}".format(i,elt))
#l'exemple ci-dessus utilise la fonction enumerate qui prend en paramettre une l
iste et renvoie les objets qui peuvent tre lis la liste.
EX2 :
liste_nom = [1,2,3,4,5,6,7,8,9,0]
for elt in enumerate(liste_nom):
print(elt)
EX3 :
liste = [[1,"kalonji"],[3,"kabeya"],[5,"kalala"]]
re crochet sont appel des tuples
for a, elt in liste :
print("{},{}".format(a, elt) )
est une liste mais utilis comme delimiteur
// les elements ent

// un delimiteur
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------UTILISATION DES LISTES------------------------------------------------------------------------------------------------------------------------------------Conversion liste chaine // chaine - liste----------------------------------------------------------pour convertir une chaine en liste, on utilise la methode SPLIT (Eclater)
EX :
phrase = "je suis entrain d'apprendre le python"
phrase.split(" ")// le paramettre entrer icic " " signifie que la chaine
sera decoup en fonction del'espace entre le mot mais split lui seul deja de
parametre donc si vous ecrivez phrase.split()
voil le resultat
["je", "suis", "entrain", "d'apprendre", "le","python"]
Pour convertir une liste en chaine, on utilise la methode JOIN.
EX :
liste = ["bonjour", "", "tous"]
" ".join(liste)
"bonjour tous" // le resultat renvoy.
-------------------------------------------------------------------------Exemple
sous forme de tp-----------------------------------------------------------------Faire ou mettre en place une fonction qui affiche une le resultat d'une division
si c'est un flottant, la fonction va afficher le resultat avec 3 rangs apres le
virgule.
------------------------------------------------------------------------Solution
Oscar le 02/04/2015---------------------------------------------------------------def div(a,b):

c = a/b
c = str(c)
c = c.split(".")
// ma resolution passe par la division pour vous
afficher le resultat avec trois rangs apres la virgule
c = "".join(c)
div = c[0]
virg = c[1:4]
return ",".join([div,virg])
-----------------------------------------------------------------------------Sol
ution Enseignant-------------------------------------------------------------------def afficher_flottant ( flottant ):
if type ( flottant ) is not float :
raise TypeError ("Le param tre attendu doit tre un flottan
t ")
flottant = str( flottant )
// dans cette resolution, vous introduisez directement le flottant
partie_entiere , partie_flottante = flottant . split (".
")
return ",". join ([ partie_entiere , partie_flottante [:
3]])
---------------------------------------------------------------------------Les l
istes et parametre de fonctions----------------------------------------------------Les fonctions dont on ne connat pas l'avance le nombre de paramtres comme la fonct
ion PRINT
Pour concevoir une telle fonction, voil la synthawxe :
EX :
def fonction(*parametres):
// vous placez le signe
etoile devant les parametres
def fonction(nom, postnom, *values)
EX :
def fonction_inconnue (* parametres ):
print ("J'ai reu : {}.". format ( parametres ))
fonction_inconnue () # On appelle la fonction sans param tre
J'ai reu : ().
fonction_inconnue (33)
J'ai reu : (33 ,).
Le fait de prciser une toile * devant le nom du paramtre fait que Python va placert
ous les paramtres de la fonction
dans un tuple, que l'on peut ensuite traiter comme on le souhaite.
---------------------------------------------------------------------------les p
arametre nomms-------------------------------------------------------------------Voyons par exemple la dnition de la fonction print :
print (value , ... , sep=' ', end='\n', file =sys. stdout ) et voil le code en py
thon de la fonction print:
def print (* values , sep =' ', end='\n', file =sys. stdout ):
Petit exercice : faire une fonction afficher identique print, c'est--dire prenant
unnombre indtermin de paramtres, les achant en les sparant l'aide du
paramtre
nomm sep et terminant l'achage par la variable fin
-------------------------Resolution Oscar-------------------------------------->>> [nb for nb in enumerate(nom) if nb != " "]
[(0, 'a'), (1, 'b'), (2, ' '), (3, 'c'), (4, 'd')]
>>> def afficher(*a, sep = " ", fin = '\n'):
...
a = list(a)
...
a =str(a)
...
a.split(",")
//pas du tout bon
...
sep.join(a)
...
print(a)
...
>>> afficher("oscar kalonji",15)
['oscar kalonji', 15]
>>> print("oscar kalonji",48)
oscar kalonji 48
------------------------------------Resolution Enseignant----------------------------------import os
def afficher (* parametres , sep=' ', fin='\n'):
parametres = list ( parametres )
for i, parametre in enumerate ( parametres ):
parametres [i] = str( parametre )
chaine = sep. join ( parametres )
#ce la meilleure solution
chaine += fin
print (chaine , end='')
os.system("pause")
-----------------------------------------------Transformer une liste en para
metre fonction------------------------------------------------EX :
>>> liste_nom = ["kalonji","kabongo","oscar",
>>> print(*liste_nom)
// A l'aide de la fonction print
, nous mettons en parametre la liste et vous avez le resultat.
kalonji kabongo oscar chaptal
#resultat si l'on precede du sig
ne *
>>> print(liste_nom)
['kalonji', 'kabongo', 'oscar', 'chaptal']
#resultat sans signe * do
nc juste l'affichage d'une liste.
On utilise une toile * dans les deux cas. Si c'est dans une dnition de fonction, ce
la
signie que les paramtres fournis non attendus lors de l'appel seront capturs dans l
a
variable, sous la forme d'un tuple. Si c'est dans un appel de fonction, au contr
aire, cela
signie que la variable sera dcompose en plusieurs paramtres envoys la fonction.
----------------------------------LES COMPREHENSIONS DE LISTE-------------------------------------------Les comprhensions de liste ( list comprehensions en anglais) sont un moyen de fil
trer ou modier une liste trs simplement.
EX :
>>> nombnre = [1,2,3,4,5,6,7,8,9,0]
>>> [a * a for a in nombre]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>

NameError: name 'nombre' is not defined
>>> [a * a for a in nombnre]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 0]
>>> [a*=2 for a in nombnre]
File "<stdin>", line 1
[a*=2 for a in nombnre]
^
SyntaxError: invalid syntax
>>> [a**2 for a in nombnre]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 0]
>>> [a**2 for a in nombnre if a%2 == 0]
[4, 16, 36, 64, 0]
>>> [a**2 for a in nombnre if a%2 == 1]
[1, 9, 25, 49, 81]
EX2
quantite = [18,14,3,48,50]
#nous declarons nous lis
te de de quantit
>>> [a - 7 for a in quantite if a >= 7]
# nous soustrayons 7 fru
its du quantit globale ssi cette quantit est superieure 7.
[11, 7, 41, 43]
EX2 :
qtt_a_retirer = 7 # On retire chaque semaine 7 fruits de
chaque sorte
>>> fruits_stockes = [15 , 3, 18, 21] # Par exemple 15 pommes , 3melons ...
>>> [ nb_fruits - qtt_a_retirer for nb_fruits in fruits_stockes if nb_fruits > q
tt_a_retirer ]
[8, 11, 14]
-------------------------------------------EXErcice tp------------------------------------------------Votre mission est de trier cette liste en fonction de la quantit de chaque fruit.
Autrement
dit, on doit obtenir quelque chose de similaire :
inventaire = [
("pommes", 22),
("melons", 4),
("poires", 18),
("fraises", 76),
("prunes", 51),
]
------------------------------------------Resolution Oscar le 07/04/2015------------------------------------------import os
inventaire = [("pommes", 22),("melons", 4),("poires", 18),("fraises", 76),("prun
es", 51),]
inventaire1 = [(b,a)for a, b in inventaire]
afficher_liste = sorted(inventaire1)
print(afficher_liste)
os.system("")
>>> [(a, b) for b, a in inventaire]
[(22, 'pommes'), (4, 'melons'), (18, 'poires'), (76, 'fraises'), (51, 'prunes')]
>>>
>>> sorted(inventaire)
[('fraises', 76), ('melons', 4), ('poires', 18), ('pommes', 22), ('prunes', 51)]
>>> nom = [(a, b) for b, a in inventaire]
>>> sorted(nom)
[(4, 'melons'), (18, 'poires'), (22, 'pommes'), (51, 'prunes'), (76, 'fraises')]
-----------------------------------------Resolution Enseignant------------------------------------------------#On change le sens de l'inventaire , la quantit avant le nom
inventaire_inverse = [( qtt , nom_fruit ) for nom_fruit ,qtt in inventaire ]
# On n'a plus qu ' trier dans l'ordre d croissant l'inventaire invers
#On reconstitue l'inventaire tri
inventaire = [( nom_fruit , qtt) for qtt , nom_fruit in sorted (inventaire_inver
se , \
reverse = True )]
---------------------------------------Resolution enseignant2----------------------------------------------# On change le sens de l'inventaire , la quantit avant le nom
inventaire_inverse = [( qtt , nom_fruit ) for nom_fruit ,qtt ininventaire ]
# On trie l'inventaire invers dans l'ordre d croissant
inventaire_inverse . sort ( reverse = True )
# Et on reconstitue l'inventaire
inventaire = [( nom_fruit , qtt) for qtt , nom_fruit in inventaire_inverse )]
----------------------------Application d'affichage de l'inverse du nom-------------------------------------import os
print("
APPLICATION D'AFFICHAGE DE L'INVERSE
")
print("
--------------------------------------------")
print("
")
sexe = input("Etes-vous Mr ou Mme/Mlle : ")
nom = input("introduisez votre nom : ")
print("voil l'inverse de votre nom")
a = len(nom)
nom_inverse = ""
while a <= len(nom) and a >= 1:
a -=1
nom_inverse +=nom[a]
print(nom_inverse)
print("Au revoir ", sexe)
os.system("pause")
---------------------------------------------LE DICTIONNAIRE-------------------------------------------------Les dictionnaires sont des objets pouvant en contenir d'autres, l'instar des lis
tes. Cependant,
au lieu d'hberger des informations dans un ordre prcis, ils associent chaque objet
contenu une cl (la plupart du temps, une chane de caractres). Pour accder aux objets
contenus dans le
dictionnaire, on n'utilise pas ncessairement des indices mais des cls qui peuvent t
re de bien des types distincts.
---------------------------------------------CREATION D'UN DICTIONNAIRE-----------------------------------------------Pour crer un dictionnaire, il faut utiliser le mot dict ou les accolades {}
EX :
mon_dictionnaire = dict()
#cration d'un dictionnaire vide
mon_dictionnaire = {}
#cration d'un dictionnaire vide
Les parenthses dlimitent les tuples, les crochets dlimitent les listes et les accol
ades {} dlimitent les dictionnaires.
>>> mon_dictionnaire = dict()
>>> mon_dictionnaire
{}
>>> mon_dictionnaire = {}
>>> chaine = "oscar"
>>> chaine
'oscar'
>>> liste = [1,2,3,4,"oscar"]
>>> liste
[1, 2, 3, 4, 'oscar']
>>> tuple = [(1,"oscar"),(2,"chaptal"),(3,"lascar")]
>>> tuple
[(1, 'oscar'), (2, 'chaptal'), (3, 'lascar')]
>>> tuple = ((1,"oscar"),(2,"chaptal"),(3,"lascar"))
>>> tuple
((1, 'oscar'), (2, 'chaptal'), (3, 'lascar'))
>>> mon_dictionnaire ["mot de passe"] = "k1253"
>>> mon_dictionnaire ["Nom utilisateur"] = "oscar"
>>> mon_dictionnaire
{'Nom utilisateur': 'oscar', 'mot de passe': 'k1253'}
EX: si on veut representer les valeurs se trouvant dans les cellules du tableau
de trois colonnes et deux lignes.
tableau = {}
#declaration du dictionnaire qui a comme nom tableau
tableau[1,1] = "kabedi"
tableau[1,2] = "f"
tableau[1,3] = "22 ans"
tableau[2,1] = "mpudi"
tableau[2,2] = "m"
tableau[3,1] = "kabeya"
tableau[3,2] = "m"
>>> tableau
{(1, 2): 'f', (3, 2): 'm', (1, 3): '22 ans', (2, 3): '19 ans', (2, 2): 'm', (3,1
): 'kabeya', (1, 1): 'kabedi', (2, 1): 'mpudi'}
vous pouvez aussi crer de dictionnaire deja remplit :
EX:
tableau = {(1, 2): 'f', (3, 2): 'm', (1, 3): '22 ans', (2, 3): '19 ans'}
mais vous tapez par exemple : dictionnaire_tab = {'Non utilisateur', 'Mot de pas
se'} # L vous n'avez declarer un dictionnaire mais au contraire un SET(qui est a
ussi un conteneur d'objet
mais ne permet pas les objets identiques)
Ex :
>>> a = {1,1,2,3,4}
>>> type(a)
<class 'set'>
>>> a = {1,1,2,3,4,3}
>>> type(a)
<class 'set'>
----------------------------------SUPPRIMER DES CLES D'UN DICTIONNAIRE--------------------------------------------
Vous avez le mot cl DEL et le methode POP qui renvoie la cl supprime :

EX:
tableau = {}
#declaration du dictionnaire qui a comme nom tableau
tableau[1,1] = "kabedi"
tableau[1,2] = "f"
tableau[2,1] = "mpudi"
tableau[2,2] = "m"
tableau[3,1] = "kabeya"
tableau[3,2] = "m"
>>> del tableau[1,1]
>>> placard = {"chemise":3, "pantalon":6, "tee shirt":7}
>>> placard
{'chemise': 3, 'pantalon': 6, 'tee shirt': 7}
>>> placard.pop("chemise")
3
>>> tableau
{(3, 2): 'm', (1, 3): '22 ans', (2, 3): '19 ans', (3, 1): 'kabeya', (2, 1): 'mpu
di'}
>>> placard = {"chemise":"m", "pantalon":6, "tee shirt":7}
>>> placard.pop("chemise")
'm'
>>> placard.pop("pantalon")
6
>>> placard
{'tee shirt': 7}
>>> tableau
{(3, 2): 'm', (1, 3): '22 ans', (2, 3): '19 ans', (3, 1): 'kabeya', (2, 1): 'mpu
di'}
>>> tableau.pop((3, 2))
'm'
>>> tableau.pop((1, 2))
KeyError: (1, 2)
>>> tableau.pop((1,3))
'22 ans'
>>> tableau
{(2, 3): '19 ans', (3, 1): 'kabeya', (2, 1): 'mpudi'}
>>> del tableau[1,1]
>>> tableau
{(1, 2): 'f', (3, 2): 'm', (1, 3): '22 ans', (2, 3): '19 ans', (2, 2): 'm', (3,1
): 'kabeya', (2, 1): 'mpudi'}
On se sert parfois des dictionnaires pour stocker des fonctions.
EX : je veux crer un dictionnaire contenant 3 fonctions :
def table_par_7 ():
nb = 7
i = 0
while i <= 10:
print(i," * ",nb," = ",nb * i)
i+=1
def carre(nb = 2):
return nb * nb
def afficher_diviseur():
i = 1
while i <=1500:
if (i % 3) == 0:
print("Aaaaaaaaaaaaaaaaaaaaaaaaaaah ", i, " est un diviseur de 3")
i +=4
continue
print(i,"n'est pas un multiple de 3")
i +=1
dic_fonction = {}
dic_fonction['table_par_7']= table_par_7
#tester le code
et tudier le resultat.
dic_fonction['carre'] =carre
dic_fonction['afficher_diviseur']=afficher_diviseur
dic_fonction['table_par_7']()
dic_fonction['carre']()
dic_fonction['afficher_diviseur']()
Uiliser la methode haskey() pour verifier la presence d'une cl dans un dictionnai
re qui renvoie un resultat booleen
ex
synthaxe : nom_dict.haskey('nom_cl')
Utiliser aussi la methode get pour visualiser le contenu d'une cl :
ex :
synthaxe : nom_dict.get("nom_cl")
renvoie l'equivalent de la cl.
Pour copier un dictionnaire, utiliser la methode copy
ex
synthaxe : new_name_dict = name_dict.copy() si non pas vous allez crer un
e rference sur l'ancien.
--------------------------------------------PARCOURS DU DICTIONNAIRE--------------------------------------------------------------------------------------------PARCOURS DE CLE--------------------------------------------------EX:
>>> tableau = {}
#declaration du dictionnaire qui a comme nom tab
leau
>>> tableau[1,1] = "kabedi"
>>> tableau[1,2] = "f"
>>> tableau[1,3] = "22 ans"
>>> tableau[2,1] = "mpudi"
>>> tableau[2,2] = "m"
>>> tableau[2,3] = "19 ans"
>>> tableau[3,1] = "kabeya"
>>> tableau[3,2] = "m"
>>> tableau[3,3] = "24 ans"
>>> for cle in tableau:
#vous pouvez utiliser aussi for cle in t
ableau.keys
...
print(cle)
...
#dans cette boucle for, on parcourt juste les cls
du dictionnaire.
(1, 2)
(3, 2)
(1, 3)
(2, 3)
(3, 3)
(2, 2)
(3, 1)
(1, 1)
(2, 1)
Vous pouvez aussi utiliser la methode Keys() pour lister les cls de votre diction
naire.
EX:
>>> tableau.keys()
dict_keys([(1, 2), (3, 2), (1, 3), (2, 3), (3, 3), (2, 2), (3, 1), (1, 1), (2, 1
)])
------------------------------------------PARCOUS DE VALEUR----------------------------------------------EX:
>>> for valeur in tableau.values():
...
print(valeur)
...
f
m
22 ans
19 ans
24 ans
m
kabeya
kabedi
mpudi
------------------------------------PARCOURS DES CLES ET VALEURS----------------------------------------------------->>>
...
...
(1,
(3,
(1,
(2,
(3,
(2,
(3,
(1,
(2,
for a, valeur in tableau.items():

print(a, valeur)
2)
2)
3)
3)
3)
2)
1)
1)
1)
f
m
22 ans
19 ans
24 ans
m
kabeya
kabedi
mpudi
-----------------------------------LES DICTIONNAIRES ET PARAMETRE DE FONCTION-------------------------------------Recuper les valeurs d'un parametre nomm dans un dictionnaire
EX:
>>> def recuper_params(**params_nommes):
...
print("je reu {} de chevre.".format(params_nommes))
...
>>> recuper_params(a=1, b = 2)
je reu {'b': 2, 'a': 1} de chevre.
>>>
Ainsi, pour avoir une fonction qui accepte n'importe quel type de paramtres, nomms
ou non, dans n'importe quel ordre, dans n'importe quelle quantit, il faut la dcla
rer
de cette manire :
def recuper_params(*liste_params, **params_nommes):
#a revoir
-----------------------Transformer un dictionnaire en parametre nomm d'une foncti

on-----------------------EX:
parametres = {" sep ":" >> ", "end ":" -\n"}
print (" Voici ", "un", " exemple ", "d' appel ", ** parametres )
Voici >> un >> exemple >> d' appel -
-----------------------------------------------LES FICHIERS-------------------------------------------------------On peut ouvrir un chier en utilisant la fonction open prenant en paramtre le chemi
n
vers le chier et le mode d'ouverture.On peut lire dans un chier en utilisant la mth
ode read. On peut crire dans un chier en utilisant la mthode write.
Un chier doit tre referm aprs usage en utilisant la mthode close. Le module pickle es
t utilis pour enregistrer des objets Python dans des chiers et les recharger ensui
te.
Voici des exemples sur les fichiers:
Je veux commencer par changer de disque ou repertoire pour me retrouver dans le
repertoirede travail que j'ai cr.
Deuximement je veux crer un fichier au format .txt et je veux ecrire la phrase "je
manipule ce fichier avec le langage python"
Pour voir le repertoire courant, utiliser la fonction getcwd(), soit os.getcwd()
et la methode chdir(change directory) du module os
>>> import os
>>> os.getcwd()
'C:\\Users\\Administrator'
>>> os.chdir("c:/fichiers_python")
>>> os.getcwd()
'c:\\fichiers_python'
Vous pouvez utiliser, en le doublant, l'antislash \\ mais, si vous oubliez de le
doubler, vous aurez des erreurs.
Je vous conseille donc d'utiliser le slash /, cela fonctionne trs
bien mme sous Windows.
Pour ouvrir un fichier on utilise le
olu de l'emplacement du fichier puis
Le mode d'ouverture nous avons: "r":
"w":
contenu du fichier.
"a":
efface pas le contenu.
mot cl OPEN suivie du chemein relatif ou abs

du mode d'ouverture.
ouverture en lecture seulement(Read)
ouverture en ecriture(write) qui efface le
ouverture en ecrire ou ajout(Append) qui n'
Pour fermer un fichier deja ouvert et il faut toujours fermer on utilise la meth
ode CLOSE.
Pour le contenu du fichier, on utilise la methode READ de la classe TextIoWrappe
r.
Pour ecrire dans un fichier, on utilise la methode WRITE et on place la chaine e
n parametre mais condition que le fichier soit ouvert en mode Append ou Write.
>>> import os
>>> os.getcwd()
'C:\\Users\\Administrator'
>>> os.chdir("c:/fichiers_python")
u repertoire en parametre.
>>> os.getcwd()
'c:\\fichiers_python'
>>> ouvrir = open("ecrire.txt")
>>> ouvrir = open("ecrire.txt","ab")
>>> ouvrir
<_io.BufferedWriter name='ecrire.txt'>
>>> type(ouvrir)
<class '_io.BufferedWriter'>
>>> ouvrir.close()
#pour voir le repertoire en cours

#pour changer le repertoire et acceder a
#pour voir le type du variable

#pour fermer un fichier
>>> ouvrir
<_io.BufferedWriter name='ecrire.txt'>
>>> lire = ouvrir.read()
io.UnsupportedOperation: read
>>> ouvrir = open("ecrire.txt","r")
#pour ouvrir le fichier plac en parametre
.
>>> contenu = ouvrir.read()
#pour lire le contenu d'un fichier
>>> print(contenu)
je manipule ce fichier avec le langage python
>>> contenu
'je manipule ce fichier avec le langage python'
>>> type(contenu)
<class 'str'>
>>> contenu.split(' ')
['je', 'manipule', 'ce', 'fichier', 'avec', 'le', 'langage', 'python']
>>> contenu = tuple(contenu)
>>> contenu
('', '', '', 'j', 'e', ' ', 'm', 'a', 'n', 'i', 'p', 'u', 'l', 'e', ' ', 'c'
'e', ' ', 'f', 'i', 'c', 'h', 'i', 'e', 'r', ' ', 'a', 'v', 'e', 'c', ' ', 'l'
'e', ' ', 'l', 'a', 'n', 'g', 'a', 'g', 'e', ' ', 'p', 'y', 't', 'h', 'o', 'n'
>>> ouvrir.close()
>>> ouvrir = open("ecrire.txt", "a")
>>> ouvrir.write("j'ajoute ces phrases depuis python")
34
>>> ouvrir.close()
>>> ouvrir = open("ecrire.txt","rb")
>>> print(contenu)
b"\xef\xbb\xbfje manipule ce fichier avec le langage pythonj'ajoute ces phrases
depuis python"
>>> ouvrir = open("ecrire.txt","ab")
>>> contnu = ouvrir.read()
io.UnsupportedOperation: read
>>> ouvrir.write("\n une fois de plus j'ajoute mes donnees via python")
>>> ouvrir.close()
>>> ouvrir = open("ecrire.txt","r")
>>> print(contenu)
>>> contenu
''
>>> ouvrir.close()
>>> ouvrir = open("ecrire.txt","a")
>>> ouvrir.write("Encore j'ajoute mes donnes via python")
38
>>> ouvrir.write("\n voil d'autres donnes")
24
>>> ouvrir.close()
>>> ouvrir = open("ecrire.txt","rb")
>>> print(contenu)
b"Encore j'ajoute mes donn\xe9es via python\r\n voil\xe0 d'autres donn\xe9es"
--------------------------------------------ECRIRE D'AUTRES TYPES DES DONNEES---------------------------------------Utiliser le mot cl WITH pour ouvrir vos fichiers sans se proccuper les fermer. voi
la l'exemple :
synthaxe :
with open("nom_fichier","mode") as variable:
#sans le double
point, vous aurez un message d'erreur.
ex:
>>> with open("ecrire.txt","r") as ouvrir:
...
contenu = ouvrir.read()
...
print(contenu)
...
Encore j'ajoute mes donnes via python
voil d'autres donnes
>>>
>>> ouvrir.closed
#j'ai verifie si mon fichier est bel et
bien ferm et c'est ok car le resultat me renvoi True.
True
---------------------------------------ENREGISTRER DES OBJETS DANS LES FICHIERS------------------------------------------Grce au module PICKLE que nous allons dcouvrir, on peut enregistrer n'importe quel
objet et le rcuprer par la suite.
Mais mbien avant d'utiliser PICKLE, il faut l'importer par : import pickle, On v
a ensuite utiliser deux classes incluses dans ce module : la classe Pickler et l
a
classe Unpickler.
EX:
import pickle
with open (' donnees ', 'wb ') as fichier :
mon_pickler = pickle . Pickler ( fichier )
score = {
" joueur 1": 5,
" joueur 2": 35,
}
with open (' donnees ', 'wb ') as fichier :
mon_pickler = pickle.Pickler ( fichier )
mon_pickler.dump ( score )
#pour ajouter le
s donnes ou les objets au fichiers A revoir
with open (' donnees ', 'rb ') as fichier :
chiers en mode lecture binaire
mon_depickler = pickle.Unpickler ( fichier )
hier.
score_recupere = mon_depickler.load()
qu'il soit prs l'affichage.
#on ouvre les fi

#on ouvre la fic
#on charge pour
-------------------------------------------TP LE vieux Pendu------------------------------------------------------------------------------------------------------resolution Oscar le 24/04/2015------------------------------------------------------------cette resolution est revoir du faite qu'il n'utilise aucun fonct
ion----------------------------------import os
import pickle
liste = ["oscar","mangeons","discute","priere"]
print("
Bienvenue au ePendu
")
print()
nom = input("Entrez votre nom svp : ")
tableau_score = {}
choix_mot = len(liste)
choix_mot = randrange(choix_mot)
mot_choisi = liste[choix_mot]
chaine = str(mot_choisi)
votre_mot = ""
chaine_index = str(chaine)
i = 0
score = 0
code = ""
while i < len(chaine):
i+=1
code = code + "*"
b = len(chaine)
b = str(b)
print("le mot que vous devez dechiffrer a "+b+" "+"caracteres")
mot_dechif = ""
a = 0
reponse = "O"
nombre_test = 1
try:
while reponse == "O":
a = 0
chaine_index = str(chaine)
while a < len(chaine):
mot_dechif = input("veuillez saisir le caractere pour dechiffrer
le mot: ")
if mot_dechif in chaine:
score = score + 3
code = code.replace("*", mot_dechif,1)
print(code)
else:
mot_dechif = input("veuillez ressaisir le caractere pour dec
hiffrer le mot: ")
a +=1
print("votre score est de :",score)
print()
reponse = input("voulez vous rejouer? / repondre par O/N : ")
reponse = reponse.upper()
try:
assert reponse.upper() == "O" and reponse != "N"
print("bonne chance")
choix_mot = randrange(choix_mot)
mot_choisi = liste[choix_mot]
chaine = str(mot_choisi)
score = 0
code = ""
i = 0
while i < len(chaine):
i+=1
code = code + "*"
print(code)
b = len(chaine)
b = str(b)
print("le mot que vous devez dechiffrer a "+b+" "+"caracteres")
nom = input("Entrez votre nom svp : ")
except:
print("vous n'aviez pas saisi une lettre")
except:
erreur = NameError
print("voil les explications : ",erreur)

with open("c:/fichiers_python/tableau.txt","ab") as tableau_score1:
pickle.dump(tableau_score, tableau_score1)
print("
Voil votre tableau de score
print(tableau_score)
os.system("pause")
")
------------------------------------------------------Resolution Enseignant le 2
4/04/2015--------------------------------------------------1. fonctions.py
import os
import pickle
from random import choice
from donnes import *
def recup_scores():
if os.path.exists(nom_fichiers_scores):
fichier_scores = open(nom_fichier_scores, "rb")
mon_depickler = pickle.Unpickler(fichier_scores)
scores = mon_depickler.load()
fichier_scores.close()
else:
scores = {}
return scores
def enregistrer_scores(scores):
fichiers_scores = open("c:/pendu_tp/nom_fichier_scores", "wb")
mon_pickler = pickle.Pickler(fichiers_scores)
mon_pickler.dump(scores)
fichiers_scores.close()
#gestion utilisateur
def recup_nom_utilisateur():
nom_utilisateur = input("Tapez votre nom : ")
nom_utilisateur = nom_utilisateur.capitalize()
if not nom_utilisateur.isalnum() or len(nom_utilisateur)<4:
print("Ce nom est invalide.")
return recup_nom_utilisateur()
else:
return nom_utilisateur
def recup_lettre():
lettre = input("Tapez une lettre : ")
lettre = lettre.lower()
if len(lettre) > 1 or not lettre.isalpha():
print("Vous n'avez pas saisi une lettre valide.")
return recup_lettre()
else:
return lettre
def choisir_mot():
return choice(liste_mots)
def recup_mot_masque(mot_complet,lettres_trouvees):
mot_masque = ""
for lettre in mot_complet:
if lettre in lettres_trouvees:
mot_masque += lettre
else:
mot_masque += "*"
return mot_masque
2.donnes.py
nb_coups = 8
nom_fichiers_scores = "scores"
liste_mots = [
"armoire",
"boucle",
"buisson",
"bureau",
"chaine",
"carton",
"couteau",
"fichier",
"garage",
"glace",
"journal",
"kiwi",
"lampe",
"liste",
"montagne",
"remise",
"sandale",
"taxi",
"vampire",
"volant",
]
3.pendu.py
from donnes import *
from fonctions import *
scores = recup_scores()
utilisateur = recup_nom_utilisateur()
if utilisateur not in scores.keys():
scores[utilisateur] = 0
continuer_partie = 'o'
while continuer_partie != 'n':
print("Jouer {0}: {1} point(s)".format(utilisateur, scores[utilisateur]))
mot_a_trouver = choisir_mot()
lettres_trouvees = []
mot_trouve = recup_mot_masque(mot_a_trouver,lettres_trouvees)
nb_chances = nb_coups
while mot_a_trouver != mot_trouve and nb_chances >0:
print("Mot trouver {0} (encore {1} chances)".format(mot_trouve, nb_chanc
es))
lettre = recup_lettre()
if lettre in lettres_trouvees:
print("Vous avez dj choisi cette lettre.")
elif lettre in mot_a_trouver:
lettres_trouvees.append(lettre)
print("Bien jou")
print(nb_chances)
else:
nb_chances -=1
print("... non, cette lettre ne se trouve pas dans le mot...")
mot_trouve = recup_mot_masque(mot_a_trouver,lettres_trouvees)
if mot_a_trouver == mot_trouve:
print("Flicitation ! Vous avez trouv le mot {0}".format(mot_a_trouver))
scores[utilisateur] = nb_chances
else:
print("PENDU !!! Vous avez perdu")
scores[utilisateur] + nb_chances
continuer_partie = input("Souhaitez-vous continuer la partie O/N ?")
continuer_partie = continuer_partie.lower()
enregistrer_scores(scores)
print("Vous finissez la partie avec {0} points".format(scores[utilisateur]))
os.system("pause")
A vous de tactiquer les codes.
------------------------------------PROGRAMMATION ORIENTEE OBJET COTE DEVELOPPEU
R--------------------------------------------------------------------------------PREMIERE APPROCHE DES CLASSES----------------------------------------------une classe est un peu un modle(moule) suivant lequel on va crer des objets. C'est
dans la classe que nous allons
dfinir nos mthodes et attributs, les attributs tant des variables contenues dans not
re objet.
la convention dite Camel Case n'utilise pas le signe soulign _ pour sparer les mot
s. Le principe
consiste mettre en majuscule chaque lettre dbutant un mot, par exemple : MaClasse
.
Pour dnir une nouvelle classe, on utilise le mot-cl class. synthaxe : class NomDeMa
Classe:
Les attributs sont des variables internes notre classe.
Pour dfinir les attributs de notre objet, il faut dfinir un constructeur dans notre
classe .un constructeur est appele
invariablement quand on souhaite crer un objet depuis notre classe.
Concrtement, un constructeur est une mthode de notre objet se chargeant de crer nos
attributs.
En vrit, c'est mme la mthode qui sera appele quand on voudra crer notre objet.
EXEMPLE
Modelisation de la personne: pour identifier une personne, on a besoin d
e son nom, prenom, postnom, age, adresse, sexe,... on considre les six attributs:
Nous allons crer une classe personne qui aura comme attributs: nom, prenom, postn
om, age, sexe, adresse:
#creation de ma premiere classe que j'ai nomme class personne
"""je veux crer une classe personne qui sera caracterise par :
-son nom
-son prenom
-son postnom
-son sexe
-son adresse
"""
class Personne:
"""je veux crer mon constructeur que je commencerai appeler pour instancier m
a classe"""
def __init__(self):#A retenir par coeur car sont les mots cls utiliss pour crer
un constructeur
self.nom = "kalonji"
self.prenom = "chaptal"
self.postnom = "kabongo"
self.age = 23
self.sexe = "m"
self.adresse = "kananga"
bernad = Personne()
print(bernad.nom,bernad.age, bernad.adresse)
--------------------------------------------------------------------------------------------------------------------------#creation de ma premiere classe que je nomme class personne
-son nom
-son prenom
-son postnom
-son sexe
-son adresse
"""
class Personne:
a classe"""
def __init__(self,nom,age,sexe):#A retenir par coeur car sont les mots cls ut
iliss pour crer un constructeur
self.nom = nom
self.age = age
self.sexe = sexe
self.adresse = "kananga"
lascar = Personne("oscar",23,"M")
print(lascar.nom)
print(lascar.age)
print(lascar.sexe)
>>>
oscar
23
M
>>>
-----------------------------------------------------------------------------------------------------------------------------#creation de ma premiere classe que je nomme class personne
-son nom
-son prenom
-son postnom
-son sexe
-son adresse
"""
class Personne:
a classe"""
def __init__(self):#A retenir par coeur car sont les mots cls utiliss pour crer
un constructeur
self.nom = ""
self.age = 23
self.sexe = "M"
self.adresse = "kanaga"
lascar = Personne()
lascar.nom = "kabedi"
lascar.prenom = "Ntumba"
lascar.age = "21"
print(lascar.nom, lascar.prenom, lascar.age,lascar.adresse)
>>>
kabedi Ntumba 21 kanaga

>>>
-------------------------------------------------Un peu intelligent---------------------------------------------------#creation de ma premiere classe que je nomme class personne
class Personne:
a classe"""
def __init__(self, nom,age):#A retenir par coeur car sont les mots cls utiliss
pour crer un constructeur
-son nom
-son prenom
-son postnom
-son sexe
-son adresse
"""
self.nom = nom
self.age = age
self.sexe = "M"
lascar = Personne("oscar",23)
print(lascar.nom, lascar.prenom, lascar.age,lascar.adresse)
>>>
oscar chaptal 23 kanaga #aprs execution, voil le resultat. donc vous commencerez i
ntroduire en parametre les valeurs prevues.
>>>
Jusque l, toutes les methodes sont contenues dans notre objet, donc elles sont pr
opres l'objet.
------------------------------------------------------LES ATTRIBUTS DE CLASSE------------------------------------------------------Actuellement nous allons voir comment crer les methodes propres au classe: wait a
nd see
On dfinit notre attribut de classe directement dans le corps de la classe.
Exemple :
...
>>> #creation de ma premiere classe que je nomme class personne
... class Personne:
#cration de la mthode de la classe.
...
objets_crees = 0
...
"""je veux crer mon constructeur que je commencerai appeler pour inst
ancier ma classe"""
...
def __init__(self, nom,age):#A retenir par coeur car sont les mots cls
utiliss pour crer un constructeur
...
...
-son nom
...
-son prenom
...
-son postnom
...
-son sexe
...
-son adresse
... """
...
self.nom = nom
...
...
...
self.age = age
...
self.sexe = "M"
...
...
Personne.objets_crees +=1
...
>>> marcel = Personne("marcel",34)
>>> print(Personne.objets_crees)
1
>>> oscar = Personne("kalonji",23)
2
>>> lascar = Personne("Mbuyi",13)
3
>>> #Voil le fonctionnement de notre attributs de la classe, qui
... est en precedent son nom par le nom de la classe.
---------------------------------------------------LES METHODES, LES RECETTES-----------------------------------------------Les attributs sont des variables propres notre objet, qui servent le caractriser.
Les mthodes sont plutt des actions, comme nous l'avons vu dans la partie prcdente, a
gissant sur l'objet.
Par exemple, la mthode append de la classe list permet d'ajouterun lment dans l'obj
et list manipul..
Exemple:
#Exercice sur les methodes
class TableauNoir:
def __init__(self):
"""cette classe TableauNoir contient un attribut :
-surface
"""
self.surface = "" #jusque l la surface du tableau est vide
def ecrire(self,MessageEcrire):
if self.surface != "":
self.surface += "\n"
self.surface += MessageEcrire #on affecte la surface la valeur qui sera
donne en parametre
def effacer(self):
self.surface = ""#on n'efface la valeur de la surface et on la valeur vi
de
def lire(self):
print(self.surface)#on affiche le contenu de la surface
RESULTAT
>>> tab = TableauNoir()
>>> tab.surface
''
>>> tab.ecrire("je suis le champion")
>>> tab.ecrire("je veux loin avec le langage python")
>>> print(tab.surface)
je suis le champion
je veux loin avec le langage python
>>> tab.lire()
je suis le champion
je veux loin avec le langage python
>>> tab.effacer()
>>> tab.lire()
>>>
>>> TableauNoir.ecrire(tab,"vous ne comprendrez rien")
>>> tab.lire()
vous ne comprendrez rien

>>
si vous devez travailler dans une mthode de l'objet sur l'objet lui-mme, vous alle
z passer par self.
Essayer de faire help(TableauNoir) et vous aurez une belle description. A vous d
e jouer.
------------------------------------LES METHODES DES CLASSES ET LES LES METHODES
STATIQUE--------------------------------Comme on trouve des attributs propres la classe, on trouve aussi des mthodes de c
lasse, qui ne travaillent pas sur l'instance self mais sur la classe mme.
C'est un peu plus rare mais cela peut tre utile parfois. Notre mthode de classe se
dnit exactement comme une mthode d'instance, la difrence qu'elle ne
prend pas en premier paramtre self (l'instance de l'objet) mais cls (la classe de
l'objet).
En outre, on utilise ensuite une fonction built-in de Python pour lui faire comp
rendre qu'il s'agit d'une mthode de classe, pas d'une mthode d'instance.
EXEMPLE :
#cration d'une methode de classe
class Personne:
"""Cration d'une classe qui contient son propre attribut ObjetCrees"""
ObjetCrees = 0
def __init__(self,nom,prenom,age):
"""A chaque fois qu'on cre un objet, on incremente un"""
self.nom = nom
self.prenom = prenom
self.age = age
Personne.ObjetCrees +=1
def objets(cls):
"""On cre une methode propre la class qui se charge d'afficher le nombre
des objets crs"""
print("jusque l {} objet(s) ont t crs".format(cls.ObjetCrees))
objets = classmethod(objets)#c'est une prcision pour dire au compilateur que
objets c'est une methode de la classe.
>>>
>>> kalonji = Personne("kalonji","Oscar",23)
>>> Mbeya = Personne("Mbeya","Berck",10)
>>> Kabongo = Personne("kabongo","Jean",18)
>>> Personne.objets#j'appelle la methode de l'objet qui me donne le total
<bound method type.objets of <class '__main__.Personne'>>
>>> Personne.objets()
jusque l 3 objet(s) ont t crs
>>> kalonji.nom
'kalonji'
>>> Mbeya.prenom
'Berck'
>>> Kabongo.age
18
>>>
>>> kalonji.objets() #appel de la methode depuis un objet instanci0
jusque l 3 objet(s) ont t crs
>>>
En fin, pour que Python reconnaisse une mthode de classe, il faut appeler la f
onction classmethod qui prend en
paramtre la mthode que l'on veut convertir et renvoie la mthode convertie.
On peut galement dfinir des mthodes statiques. Elles sont assez proches des mthodes d
e classe sauf qu'elles ne prennent
aucun premier paramtre, ni self ni cls. Elles travaillent donc indpendemment de to

ute donne, aussi bien contenue dans l'instance
de l'objet que dans la classe.
EXEMPLE :
#cration d'une methode de classe
class Personne:
def ClassStat():#j'ai definie une classe statique
print("J'affiche n'importe quoi")
ClassStat = staticmethod(ClassStat)#la conversion en classe statique
>>>
>>> Personne.ClassStat
<function Personne.ClassStat at 0x02516DB0>
>>> Personne.ClassStat()
J'affiche n'importe quoi
>>>
-----------------------------------------------UN PEU D'INTROSPECTION------------------------------------------------Eh bien. . . le terme d'introspection, je le reconnais, fait penser quelque chos
e de plutt abstrait.
Pourtant, vous allez trs vite comprendre l'ide qui se cache derrire: Python propose
plusieurs techniques pour explorer un objet,
connatre ses mthodes ou attributs.
/////////////////////////////////////LA fonction DIR et l'attribut spcial __dict_
_////////////////////////////////////////////////////////////////
La premire technique d'introspection que nous allons voir est la fonction dir. El
le prend en paramtre un objet et renvoie la liste de ses attributs et mthodes.
Par dfaut, quand vous dveloppez une classe, tous les objets construits depuis cett
e classe possderont un attribut spcial __dict__.
Cet attribut est un dictionnaire qui contient en guise de cls les noms des attrib
uts et, en tant que valeurs, les valeurs des attributs.
EXEMPLE :
#Exercice sur les methodes
class TableauNoir:
def __init__(self):
"""cette classe TableauNoir contient un attribut :
-surface
"""
self.surface = "" #jusque l la surface du tableau est vide
def ecrire(self,MessageEcrire):
if self.surface != "":
self.surface += "\n"
self.surface += MessageEcrire #on affecte la surface la valeur qui sera
donne en parametre
def effacer(self):
self.surface = ""#on n'efface la valeur de la surface et on renvoie la v
aleur vide
def lire(self):
print(self.surface)#on affiche le contenu de la surface
EXECUTION DE LA CLASSE
>>> dir(TableauNoir)# Apartir de la fonction dir() j'ai place en parametre ma cl
asse TableauNoir et il m'affiche tout un truc des choses utiles
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__form
at__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__',

'__lt__', '__module__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof_
_', '__str__', '__subclasshook__', '__weakref__', 'ecrire', 'effacer', 'lire']
>>> tab = TableauNoir()
>>> tab.surface
''
>>> tab.ecrire("je suis un citoyen congolais")
>>> tab.lire()
je suis un citoyen congolais
>>> tab.__dict__
{'surface': 'je suis un citoyen congolais'}
>>> tab.__dict__['surface']= 'je suis chez moi'#souvenez de la synthaxe du dicti
onnaire
>>> tab.__dict__
{'surface': 'je suis chez moi'}
>>>
EXEMPLE D'UNE CLASSE STATIQUE
#cration d'une methode de classe statique
class Personne:
def ClassStat():#j'ai definie une classe statique
print("J'affiche n'importe quoi")
ClassStat = staticmethod(ClassStat)#la conversion en classe statique
EXECUTION
>>> oscar = Personne()
>>> oscar.ClassStat()
J'affiche n'importe quoi
>>>
-----------------------------------------------------------------L'ENCAPSYLATION
----------------------------------------------------------------------L'encapsulation est un principe qui consiste cacher ou protger certaines donnes de
notre objet.
Donc vous n'avez pas l'autorisation l'exterieur d'appeller un attribut de la cla
sse
Pur y parvenir, nous allons crer des methodes particulieres appeles ACCESSEURS et M
UTATEURS.
Les accesseurs donnent accs l'attribut. Les mutateurs permettent de le modifier. C
oncrtement, au lieu d'crire mon_objet.mon_attribut, vous allez crire
mon_objet.get_mon_attribut() 1. De la mme manire, pour modier l'attribut crivez mon_
objet.set_mon_attribut(valeur) 2 et non pas mon_objet.mon_attribut = valeur.
Ah mais d'abord, je n'ai pas dit que vous ne pouviez pas. Vous pouvez trs bien ac
cder aux attributs d'un objet directement, comme on l'a fait au chapitre prcdent.
Je ne fais ici que rsumer le principe d'encapsulation tel qu'on peut le trouver d
ans d'autres langages. En Python, c'est un peu plus subtil.
L'inconvnient de devoir crire des accesseurs et mutateurs, comme vous l'aurez sans
doute compris, c'est qu'il faut crer deux mthodes pour chaque attribut de notrecl
asse.
D'abord, c'est assez lourd. Ensuite, nos mthodes se ressemblent plutt. Certains en
vironnements de dveloppement proposent, il est vrai, de crer ces accesseurs et
mutateurs pour nous, automatiquement. Mais cela ne rsout pas vraiment le problme,
vous en conviendrez.
Python a une philosophie un peu diffrente : pour tous les objets dont on n'attend
pas une action particulire, on va y accder directement, comme nous l'avons fait
au chapitre prcdent. On peut y accder et les modifier en crivant simplement mon_objet
.mon_attribut. Et pour certains, on va crer des proprits.
---------------------------------------------------------------LES PROPRIETES----------------------------------------------------------------------------En Python, il n'y a pas d'attribut priv. Tout est public. Cela signifie que si vou
s voulez modifier un attribut depuis l'extrieur de la classe, vous le pouvez.
Pour faire respecter l'encapsulation propre au langage.
Les proprits sont un moyen transparent de manipuler des attributs d'objet. Elles p
ermettent de dire Python : Quand un utilisateur souhaite modier cet attribut,
fais cela . De cette faon, on peut rendre certains attributs tout fait inaccessibl
es depuis l'extrieur de la classe, ou dire qu'un attribut ne sera visible qu'en l
ecture et non
modiable. Ou encore, on peut faire en sorte que, si on modifie un attribut, Python
recalcule la valeur d'un autre attribut de l'objet.
C'est dans la dnition de la classe que vous allez prciser que tel ou tel attribut d
oit tre accessible ou modiable grce certaines proprits.
Les proprits sont des objets un peu particuliers de Python. Elles prennent la plac
e d'un attribut et agissent diffremment en fonction du contexte dans lequel elles
sont
appeles. Si on les appelle pour modifier l'attribut, par exemple, elles vont redir
iger vers une mthode que nous avons cre, qui gre le cas o on souhaite modifier l'attri
but.
EXEMPLE DES PROPRIETES
#creation de ma premiere classe que je nomme class personne
class Personne:
objets_crees = 0
a classe"""
def __init__(self, nom,age):#A retenir par coeur car sont les mots cls utiliss
pour crer un constructeur
-son nom
-son prenom
-son postnom
-son sexe
-son adresse
"""
self.nom = nom
self.age = age
self._sexe = "M"
self._lieu_residence = "kanaga"
Personne.objets_crees +=1
def _get_lieu_residence(self):
"""methode qui sera appel quand on souhaitera accder en lecture de l'attri
but 'lieu_residence'
"""
print("On accde l'attribut lieu_residence")#il n'ya pas de difference ent
re _lieu_residence et lieu_residence mais par convention, il interdit d'accder a
l'externe dans un attribut qui commence par un soulign
return self._lieu_residence or self._sexe
def _set_lieu_residence(self, nouvelle_residence):
"""Methode appele quand on souhaite modifier le lieu de residence"""
if len(nouvelle_residence) == 1:
print("Attention, il semble que {} {} ans.".format(\

self.nom, nouvelle_residence))
self._sexe = nouvelle_residence
else:
print("Attention, il semble que {} dmnage {}.".format(\
self.nom, nouvelle_residence))
self._lieu_residence = nouvelle_residence
def _del_lieu_residence(self):
"""la methode qui sera appele quand on voudra effacer le contenu du lieu
de residence"""
print("Attention, vous etes sur le point d'effacer l'attribut lieu de re
sidence")
del self._lieu_residence
reponse = "vous etes fou vous, que voulez vous faire"
return print(reponse)
def _help_lieu_residence(self):
"""la methode qui sera appele pour afficher l'aide sur l'attribut lieu de
residence"""
help(self._lieu_residence)
reponse ="cet attribut stocke vos adresses et gre facilement vos deplacem
ents, donc ne vous souciez de rien car nous sommes l pour vous"
return reponse
#on va dire python que notre attribut lieu_residence pointe vers la prop
riete
lieu_residence = property(_get_lieu_residence, _set_lieu_residence,_del_lieu
_residence,_help_lieu_residence)
-------------------------------------------------------LES METHODES SPECIALES-------------------------------------------------------------------------------------Les mthodes spciales sont des mthodes d'instance que Python reconnat et sait utilise
r, dans certains contextes.
Elles peuvent servir indiquer Python ce qu'il doit faire quand il se retrouve de
vant une expression comme mon_objet1 + mon_objet2,
voire mon_objet[indice]. Et, encore plus fort, elles contrlent la faon dont un obj
et se cre, ainsi que l'accs ses attributs.
-----------------------------------------------------EDITION D'UN OBJET----------------------------------------------------Voil quelques methodes que pouvez utiliser mais pour plus d'information, je vous
conseille d'aller voir sur la site du python:
#exercice sur les methodes spciales
class Personne:
"""cette classe contiendra quelques methodes spciales"""
def __init__(self,nom):
self._nom = nom
self.age = 12
def _get_nom(self):
print("Vous allez bientt acceder l'attribut nom")
self._nom
return self._nom
def _set_nom (self, new_nom):
print("Vous avez changer la valeur de l'attribut nom")
self._nom = new_nom
nom = property(_get_nom,_set_nom)
def __del__(self):
""" la methode del est appele lorsqu'il faut supprimer un objet de l'inst
ance
ou l'attribut de la classe """
print("C'est la fin, on me supprime maintenat")
def __repr__(self):
"""la methode repr permet une bonne affichage de notre objet instanci si
elle est prealablement
modifi. voici un exemple. Vous pouvez aussi utiliser la fonction repr qui prend e
n p
en parametre le nom de l'objet"""
return ("je m'appelle {}, age de {}".format(self._nom,self.age))
def __str__(self):
"""la methode str permet de convertir la sortie en string comme peut bie
n le faire print,
donc une affichage personnalise quand vous faites print(nom_objet)"""
return "nom : {}, age : {}".format(self._nom, self.age)
def __getattr__(self,no):
"""cette methode est appele lorque l'on recherche un attribut de l'objet
quelconque
et qu'il n'existe pas, alors la methode getattr renvoie le message. voir l'exemp
le ci-dessous"""
return "Alerte!!! cet attribut {} n'existe pas"
def __delattr__(self,age):
"""cette methode appele quand on souhaite supprimer un attribut d'un obje
t, va nous servir ici
de bloquer la suppression de l'attribut age"""
raise AttributeError("!Vous ne pouvez pas supprimer cet attribut")
---------------------------------------------------les methodesvde conteneur----------------------------------------------------Nous allons commencer travailler sur ce que l'on appelle la surcharge d'oprateurs
. Il s'agit assez simplement d'expliquer Python quoi faire quand on utilise tel
ou tel
oprateur. Nous allons ici voir quatre mthodes spciales qui interviennent quand on t
ravaille sur des objets conteneurs.
-------------------------------------------------------Accs aux elements du conte
neur----------------------------------------------Tout en sachant que les conteneurs sont les listes, les chaines des caracteres e
t les dictionnaires.
Passons l'exercice pour plus de pratique. Nous allons utiliser la methode getite
m, setitem et delitem.
class Zdict:
def __init__(self):
self.un = []
def __getitem__(self,index):
"""La methode consiste l'appel de l'attribut de l'objet"""
return self.un[index]
def __setitem__(self,index,valeur):
"""Cette methode intervient lors du changement
de valeur ou lors de l'affectation"""
self.un[index] = valeur
def __delitem__(index):
"""La methode consiste a effacer un elements dans le dictionnaire"""
del self.un[index]
return "Vous venez d'effacer un lment du dictionnaire l'index {} ".format(
self.un[index])
def __repr__():
return "Dans votre dictionnaire, il ya la valeur {}.".format(self.un)

def __contains__(self,value):
"""cette methode verifie le contenu d'un dictionnaire parrapport un lment"""
value in self.un
return "D'accord, il existe"
def __len__():
taille = len(self.un)
"""la methode qui consiste renvoyer la taille de la liste"""
return "votre dictio comme taille .".format(taille)
""""""""""""""""""Je vous conseille de tester ces exemples""""""""""""""""""""""
""""""
-----------------------------------------------------------LES METHODES MATHEMAT
IQUES-------------------------------------------------------------Sachez que sur le mme modle, il existe les mthodes :
1. __sub__ : surcharge de l'oprateur - ;
2. __mul__ : surcharge de l'oprateur * ;
3. __truediv__ : surcharge de l'oprateur / ;
4. __floordiv__ : surcharge de l'oprateur // (division entire) ;
5. __mod__ : surcharge de l'oprateur % (modulo) ;
6. __pow__ : surcharge de l'oprateur ** (puissance) ;
. . .
Pour plus des details, je vous conseille d'aller visiter le site de python
EXERCICE
exercice sur le methode mathematique
class duree:
def __init__(self, min = 0,sec = 0):
""" Constructeur de la classe """
self.min = min # Nombre des minutes
self.sec = sec #Nombre des secondes
def __str__(self):
"""Affichage tres jolie de nos objets"""
return "{0:02}:{1:02}.".format(self.min,self.sec)
def __repr__(self):
return "{0:02}:{1:02}".format(self.min,self.sec)
def __add__(self, duree_actuelle):
"""On va essayer de limiter notre 60 secondes et les minutes peuvent deb
order"""
nouvelle_duree = duree()
""" On va copier self pour le placer dans l'objet nouvellement cr"""
nouvelle_duree.min = self.min
nouvelle_duree.sec = self.sec
#on ajoute la nouvelle valeur
nouvelle_duree.sec +=duree_actuelle
#On va tester pour savoir si les secondes depasse deja 60
if nouvelle_duree.sec >= 60:
nouvelle_duree.min += nouvelle_duree.sec // 60
nouvelle_duree.sec = nouvelle_duree.sec % 60
#on va renvoyer la nouvelle dure
return nouvelle_duree
def __radd__(self,duree_actuelle):
"""Voil le contraire de la mthode __add__, elle renvoie la methode __add__
son appel. """
return self + duree_actuelle
def __iadd__(self, duree_actuelle):
"""Ici c'est la methode qui sera appele lors de l'incrementation d'un ent
ier"""
self.sec += duree_actuelle
#on va maintenant tester si la valeur du self.sec est superieur zero
if self.sec >= 60:
self.min += self.sec//60
self.sec = self.sec % 60
#on renvoie le self qui est l'objet
return self
///////////////////////Encore une fois, je vous prie d'executer les codes///////
////////////////////////////////
------------------------------------------------------LES METHODES DES COMPARAIS
ONS----------------------------------------------------------Pour commencer, nous allons voir la surcharge des oprateurs de comparaison que vou
s connaissez depuis quelque temps maintenant : ==, !=, <, >, <=, >=.
Oprateur Mthode spciale Rsum
== def __eq__(self,
objet_a_comparer):
Oprateur d'galit (equal ). Renvoie True
si self et objet_a_comparer sont gaux,
False sinon.
!= def __ne__(self,
objet_a_comparer):
Dirent de (non equal ). Renvoie True si
self et objet_a_comparer sont dirents,
False sinon.
> def __gt__(self,
objet_a_comparer):
Teste si self est strictement suprieur
(greather than) objet_a_comparer.
>= def __ge__(self,
objet_a_comparer):
Teste si self est suprieur ou gal (greater
or equal ) objet_a_comparer.
< def __lt__(self,objet_a_comparer):
Teste si self est strictement infrieur (lower
than) objet_a_comparer.
<= def __le__(self,objet_a_comparer):
Teste si self est infrieur ou gal (lower
En retour, chaque methode retourne false ou true selon la comparaison.
EXEMPLE
#exercice sur les methodes de comparaison
class compare:
"""Cette classe compare de deux attributs"""
def __init__(self, nbre1 = 45, nbre2 = 50 ):
self.nbre1 = nbre1
self.nbre2 = nbre2
def __eq__(self,nbre):
"""Nous comparons les deux nombres ou les deux attributs de notre objet"
""
return self.nbre == self.nbre

-----------------------------------------------------LES METHODES SPECIALES UTIL
E A PICKLE-----------------------------------------------------------------------EXEMPLE
import pickle
with open ('donnees', 'wb') as fichier :
mon_pickler = pickle.Pickler( fichier )
class mon_dict:
def __init__(self):
self.nom = "oscar"
self.age = 20
self.conpteur = 5
def __getstate__(self):
mon_dict = dict[self.__dict__]
mon_dict[self.compteur]=0
return mon_dict
def __repr__(self):
return ("votre nom {} ag de {}, le compteur est {}".format(self.nom,s
elf.age,self.compteur))
with open ('donnees', 'wb') as fichier :
mon_pickler = pickle.Pickler( fichier )
def __setstate__(self):
mon_dict[self.compteur]=0
self.__dict__ = mon_dict
mon_pickler.dump (mon_dict)
#pour ajouter les donnes
ou les objets au fichiers A revoir
with open ('donnees', 'rb') as fichier :
#on ouvre les fichiers e
n mode lecture binaire
mon_depickler = pickle.Unpickler(fichier) #on ouvre la fichier.
self = mon_depickler.load()#on charge pour qu'il soit prs l'affichage.
---------------------------------------------------------------L'HERITAGE-----------------------------------------------------------------------------------------l'hritage est une fonctionnalit puissante objet qui permet de dclarer que telle cla
sse sera elle-mme modele sur une autre
classe, qu'on appelle la classe parente, ou la classe mre. Concrtement, si une cla
sse b hrite de la classe a, les objets crs sur
le modle de la classe b auront accs aux mthodes et attributs de la classe a.
SYNTHAXE DE L'HERITAGE
class ClasseMere:#Definition de la classe mre
...Methodes...
class ClasseFille(ClasseMere):#definition de la classe fille
...methodes...
EXEMPLE
#exercice sur l'hritage
class ClassMre:#Voil ma classe mre qui cedera ses proprietes et methodes
nom = ""
def __init__(self,nom):#mon constructeur
self.nom = nom
self.age = 10
def __str__(self):#affichage personnalise
return "Votre est {} ag de {}.".format(self.nom,self.age)
def __repr__(self):#affichage personnalise
return "Nom : {}, Age : {}.".format(self.nom,self.age)
class ClasseFille(ClassMre):#Voil ma classe fille qui hrite de la classe mre
def __init__(self,nom,sexe):#Constructeur de la classe fille
ClassMre.__init__(self,nom)
self.sexe = sexe
def __str__(self):
return"Nom : {}, Age : {}, Sexe : {}.".format(self.nom,self.age,self.sex
e)
def __repr__(self):
ClassMre.__repr__(self)
return "Nom : {}, Age : {}, Sexe : {}".format(self.nom,self.age,self.sex
e)
RESULTAT
Nom
>>>
Nom
>>>
>>>
Nom
>>>
>>>
Nom
>>>
Nom
>>>
: Njiba, Age : 10, Sexe : F

print(l)
: Njiba, Age : 10, Sexe : F.
k = ClassMre("YAMANISA")
k
: YAMANISA, Age : 10.
l.age = 15
l
: Njiba, Age : 15, Sexe : F
k
: YAMANISA, Age : 10.
EXEMPLE
nom = ""
self.nom = nom
self._age = 10
def _getAge_(self):
print("Merci de bien utiliser son age")
return self._age
def _setAge_(self,value):
print("Il semble que la personne de {} vient de changer de nom".format(
self.nom))
self._age = value
return "Les modications ont t effactues avec succs"
age = property(_getAge_,_setAge_)
self.sexe = sexe
def __str__(self):
e)
def __repr__(self):
ClassMre.__repr__(self)
return "Nom : {}, Age : {}, Sexe : {}".format(self.nom,self.age,self.sex
e)
//////////////////////////////////////////////////////////DEUX FONCTIONS TRES PR
ATIQUES///////////////////////////////////////////////////////////////////////
Python dfinit deux fonctions qui peuvent se rvler utiles dans bien des cas : issubcl
ass et isinstance.Comme son nom l'indique,ISSUBCLASS elle vrifie si une classe
est une sous-classe d'une autre classe. Elle renvoie True si c'est le cas, False
sinon.ISINSTANCE permet de savoir si un objet est issu d'une classe ou de ses c
lasses filles
RESULTAT EN CONSIDERANT LA CLASSE L(EXEMPLE CI-DESSUS
>>> isinstance(ClasseFille,ClassMre)
False
>>> isinstance(ClassMre,ClasseFille)
False
>>> issubclass(ClassMre,ClasseFille)
False
>>> issubclass(ClasseFille,ClassMre)
True
>>> k = ClasseFille("Njiba","f")
>>> l = ClassMre("KASONGO")
>>> isinstance(k,ClassMre)
True
>>> isinstance(l,ClasseFille)
False
>>> isinstance(l,ClassMre)
True
>>>
Autres exemples
nom = ""
self.nom = nom
self._age = 10
def _getAge_(self):
return self._age
self.nom))
self._age = value
self.sexe = sexe
def __str__(self):
e)
class ClassPetitFils(ClasseFille):#la classe petite fille qui aura hrite les propr
iets de la classe mre et la classe fille
def __init__(self,nom,sexe,a):#constructeur de la classe petit fils
ClasseFille.__init__(self,nom,sexe)
self.nom = "Njiba"
self.sexe = "F"
self.a = a
////////////////////////////////////////////////////////////HERITAGE MULTIPLIE//
//////////////////////////////////////////////////////////////////////////
Python inclut un mcanisme permettant l'hritage multiple. L'ide est en substance trs
simple : au lieu d'hriter d'une seule classe, on peut hriter de plusieurs.
SYNTHAXE DE L'HERITAGE MULPTIPLIE
class ClasseMere:#Definition de la classe mre
...Methodes...
class AutreClasse:#classe ayant ces propres methodes et attributs
...methodes...
class ClasseFille(ClasseMere,AutreClasse):#cette classe herite de deux classes
...methodes...
EXEMPLE
#exercice sur l'heritage multiplie
nbre = 0
self.nom = nom
self._age = 10
def _getAge_(self):
return self._age
self.nom))
self._age = value
class AutreClasse(ClassMre):#Voil ma classe fille qui hrite de la classe mre
def __init__(self,sexe):#Constructeur de la classe fille
self.sexe = sexe
def __str__(self):
return"Sexe : {}.".format(self.sexe)
def __repr__(self):
return self.sexe
class ClassPetitFils(AutreClasse,ClassMre):#Cette classe herite de deux classes
def __init__(self,nom,sexe,a):#constructeur de la classe petit fils
AutreClasse.__init__(self,sexe)
self.a = a
def __repr__(self):
return"Nom : {}, Age : {}, Sexe : {}, Etat civil : {}.".format(self.nom,

self.age,self.sexe,self.a)
//////////////////////////////////////////////////RETOUR SUR LES EXCEPTIONS/////
///////////////////////////////////////////////////////
Les exceptions sont non seulement des classes, mais des classes hirarchises selon
une relation d'hritage prcise.
Cette relation d'hritage devient importante quand vous utilisez le mot-cl except.
En effet, le type de l'exception que vous prcisez aprs est intercept. . .
ainsi que toutes les classes qui hritent de ce type.
EXEMPLE
>>> class MonException(Exception):
...
"""On se contente de stocker le message d'erreur"""
...
def __init__(self,message):
...
self.message = message
...
def __str__(self):
...
"""on renvoie le message"""
...
return self.message
...
>>> k = MonException("tu es malade")
>>> k
MonException('tu es malade',)
>>> print(k)
tu es malade
>>> raise MonException("OUPS...j'ai tout cass")
__main__.MonException: OUPS...j'ai tout cass
>>>
Pour plus des details, j'ai vous prie d'aller visiter le site officiel de python
.
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////////
------------------------------------------------------------------DERRIERE LA BO
UCLE FOR---------------------------------------------------------------------Nous utilisons des itrateurs sans le savoir depuis le moment o nous avons abord les
boucles et surtout, depuis que nous utilisons le mot-cl for pour parcourir des o
bjets
conteneurs.
UTILISER LES ITERATEURS
L'itrateur, c'est un objet qui va tre charg de parcourir l'objet conteneur, ici une
liste.
L'itrateur est cr dans la mthode spciale __iter__ de l'objet. Ici, c'est donc la mthod
e __iter__ de la classe list qui est appele et
qui renvoie un itrateur permettant de parcourir la liste.
chaque tour de boucle, Python appelle la mthode spciale __next__ de l'itrateur, qui
doit renvoyer l'lment suivant du parcours ou lever l'exception StopIteration si
le parcours touche sa fin.
Avant de plonger dans le code, sachez que Python utilise deux fonctions pour app
eler et manipuler les itrateurs : iter permet d'appeler la mthode spciale __iter__
de
l'objet pass en paramtre et next appelle la mthode spciale __next__ de l'itrateur pas
s en paramtre.
EXEMPLE
>>> liste = [1,2,3,4,5,6,7,8,9]
>>> iter_liste = iter(liste)#On cre l'iterateur avec la methode __iter__.
>>> iter_liste
<list_iterator object at 0x01E107B0>
>>> print(iter_liste)
<list_iterator object at 0x01E107B0>
>>> next(iter_liste)
1
>>> next(iter_liste)#On appelle la methode next de l'iterateur
2
3
4
5
6
7
8
9
StopIteration
>>>
Quand on parcourt une chane grce une boucle for (for lettre in chaine:), c'est ce
mcanisme d'itrateur qui est appel.
Chaque lettre renvoye par notre itrateur se retrouve dans la variable lettre et la
boucle s'arrte quand l'exception StopIteration est leve.
EXEMPLE
#Exercice sur le chapitre derriere la boucle for
class RevStr(str):#Crations de la classe qui herite de la classe string
def __iter__(self):#Appelle de la methode iter
return ItRevStr(self)
class ItRevStr():
"""Construiction de la classe permettant de parcourir une liste du dernier
au premier"""
def __init__(self,mot):
"""On se positionne a la fin du mot"""
self.mot = mot
self.position = len(mot)
def __next__(self):
"""Cette methode doit renvoyer l'element suivant dans dans le parcours o
u lever
l'exception si le parcours est la fin"""
if self.position == 0:
print("Vous venez de parcourir votre mot. Merci!")
raise StopIteration
self.position -=1
return self.mot[self.position]
-------------------------------------------------------------------------LES GEN
ERATEURS----------------------------------------------------------------Les gnrateurs sont avant tout un moyen plus pratique de crer et manipuler des itrate
urs. Vous verrez un peu plus loin dans ce chapitre qu'ils
permettent des choses assez complexes, mais leur puissance tient surtout leur si
mplicit et leur petite taille.
Pour crer un gnrateur, on utilise le mot cl : YIELD
Ce motcl ne peut s'utiliser que dans le corps d'une fonction et il est suivi d'un
e valeur renvoyer.
EXEMPLE
#Exercice sur le generateur
def essai_gen():
yield "oscar"
yield "chaptal"
yield "lascar"
def intervale1(a,b):#la fonction charger de trouver les valeurs situes entre 2 no
mbre
if a <= b:#test si borne infrieure a est inferieur ou egal au borne b
a +=1
while a<b:#test de parcours de l'intervale
yield a
a +=1
else:
if a > b:#test de l'oppos du premier test
a-=1
while a > b:#test de parcours inverse
yield a
a-=1
else:
return 'Vous etes cot'
def intervale2(a,b):
if a <= b:
while a<=b:
yield a
a +=1
else:
print("Vous etes cot")
--------------------------------------------------------------LES GENERATEURS CO
-ROUTINES--------------------------------------------------------------------------Les co-routines sont un moyen d'altrer le parcours. . . pendant le parcours. Pare
xemple, dans notre gnrateur intervalle, on pourrait vouloir
passer directement de 5 10.
Le systme des co-routines en Python est contenu dans le mot-cl yield que nous avon
s vu plus haut et l'utilisation de certaines mthodes de notre
gnrateur.
EXEMPLE
def intervale(a,b):#fonction charg de sauter quelques entiers dans son parcours
if a < b:#On teste si borne a est inferieur borne b
while a<=b:#Meme test d'infriorit entre le deux bornes

getvaleur = (yield a)#On capture la valeur du yield dans une variabl
e
if getvaleur == 10:#On test pour savoir si la valeur capture est 10
b +=5
print("On vient d'ajouter 5 points votre borne superieur")
a+=1
else:
print('aahaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
RESULTATS APRES TEST
>>> l = intervale(1,20)
>>> for elt in l:
if elt == 15:
l.send(20)
print(elt)
>>> for elt in l:
if elt == 10:
l.send(14)
print(elt)
>>> for elt in l:
if elt == 10:
l.send(14)
print(elt, end = " ")
>>> for elt in l:
if elt == 10:
l.send(14)
print(elt, end = " ")
Pour interrompre prmaturement une boucle, on utilise la methode CLOSE.
EXEMPLE
def intervale(a,b):#fonction charg de sauter quelques entiers dans son parcours
e
b = b + 5
a+=1
else:
RESULRTAT
>>> k = intervale(5,18)
>>> for elt in k:
print(elt)
if elt == 10:
k.close()
Pour appeler les mthodes du gnrateur, on doit le stocker dans une variable avant la
boucle. Si vous aviez crit directement for nombre in
intervalle(5, 20), vous n'auriez pas pu appeler la mthode close du gnrateur.

Les gnrateurs permettent de crer plus simplement des itrateurs qui sont sont des fon
ctions utilisant le mot-cl yield suivi de la valeur transmettre la
boucle.
EXEMPLE
>>> def intervale(a,b):#fonction charg de sauter quelques entiers dans son parcou
rs
b = b + 5
a+=1
else:
>>>
>>>
5
>>>
6
>>>
7
>>>
8
>>>
9
>>>
k = intervale(5,14)#on cre notre iterateur

next(k)#On appelle la methode next
next(k)
next(k)
next(k)
next(k)
Phrase sage: La comprehension vient en lisant car la lecture est la mre de scienc
e.
-------------------------------------------------------------------------------------TP Un dictionnaire ordonn------------------------------------
PARTIE RESSERVE AU TP SUR LES CL

ASSES
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++LES DECORATEURS+
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++
Les dcorateurs sont un moyen simple de modifier le comportement par dfaut de fonc
tions. C'est un exemple assez flagrant de ce qu'on appelle la mtaprogrammation,
que je vais dcrire assez brivement comme l'criture de programmes manipulant. . . d'
autres programmes. Cela donne faim, non ?
Les dcorateurs sont des fonctions de Python dont le rle est de
ment par dfaut d'autres fonctions ou classes. Pour schmatiser,
par un dcorateur ne s'excutera pas elle-mme mais appellera le
rateur de dcider s'il veut excuter la fonction et dans quelles
modifier le comporte
une fonction modifie
dcorateur. C'est au dco
conditions.
exemple
# -*- coding: cp1252 -*def Singleton(class_definies):
instance = {}
def get_instance():
if class_definies not in instance:
instance[class_definies]= class_definies()
return instance[class_definies]
return get_instance
@Singleton
class Bonjour():
def __init__(self):
self.message = ""
def __str__():
return "Voil votre message {}".format(self.message)
exemple 2
"""Exercice sur le decorateur"""
def obsolete(fonction):
"""C'est cette fonction qui sera mon decorateur"""
def message():
"""Voil la fonction qui fera d'office l'affichage d'un message"""
print("La fonction {} est obsolete".format(fonction))
return message
def error(fonction):
"""C'est cette fonction qui sera mon decorateur"""
def message():
"""Voil la fonction qui fera d'office l'affichage d'un message"""
raise RuntimeError("la fonction {0} est obsolete".format(fonction))
return message
@obsolete
def salut():
print("je t'aime")
@error
def voir():
print('je suis desol!!')
exemple 3
def mon_decorateur(fonction):
def fonction_modifi():
"""exemple d'un decorateur"""
print("la fonction modifie par notre decorateur {0}".format(fonction))
return fonction()
return fonction_modifi
@mon_decorateur
def salut():
"""fonction modifie par le decorateur"""
print("salut!")
-Les dcorateurs permettent de modier le comportement d'une fonction.
Ce sont eux-mmes des fonctions, prenant en paramtre une fonction et renvoyant
une fonction (qui peut tre la mme).
On peut dclarer une fonction comme dcore en plaant, au-dessus de la ligne de
sa dnition, la ligne @nom_decorateur.
Au moment de la dnition de la fonction, le dcorateur est appel et la fonction
qu'il renvoie sera celle utilise.
Les dcorateurs peuvent galement prendre des paramtres pour inuer sur le comportement
de la fonction dcore.
----------------------------------------------------------LES METACLASSES
-----------------------------------------------------------------------LA METHODE __new__
La mthode __init__, comme nous l'avons vu, est l pour initialiser notre ob
jet (en
crivant des attributs dedans, par exemple) mais elle n'est pas l pour le crer. La mt
hode qui s'en charge, c'est __new__.
C'est aussi une mthode spciale, vous en reconnaissez la particularit. C'est galement
une mthode dnie par object, que l'on peut rednir
en cas de besoin. Avant de voir ce qu'elle prend en paramtres, voyons plus prcismen
t ce qui se passe
quand on tente de construire un objet :
On demande crer un objet, en crivant par exemple Personne("Doe", "John").
La mthode __new__ de notre classe (ici Personne) est appele et se charge de constr
uire un nouvel objet.
Si __new__ renvoie une instance de la classe, on appelle le constructeur __init_
_ en
lui passant en paramtres cette nouvelle instance ainsi que les arguments passs lor
s de la cration de l'objet.
EXEMPLE
#exemple de la metaclasse avec la methode __new__
class Personne():
def __new__(cls,nom,prenom):
print('Appel de la methode new de la classe {}'.format(cls))
return object__new__(cls,nom,prenom)
def __init__(self,nom,prenom):
print("Appel de la methode __init__")
self.nom = nom
self.prenom = prenom
self.age = 23
self.etat = "Celibataire"
>>> A001 = Personne ("kalonji","oscar")
Appel de la methode __init__
>>>
>>> kalonji = type("kalonji",(),{})

>>> kalonji
<class '__main__.kalonji'>
>>> A001 = kalonji()
>>> kalonji.__doc__("je t'aime")
------------------------------------------CREATION DES CLASSES DYNAMIQUEMENT APA
RTIR DE LA GRANDE CLASSE TYPE--------------------------------------------La classe type prend trois arguments pour se construire :
le nom de la classe crer ;
un tuple contenant les classes dont notre nouvelle classe va hriter ;
un dictionnaire contenant les attributs et mthodes de notre classe.
def creer_personne(Personne,nom,prenom):
"""La fonction qu jouera le rle de constructeur pour
notre exemple classe Personne.
Elle prend en parametre, outre la personne
nom -- son nom
prenom -- son prenom
"""
Personne.nom = nom
Personne.prenom = prenom
Personne.age = 21
Personne.lieu_residence = "Lyon"
def presenter_personne(Personne):
"""Fonction prsentant la personne.
Elle affiche son prenom, nom et l'ge."""
print("{} {}".format(Personne.nom, Personne.prenom))
#Dictionnaire des methodes
methodes = {
"__init__":creer_personne,
"presenter":presenter_personne}
#Cration dynamique de la classe
Personne = type("Personne",(),methodes)
toute les classes en python derive de la grande classe type.
>>> A001 = Personne("Oscar",'KALONJI')
>>> A001.nom
'Oscar'
>>> A001.age
21
>>> A001
<__main__.Personne object at 0x0231AED0>
.
>>> A001.presenter()
Oscar KALONJI
>>> A00.creer_personne()
-----------------------------------------------------DEFINITION D'UNE METACLASSE
------------------------------------------------------Nous avons vu que type est la mtaclasse de toutes les classes par dfaut. Cependant
, une classe peut possder une autre mtaclasse que type.
Construire une mtaclasse se fait de la mme faon que construire une classe. Les mtacl
asses hritent de type.
Nous allons notamment nous intresser deux mthodes que nous avons utilises dans nos
dnitions de classes :
la mthode __new__, appele pour crer une classe ;
la mthode __init__, appele pour construire la classe.
Exemple de la methode __init__ qui prend en parametre :
1. la metaclasse servant de base la cration de notre nouvelle classe
2. le nom de notre nouvelle classe
3. un tuple contenant les classes dont heritent notre classe crer
4. le dictionnaire des attributs et methodes de la classe crer.
En programmation objet, une classe est une sorte de moule qui permet de crer un
sous-ensemble d'objets. La classe dcrit comment se comportent
ses objets, fournit leur interface et compose la structure de leur tat.
La classe permet de crer de nouveaux objets au moyen d'un mcanisme appel instancia
tion. Ce mcanisme peut se dcomposer en deux oprations :
-allocation d'un espace mmoire pour le nouvel objet (opration alloc()),
-initialisatiion du nouvel objet (opration init()).
Tout comme Smalltalk et Ruby, Python est un environnement de programmation rflexi
f, c'est--dire que Python est capable de s'analyser et de se modifier
lui-mme. Dans un tel environnement, les classes peuvent tre vues comme des objets
part entire crs au moyen du mcanisme d'instanciation (alloc();
init()). Dans ce cas, toutes les classes peuvent tre vues comme des intances cres
partir d'une mme classe.
Une classe dont les instances sont des classes se nomme mtaclasse (notez que la df
inition est rcursive). Puisqu'une mtaclasse est une classe,
elle dfinit elle aussi le comportement et la structure de l'tat de ses instances.
En crant une nouvelle mtaclasse, on va donc intervenir sur
la manire avec laquelle les classes sont cres et donc intervenir sur une partie du
langage lui-mme. Grce un mcanisme comme celui-ci,
le dveloppeur va pouvoir ajouter de nouvelles fonctionnalits au langage, comme la
possibilit de tracer les appels de mthodes, la possibilit de crer
des singletons, la srialisation d'objets au format XML, etc. Sous Python, le mcani
sme de mtaclasse est suffisamment puissant pour permettre la cration
de telles fonctionnalits.
-------------------------------------------------------Mtaclasse sous Python-----------------------------------------------------------------------
Les mtaclasses Python possdent quelques spcificits par rapport aux concepts thoriques
. La mtaclasse de base se nomme type (qui est retourn par
monObjet.__class__.__class__). Pour crer une nouvelle mtaclasse, il suffit de drive
r la mtaclasse de base.
Que va-t-on trouver dans une mtaclasse ? Les mtaclasses permettent de crer des obje
ts particuliers capables d'instancier.
On va donc y dcrire des mthodes reprsentant les deux oprations alloc() et init() et
qui, sous Python,
sont respectivement dnommes __new__() et __init__(). Ainsi, la mtaclasse permet de
matriser le processus d'instanciation.
Dans les mtaclasses, on peut aussi ajouter des attributs et des mthodes qui vont s
'ajouter l'tat et l'interface des classes instancies.
Ce seront donc des attributs et des mthodes de classe.
Les oprations alloc() et init() sont reprsentes par les mthodes de type __new__() et
__init__(). __new__() est une mthode de classe qui prend
quatre paramtres :
-metacls : la mtaclasse classe elle-mme (remplace le traditionnel self, pa
r convention),
- name : le nom de la nouvelle classe,
- bases : la liste des classes parentes de la nouvelle classe,
-dct : le dictionnaire de l'ensemble des attributs et mthodes dcrit dans l
a nouvelle classe.
__new__() doit absolument retourner un objet. De manire gnrale, cette mthode permet
de raliser des oprations de bas niveau sur des classes :
changer l'interface, modifier les classes de base, donner un autre nom de classe
, etc.
La mthode __init__() est une mthode d'instance. Elle possde les mmes paramtres que la
mthode __new__(), l'exception du premier paramtre
qui reprsente la nouvelle classe et qui est nomm cls par convention. __init__() pe
rmet
de raliser des oprations de plus haut niveau sur les classes : vrification, enregis
trement, etc. Certaines oprations de bas niveau n'y sont plus
possibles, comme changer le nom ou les classes de bases.
Lors de la cration d'une instance, c'est la mthode __call__() qui est appele et qui
s'occupe de l'appel des mthodes __new__() et __init__().
En effet, l'expression MaClasse() quivaut MaClasse.__call__(). Donc, modifier __c
all__() revient aussi modifier le processus d'instanciation.
La liaison entre une classe et sa mtaclasse se fait au moyen de la variable __met
aclass__. Si elle est assigne dans une classe, seule cette classe est
concerne. Si elle est assigne dans un module, ce sont toutes les nouvelles classes
du module qui sont concernes.
EXEMPLE
import types
class Tracer(type):
def __new__(metacls, name, bases, dct):
# dfinition d'une fonction wrapper pour les mthodes

def _wrapper(name, method):
# cration d'une fonction permettant tracer une mthode
def _trace(self, *args, **kwargs):
print "(call %s)" % name
return method(self, *args, **kwargs)
# idiome: faire passer une fonction pour une autre
_trace.__name__ = method.__name__
_trace.__doc__ = method.__doc__
_trace.__dict__.update(method.__dict__)
return _trace
# remplacement de toutes les mthodes par leur quivalent trac

newDct = {}
for name, slot in dct.iteritems():
if type(slot) is types.FunctionType:
newDct[name] = _wrapper(name, slot)
else:
newDct[name] = slot
# appel au constructeur de la super classe (type)
return type.__new__(metacls, name, bases, newDct)

Formation Python

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Formation Python

Hochgeladen von

Copyright:

Verfügbare Formate

-------APPRENDE PYTHO-----PRATIQUE--LE 06 MARS 2015 PAR Oscar KALONJI

des variables-une variable, il suffit d'crire le nom du variable et l'affecter un

if a > 0 : # on test si la variable est suprieur 0 (le : sont indispendisable aprs

abords dans ce chapitre pour tre rellement intressant.

print ("L'anne saisie n'est pas bissextile .")

rve de devenir grand

while mise <= 0 or mise > argent :

LE 27/03/2015--------rve de devenir grand

Voici quelques methodes : upper(pour obtenir le majuscule), capitalize(obtenir l

Pour remplacer une lettre, voil l'exemple :

// les elements ent

Oscar le 02/04/2015---------------------------------------------------------------def div(a,b):

File "<stdin>", line 1, in <module>

Vous avez le mot cl DEL et le methode POP qui renvoie la cl supprime :

for a, valeur in tableau.items():

-----------------------Transformer un dictionnaire en parametre nomm d'une foncti

mot cl OPEN suivie du chemein relatif ou abs

#pour voir le repertoire en cours

#pour voir le type du variable

#on ouvre les fi

print("voil les explications : ",erreur)

kabedi Ntumba 21 kanaga

vous ne comprendrez rien

aucun premier paramtre, ni self ni cls. Elles travaillent donc indpendemment de to

at__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__',

print("Attention, il semble que {} {} ans.".format(\

return "Dans votre dictionnaire, il ya la valeur {}.".format(self.un)

return self.nbre == self.nbre

: Njiba, Age : 10, Sexe : F

return"Nom : {}, Age : {}, Sexe : {}, Etat civil : {}.".format(self.nom,

while a<=b:#Meme test d'infriorit entre le deux bornes

intervalle(5, 20), vous n'auriez pas pu appeler la mthode close du gnrateur.

k = intervale(5,14)#on cre notre iterateur

PARTIE RESSERVE AU TP SUR LES CL

>>> kalonji = type("kalonji",(),{})

# dfinition d'une fonction wrapper pour les mthodes

# remplacement de toutes les mthodes par leur quivalent trac

Das könnte Ihnen auch gefallen

at', 'ge', 'getattribute', 'gt', 'hash', 'init', 'le__',