Cours Python 2PI

Professeur: Dr.
Said NOUH
2023-2024
1
Chapitre 1:Généralités, Rappels
Et Instructions de base de Python
2
Question clé du module informatique:
On dispose du matériel informatique (microprocesseur,
mémoire vive, périphériques d’entrée, périphériques de
sortie, et périphériques de stockage). Comment exploiter
ce matériel et le programmer pour résoudre des
problèmes ?
Deux situations:
1) utilisation des programmes faits par d’autres
personnes.
2) Création de nouveaux programmes
3
ALGORITHME
 Algorithme du surnom latin Algorismi du mathématicien Arabe
Al Khwarizmi.
 Définition: Un algorithme est une suite d’actions précises
qui doivent être exécutées dans un ordre déterminé en vue
de la résolution d’un problème.
 Objectifs:
Un algorithme sert à transmettre un savoir faire.
Il décrit les étapes à suivre pour réaliser un travail.
Il permet d'expliciter clairement les idées de solution d’un
problème indépendamment d'un langage de programmation.
L'utilisateur d'un algorithme n'aura qu'à suivre les instructions,
dans l'ordre pour arriver au résultat que doit donner l'algorithme.
«Ce que l’on conçoit bien s’énonce clairement et les
mots pour le dire arrivent aisément» [N. Boileau]
4 4
QU'EST-CE QU'UN BON ALGORITHME / PROGRAMME?
On peut noter qu'un bon algorithme est un schéma résolution

possédant les caractéristiques suivantes :
• Correct: s'il répond au problème posé.
• Précis: s'il fournit exactement les résultats attendus
• Rapide : s'il utilise un temps d'exécution minimal
indépendamment de la vitesse de la machine.
• Efficace: s'il utilise le moins d'espace mémoire possible
• Clair et lisible : s'il ne présente pas de difficulté de
compréhension pour un autre programmeur
désirant le maintenir ou le développer,
• Résistant : s'il est capable de détecter les cas de mauvaises
utilisations.
5
•Exemple
L'algorithme suivant décrit l'usage d'un appareil téléphonique à pièces de monnaie
pour effectuer une communication:
Début
Décrocher l'appareil;
Insérer les pièces nécessaires;
Composer le numéro désiré;
L’interlocuteur décroche l’appareil
Parler;
Raccrocher;
Fin
Remarque :
On a une représentation de la solution du problème sous la forme d’un algorithme. Mais
certains cas n’ont pas été prévus (numéro occupé par exemple), d’où insuffisance de la
solution proposée. Il est nécessaire de détailler au maximum les ordres élémentaires
connus par la machine et prévoir tous les cas possibles. La machine ne peut pas intervenir
dans les cas non prévus (elle ne peut pas réfléchir, elle exécute vos ordre uniquement).
6
Les variables et les constantes
• Une variable est une entité qui 14.25

contient une information, elle Valeur
possède :
– un nom (on parle d’identifiant) Noteinfo
– une valeur Identificateur Données
– un type qui caractérise Réel

l’ensemble des valeurs que peut Type
prendre la variable ainsi que les
opérations permises. Un nom (identificateur d’une variable)
doit commencer par une lettre
• Les variables sont stockées dans la alphabétique etdoit être constitué
mémoire de l’ordinateur et sont uniquement de lettres, de chiffres et du
modifiables contrairement aux soulignement _ (Eviter les caractères de
ponctuation et les espaces)
constantes (Pi=3.14 par exemple) Et doit être différent des mots réservés
du langage.
7
Les variables et les constantes
• Type de variable
– entier (python: int) pour manipuler des entiers
– réel (python: float) pour manipuler des nombres
réels
– booléen (python: bool) pour manipuler des valeurs
booléennes
– Caractère (python: str) pour manipuler des caractères
alphabétiques ou numériques. On peut manipuler des
chaînes de caractères permettant de représenter des
mots ou des phrases.
8
• Les opérateurs: +, -, *, / Avec en plus pour les entiers div et mod,
qui permettent respectivement de calculer une division entière et le
reste de cette division.
par exemple :11 div 2 vaut 5, 11 mod 2 vaut 1
En Python: 11//2 vaut 5 et 11%3 vaut 2
• L’opérateur d’égalité :
pour les types simples il permet de savoir si les deux opérandes
sont égales ou non.
Il est représenté par le caractère = (en algo) et par (= =) en python
Le résultat d'une expression contenant cet opérateur est un booléen
• On a aussi l’opérateur d’inégalité : ≠ (en python !=)
• Et pour les types possédant un ordre les opérateurs de comparaison
<, ≤, >, ≥
9
Priorités des opérateurs arithmétiques
• Tout comme en arithmétique les opérateurs ont des
priorités Par exemple * et / sont prioritaires sur + et -
Pour les booléens, la priorité des opérateurs est : non,
et, ouExclusif et ou
• Pour supprimer toutes ambiguïtés on peut utiliser des
parenthèses
10
Les opérateurs logiques
Les operateurs logiques sont : ET ( and en python), OU (or en
python) et NON (not en python).
-Pour que la condition logique : condition1 ET condition2

soit VRAI, il faut impérativement que la condition1 soit
VRAI et que la condition2 soit VRAI.
- Pour que la condition logique : condition1 OU condition2

soit VRAI, il suffit que condition1 soit VRAI ou condition2
soit VRAI. Il est a noter que cette condition logique sera
VRAI si condition1 et condition2 sont VRAI.
- Le NON inverse une condition : NON(condition)

