Cours Info 1er Annee MR Bouhou

CPGE Informatique MPSI / 1TSI /PCSI
Lydex – Ben guerir Programmation Mr L. BOUHOU
1
Chap I
Les instructions de base
I.1. Notion de base
 Un programme est un ensemble d’instructions écrites dans un ordre précis sous un langage de programmation dont le but de
les exécuter par la machine afin de résoudre un problème quelconque.
 Dans ce qui suit, on développera, le langage de programmation Python, comme outil de vérification des algorithmes proposés
en cours d’Algorithmique, et non pas comme outil à étudier.
 Un programme sous python doit respecter, lors de son écriture, la notion d’alignement d’instructions par bloc.
I.2. Notion de Variable

 Une variable apparaît dans un langage de programmation sous un nom de variable, mais pour l'ordinateur il s'agit d'une
référence désignant une adresse mémoire, c'est-à-dire un emplacement précis dans la mémoire vive.
 A cet emplacement sera stockée une valeur bien déterminée qui sera stockée sous la forme d'une suite de nombres binaires.
I.3. Les instructions d’entrée et de sortie
I.3.1. L’instruction d’entrée : « input() » :
C’est une instruction qui bloque l’exécution des instructions afin de permettre une saisie d’une donnée de type entier(int),
réel(float), …etc., au clavier destinée à être stockée dans une variable.
Syntaxe
NomVariable = input(Argument)
-Argument : peut-être omis ou un message dont le but de faciliter la communication entre l’utilisateur et la machine.
Exemple
N=input(„„Taper votre nom :‟‟)
X=input(„‟Donner votre prénom : „‟)
Remarque
On peut convertir la donnée saisie en un type de donnée en même temps que sa saisie de la manière suivante :
N=int(input(„‟Donner un entier positif : ‟‟))
N=float(input(„‟Donner un nombre réel :‟‟))
I.3.2.L’instruction de sortie
L’instruction « print() » permet d’afficher, à l’écran, un message ou d’une donnée stockée dans une variable ou encore une
expression à déduire de plusieurs variables.
Syntaxe : print(Argument)
-Argument : peut-être :
un message entre double cote ‘’ message ‘’
un nom de variable déjà utilisée pour afficher son contenu
une expression à afficher son résultat.
Exemples
N=int(input(„‟Donner un entier N:‟‟))
Print(„‟ Son cube est :‟‟)
print(N**3) ou bien print(„‟Son cube est :‟‟,N**3)
2
Application: Ecrire un programme Phyton permettant la saisie de 3 notes afin de déterminer et d’afficher la moyenne de ces
notes.
Remarque : l’affectation est traduite, en python, par le symbole ‘’=’’.
Chap II
Les instructions Alternatives
II.1.Definition
Il s’agit d’une instruction conditionnelle (if…) qui permet d’exécuter une action qui peut être une ou plusieurs instructions(bloc
d’instructions) en fonction de la valeur logique d’une condition.
II.2 . Conditionnel Simple:
Syntaxe : if (condtion) : « action »
- condition : comparaison entre deux membres dont l’un est souvent une variable ou une expression en fonction d’une variable.
- action: une instruction ou bloc d’instructions à encadrer par l’alignement.
Exemple1
NE=float(input(„‟Donner la note de l‟examen écrit :‟‟))
NO=float(input(„‟Donner la note de l‟examen oral :‟‟))
NTP=float(input(„‟Donner la note de l‟examen TP :‟‟))
M=(NE+NO+NTP)/3
if M>=10 : print(„‟condidat admis‟‟)
print(‟‟ok‟‟)
Exemple2
…
M=(NE+NO+NTP)/3
if M>=10 :
print(„‟condidat admis‟‟)
R=(NO+NTP)/2
print(„‟Resultat:‟‟)
print(„‟Exam Ecrit:‟‟,NE,‟‟\n Exam Oral+TP:‟‟,R)
print(„‟ok‟‟)
II.3 . Conditionnel avec un choix parmi deux:
Syntaxe : if (condtion) : « action1 »
else: « action2 »
Remarque: tenir compte de l’alignement des instructions des actions selon l’objectif souhaité.
Exemple1
NTP=float(input(„‟Donner la note de l‟examen TP :‟‟))
M=(NE+NO+NTP)/3
if M>=10 : print(„‟condidat admis‟‟)
else:print(„‟condidat Non admis‟‟)
Exemple2
…
M=(NE+NO+NTP)/3
if M>=10 :
3
R=(NO+NTP)/2
print(„‟Resultat:‟‟)
print(„‟Exam Ecrit:‟‟,NE,‟‟\n Exam Oral+TP:‟‟,R)
else:print(„‟condidat non admis‟‟)
print(„‟ok‟‟)
II.4 . Conditionnel avec un choix parmi deux: Syntaxe
Syntaxe :
if (condtion1) :
inst1
inst2
if (condition2):
insta
…
instx
else:
…
inst4
…
else:
inst1
if (condition3):
insta
instrb
…
instx
else: …
inst3
…
Exemple
M=(NE+NO)/2
if M<=10 : print(„‟condidat Non admis‟‟)
else:
if M<12:print(„‟Mention : Passable‟‟)
else:
if M<14: print(„‟Mention : Assez Bien‟‟)
else:print(„‟Mention : Bien‟‟)
Remarque:
else : = elif <<cond>> : inst
if <<cond>> : inst
4
Chap III
Les instructions Itératives
3.1. Définition
Il s’agit d’instructions qui permettent de répéter l’exécution d’une action qui peut être une ou plusieurs instructions.
3.2. la boucle « for… »
Pour l’instruction ‘’for’’, le nombre d’itération doit être déterminé et connu d’avance.
Syntaxe:
for compteur in range(VD,VF) :
inst 1
inst 2
……
instr n
Exemples:
1- for i in range(1,10): print(‘3*i)
2- for i in range(5,20):
R=i%2
if R!= 0:print(i)
Remarque 1 : On peut imbriquer deux boucles ‘’for’’ (ou plus).
Syntaxe:
for compteur1 in range(VD1,VF1):
Inst 1
Inst 2
for compteur2 in range(VD1 , VF2) :
Inst a
Inst b
…..
Inst x
Inst 4
Inst 5
…..
Inst n
fin
Remarque 2 : On peut interrompre une boucle ‘’for’’ .

Syntaxe:
for compteur1 in range(VD1,VF1):
Inst 1
Inst 2
if condition:
instr
break
Inst 4
Inst 5
…..
Inst n
5
3.3. la boucle « while… »
Pour l’instruction ‘’while’’, le nombre d’itération n’est pas déterminé(n’est pas connu d’avance). Ce nombre dépond d’une
condition.
Syntaxe: While « condition »:
inst 1
……
instr n
Exemple:
n=0
S1 = 0
While S<1500 :
N=float(input(„‟ prix du produit :‟‟))
S2 = S1
S1 = S1 + N
n=n+1
Print(„‟nombre d‟article sans dépasser la condition est :‟‟,n-1)
Print(„‟le montant correspondant est ;‟‟,S2)
Remarque :
On peut imbriquer :
- deux boucles while et plus
- une boucle while et une boucle for
While condition1 : While condition1 :
Inst1 Inst1
Inst2 Inst2
While condition2 : For compteur in range(VD,VF) :
Insta Insta
instb instb
…. ….
Inst4 Inst4
….. …..
For compteur in range(VD,VF) :
Inst1
Inst2
While condition1 :
Insta
Instb
….
Inst4
….
6
Chap IV
Les fonctions
4.1. Définition et Déclaration

