Python 2015 BM

CHAPITRE 1 : introduction la programmation en python
1- Les langages de diffrents niveaux

Le langage machine. Il est form de 0 et de 1 et nest pas portable, mais cest le seul que lordinateur puisse
comprend
le langage dassemblage est un codage alphanumrique du langage machine. Il est plus lisible que le langage
machine, mais nest toujours pas portable. On le traduit en langage machine par un assembleur ;
les langages de haut niveau. Souvent normaliss, ils permettent le portage dune machine lautre.
Ils sont traduits en langage machine par un compilateur ou un interprteur.
2- Bref historique des langages
Annes 50 (approches exprimentales) : FORTRAN, LISP, COBOL, ALGOL. . .
Annes 60 (langages universels) : PL/1, Simula, Smalltalk, Basic. . .
Annes 70 (gnie logiciel) : C, PASCAL, ADA, MODULA-2. . .
Annes 80 (programmation objet) : C++, LabView, Eiffel, Perl, VisualBasic. . .
Annes 90 (langages interprts objet) : Java, tcl/Tk, Ruby, Python. . .
Annes 2000 (langages commerciaux propritaires) : C#, VB.NET. . .
3- Historique
Date de naissance : 1990 Pre : Guido Van Rossum (Pays-Bas)
1996 : sortie de Numerical Python
2001 : naissance de la PSF (Python Software Fundation)
Les versions se succdent.
4- Les avantages de Python
langage de haut niveau portable sur tous les systmes dexploitation typage dynamique : pas besoin de
dclarer le type des variables ! extensible (interfaable avec dautres bibliothques et modules) sous licence
libre syntaxe trs simple multiparadigme : impratif et orient-objet interprt et/ou prcompil puis
interprt
5- Compilation et interprtation
Il existe deux techniques pour effectuer la traduction d'un programme source en code binaire excutable par la
machine : l'interprtation et la compilation.
Dans la technique dinterprtation, le logiciel interprteur doit tre utilis chaque fois que l'on veut faire
fonctionner le programme.
La compilation consiste traduire la totalit du texte source en une fois. Le logiciel compilateur lit toutes les
lignes du programme source et produit une nouvelle suite de codes que l'on appelle programme objet (ou code
objet).
Chacune de ces deux techniques ses avantages et ses inconvnients: L'interprtation est idale lorsque l'on est
en phase d'apprentissage du langage, ou en cours d'exprimentation sur un projet, Par contre, lorsqu'un projet
comporte des fonctionnalits complexes qui doivent s'excuter rapidement, la compilation est prfrable
1
Certains langages modernes tentent de combiner les deux techniques afin de retirer le meilleur de chacune. C'est
le cas de Python et aussi de Java
Les avantages de cette mthode sont apprciables : Le fait de disposer en permanence d'un interprteur
permet de tester et vrifier le bon fonctionnement de chaque composant d'une application au fur et mesure de
sa construction. Le bytecode est portable.
Programme : un programme est la traduction dun algorithme en un langage compilable ou interprtable par un
ordinateur.
6- Installation de python on va utiliser la distribution pizzo http://www.pyzo.org/
Les deux modes dexcution dun code Python
Soit on enregistre un ensemble dinstructions Python dans un fichier grce un diteur (on parle alors dun script
Python)
soit on utilise linterprteur Python embarqu qui excute la boucle dvaluation
7- Les instructions de base en python