Est VRAI si condition est FAUX, et il sera FAUX si
condition est VRAI. 11
12
Manipulation des variables
• On peut faire deux choses avec une variable :
1. Obtenir son contenu: cela s’effectue simplement en
appelant la variable par son nom
2. Affecter un (nouveau) contenu: cela s’effectue en
utilisant l’opérateur d’affectation représenté par le
symbole ←
La syntaxe de cet opérateur est :
identifiant_de_la_variable ← expression
En python: identifiant_de_la_variable = expression
13
Manipulation de variables
• Par exemple l’expression c ← a + b :
On prend la valeur contenue dans la variable a et
celle contenue dans la variable b. On additionne ces
deux valeurs et on met ce résultat dans la variable c
• Si c avait auparavant une valeur, cette dernière est
perdue !
• Un algorithme peut avoir des interactions avec
l’utilisateur. il peut afficher un résultat (du texte ou le
contenu d’une variable) ou demander à l’utilisateur de
saisir une information afin de la stocker dans une
variable
• En tant qu’informaticien on raisonne en se mettant
“à la place de la machine” 14
Les entrées / sorties
• Instruction d'écriture:
L'instruction de restitution de résultats sur le
périphérique de sortie (en général l'écran) est :
écrire(liste d'expressions)
En Python: print(" X= ",X, " Y= ", Y, ……)
Cette instruction réalise simplement l'affichage des
valeurs des expressions décrites dans la liste.
Ces instructions peuvent être simplement des
variables ayant des valeurs ou même des nombres ou
des commentaires écrits sous forme de chaînes de
caractères.
– Exemple d'utilisation : écrire(x, y+2, "bonjour")
15
Les entrées / sorties
• Instructions de lecture:
L'instruction de prise de données sur le périphérique
d'entrée (en général le clavier) est :
variable ← lire() ou lire(variable)
En Python:
variable = (int, float, …) (input(« votre message"))
L'exécution de cette instruction consiste à affecter
une valeur à la variable en prenant cette valeur sur le
périphérique d'entrée.
Avant l'exécution de cette instruction, la variable
avait ou n'avait pas de valeur. Après, elle a la valeur
prise sur le périphérique d'entrée.
16
Structure séquentielle
a- Définition
On dit qu'un algorithme a une structure séquentielle lorsque les instructions
s'exécutent d'une manière linéaire une après une du début jusqu'à la fin.
b- exemple
Soit l'algorithme suivant:
Algorithme moyenne;
Variables NT1, NT2, NT3, MOY : Réel;
Début
LIRE (NT1);
LIRE (NT2);
LIRE (NT3);
MOY← (NT1+ NT2+ NT3)/3;
ECRIRE (MOY);
Fin
Cet algorithme a une structure séquentielle, les instructions s'exécutent

d'une manière linéaire (l'une après l'autre).
17
Exercice 1 : Exercice 2: Écrire un algorithme qui permet
Quels sont les messages affichés à de saisir le prix "Hors taxe" d'une
l’cran après l’exécution des marchandise et d’afficher ensuite le prix
instructions suivantes ? "TTC" sachant que cet article a une T.V.A
1. A<---2 (constante) de 20%. Traduire en Python
2. A<---A+2
3. B<---A*2+A Exercice 3: Écrire un algorithme saisissant
4. C<---4 deux variables entières et qui calcule et
5. C<---B-C affiche leur moyenne. Traduire en Python
6. C<--- C+A-B
7. A<--- B-C*A Exercice 4: Écrire un algorithme saisissant
8. A<--- (B-A)*C un temps en secondes que l’on transcrira en
9. B<--- (A+C)*B jours, heures, minutes et secondes. Traduire
en Python.
10. Ecrire(‘la valeur de A est :’ , A)
11. Ecrire(‘la valeur de B est :’ , B)
Exercice 5: Écrire un algorithme saisissant
12. Ecrire(‘la valeur de C est :’ , C)
la valeur d’une variable X, puis il calcule la
valeur de X16 (rapidement). Traduire en
Traduire cet algorithme au langage
Python.
Python
18
Structure conditionnelle ou alternative
• L’instruction si alors sinon permet de conditionner l’exécution
d’un algorithme à la valeur d’une expression booléenne.
Syntaxe :
si expression booléenne alors
suite d’instructions exécutées si l’expression est vrai
sinon
suite d’instructions exécutées si l’expression est
fausse
finsi
Remarque: cette structure est appelée structure alternative ou
sélective simple. S’il n’y a pas le sinon, elle est appelée
structure sélective réduite.
19
Exemple en algorithmique:
Algorithme equationDeuxiemeDegre
Variable a,b,c,delta,x1,x2: réels
Début
Ecrire(« donner a, b et c: »)
Lire(a,b,c)
deltab*b-4*a*c
Si(delta<0) alors ecrire(« pas de solutions »)
sinon si (delta=0) alors ecrire(« une solution:»,-b/(2*a))
sinon x1 (-b-racine(delta))/(2*a)
x2 (-b+racine(delta))/(2*a)
Ecrire(« 2 solutions: »,x1,x2)
Finsi
Finsi
Fin 20
Exemple en python:
from math import *
print("donner a, b et c: ")
a=float(input("")); b=float(input("")); c=float(input(""));
delta=b*b-4*a*c
if(delta<0) :
print("pas de solutions ")
elif(delta==0) :
print("une solution:",-b/(2*a))
else:
x1 =(-b-sqrt(delta))/(2*a)
x2 =(-b+sqrt (delta))/(2*a)
print("2 solutions:" ,x1,x2)
21
Définition
Dans un algorithme ayant une structure alternative les instructions s'exécutent selon la réalisation
d'une condition ou non.
•La condition est une expression logique de type X Relation Y
Avec Relation est l'un des opérateurs de comparaison Suivants:
Opérateur signification Langage Python

= Egal ==
<> ou  Différent !=
< Strictement inférieur <
> Strictement supérieur >
<= Inférieur ou égal <=
>= Supérieur ou égal >=
La condition peut être:

Condition simple: Exemples: a<2000; Moy<10;
Condition Composée: Exemple: (Moy>13) ET (Moy <= 16)
22
Instruction conditionnelle En Python:
if (conditions 1): ATTENTION à l’indentation en Python !!!!
……………….
elif (conditions 2):
……………….
elif (conditions 3):
…………….
else :
……………….
Les blocs d'instructions sont toujours associés à une ligne

d'en-tête contenant une instruction bien spécifique (if, elif,
else, while,for, def, ...) se terminant par un double point.
23
24
Instruction conditionnelle
Exemple: Organigramme:
Algorithme ValeurAbs
Variables: valeur, valeurabsolue : réels.
début
Ecrire (‘donner un nombre’);
Lire (valeur);
si valeur ≥ 0 alors
valeurabsolue ← valeur
sinon
valeurabsolue ← valeur * -1
finsi
Ecrire(valeurabsolue )
fin
25
Instruction conditionnelle
Exercice 6:
Ecrire l’exemple précédent en langage Python:
Réponse:
print("entrer un nombre");
valeur=float(input()); # (float pour l'ensemble IR et int pour
# l'ensemble Z)
if valeur>=0:
valabsolue=valeur
else:
valabsolue=-1.0*valeur
print("la valeur absolue est: ", valabsolue)
26
La boucle déterministe
• Il est fréquent que le nombre de répétitions soit connu à
l'avance, et que l'on ait besoin d'utiliser le numéro de l'itération
afin d'effectuer des calculs ou des tests. Le mécanisme
permettant cela est la boucle Pour.
• Forme de la boucle Pour :
Pour variable de valeur initiale à valeur finale faire
liste d'instructions
fin pour
-------------------------------------------------------------------------
En Python:
for <cible> in <objet>:
<instructions>
else :
<instructions>
27
• La boucle for fonctionne sur les chaînes, les listes, les tuples et
d’autres objets.
• La partie else: … est optionnelle.
• L’instruction range (a,b,pas) permet de créer une liste L
croissante ou décroissante d’entiers successifs . aL, a+pas L,
a+2*pas L, a+3*pas L, ….. Et x L: x<b
• Exemple:
for i in range(10,20,3):
print (i);
else:
print("Sortie de la boucle avec i=",i);
input();
Donne à l’exécution: 10
13
16
19
Sortie de la boucle avec i= 19
28
Représentation graphique (organigramme) de la boucle pour :
Pour i= i_initiale à i_finale faire

instructions
Fin pour
i ←a
Vrai
i <b instructions i ← i + pas
faux
29
boucle indéterministe
• L'utilisation d'une "boucle pour" nécessite de connaître
à l'avance le nombre d'itérations désiré, c'est-à-dire la
valeur finale du compteur. Dans beaucoup de cas, on
souhaite répéter une instruction tant qu'une certaine
condition est remplie, alors qu'il est à priori impossible
de savoir à l'avance au bout de combien d'itérations
cette condition cessera d'être satisfaite. Dans ce cas, on
a deux possibilités :
la boucle Tant que et la boucle Répéter jusqu'à
• Syntaxe de la boucle Tant que :
tant que condition faire
liste d'instructions
ftant
30
Les répétitions conditionnelles
• Etant donné que la condition est évaluée avant
l'exécution des instructions à répéter, il est possible
que celles-ci ne soient jamais exécutées.
• Il faut que la liste des instructions ait une incidence
sur la condition afin qu'elle puisse être évaluée à
faux et que la boucle se termine.
• Il faut toujours s'assurer que la condition devient
fausse au bout d'un temps fini.
• Exemple : Un utilisateur peut construire des
rectangles de taille quelconque, à condition que les
largeurs qu'il saisit soient supérieures à 1 pixel.
31
En Python:
La boucle while exécute un bloc tant que la condition de continuité est
vérifiée. La particularité de ce while est qu’il peut y avoir un else optionnel
dont le bloc sera exécuté lorsqu’on sort de la boucle.
while <test> :
<instructions>
Exemple: programme qui compte le nombre de chiffres d’un nombre

a=(int)(input("Entrer un entier:"));
if a==0:
print("le nombre de chiffres est:",1);
else:
nbchif=0;
while a>0:
a=a//10;
nbchif=nbchif+1;
print("le nombre de chiffres est:",nbchif);
32
Chapitre 2
Programmation modulaire: les fonctions
33
Définir une fonction
Il arrivera souvent qu'une même séquence d'instructions doive être utilisée à plusieurs
reprises dans un programme, et on souhaitera bien évidemment ne pas avoir à la
reproduire systématiquement.
Nous avons vu diverses fonctions pré-programmées (pow, exp, …). Voyons à

présent comment on peut définir nous-mêmes de nouvelles. La syntaxe Python
pour la définition d'une fonction est la suivante:
def nomDeLaFonction(liste de paramètres):

...
bloc d'instructions
...
[resultat=…..] # […] c’est optionnel
[return resultat]
34
Fonction simple sans paramètres
>>> def table7():

... n=1
... while n <11 :
... Print( n * 7)
... n = n+1
Pour utiliser la fonction que nous venons de définir, il suffit de l'appeler par son
nom. Ainsi :
>>> table7()
Provoque l'affichage de :
7 14 21 28 35 42 49 56 63 70
35
Pourquoi définir une fonction ?
1. Créer une nouvelle fonction vous offre l'opportunité de donner un nom à tout un
ensemble d'instructions. De cette manière, vous pouvez simplifier le corps
principal d'un programme, en dissimulant un algorithme secondaire complexe
sous une commande unique, à laquelle vous pouvez donner un nom très
explicite, en français si vous voulez.
2. Créer une nouvelle fonction peut servir à raccourcir un programme, par

élimination des portions de code qui se répètent. Par exemple, si vous devez
afficher la table par 7 plusieurs fois dans un même programme, vous n'avez pas
à réécrire chaque fois l'algorithme qui accomplit ce travail.
3. Une fonction est donc en quelque sorte une nouvelle instruction personnalisée,
que vous ajoutez vous-même librement à votre langage de programmation.
36
Fonction avec paramètres
La fonction table() telle que définie ci-dessous utilise le paramètre base pour
calculer les dix premiers termes de la table de multiplication de base.
>>> def table(base):

n=1
while n <11 :
print (n * base)
n = n +1
Pour tester cette nouvelle fonction, il nous suffit de l'appeler avec un

argument.
>>> table(13)
13 26 39 52 65 78 91 104 117 130
>>> table(9)
9 18 27 36 45 54 63 72 81 90
37
Fonction avec plusieurs paramètres
La fonction table() est certainement intéressante, mais elle n'affiche toujours que les dix
premiers termes de la table de multiplication, alors que nous pourrions souhaiter qu'elle en
affiche d'autres. Nous allons l'améliorer en lui ajoutant des paramètres supplémentaires,
dans une nouvelle version que nous appellerons cette fois tableMulti() :
>>> def tableMulti(base, debut, fin):

print (Fragment de la table de multiplication par', base, ':‘)
n = debut
while n <= fin :
print (n, 'x', base, '=', n * base)
n = n +1
Cette nouvelle fonction utilise donc trois paramètres : la base de la table comme dans l'exemple
précédent, l'indice du premier terme à afficher, l'indice du dernier terme à afficher.
Essayons cette fonction en entrant par exemple :
>>> tableMulti(8, 13, 17)
Fragment de la table de multiplication par 8 :
13 x 8 = 104
14 x 8 = 112
15 x 8 = 120
16 x 8 = 128
17 x 8 = 136
38
Utilisation des fonctions dans une autre fonction
Les fonctions peuvent aussi s'utiliser dans des scripts. Veuillez essayer vous-
même le petit programme ci-dessous, lequel calcule le volume d'une sphère à
l'aide de la formule : V= 4/3* pi*r^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 sphère vaut', volumeSphere(r))
Ce programme comporte trois parties : les deux fonctions cube() et

volumeSphere(), et ensuite le corps principal du programme.
Dans le corps principal du programme, il y a un appel de la fonction
volumeSphere().
A l'intérieur de la fonction volumeSphere(), il y a un appel de la fonction cube().
39
Fonction anonyme (lambda function)
Le mot-clé lambda en Python permet la création de fonctions anonymes
(i.e. sans nom et donc non définie par def)
Exemple:
>>> f = lambda x : x * x
>>> f ( 3 )
9
On peut également préciser plusieurs arguments:
>>> g = lambda x , y : x * y
>>> g(5, 7)
35
On peut également préciser des valeurs par défaut :
>>> g = lambda x , y=2 : x * y
>>> g ( 6 )
12
40
Fonctions comme valeurs de première classe
En Python, une fonction est une valeur comme une autre, c’est-à-dire qu’elle peut
être passée en argument, renvoyée comme résultat ou encore stockée dans une
variable. On dit que les fonctions sont des valeurs de première classe.
Une application directe est la définition d’un opérateur mathématique par une
fonction.

n
i 1
f (i )
Par exemple, la somme : , pour une fonction f quelconque, peut être
ainsi définie :
def somme_fonction( f , n ):
s = 0
for i in range(n+1):
s = s + f ( i )
return s
41
Exemple d’application:
Pour calculer la somme des carrés des entiers de 1 à 10, on

commence par définir une fonction carre.
def carre ( x ) :
return x*x
Puis, on la passe en argument à la fonction somme_fonction :
>>> somme_fonction ( carre , 10 )

385
42
Avantages des fonctions
Voici quelques avantages d'un programme modulaire:
• Meilleure lisibilité
• Diminution du risque d'erreurs
• Possibilité de tests sélectifs
• Réutilisation de modules déjà existants
• Simplicité de l'entretien
• Favorisation du travail en équipe
• Hiérarchisation des modules
Procédure et fonction
Les "fonctions": assez proches de la notion mathématique correspondante.
Notamment, une fonction dispose d'arguments (en python, une fonction peut ne
pas comporter des arguments) qui correspondent à des informations qui lui sont
transmises et elle fournit un résultat qui peut être d’un type reconnu en python
(nombre, liste, tuple, …..
L’appel d’une fonction peut apparaître dans une expression.
 Les "procédures":. La procédure ne possède pas de valeur de retour et son appel

ne peut pas apparaître au sein d'une expression. Par contre, elle peut disposer
d'arguments. 4343
Variable locale et variable globale
1. Variable locale
Les variables déclarées dans une fonction sont uniquement visibles à
l'intérieur de cette fonction. On dit que ce sont des variables locales.
2. Variable globale
Les variables déclarées à l'extérieur de toutes les fonctions sont disponibles
à toutes les fonctions du programme par l’utilisation du mot clé global. Ce
sont alors des variables globales.
Conseils :
 Les variables globales sont à utiliser avec précaution.
 Il faut faire attention à ne pas cacher involontairement des variables
globales par des variables locales portant le même nom.
 Il est conseillé d'écrire des programmes aussi localement que possible.
44 44
Chapitre 3
Les chaines de caractères
45
Le type des chaînes de caractères, string en anglais et dans Python, est celui
permettant de représenter des textes. On considère dans un premier temps des
textes élémentaires, ceux composés d’une unique lettre ; on les appelle les
caractères.
En Python, les caractères peuvent être n’importe quelle lettre de l’alphabet, mais
aussi des symboles, comme les signes de ponctuation. Une chaîne de
caractères est une suite finie de caractères consécutifs, qu’on note entre
apostrophes ou guillemets :
'Ceci est une chaine'
La chaîne vide se note '' ou " "
Accès à un caractère:
On peut stocker une chaîne dans une variable :
s = 'Bonjour'
et accéder à chacun des caractères à l’aide de la construction s[i] :
>>>s[2]
'n’
Comparaison:
>>> ‘bonjour’ == ‘bonne journée’
False
46
les chaînes sont immuables

>>> s[0] = 'A'
TypeError: 'string' object does not support item assignment
Concaténation: On concatène deux chaînes à l’aide de l’opérateur + :

>>>'Bonjour '+ 'lecteur !'
'Bonjour lecteur !'
Longueur: On utilise len pour obtenir la longueur d’une chaîne :

>>>len('Bonjour')
7
Sous-chaînes
Un ensemble de caractères consécutifs à l’intérieur d’une chaîne s’appelle une
sous-chaîne. Ainsi, 'lecteur' ou 'jour lec' sont des sous-chaînes de 'Bonjour
lecteur !'.
Pour extraire une sous-chaîne de s, on écrit s[i:j] où i est l’indice du premier
caractère de la sous-chaîne et j est l’indice du dernier caractère plus un.
Exemples :
>>>s = 'Bonjour lecteur !'
>>>s[0:7] # de s[0] à s[6]
'Bonjour'
47
>>> ‘j' in 'Bonjour lecteur !‘
True
Il est à noter qu’il est également possible de tester la présence d’une sous-
chaîne dans une chaîne avec la même construction :
>>>'lecteur' in 'Bonjour lecteur !'
True
>>>'Bjr' in 'Bonjour lecteur !'
False
Conversion vers des types simples:
On peut convertir une valeur d’un type simple vers une chaîne de caractères à
l’aide de la construction str(e). La chaîne obtenue est la même que celle que
Python aﬃche par évaluation de e :
>>>str(1.2)
'1.2'
Il est possible de reconvertir une telle chaîne vers une valeur d’un type simple :
>>>int('123')
123
>>>float('1.2') Code ASCII en Python:
1.2
ord(‘A’)=65 et chr(65)=‘A’
>>>bool('True')
True
ord(‘0’)=48et chr(48)=‘0’
>>> p=‘abcde’; q=p*3
q=‘abcdeabcdeabcde’ 48
>>> x="Bonjour mes chers étudiants"
>>> y=x.split()
y= ['Bonjour', 'mes', 'chers', 'étudiants']
>>> x="Idrissi, Bouhajeb, Belkouch, Soulane, Sadir"

>>> y= x.split(",")
['Idrissi', ' Bouhajeb', ' Belkouch', ' Soulane', ' Sadir']
>>> n=x.count('S')
n=2
>>> x.endswith("dir")
True
>>> x.startswith("Idris")
True
>>>y =x.lower()
y= ‘idrissi, bouhajeb, belkouch, soulane, sadir‘
>>> y=x.upper()
'IDRISSI, BOUHAJEB, BELKOUCH, SOULANE, SADIR‘
>>>x.find('Bel')
19
>>> x.index('Bel')
19 49
>>> x="Bonjour mes chers étudiant alyassamine SUP 2018"
>>> x.islower()
>>> chaine = 'Aujourd'hui'
False >>> chaine = 'Aujourd\'hui'
>>> x.isupper() >>> print chaine
False >>> chaine = "Aujourd'hui"
>>> x.isdigit() >>> print chaine
False >>> chaine = 'Première ligne\nDeuxième ligne'
>>> x.isalpha() >>> print chaine
False >>> chaine = """Première ligne
>>> x.isalnum() Deuxième ligne"""
>>> print chaine
False
>>> X="Pa"
>>> y=x.replace(' ','') >>> Y=X*2
"PaPa"
>>> y
'BonjourmeschersétudiantalyassamineSUP2018'
>>> y.isalnum()
True
>>> '6'.isdigit() >>> X="Bon"
True >>> Y=X*2
"BonBon"
>>> x[43:].isnumeric()
True 50
>>> " ".isspace()
True
>>> "Soulane Slimane".isspace()
False
>>> " ".isspace()
True
>>> "\t".isspace()
True
>>> "Titre".istitle()
True
>>> "TitrE".istitle()
False
>>> "Titre de mon site".istitle()
False
>>> "Titre De Mon Site".istitle()
True
>>> "***".join(["Idrissi", "alaoui" , "Said"])
'Idrissi***alaoui***Said‘
>>> "Soulane".replace("ou", "a")
'Salane'
>>> ("Soulane".replace("ou", "a")).replace("la","loua")
'Salouane'
51
>>>"olivier\nengel\ndéveloppeur".splitlines()
['olivier', 'engel', 'développeur']
>>> x="bonjour sup mpsi. soyez les bienvenue"
>>> x.capitalize()
'Bonjour sup mpsi. soyez les bienvenue'
>>> e="\n"
>>> e.isprintable()
False
>>> x='bon'
>>> x.isprintable()
True
>>> x='bon'
>>> x.isprintable()
True
>>> y="c'estunevariable100%"
>>> y.isidentifier()
False
>>> x="Bonjour Chers Etudiants"
>>> x.swapcase()
'bONJOUR cHERS eTUDIANTS‘
>>> x="ceCi n'eSt pas BOn"
>>> x.title()
"Ceci N'Est Pas Bon" 52
x=" bonjour à tous "
a=x.center(40,'*')
print(a); print(len(a))
********* bonjour à tous *********
40
a=x.ljust(40,'*'); print(a)
print(len(a))
 bonjour à tous ******************
40
a=x.lstrip() #efface les espaces de début
print(a)

bonjour à tous
x="bonne***année universitaire à tous"

a=x.partition('***');print(a)
 ('bonne', '***', 'année universitaire à tous') 53
x="bonne année universitaire à tous"
a=x.rjust(40,'*')
print(a)
 ********bonne année universitaire à tous
>>> x='bon courage. bonne journée'

>>> x.find('bon')
0
>>> x.rfind('bon')
13
54
Définition d'une liste
Les listes
C’est une collection ordonnée et modifiable d’éléments éventuellement hétérogènes.
>>> nombres = [5, 38, 10, 25]
>>> mots = ["fromage", "confiture", "chocolat"]
>>> L= [5000, "Big Data", 3.1416, ["Bon", "Jour", 1947]]
Dans le dernier exemple ci-dessus, nous avons rassemblé un entier, une chaîne,
un réel et même une liste, pour vous rappeler que l'on peut combiner dans une liste
des données de n'importe quel type, y compris des listes.
Accès aux éléments d’une liste

Pour accéder aux éléments d'une liste, on utilise les mêmes méthodes (index,
découpage en tranches) que pour accéder aux caractères d'une chaîne :
>>> print(nombres[2])
10
>>> print(nombres[1:3]) >>> print(nombres[-1])
[38, 10] 25
>>> print(nombres[2:3]) >>> print(nombres[-2])
[10] 10
>>> print(nombres[2:])
[10, 25]
>>> print(nombres[:2])
[5, 38]
55
Les listes sont modifiables
Les listes sont des séquences modifiables.
Exemples :
>>> nombres[0] = 17
>>> print(nombres)
[17, 38, 10, 25]
Les listes sont des objets

Sous Python, les listes sont des objets pour les quels on peut appliquer des méthodes
(fonctions) particulièrement efficaces. En voici quelques-unes :
>>> nombres = [17, 38, 10, 25, 72]
>>> nombres.sort() # trier la liste
>>> nombres
[10, 17, 25, 38, 72]
>>> nombres.append(12) # ajouter un élément à la fin
>>> nombres
[10, 17, 25, 38, 72, 12]
>>> nombres.reverse() # inverser l'ordre des éléments
>>> nombres
[12, 72, 38, 25, 17, 10]
56
>>> nombres.index(17) # retrouver l'index d'un élément
4
>>> nombres.remove(38) # enlever (effacer) un élément
>>> nombres
[12, 72, 25, 17, 10]
En plus de ces méthodes, vous disposez encore de l'instruction intégrée del, qui vous
permet d'effacer un ou plusieurs éléments à partir de leur(s) index :
>>> del(nombres[2])
>>> nombre
s[12, 72, 17, 10]
>>> del(nombres[1:3])
>>> nombres
[12, 10]
Insertion d'un ou plusieurs éléments n'importe où dans une liste

>>> mots = ['jambon', 'fromage', 'confiture', 'chocolat']
>>> mots[2:2] =["miel"] # équivalent à mots=mots[:2] + ["miel"] + mots[2:]
>>> mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat']
>>> mots[5:5] =['saucisson', 'ketchup']
>>> mots
['jambon', 'fromage', 'miel', 'confiture', 'chocolat', 'saucisson', 'ketchup']
57
Suppression/remplacement d'éléments
>>> mots[2:5] = [] # [] désigne une liste vide
>>> mots
['jambon','fromage','saucisson', 'ketchup‘]
>>> mots[1:3] = ['salade']
>>> mots['jambon', 'salade', 'ketchup']
>>> mots[1:] = ['mayonnaise', 'poulet', 'tomate']
>>> mots['jambon', 'mayonnaise', 'poulet', 'tomate']
Création d'une liste de nombres à l'aide de la fonction range()

>>> L=list(range(10))
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(5,13))
[5, 6, 7, 8, 9, 10, 11, 12]
>>> list(range(3,16,3))
[3, 6, 9, 12, 15]
Les arguments négatifs sont autorisés :

>>> list(range(10, -10, -3))
[10, 7, 4, 1, -2, -5, -8]
58
Parcours d'une liste à l'aide de for, range() et len()
L'instruction for est l'instruction idéale pour parcourir une liste :
>>> prov = ['La','raison','du','plus','fort','est','toujours','la','meilleure']
>>> for mot in prov:
... print(mot, end =' ')
La raison du plus fort est toujours la meilleure
Si vous voulez parcourir une gamme d'entiers, la fonction range() s'impose :

>>> for n in range(10, 18, 3):
... print(n, n**2, n**3)...
10 100 1000
13 169 2197
16 256 4096
Une liste en mode compréhension :

>>>S=[i**2 for i in range(4)]
>>> S
[0, 1, 4, 9]
>>> L1=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L2=[x for x in L1 if x%3==0]
>>> L2
[0, 3, 6, 9]
59
Opérations sur les listes
On peut appliquer aux listes les opérateurs + (concaténation) et * (multiplication) :
>>> fruits = ['orange','citron']
>>> legumes = ['poireau','oignon','tomate']
>>> fruits + legumes
['orange', 'citron', 'poireau', 'oignon', 'tomate']
>>> fruits * 3
['orange', 'citron', 'orange', 'citron', 'orange', 'citron']
L'opérateur * est particulièrement utile pour créer une liste de n éléments identiques :
>>> T = [0]*7
>>> T
[0, 0, 0, 0, 0, 0, 0]
Supposons par exemple que vous voulez créer une liste B qui contient le même
nombre d'éléments qu'une autre liste A. Vous pouvez obtenir ce résultat de différentes
manières, l'une des plus simples consiste à effectuer : B = [0]*len(A).
>>>'orange‘ in fruits
True
>>>len(fruits)
2
60
index(L,x,a,b) retourne la position de la première occurrence de x
dans la liste L entre les deux positions a et b. si b n’est pas donné la
recherche s’éffectue de la position a à la fin.
index(L,x) retourne la position de la première occurrence de x dans

la liste L (de début à la fin).
>>> T=[6,4,8,4,9,4,7,4,9]
>>> m=T.index(4,2,7)
>>> m
3
>>> m=T.index(4,6)
>>> m
7
>>> m=T.index(4,8)
Traceback (most recent call last):
File "<console>", line 1, in <module>
ValueError: 4 is not in list
>>> m=T.index(9,8)
>>> m
8
61
>>> T=[6,4,8,4,9,4,7,4,9]
>>> T.remove(T[3])
>>> T
[6, 8, 4, 9, 4, 7, 4, 9]
>>> del(T[2])
>>> T
[6, 8, 9, 4, 7, 4, 9]
>>> a=T.pop()
>>> a
9
>>> T
[6, 8, 9, 4, 7, 4]
>>> b=T.pop(-2)
>>> T
[6, 8, 9, 4, 4]
>>> b=T.pop(1)
>>> b
8
62
>>> T=[6,4,8,4,9,4,7,4,9]
>>> T.remove(T[3])
>>> T
[6, 8, 4, 9, 4, 7, 4, 9]
>>> del(T[2])
>>> T
[6, 8, 9, 4, 7, 4, 9]
>>> a=T.pop()
>>> a
9
>>> T
[6, 8, 9, 4, 7, 4]
>>> b=T.pop(-2)
>>> T
[6, 8, 9, 4, 4]
>>> b=T.pop(1)
>>> b
8
63
>>> T=[6,4,8,4,9,4,7,4,9]
>>> T.append([1,2,3])
>>> T
[6, 4, 8, 4, 9, 4, 7, 4, 9, [1, 2, 3]]
>>> T.extend([7,8,9])
>>> T
[6, 4, 8, 4, 9, 4, 7, 4, 9, [1, 2, 3], 7, 8, 9]
>>> T.insert(2,10000) # insére 10000 dans la position 2 de
la liste T
>>> T
[6, 4, 10000, 8, 4, 9, 4, 7, 4, 9, [1, 2, 3], 7, 8, 9]
>>> L=["Bon","Jour","Monsieur"]
>>> C="***".join(L)
>>> C
'Bon***Jour***Monsieur’
64
Les références partagées et le module copy
• Par erreur, il y a des personnes qui pensent que la manière la
plus simple de copier une liste est de déclarer une variable et de
lui affecter ladite liste comme dans l’exemple ci-dessous:
liste_initiale = [1, 6.3, [‘Amrani', ‘Yassine']]
copie_liste = liste_initiale
print(copie_liste)
Résultat : [1, 6.3, [‘Amrani', ‘Yassine']]
• Mais en faisant cela, nous avons simplement créé un alias, c’est-
à-dire que nous avons instancié un nouvel objet qui partage la
même référence que la liste copiée! Autrement dit nous avons
donné un deuxième nom copie_liste de la liste liste_initiale.
liste_initiale = [1, 6.3, ['Amrani', 'Yassine']]
copie_liste = liste_initiale
liste_initiale[0]=4
print(liste_initiale)
print(copie_liste)

[4, 6.3, ['Amrani', 'Yassine']]
On remarque clairement la dépendance entre la liste et sa copie.
Faire une shallow copy avec list() ou liste[:]
Essayons de voir si nous pouvons solutionner le problème en déclarant une
nouvelle liste et en lui affectant liste_initiale. Deux possibilités s’offrent à nous :

copie_liste = list(liste_initiale)
Ou bien
copie_liste = liste_initiale[:]
Le schéma suivant résume la situation
copie_liste1 = list(liste_initiale)
copie_liste2 = liste_initiale[:]
liste_initiale[0]=4
liste_initiale[2][0]='Saadi'
liste_initiale[2][1]='Anis'
print(liste_initiale); print(copie_liste1); print(copie_liste2)

[4, 6.3, ['Saadi', 'Anis']]
[1, 6.3, ['Saadi', 'Anis']]
[1, 6.3, ['Saadi', 'Anis']]
Avec le code ci-dessous, on arrive certes à faire une copie profonde
mais ce n’est pas l’idéal.
copie_liste = list(liste_initiale); copie_liste[2] = list(liste_initiale[2])
liste_initiale[2][0]='Louhmadi'; liste_initiale[2][1]= 'Salim'
print(liste_initiale ); print(copie_liste)
 [1, 6.3, ['Louhmadi', 'Salim']]
Dans le cas d’une liste représentant un arbre (liste de listes de listes
de listes ….) la solution présentée en haut n’est pas très pratique!
Le module copy qui fonctionne avec tous les types mutables, permet
de faire deux sortes de copies différentes:
• la shallow copy (shallow signifie superficiel ou peu profond.)
• la deep copy (deep signifie profond.)
Pour utiliser ces deux méthodes, il faut importer le module copy:
• copy.copy effectue une shallow copy
• copy.deepcopy effectue une deep copy
• une shallow copy effectue une copie des éléments de premier
niveau. Elle copie les éléments 1 et 6.3 tandis que le troisième
élément (qui est une liste) devient une référence partagée. Cela
signifie que si vous remplacez « Amrani » par « Saadi » dans la
petite liste qui se trouve à l’indice 2 de la liste copie_liste, cette
modification affectera liste_initiale car ce n’est pas un élément de
premier niveau.
import copy
copie_liste = copy.copy(liste_initiale)
liste_initiale[1]=7.15 ; liste_initiale[2][0]='Saadi';
liste_initiale[2][1]='Anis'
print(liste_initiale); print(copie_liste)
 [1, 7.15, ['Saadi', 'Anis']] [1, 6.3, ['Saadi', 'Anis']]
import copy
liste_initiale = [1, 6.3, ['Amrani', 'Yassine',[15,18]]]
copie_liste = copy.deepcopy(liste_initiale)
liste_initiale[1]=7.15 ; liste_initiale[2][0]='Saadi';
liste_initiale[2][1]='Anis' ; liste_initiale[2][2][1]=19
print(liste_initiale); print(copie_liste)
[1, 7.15, ['Saadi', 'Anis', [15, 19]]]
[1, 6.3, ['Amrani', 'Yassine', [15, 18]]]
Le module copy (avec ses méthodes shallow copy et deep copy)
fonctionne parfaitement avec d’autres objets mutables tels que les
dictionnaires.
import copy
dico = {"Nom" : "Amrani", 'Prénoms' : {'Prénom 1' : "Yassine",
'Prénom 2' : "Yasmine"}}
copie_dico = copy.deepcopy(dico)
copie_dico['Nom'] = "Saadi"
copie_dico['Prénoms']['Prénom 1'] = "Nissrine"
print(dico) ; print(copie_dico)

{'Nom': 'Amrani', 'Prénoms': {'Prénom 1': 'Yassine', 'Prénom 2':
'Yasmine'}}
{'Nom': 'Saadi', 'Prénoms': {'Prénom 1': 'Nissrine', 'Prénom 2':
'Yasmine'}}
Le même raisonnement s’applique sur les tuples:
T1=(1,2,3,[4,6,[7,8,9]]) ; T2=T1; T3=copy.deepcopy(T1)
T1[3][0]=7777; print(T1); print(T2);print(T3)
 (1, 2, 3, [7777, 6, [7, 8, 9]])
(1, 2, 3, [7777, 6, [7, 8, 9]])
(1, 2, 3, [4, 6, [7, 8, 9]])
Le même raisonnement s’applique sur les ensembles
import copy
S1=set(); S1.add(10); S1.add('Master DSBD');S1.update({11,12,13})
S2=S1 ; S3=copy.deepcopy(S1)
S2.remove(10) ; S3.remove(12); print(S1); print(S2); print(S3)

{'Master DSBD', 11, 12, 13}
{'Master DSBD', 11, 12, 13}
{'Master DSBD', 10, 11, 13}
Avec les objets de type str(), int() ou bien float(), il est inutile
d’utiliser le module copy puisque de toute façon, l’affectation va
créer un nouvel objet qui aura sa propre référence.
Dictionnaires
Les types composites (chaînes de caractères, listes et tuples) considérés jusqu’à
maintenant étaient tous des séquences, i.e. des suites ordonnées d’éléments.
On peut accéder à un élément d’une séquence à partir de sa position.
Un dictionnaire ressemble à une liste et est modifiable mais n’est pas une
séquence car les éléments enregistrés ne sont pas disposés dans un ordre
immuable.
On peut accéder à un élément d’un dictionnaire à partir d’une clé. Cette clé
peut être une chaîne, un nombre ou même d’un type composite sous certaines
conditions. On ne peut pas modifier les clés d’un dictionnaire.
Puisque le type dictionnaire est un type modifiable, nous pouvons commencer

par créer un dictionnaire vide noté {}, puis le remplir par la suite.
>>> traduction = {}
>>> print(traduction) dictionnaire vide
{}
>>> traduction["mouse"] = "souris" insertion d’éléments à l’aide de
>>> traduction["keyboard"] = "clavier" paires clé-valeur
>>> print(traduction)
{'mouse': 'souris', 'keyboard': 'clavier'} 76
Le dictionnaire est entouré de {}.
Les dictionnaires
On peut aussi créer un dictionnaire comme suit :
>>> D = {"kh" : "khalil", "ch" : "chrit"}
>>> F, G = {}, {5: "Mauve", 2: "Rouge"}
>>> print (D, F, G)
{"kh" : "khalil", "ch" : "chrit"}{} {2: 'Rouge', 5: 'Mauve'}
L’ordre dans lequel les éléments apparaissent à l’affichage du dictionnaire ne
correspond pas nécessairement à celui dans lequel nous les avons insérés.
Cela n’a pas d’importance car nous utilisons les clés pour accéder à un élément.
>>> Couleur = {1: "Rouge", 2: "Vert", 3: "Bleu"}
>>> print(Couleur)
{1: 'Rouge', 2: 'Vert', 3: 'Bleu'}
>>> Couleur = {'1': "Rouge", '2': "Vert", '3': "Bleu"}
>>> print(Couleur)
{'1': 'Rouge', '3': 'Bleu', '2': 'Vert'}
Illustrons maintenant la variété de types de clés qu’on peut utiliser.

>>> D = {1: "un", '1': "valeur_unitaire", 1.1: "valeur_decimale"}
>>> print(D)
{'1': 'valeur_unitaire', 1: 'un', 1.1000000000000001: 'valeur_decimale'}
>>> D[1.1]
'valeur_decimale' 77
Les dictionnaires
Nous pouvons utiliser en guise de clés n’importe quel type de donnée non
modifiable : des entiers, des réels, des chaînes de caractères et même des tuples.
>>> sudoku = {}
>>> sudoku[(0, 1)] = 9
>>> sudoku[(0, 4)] = 5
>>> sudoku[(0, 7)] = 3
>>> print(sudoku)
{(0, 1): 9, (0, 7): 3, (0, 4): 5} Chaque clé dans un
>>> print(sudoku[(0,4)]) dictionnaire est unique.
5
>>> print(sudoku[(2,2)])
File "<pyshell#6>", line 1, in <module>
print sudoku[(2,2)]
KeyError: (2, 2)
Les dictionnaires permettent tous les opérateurs de type standard mais n’autorisent
pas d’opérations telles que la concaténation, la répétition ou l’extraction d’un groupe
d’éléments contigus car les dictionnaires ne sont pas des séquences, c’est-à-dire
les éléments ne sont pas disposés dans un ordre particulier. 78
Les dictionnaires
Contrairement à une liste, nous ne faisons pas appel à une méthode particulière
telle que append() pour ajouter un nouvel élément à un dictionnaire. Il suffit de
créer une nouvelle paire clé-valeur.
{'mouse': 'souris', 'keyboard': 'clavier'}
>>> traduction["computer"] = "ordinateur"
{'computer': 'ordinateur', 'mouse': 'souris', 'keyboard': 'clavier'}
dict() : renvoie un dictionnaire issu par exemple d’une séquence où ses éléments
doivent être associés deux à deux. Le premier élément constituera une
nouvelle clé et le second sa valeur associée.
>>> dict([[1,2], [6,7], [3,9]])

{1: 2, 3: 9, 6: 7} >>> L=[45, 49, 34, 302]
>>> dict([(1,2), (6,7), (3,9)]) >>> D=dict(enumerate(L))
{1: 2, 3: 9, 6: 7} >>> D
>>> dict(((1,2), (6,7), (3,9))) {0: 45, 1: 49, 2: 34, 3: 302}
{1: 2, 3: 9, 6: 7}
79
L=[["Zineb",17],["Salma",16.75],["Amine",15]]
def trouverNote(M,nom):
for i in range(len(M)):
if M[i][0]==nom:
return M[i][1]
return -1
Exercice:
On dispose d’un dictionnaire associant à des noms de commerciaux
d’une société le nombre de ventes qu’ils ont réalisées.
Par exemple :
ventes= {"Amine":14, "Rachid":19, "Hamza":15, "Taha":21, "Aya":17}
1) Écrivez une fonction qui prend en entrée un dictionnaire et renvoie le