Une fonction est un sous-programme qui regroupe un bloc d’instruction qui seront exécutées suite à l’appelle de cette fonction
par son nom.
Avant d’appeler une fonction, celle-ci peut être déclarée d’une manière générale de la manière suivante:
Def Nom_Fonction (arg1, arg2, ...):
Inst1
Inst2
…
Instrn
Et elle sera appelée par son nom: Nom_Fonction(…)
4.2. Variable globale – Variable locale
Variable globale : est une variable définie à l'extérieur de toute les fonctions. Son contenu est « visible » de l'intérieur d'une
fonction (la fonction peut accéder à son contenu pour l’utiliser), mais la fonction ne peut pas le modifier.
Remarque : si on souhaite modifier, par une fonction, le contenu d’une variable globale, on peut le faire en la déclarant à
l’intérieure de cette fonction, par le mot réservé « global » (voir paragraphe 4.5).
Variable locale : est une variable définie à l’intérieur d'une fonction. Son contenu n’est pas « visible » de l'intérieur d'une autre
fonction (une autre fonction ne peut pas accéder à son contenu pour l’utiliser).
4.3. Les différents types de fonctions

On distingue 4 types de fonctions:
1-Fonction sans valeur de retour et sans paramètres 3-Fonction avec valeur de retour et sans paramètres
2-Fonction sans valeur de retour et avec paramètres 4-Fonction avec valeur de retour et avec paramètres
4.3.1. Fonction sans valeur de retour et sans paramètres

Déclaration :
def NomFonction() :
Inst 1
Inst 2 bloc d’instructions qui
… seront exécutés suite à l’appel
Inst n de cette fonction
Appel : NomFonction()
4.3.2. Fonction sans valeur de retour et avec paramètres

Déclaration :
def NomFonction(P1,P2,…) :
Inst 1
Inst 2 bloc d’instructions en fonction
… des paramètres
Inst n
Appel : NomFonction(liste valeur) ou NomFonction(liste variable)
4.3.3. Fonction avec valeur de retour et sans paramètres

Déclaration :
7
def NomFonction()
Inst 1
Inst 2 bloc d’instructions pour atteindre
… un résultat R
Inst n
return R
Appel : NomVariable = NomFonction() ou print(‘’Résultat est : ‘’, NomFonction())
4.3.4. Fonction avec valeur de retour et avec paramètres

Déclaration :
def NomFonction(liste des paramètres) :
Inst 1
Inst 2 bloc d’instructions pour atteindre
… un résultat R
Inst n
return R
Appel : NomVariable =NomFonction(liste valeur) ou NomVariable=NomFonction(liste variable)
ou encore print(‘’Résultat est :’’,NomFonction(Liste valeur / Liste variable))
4.4. Fonction récursive
Une fonction récursive est une fonction qui fait appel à elle-même toute fois cet appelle est autorisé (c.à.d. l’appelle doit être
conditionné).
Déclaration :
def NomFonction(liste des paramètres) :
inst1
inst2
…
If « condition » :
Inst i
…
NomFonction(liste des valeurs)
Chap V
Les chaines de caractères
5.1. Introduction
Jusqu’à présent nous n’avons manipulé que des nombres. Mais un programme d’ordinateur peut également traiter des
caractères alphabétiques, des mots, des phrases, ou des suites de symboles quelconques.
Dans la plupart des langages de programmation, il existe pour cet usage des structures de données particulières que l’on
appelle: ≪ chaines de caractères ≫.
5.2. Le type de donnée string(correspondant aux chaines de caractère)

Une donnée de type string peut se définir en première approximation comme une suite quelconque de caractères.
Dans un script python, on peut délimiter une telle suite de caractères, soit par des apostrophes (simple quottes), soit par
des guillemets (double quottes).
Exemples :
8
phrase1 = " Est-ce que vous avez compris ?"
phrase2 = 'Bonjour tout le monde, '
print (phrase2, phrase1)
'Bonjour tout le monde, Est-ce que vous avez compris ?
Les 2 variables phrase1, phrase2 sont donc des variables de type string.
les chaines sont des séquences de caractères, Chacun occupe une place précise dans la séquence. Sous Python, les
éléments d’une séquence sont toujours indicés (ou numéroté) de la même manière que les tableaux, c’est-a-dire à partir de zéro.
Pour extraire un caractère d’une chaine, il suffit d’accoler au nom de la variable qui contient cette chaine, son indice
entre crochets :
Exemple:
Ville = 'Marrakech'
print(Ville[1], Ville[3], Ville[5])  a r k
5.3. Opérations élémentaires sur les chaînes

Python intègre de nombreuses fonctions qui permettent d’effectuer divers traitements sur les chaines de caractères
(conversions majuscules/minuscules, découpage en chaines plus petites, recherche de mots, etc.). Cependant, nous devons vous
demander de patienter : ces questions seront développées ultérieurement (voir …..).
5.3.1. Concaténation :
assembler plusieurs petites chaines pour en construire de plus grandes. on fait appel a l’opérateur « + » :
Exemple :
a = 'Petit poisson'
b = ' deviendra grand'
c=a+b
and
5.3. 2. Longueur d’une chaine
Pour avoir le nombre de caractères que contient une chaine de caractere, on fait appel à la fonction intégrée len() :
Exemple :
ch =„BeniMellal'
print(len(ch))  10
5.3.3. Convertir en nombre une chaine de caractères

Exemple :
ch = '8647' ch = '8647'
print(ch + 65)→ *** erreur *** : on ne peut pas additionner n = int(ch)
une chaine et un nombre print(n + 65)
8712
Dans cet exemple, la fonction intégrée int() convertit la chaîne en nombre entier. Il serait également possible de
convertir une chaîne de caractères en nombre réel, à l’aide de la fonction intégrée float().
5.3.4.Extraction de fragments de chaînes
L’extraction consiste a indiquer entre crochets les indices correspondant au début et a la fin de la ≪ tranche ≫ que l’on souhaite
extraire :
ch = "Juliette"
9
ch[0:3]  Jul
Dans la tranche [n,m], le n-ième caractère est inclus, mais pas le m-ième.
ch[3:7]  iett
Les indices de découpage ont des valeurs par défaut : un premier indice non défini est considéré comme zéro, tandis que
le second indice omis prend par défaut la taille de la chaine complète :
ch[:3]  Jul
ch[3:]  iette
Les caractères accentues ne doivent pas faire problème :
ch = 'Adelaide'
print(ch[:3], ch[4:])  Ade aide
5.3.5.Les chaînes sont des séquences non modifiables
Vous ne pouvez pas modifier le contenu d’une chaine existante. Essayez par exemple :
salut = 'bonjour a tous'
salut[0] = 'B'  erreur !!!!
print(salut) !!!!
Par contre, le script ci-dessous fonctionne parfaitement :