7.1- Dclaration et Typage des variables
Une variable est un identificateur associ une valeur. En Python, cest une rfrence dobjet
Un identificateur Python est une suite de caractres commence par un alphabet qui ne contient ni espace ni
caractres spciaux ni mots cl, il est sensible la casse
Les variables Python sont crs lors de leur premire affectation, sans dclaration pralable, Les variables Python
ne sont donc pas associs des types, mais les valeurs qu'elles contiennent
>>> n = 7 # affectation d'un entier
>>> msg = "Quoi de neuf ?" # Affectation d'une chaine
>>> pi = 3.14159 # affectation d'un flottant
Les diffrents types de donnes :
Les entiers :int Les rels :float Logique :bool(True , False)
Texte : str
7.2- Pour savoir de quel type une variable : type(nom_de_la_variable)
>>> a = 3 >>> type(a) <class 'int'>
>>> type(3.4) <class 'float'>
>>> type("un essai") <class 'str'>
7.3- Affectation : On affecte une variable par une valeur en utilisant le signe = (qui na rien voir avec lgalit en
math !)
a = 2 # prononcez : a "reoit" 2
c = b * a # prononcez : c "reoit" b*a
- Les variantes de laffectation
>>> x = y = 3 >>> x 3 >>> a, b = 4, 8.33 >>> a=5
>>> y 3 >>> a 4 >>> b = 32
>>> b >> a,b = b,a # permutation
8.33 >>> a
32 >>> b 5
7.4- Les entres (lecture)
2
Il sagit de raliser une saisie au clavier : la fonction input() interrompt le programme, affiche une ventuelle
invite lcran et attend que lutilisateur entre une donne au clavier (affiche lcran) et la valide par Entre
La fonction standard input() effectue toujours une saisie en mode texte (la valeur retourne est une chane) dont
on peut ensuite changer le type (on dit aussi transtyper) :
>>> f1 = input("Entrez un >>> f2= float(input("Entrez un autre flottant >>> f1 = int(input("Entrez un entier :
flottant : ") : ")) "))
Entrez un flottant : 12.345 Entrez un autre flottant : 12.345 Entrez un entier : 12
>>> type(f1) >>> type(f2) >>> type(f1)
<class 'str'> <class 'float'> <class 'int'>
7.5- Les sorties(affichage)

En mode calculatrice , Python lit-value-affiche, mais la fonction print() reste indispensable aux affichages
dans les scripts :
a, b = 2, 5 print(a,b,sep='@') 2@5 # pour afficher autre chose qu'un espace en

print(a, b) 2 5 print(a,b,end='@') 2 5@ fin de ligne : print(a, end="@"); print(b)
print("Somme :", a + b) Somme : 7 2@3
7.6- Oprateurs de comparaison

x == y # x est gal y
x != y # x est diffrent de y
x > y # x est plus grand que y
x < y # x est plus petit que y
x >= y # x est plus grand que, ou gal y
x <= y # x est plus petit que, ou gal y
7.7- Le symbole \ est spcial : il permet de transformer le caractre suivant :

\n est un saut de ligne
\t est une tabulation
\b est un backspace
\a est un bip
\" est un " s="l"un" gnre erreur : s="l\"un"
\\ est un \ s= s="l\un" gnre erreur : s="l\\un"
7.8- Oprations
les oprations classiques +,-,*
// division entire
/ division relle
% reste de la division entire
divmod(x,y) quotient et reste de la division
abs(x) valeur absolue
pow(x,y) ou x**y puissance
3
TPN1 : prise en main python
Tableau 1 : premires commandes python
instruction taper rsultat obtenu + commentaire ou explication
20+1
20/3
20//3
20%3
5.45*10
2**4
(3+2)*5
3+2*5
"il fait " + "beau"
"bonjour "*5
Astuce : pour viter d'avoir retaper toute une ligne, utilisez la flche haut du clavier pour vous positionner sur
cette ligne, puis tapez Entre : la ligne est recopie aprs l'invite de commande et vous pouvez la modifier
avant de taper nouveau Entre.
Tableau 2 : premiers messages d'erreur
Certaines instructions ne sont pas acceptes par l'interprteur python et provoquent l'affichage d'un message
d'erreur. Il faut lire attentivement tous les messages d'erreur (mme s'ils sont en anglais) car ces messages nous
apprennent comment fonctionne le langage et nous aident corriger nos instructions et nos programmes. Tapez
les instructions suivantes, observez les erreurs obtenues et analysez-les :
instruction taper erreur observe + explication
20/0
20@3
"bonjour"/3
"bonjour" + 5
(3+2))*5
(3+2*5
Tableau 3 : les types de donnes

type(3)
type(1.5)
type("bonjour")
4
type("3")
type(3+1.5)
Exercice 1 : oprateurs et types de donnes

Sur quels types de donnes peut-on utiliser les oprateurs + , * , / , // , % , ** ? Quel est le type du rsultat
? Rpondre en compltant ci-dessous. Vous pouvez faire des tests en tapant d'autres instructions dans l'interprteur
python.
(exemple : 3+7.1 est accept par l'interprteur python, donc l'oprateur + s'applique un entier et un flottant,
et le rsultat est de type flottant).
oprateur types de donnes utilisables type du rsultat
+
*
/
//
%
**
Pour les chanes de caractres, l'oprateur + s'appelle la concatnation (il fusionne bout bout deux chanes de
caractres)
Tableau 4 : transtypage
On peut parfois transformer une donne d'un certain type, en une donne d'un autre type. Cela s'appelle le
transtypage (ou cast en anglais).
donne de de quel type est la instruction taper type du rsultat obtenu et/ou commentaire
dpart donne de dpart ?
3.0 int(3.0)
3.5 int(3.5)
3 float(3)
4 str(4)
"3" int("3")
"3.5" float("3.5")
"3.5" int("3.5")
"bonjour" int("bonjour")
Tableau 5 : oprateur d'affectation =
5
instruction taper quelle est la Quelle est la donne (ou est De quel type est cette
variable ? le rsultat de l'valuation de donne (ou ce rsultat) ?
la partie droite) ?
age = 20
age = 30
prenom="Ali"
taille_m = 1.75
taille_cm=
100*taille_m
age = age + 3
phrase1 ="bonjour"+
prenom
phrase1 = phrase1 +
" !"
phrase2 = prenom +"
a " +str(age)+"
ans."
Pour afficher le contenu d'une variable dans l'interprteur python, il suffit de taper le nom de cette variable.
Taper les instructions suivantes et complter :
instruction taper quelle valeur contient
age
prenom
prenom="Ali"
prenom
age = 40
age
age = 22
age
age = age + 1
age
phrase1
phrase2
Tableau 6 : utilisation de la fonction input
6
instruction taper commentaire
numero=input("entrez un
chiffre entre 1 et 5 : ")
type(numero)
numero = numero + 1
numero = int(numero)
type(numero)
numero = numero + 1
Tableau 7 : boolens
1 == 1
1 == 3
1 != 3
1 == 1.0
(3+7) == (5*2)
(1 == 1) and (2<2)
(1 == 1) and
(2<=2)
(2 == 15) or (3>2)
1 < 4 < 15
valeur = (1==1)
type(valeur)
not(valeur)
True and False
True or False
7
CHAPITRE 2 : Les structures conditionnelles
1- Test simple
Une instruction conditionnelle nest excute que si une condition donne est vrifie. Pour traduire cela, on
utilise linstruction if, qui a en Python la syntaxe suivante :
Syntaxe :
if condition: Exemple :
bloc dinstructions si condition vrifis note=float(input("Note sur 20 : ")
#suite du programme if note>=10.0 :
print(" jai la moyenne ")
print("fin du programme ")
2- Indentation signifiante
un bloc est une suite dinstructions qui sexcutent les unes aprs les autres. Pour
identifier sans ambigut les instructions appartenant au bloc du if, il est ncessaire de
les indenter. Indenter signifie ajouter un mme nombre despaces devant chacune des
lignes dfinissant les instructions.
Au sein dun bloc, le niveau dindentation doit tre le mme.

La premire instruction qui suit une instruction conditionnelle et qui est place au mme niveau dindentation
que linstruction if marque la fin du bloc
3- Test alternatif
Syntaxe
if condition: Exemple :
bloc dinstructions si la condition est vrifie note=float(input("Note sur 20 : ")
else: if note>=10.0 :
bloc dinstructions si la condition nest pas vrifie print(" jai la moyenne ")
#suite du programme else :
print("C'est en dessous de la moyenne")
4- Test imbriqu print("fin du programme ")

note = float(input("Note sur 20 : ")
if note > 20.0 or note < 0.0:
print("Note invalide !")
else:
if note >= 10.0:
print("J'ai la moyenne")
if note == 20.0:
# ce bloc est excut si l'expression (note == 20.0) est vraie
print("C'est mme excellent !")
else:
if note == 0.0:
# ce bloc est excut si l'expression (note == 0.0) est vraie
print("... lamentable !")
print("Fin du programme")
5- L'instruction elif
8
Une instruction elif (contraction de else if) est toujours associe une instruction if
Syntaxe
if condition 1:
bloc d'instructions 1
elif condition 2:
elif condition 3:
else:
# suite du programme
Si condition 1 est vraie alors le bloc d'instructions 1 est excut, et on passe la suite du programme.
Si condition 1 est fausse alors on teste l'expression 2 :
si condition 2 est vraie on excute le bloc d'instructions 2, et on passe la suite du programme.
si condition 2 est fausse alors on teste la condition 3, etc.
Le bloc d'instructions 4 est donc excut si toutes les conditions sont fausses (c'est le bloc "par dfaut").
Parfois il n'y a rien faire.
Dans ce cas, on peut omettre l'instruction else :
if condition 1:
elif condition 2:
elif condition 3:
# suite du programme
Exemple
note = float(input("Note sur 20 : "))
if note == 0.0:
print("... lamentable !")
elif note == 20.0:
print("C'est mme excellent !")
elif note < 10.0 and note > 0.0: # ou bien : elif 0.0 < note < 10.0:
elif note >= 10.0 and note < 20.0: # ou bien : elif 10.0 <= note < 20.0:
else:
print("Note invalide !")
print("Fin du programme")
9
Tp N2 : les structures conditionnelles
1-crire un programme python qui demande un entier ............

lutilisateur, teste si ce nombre est positif (>=0) ou non, et ............
affiche positif ou ngatif. ............
............
............
............
............
2-crire un programme python qui demande un entier ............

lutilisateur, teste si ce nombre est strictement positif, nul ............
ou strictement ngatif, et affiche ce rsultat. ............
............
............
............
............
............
............
............
............
............
............
3-crire programme python qui teste si un nombre entier ............
est pair ou impair ............
............
............
............
............
............
4-Un lve arrive en retard de T minutes : une dcision ............

sera prise son gard, lorsque le retard nexcde pas 5 ............
minutes, il peut joindre sa classe sans billet dentre. ............
Lorsque le retard nexcde pas 10 minutes, il peut joindre ............
sa classe avec un billet de retard. Si son retard excde 10 ............
minutes pour la 1re fois il rentre au cours suivant sans ............
punition, sinon ( > 1 fois ) il rentre au cours suivant avec ............
avertissement. ............
crire un programme python qui permet de saisir : ............
- n : nombre de retard ............
- t : nombre des minutes en retard ............
et affiche la dcision : ............
- sans billet ............
- billet de retard ............
- cours suivant sans punition ............
- cours suivant avec punition.
5-Lesprance de vie se calcule comme suit : ............
10
-Tout le monde commence 85 ans desprance de vie ............
-Si la personne fume, elle perd 10 ans desprance de vie ............
-Si la personne a une pression sanguine suprieure ............
120 mm, elle perd 2 ans desprance pour chaque ............
tranche complte de 20 mm en haut de 120. Par exemple, ............
une personne qui fait 142 mm de pression perd 2 ans, une ............
personne qui fait 152 mm perd 2 ans aussi, 160 mm : 4 ............
ans, etc. ............
- Si la personne mange un nombre pair de kilos de bleuets ............
(Plante fleurs bleues) par anne, elle gagne 2 ans ............
crire un programme python qui demande lutilisateur ............
les informations ncessaires, et ensuite afficher ............
lesprance de vie de la personne. ............
............
............
............
............
............
............
............
6-crire un programme python qui demande ............

lutilisateur de saisir le sexe (M/F), la taille (cm), et le ............
poids (kg) dune personne et dafficher : ............
1. PI, le poids idal dune personne, sachant que ce poids ............
thorique est donn par la formule de Lorenz comme ............
suit : ............
- Pour un homme : PI = (taille 100) (taille 150) / 4 ............
- Pour une femme : PI = (taille -100) (taille 120) /4 ............
2. BMI, lindicateur dobsit (Body Mass Index) o BMI = ............
poids / taille avec taille en mtre ............
3. Si une personne est considre comme : Normale (BMI ............
<= 27), ou obse (BMI > 27) ou Malade (BMI >= 32) ............
............
............
............
............
............
............
............
............
............
11
CHAPITRE 3 : Les structures itratives en python (Les boucles)
1- Boucle while (tant que)
Syntaxe :
While (condition) :
Instructions
Exemple :
x=1
While x<10 :
Print ("x a pour valeur" ,x)
x=x*2
Print("fin")
2- Boucle for (pour)

syntaxe
For i in range (Vi,Vf,P):
Instructions
Range(Vi,Vf,p) # retourne les entiers de Vi Vf-1, avec un pas de P
Range(Vi,Vf) # de mme avec la valeur par dfaut de p=1
Range(Vf) # de mme avec la valeur par dfaut de Vi=0 ;Range(Vf) permet dnumrer les entiers de 0 Vf-1
Exemple
For i in range(10) :
Print ("bonjour")
3- Interrompre une boucle : break
Sort immdiatement de la boucle for ou while en cours contenant l'instruction :
for x in range(1, 11): # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
if x == 5:
break
print(x, end=" ")
print("\n Boucle interrompue pour x =", x)
# Affiche :
#1234
# Boucle interrompue pour x = 5
4- Court-circuiter une boucle : continue
Passe immdiatement l'itration suivante de la boucle for ou while en cours contenant l'instruction ; reprend
la ligne de l'en-tte de la boucle :
for x in range(1, 11): # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
if x == 5:
continue
print(x, end=" ")
print("\n La boucle a saut la valeur 5")
# affiche :
# 1 2 3 4 6 7 8 9 10
# La boucle a saut la valeur 5
12
Tp N3 : les boucles
1-crire un programme python qui demande 10 entiers,
compte le nombre dentiers positifs saisis ............
............
............
............
............
............
............
2-crire un programme python qui demande des entiers ............

positifs lutilisateur, les additionne, et qui sarrte en ............
affichant le rsultat ds quun entier ngatif est saisi. ............
............
............
............
............
............
3-le pgcd de 12 et 18 est 6 car les diviseurs de 12 sont {1 ............

;2 ;3 ;4 ;6 ;12} et les diviseurs de 18 sont {1 ;2 ;3 ;6 ;9 ;18}, ............
et les diviseurs communs aux deux entiers sont {1 ;2 ;3 ;6}, ............
et le plus grand entier est bien 6. Ecrire un programme ............
python pour dterminer le PGCD de deux nombres entiers ............
A et B : (Algorithmes des soustractions successives). ............
............
............
............
............
4-crire un programme python qui permet de retrouver le ............

maximum et le minimum dune liste de nombres positifs ............
saisis par lutilisateur. La fin de liste est indique par un ............
nombre ngatif. Exemple : 7 2 20 15 2 6 5 -1. Le maximum ............
est 20, le minimum est 2. ............
............
............
............
............
............
5-crire un programme python qui affiche le nombre ............

doccurrences de la plus grande valeur, Par exemple, pour ............
la srie 1 2 3 1 2 3 3 2 3 1 0, le max est 3 et il y a quatre ............
occurrences de 3. Dans la srie 1 2 3 3 3 3 1 2 4 1 2 3 0, il y ............
a une seule occurrence du maximum qui est 4. ............
............
............
............
13
6-Nombres parfaits : Un nombre est parfait sil est gal ............
la somme de ses diviseurs stricts (diffrents de lui-mme). ............
Ainsi par exemple, lentier 6 est parfait car 6 = 1 + 2 + 3. ............
crire un programme python permettant de dterminer si ............
un entier naturel est un nombre parfait. ............
............
............
............
7-Les nombres de Amstrong appels parfois nombres ............

cubes sont des nombres entiers qui ont la particularit ............
dtre gaux la somme des cubes de leurs chiffres. Par ............
exemple, 153 est un nombre dAmstrong car on a : 153 = ............
13 + 53 + 33: ............
Ecrire un programme python qui teste si un nombre est ............
amstrong ............
............
............
............
8crire un programme python qui lit un nombre entier et ............

dtermine si celuici est un nombre premier. ............
............
............
............
............
............
............
9-crire un programme python qui tant donne un entier ............

positif ou nul, calcule la factorielle de cet entier. Si lentier ............
est strictement ngatif, on demandera lutilisateur de ............
saisir un nouvel entier. Rappel : La factorielle de n, note ............
n!, est : n ! = 1 * 2 * *n ............
............
............
............
............
............
10-crire un programme python qui affiche ............

* ............
** ............
............
***
............
**** ............
Pour un n=4 ............
............
............
14
CHAPITRE 4 : Les Listes
Les listes
Une liste est une collection dlments spars par des virgules, lensemble tant entre crochets *+.
Le premier lment dune liste possde lindice 0. Dans une liste on peut avoir des lments de plusieurs types
Cration dune liste
on peut crer une liste en la dclarant et en lui affectant directement une liste de donnes :
s=*lundi , mardi , 230 , dimanche,True]
il est possible de dclarer une liste vide :s=[]
Extraction de sous-listes :
Soit lst une liste quelconque.
lst[p] renvoie l'lment d'indice p de lst.
lst[p:n] renvoie une nouvelle liste constitue des lments de lst d'indice p inclus n exclu.
lst[p:n:pas] renvoie une nouvelle liste constitue des lments de lst d'indice p inclus n exclu, tous les pas.
lst[:] renvoie une nouvelle liste constitue de tous les lments de lst.
lst[p:] renvoie une nouvelle liste constitue de tous les lments de lst partir de l'lment d'indice p inclus.
lst[:n] renvoie une nouvelle liste constitue de tous les lments de lst depuis le premier jusqu' l'lment
d'indice n exclu.
lst[::pas] renvoie une nouvelle liste constitue des lments de lst, tous les pas.
Exemple : s=*lundi , mardi , 230 , dimanche+
Taper les lignes suivantes dans lenvironnement IDLE et commentez les rsultats obtenus
a. Accs aux lments dune liste
Commande Affichage Commentaire

s[0]
s[1 :]
s[ :2]
s[1 :3]
s[0 :4 :2]
s[ :]
Soit lst une liste quelconque, soit elt un lment :

len(lst) renvoie le nombre d'lments dans lst.
lst.append(elt) ajoute llment elt la fin de la liste lst.
lst.remove(elt) supprime de la liste lst, la premire occurence de llment elt (si la liste lst contient
plusieurs fois l'lment elt, seul le premier est enlev).
lst.pop() supprime le dernier lment de la liste lst.
lst.pop(i) supprime l'lment d'indice i de la liste lst.
elt in lst renvoie True si elt est un lment de la liste lst, sinon renvoie False.
lst.index(elt) renvoie l'indice de llment elt dans la liste lst.
lst.sort() modifie la liste lst en la triant par ordre croissant.
sorted(lst) cre une copie de la liste lst, trie par ordre croissant (la liste lst n'est pas modifie par
cette instruction ; seule sa copie est trie).
15
b. Oprations sur les listes
Commande Affichage Commentaire

len(s)
del(s[2])
s+*jeudi,vendredi]
s*2
s[2]=mercredi
s[0 :2]=[jeudi,38]
s.append(samedi)
s.insert(3,29)
s.remove(lundi)
s.pop(3)
s.pop()
s
s.index(mardi)
s.index(jeudi)
s.reverse()
S=[1,9,6,10,9,2]
s.sorted()
min(s)
max(s)
sum(s)
s.count()
s.clear()
N.B En tapant help(list) dans l'interprteur python, on obtient toutes ces fonctions ainsi que beaucoup d'autres.
Tout comme pour les chanes de caractres, on peut concatner deux listes avec l'oprateur + et rpliquer
plusieurs fois le contenu d'une liste avec l'oprateur de multiplication * et un entier .
c. liste de listes
var=[[1,2,3],[4,5,6]]
var[0]
var[1]
var[0][0]
var[0][1]
var[0][2]
d. Parcourir ou remplir une liste avec une boucle for
On peut parcourir une liste avec une boucle for de 2 faons :
- soit en parcourant les indices de la liste :
for indice in range(len(lst)):
- soit en parcourant directement la liste :
for element in lst:
16
CHAPITRE 5 : Les chanes de caractres
Les chanes de caractres fonctionnent peu prs comme des listes de caractres, mais elles ne sont pas
modifiables : on ne peut donc pas leur ajouter des caractres ou en enlever, ni trier leurs caractres par ordre
croissant, ni modifier les caractres un par un.
En revanche, on peut accder aux caractres d'une chane par leurs indices dans la chane, et extraire des sous-
chanes d'une chane de la mme faon que pour les listes.
a- Fonctions utiles pour travailler avec des chanes

uneChaine[p:n:pas] Renvoie une nouvelle chane constitue des caractres de uneChaine
d'indice p inclus n exclu, tous les pas.
unCar in uneChaine Renvoie True si le caractre unCar est prsent dans la chane uneChaine,
sinon renvoie False.
len(uneChaine) Renvoie la longueur (le nombre de caractres) de la chane uneChaine
le caractre \n introduit un retour la ligne
le caractre \t introduit une tabulation (dcalage horizontal)
le caractre \\ introduit un seul \

uneChaine.split([sparateur]) Renvoie une liste contenant la chane uneChaine dcoupe en plusieurs
sous-chanes. Par dfaut la sparation se fait sur les blancs (espaces,
tabulations, retours la ligne), sauf si un autre sparateur est spcifi.
uneChaine.join(uneListeDeChaines) Renvoie une nouvelle chane contenant tous les lments de la liste
uneListeDeChaines, concatns en utilisant uneChaine comme sparateur.
uneChaine.find(sousChane) Renvoie la position de la premire occurrence de sousChane dans
uneChaine. Renvoie -1 si souChane n'est pas trouve.
uneChaine.strip([caractres]) Renvoie une nouvelle chane dans laquelle tous les blancs (ou tout
caractre prsent dans caractres s'il est donn en paramtre) sont ts au
dbut et la fin de uneChaine.
uneChaine.replace(ancienne, Renvoie une nouvelle chane dans laquelle chaque occurrence dans
nouvelle) uneChaine de la sous-chane ancienne est remplace par nouvelle.
uneChaine.capitalize() Renvoie une nouvelle chane dans laquelle le premier caractre de
uneChaine a t transform en majuscule et les suivants en minuscules.
uneChaine.lower() Renvoie une nouvelle chane o toutes les lettres de uneChaine ont t
converties en minuscules.
uneChaine.upper() Renvoie une nouvelle chane o toutes les lettres de uneChaine ont t
converties en majuscules.
uneChaine.swapcase() convertit toutes les majuscules en minuscules et vice-versa
N.B :Nous avons tudi jusqu'ici deux types de donnes composites : les chanes, qui sont composes de
caractres, et les listes, qui sont composes d'lments de n'importe quel type. Vous devez vous rappeler une
autre diffrence importante entre chanes et listes : il n'est pas possible de changer les caractres au sein d'une
chane existante, alors que vous pouvez modifier les lments d'une liste. En d'autres termes, les listes sont des
squences modifiables, alors que les chanes sont des squences non-modifiables
b- manipuler les chanes de caractres
s1=" bonjour tsi "
len(s1)
s1[:3]
s1[2]="z"
17
o in s1
S1.capitalize()
S1.center(18)
S1.count(o)
S1.find(b)
S1.replace("o","f")
S1.split()
S1.upper()
S1.lower()
print("vive\n l'informa\ntique")
"ara"=="zygomatique"
"ara"<"zygomatique"
"ara">"zygomatique"
"abscisse"<"zbu"
"abscisse"=="zbu"
"abscisse">"zbu"
CHAPITRE 6 : Les tuples
Un tuple est une liste qui ne peut pas tre modifie, ils utilisent les parenthses au lieu des crochets
a- Crer un tuple
Pour crer un tuple, vous pouvez utiliser la syntaxe suivante: t = ()
Pour crer un tuple avec des valeurs, vous pouvez le faire de cette faon: t = (1, "tsi", "123")
Afficher une valeur d'un tuple
b- Operations sur les tuples
Les oprations que l'on peut effectuer sur des tuples sont syntaxiquement similaires celles que l'on effectue sur
les listes, si ce n'est que les tuples ne sont pas modifiables
t[0]=23 #non autoris
c- A quoi sert un tuple alors?
Le tuple permet une affectation multiple:
>>> v1, v2 = 11, 22
>>> v1
11
>>> v2
22
Il permet galement de renvoyer plusieurs valeurs lors d'un appel d'une fonction:
On utilisera un tuple pour dfinir des sortes de constantes qui n'ont donc pas vocation changer.
18
CHAPITRE 7:Les dictionnaires
Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des index, on utilise des cls, c'est dire
des valeurs autres que numriques.
Comment crer un dictionnaire?
Pour initialiser un dictionnaire, on utile la syntaxe suivante: >>> dct = {}
Comment ajouter des valeurs dans un dictionnaire? Rcuprer une valeur dans un dictionnaire
Pour ajouter des valeurs un dictionnaire il faut La mthode get vous permet de rcuprer une valeur
indiquer une cl ainsi qu'une valeur: dans un dictionnaire
>>> dct = {} >>> dct = {"prenom": "Med", "age": 40}
>>> dct["un"] = "one" >>> dct.get("prenom")
>>> dct["deux"] = "two" 'Med'
>>> dct
{'un': 'one', 'deux': 'two'}
Vous pouvez utiliser des cls numriques comme dans
la logique des listes.
Supprimer une entre de dictionnaire Rcuprer les cls par une boucle
Il est possible de supprimer une entre en indiquant sa Pour rcuprer les cls on utilise la mthode keys
cl, comme pour les listes: >>> dict = {"un":"one","deux":"two", "trois" :
>>> del dct["prenom"] "three","quatre" : "four "}
>>> dct >>> for cle in dict.keys():
{'age': 40} ... print (cle)
...
Un
Trois
quatre
deux
Rcuprer les valeurs par une boucle Rcuprer les cls et les valeurs par une boucle
Pour cela on utilise la mthode values Pour rcuprer les cls et les valeurs en mme temps,
>>> dict = {"un":"one","deux":"two", "trois" : on utilise la mthode items qui retourne un tuple.
"three","quatre" : "four "} >>> dict = {"un":"one","deux":"two", "trois" :
>>> for valeur in dict.values(): "three","quatre" : "four "}
... print (valeur) >>> for cle, valeur in dict.items():
... ... print (cle, valeur)
One ...
three un one
four trois three
two quatre four
deux two
Utiliser des tuples comme cl Crer une copie indpendante d'un dictionnaire
Une des forces de python est la combinaison >>> d = {"k1":"med", "k2":"mohamed"}
tuple/dictionnaire qui fait des merveilles dans certains >>> e = d
cas comme lors de l'utilisation de coordonnes. >>> d["k1"] = "Mohamed"
>>> b = {} >>> e
>>> b[(3,2)]=12 {'k2': mohamed, 'k1': mohamed}
>>> b[(4,5)]=13 Pour crer une copie indpendante vous pouvez
>>> b utiliser la mthode copy:
{(4, 5): 13, (3, 2): 12} >>> d = {"k1":"med", "k2":"mohamed"}
>>> e = d.copy()
>>> d["k1"] = "mohamed"
>>> e
{'k2': 'med', 'k1': 'mohamed'}
19
Tp
20
CHAPITRE 8:Les ensembles
Qu'est-ce qu'un ensemble ?
Un ensemble en Python est une collection d'objets sans rptition et sans ordre. On les note comme en maths
avec des accolades {...}. Les lments sont de types quelconques.
Exemples : {5,3,-8,2} {'o','e','y','u','a','i'} {5,'foo',(3,-2),7.4}
L'ensemble vide se note set() et non {} qui cre un dictionnaire !
>>> type({'prix':50, 'nom':'Eska'})
dict
>>> type({2,6,1}
Set
Accs aux lments d'un ensemble
Les lments d'un ensemble ne sont pas numrots. On ne peut pas utiliser une notation comme e[i] puisque parler de
l'lment numro i n'a pas de sens !
L'oprateur in permet de savoir si un objet appartient un ensemble
>>>s={1,2,3,4,3,4,4,5}
>>>s
{1,2,3,4,5}
>>> 2 in {1,2,3,4}
True
L'oprateur < permet de savoir si un ensemble d objet appartient un ensemble
.>>> {2,4} < {1,2,3,4}
True
Axiome du choix : il est possible d'obtenir un lment d'un ensemble E et de le supprimer en mme temps avec la
mthode pop().
>>> E = {5,2,3,1}
>>> x = E.pop()
>>> (x, E) (1, {2,3,5})
donc un ensemble est mutable !
Comment construire un ensemble ?
En extension :
>>> E = {5,2,3,1}
>>> E {1, 2, 3, 5}
Avec la fonction set(...)
>>> E = set('aeiouy')
>>> E {'o', 'i', 'e', 'a', 'y', 'u'}
>>> E = set([5,2,5,6,2])
>>> E {2, 5, 6}
En ajoutant un lment un ensemble E avec la mthode E.add(x)
>>> E = {5,3,2,1}
>>> E.add(8)
>>> E {8,1,2,3,5}
Le nombre d'lments d'un ensemble
On parle du cardinal d'un ensemble (fini). Il s'agit de la fonction len.
>>> E = {5,2,3,1}
>>> len(E) 4
Oprations sur les ensembles
L'ensemble vide se note set()
La runion E U F = ,x : x E ou x F} se note E | F en Python.
>>> {3,2,5,4} | {1,7,2,5}
{1, 2, 3, 4, 5, 7}
L'intersection E F = ,x : x E et x F} se note E & F en Python.
>>> {3,2,5,4} & {1,7,2,5} {2, 5}
La diffrence E - F = {x : x E et x F} se note E - F en Python.
>>> {3,2,5,4} - {1,7,2,5} {3, 4}
Ne pas confondre E - {x} qui construit un nouvel ensemble, avec la mthode E.remove(x) qui supprime x de l'ensemble E.
21
Tp
22
Tp N4
1-crire un programme python qui lit une phrase et
compte le nombre de voyelles quelle contient ............
Exemple : bonjour ............
contient 3 voyelles ............
crire un programme python qui lit une phrase et compte ............
le nombre doccurrence des voyelles quelle contient ............
Exemple : bonjour ............
a e o u i y ............
0 0 21 0 0
2- Un palindrome est un mot ou une phrase qui se lit ............
indiffremment dans les 2 sens (ex : 'bob', 'radar' ou 'Engage le ............
jeu que je le gagne'. crire un programme python qui test si ............
une phrase est palindrome ou non ............
............
............
............
............
3- crire un programme python qui lit une liste de ............

nombres positifs saisis par lutilisateur, La fin de liste est ............
indique par un nombre ngatif, cherche le maximum, le ............
minimum, calcul la somme et cherche lexistence dun ............
lment saisi par lutilisateur dans la liste ............
............
............
............
............
............
4- crire un programme python qui enlve toutes les ............

apparitions dun caractre saisie par lutilisateur dans une ............
phrase ............
Exemple: ............
Cette ligne contient quelques lettres : e. ............
Ctt lign contint qulqus lttrs .
............
............
............
............
............
5- crire un programme python qui demander l'utilisateur ............

d'entrer une chane d'ADN , vrifie que cette chane est bien ............
une chane d'ADN( c'est dire qu'elle contient seulement des ............
"A" , des "T" , des "C" et des "G") toute en stockant ............
loccurrence de chaque lettre dans un dictionnaire ............
Exp : AATACCGGGGGAA
............
,A :4,C :2,G :5,T :1}
............
............
23
CHAPITRE 8:Les fonctions
Dfinition d'une fonction

Une fonction est une suite d'instructions regroupes sous un nom que l'on peut appeler avec son nom. une fonction est
compose de trois grandes parties :
Son nom qui permet d'y faire appel.
Ses arguments qui permettent de spcifier des donnes lui transmettre.
Sa sortie, c'est--dire ce qu'elle retourne comme rsultat.
La syntaxe Python pour la dfinition dune fonction:

def nom_fonction(liste de paramtres):
bloc d'instructions
Fonction simple sans paramtres: Fonction simple avec paramtres :

Exemple : Dans la dfinition d'une telle fonction, il faut prvoir une
def table7(): variable particulire pour recevoir l'argument transmis.
n=1 Cette variable particulire s'appelle un paramtre(ou
while n <11 : argument)
print (n * 7) def table(base):
n = n +1 n=1
Pour utiliser la fonction il suffit de l'appeler par son nom : while n <11 :
table7() print (n * base)
n = n +1
Utilisation d'une variable comme argument : Fonction avec plusieurs paramtres :

L'argument que nous utilisons dans l'appel d'une fonction def tableMulti(base, debut, fin):
peut tre une variable print ('Fragment de la table de multiplication par', base, ':')
a=1 n = debut
while a <20: while n <= fin :
table(a) print (n, 'x', base, '=', n * base)
a = a +1 n = n +1
RM : Le nom d'une variable que nous passons comme appel de la fonction
argument n'a rien voir avec le nom du paramtre tableMulti(8, 13, 17)
correspondant dans la fonction les valeurs prisent par la appel en boucle de la fonction
variable a sont affects la variable base t, d, f = 11, 5, 10
while t<21:
tableMulti(t,d,f)
t, d, f = t +1, d +3, f +5
Variables locales, variables globales :

les variables l'intrieur du corps d'une fonction ne sont accessibles qu' la fonction elle-mme. On dit que ces variables
sont locales la fonction. C'est le cas des variables base, debut, fin et n dans lexemple prcdent.
Chaque fois que la fonction tableMulti() est appele, Python rserve pour elle (dans la mmoire de l'ordinateur)un nouvel
espace de noms. Les contenus des variables base, debut, fin et n sont stocks dans cet espace de noms qui est inaccessible
depuis l'extrieur de la fonction.
24
Exemple 1: Exemple 2 : Exemlpe 3 :
def masque(): def masque(): def monter():
p = 20 global p global a
print (p, q) p = 20 a = a+1
p, q = 15, 38 print (p, q) print (a)
>>> masque() p, q = 15, 38 >>> a = 15
20 38 >>> masque() >>> monter()
>>> print (p, q) 20 38 16
15 38 >>> print (p, q) >>> monter()
20 38 17
Vraies fonctions et procdures

Les fonctions que nous avons dcrites jusqu' prsent ne sont pas tout fait des fonctions au sens strict, mais plus
exactement des procdures. Une vraie fonction (au sens strict) doit en effet renvoyer une valeur lorsqu'elle se termine.
Exemple 1 :
def cube(x):
return x*x*x
L'instruction return dfinit ce que doit tre la valeur renvoye par la fonction. Dans notre exemple il s'agit du cube de
l'argument qui a t transmis lors de l'appel de la fonction.
>>> b = cube(9) # lappel de la fonction
>>> print (b) #ou print(cube(9))
729
RM : lappel de la fonction avec return ce fait par une variable
Exemple 2 :
def table(base):
result = [] # result est une liste vide
n=1
while n < 11:
b = n * base
result.append(b) # ajout d'un terme la liste
n = n +1
return result
>>> ta9 = table(9)
Ainsi nous affectons la variable ta9 les dix premiers termes de la table de multiplication par 9, sous la forme d'une liste :
>>> print (ta9)
[9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
>>> print( ta9[0])
9
>>> print (ta9[3])
36
>>> print (ta9[2:5])
[27, 36, 45]
Exemple 3 :
def cube(n):
return n**3
def volumeSphere(r):
return 4 * 3.1416 * cube(r) / 3
r = input('Entrez la valeur du rayon : ')

print ('Le volume de cette sphre vaut', volumeSphere(r))
25
Paramtres des fonctions
Valeurs par dfaut

En Python, il est possible de dfinir des valeurs par dfaut aux arguments des fonctions, il suffit d'affecter une valeur aux
arguments directement dans la dclaration de la fonction:
Syntaxe : Exemple :
def fonction(arg1, arg2, arg3 = valeur, arg4 = valeur2, ..) : def puissance(nombre, puissance = 2) :
instructions... return nombre ** puissance
appel
print(puissance(3,3))#appel avec 2 arguments
print(puissance(3))#appel avec un seul argument par dfaut le
deuxime vaut 2
Appel dsordonn
Cela vous permet de donner les arguments d'une fonction dans n'importe quel ordre, il suffit de prciser le nom des
arguments que l'on donne aux fonctions :
Exemple1 : Exemple2 :
def puissance(nombre, puissance = 2) : def operations(nombre, plus = 2, moins = 2, divise = 3, multiplie = 5) :
return nombre ** puissance return nombre+plus, nombre-moins, nombre/divise, nombre*multiplie
appel de la fonction appel de la fonction
print(puissance(puissance = 4, nombre = 3)) print(operations())# erreur vous devez mentionner nombre car il ne
contient aucune valeur par dfaut
TypeError Traceback (most recent call last)
<ipython-input-90-07ad72224df3> in <module>()
----> 1 print(operations())
TypeError: operations() missing 1 required positional argument: 'nombre'
print(operations(1)
>>>(3, -1, 0.3333333333333333, 5)
print(operations(4,4, divise = 6, multiplie = 8))
>>>(8, 2, 0.6666666666666666, 32)
RM : Les arguments s'crivent dans l'ordre suivant dans la dclaration d'une fonction : les arguments obligatoires, les
arguments avec valeur par dfaut (facultatifs) et enfin des arguments supplmentaires si ncessaires.
Nombre indfini d'arguments
Arguments anonymes
Ceci est raliser par une squence (liste, tuple ou chane de caractres) comme argument, ceci se prcise par l'utilisation
de l'oprateur '*' juste avant le nom de l'argument :
Exemple1 :
def fonction(*args) :
for elt in args :
print(elt)
appel de la fonction:
fonction(43, 38, "Peuh !", True) >>> (43, 38, 'Peuh !', True)
appel de la fonction par une chaine de caractre: fonction(bonjour tsi))
>>> bonjour tsi
appel de la fonction par * : fonction(*'abcdef')
a
b
c
e
f
RM :Si vous n'utilisez pas l'oprateur '*', votre squence sera alors considre comme n'tant qu'un seul argument ! Cela
est d au typage dynamique, donc '*' prcise que chaque lment de la squence est un argument part entire.
26
Arguments avec cl
Si vous voulez associer une cl chacun des arguments que vous donnez en supplment une fonction, il va falloir utiliser
un dictionnaire. c'est l'oprateur '**' qui sera utilis.
def fonction(**args) :
for cle in args :
print(cle,args[cle])
appel de la fonction
fonction(arg1 = 'Peuh !', arg2 = 38)
>>> arg1 Peuh !
arg2 38
RM:pour convertir un dictionnaire non pas en un seul argument mais en une suite d'arguments, il faut utiliser l'oprateur
'**' devant le dictionnaire pass en argument.
def fonction(**args) :
for cle in args :
print(cle,args[cle])
appel de la fonction
fonction(**dict(arg1 = 'Peuh !', arg2 = 38))
Fonctions anonymes en Python (ou lambda)
Il nexiste aucune opration quon fasse avec une fonction anonyme quon ne puisse faire avec une fonction normale. On
utilise les fonctions anonymes par got, pour des raisons de style. En effet, les lambdas sont trs pratiques pour crer des
fonctions jetables, que lon ne va lutiliser quune seule fois
Prsentation des fonctions lambda
def f(x):
return x*2
f(3)
6 Voici une fonction lambda qui fait la mme chose que la fonction ordinaire prcdente. Notez la
g = lambda x: x*2 syntaxe condense et le mot-cl return, Remarquez que la fonction na pas de nom, mais quelle
g(3) peut tre appele travers la variable laquelle elle est assigne.
6 Vous pouvez utiliser une fonction lambda sans lassigner une variable. Ce nest pas forcment
(lambda x: x*2)(3) trs utile, mais cela dmontre quune fonction lambda est simplement une fonction en ligne
6
Les limites des lambdas
On ne peut les crire que sur une ligne.
On ne peut pas avoir plus dune instruction dans la fonction.
Les modules, qu'est-ce que c'est ?
Il sagit dune sorte de bibliothque (un regroupement de fonctions prdfinies) qui une fois importe permet daccder
de nouvelles fonctions. Il en existe beaucoup. On peut citer :
Le module math
Cest un module qui permet davoir accs aux fonctions mathmatiques : cos, sin, la racine carre (sqrt), nombre (pi) ..
>>> import math # importation du module >>> math.fabs(-3) # Valeur absolue :3
>>> math.sqrt(25) # racine carre >>> math.ceil(2.3) # Renvoie le plus petit entier >= 2.3 :3
>>> math.pow(5, 2) # 5 au carr(5**2) >>> math.floor(5.8) # Renvoie le plus grand entier <= 5.8 : 5
>>> math.exp(5) # Exponentielle >>> math.trunc(9.5) # Tronque 9.5 :9
Le module random
Ce module va nous permettre dutiliser des fonctions gnrant des nombres alatoires.
- random.random() qui renvoie un nombre alatoire entre 0 et 1,
- random.randint(vi,vf) qui renvoie un nombre alatoire entre vi inclus et vf inclus
- random.randrange(vi, vf,p) qui renvoie un nombre alatoire entre vi inclus et vf exclue avec un pas de p
- choice(liste) qui choisit au hasard un nombre dans une liste donne.
import random liste = ['Pierre', 'Paul', 'Jacques']
x=random.random() x=random.choice(liste)
print(x) print(x)
random.randrange(5, 10, 2) L = [7, 3, 8, 5, 6]
random.randint(1, 6) x=random.choice(L)
print(x)
27
Tp 5
1-Ecrire une fonction MIN et une fonction MAX qui
dterminent le minimum et le maximum de deux ............
nombres rels. ............
1- crire des fonctions voyelles et consonnes, prenant en ............
argument une chane de caractres et ............
renvoyant respectivement le nombre de voyelles et le ............
nombre de consonnes prsentes dans cette ............
chane. ............
2- Un palindrome est un mot ou une phrase qui se lit ............

indiffremment dans les 2 sens (ex : 'bob', 'radar' ou 'Engage le ............
jeu que je le gagne'. crire un une fonction palindrome qui ............
test si une phrase est palindrome ou non ............
............
............
............
............
3- Donner une dfinition de la fonction suppression telle que ............

suppression(c, s) supprime toutes les occurrences du caractre ............
c dans la chane s. ............
Par exemple : ............
>>> suppression('p', 'le papa noel') 'le aa noel' ............
............
............
............
............
............
4- Tout langage de programmation dfinit un ensemble de ............

mots cls qui sont des chanes de caractres ayant ............
des significations et des utilisations spcifiques pour ce ............
langage. ............
Pour notre pseudo langage PL, on suppose avoir dfini :
............
MotsCles : une liste qui contient les chanes de caractres qui
............
reprsentent les mots cls de notre pseudo langage PL. Pour le
moment le tuple est : MotsCles = ............
('si','sinon','tantque','pour','definir'). ............
Ecrire une fonction motCle(mot) qui retourne True si mot (le ............
paramtre de la fonction) est un mot cl de PL et False sinon. ............
Exemple. : lappel motCle("si") retourne True et lappel
motcle("entier") retourne False.
5- crire une fonction supprEspaces(ch) qui supprime les ............
espaces multiples conscutifs( qui se suivent) entre les ............
caractres de la chane ch. ............
Exemple : Soit la chane ch=" il fait beau " ............
La fonction supprEspaces(ch), retournera la chane " il fait
............
beau "
............
............
............
28
Tp supplmentaire:
Brins dADN Cet exercice sintresse la manipulation des chanes de caractres et aborde notamment lopration de
dcoupage ainsi que la notion de fonctions partielles vues en cours. Un brin dADN (acide dsoxyribonuclique) est une
molcule prsente dans tout organisme vivant et caractrise en gnral par une squence de bases azotes. Il existe 4
bases diffrentes : ladnine, la thymine, la cytosine, et la guanine. Ces quatre bases jouent un rle important chez les
organismes vivants puisque cest leur agencement (cest dire leur ordre dans la squence) qui dtermine le rle du brin
dADN. Dans cet exercice, les 4 bases seront reprsentes par les 4 caractres A, T, C et G et les brins dADN par
des chanes de caractres. Ainsi un brin dADN qui prsente la squence adnine, adnine, cytosine, guanine sera
reprsent par la chane de caractre AACG
Question 1 Chacune des quatre bases possde une base dite complmentaire avec laquelle elle est capable de sapparier.
Ainsi ladnine et la thymine sont complmentaires et la cytosine et la guanine sont complmentaires.
Donner une dfinition de la fonction base_comp qui, tant donne une base azote, renvoie la base complmentaire.
Par exemple :
>>> base_comp('A') 'T'
>>> base_comp('G') 'C'
>>> base_comp('T') 'A'
>>> base_comp('C') 'G'
Question 2 Par extension le brin complmentaire dun brin dADN est constitu dune squence de bases de mme
longueur mais contenant les bases complmentaires de celui-ci. Donner une dfinition de la fonction brin_comp qui, tant
donn un brin dADN, renvoie le brin dADN complmentaire.
Par exemple :
>>> brin_comp('ATCG') 'TAGC'
>>> brin_comp('ATTGCCGTATGTATTGCGCT') 'TAACGGCATACATAACGCGA'
>>> brin_comp('') ''
Question 3 Donner une dfinition test_comp qui, tant donns deux brins dADN, teste si ces deux brins sont
complmentaires. On notera quune condition minimale pour quils soient complmentaires est quils aient la mme
longueur.
Par exemple :
test_comp('','') True
test_comp('', 'ATCG') False
test_comp('ATCG', '') False
test_comp('ATCG', 'TAGC') True
test_comp('ATCG', 'TAAG') False
test_comp('ATTGCCGTATGTATTGCGCT', 'TAACGGCATACATAACGCGA') True
29
Question 4 : Sous-squence et dcoupage de chanes Une des problmatiques importantes dans le domaine de lanalyse
des molcules dADN est la recherche de squences spcifiques. Dans cette question, on cherche crire une fonction qui
teste si un brin dADN est une sous-squence du second, cest dire si sa squence apparat dans le second brin. Pour cela,
on exploitera lopration de dcoupage des chanes de caractres vu en cours. La solution consiste, tant donn un premier
brin b1 de longueur n, tester toutes les sous-chanes de longueur n dun second brin b2. Si lune de ces sous-chaines est
identique b1, alors b1 est une sous-squence de b2. Par convention, la squnce vide est sous-squence de toute
squence. Donner une dfinition de la fonction test_sous_sequence qui tant donns deux brins dADN, teste si le premier
est une sous-sequence du second.
Par exemple :
>>> test_sous_sequence('','') True
>>> test_sous_sequence('','ATCG') True
>>> test_sous_sequence('ATCG','') False
>>> test_sous_sequence('GC', 'TAGC') True
>>> test_sous_sequence('GC', 'TAAG') False
>>> test_sous_sequence('CA','TAACGGCATACATAACGCGA') True
Question 5 : Fonctions partielles Outre le fait de savoir si une squence apparat dans un brin dADN, on aimerait
galement connatre sa position dans le brin. Sur le principe, cest une simple variation du problme prcdent dans lequel
on renvoie un entier (lindice du dbut de la squence dans le brin) au lieu dun boolen. Mais une difficult apparat ici
puisque si le premier brin nest pas une sous-squence du second, alors il ny a pas dindice renvoyer. On exploitera donc
la solution vue en cours qui sappuie sur les fonctions partielles. Donner une dfinition de la fonction
recherche_sous_sequence qui tant donns deux brins dADN b1 et b2, renvoie lindice de b2 correspondant au dbut de
b1 si b1 est une sous-squence de b2 et ne renvoie rien (None) sinon.
Par exemple :
>>> recherche_sous_sequence('','') 0
>>> recherche_sous_sequence('','ATCG') 0
>>> recherche_sous_sequence('ATCG','')
>>> recherche_sous_sequence('GC', 'TAGC') 2
>>> recherche_sous_sequence('GC', 'TAAC')
>>> recherche_sous_sequence('CATA','TAACGGCATACATAACGCGA') 6
30
Chapitre9 : Programmation Oriente Objet
Avant-propos
En programmation structur un programme est form de la runion de diffrentes procdures et de diffrentes structures
de donnes gnralement indpendantes de ces procdures.
On a un dcoupage net entre donnes et traitement (Procdure).
Traitement 1
Donnes
Traitement 2
En P.O.O un programme met en uvre diffrents objets, chaque objet est associ des donnes et des mthodes agissant
sur ces derniers (On parle des mthodes plutt que procdures).
Alors en P.O.O un programme devient un ensemble des petites entits qui interagissent et communique par message.
Chacune de ces entits est autonome est comprend une partie traitement.
Donnes
Traitement
Les concepts:
Objet : cest une entit cohrente rassemblant des donnes et des codes (mthodes) travaillant sur ces donnes.
Objet: Variable Classe: Type
Classe : les concepts classe correspond simplement la gnralisation de la notion type dans les langues classique, en effet
une classe nest rien dautre que la description dun ensemble dobjet ayant une structure de donnes communs et dispose
des mmes mthodes.
Alors comme des variables dun type classe, en P.O.O en dis aussi quun objet est une instance de la classe.
Linstanciation : Cest la cration dun objet partir dune classe.
Lhritage : Il permet de dfinir une nouvelle classe partir dune classe existant lappelle on ajoute des nouvelles
donnes et des nouvelles mthodes.
Donc lhritage facilite largement la rutilisation des codes.
Encapsulation des donnes : Ce la signifi quil nest pas possible dagir directement sur les donnes dun objet, il est
ncessaire de passer par des mthodes qui joue ainsi le rle dinterface obligatoire.
Dfinition dune classe en python:
Syntaxe # Dfinition des mthodes: Exemples1 :
class nom_de_classe(object) : def mthode(self) : class voiture():
attribut1 = valeur1 instruction1 marque = "Ford"
couleur = "Noir"
attributN = valeurN instructionN prix = 168000.00
def afficher(self):
print("Marque : ", self.marque)
print("Couleur: ", self.couleur)
print("Prix : ", self.prix)
Exemples2 :
class point(object):
x=0
y=0
def saisir(self) :
self.x = float(input(Entrer labscisse : ))
self.y = float(input(Entrer lordonne : ))
def afficher(self):
print("(",self.x,",",self.y,")")
RM:Le paramtre (facultatif) object reprsente la classe anctre (voir section hritage) de toutes les classes.
Le paramtre Self reprsente l'instance de l'objet en cours, et possde donc le mme type que lui.
31
Instanciation
Aprs la dfinition des classes prcdentes, on peut crer des objets (ou instances) de ces classes comme suit :
>>> v = voiture() # v est une instance de la classe voiture
>>> v.afficher() # on appelle la mthode afficher de lobjet v
>>> A = point() # A est un point
>>> A.saisir() # permet dentrer les coordonnes de A
>>> A.afficher() # les affiche
Notion de constructeur(initialiseur)
Le constructeur est une mthode spciale dune classe qui est appele automatiquement la cration dun objet. Il sagit
donc de la premire mthode excute pour un objet et elle constitue de ce fait lendroit idal pour initialiser les donnes
de lobjet.
En Python, cette mthode doit obligatoirement avoir le nom __init__
Exemple
class point():
def __init__(self):
self.x = 0.0
self.y = 0.0
def saisir(self):
self.x = float(input(Entrer labscisse : ))
self.y = float(input(Entrer lordonne : ))
def afficher(self):
Constructeur avec arguments (ou paramtres) Valeurs par dfaut des arguments :
def __init__(self, abs, ord) : def __init__(self, abs=0.0, ord=0.0) :
self.x = abs self.x = abs
self.y = ord self.y = ord
Instanciation : A = point(1.0, 0.5) Instanciation : A = point(1.0, 0.5) ou A = point()
Surcharge dun constructeur

On parle de surcharge lorsquon dfinit plusieurs constructeurs pour une mme classe ayant, videmment, le mme nom
et des listes darguments diffrentes.
Exemple :
class Point: a=Point()
def __init__(self): # premier constructeur a.saisir()
self.x=x a.affiche()
self.y=y c=Point(25)
def __init__(self,x=0): # deuxime constructeur b=Point(5,20)
self.x=x b.affiche()
self.y=0 c.affiche()
def __init__(self,x=0,y=0): # troisieme constructeur a.deplace(20,20)
self.x=x a.affiche()
self.y=y
def affiche(self):
def deplace(self, dx, dy):
self.x = self.x + dx
self.y = self.y + dy
def saisir(self):
self.x = float(input('Entrer l\'abscisse : '))
self.y = float(input('Entrer l\'ordonne : '))
La notion dencapsulation
Le concept dencapsulation est un concept trs utile de la POO. Il permet en particulier dviter une modification par erreur
des donnes dun objet. En effet, il nest alors pas possible dagir directement sur les donnes dun objet ; il est ncessaire
de passer par ses mthodes qui jouent le rle dinterface obligatoire.
32
Dfinition dattributs privs
On ralise la protection des attributs de notre classe Point grce lutilisation dattributs prives. Pour avoir des attributs
privs, leur nom doit dbuter par __ (deux fois le symbole underscore _, qui est le tiret sur la touche 8).
class Point:
def __init__(self, x, y):
self.__x = x
self.__y = y
Il nest alors plus possible de faire appel aux attributs __x et __y depuis lextrieur de la classe Point.
>>> p = Point(1, 2)
>>> p.__x
Traceback (most recent call last):
File "<pyshell#9>", line 1, in
p.__x
AttributeError: Point instance has no attribute '__x'
Il faut donc disposer de mthodes qui vont permettre par exemple de modifier ou dafficher les informations associes
ces variables.
class Point: a = Point(2, 4)
def __init__(self, x, y): a.affiche()
self.__x = x a.deplace(1, 3)
self.__y = y a.affiche()
def deplace(self, dx, dy):

self.__x = self.__x + dx
self.__y = self.__y + dy
def affiche(self):
print("abscisse =", self.__x, "ordonnee =", self.__y)
Accesseurs et mutateurs
Parmi les diffrentes mthodes que comporte une classe, on a souvent tendance distinguer :
les constructeurs ;
les accesseurs (en anglais accessor) qui fournissent des informations relatives ltat dun objet, cest--dire aux valeurs de
certains de ses attributs (gnralement privs) sans les modifier ;
les mutateurs (en anglais mutator) qui modifient ltat dun objet, donc les valeurs de certains de ses attributs.
On rencontre souvent lutilisation de noms de la forme get_XXXX() pour les accesseurs et set_XXXX()pour les mutateurs,
Par exemple, pour la classe Point sur laquelle nous avons dj travaill on peut dfinir les mthodes suivantes :
Exemple :
class Point: a = Point(3, 7)
def __init__(self, x, y): print("a : abscisse =", a.get_x())
self.__x = x print("a : ordonnee =", a.get_y())
self.__y = y a.set_x(6)
def get_x(self): a.set_y(10)
return self.__x print("a : abscisse =", a.get_x())
def get_y(self): print("a : ordonnee =", a.get_y())
return self.__y
def set_x(self, x):
self.__x = x
def set_y(self, y):
self.__y = y
Hritage
Lhritage offre la possibilit de crer une classe partir dune autre. Cela signifie que la nouvelle classe (classe drive)
bnficie des attributs et mthodes de la classe dont elle drive (classe de base ou classe mre).
33
Exemple
Un Atome est un objet constitu dun certain nombre de protons, dlectrons et de neutrons :
class Atome(object):
def __init__(self,e,p,n): # premier constructeur
self.nbre_electrons=x
self.nbre_protons=p
self.nbre_neutrons=n
def afficher(selef) :
print("Je contiens:\n\t",self.nbre_electrons," lctrons,")
print("\t", self.nbre_protons," protons,")
print("\t", self.nbre_neutrons," neutrons.")
Un Ion est un Atome qui possde, en plus des proprits dun atome, une charge :
class Ion(Atome):
def __init__(self, e,p,n,c) :
Atome.__init__(e,p,n)
self.charge = c
def afficher(self) :
Atome.afficher()
print("Ma charge est",self.charge)
Polymorphisme
Le polymorphisme traite de la capacit de l'objet possder plusieurs formes: poly comme plusieurs et morphisme comme
forme. Le polymorphisme, en d'autres termes, est donc la capacit du systme choisir dynamiquement la mthode qui
correspond au type rel de l'objet en cours. Ainsi, si l'on considre un objet Vhicule et ses descendants Bateau, Avion,
Voiture possdant tous une mthode Avancer, le systme appellera la fonction Avancer spcifique suivant que le vhicule
est un Bateau, un Avion ou bien une Voiture.
TP1:
Crer la classe salarier celle-ci les proprits suivantes : Crer la classe commerciale drive de la classe salarier.
Salarier Commercial, Attributs privs: Commission,Taux
Attributs privs:Mat,Nom,,Service,Sal Mthodes: Affiche(),Saisie(),Calculsalaire()
Mthodes suivantes : saisie () qui permet de saisir les (Calculsalaire() de la classe commerciale)= (Calculsalaire()
attribues, de la classe salarier)+taux .commission/100
afficher () qui permet dafficher les informations sur salari
et calcul salaire() fonction qui calcul de salaire annuel,
les get pour afficher et set pour modifier les attributs privs
de la classe salarier
Tp2:
Crer une classe Point permettant de reprsenter des comparer: vrifie si deux points sont identiques
points dans un plan caractris par deux coordonnes x et y symtrique: renvoie le symtrique dun point
Dfinir les fonctions membres suivantes : distance: calcule la distance entre deux points
constructeur dinitialisation rotation: effectue au point une rotation d'un angle A par
affiche: se contentant d'afficher les coordonnes rapport lorigine.
cartsiennes du point. Ecrire une classe permettant de reprsenter des cercles qui
translation: effectue une translation dfinie par un se caractrisent par un rayon et un centre de type point Les
argument oprations possibles sur un cercle sont :
positionner: positionne le point aux coordonnes mthode affiche():laffichage des caractristiques du cercle
cartsiennes passes en paramtre l'obtention de son rayon,
positionner: positionne le point aux coordonnes dun autre le changement de son rayon,
point l'obtention de son centre,
milieu: renvoie le point milieu du segment compos du la translation de son centre,
point courant et d'un autre point. le calcul de sa surface,
le calcul de son primtre,
le test de l'galit du cercle avec un autre cercle,
la vrification de l'appartenance d'un point au cercle,
34
Chapitre10 : les exceptions
Les exceptions sont les oprations queffectue un interprteur ou un compilateur lorsqu' une erreur est dtecte au cours
de lexcution dun programme. En gnrale, lexcution du programme est alors interrompue, et un message derreur plus
ou moins explicite est affich.
Exemple :
>>> print(7/0)
ZeroDivisionError: int division or modulo by zero
Propagation des exceptions
Lorsquune exception est dclenche, le droulement normal de la fonction en cours dexcution est interrompu, et
lexception est transmise (ou propage) la fonction appelante, etc ...
Cette propagation peut cependant tre stoppe par un traitement appropri quon nomme parfois aussi rcupration.
Rcupration dune exception
Rcuprer une exception revient prciser le traitement quil convient deffectuer dans cette situation exceptionnelle.
En Python, la syntaxe dune rcupration dexception est de la forme
try:
# Test d'instruction(s)
except TypeDInstruction:
# Traitement en cas d'erreur
except TypeDInstruction:
# Traitement en cas d'erreur
else :
# Traitement en cas ou aucune erreur ne survient dans le bloc
finally:
# Instruction(s) excute(s) qu'il y ait eu des erreurs ou non
Quelques exceptions en Python
ZeroDivisionError : dclenche lors NameError : dclenche lorsquun ValueError : dclenche lorsque dans
dune tentative de division par 0 identificateur inconnu est trouv une donne dun type correct ne
>>> 1 / 0 >>> print (timoleon) permet pas lvaluation dune
Traceback (most recent call last): Traceback (most recent call last): expression.
File "<stdin>", line 1, in <module> File "<stdin>", line 1, in <module> >>> int (' a 12')
ZeroDivisionError: division by zero NameError: name 'timoleon' is not Traceback (most recent call last):
defined File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with
base 10: ' A 12'
TypeError : dclenche lorsquune IndexError : dclenche lorsquun ImportError : dclenche lors dune
donne est dun mauvais type indice est hors dun intervalle autoris tentative dimportation dun module
>>> len (1) >>> l = [1,2,3] inexistant.
Traceback (most recent call last): >>> l[3] >>> import timoleon
File "<stdin>", line 1, in <module> Traceback (most recent call last): Traceback (most recent call last):
TypeError: object of type 'int' has no File "<stdin>", line 1, in <module> File "<stdin>", line 1, in <module>
len() IndexError: list index out of range ImportError: No module named
'timoleon'
FileNotFoundError : dclenche KeyError : dclenche lors dune RutimeError : dclenche lorsquune
lorsquune opration douverture de tentative daccs la valeur dun erreur est dtecte lexcution dun
fichier choue. dictionnaire avec une cl inexistante. programme, erreur qui chappe
>>> entree = open ('timoleon','r') >>> d = {} toutes les catgories prcdentes.
Traceback (most recent call last): >>> d['timoleon'] >>> from factorielle import fact
File "<stdin>", line 1, in <module> Traceback (most recent call last): >>> fact (1000)
FileNotFoundError: [Errno 2] No such File "<stdin>", line 1, in <module> ...
file or directory: 'timoleon' KeyError: 'timoleon' RuntimeError: maximum recursion
depth exceeded in comparison
35
Exemple :
def division(x,y): Execution:
try: Division(5,2)
r=x/y Rsultat=2.5
except NameError: fin du programme
print("La variable x ou y n'a pas t dfinie.") Division(5,0)
except TypeError: La variable y est gale 0
print("type incompatible avec la division.") fin du programme
except ZeroDivisionError: Division(5,a)
print("La variable y est gale 0.") type incompatible avec la division
else: fin du programme
print("rsultat = ", r)
finally :
print("fin du programme")
Les assertions (assert)
Les assertions sont un moyen simple de s'assurer, avant de continuer, qu'une condition est respecte.
Exemple :
try:
n = float(input("Saisissez une note :"))
assert 20>=n>=0
except ValueError:
print("Vous n'avez pas saisi un nombre.")
except AssertionError:
print("svp une note entre 0 et 20.")
raise
annee = input("donner une anne")
try:
annee = int(annee)
if annee<=0:
raise Exception("l'anne saisie est ngative ou nulle")
except ValueError:
print("La valeur saisie est invalide.")
Vos propres exceptions
Pour des raisons pratiques, vous serez peut-tre amen(e) faire vos propres exceptions.
Nous allons comprendre comment le faire en analysant ce code :
class MonException(Exception):
def __init__(self,raison):
self.raison = raison
def __str__(self):
return self.raison
def multiplierpar5(n):
if n > 20:
raise MonException("Le nombre est trop grand !")
else:
return n * 5
Finalement, cette fonction utilise pourrait donner ceci :
try:
print multiplier_par_5(2)
print multiplier_par_5(21)
except MonException as e:
print (e)
Excution
10
Le nombre est trop grand !
36
Chapitre11 : les fichiers
Une manire de stocker des donnes de manire prenne est de les stocker dans des fichiers.
Les chemins absolus et relatifs sont deux moyens de dcrire le chemin menant des fichiers ou rpertoires.
Le chemin absolu
Quand on dcrit une cible (un fichier ou un rpertoire) sous la forme d'un chemin absolu, on dcrit la suite des
rpertoires menant au fichier. Sous Windows, on partira du nom de volume (C:\, D:\). Par exemple, sous
Windows, si on a un fichier nomm fichier.txt, contenu dans un dossier cpge, lui-mme prsent sur le disque C:,
le chemin absolu menant notre fichier sera C:\cpge\fichier.txt.
Le chemin relatif
Quand on dcrit la position d'un fichier grce un chemin relatif, cela veut dire que l'on tient compte du dossier
dans lequel on se trouve actuellement. Ainsi, si on se trouve dans le dossier C:\test et que l'on souhaite accder
au fichier fic.txt contenu dans ce mme dossier, le chemin relatif menant ce fichier sera tout simplement fic.txt.
Editer un fichier
Pour diter un fichier en python on utilise la fonction open.
Cette fonction prend en premier paramtre le chemin du fichier (relatif ou absolu) et en second paramtre le
type d'ouverture
La fonction open
Voici la syntaxe pour lire un fichier
fichier = open("data.txt", "r")
print fichier
<open file 'data.txt', mode 'r' at 0x7ff6cf3fe4b0>
On remarque que le deuxime paramtre est renseign par un r, ce paramtre indique une ouverture de
fichier en lecture.
Les types d'ouverture

Il existe plusieurs modes d'ouverture:
r, pour une ouverture en lecture (READ).
w, pour une ouverture en criture (WRITE), chaque ouverture le contenu du fichier est cras. Si le fichier
n'existe pas python le cre.
a, pour une ouverture en mode ajout la fin du fichier (APPEND). Si le fichier n'existe pas python le cre.
b, pour une ouverture en mode binaire.
t, pour une ouverture en mode texte.
x, cre un nouveau fichier et l'ouvre pour criture
Fermeture d'un fichier

Comme tout lment ouvert, il faut le refermer une fois les instructions termines. Pour cela on utilise la
mthode close().
fichier.close()
Lire le contenu d'un fichier

On a : fichier=open(entree.txt,r)
fichier.read() : fournit la totalit de fichier sous forme dune chane de caractres
fichier.read(n) : fournit n caractres de fichier partir de la position courante
fichier.readline() : fournit une ligne de fichier sous forme dune chane de caractres
fichier.readlines() : fournit la totalit de fichier sous forme dune liste de chane de caractres
37
Ecrire dans un fichier
On a : fichier=open(sortie.txt,w)
fichier.write(ch) : crit la chane ch dans fichier
fichier.writelines(list) : crit les chane de list dans fichier
A noter que pour le monde d'ouverture a, si vous voulez crire la ligne, vous pouvez utiliser le saut de ligne \n:
fichier = open("data.txt", "a")
fichier.write("\nBonjour monde")
fichier.close()
Exemple dutilisation des fichiers
fic1=open(source.txt,r)
fic2=open(but.txt,w)
ch=fic1.readline()
while ch!="":
fic2.write(ch)
ch=fic1.readline()
fic1.close() # Ne pas oublier ()
fic2.close()
Le mot cl with
Il existe une autre syntaxe plus courte qui permet de s'manciper du problme de fermeture du fichier: le mot
cl with.
Voici la syntaxe:
with open("data.txt", "r") as fichier:
print fichier.read()
Vous pouvez appeler mon_fichier.closed pour vrifier que le fichier est referm. Si le fichier est
ferm, mon_fichier.closed vaudra True.
RM:Il est inutile, par consquent, de fermer le fichier la fin du bloc with. Python va le faire tout seul
Module os
getcwd() : fournit le rpertoire courant
chdir(nomrep) : se place dans le rpertoire nomrep
rename(src,dest) : renomme src en dest
remove(chemin): supprime un fichier Exemple:
rmdir(chemin) : supprime un dossier vide import os as os
mkdir(chemin) : cre le rpertoire chemin >>> os.getcwd( ) : C :\Python32
listdir(chemin) : liste les fichiers de chemin >>> os.chdir(C :\ cpge \ informatique)
>>> os.getcwd( ) : C :\ cpge \ informatique
Module os.path import os.path as opa
Utilisation : from os.path import *, ou import os.path >>>print(opa.exists('test.txt')) : True
exists(chemin) : vrai si chemin existe >>>print(opa.isfile('test.txt')): True
isfile(chemin) : vrai si chemin est un fichier
isdir(chemin) : vrai si chemin est un rpertoire
Enregistrer des objets dans des fichiers
Grce au module pickle , on peut enregistrer n'importe quel objet et le rcuprer par la suite
Enregistrer un objet dans un fichier
Il nous faut naturellement d'abord importer le module pickle.
>>> import pickle
On va ensuite utiliser deux classes incluses dans ce module : la classe Pickler et la classeUnpickler.
Pour crer notre objet Pickler, nous allons l'appeler en passant en paramtre le fichier dans lequel nous allons
enregistrer notre objet.
>>> with open('donnees', 'wb') as fichier:
mon_pickler = pickle.Pickler(fichier)
38
Quand nous allons enregistrer nos objets, ce sera dans le fichier donnees, notez le mode d'ouverture : on ouvre
le fichier donnees en mode d'criture binaire. Il suffit de rajouter, derrire la lettre symbolisant le mode, la
lettre b pour indiquer un mode binaire.
RM:Le fichier que Python va crire ne sera pas trs lisible si vous essayez de l'ouvrir
Maintenant que notre pickler est cr, On utilise la mthode dump du pickler pour enregistrer l'objet:
Exemple :
score = { "joueur 1": 5, "joueur 2": 35, "joueur 3": 20, "joueur 4": 2}
with open('donnees', 'wb') as fichier:
mon_pickler = pickle.pickler(fichier)
mon_pickler.dump(score)
Si vous voulez enregistrer plusieurs objets, appelez de nouveau la mthode dump avec les objets enregistrer.
Rcuprer nos objets enregistrs

Nous allons utiliser une autre classe Unpickler dfinie dans notre module pickle.
Commenons par crer notre objet. sa cration, on lui passe le fichier dans lequel on va lire les objets.
Puisqu'on va lire, on change de mode, on repasse en mode r, et mme rb puisque le fichier est binaire.
with open('donnees', 'rb') as fichier:
mon_depickler = pickle.Unpickler(fichier)
Pour lire l'objet dans notre fichier, il faut appeler la mthode load de notre depickler. Elle renvoie le premier
objet qui a t lu (s'il y en a plusieurs, il faut l'appeler plusieurs fois).
with open('donnees', 'rb') as fichier:
mon_depickler = pickle.Unpickler(fichier)
score_recupere = mon_depickler.load()
En rsum
On peut ouvrir un fichier en utilisant la fonction open prenant en paramtre le chemin vers le fichier et le mode
d'ouverture.
On peut lire dans un fichier en utilisant la mthode read.
On peut crire dans un fichier en utilisant la mthode write.
Un fichier doit tre referm aprs usage en utilisant la mthode close.
Le module pickle est utilis pour enregistrer des objets Python dans des fichiers et les recharger ensuite.
39
Tp :
Exercice 1:
1. Crer un fichier texte (via open en mode criture) et y crire un texte sur plusieurs lignes (rappelons que le
retour la ligne est cod par \n en Python). Bien. Maintenant, trouvez o Python a t fourrer votre fichier, soit
laide de la recherche Windows, soit laide de la commande getcwd du module os de Python, utilisez la
commande chdir de ce mme module os.
2. Lire le fichier que vous venez de crer avec la mthode readlines et afficher le rsultat.
3. crire un petit programme comptant le nombre de caractres de votre fichier texte.
4. crire une fonction comptant le nombre de e dans votre texte. crire une fonction crant une liste contenant
le nombre doccurrences de chaque lettre de lalphabet.
5. crire une fonction crant une copie de votre fichier texte o tous les caractres ont t mis en majuscules.
6. crire une fonction crant un nouveau fichier texte ne contenant que les lignes du fichier prcdent qui
commencent par un e. Mme chose avec les lignes commenant par une majuscule
7. crire une fonction affichant la phrase la plus longue de votre fichier.
8. crire une fonction recopiant le texte dans un nouveau fichier, mais format de faon contenir exactement
50 caractres par ligne.
Exercice 2:
crire une fonction qui recopie le fichier source.txt dans le fichier but.txt en supprimant toutes les lignes qui
commencent par le symbole #.
Exercice 3:
utilisez le fichier :admissibles.txt , qui contient la liste des candidats un concours rcent, avec les quatre champs
suivants : numro de candidat, Nom (en majuscules) et prnom (en minuscules), rsultat lcrit du concours,
puis srie doral pour les admissibles. Ces quatre champs sont spars par des tabulations, le nom et le prnom
par un simple espace
1. Compter le nombre total de candidats, puis le nombre de candidats admissibles.
2. Crer quatre nouveaux fichiers texte contenant la liste des candidats de chaque srie doral (uniquement nom
et prnom).
3. Compter le nombre de candidats dont le prnom commence par chacune des lettres de lalphabet.
4. Crer un copie du fichier de candidats o ces derniers sont classs par ordre de numro et non par ordre
alphabtique (ou par ordre alphabtique des prnoms si vous prfrez)
40
CHAPITRE12 : les tris
But des algorithmes de tri.

Trier un tableau: c'est rang les lments d'un tableau en ordre croissant ou dcroissant.
Il existe plusieurs mthodes de tri qui se diffrencient par leur complexit d'excution et leur complexit de
comprhension pour le programmeur.
1- Tri par slection (tri par minimum)
Cette mthode de tri commence par rechercher l'lment de la liste ayant la plus petite valeur pour l'changer
avec celui situ en premire position, puis elle recherche l'lment ayant la deuxime plus petite valeur pour
l'changer avec celui situ en deuxime position et elle recommence ainsi jusqu' atteindre le dernier lment
de la liste.
Cette mthode porte le nom de tri par slection car elle procde la slection successive de l'lment minimal
parmi ceux restants
Programme en Python :
tri de [101, 115, 30, 63, 47, 20] def triSelection(a) :
tape 1 : [20, 115, 30, 63, 47, 101] n = len(a)
tape 2 : [20, 30, 115, 63, 47, 101] for i in range(n) :
tape 3 : [20, 30, 47, 63, 115, 101] k=i
tape 4 : [20, 30, 47, 63, 115, 101] for j in range(i+1,n) :
Rsultat : [20, 30, 47, 63, 101, 115] if a[k] > a[j] :
k=j
a[k],a[i] = a[i],a[k]
a = [101, 115, 30, 63, 47, 20]; triSelection(a) ; print(a)
2- Tri par insertion
Cette mthode de tri considre les lments de gauche droite en insrant chacun sa place parmi ceux dj
tris situs sur sa gauche. Pour insrer l'lment couramment considr, on dplace simplement les lments
qui lui sont suprieurs un cran vers la droite et on l'insre dans la place laisse vacante
tri de [101, 115, 30, 63, 47, 20]
def triInsertion(a):
tape 1 : [20, 115, 30, 63, 47, 101]
for i in range(len(a)):
tape 2 : [20, 115, 30, 63, 47, 101]
x = a*i+ # Cest llment insrer
tape 3 : [20, 30, 115, 63, 47, 101]
k = i # k est son indice
tape 4 : [20, 30, 63, 115, 47, 101]
# Insertion dans la partie trie :
tape 5 : [20, 30, 47, 63, 115, 101] while k > 0 and a[k-1] > x:
tape 6 : [20, 30, 47, 63, 101, 115]
# Dcalage dun cran sur la gauche :
Rsultat : [20, 30, 47, 63, 101, 115]
a[k],a[k-1] = a[k-1],x
k = k-1
print(a)
return a
3- Tri bulle print(triInsertion([20, 115, 30, 63, 47, 101]))
Cette mthode de tri consiste traverser plusieurs fois la liste de gauche droite en changeant chaque
passage des lments adjacents placs dans un mauvais ordre relatif. Plus prcisment, ds que l'lment de
plus grande valeur est rencontr lors de la premire traverse, il est chang avec chacun des lments situs
sa droite jusqu' ce qu'il trouve sa place dfinitive, l'extrmit droite de la liste. A la deuxime traverse, c'est
l'lment ayant la deuxime plus grande valeur qui est successivement pouss vers sa place dfinitive et ainsi de
suite
tri de [101, 115, 30, 63, 47, 20]
tape 1 : [20, 115, 30, 63, 47, 101] tape 2 : [20, 30, 115, 63, 47, 101] tape 3 :[20, 30, 63, 115, 47, 101]
tape 4 : [20, 30, 63, 47, 115, 101] tape 5 :[20, 30, 63, 47, 101, 115] tape 6 :[20, 30, 63, 47, 101, 115]
tape 7 : [20, 30, 63, 47, 101, 115] tape 8 :[20, 30, 47, 63, 101, 115] tape 9 :[20, 30, 47, 63, 101, 115]
tape 10 : [20, 30, 47, 63, 101, 115] tape 11 :[20, 30, 47, 63, 101, 115] tape 12 :[20, 30, 47, 63, 101, 115]
tape 13 : [20, 30, 47, 63, 101, 115] tape 14 :[20, 30, 47, 63, 101, 115] tape 15 :[20, 30, 47, 63, 101, 115]
Rsultat : [20, 30, 47, 63, 101, 115]
41
def triBulles(a):
for i in range(len(a)-1, 0, -1):
# positionner le prochain plus grand lment
for j in range(i):
# changer les lments adjacents s'ils sont dans un mauvais ordre relatif
if a[j] > a[j+1]:
a[j], a[j+1] = a[j+1], a[j]
print(a)
return a
print(triBulles([20, 115, 30, 63, 47, 101]))
4- Recherche squentielle
consiste parcourir squentiellement la liste jusqu' atteindre l'lment cherch. Si l'lment recherch est
trouv, sa position dans la liste est, dans ce cas, retourne par l'algorithme.
Programme python:
def RechercheSeq(l, c):
position = -1
i=0
while i < len(l):
if l[i] == c:
position = i
break
else:
i += 1
return position
rech=RechercheSeq([4,8,5,99,45,6,3],9)
if rech==-1:
print('n\'existe pas')
else:
print('existe en position:',rech)
5- Recherche dichotomique dans un tableau tri

consiste comparer l'lment cherch avec l'lment central de la liste. Si l'lment cherch lui est infrieur, il
doit se trouver dans la premire moiti de la liste; si l'lment cherch lui est suprieur, il doit se trouver dans la
deuxime moiti de la liste. En appliquant rcursivement cette technique la moiti choisie, l'algorithme
aboutira soit la position de l'lment cherch, soit aucune position auquel cas l'lment n'appartient pas la
liste
Programme python
def RechercheDico(l, c): droite = milieu -1
position = -1 else:
gauche = 0 gauche = milieu + 1
droite = len(l)-1 return position
while gauche <= droite: rech=RechercheDico([4,5,6,7,8,9],9)
milieu = (gauche+droite)//2 if rech==-1:
if c == l[milieu]: print('n\'existe pas')
position = milieu else:
break print('existe en position:',rech)
else:
if c < l[milieu]:
42
Partie 3:ingnierie numrique et simulation (partie 1)
CHAPITRE1 : manipulation des vecteurs avec les listes
1- Ecrire une fonction qui permet la lecture des lments d'un tableau a une dimension
2- Ecrire une fonction qui permet l'affichage des lments d'un tableau a une dimension
3- Ecrire une fonction qui permet de calculer la somme des lments de deux tableaux a une dimension
4- Ecrire une fonction qui permet de calculer le produit des lments de deux tableaux a une dimension
5- Ecrire une fonction qui permet de chercher le maximum des lments d'un tableau a une dimension
6- Ecrire une fonction qui permet de chercher le minimum des lments d'un tableau a une dimension
7- Ecrire une fonction qui permet de dterminer l'existence d'un lment dans d'un tableau
def lireTab(t,n): def afficherTab(t):

for i in range(n): for i in range(len(t)):
try: print('t[%d]:' % (i),t[i])
t[i]=int(input('donner t[%d]:' % (i)))
except ValueError:
print("un nombre svp.")
return(t)
def sommeTab(t1,t2): #appel

t3=3*[0] t1=3*[0]
for i in range(len(t1)): #pour gnraliser le programme on rajoute n qui reprsentera la taille du
t3[i]=t1[i]+t2[i] tableau ( onremplacera 3 par n)
return t3 # n=int(input('tapez la taille du tableau'))
def produitTab(t1,t2): s=lireTab(t1,3)
t3=3*[0] afficherTab(s)
for i in range(len(t1)): t2=3*[0]
t3[i]=t1[i]*t2[i] p=lireTab(t2,3)
return t3 afficherTab(p)
def chercherMax(t): som=sommeTab(t1,t2)
return max(t) afficherTab(som)
prod=produitTab(t1,t2)
def chercherMin(t):
afficherTab(prod)
return min(t)
print('maximum:',chercherMax(t1))
def chercherElt(t,x):
print('minimum:',chercherMin(t1))
trouver=False
if chercherElt(t1,int(input('taper lment chercher:')))==True:
for i in range(len(t)):
print('lment existe')
if t[i]==x:
else:
trouver=True
print('lment n\'existe pas')
break
return trouver
43
CHAPITRE2 : manipulation des vecteurs avec numpy
Pourquoi numpy?
Numpy est un package pour Python spcialis dans la manipulation des tableaux (array), pour nous essentiellement les
vecteurs et les matrices
Les tableaux numpy ne gre que les objets de mme type
Le package propose un grand nombre de routines pour un accs rapide aux donnes (ex. recherche, extraction), pour les
manipulations diverses (ex. tri), pour les calculs (ex. calcul statistique)
Cration Dun Vecteur

Pralable important : importer le module numpy :
import numpy as np #(np sera lalias utilis pour accder la librairie numpy ).
Cration manuelle partir dun ensemble de valeurs Typage des donnes

a = np.array([1.2,2.5,3.2,1.8]) #cration et typage implicite
# Noter le rle des [ ] pour dlimiter les valeurs a = np.array([1,2,4])
Informations sur la structure print(a.dtype) #int32
#type de la structure Le typage des valeurs peut tre implicite ou explicite
print(type(a)) #<class numpy.ndarray> #cration et typage explicite prfrable !
#type des donnes a = np.array([1,2,4],dtype=float)
print(a.dtype) #float64 print(a.dtype) #float64
#nombre de dimensions print(a) #[1. 2. 4.]
print(a.ndim) #1 (on aura 2 si matrice, etc.) #un vecteur de boolens est tout fait possible
#nombre de lignes et colonne b = np.array([True,False,True,True], dtype=bool)
print(a.shape) print(b) #[True False True True]
#(4,) on a tuple 4 cases sur la 1re dim (n0) Cration dun array dobjets complexes (autres que les
#nombre totale de valeurs types de base) est possible
print(a.size) #4, nb.lignes x nb.colonnes si matrice # la donne peut tre un objet python
a = np.array([{"Toto":(45,2000)},{"Tata":(34,1500)}])
print(a.dtype) #object
Cration dune squence de valeurs Chargement partir dun fichier
#suite arithmtique de raison 1 Les donnes peuvent tre stockes dans un fichier texte
a = np.arange(start=0,stop=10) (loadtxt pour charger, savetxt pour sauver)
print(a) #charger partir d'un fichier #typage explicite possible
#[0 1 2 3 4 5 6 7 8 9], attention dernire valeur est exclue a = np.loadtxt("vecteur.txt",dtype=float)
#suite arithmtique de raison step print(a) #[4. 5. 8. 16. 68. 14. 35.]
a = np.arange(start=0,stop=10,step=2) 1 seule colonne pour linstant
print(a) #[0 2 4 6 8]
#suite linaire, nb. de valeurs est spcifi par num
a = np.linspace(start=0,stop=10,num=5)
print(a) #[0. 2.5 5. 7.5 10.], la dernire valeur est incluse ici
#vecteur de valeurs identiques 1 ,1 seule dim et 5 valeurs
a = np.ones(shape=5)
print(a) # [1. 1. 1. 1. 1.]
#vecteur de valeurs identiques 0 ,1 seule dim et 5 valeurs
a = np.zeros(shape=5)
print(a) # [0. 0. 0. 0. 0.]
#plus gnralement , rptition 5 fois (1 dimension) de la Remarque : si besoin, modifier le rpertoire par dfaut avec
valeur 3.2 la fonction chdir() du module os (quil faut importer au
a = np.full(shape=5,fill_value=3.2) pralable)
print(a) #[3.2 3.2 3.2 3.2 3.2]
44
Conversion dune collection (type standard Python) en Redimensionnement explicite
type array de numpy a = np.array([1,2,3])
#liste de valeurs #redimensionnement
lst = [1.2,3.1,4.5] #1 valeur pour vecteur, couple de valeurs pour matrice
print(type(lst)) #<class list> a.resize(new_shape=5)
#conversion partir d'une liste print(a) #[1 2 3 0 0], les nouvelles cases mises 0
a = np.asarray(lst,dtype=float) Concatnation de 2 vecteurs
print(type(a)) #<class numpy.ndarray> concatenation 2 vecteurs
print(a) #[1.2 3.1 4.5] x = np.array([1,2,5,6])
Redimensionnement y = np.array([2,1,7,4])
Rajouter une valeur en dernire position z = np.append(x,y) print(z) #[1 2 5 6 2 1 7 4]
#vecteur de valeurs Suppression dune valeur via son indice
a = np.array([1.2,2.5,3.2,1.8]) #suppression via indice
#ajouter une valeur, place en dernire position b = np.delete(a,2) #une plage dindices est aussi possible
a = np.append(a,10) print(b) #[1.2 2.5 1.8 10.]
print(a) #[1.2 2.5 3.2 1.8 10.]
EXTRACTION DES VALEURS :Accs indic , Plages dindices , v = np.array([1.2,7.4,4.2,8.5,6.3])
toutes les valeurs Accs par conditions :v = np.array([1.2,7.4,4.2,8.5,6.3])

print(v) #extraction avec un vecteur de boolens
#ou b = np.array([False,True,False,True,False],dtype=bool)
print(v[:]) # noter le rle du : , il faut lire ici dbut fin print(v[b]) # [7.4 8.5] #on peut utiliser une condition pour
#accs indic - premire valeur l'extraction
print(v[0]) # 1.2 Noter que le 1er indice est 0 (zro) print(v[v < 7]) # [1.2 4.2 6.3] #parce que la condition est un
#dernire valeur vecteur de boolen
print(v[v.size-1]) b = v < 7; print(b) # [True False True False True]
#6.3 print(type(b)) # <class numpy.ndarray> #on peut utiliser la
#plage d'indices contigus fonction extract()
print(v[1:3]) # [7.4 4.2] print(np.extract(v < 7, v)) # [1.2 4.2 6.3]
#extrmes, dbut 3 (non-inclus) Tri et recherche : v = np.array([1.2,7.4,4.2,8.5,6.3])
print(v[:3]) # [1.2 7.4 4.2] #recherche valeur max
#extrmes, 2 fin print(np.max(v)) # 8.5
print(v[2:]) # [4.2 8.5 6.3] Remarque : Lquivalent existe pour min()
#indice ngatif #recherche indice de valeur max
print(v[-1]) # 6.3, dernier lment print(np.argmax(v)) # 3
#indices ngatifs #tri des valeurs
print(v[-3:]) # [4.2 8.5 6.3], 3 derniers lments print(np.sort(v)) # [1.2 4.2 6.3 7.4 8.5]
Accs indic: v = np.array([1.2,7.4,4.2,8.5,6.3]) #rcupration des indices tris
La notation gnrique des indices est : dbut:fin:pas print(np.argsort(v)) # [0 2 4 1 3]
fin est non inclus dans la liste #valeurs distinctes
#valeur n1 n3 avec un pas de 1 a = np.array([1,2,2,1,1,2])
print(v[1:4:1]) # [7.4, 4.2, 8.5] print(np.unique(a)) # [1 2]
#le pas de 1 est implicite
print(v[1:4]) # [7.4, 4.2, 8.5]
#n0 n2 avec un pas de 2
print(v[0:3:2]) # [1.2, 4.2]
#le pas peut tre ngatif, n3 n1 avec un pas de -1
print (v[3:0:-1]) # [8.5, 4.2, 7.4]
#on peut exploiter cette ide pour inverser un vecteur
print(v[::-1]) # [6.3, 8.5, 4.2, 7.4, 1.2]
45
CALCULS SUR LES VECTEURS
Principe : Les calculs se font lment par lment (elemenstwise) entre vecteurs numpy
v = np.array([1.2,7.4,4.2,8.5,6.3])
#moyenne x = np.array([1.2,1.3,1.0])
print(np.mean(v)) # 5.52 y = np.array([2.1,0.8,1.3])
#mdiane #produit scalaire
print(np.median(v)) # 6.3 z = np.vdot(x,y)
#variance print(z) # 4.86
print(np.var(v)) # 6.6856 #ou lquivalent calcul
#quantile print(np.sum(x*y)) # 4.86
print(np.percentile(v,50)) #6.3 (50% = mdiane) #norme d'un vecteur
#somme n = np.linalg.norm(x)
print(np.sum(v)) # 27.6 print(n) # 2.03
#somme cumule #ou lquivalent calcul
print(np.cumsum(v)) # [1.2 8.6 12.8 21.3 27.6] import math
Calculs entre vecteurs Le principe elementwise print(math.sqrt(np.sum(x**2))) # 2.03
#calculs entre vecteurs Oprations ensemblistes
x = np.array([1.2,1.3,1.0]) Principe : Un vecteur de valeurs (surtout entires) peut tre
y = np.array([2.1,0.8,1.3]) considr comme un ensemble de valeurs.
#multiplication #oprations ensemblistes
print(x*y) # [2.52 1.04 1.3] x = np.array([1,2,5,6])
#addition y = np.array([2,1,7,4])
print(x+y) # [3.3 2.1 2.3] #intersection
#multiplication par un scalaire print(np.intersect1d(x,y)) # [1 2]
print(2*x) # [2.4 2.6 2. ] #union attention, ce nest pas une concatnation
#comparaison de vecteurs print(np.union1d(x,y)) # [1 2 4 5 6 7]
x = np.array([1,2,5,6]) #diffrence c.-d. qui sont dans x et pas dans y
y = np.array([2,1,7,4]) print(np.setdiff1d(x,y)) # [5 6]
b=x>y
print(b) # [False True False True]
#oprations logiques
a = np.array([True,True,False,True],dtype=bool)
b = np.array([True,False,True,False],dtype=bool)
#ET logique
np.logical_and(a,b) # [True False False False]
#OU exclusif logique
np.logical_xor(a,b) # [False True True True]
46
CHAPITRE3 : manipulation des matrices avec les listes
1- Ecrire une fonction qui permet la lecture des lments d'une matrice
2- Ecrire une fonction qui permet l'affichage des lments d'une matrice
3- Ecrire une fonction qui permet de calculer la somme des lments de deux matrices
4- Ecrire une fonction qui permet de calculer le produit des lments de deux matrices
def lireMat(t,n):
for i in range(n):
for j in range(n):
try:
t[i][j]=int(input('donner t[%d,%d]:' % (i,j)))
except ValueError:
print("entier svp.")
return(t)
def afficherMat(t):
for i in range(len(t)):
for j in range(len(t)):
print('t[%d,%d]:' % (i,j),t[i][j])
def sommeMat(t1,t2):
t3=[[0,0,0],[0,0,0],[0,0,0]]
for i in range(len(t1)):
for j in range(len(t1)):
t3[i][j]=t1[i][j]+t2[i][j]
return t3
def produitMat(t1,t2):
t3=[[0,0,0],[0,0,0],[0,0,0]]
for i in range(len(t1)):
for j in range(len(t1)):
t3[i][j]=0
for k in range(len(t1)):
t3[i][j]=t3[i][j]+t1[i][k]*t2[k][j]
return t3
#appel
t=[[0,0,0],[0,0,0],[0,0,0]]
t1=lireMat(t,3)
afficherMat(t1)
t=[[0,0,0],[0,0,0],[0,0,0]]
t2=lireMat(t,3)
som=sommeMat(t1,t2)
afficherMat(som)
prod=produitMat(t1,t2)
afficherMat(prod)
47
CHAPITRE4 : manipulation des matrices avec numpy
Cration Dune Matrice

Cration via une saisie manuelle
Pralable important : importer le module numpy
import numpy as np
np sera lalias utilis pour accder aux routines de la librairie numpy .
Cration manuelle partir dun ensemble de valeurs Cration dune matrice partir dune squence de valeurs
a = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]]) #cration partir d'une squence
Noter le rle des [ ] et [ ] pour dlimiter les portions de la #attention les dim. doivent tre compatibles
matrice a = np.arange(0,10).reshape(2,5)
Informations sur la structure print(a)
#type de la structure arange() gnre une squence de valeurs, 0 9.
print(type(a)) #<class numpy.ndarray> reshape() se charge de les rorganiser en matrice 2 lignes et
#type des donnes 5 colonnes.
print(a.dtype) #float64
#nombre de dimensions
print(a.ndim) #2 (car cest une matrice) #un vecteur peut tre converti en matrice
#nombre de lignes et col, shape renvoie un tuple a = np.array([2.1,3.4,6.7,8.1,3.5,7.2])
print(a.shape) #(3,2) : 3 lignes et 2 colonnes print(a.shape) # (6,)
#nombre totale de valeurs #redim. en 3 lignes x 2 col.
print(a.size) #6, nb.lignes x nb.colonnes b = a.reshape(3,2)
Affichage dune matrice dans la console (IPython) print(b.shape) # (3, 2)
#print de lensemble print(b)
print(a)
#matrices de valeurs identiques

Le typage des valeurs peut tre implicite ou explicite #ex. pour une initialisation
#cration et typage implicite a = np.zeros(shape=(2,4))
a = np.array([[1,2],[4,7]]) print(a)
print(a.dtype) #int32
#cration et typage explicite
a = np.array([[1,2],[4,7]],dtype=float) #plus gnralement
print(a.dtype) #float64 a = np.full(shape=(2,4),fill_value=0.1)
Tout comme pour les vecteurs, la cration dune matrice print(a)
dobjets complexes (autres que les types de base) est
possible
Chargement partir dun fichier #charger partir d'un fichier, typage explicite
Les donnes peuvent tre stockes dans un fichier texte #sparateur de colonne = tabulation \t
(loadtxt pour charger, savetxt pour sauver) a = np.loadtxt("matrice.txt",delimiter="\t",dtype=float)
print(a)
La premire ligne doit tre ignore dans ce fichier, do le

symbole # en dbut de 1re ligne.
Remarque : si besoin, modifier le rpertoire par dfaut avec
la fonction chdir() du module os (quil faut importer au
pralable)
48
Conversion dune collection (type standard Python) en #ajouter une colonne
type array de numpy d = np.array([[7.8],[6.1],[5.4]])
#liste de valeurs print(np.append(a,d,axis=1))
lst = [1.2,3.1,4.5,6.3] Accoler le vecteur d en tant que nouvelle colonne (axis = 1)
print(type(lst)) # <class list> de la matrice a
#conversion partir d'une liste : 2 tapes asarray() et
reshape()
a = np.asarray(lst,dtype=float).reshape(2,2)
print(a) Insertion de b en tant que nouvelle ligne (axis = 0) la
position n1
#insertion
Redimensionnement print(np.insert(a,1,b,axis=0))
a=
Suppression de la ligne (axis = 0) via son indice (n1)

#matrice de valeurs
#suppression
a = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])
print(np.delete(a,1,axis=0))
#ajouter une ligne
b = np.array([[4.1,2.6]])
c = np.append(a,b,axis=0)
print(c) Redimensionnement dune matrice
#modifier la dimension d'une matrice existante
#parcourt les donnes lignes par ligne
h = np.resize(a,new_shape=(2,3))
print(h)
Accoler le vecteur b en tant que nouvelle ligne (axis = 0) de
la matrice a
Extraction Des Valeurs
Accs indic #indice ngatif dernire ligne et toutes les colonnes
v = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]]) print(v[-1,:])
v=
#indices ngatifs deux dernires lignes et toutes les
colonnes
#affichage de la structure dans son ensemble print(v[-2:,:])
print(v)
#accs indic - premire valeur
print(v[0,0]) # 1.2 #calculer la somme des colonnes pour chaque ligne
#dernire valeur noter lutilisation de shape (qui est un s = np.sum(v,axis=1)
tuple) print(s) # [ 3.7 5. 5.4 ]
print(v[v.shape[0]-1,v.shape[1]-1]) # 4.3 #reprer les lignes dont la somme est gale au minimum
#autre solution pour affichage de toutes les valeurs, noter #il est possible quil y en ait plusieurs
le rle des : b = (s == np.min(s))
print(v[:,:]) print(b) # [ True False False]
#plage d'indices contigus : lignes 0 1 (2 non inclus), #application du filtre boolen
toutes les colonnes print(v[b,:])
print(v[0:2,:])
#extrmes, dbut to 2 (non-inclus)