nombre total de ventes dans la société.
2) Écrivez une fonction qui prend en entrée un tel dictionnaire et renvoie

le nom du vendeur ayant réalisé le plus de ventes. Si plusieurs
vendeurs sont maximaux sur ce critère, la fonction devra retourner le
nom de l’un d’entre eux.
81
Supprimer des éléments d’un dictionnaire ou des dictionnaires entiers
Pour enlever un élément à un dictionnaire, on utilise l’instruction del et pour

connaître le nombre d’éléments du dictionnaire, on se sert de la fonction len.
>>> del(traduction["mouse"])
>>> print (len(traduction))
2
{'computer': 'ordinateur', 'keyboard': 'clavier'}
>>> traduction.pop('computer') Supprime et retourne l’entrée.
'ordinateur'
>>> traduction.clear() Supprime toutes les entrées
>>> print(traduction) d’un dictionnaire.
{}
>>> del(traduction) Supprime un dictionnaire.

print traduction
NameError: name 'traduction' is not defined
82
Accès aux valeurs d’un dictionnaire
keys() : renvoie la liste des clés utilisées dans le dictionnaire.

Cela permet de parcourir un dictionnaire et d’accéder à ses valeurs.
>>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'}

>>> for cle in dictionnaire.keys():
print (cle, « --- » ,dictionnaire[cle])
bleu---blue
vert---green
rouge---red
Depuis Python 2.2, ce n’est plus nécessaire d’utiliser la méthode keys().