salut = 'bonjour a tous'
salut = 'B' + salut[1:]
print(salut) Bonjour a tous
Dans cet exemple, en effet, nous ne modifions pas la chaine salut. Nous en recréons une nouvelle, avec le même nom(il
s’agit bien d’une nouvelle chaine).
5.3.6. Autres fonctions sur les chaînes
- find(sch) : cherche la position d'une sous-chaîne sch dans la chaîne :
ch1 = "Cette leçon vaut bien une fromage, sans doute ?"
ch2 = "fromage"
ch1.find(ch2) 26
Rmq:cas où la sch ne figure pas dans la chaine la fct returne -1
- count(sch) : compte le nombre de sous-chaînes sch dans la chaîne :
ch1 = "Le héron au long bec emmanché d'un long cou"
ch2 = 'long'
ch1.count(ch2)  2
-lower() : convertit une chaîne en minuscules syntaxe : ch.lower()

-upper() : convertit une chaîne en majuscules syntaxe : ch.upper()
-capitalize() : convertit en majuscule la première lettre d'une chaîne syntaxe : ch.capitalize()
-swapcase() : convertit toutes les majuscules en minuscules et vice-versa  syntaxe : ch.swapcase()
-char() : renvoi le caractere correspondant à un code, donné comme argument à cette fonction, supposé un code ASCII
-ord() : renvoi le code ASCII correspondant à un caractere donnée comme argument à cette fonction.
10
Chap VI
Les Listes
6.1. Présentation
On peut définir une liste comme une collection d’éléments séparés par des virgules, l’ensemble étant enfermé dans
des crochets. Exemple : Lst = ['lun','mar','mer',18,20.3,'jeu','ven’]
Dans cet exemple, la valeur de la variable Lst est une liste.
Les éléments individuels qui constituent une liste peuvent être de types variés. (nous verrons plus loin qu’un élément
d’une liste peut lui-même être une liste !).
Comme les chaines de caractères, les listes sont des collections ordonnées d’objets. Les divers éléments qui
constituent une liste sont en effet toujours disposes dans le même ordre, et l’on peut donc accéder a chacun d’entre
eux individuellement si l’on connait son index dans la liste.
Exemples :
Lst=['lun','mar','mer',18, 20.3,'jeu','ven']
Lst[2]  mer
Lst[4]  20.3
A la différence de ce qui se passe pour les chaines, qui constituent un type de données non-modifiables, il est possible
de changer les éléments individuels d’une liste :
Lst[3] = Lst[3] +7
Lst  ['lun','mar','mer',25,20.3,'jeu','ven']
On peut donc remplacer certains éléments d’une liste par d’autres, comme ci-dessous :
Lst[2] = 'Juillet'
Lst  ['lun','mar','Juillet',25,20.3,'jeu','ven']
6.2. Les fonctions concernant les listes

6.2.1. La fonction intégrée len(), que nous avons déjà rencontrée à propos des chaines, s’applique aussi aux listes.
Exemple :
ch=‟bonjour‟
L=len(ch)
L7
6.2.2. append(): qui signifie « ajouter » en anglais permet d’ajouter un élément, passé comme argument, à une liste:
Syntaxe : Liste.append(element)
Exemple :
Lst = ['lun','mar','mer','juillet',25, 'jeu','ven']
Liste.append(„sam‟)
Lst  ['lun','mar','mer','juillet',25, 'jeu','ven', 'sam']
6.2.3. extend(): permet d'ajouter les éléments d'une liste 'L' à la liste à laquelle la méthode est appliquée.
Exemple :
11
L1 = [1,2,3]
L2 = [4,5,6]
L1.extend(L2)
L1  [1, 2, 3, 4, 5, 6]
L2  [4,5,6]
6.2.4.insert(): permet d'insérer un élément x à un index i donnée.

Syntaxe : liste.insert(i,x)
Exemples :
L = [„c‟, ‟r‟, ‟a‟, ‟b‟, ‟e‟]
- L.insert(0,‟f‟) # on ajoute „f‟ au début de la liste
L  [„f‟, „c‟, ‟r‟, ‟a‟, ‟b‟, ‟e‟]
- L.insert(4,15) # pareil pour ajouter 15 à l‟index 4
L  [„f‟, „c‟, ‟r‟, ‟a‟, 15, ‟b‟, ‟e‟]
6.2.5. remove(x): permet de supprimer la première occurrence d’un élément de la liste dont la valeur correspond à la
valeur de x.
Syntaxe : liste.remove(elt_à_supp)
Exemples :
L = [„ab‟, „ac‟, „ad‟, „bc‟, „ac‟, „bd‟]
L.remove(„ac‟)
L  [„ab‟, „ad‟, „bc‟, „ac‟, „bd‟]
6.2.6. del() : permet de supprimer, d’une liste, un élément quelconque (en indiquant son index).
Syntaxe : del(liste[indexe_elt_à_supp])
Exemple :
L = ['lun','mar','mer','juillet',25, 'jeu','ven', 'sam']
del(L[2])
L  ['lun','mar','Juillet',25,'jeu','ven„,‟sam‟]
6.2.7. pop(i) : permet de retirer l'élément figurant à l'index 'i' d'une liste et de le retourner.
Syntaxe : liste.pop(i) # i est l’index de l’élément à supprimer de la liste et de le renvoyer
Exemple :
L = ['a','b','c']
R=Lst.pop(1)
R 'b'
L ['a', 'c']
6.2.8. count(x): renvoie le nombre d'occurrences de la valeur de .

Exemple :
L = ['a','b','c','d','a']
R=L.count('a')
12
R2
R= L.count('e')
R0
6.2.9. reverse(): permet d'inverser une liste.
MaListe = [0,1,2,3,4,5]
MaListe.reverse()
MaListe -- [5, 4, 3, 2, 1, 0]
6.2.10. index(e): renvoie l'index du premier élément dont la valeur est 'e'. Si la valeur ne figure pas dans la liste, une
erreur est renvoyée.
Exemple :
MaListe = ['a','b','c']
MaListe.index('c')  2
6.3. Cas particulier: liste de valeurs Numérique
Initialisation d‟une liste par des valeurs numeriques
- Par des 0:NomListe=zeros(Nombres de cases)
Exemple: import numpy as np
L1=np.zeros(8)  L1=[0,0,0,0,0,0,0,0]
- Par des 1: NomListe=ones(nombres de cases)
Exemple: L2=np.ones(8) L1=[1,1,1,1,1,1,1,1]
- Par différents valeurs: NomListe=[val1, val2, …, valn)
Exemple: L3=[4,26,9,11]
Déclaration
On ne peut appliquer aucune fonction prédéfinie, concernant les listes, à une variable que si cette variable est
initialisée par des valeurs ou au moins déclarée comme liste.
Déclaration: NomListe=[ ]
Exemple: L=[ ]
L.append(5)  L=[5]
Lecture des éléments d’une liste de nombres :
NomListe=[]
NombreDeCases=int(input(„‟donner …. ‟‟))
for i in range( 1,NombreDeCases+1 ) :
print(„‟valeurs „‟,i,‟‟ : „‟)
x=…((input())
NomListe.append(x)
Exemple:
print("donner le nombre d'entier à manipuler:")
n=int(input())
T=[]
for i in range( 1,n +1) :
print(„‟Entier „‟,i,‟‟ : „‟)
13
x=int(input())
T.append(x)
Affichage des éléments d'une liste
- Méthode 1 :
for i in range( NbreValeurs ) : print(nomListe[i]) Ou for i in range( valDebut, valFin) : print(nomListe[i])
- Méthode 2 :
i=0
while i<len(NomListe):
print(NomListe[i])
i=i+1
- Méthode 3 : for val in NomListe : print( val )
6.4. Fonction qui laisse passer, comme paramètre, une liste
Déclaration:
def NomFct(NomPrListe):
traitement en fct de NomPrListe[i] avec 0 <= i < len(NomPrListe)
Appel: NomFct(NomListe)
Exemple: fonction Max() qui laisse passé, comme paramètre, une liste de n entiers afin de retourner le plus grand
entier de ces n entiers.
6. 5.Liste contenant une liste
Les éléments d’une liste peuvent être des listes.
Exemple :
L= [[1,‟Meryam‟,18],[2,‟Kamal‟,23],‟lun‟,4.5]
L[1] [2,Kamal‟,23] et L[3]  4.5
On peut ajouter, un élément type liste à une liste:
P3=[3,‟Amin‟,19]
L.append(P3)
L  [[1,‟Meryam‟,18],[2,Kamal‟,23],‟lun‟,4.5,[3,‟Amin‟,19]]
Pour accéder aux différents constituants d’une liste de ce type, on utilise deux indexes i et j avec i qui indique l’index
de l’élément i dans la liste principale et j l’index de l’élément dans la liste des éléments de l’élément i.
Exemple:
L=[[1,‟Meryam‟,18],[2,Kamal‟,23],‟lun‟,4.5,[3,‟Amin‟,19]]
L[4][1]  ‟Amine‟
Application : somme de deux matrices carrées d‟ordre 3
L1=[[1,0,2],[1,1,0],[2,1,1]]
L2=[[0,1,2],[1,1,1],[2,0,1]]
L=[]
for i in range(3):
for j in range(3):
L.append(L1[i][j] + L2[i][j])
L [[1,1,4],[2,2,1],[4,1,2]]
6.6. Trier une liste de nombres
Pour trier les éléments d’une liste on peut utiliser la fonction sort().
14
Syntaxe: NomListe.sort()
Sinon, on peut utiliser des algorithmes permettant de trier les éléments d’une liste.
6.6.1. Tri à Bulle
Il s’agit de faire plusieurs balayages de la liste en ordonnant les paires d’éléments adjacents de bas en haut (gauche à
droite). A la fin du premier balayage, l’élément le plus grand est remonté au sommet de la liste comme une bulle
d’air dans l’eau. Lors du deuxième balayage, on ne considère que la partie non triée de la Liste pour obtenir à la fin le
deuxième plus grand élément avant le plus grand et ainsi de suite jusqu’à ce que la liste soit trié complètement.
def TriBulle(L):
for i in range(0,len(L)):
for j in range(0,len(L)-i-1):
if (L[j]>L[j+1]) :
temp=L[j]
L[j]=L[j+1]
L[j+1]=temp
6.6.2. Tri par sélection
La méthode est de balayer tous les éléments pour chercher le plus petit qui sera échangé avec L[0]. Puis de répéter, en
cherchant le plus petit élément parmi les éléments restants (de L [1]  L[n-1]) et ainsi de suite.
def TriSelection(L):
for i in range(0,len(L)-1):
min=L[i]
k=i
for j in range(i+1,len(L)):
if (L[j]<min):
min=L[j]
k=j
if min<L[i]:
L[k]=L[i]
L[i]=mi
6.6.3. Tri en utilisant des appels récursifs
Il s‟agit d‟une fonction qui laisse passer, comme paramètre, la liste et sa longueur, afin de placer, pour le tri
croissant, le plus grand élément (respectivement le plus petit pour le tri décroissant ) dans la dernière case de la
liste, puis au lieu de faire une boucle qui itère le même processus on utilise un appel récursif avec une longueur
réduite de 1 permettant à cet appel de se reproduire jusqu‟à ce que la liste soit triée.
def TriRecursif(L,n):
if n>=2:
for i in range(n-1):
if (L[i]>L[i+1]) :
x=L[i]
L[i]=L[i+1]
L[i+1]=x
TriRecursif(L,n-1)
15
Chap VII
Les fichiers Textes
Un fichier est un ensemble d’information enregistré d’une manier permanente dans une mémoire de masse.
Fichier texte =fichier dont le contenu est une suite de caractères « imprimables », en lignes successives, ces lignes
étant séparées les unes des autres par un caractère spécial non imprimable appelé marqueur de fin de ligne(‘’\n’’).
7.1. Création d’un fichier texte
Pour créer un fichier texte en tapant son contenu via le clavier, on peut utiliser, sous Python, les instructions
regroupées dans la fonction présentée ci-dessous à laquelle on doit fournir le nom de fichier à créer.
def creation(nf) :
f=open(nf,'w')
ch=input("taper du texte:")
f.write(ch)
f.close
7.2. Lecture d’un fichier texte
Pour lire tout le contenu d’un fichier texte supposé existant, on peut utiliser, sous Python, les instructions regroupées
dans la fonction présentée ci-dessous à laquelle on doit fournir le nom de fichier à lire son contenu:
def lecture(nf) :
f=open(nf,'r')
ch=f.read()
print(ch)
f.close
Remarque : on peut créer un fichier dont le contenu est du texte fixe(par exemple de 4 lignes) :
def creation(nf) :
f = open(nf, "w")
f.write("la ligne 1\n la ligne 2\nla ligne 3\n la ligne 4")
f.close()
7.3. Extraction des lignes d’un fichier texte
Pour extraire les lignes, d’un fichier séparément les unes des autres, on peut utiliser l’une des methodes suivantes :
7.3.1. la méthode readline(), ne lit qu’une seule ligne à la fois (en incluant le caractère de fin de ligne) :
f = open(„‟nf‟‟,‟r')
lg = f.readline()
Et pour parcourir l’ensemble des lignes du fichier il faut utiliser une boucle permettant la lecture du début du fichier
jusqu’à sa fin.
7.3.2. la méthode readlines(), transfère toutes les lignes du fichier dans une liste de chaînes :
Liste = f.readlines()
print(Liste)  [„ligne 1\n', „ligne 2\n„,…]
f.close()
Remarques:
- Nombre de ligne du fichier est donc déterminé par la longueur de la liste(len(liste)) ;
- L’accès à une ligne du fichier se fera donc par liste[i] avec 0 <= i < len(liste)
- readline() est une méthode qui renvoie une chaîne de caractères, alors que la méthode readlines() renvoie une
liste.
16
Chap VIII
Les Exceptions
8.1. Présentation
Une exception est un mécanisme d’interruption du programme utilisé pour signaler que quelque chose d’anormal est
en train de se produire.
On les rencontre dans de nombreux cas, mais souvent, c’est dans le cadre d’erreurs.
Par exemple, Python va déclencher une erreur pendant la 3eme itération de for de l'exemple ci-dessous qui affiche
une série des inverses de quelques nombres à virgule flottante suivant :
nombres = [0.3333, 2.5, 0, 10]
for x in nombres:
print(„‟ x = „‟,x,‟‟ et l‟inverse de x est (1/x) = „‟,1.0/x)
Apres exécution:
x = 0.3333 et inverse de x est (1/x) = 3.0003000300030003
Traceback (most recent call last):
File "<tmp 1>", line 3, in <module>
print( "x = ",x," et inverse de x est (1/x) = ", 1.0 / x)
ZeroDivisionError: float division by zero
La dernière ligne du message d'erreur indique ce qui s'est passé. Les exceptions peuvent être de plusieurs types, le
type est écrit dans le message.
Dans l'exemple, le type est ZeroDivisionError (erreur de division par zéro).
On peut rencontrer dans d’autre situation d’autres types d’erreur exemple NameError (erreur de nom), TypeError
(erreur de type), etc.
8.2. Attraper une exception
On peut détecter une exception, et réagir, à notre façon, quand une erreur survient, à l’aide de l’instruction try/except.
Il est donc possible d'écrire l’exemple précèdent d’une manière à afficher un message personnel lors la détection
d’une erreur sans laisser le type d’erreur se déclencher.
nombres = [0.3333, 2.5, 0, 10]
try:
for x in nombres:
print("x = ",x,end="\t")
print(" et inverse de x est (1/x) = ", 1.0 / x)
except:
print("Attention, Erreur!")
Apres exécution:
x = 0 Attention, Erreur!
L'instruction try fonctionne ainsi:
- D'abord, la clause d'essai (clause try: les instructions entre les mots-clés try et except) est exécutée.
- S'il ne se produit pas d'exception, la clause d'exception (clause except) est ignorée, et l'exécution du try est
terminée.
17
- Si une exception se produit à un moment de l'exécution de la clause d'essai, le reste de la clause try est
ignoré. Puis si son type correspond à l'exception donnée après le mot-clé except, la clause except est exécutée,
puis l'exécution reprend après l'instruction try.
- Si une exception se produit qui ne correspond pas à l'exception donnée dans la clause except, elle est
renvoyée aux instructions try extérieures; s'il n'y a pas de prise en charge, il s'agit d'une exception non gérée et
l'exécution est arrêtée avec un message, comme vu précédemment.
Dans l’exemple précèdent aucun type d’erreur à détecter n’a été signalé devant le mot « except ». Mais si on souhaite
spécifier le type d’erreur, on indiquera le nom du type d’erreur comme dans l’exemple suivant:
nombres = [0.3333, 2.5, 0, 10]
try:
for x in nombres:
except ZeroDivisionError:
print("Attention, division par zéro impossible!")
Apres exécution:
x = 0 Attention, division par zéro impossible
Ce pendant si un autre type d’erreur survient, il ne sera pas gérer par le message d’erreur(correspondant au type
« ZeroDivisionError »).
nombres = [0.3333, 2.5, „‟7‟‟, 10]
try:
for x in nombres:
print("Attention, division par zéro impossible!")
Apres exécution:
Traceback (most recent call last):
File "<tmp 1>", line 5, in <module>
TypeError: unsupported operand type(s) for /: 'float' and 'str„
On peut donc gérer plusieurs exceptions :
Def essai(L):
try:
for i in range(len(L)):
print("x = ",L[i],end="\t")
print(" et inverse de x est (1/x) = ", 1.0 / L[i])
18
print("Attention, division par zéro impossible")
except TypeError:
print("Attention, Type de données non compatible")
except IndexError:
print("Attention, indexation hors limite")
except NameError:
print("Attention, variable non definit")
8.3. Finally et else
try/except peut être complété par deux autres mots clés : finally et else.
else: est le bloc exécuté si aucune exception n’est levée.
finally: est un bloc qui est exécuté après que tous les autres blocs aient été exécutés, peu importe qu’il y ait eu une
exception ou non.
Exemple :
nombres = [0.3333, 2.5, 8, 10]
try:
for i in range(len(nombres)):
print("x = ",nombres[i],end="\t")
print(" et inverse de x est (1/x) = ", 1.0 / nombres[i])
print("Attention, division par zéro impossible")
except TypeError:
print("Attention, Type de données non compatible")
except IndexError:
print("Attention, indexation hors limite")
except NameError:
print("Attention, variable non définit")
else:
print("Aucune erreur n a été détectée")
finally:
print("exécution terminée; fin programme")
19
Chap IX
Les Fichiers de données
9.1. Création d’1 fichier de donnée:
Le module pickle est utilisé pour enregistrer des objets Python dans des fichiers et les recharger ensuite.
Etape 1: importer le module « pickle »  import pickle
Etape 2:ouvrir un fichier de donnée pour écriture  f =open('NomFich', 'wb')
Etape 3:créer un enregistrement sous forme d’une liste  L=[Val1,Val2,…,Valn]
Etape 4:Ajouter l’element L au fichier ouvert  pickle.dump(L,f)
Etape 5:fermer le fichier  f.close()
Syntaxe
import pickle
def creer(NomFich):
f =open(NomFich, 'wb')
NB= int(input(“Nombre d‟enregistrement souhaité ajoutés :”))
for i in range(NB):
L=[]
print(“Entrez les Données de l‟Enreg ",i+1," : ")
d1=input(„‟Donnée 1:”) #tenant compte du type
L.append(d1)
d2=input(“Donnée 2 : ")
L.append(d2)
....
dn=input(“Donné n : "))
L.append(dn)
pickle.dump(L,f)
f.close()
Exemple
Fonction creer() qui laisse passer, comme parametre, un nom de fichier afin de creer un fichier de données sur les
notes de n Etudiants. On enregitrera, dans ce fichier, pour chaque etudiant son numéro d’inscription(entier), son
nom(text), sa note de l’examen Ecrit(reel), celle de l’examen Oral(reel) et celle de l’examen TP(reel).
import pickle
def creer(NomF):
f =open(NomF, 'wb')
NB=int(input("donner le nombre d étudiant :"))
for i in range(0,NB):
L=[]
print("numéro inscription de l'étudiant ",i+1," : ")
numIns=input()
L.append(numIns)
nom=input("nom : ")
L.append(nom)
NE=float(input("note Ecrit : "))
20
L.append(NE)
NO=float(input("note oral : "))
L.append(NO)
NTP=float(input("note TP : "))
L.append(NTP)
pickle.dump(L,f)
f.close()
9.2. Lecture d’1 fichier de donnée:
Etape 1: importer le module « pickle » si ce n’est déjà fait  import pickle
Etape 2:ouvrir un fichier de donnée pour lecture  f =open('donnees_test2', ‘rb')
Etape 3: lecture individuel de chaque enregistrement  L = pickle.load(f)
Etape 4: fermer le fichier  f.close()
Syntaxe
def lecture(NomFichier):
f = open(NomFichier, 'rb')
while 1:
try:
L = pickle.load(f)
« Traitement en fonction de L[0], L[1], …»
« puis Affichage ou valeur de retour »
except EOFError:
print(« message indiquant la fin »)
break
f.close()
Exemple
Fonction lecture() qui laisse passer, comme paramètre, le nom de fichier crée lors du paragraphe précédent, afin de
récupérer les données de ce fichier dont le but d’afficher, pour chaque étudiant son numéro d’inscription, son nom et
la moyenne de ses trois notes(note de l’examen Ecrit, celle de l’examen Oral et celle de l’examen TP) et d’afficher la
décision du jury(Admis/Non Admis).
def lecture(NomF):
f = open(NomF, 'rb')
print("num Insc \t\t Nom \t\t Moyenne \t\t Décision Jury")
while 1:
try:
L = pickle.load(f)
num=L[0]
nom=L[1]
NE=L[2]
NO=L[3]
NTP=L[4]
M=(NE+NO+NTP)/3
if M<10:Decision="Non Admis"
21
else:Decision="Admis"
print(num,"\t\t\t\t\t\t",nom,"\t\t%.2f"%M,"\t\t\t",Decision) except EOFError:
print("fin ")
break
f.close()
Chap X
Les dictionnaires et Tuples
10.1. Dictionnaires
Les dictionnaires se révèlent très pratiques lorsque vous devez manipuler des structures complexes à décrire et que
les listes présentent leurs limites.
Les dictionnaires sont des collections non ordonnées d'objets, c-à-d qu'il n'y a pas de notion d'ordre. On accède aux
valeurs d'un dictionnaire par des clés. Regardez l'exemple suivant :
ani1 = {}
ani1['nom'] = 'girafe'
ani1['taille'] = 5.0
ani1['poids'] = 1100
ani1  {'nom': 'girafe', 'poids': 1100, 'taille': 5.0}
ani1['taille']  5.0
10.1.1. Méthodes keys() et values()

Les méthodes keys() et values() renvoient, comme vous vous en doutez, les clés et les valeurs d'un dictionnaire (sous
forme de liste) :
ani1.keys()  ['nom', 'poids', 'taille']
ani1.values()  ['girafe', 1100, 5.0]
On peut aussi initialiser toutes les clés d'un dictionnaire en une seule opération :
ani2 = {'nom':'singe', 'poids':70, 'taille':1.75}
Applications
On souhaite déterminer le nombre d‟occurrence de chaque lettre présente dans une chaine ch passée, comme
paramètre d‟une fonction intitulée OccurrenceDic(ch) en utilisant la notion d‟un dictionnaire.
La chaine est supposée ne contenant que les lettres alphabétiques.
On affichera:
-Un dictionnaire dont les clés sont les différentes lettres de la chaine et les valeurs sont les occurrences
correspondantes.
-Uniquement les différentes lettres de la chaine
-Uniquement Les occurrences correspondante
22
10.1.2. Liste de dictionnaires

En créant une liste de dictionnaires possédant les mêmes clés, on obtient une structure qui ressemble à une base de
données :
animaux = [ani1, ani2]

Animaux  [{'nom': 'girafe', 'poids': 1100, 'taille': 5.0}, {'nom': 'singe', 'poids': 70, 'taille': 1.75}]
for ani in animaux:

print(ani['nom'],‟ |t „,ani[„taille‟])  girafe 5 .0
singe 1.75
10.1.3. Existence d'une clef
Pour vérifier si une clé existe, vous pouvez utiliser la propriété « has_key() » OU « in »:
if ani2.has_key('poids'):
print( "La clef 'poids' existe pour ani2“)
Ou
if "poids" in ani2:
print( "La clef 'poids' existe pour ani2")
10.2. Tuples
Les tuples correspondent aux listes à la différence qu'ils sont non modifiables. Pratiquement, ils utilisent les
parenthèses au lieu des crochets :
X= (1,2,3)
X  (1, 2, 3)
X[2]  3
X[0:2]  (1, 2)
X[2] = 15  erreure!!
L'affectation et l'indiçage fonctionne comme avec les listes, mais si l'on essaie de modifier un des éléments du tuple,
Python renvoie un message d'erreur. Si vous voulez ajouter un élément (ou le modifier), vous devez créer un autre
tuple :
x = (1,2,3)
x + (2,)  (1, 2, 3, 2)
Remarque : pour utiliser un tuple d'un seul élément, vous devez utiliser une syntaxe avec une virgule (élément,), ceci
pour éviter une ambiguïté avec une simple expression.
Autre particularité des tuples, il est possible d'en créer de nouveaux sans les parenthèses, dès lors que ceci ne pose
pas d'ambiguïté avec une autre expression :
x = (1,2,3)
X  (1, 2, 3)
ou
x = 1,2,3
X  (1, 2, 3)
23
Enfin, on peut utiliser la fonction tuple(sequence) qui fonctionne exactement comme la fonction list, c-à-d qu'elle
prend en argument un objet séquentiel et renvoie le tuple correspondant :
range(10)  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
tuple(range(10))  (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
tuple("ATGCCGCT")  ('A', 'T', 'G', 'C', 'C', 'G', 'C', 'T').

Applications
On suppose avoir une liste de dictionnaire « LD » composé des numéros d‟inscription des noms des élèves d‟une
classe et de leurs notes d‟examens d‟écrit, d‟oral et de TP comme c‟est indiqué ci-dessous :
LD=[{„‟NI‟‟:1, „‟Nom‟‟: ‟‟Driss‟‟,‟‟NE‟‟:15,75, „‟NO‟‟:11, „‟TP‟‟:12},
{„‟NI‟‟:2, „‟Nom‟‟: ‟‟Asmaa‟‟,‟‟NE‟‟:13, „‟NO‟‟:12, „‟TP‟‟:12,5},
……………………………………………………………………………,
{„‟NI‟‟:25, „‟Nom‟‟: ‟‟Rida‟‟,‟‟NE‟‟:10, „‟NO‟‟:8,5, „‟TP‟‟:9,5}]
Question: Etablir une fonction rechercher() qui accepte, comme argument, la liste de dictionnaire et un Numéro
d‟inscription afin de retourner le nom, la moyenne((NE+NO+TP)/3) et la décision du jury(Candidat Admis/Non
Admis) de l‟élève ayant fourni, son numéro, à cette. La fonction retourne 0 si le matricule qu‟on lui a fourni ne figure
pas dans la liste de dictionnaires.
Remarque : les listes, dictionnaires, tuples sont des objets qui peuvent contenir des collections d'autres objets. On
peut donc construire des listes qui contiennent des dictionnaires, des tuples ou d'autres listes, mais aussi des
dictionnaires contenant des tuples, des listes, etc.
Chap XI
Ingénierie Numérique
11.1. Zéro d'une fonction
11.1.1. Méthode dichotomique:
Pour plus de détail sur la méthode dichotomie d’une manière générale voir TD présenté sur ce sujet.
Dans la méthode dichotomique pour la recherche du zéro d’une fonction sur un intervalle [a,b] , on procède
successivement en calculant f(a), f(b) et f((a+b)/2) et en regardant le signe de ces trois expressions.
- Si f(a) * f((a+b)/2) <0 , alors il y a un zéro dans l'intervalle [a , (a+b)/2]
- sinon si f((a+b)/2) * f(b) < 0 alors il y a un zéro dans l'intervalle [(a+b)/2, b]
Le plus souvent on ne pourra pas trouver une valeur exacte seulement une valeur approchée.
Dans l'algorithme par dichotomie on s'arrête au bout de n étapes afin d'obtenir une précision ε telle que (b-a)/2n <= ε
Soit n>= (log(b-a) – log(ε))/ log(2)
import math
def g(x):
return x**(1/2) * math.cos(x)
def dichotomie(a, b, f, eps=1e-10):
global v
24
v=1
if(fabs(a - b) <= eps): return (a+b)/2.0
else:
m = (a+b)/2
if f(a) * f(m) <= 0: return dichotomie(a, m, f, eps)
elif f(m) * f(b) <= 0:return dichotomie(m,b, f, eps)
else:v=0
x=1
y=2
R=dichotomie(x, y, g)
if v==1:
print("Valeur du zéro de la fonction f sur [%s,%s] :%s" %(x, y, R))
else:print("Pas de zéro possible pour cet intervalle")
11.1.2. Méthode de Newton
La méthode de Newton appelée également méthode de Newton-Raphson a pour but de réaliser l'approximation d'une
fonction affine g d'une fonction f différentiable en un point a.
Principe : approximation d'une fonction en se basant sur le développement de Taylor au premier ordre.
- On choisit un point de départ x0 proche de la solution recherchée.
- On fait alors une approximation grossière en la considérant égale à sa tangente f(x) ~ f(x0) + f ’ (x0) * (x-x0).
- On détermine alors le point d'intersection avec l'axe des abscisses en résolvant l'équation :f(x0) + f ’ (x0) * (x-x0)=0
- On obtient alors le point x1. Et on réitère le processus à partir de ce point.
- On construit par récurrence la suite : xn+1= xn - (f(xn)/f’(xn))
Méthode de Newton
import math
def newton(f, df, xi, h , n):
if(n == 0): return xi
else:
return newton(f, df, xi - f(xi)/df(f,xi,h), h, n-1)
def f(x):
return x-math.log(x)-3 # f(x)= x – log(x) – 3
def df (f,x, h):
25
return (f(x+h)-f(x-h)) / (2.0*h)
def verifier() :
x0 = 2
y0=f(x0)
h=0.0001
n=10
print("Abcisse du zéro (méthode Newton :", newton(f, df, x0, h, n))
verifier()  Abcisse du zéro (méthode Newton : 4.505241495792883
11.2. Méthode d’Intégration

Soit une fonction f à valeurs réelles, continue par morceaux sur un intervalle [ a , b ]. On souhaite calculer une valeur
approchée de l’intégrale ∫ ( )
11.2.1. Méthode des rectangles

La méthode des rectangles consiste à approximer la fonction f par une fonction en escalier. On considère un entier n
et un pas de subdivision . Pour tout entier k de [0,n], on pose ak=a+k* . Sur l’intervalle [ak , ak+1], on
approxime f par la fonction constante égale à f( ) (voir figure 9.1)
On prend, comme valeur approchée de l’intégrale de f sur [a,b], l’intégrale de la fonction en escalier ainsi construite,
c'est-à-dire la somme des aires des rectangles(les rectangles ont tous une base de longueur ).
26
Une implémentation de la méthode des rectangles pour calculer ∫ ( ) en subdivisant l’intervalle [a,b] en n
intervalles est proposée ci-après. En voici le code Python.
def rectangles (f,a,b,n) : #Méthode des rectangles
S=0
for i in range (0,n):
xi=a+(b-a)*i/n
xj=a+(b-a)*(i+1)/n
S+=f((xi+xj)/2.0)*(xj-xi)
return S
on peut montrer que :
( ) ( ) ( )
∫ ( ) ∑ ( )
par conséquence, notre fonction rectangles() peut s’écrire de la façon suivante :
def rectangles (f,a,b,n) : #Methode des rectangles

S=0
xi=a+(b-a)/2*n + i * (b-a)/n
S+=f(xi)
return((b-a)/n) * S
11.2.2. Méthode des trapèzes
La méthode des trapèzes consiste à approximer la fonction f par une fonction continue affine par morceaux. Ceux-ci
coïncident avec la fonction f au point de la subdivision (voir figure 9.2). En notant ak = a+k* les points de la
( ) ( ( ) ( ))
subdivision du segment [a,b], l’aire de chaque trapèze est égale à , c'est-à-dire, en faisant la
somme de ces trapèzes on aura :
27
( ) ( )
∫ ( ) ( ∑ ( ))
Voici une implémentation de la méthode des trapèzes en Python:

def trapezes(f,a,b,n):#Methode des trapezes
S=0
xi=a+(b-a)*i/float(n)
xj=a+(b-a)*(i+1)/float(n)
S+=(f(xi)+f(xj))/2.0*(xj-xi)
return S
Chap XII : La bibliothèque NumPy

12.1. Présentation
NumPy est essentiellement dédié aux traitements des tableaux ou des matrices.
- Tous les éléments d'un tableau NumPy sont de même type
- IL n'est pas possible de modifier la taille d'un tableau créé.
- Un tableau NumPy est dynamique, c'est-à-dire que vous pourrez ajouter des éléments à la fin d'un tableau.
Comment utiliser le module NumPy ?
import numpy as np
Comment initialiser un tableau ?
Un tableau de type simple : t1=np.array((1,2,3,4)) ou encore t1=np.array([1,2,3,4])
Une matrice : t2=np.array([ [1,2,3], [4,5,6], [7,8,9] ], float)
28
Un tableau de nombres complexes: t3=np.array([[1+2j],[4+6j]])
12.2. NumPy : fonctionnalités de base
Vecteur:
V1 = np.zeros(5)  [ 0. 0. 0. 0. 0.]
V2 = 2*np.ones(5)  [ 2. 2. 2. 2. 2.]
V3 = np.arange(5,10,2)  [5 7 9] Signifie: des valeurs entre 5 et 10 (non inclus) avec un décalage de 2.
V4 = np.linspace(0,2,5)  [ 0. 0.5 1. 1.5 2. ] signifie : 5 valeurs équiréparties entre 0 et 2.
Matrice:
M1 = np.zeros((2,3))  [[ 0. 0. 0.][ 0. 0. 0.]]
M2 = 3*np.ones((2,3))  [[ 3. 3. 3.][ 3. 3. 3.]]
M3 = np.eye(3)  [[ 1., 0., 0.],[ 0., 1., 0.],[ 0., 0., 1.]]
12.3. la fonction eye()
Syntaxe :
eye(N, M=None, k=0, dtype=<class 'float'>
Matrice 3*5 avec des 1 sur la diagonale:
np.eye(3,5,dtype=int) array([[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0]])
Matrice avec des 1 sur une diagonale supérieure ou inférieure:
- np.eye(3,k=1,dtype=int)  array([[0, 1, 0],
[0, 0, 1],
[0, 0, 0]])
- np.eye(3,k=-1,dtype=int)  array([[0, 0, 0],
[1, 0, 0],
[0, 1, 0]])
12.4. Les calculs
12.4.1. Opérations possibles
Somme de matrices terme à terme: M3 = M1 + M2
Produit, terme à terme, des coefficients de deux matrices: M3= M1 * M2
Produit de matrices : M3 = np.dot(M1,M2)
Les fonctions appliquées sur les coefficients de la matrice par exemple: log, abs, exp … : M3 = np.log(M1)
Les fonctions booléenne <, >, …. : M3 < M1
Copie du tableau ou de la matrice : M3.copy()
Transposition d'une matrice : M3.transpose() ou encore np.transpose(M3)
12.4.2. Manipulation de tableaux:
Somme, produit, puissance, exponentiel, logarithme
tab= np.arange(6)  array([0, 1, 2, 3, 4, 5])

tab + 2  array([2, 3, 4, 5, 6, 7])
tab *5  array([ 0, 5, 10, 15, 20, 25])
np.exp(tab)  array([ 1. , 2.71828183 , 7.3890561 , 20.08553692 , 54.59815003 , 148.4131591 ])
np.log(tab)  array([ -inf, 0. , 0.69314718, 1.09861229, 1.38629436, 1.60943791])
29
tab * tab  array([ 0, 1, 4, 9, 16, 25])
tab ** tab  array([ 1, 1, 4, 27, 256, 3125], dtype=int32)
Min, max, moyenne, somme, produit, tri.
tab= np.arange(6)  array([0, 1, 2, 3, 4, 5])
np.min(tab)  0
np.max(tab)  5
np.mean(tab)  2.5
np.sum(tab)  15
np.prod(tab)  0
np.sort(tab)  array([0, 1, 2, 3, 4, 5])
12.4.3. Manipulation de matrices
somme, produit, tri, min, max , transpose.
m= np.array ([ [2,5], [4,3] ]) np.multiply(m,n)  array([[ 2, 10],
n= np.array([ [1,2], [3,4] ]) [12, 12]])
m + n  array([[3, 7], np.min(m)  2
[7, 7]]) m.sum()  14
m * n  array([[ 2, 10], m.transpose()  array([[2, 4],
[12, 12]]) [5, 3]])
np.dot(m,n)  array([[17, 24],
[13, 20]])
12.5. Numpy.linalg
Résolution des systèmes linéaire AX=B en utilisant « det » et « solve » de linalg
syntaxe: B= np.array([[v1],
import numpy as np [v2],
A= np.array([[a1,a2,…,an], …
[b1,b2,…,bn], [vm]],type)
… Determinant=np.linlag.det(A)
[m1,m2,…,mn]],type) If Determinant != 0:
Solution=np.linalg.solve(A,B)
chap XIII
Les Classes
13.1. Présentation
Les classes consiste en effet à regrouper dans un même ensemble (l'objet) à la fois un certain nombre de données (ce
sont les attributs d'instance) et les algorithmes destinés à effectuer divers traitements sur ces données (ce sont les
méthodes, c'est-à-dire des fonctions encapsulées).
Objet = [ attributs + méthodes ]
Le premier paramètre utilisé par une méthode doit toujours être une référence d'instance. Vous pourriez en principe
utiliser un nom de variable quelconque pour ce paramètre, mais il est vivement conseillé de respecter la convention
qui consiste à toujours lui donner le nom self. Le paramètre self désigne donc l'instance à laquelle la méthode sera
30
associée, dans les instructions faisant partie de la définition. (De ce fait, la définition d'une méthode comporte
toujours au moins un paramètre, alors que la définition d'une fonction peut n'en comporter aucun).
13.2. La méthode « constructeur »
Une méthode « constructeur » est une méthode qui est exécutée automatiquement lorsque l'on instancie un nouvel
objet à partir de la classe. On peut y placer tout ce qui semble nécessaire pour initialiser automatiquement l'objet que
l'on crée. Sous Python, la méthode constructeur doit obligatoirement s'appeler __init__ (deux caractères « souligné »
le mot init, puis encore deux caractères « souligné »).
Voyons comment cela se passe en pratique :
Syntaxe generale :
Declaration:
class NomClasse:
def __init__(self,Attr1,Attr2,…,Attrn):
self.Attr1 =Attr1
self.Attr2 =Attr2
…
self.Attrn =Attrn
def Methode1(self,Parametre1,…, Parametrem):
Traitement en fct des parametre
return/Affichage resultat
def ….
def Methoden(self,Parametre1,…, Parametrem):
Traitement en fct des parametre
return/Affichage resultat
Instancier une classe :
NomVariableClasse = NomClasse(liste des attributs)
Exploitation des fonctions de la classe :
NomVariable = NomVariableClasse.NomMethodei(liste valeur des parametres)
Exemples :voir TP
31

Cours Info 1er Annee MR Bouhou

Transféré par

Informations du document

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

Cours Info 1er Annee MR Bouhou

Transféré par

Droits d'auteur :

Formats disponibles

CPGE Informatique MPSI / 1TSI /PCSI

Lydex – Ben guerir Programmation Mr L. BOUHOU

I.2. Notion de Variable

Remarque 2 : On peut interrompre une boucle ‘’for’’ .

4.1. Définition et Déclaration

4.3. Les différents types de fonctions

4.3.1. Fonction sans valeur de retour et sans paramètres

4.3.2. Fonction sans valeur de retour et avec paramètres

4.3.3. Fonction avec valeur de retour et sans paramètres

Appel : NomVariable = NomFonction() ou print(‘’Résultat est : ‘’, NomFonction())

4.3.4. Fonction avec valeur de retour et avec paramètres

5.2. Le type de donnée string(correspondant aux chaines de caractère)

5.3. Opérations élémentaires sur les chaînes

5.3.3. Convertir en nombre une chaine de caractères

Par contre, le script ci-dessous fonctionne parfaitement :

-lower() : convertit une chaîne en minuscules syntaxe : ch.lower()

6.2. Les fonctions concernant les listes

6.2.4.insert(): permet d'insérer un élément x à un index i donnée.

6.2.8. count(x): renvoie le nombre d'occurrences de la valeur de .

6.2.9. reverse(): permet d'inverser une liste.

10.1.1. Méthodes keys() et values()

10.1.2. Liste de dictionnaires

animaux = [ani1, ani2]

for ani in animaux:

tuple("ATGCCGCT")  ('A', 'T', 'G', 'C', 'C', 'G', 'C', 'T').

11.2. Méthode d’Intégration

11.2.1. Méthode des rectangles

def rectangles (f,a,b,n) : #Methode des rectangles

Voici une implémentation de la méthode des trapèzes en Python:

Chap XII : La bibliothèque NumPy

tab= np.arange(6)  array([0, 1, 2, 3, 4, 5])

Vous aimerez peut-être aussi