print(v[:2,:])
#extrmes, lignes 1 dernire

print(v[1:,:])
49
Tri et recherche
V= Parcours dune matrice : les itrateurs
v=
#recherche valeur max des lignes (axis = 0) pour chaque

colonne Avec les itrateurs, nous pouvons accder aux valeurs de la
print(np.max(v,axis=0)) # [ 3.2 4.3 ] : 3.2 est la max des matrice sans avoir recourir aux indices (ligne par ligne,
lignes pour la colonne 0, 4.3 est la max des lignes pour la colonne par colonne)
colonne 1 #itrateur - accs ligne par ligne
#recherche valeur max des colonnes (axis = 1) pour chaque s = 0.0
ligne for x in np.nditer(v):
print(np.max(v,axis=1)) # [ 2.5 3.2 4.3] print(x)
#recherche indice de valeur max des lignes (axis = 0)pour s=s+x
chaque colonne print("Somme = ",s)
print(np.argmax(v,axis=0)) # [ 1 2 ]
#tri des lignes (axis = 0) pour chaque colonne
print(np.sort(v,axis=0))
#rcupration des indices tris

print(np.argsort(v,axis=0)) #itrateur - accs colonne par colonne
#"F" pour " Fortran order "
s = 0.0
Itrations for x in np.nditer(v,order="F"):
Parcours dune matrice : boucle indices print(x)
Avec les indices, nous pouvons accder aux valeurs de la s = s +x
matrice comme bon nous semble (ligne par ligne ou print("Somme = ",s)
colonne par colonne)
V=
#boucles indices
s = 0.0 Matrice particulire:
for i in range(0,v.shape[0]): np.zero(n):matrice null
for j in range(0,v.shape[1]): np.ones(n):matrice avec des 1
print(v[i,j]) np.eye(n): matrice avec des 1 diagonale et des 0 ailleurs
s = s + v[i,j] np.diag(v):matrice avec la diagonale le vecteur v
print("Somme = ",s)
50
Calculs Sur Les Matrices
Solution de Y.a = z
V= #rsolution d'quation
z = np.array([1.7,1.0])
print(np.linalg.solve(y,z)) # [0.8195 -0.0261]
Principe : les calculs sont raliss selon un axe (0 : On peut faire a = Y-1.z
traitement des valeurs en ligne pour chaque colonne, 1 : #vrification
inversement) print(np.dot(np.linalg.inv(y),z)) # [0.8195 -0.0261]
#moyenne des lignes pour chaque colonne #matrice symtrique avec XTX
print(np.mean(v,axis=0)) # [1.833 2.867] s = np.dot(np.transpose(x),x)
#moyenne des colonnes pour chaque ligne print(s)
print(np.mean(v,axis=1)) # [1.85 2.5 2.7]
#somme cumule des valeurs en ligne pour chaque
colonne
print(np.cumsum(v,axis=0)) #val. et vec. propres d'une matrice symtrique
print(np.linalg.eigh(s))
#matrice de corrlation
#rowvar = 0 pour indiquer que les variables
#sont organiss en colonnes
m = np.corrcoef(v,rowvar=0)
print(m)
Fonctions matricielles
X= y=
#transposition
print(np.transpose(x))
#multiplication
print(np.dot(x,y))
#dterminant
print(np.linalg.det(y)) # 4.21
#inversion
print(np.linalg.inv(y))
51
Td sur numpy:
Importer le package numpy sous le nom np
Question de cours
1. Crer un vecteur nul de la taille 10, mais la cinquime valeur qui est 1
2. Crer un vecteur nul de la taille 10
3. Crer un vecteur avec des valeurs allant de 10 49
4. Inverser un vecteur (premier lment devient dernier)
5. Trouvez des indices d'lments non nuls de [1,2,0,0,4,0]
6. Crer une matrice d'identit 3x3
7. Crer une matrice 3x3 avec des valeurs allant de 0 8
8. Crer un tableau de 10x10 avec des valeurs alatoires et trouver les valeurs minimales et
maximales
9. Crer un vecteur alatoire de taille 30 et trouver la valeur moyenne
10.Crer une matrice de 5x5 avec des valeurs 1,2,3,4 juste au-dessous de la diagonale
11.Crer une matrice de 5x5 avec des valeurs de ligne allant de 0 4
12.Crer un vecteur alatoire de taille 10 et le tri
13.Multiplier une matrice 5x3 par une matrice 3x2 (produit de la matrice relle)
52
.Elments de Correction des exercices.
Question de cours # un petit programme test
1)Z = np.zeros(10) T=np.array([[1,2,3],[2,5,9],[6,-2,0]])
Z[4] = 1 print(somme_triangle(T))
print(Z) 4)import numpy as np
2) Z = np.zeros(10) def maximum(T):
print(Z) n,m=np.size(T,0),np.size(T,1)
3) Z = np.arange(10,50) M=T[0,0]
print(Z) for i in range(n):
4) Z = np.arange(50) for j in range(m):
Z = Z[::-1] if T[i,j]>M:
Print(Z) M=T[i,j]
5) nz = np.nonzero([1,2,0,0,4,0]) return M
print(nz) # un petit programme test
6) Z = np.eye(3) T=np.array([[1,2,3],[2,5,9],[6,-2,0]])
print(Z) print(maximum(T))
7) Z = np.arange(9).reshape(3,3) 5) import numpy as np
print(Z) def test_valeur(T,x):
8) Z = np.random.random((10,10)) m,n=np.size(T,0),np.size(T,1)
Zmin, Zmax = Z.min(), Z.max() i=0
print(Zmin, Zmax) j=0
9) Z = np.random.random(30) while i<m:
m = Z.mean() if T[i,j]==x :
print(m) return True
10) Z = np.diag(1+np.arange(4),k=-1) j=j+1
print(Z) if j==n:
11) Z = np.zeros((5,5)) j=0
Z += np.arange(5) i=i+1
print(Z) return False
12) Z = np.random.random(10) # un petit programme test
Z.sort() T=np.array([[1,2,3],[2,5,9],[6,-2,0]])
print(Z) print(test_valeur(T,2))
13) Z = np.dot(np.ones((5,3)), np.ones((3,2))) print(test_valeur(T,7))
print(Z) 6)import numpy as n
Exercices def produit(A,B):
1) import numpy as np m,n,p=np.size(A,0),np.size(A,1),np.size(B,1)
def somme_diag(T): C=np.zeros([n,p])
n=np.size(T,0) for i in range(n):
S=0 for j in range(p):
for i in range(n): for k in range(m):
S+=T[i,i] C[i,j]+=A[i,k]*B[k,j]
return S return C
# un petit programme test # Un petit programme test.
T=np.array([[1,2,3],[2,5,9],[6,-2,0]]) A=np.array([[1,2,3],[5,4,6],[0,2,5]])
print(somme_diag(T)) B=np.array([[1,1,-1],[1,1,1],[1,1,1]])
2) import numpy as np print(produit(A,B))
def somme(T): print(produit(B,A))
n,m=np.size(T,0),np.size(T,1) 7) import numpy as n
S=0 def tri_bulle(L):
for i in range(n): n=len(L)
for j in range(m): for i in range(n-1):
S+=T[i,j] for j in range(1,n-i):
return S if L[j-1]>L[j]:
# un petit programme test L[j],L[j-1]=L[j-1],L[j]
T=np.array([[1,2,3],[2,5,9],[6,-2,0]]) return L
print(somme(T)) def Class_Col(T):
3) import numpy as np m,n=np.size(T,0),np.size(T,1)
def somme_triangle(T): for j in range(n):
n=np.size(T,0) T[:,j]=tri_bulle(T[:,j])
S=0 return T
for i in range(n): # Un petit programme test.
for j in range(i,n): T=np.array([[1,2,3],[5,4,6],[0,2,5]])
S+=T[i,j] print(Class_Col(T))
return S
53
CHAPITRE 5:Trac de courbes
Pour tracer des courbes, Python nest pas suffisant et nous avons besoin des bibliothques NumPy et matplotlib
Cration dune courbe
Utilisation de plot()
Linstruction plot() permet de tracer des courbes qui relient des
points dont les abscisses et ordonnes sont fournies dans des
tableaux.
Exemple 1
import numpy as np
import matplotlib.pyplot as plt
x = np.array([1, 3, 4, 6])
y = np.array([2, 3, 5, 1])
plt.plot(x, y)
plt.show() # affiche la figure l'ecran
Exemple 2
Dans cet exemple, nous allons tracer la fonction cosinus.
Syntaxe standard import numpy as np
x = np.linspace(0, 2*np.pi, 30)
y = np.cos(x)
plt.plot(x, y)
plt.show() # affiche la figure l'ecran
Dfinition du domaine des axes - xlim() et ylim()