>>> for cle in dictionnaire:
print (cle, « --- » ,dictionnaire[cle])
bleu---blue
vert---green
rouge---red
83
On doit vérifier si un dictionnaire possède une clé avant de tenter d’accéder à
sa valeur.
>>> if 'noir' in dictionnaire: dictionnaire['noir']

>>> 'rouge' in dictionnaire
True
Comment modifier un dictionnaire ?

Vous pouvez mettre à jour un dictionnaire en lui ajoutant une nouvelle entrée ou
en modifiant une entrée existante.
>>> dictionnaire['noir'] = 'black'
>>> dictionnaire['bleu'] = 'BLUE'
>>> print(dictionnaire)
{'bleu': 'BLUE', 'noir': 'black', 'vert': 'green', 'rouge': 'red'}
Lorsqu’on affecte une valeur à une clé qui n’existe pas encore, la clé est créée
dans le dictionnaire et la valeur est ajoutée. Mais si la clé existe déjà, alors la
valeur existante est remplacée par la nouvelle.
>>> dictionnaire = {1: "vert", 1:"VERT"}
>>> print(dictionnaire)
{1: 'VERT'} 84
Fonctions et méthodes permettant de manipuler des dictionnaires.
D.values() : renvoie la liste des valeurs utilisées dans le dictionnaire D.
D.items() : renvoie une liste équivalente de tuples à partir d’un dictionnaire D.
>>> print(traduction.keys())
['computer', 'keyboard']
>>> print(traduction.values())
['ordinateur', 'clavier']
>>> print(traduction.has_key("mouse"))
False
>>> print(traduction.items())
[('computer', 'ordinateur'), ('keyboard', 'clavier')]
D.copy() : effectue une vraie copie d’un dictionnaire D au lieu d’un alias.
>>> conversion = traduction.copy()
>>> conversion["mouse"] = "souris"
>>> print traduction
{'computer': 'ordinateur', 'keyboard': 'clavier'}
>>> print conversion
{'computer': 'ordinateur', 'mouse': 'souris', 'keyboard': 'clavier'}
85
Les tuples
Vous savez qu’il n’est pas possible de changer les caractères au sein d’une chaîne
existante, alors que vous pouvez modifier les éléments d’une liste.
Un tuple est une collection d’éléments à l’intérieur de parenthèses séparés par des
virgules semblable à une liste mais il n’est pas modifiable.
Un tuple peut représenter une clé de dictionnaire ce qu’une liste ne peut faire.
Les tuples sont préférables aux listes partout où l’on veut être certain que les
données transmises ne soient pas modifiées par erreur.
>>> saisons = ("printemps", "été", "automne", "hiver")
>>> print(saisons)
('printemps', 'été', 'automne', 'hiver')
>>> print(saisons[2:3])
('automne',) Il faut toujours au moins
>>> print (("printemps",) + saisons[1:4]) une virgule pour définir
('printemps', 'été', 'automne', 'hiver') un tuple.
>>> saisons[2] = "Automne"

saisons[2] = "Automne"
TypeError: 'tuple' object does not support item assignment 86
Création et affectation d’un tuple (suite)
>>> un_tuple = () tuple vide
>>> print un_tuple
()
>>> tuple("abc")
('a', 'b', 'c')
Pour accéder aux valeurs d’un tuple, on utilise les crochets de la même façon
qu’avec les listes.
>>> Couleur = ("blanc", "bleu", "rouge", "mauve", "noir")

>>> print(Couleur[1:3])
('bleu', 'rouge')
>>> print(Couleur[:3])
('blanc', 'bleu', 'rouge')
>>> print(Couleur[3:])
('mauve', 'noir')
87
Modification d’un tuple
Cela ne peut se faire directement. Il faut créer un nouveau tuple à l’aide

d’anciens grâce à l’opérateur de concaténation ou de répétition.
>>> Teinte = Couleur[1], Couleur[2], Couleur[4]

>>> print(Teinte)
('bleu', 'rouge', 'noir')
>>> Teinte = Teinte[0:2] + ("vert",)
>>> print(Teinte * 2)
('bleu', 'rouge', 'vert', 'bleu', 'rouge', 'vert')
On peut modifier certains éléments d’un tuple si ces éléments sont modifiables.
>>> T = (5, [0, 1, 2])
>>> print (T)
(5, [0, 1, 2])
>>> T[0] = 6
T[0] = 6
TypeError: 'tuple' object does not support item assignment
>>> T[1][0] = -1
>>> print (T)
(5, [-1, 1, 2]) 88
Suppression d’un tuple ou des éléments d’un tuple
Il est impossible de supprimer individuellement les éléments d’un tuple.
On peut assembler un nouveau tuple en omettant les éléments indésirables.
Pour supprimer explicitement un tuple entier, on utilise del :
del (teinte)
Les opérateurs *, +, in, [], <, >, ==, <=, >= et les fonctions intégrées len, max, min
se comportent exactement de la même façon avec les tuples qu’avec les listes.
Les méthodes de manipulation de listes : tri, remplacement, insertion, etc. – ne