Il est possible fixer indpendamment les domaines des abscisses et des ordonnes en utilisant les
fonctions xlim(xmin, xmax) et ylim(ymin, ymax).
Exemple 1
import numpy as np
y = np.cos(x)
plt.plot(x, y)
plt.xlim(-1, 5)
plt.show()
Exemple 2
import numpy as np
y = np.cos(x)
plt.plot(x, y)
plt.ylim(-2, 2)
plt.show()
54
Ajout dun titre - title()
On peut ajouter un titre grce linstruction title().
import numpy as np
y = np.cos(x)
plt.plot(x, y)
plt.title("Fonction cosinus")
plt.show()
Ajout dune lgende - legend()
import numpy as np
y = np.cos(x)
plt.plot(x, y, label="cos(x)")
plt.legend()
plt.show()
RM: Pour faire afficher le label, il ne faut pas oublier de faire
appel linstruction legend().
Labels sur les axes - xlabel() et ylabel()
Des labels sur les axes peuvent tre ajouts avec les
fonctions xlabel() et ylabel().
import numpy as np
y = np.cos(x)
plt.plot(x, y)
plt.xlabel("abscisses")
plt.ylabel("ordonnees")
plt.show()
Affichage de plusieurs courbes

Pour afficher plusieurs courbes sur un mme graphe, on peut
procder de la faon suivante :
import numpy as np
y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1)
plt.plot(x, y2)
plt.show()
Exemple avec un lgende
import numpy as np
y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, label="cos(x)")
plt.plot(x, y2, label="sin(x)")
plt.legend()
plt.show()
55
Formats de courbes
Il est possible de prciser la couleur, le style de ligne et de symbole (marker) en ajoutant une chane de
caractres de la faon suivante :
import numpy as np
y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, "r--", label="cos(x)")
plt.plot(x, y2, "b:o", label="sin(x)")
plt.legend()
plt.show()
Style de ligne
Les chanes de caractres suivantes permettent de dfinir le
style de ligne :
Chane - -- : -.
Effet ligne continue tirets ligne en pointill tirets points
RM:Si on ne veut pas faire apparatre de ligne, il suffit dindiquer un symbole sans prciser un style de ligne.
Exemple
import numpy as np
y = np.sin(x)
plt.plot(x, y, "o-", label="ligne -")
plt.plot(x, y-0.5, "o--", label="ligne --")
plt.plot(x, y-1, "o:", label="ligne :")
plt.plot(x, y-1.5, "o-.", label="ligne -.")
plt.plot(x, y-2, "o", label="pas de ligne")
plt.legend()
plt.show()
Symbole (marker)
Les chanes de caractres suivantes permettent de
dfinir le symbole (marker) :
Chane . , o v ^ < >
Effet point pixel circle Triangle Triangle Triangle Triangle
marker marker marker down marker up marker left marker right marker
Chane s p * h H + x D d
Effet square pentagon star hexagon1 hexagon2 plus x diamond thin_diamond
marker marker marker marker marker marker marker marker marker
Couleur
Les chanes de caractres suivantes permettent de dfinir la couleur :
Chane b g r c m y k w
Couleur bleu vert rouge cyan magenta jaune noir blanc
Largeur de ligne
Pour modifier la largeur des lignes, il est possible de changer la valeur de largument linewidth.
import numpy as np
y1 = np.cos(x)
y2 = np.sin(x)
56
plt.plot(x, y1, label="cos(x)")
plt.plot(x, y2, label="sin(x)", linewidth=4)
plt.legend()
plt.show()
On peut bien entendu crer une fonction autre que celles qui existent
dj dans numpy pour la tracer.
Exemple :
import numpy as np
def f(x) :
return(np.log(x + np.sqrt(x**2 + 1)))
x = np.linspace(-10, 10, 10000)
plt.plot(x, f(x))
plt.show()
import numpy as np
def g(x):
if x<0:
return 0
else:
return 1.5
x=np.linspace(-3,3,100)
plt.plot(x,np.exp(-x**2),'b-')
plt.plot(x,[g(xi) for xi in x],'r-')
plt.legend(["f","g"])
plt.xlabel("x")
plt.ylabel("y")
plt.show()
import numpy as np
w_0=1e4
xi=0.5
A=1
w_a=w_0*np.sqrt(1-xi**2)
T=2*np.pi/w_0
t=np.linspace(0,4*T,100)
plt.plot(t,A*np.cos(w_a*t)*np.exp(-xi*w_0*t),'b-')
plt.plot(t,A*np.exp(-xi*w_0*t),'r--')
plt.plot(t,-A*np.exp(-xi*w_0*t),'r--')
plt.xlabel("t (s)")
plt.ylabel("u_c (V)")
plt.title("Regime pseudoperiodique")
plt.show()
57
CHAPITRE6 : manipulation des polynomes avec numpy
Les polynmes sont manipuls avec la classe poly1d() du package numpy.
La cration d'un objet (polynme) de la classe poly1d se fait Les coefficients du polynme sont obtenus par P[i]
par la commande suivante : >>> P=np.poly1d([1, 1, 5, 7, 8, 9])
>>> import numpy as np 1
>>> P=np.poly1d([1,2,4]) >>> for i in range(6):
>>> print(P) print(P[i])
1 x2 + 2 x + 4 9
La liste L=[1,2,4] est donc la liste des coefficients du 8
polynme classs par degr dcroissant. 7
On peut rentrer un polynme en spcifiant ses racines : 5
>>> Q=np.poly1d([1,1],True) 1
>>> print(Q) 1
1 x2 - 2 x + 1 Exercice : Programmer une fonction calculant QoP pour la
On peut changer le nom de la variable : composition des polynmes.
>>> Q=np.poly1d([1,2,1],False,'t') def compo(P,Q):
>>> print(Q) q=Q.order
2
1t +2t+1 print(q)
L'valuation consiste calculer le polynme sur une valeur S=np.poly1d([0])
donne : for i in range(q+1):
>>> Q(1) print(i)
4 S=S+Q[i]*P**i
>>> Q(-1) return(S)
0 Modification de la variable utilise pour l'inconnue
On peut spcifier des coefficients complexes : >>> = np.poly1d([1,2,3], variable='z')
>>> R=np.poly1d([1,1j,2*1j]) >>> print P
>>> print(R) 1 z2 + 2 z + 3
2
1 x + 1j x + 2j Division euclidienne des polynmes : le rsultat est un
Recherche des racines : couple de polynmes (Quotient,Reste).
>>> P=np.poly1d([1,0,1]) >>> P/Q
>>> print(P) (poly1d([ 0.42857143, -0.04081633]), poly1d([-1.59183673,
2
1x +1 2.16326531]))
>>> P.r On peut rcuprer sparment le quotient et le reste :
array([ 0.+1.j, 0.-1.j]) >>> (quo,res)=P/Q
Quelques mthodes de la classe poly1d >>> quo
Liste des coefficients : P.c , Degr du polynme: P.order poly1d([ 0.42857143, -0.04081633])
>>> P=np.poly1d([1,1,5,7,8,9]) Intgration et drivation :
>>> P.coeffs >>> P=np.poly1d([1,1,5,7,8,9])
array([1, 1, 5, 7, 8, 9]) >>> P.deriv()
>>> P.order poly1d([ 5, 4, 15, 14, 8])
5 >>> P.integ()
Multiplication /Addition/Puissance poly1d([ 0.16666667, 0.2 , 1.25 , 2.33333333, 4. ,
>>> Q=np.poly1d([4,2,1]) 9. , 0. ])
>>> print(Q)
4 x2 + 2 x + 1
>>> Q+P
poly1d([ 1, 1, 5, 11, 10, 10])
>>> print(Q+P)
1 x5 + 1 x4 + 5 x3 + 11 x2 + 10 x + 10
>>> Q*P
poly1d([ 4, 6, 23, 39, 51, 59, 26, 9])
>>> print(Q**3)
64 x6 + 96 x5 + 96 x4 + 56 x3 + 24 x2 + 6 x + 1
58
CHAPITRE6 : manipulation des polynomes avec numpy
Polynmes La classe Polynomial du module numpy.polynomial.polynomial permet de travailler avec des polynmes.
from numpy.polynomial import Polynomial
Pour crer un polynme, il faut lister ses coefficients par ordre de degr croissant.
Par exemple, pour le polynme 3 + 2 3,
p = Polynomial([-3, 2, 0, 1])
On peut alors utiliser cette variable comme une fonction pour calculer, en un point quelconque, la valeur de la fonction
polynme associe. Cette fonction peut agir galement sur un tableau de valeurs, elle calcule alors la valeur de la fonction
polynme en chacun des points indiqus.
p(0)
-3.0
p([1, 2, 3])
array([ 0., 9., 30.])
Lattribut coef donne accs aux coefficients ordonns par degr croissant ; ainsi p.coef[i] correspond au coefficient du
terme de degr i.
La mthode degree renvoie le degr du polynme
La mthode roots calcule ses racines.
p.coef array([-3., 2., 0., 1.])
p.coef[1]
2.0
p.degree()
3
p.roots()
array([-0.5-1.6583124j, -0.5+1.6583124j, 1.0+0.j ])
La mthode deriv renvoie un nouveau polynme, driv du polynme initial. Cette mthode prend en argument facultatif
un entier positif indiquant le nombre de drivations effectuer.
La mthode integ intgre le polynme, elle prend un paramtre optionnel supplmentaire donnant la constante
dintgration utiliser, ce paramtres peut tre une liste en cas dintgration multiple ; les constantes dintgration non
prcises sont prises gales zro.
p.deriv().coef array([ 2., 0., 3.])
p.deriv(2).coef array([ 0., 6.])
p.deriv(5).coef array([-0.])
p.integ().coef array([ 0. , -3. , 1. , 0. , 0.25])
p.integ(1, 2).coef # intgrer une fois avec la constante 2
array([ 2. , -3. , 1. , 0. , 0.25])
p.integ(2, [1, 2]).coef # intgrer deux fois
array([ 2. , 1. , -1.5 , 0.33333333, 0. , 0.05 ])
Les oprateurs +, -, * permettent dadditionner, soustraire et multiplier des polynmes. Ils fonctionnent galement entre
un polynme et un scalaire.
Loprateur ** permet dlever un polynme une puissance entire positive.
a = Polynomial([1, 2, 1])
b = Polynomial([5, 3])
p = 2*a * b + Polynomial([-7, 2])
p.coef array([ 3., 28., 22., 6.])
(p**2).coef array([ 9., 168., 916., 1268., 820., 264., 36.])
Loprateur / permet de diviser un polynme par un scalaire.
Pour diviser deux polynmes il faut utiliser loprateur // qui renvoie le quotient ;
Loprateur % calcule le reste.
(p / 2).coef array([ 1.5, 14. , 11. , 3. ])
q = p // a
r = p % a q.coef array([ 10., 6.])
r.coef array([-7., 2.])
(q * a + r).coef array([ 3., 28., 22., 6.])
59
CHAPITRE7 : Recherche des racines dune fonction (zro d'une fonction)
Objectifs
valuer numriquement une solution dquation de la forme f (x) = 0 avec f une fonction valeurs relles, Le but est donc
de trouver une solution approche avec une bonne approximation, plusieurs mthodes peuvent tre utilises dont la
recherche par dichotomie, la mthode de Newton et la mthode de Lagrange.
Mthode dichotomique
Le principe est de diviser lintervalle en deux parts gales, de conserver la partie contenant la racine et dy reproduire
lopration jusqu ce que le critre de convergence soit satisfait. A partir dun intervalle donn *a, b+, encadrant une racine
de la fonction f tudie :
calculer le point c milieu de lintervalle : c = a + b
valuer p = f(a). f(c) puis test :
si p > 0, il ny a pas de racine dans lintervalle [a, c]. La racine est dans lintervalle *c, b+. On donne alors a la valeur de c
si p < 0, la racine est dans [a, c]. On donne alors b la valeur de c
si p = 0, alors la racine est c.
test darrt : Evaluer le critre de convergence
recommencer si le critre de convergence nest pas satisfait
Mthode par dichotomie pour la fonction f sur *a, b+ avec une tolrance :
Exemple : Approximation de 2
Soit f une fonction dfinie par f x x 2 2 continue sur lintervalle [1, 2], valeurs relles
o f (1) = -1 < 0 et f (2) = 2 > 0 donc lquation

o f (x) = 0 possde une solution dans [1, 2]
La valeur mdiane de cet intervalle est 1.5.
o f (1.5) = 0.25 > 0 > f (1), donc lquation f (x) = 0
possde une solution dans [1, 1.5].
o f (1.25) = -0.4675 < 0 < f (1.5), donc lquation
o f (x) = 0 possde une solution dans [1.25, 1.5].
o ...
o f (1.41430664062) 0.000263273715973 > 0 > f
(1.4140625),
o donc lquation f (x) = 0 possde une solution
dans [1.4140625, 1.41430664062].
o appel de la fonction dichotomie pour f x x 2 2
60
o Mthode de Lagrange ( Mthode de la corde )
Le principe de la mthode de la corde est de diviser lintervalle en deux, de conserver la partie contenant la racine et dy
reproduire lopration jusqu ce que le critre de convergence soit satisfait. Au lieu de diviser en deux parts gales, on
cherche le point c (diviseur de lintervalle intersection de laxe des abscisses et de la droite passant par les points
A = (a, f(a)) et B = (b, f(b)). Lquation de la corde est donne par:
A partir dun intervalle donn *a, b+, encadrant une racine de la fonction f tudie :
calculer le point c sur la corde et sur laxe des abscisses :
valuer p = f(a). f(c) puis test :

si p > 0, il ny a pas de racine dans lintervalle [a, c]. La racine est dans lintervalle *c, b+. On donne alors a la valeur de c
si p < 0, la racine est dans [a, c]. On donne alors b la valeur de c
si p = 0, alors la racine est c.
test darrt : Evaluer le critre de convergence
recommencer si le critre de convergence nest pas satisfait
Mthode de la corde de Lagrange pour la fonction f sur *a, b+ avec une tolrance :
Mthode de Newton
Les mthodes de Schrder sont bases sur les n premires drives dune fonction f pour une mthode dordre n + 1.
Dans le cas de la mthode de Newton, on nutilise que la drive premire.
RAPPEL Si la fonction est de classe C 1 sur lintervalle *a, b+ alors, le dveloppement de Taylor lordre 1 donne:
f(b) = f(a) + f (a).(b a) + o(b a) A partir dun point x0, la mthode consiste rechercher le point suivant x1 en le
supposant racine de la fonction et en ngligeant le terme o(b a) dans le dveloppement de Taylor lordre 1.
Ainsi:
Soit f de classe C 1 sur I = [a, b]:

choisir un premier candidat x0
test darrt : Tester le critre de convergence
si le critre nest pas atteint, calculer le nouveau candidat
reprendre depuis le test darrt
61
Mthode de Newton pour la fonction f sur *a, b+ avec une tolrance :
Recherche des racines dune fonction par le module scipy

Le module scipy.optimize regorge de procdures (cf help(scipy.optimize) pour le dtail) permettant de trouver des minima,
des zros ou des points fixes
sp.optimize.newton(f,x0,fprime=None): tant donn une fonction f et le voisinage x0 dune de ses racines, cette mthode
essaie de calculer la position du zro, soit par la mthode de la scante (cas o fprime nest pas donn), soit par la mthode
de Newton (cas o fprime, la drive de f, est donne).
sp.optimize.bisect (f,a,b): la mthode dichotomique qualifi de lente mais sr Trouve une racine de f sur lintervalle * a ; b +
condition que f(a).f(b) < 0 au dpart
sp.optimize.brentq(f,a,b): Trouve une racine de f sur lintervalle * a ; b + condition que f(a).f(b) < 0 au dpart (Utilise
lalgorithme de Brent (1973) ).
Exemples :
>>> import scipy as sp
>>> import scipy.optimize
>>> f = lambda x: x**2 - 2
>>> fp= lambda x: 2*x
>>> sp.optimize.newton(f,1) # Mthode des scantes en partant de 1
1.4142135623730947
>>> sp.optimize.newton(f,1,fp) # Mthode de Newton en partant de 1
1.4142135623730951
>>> sp.optimize.brentq(f,0,2) # Mthode de Brent entre 0 et 2
1.4142135623731364
>>> sp.optimize.bisect(f,0,2)
1.4142135623724243
>>> sp.sqrt(2) # La bonne rponse
1.4142135623730951
>>> sp.optimize.newton(f,100) # Mthode des scantes en partant de 100
1.4142135623730951
>>> sp.optimize.newton(f,100,fp) # Mthode de Newton en partant de 100
1.4142135623730951
62
CHAPITRE8 : Rsolution numrique des quations diffrentielles
Introduction :
Le but de ce chapitre est dtudier la rsolution dun problme dynamique une dimension, linaire ou non, conduisant
la rsolution approche dune quation diffrentielle ordinaire par la mthode dEuler. En dautre terme, on veut trouver
une solution une quation diffrentielle de la forme :
y ' t F t , y (t )

y t 0 y 0
Mthode dEuler
On considre une quation diffrentielle dordre 1 avec condition initiale (problme de Cauchy) :
y ' t F t , y (t )

y t 0 y 0
quoi sert la mthode dEuler ? dterminer approximativement les
valeurs prises par y en des instants t0, t1, . . . , tN-1.
Nous utiliserons les notations suivantes :
y(t0), y(t1), . . . , y(tN-1) sont les valeurs exactes (on connat seulement y(t0))
y0, y1, . . . , yN-1 sont les valeurs approches fournies par la mthode
dEuler. On a gnralement,
pour tout i [2,N -2], ti+1=ti+t avec t un nombre fix assez petit .
Quel est le principe du calcul ? On pose y0 =y(t0)
et on construit ensuite yi+1 partir de yi pour tout i [0,N -2].
Plus prcisment, on choisit yi+1 tel que
Avec PYTHON, nous utiliserons des listes
t = [t0, t1, . . . , tN-1] et y= [y0, y1, . . . , yN-1].
On dfinira donc y[i +1] en posant :
i [0,N -2], y[i +1] = y[i ]+(t [i +1]-t [i ])*F(y[i ], t [i ])
Comment programmer la mthode dEuler ?

tant donns la fonction F, la valeur y0 et un tableau t de taille N contenant les valeurs t0, . . . , tN-1,
on doit raliser les oprations suivantes : Traduction en PYTHON :
Crer un tableau y de taille N

y[0]y0
pour i al lant de 0 N 2
y[i +1] y[i ]+(t [i +1]-t [i ])*F(y[i ], t [i ])
fin pour
Remarque : la commande y=[0]*N cre une liste y de taille N ne contenant que des 0.
Exemple Python. On considre lquation y'=y avec la condition initiale y(0) =1. La solution est la fonction exponentielle, ce
qui permet de comparer les rsultats obtenus. On va travailler sur lintervalle *0,1+ en considrant tout dabord un pas de
0.25 puis un pas de0.1. La fonction exponentielle est reprsente en pointills pour comparer.
F doit tre dfinie comme une fonction de deux

variables mme si ici elle ne dpend que de y.
63
Equation diffrentielle d'ordre 2
Python ne dispose pas de fonctions pour rsoudre numriquement une quation diffrentielle d'ordre 2. Cependant, une
telle quation diffrentielle peut toujours tre transforme en un systme d'quation diffrentielle d'ordre 1.
Rsolution des quations diffrentielles avec odient
Modules utiles
Importer les modules suivants :
import numpy as np
import scipy.integrate
Une quation dordre 1
Nous allons tudier lquation diffrentielle (E1) :(E1) y = 2xy2 avec la condition initiale y(0) = 0.2 sur le segment I = [0, 2]
Cration dune subdivision
Nous allons crer une subdivision quirpartie du segment [0, 2]. Le but est de crer le tableau detype numpy.ndarray
array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ,1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. ])
numpy offre deux solutions :
La fonction np.linspace dont la syntaxe est np.linspace (debut inclus, fin incluse, nombre de points)
Ici lappel correspondant est np.linspace (0, 2., 21).
La fonction np.arange dont la syntaxe est np.arange (debut inclus, fin exclue, pas)
Affecter la variable x cette subdvision.
Rcriture de l'quation
Nous allons rcrire lquation diffrentielle sous la forme y = f(y, x)
Crer la fonction f approprie :
def f (y, x) :
return (2 * x * y**2)
Rsolution approche avec la mthode dEuler
Soit n tel que x soit la subdivision [x0, . . . , xn] (sur notre exemple n vaut 20). Soient a et b tels que I = [a, b] (sur notre
exemple a = 0. et b = 2.)
Posons h =(b a)/n
(Cest la distance entre deux valeurs conscutives de la subdivision). Sur notre exemple, h = 0.1
Notons y la solution de (E1). Nous ne cherchons pas calculer explicitement y. Il sagit de crer la liste [y0, . . . , yn] ou pour
tout i [[0, n]], yi est une valeur approche de y(xi).
Rappelons le schma dEuler (explicite) :
(y0 = 0.2 (valeur initiale)
k [[1, n]], yk = yk1 + hf(yk1, xk1)
Programmer le calcul de cette liste et la mmoriser dans une variable nomme ye (comme yEuler).
Vous pouvez a votre convenance gnrer une liste classique ou un objet de type np.ndarray
64
Vrification : y20 doit tre ` peu prs gal 0.658
Rsolution avec la fonction prprogramme odeint
La fonction odeint du module scipy.integrate a pour syntaxe :
scipy.integrate.odeint (fonction f, valeur initiale en a, subdivision de [a, b])
La valeur de retour est une matrice colonne forme des valeurs y0, . . . , yn.
Excuter la ligne : ys = scipy.integrate.odeint (f, 0.2, x)
Afficher ensuite la valeur de ys avec une instruction print.
Reprsentation simultane
Pour obtenir laffichage de la fentre graphique correspondante il faut aprs linstruction plt.plot excuter linstruction
plt.show ()
Nous allons tracer simultanment sur le mme schma la courbe donne par le schma dEuler explicite et la courbe
donne par lusage de la fonction odeint. Excuter les instructions :
plt.plot (x, ys)
plt.plot (x, ye, linestyle=--) # trace en trait discontinu
plt.xlabel (Axe des abscisses) # annotation de laxe des abscisses
plt.ylabel (Solutions directe et approche) # annotation axe des ordonnes
plt.show ()
Equation dordre 2
Nous allons maintenant nous intresser une quation dordre 2 :
(E2) y'' + y' y = x2 4 sin(x) avec
(y(0) = 1
Y'(0) = 2)
La fonction odeint ne permet de rsoudre que des quations dordre 1. Le truc cest de transformer l'quation dordre 2
en une quation dordre 1 en considrant que linconnue nest pas la fonction y mais le couple z = (y, y').
On calculer alors z'= (y', y'') = (y',-y' + y + x2 4 sin(x)) = f(z) ou f est une fonction que lon peut dfinir :
def f (z, x) :
(y, dy) = z # on rcupre les deux composantes
return ([dy, -dy + y + x**2 - 4*np.sin(x)])
La condition initiale est z0=[1., 2.]
Rsolution
Dfinir la fonction comme cidessus.
Rsoudre ensuite lquation diffrentielle sur lintervalle *0, 4+ :
x = np.linspace (0., 4., 100)
z0 = [1., 2.]
z = scipy.integrate.odeint (f, z0, x)
Regarder la valeur de z : cest la matrice **y(x0), y'(x0)], . . . , [y(xn1), y'(xn1)]] o [x0, . . . , xn] est le tableau des abscisses.
Extraction de la valeur de y et trac
Pour effectuer le trac il faut extraire la premire colonne de la matrice z. Cest ici que les matrices numpy montrent leur
puissance :
y = z[:, 0]
Effectuer ensuite le trac :
plt.plot (x, y)
plt.show ()
Pour ne pas trop craser la figure, il est possible de fixer lchelle sur laxe des ordonnes en insrant
linstruction plt.ylim (0., 10.) entre plt.plot(x,y) et plt.show(). Il existe aussi bien sur une mthode xlim pour laxe des
abscisses.
Exercice1:
On considre le problme de Cauchy { on pose y=x' alors x''=f(x,t) y'=f(x,t) {
Exemple : on considre quation diffrentielle du pendule avec on prendra L=1m

On posant v= on obtient le systme { il s'crit X'=F(X,t) avec X= [ ] et F(X,t)=[ ] on rsout sur
l'intervalle [0,5T] avec T=2
65
Exercice 2
On considre lquation diffrentielle du second ordre : x''(t )(1x2)x'(t )+x(t ) = 0
On pose y = x'.
Vrifier que (x, y) est solution dun systme de deux quations diffrentielles du premier ordre.
Tracer les trajectoires pour les conditions initiales (x(0), y(0)) = (1,0) et (x(0), y(0)) =(3,0) sur lintervalle *0, 20+
Exercice 3
rsoudre sur lintervalle *0,10+ le problme de Cauchy : y''+3y'+2y=2cos(t ), y(0)=1,y'(0)=0
Le nouveau systme en posant z = y :y'=z, z'=-3z-2y+2cos(t ) , y(0) = 1, z(0) = 0
La fonction F associe au systme avec X =[ ]
66

Python 2015 BM

Transféré par

Droits d'auteur :

Formats disponibles

Python 2015 BM

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python 2015 BM

Transféré par

Droits d'auteur :

Formats disponibles

CHAPITRE 1 : introduction la programmation en python

1- Les langages de diffrents niveaux

7- Les instructions de base en python

7.5- Les sorties(affichage)

a, b = 2, 5 print(a,b,sep='@') 2@5 # pour afficher autre chose qu'un espace en

7.6- Oprateurs de comparaison

7.7- Le symbole \ est spcial : il permet de transformer le caractre suivant :

"il fait " + "beau"

instruction taper erreur observe + explication

Tableau 3 : les types de donnes

Exercice 1 : oprateurs et types de donnes

Tableau 5 : oprateur d'affectation =

Tableau 6 : utilisation de la fonction input

instruction taper rsultat obtenu + commentaire ou explication

True and False

Au sein dun bloc, le niveau dindentation doit tre le mme.

4- Test imbriqu print("fin du programme ")

1-crire un programme python qui demande un entier ............

2-crire un programme python qui demande un entier ............

4-Un lve arrive en retard de T minutes : une dcision ............

5-Lesprance de vie se calcule comme suit : ............

6-crire un programme python qui demande ............

2- Boucle for (pour)

2-crire un programme python qui demande des entiers ............

3-le pgcd de 12 et 18 est 6 car les diviseurs de 12 sont {1 ............

4-crire un programme python qui permet de retrouver le ............

5-crire un programme python qui affiche le nombre ............

7-Les nombres de Amstrong appels parfois nombres ............

8crire un programme python qui lit un nombre entier et ............

9-crire un programme python qui tant donne un entier ............

10-crire un programme python qui affiche ............

Commande Affichage Commentaire

Soit lst une liste quelconque, soit elt un lment :

Commande Affichage Commentaire

a- Fonctions utiles pour travailler avec des chanes

le caractre \\ introduit un seul \

s1=" bonjour tsi "

CHAPITRE 6 : Les tuples

3- crire un programme python qui lit une liste de ............

4- crire un programme python qui enlve toutes les ............

5- crire un programme python qui demander l'utilisateur ............

Dfinition d'une fonction

La syntaxe Python pour la dfinition dune fonction:

Fonction simple sans paramtres: Fonction simple avec paramtres :

Utilisation d'une variable comme argument : Fonction avec plusieurs paramtres :

Variables locales, variables globales :

Vraies fonctions et procdures

r = input('Entrez la valeur du rayon : ')

Valeurs par dfaut

2- Un palindrome est un mot ou une phrase qui se lit ............

3- Donner une dfinition de la fonction suppression telle que ............

4- Tout langage de programmation dfinit un ensemble de ............

>>> base_comp('A') 'T'

>>> base_comp('G') 'C'

>>> base_comp('T') 'A'

>>> base_comp('C') 'G'

>>> brin_comp('ATCG') 'TAGC'

>>> brin_comp('ATTGCCGTATGTATTGCGCT') 'TAACGGCATACATAACGCGA'