sont pas implémentées.
Un ensemble d’éléments séparés par des virgules et écrits sans symboles
d’identification de type crochets pour les listes, parenthèses pour les tuples, etc.
est par défaut un tuple.
>>> "Abc", 99 >>> u, v = 0, 1
('Abc', 99) >>> u, v
>>> x = 23, 45, "q" (0, 1)
>>> x >>> print (u, v)
(23, 45, 'q') 01
>>> T = (2, 3)
Les fonctions intégrées list() et tuple() permettent >>> T = list(T)
de convertir une liste en tuple ou vice versa. >>> print (T)
[2, 3] 89
L’approche Objet
La réalisation d’un projet informatique suit idéalement 3

phases successives :
– Analyse : comprendre clairement le problème posé ;
– Conception : identifier les concepts fondamentaux impliqués dans une
solution ;
– Programmation : exprimer la solution dans un programme informatique.
Deux approches pour réaliser un projet informatique
1) Approche fonctionnelle (début des développements informatiques,
années 1960-80) :
– Données séparées des traitements ;
– Concept clef : la fonction (procédure, routine, ...)  découpage du
problème en fonctions ... découpées en sous-fonctions ...
C’est le cas des programmes vus en S3 (programmation en C) et S4

(structures de données)
L’approche Objet
2) L’approche Objet: rapprocher les entités informatiques de celles du
monde réel ...
 Faire des objets communicants entre eux possédant :
• des propriétés  données
• des comportements  méthodes
Compte_bancaire 1 Compte_bancaire 2
solde : 10000 solde : 123456
numero : 6 Attributs numero : 17
proprietaire : amine proprietaire : amina
Creation(6, 10000): void creation(17, 123456): void
depot(2000): void Méthodes
depot(1115): void
retrait(5000): void Retrait(9896): void
Deux objets de type Compte_bancaire

L’approche Objet
Le concept d’Objet
Un objet informatique, au sens de l’Orienté Objet, est une unité

atomique possédant :
– une identité ;
– un état, défini par un ensemble de données (attributs, ou données
membres) ;
– un comportement, défini par un ensemble de fonctions (méthodes, ou
fonctions membres).
Un Objet peut correspondre à :
– Un objet concret du monde réel, ayant une réalité physique (une
personne, une voiture, un système mécanique, un étudiant, . . . ) ;
– Un concept abstrait (un compte bancaire, une contrainte mécanique, une
vitesse, une équation différentielle, . . . ) ;
– ….
Les deux principaux paradigmes de la programmation objet
• L'abstraction, c'est la capacité d'ignorer les détails d'un élément pour en avoir
une vision globale.
L'abstraction de données consiste à regrouper des données, ce qui aboutit aux

types complexes de données (comme les structures en C).
Le modèle objet est une abstraction des données et des traitements (fonctions
qui seront appliquées sur ces données).
• L'encapsulation, c'est le masquage de certains éléments au sein d'une entité

(un "module", ou un objet). Ils ne sont plus visibles (ou accessibles) à
l'extérieur de l'entité.
Dans le modèle objet, un objet n'est visible de l'extérieur que par son interface.
Introduction à la programmation Orienté Objet sous python 3
95
Introduction à la programmation Orienté Objet sous python 3
96
Base de données Sqlite sous python 3
Soit la base de données dont le shéma relationnel ci-dessous:
• clients( code_client,nom_complet, adresse ,type ,remise ,

date_naissanceDATE, fonction ,Société, Contact )
• Employe(N_employé,nom , prénom , Fonction , Date_d_embauche,
Date_de_naissance, code_postal, Ville , Code_du_superieur);
• commande(numero_commande ,numero_client*, date_commande,
num_employe* , a_livrer_avant)
• fournisseur(numero_fr ,nom_fr ,ville_fr);
• produit( ref_produit ,désignation ,pu ,famille ,numero_fr*, unites_en_Stock);
• details_commandes( numero_commande*, ref_produit*, Quantite );
97
import sqlite3 Connexion des bases de données avec Python
fichierDonnees = "C:/______________python 20-21/DB1.sqlite"
conn=sqlite3.connect(fichierDonnees)
cur=conn.cursor()
cur.execute("INSERT INTO fournisseur
(numero_fr,nom_fr,ville_fr)VALUES(6401,'Ahmadi','meknes'),
(909,'A','B')")
cur.execute("SELECT * FROM fournisseur")
TableFournisseurs=cur.fetchall() # ou bien: list(cur)
cur.execute("delete FROM fournisseur where numero_fr=61")
conn.commit()
cur.close()
conn.close()
98
L’opération commit() et rollback()
• Commit est l'opération, qui donne un signal vert à la base de

données pour finaliser les changements, et après cette
opération, aucun changement ne peut être renvoyé.
• Si vous n'êtes pas satisfait d'un ou de plusieurs des

changements et que vous souhaitez rétablir ces modifications
complètement, utilisez la méthode rollback().
L’opération de lecture d’une base de données
• Une fois que notre connexion à la base de données est établie, vous
êtes prêt à effectuer une requête dans cette base de données. Vous
pouvez utiliser la méthode fetchone () pour extraire une valeur
unique ou fetchall () pour extraire plusieurs valeurs d'une table de
base de données.
– fetchone (): Il récupère la ligne suivante d'un ensemble de
résultats de requête. Un ensemble de résultats est un objet
renvoyé lorsqu'un objet curseur est utilisé pour interroger une
table.
– fetchall (): Il récupère toutes les lignes d'un jeu de résultats. Si
certaines lignes ont déjà été extraites du jeu de résultats, elles
récupèrent les lignes restantes du jeu de résultats.
– rowcount: Il s'agit d'un attribut en lecture seule et renvoie le
nombre de lignes affectées par une méthode execute ().
• nombre de lignes affectés peut être obtenu avec cur.rowcount.

Attention, ce nombre est correct uniquement pour les
insert/update/delete. Il vaut -1 pour les select.
• en fait, on peut aussi utiliser directement execute et executemany

avec la connection sans ouvrir explicitement de curseur, c'est un
raccourci, par exemple : con.executemany("insert into myTable (x,
y) values (?, ?)", data).
Base de données Sqlite sous python
Exercice 11:
1) En utilisant fetchall, écrire une fonction python:
def ListeDesProduit(numFour) permettant d’afficher la liste des produits
du fournisseur numéronumFour. Tester cette fonction pour numFour=1.
2) En utilisant fetchone(), écrire une fonction python:

def InformationsProduit(REF) permettant d’afficher les informations du
produit de référence RE. Tester cette fonction pour REF =1.
3) En utilisant fetchone(), écrire une fonction python :

def InformationsProduit(DESIGN) permettant d’afficher les informations
du produit de désignation DESIGN.
Tester cette fonction pour DESIGN = "Clavier".
4) Ecrire une fonction python def InsererFournisseur(f) permettant d’insérer

le fournisseur f dans la table fournisseur. Donner à l’utilisateur de cette
fonction la possibilité de valider cette insertion ou de l’annuler. Tester cette
fonction pour f=(20,'Louhmadi','Mohammedia')
def ListeDesProduit(numFour):
import sqlite3
fichierDonnees ="C:/DB1.sqlite"
cur=conn.cursor()
requete="SELECT * FROM produit where numero_fr="+str(numFour)
cur.execute(requete)
resultat=cur.fetchall()
for r in resultat:
print(r)
cur.close()
conn.close() 103
def InformationsProduit(REF):
import sqlite3
fichierDonnees = "C:/DB1.sqlite"
cur=conn.cursor()
requete="SELECT * FROM produit where ref_produit="+str(REF)
print(requete)
resultat=cur.fetchone()
print(resultat)
cur.close()
conn.close() 104
def InformationsProduit(DESIGN):
import sqlite3
cur=conn.cursor()
requete="SELECT * FROM produit where désignation="+'"'+DESIGN+'"'
print(requete)
resultat=cur.fetchone()
print(resultat) ; cur.close() ; conn.close()
105
four=(2999,'Louhmadi','Mohammedia'); f3=(112611,'Akrami','Casablanca')
def InsererFournisseur(f):
import sqlite3
cur=conn.cursor()
requete="insert into fournisseur values"+str(f)
choix=input("Pour valider cette insertion taper O, sinon N:")
if choix=='O':
conn.commit()
else:
conn.rollback()
cur.close()
conn.close()
106
Les interfaces graphiques sous python 3
• Les boutons permettent de proposer une action à l'utilisateur. Dans l'exemple
ci-dessous, on lui propose de fermer la fenêtre.
• from tkinter import *
• fenetre=Tk()
• fenetre.geometry('400x200')
• fenetre.title('PI-2 ESTEM Window')
• # définition des dimensions de la fenêtre (400x300)
• label = Label(fenetre, text="Bonjour PI-2 ESTEM, Bienvenue!",fg="red",bg='yellow')
• label.pack() # affichage du label
• bouton=Button(fenetre, text="Fermer", command=fenetre.destroy)
• bouton.pack() # affichage du bouton
• fenetre.mainloop()
• #fenetre.mainloop()# est très importante, parce que c'est elle qui provoque le
• #démarrage du réceptionnaire d'événements associé à la fenêtre. Cette instruction
• # est nécessaire pour que votre application soit « à l'affût » des clics de souris, des
pressions exercées sur les touches du clavier, etc. C'est donc cette instruction qui « la
met en marche », en quelque sorte T1 107
#Checkbutton : affiche des cases à cocher.
from tkinter import *
fenetre = Tk()
CheckVar1 = StringVar()
bouton = Checkbutton(fenetre, text="Etudiant",variable = CheckVar1,onvalue ="oui", offvalue = "non")
bouton.pack()
bouton2 = Checkbutton(fenetre, text="Prépas Integrés", variable = CheckVar2,onvalue ="oui", offvalue = "non")
bouton2.pack()
bouton3 = Checkbutton(fenetre, text="Bac Scientifique", variable = CheckVar3,onvalue ="oui", offvalue = "non")
bouton3.pack()
labelX=Label(fenetre, text="vous êtes: ")
labelX.pack()
def fonction1():
ch=""
if(CheckVar1.get()=="oui"):
ch+="Etudiant"
ch+=" Prépas Integrés "
ch+=" Bac Scientifique "
labelX.configure(text="vous êtes: "+ch)
bouton4=Button(fenetre, text="Afficher", command=fonction1)
bouton4.pack()
T2
fenetre.mainloop()
108
Les boutons radio sont des cases à cocher qui sont dans un groupe
et dans ce groupe seul un élément peut être sélectionné.
• fenetre = Tk()
• value = StringVar()
• bouton1 = Radiobutton(fenetre, text="Oui", variable=value, value=1)
• bouton2 = Radiobutton(fenetre, text="Non", variable=value, value=2)
• bouton3 = Radiobutton(fenetre, text="Peu être", variable=value,
value=3)
• bouton1.pack()
• bouton2.pack()
• bouton3.pack()
T3
109
• Les frames (cadres) sont des conteneurs qui permettent de
séparer des éléments.
• fenetre = Tk()
• fenetre['bg']='white'
• # frame 1
• Frame1 = Frame(fenetre, borderwidth=2, relief=GROOVE)
• Frame1.pack(side=LEFT, padx=30, pady=30)
• # frame 2
• Frame2 = Frame(fenetre, borderwidth=2, relief=GROOVE)
• Frame2.pack(side=LEFT, padx=10, pady=10)
• # frame 3 dans frame 2
• Frame3 = Frame(Frame2, bg="white", borderwidth=2, relief=GROOVE)
• Frame3.pack(side=RIGHT, padx=5, pady=5)
• # Ajout de labels
• Label(Frame1, text="Frame 1").pack(padx=10, pady=10)
• Label(Frame2, text="Frame 2").pack(padx=10, pady=10)
• Label(Frame3, text="Frame 3",bg="white").pack(padx=10, pady=10)
T4 110
root = Tk()
root.title('Frames')
for r in [RAISED, SUNKEN, FLAT, RIDGE, GROOVE, SOLID]:
f = Frame(root, borderwidth=2, relief=r)
Label(f, text=r, width=10).pack(side=LEFT)
f.pack(side=LEFT, padx=5, pady=5)
root.mainloop()
T5 111
Le widgets Entry:
T6
112
• Les listes permettent de récupérer une valeur sélectionnée par
l'utilisateur.

• fenetre = Tk()
• liste = Listbox(fenetre)
• liste.insert(1, "Python")
• liste.insert(2, "PHP")
• liste.insert(3, "jQuery")
• liste.insert(4, "CSS")
• liste.insert(5, "Javascript")
• liste.pack()
T7
113
• Un canvas (toile, tableau en français) est un espace dans lequel
vous pouvez dessiner ou écrire ce que vous voulez
• fenetre = Tk()
• canvas = Canvas(fenetre, width=150, height=120,
background='yellow')
• ligne1 = canvas.create_line(75, 0, 75, 120)
• ligne2 = canvas.create_line(0, 60, 150, 60)
• txt = canvas.create_text(75, 60, text="Cible", font="Arial 16
italic", fill="blue")
• #canvas.delete(ligne2)
• canvas.pack()
T9
114
T9-V-2
115
• Le widget scale permet de récupérer une valeur numérique via
un scroll
T10
116
T10-V-2
117
• La spinbox propose à l'utilisateur de choisir un nombre
T11 118
Le labelframe est un cadre avec un label
• fenetre = Tk()
• l = LabelFrame(fenetre, text="Titre de la frame", padx=20,
T11 pady=20)
• l.pack(fill="both", expand="yes")
• Label(l, text="A l'intérieure de la frame").pack()
T12
119
Pour pouvoir utiliser les alertes de votre os, vous pouvez importer le
module tkMessageBox
from tkinter.messagebox import *
def callback():
if askyesno('Titre 1', 'Êtes-vous sûr de vouloir faire ça?'):
showwarning('Titre 2', 'Tant pis...')
else:
showinfo('Titre 3', "Vous n'êtes pas sûr!")
showerror("Titre 4", "Au revoir...")
B=Button(text='Action', command=callback)
B.pack()
fenetre.mainloop()
T13
120
Pour pouvoir utiliser les alertes de votre os: module tkMessageBox
T14 121
• Il est possible de créer une barre de menu comme-ceci:
• def alert():
showinfo("alerte", "Bravo!")
• fenetre = Tk()
• menubar = Menu(fenetre)
• menu1 = Menu(menubar)
• menu1.add_command(label="Créer", command=alert)
• menu1.add_command(label="Editer", command=alert)
• menu1.add_separator()
• menu1.add_command(label="Quitter", command=fenetre.quit)
• menubar.add_cascade(label="Fichier", menu=menu1)
• menu2.add_command(label="Couper", command=alert)
• menu2.add_command(label="Copier", command=alert)
• menu2.add_command(label="Coller", command=alert)
• menubar.add_cascade(label="Editer", menu=menu2)
• menu3.add_command(label="A propos", command=alert)
• menubar.add_cascade(label="Aide", menu=menu3)
• fenetre.config(menu=menubar)
• T15
fenetre.mainloop() 122
Animations (voir T16.py)
Canevas = Canvas(Mafenetre,height=HAUTEUR,width=LARGEUR,bg='white')
Canevas.coords(Balle,X-RAYON,Y-RAYON,X+RAYON,Y+RAYON)
Mafenetre.after(50,deplacement)
Balle = Canevas.create_oval(X-RAYON,Y-
RAYON,X+RAYON,Y+RAYON,width=1,fill='green')
123
• Vous pouvez récupérer les actions utilisateurs à travers
les events (évènements).
• Pour chaque widget, vous pouvez binder (lier) un évènement, par exemple
dire lorsque l'utilisateur appuie sur telle touche, faire cela.
• Voici un exemple qui récupère les touches appuyées par l'utilisateur:

• fenetre = Tk()
• def clavier(event):
touche = event.keysym
print(touche)
• canvas = Canvas(fenetre, width=500, height=500)

• canvas.focus_set()
• canvas.bind("<Key>", clavier)
• canvas.pack()
124
• D'autres évènements existent:
• <Button-1> : Click gauche
• <Button-2> : Click milieu
• <Button-3> : Click droit
• <Double-Button-1> : Double click droit
• <Double-Button-2> : Double click gauche
• <KeyPress> : Pression sur une touche
• <KeyPress-a> : Pression sur la touche a (minuscule)
• <KeyPress-A> : Pression sur la touche A (majuscule)
• <Return> : Pression sur la touche entrée
• <Escape> : Touche Echap <Up> : Pression sur la flèche directionnelle haut
<Down> : Pression sur la flèche directionnelle bas
• <ButtonRelease> : Lorsque qu'on relache le click <Motion> : Mouvement de
la souris <B1-Motion> : Mouvement de la souris avec click gauche <Enter> :
Entrée du curseur dans un widget
• <Leave> : Sortie du curseur dans un widget <Configure> :
Redimensionnement de la fenêtre
• <Map> <Unmap> : Ouverture et iconification de la fenêtre
• <MouseWheel> : Utilisation de la roulette 125

Cours Python 2PI

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 Python 2PI

Transféré par

Droits d'auteur :

Formats disponibles

Professeur: Dr.

On peut noter qu'un bon algorithme est un schéma résolution

• Une variable est une entité qui 14.25

– un type qui caractérise Réel

-Pour que la condition logique : condition1 ET condition2

- Pour que la condition logique : condition1 OU condition2

- Le NON inverse une condition : NON(condition)

Cet algorithme a une structure séquentielle, les instructions s'exécutent

Opérateur signification Langage Python

La condition peut être:

Les blocs d'instructions sont toujours associés à une ligne

Pour i= i_initiale à i_finale faire

Exemple: programme qui compte le nombre de chiffres d’un nombre

Nous avons vu diverses fonctions pré-programmées (pow, exp, …). Voyons à

def nomDeLaFonction(liste de paramètres):

>>> def table7():

2. Créer une nouvelle fonction peut servir à raccourcir un programme, par

>>> def table(base):

Pour tester cette nouvelle fonction, il nous suffit de l'appeler avec un

>>> def tableMulti(base, debut, fin):

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

Ce programme comporte trois parties : les deux fonctions cube() et

Pour calculer la somme des carrés des entiers de 1 à 10, on

Puis, on la passe en argument à la fonction somme_fonction :

>>> somme_fonction ( carre , 10 )

 Les "procédures":. La procédure ne possède pas de valeur de retour et son appel

les chaînes sont immuables

Concaténation: On concatène deux chaînes à l’aide de l’opérateur + :

Longueur: On utilise len pour obtenir la longueur d’une chaîne :

>>> x="Idrissi, Bouhajeb, Belkouch, Soulane, Sadir"

x="bonne***année universitaire à tous"

>>> x='bon courage. bonne journée'

Accès aux éléments d’une liste

Les listes sont des objets

Insertion d'un ou plusieurs éléments n'importe où dans une liste

Création d'une liste de nombres à l'aide de la fonction range()

Les arguments négatifs sont autorisés :

Si vous voulez parcourir une gamme d'entiers, la fonction range() s'impose :

Une liste en mode compréhension :

index(L,x) retourne la position de la première occurrence de x dans

liste_initiale = [1, 6.3, ['Amrani', 'Yassine']]

On peut accéder à un élément d’une séquence à partir de sa position.

Puisque le type dictionnaire est un type modifiable, nous pouvons commencer

Illustrons maintenant la variété de types de clés qu’on peut utiliser.

>>> dict([[1,2], [6,7], [3,9]])

1) Écrivez une fonction qui prend en entrée un dictionnaire et renvoie le

2) Écrivez une fonction qui prend en entrée un tel dictionnaire et renvoie

Pour enlever un élément à un dictionnaire, on utilise l’instruction del et pour

Traceback (most recent call last):

keys() : renvoie la liste des clés utilisées dans le dictionnaire.

>>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'}

Depuis Python 2.2, ce n’est plus nécessaire d’utiliser la méthode keys().

>>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'}

>>> if 'noir' in dictionnaire: dictionnaire['noir']

Comment modifier un dictionnaire ?

D.values() : renvoie la liste des valeurs utilisées dans le dictionnaire D.

D.items() : renvoie une liste équivalente de tuples à partir d’un dictionnaire D.

Traceback (most recent call last):

>>> Couleur = ("blanc", "bleu", "rouge", "mauve", "noir")

Cela ne peut se faire directement. Il faut créer un nouveau tuple à l’aide

>>> Teinte = Couleur[1], Couleur[2], Couleur[4]

Les méthodes de manipulation de listes : tri, remplacement, insertion, etc. – ne

La réalisation d’un projet informatique suit idéalement 3