0% ont trouvé ce document utile (0 vote)

228 vues72 pages

Cours Python L1 - Version Finale

Transféré par

Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.

Formats disponibles

Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

0% ont trouvé ce document utile (0 vote)

228 vues72 pages

Cours Python L1 - Version Finale

Transféré par

Aøuiche Ines

Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.

Formats disponibles

Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

Université Aboubakr Belkaid - Tlemcen

Introduction à l’algorithmique
et à la programmation sous
Python

Par Dr. BENSMAINE-MENADJELIA Nardjes

Support de cours

1
Table des matières

1 Introduction 4
1.1 Langage machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Langages de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Algorithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Découvrir Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.1 Installer et utiliser Python . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.2 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . 12
1.4.3 Instruction d’écriture (print) . . . . . . . . . . . . . . . . . . . . . 14
1.4.4 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.5 Écrire des algorithmes et des programmes Python . . . . . . . . . . . . . 16

2 Les variables 18
2.1 Affectation simple, multiple et parallèle . . . . . . . . . . . . . . . . . . . 19
2.2 Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3 Le typage dynamique en Python . . . . . . . . . . . . . . . . . . . . . . . 23
2.4 Instruction de lecture (input()) . . . . . . . . . . . . . . . . . . . . . . . 24
2.5 Conversion des types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3 Les structures conditionnelles 28

3.1 Comparaisons simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2 Comparaisons multiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3 Structure Si...Alors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Structure Si...Alors...Sinon . . . . . . . . . . . . . . . . . . . . . . . . 36
3.5 Structures Si...Alors...Sinon imbriquées . . . . . . . . . . . . . . . . . 38

4 Les structures répétitives 41

4.1 Fonction range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.2 Boucle ”Pour” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.3 Boucle ”Tant Que” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.4 Instructions ”break” et ”continue” . . . . . . . . . . . . . . . . . . . . . 48

2
5 Fonctions 49
5.1 Définition d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.2 Passage d’arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.3 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

6 Listes, dictionnaires et tuples 57

6.1 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.1.1 Définition de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.1.2 Indexation des listes . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6.1.3 Listes à deux dimensions . . . . . . . . . . . . . . . . . . . . . . . 60
6.1.4 Manipulation des listes . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.1.5 Copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
6.1.6 Portée des listes dans une fonction . . . . . . . . . . . . . . . . . . 64
6.2 Les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
6.2.1 Méthodes keys() et values() . . . . . . . . . . . . . . . . . . . . 67
6.2.2 Liste de dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . 67
6.3 Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Bibliography 1

A Liste des types en Python [1] 2

3
Chapitre 1

Introduction

Les machines de nos jours (robots, ordinateurs, appareils électroniques, etc.) sont
devenus très puissants. De plus, ils ont l’aire parfois très intelligents grâce aux applica-
tions qui les gèrent (leurs systèmes d’exploitation). Cependant, leur intelligence restera
toujours artificielle pour la simple raison qu’une machine est incapable de réfléchir.
Une machine ne fait qu’exécuter les commandes communiqués par les êtres humains
à travers des programmes informatique. Cela dit que derrière toute intelligence ar-
tificielle d’une machine, une véritable intelligence humaine maı̂tresse.

Si l’intelligence de l’être humain est véritable, pourquoi a-t-il besoin de l’intelligence

artificielle mes machines ?

L’être humain est souvent capable de résoudre les problèmes d’une façon ”logique”
et d’appliquer la solution à une petite instance du problème. Cependant, lorsque la
taille de l’instance du problème devienne grosse, le cerveau humain se trouve incapable
d’appliquer la solution vu que les calculs deviennent complexes. Par exemple, on sait
tous comment calculer xy . La solution de ce problème est de multiplier x par lui-même
y fois. On est même tous capable de calculer 54 ou 28 dans nos têtes ou sur papier. En
revanche, c’est difficile (voir, impossible) pour nous de calculer 7025 ou 45078 ! De ce fait,
on enseigne à la machine la méthode de résolution de ce problème (calcul de xy ) puis
on profite de sa capacité de calcul dans la résolution des problèmes de grosses tailles
(comme 45078 ).

1.1 Langage machine

Un ordinateur, comme tout appareil électronique, n’est capable d’interpréter (d’une
façon directe) que les signaux électriques. De ce fait, l’alphabet de son langage ne contient
que deux lettres :

4
— Passage du courant électrique, on va le noter P .
— Absence du courant électrique, on va le noter A.

De ce fait, une commande interprétable par la machine devra ressembler à ça :

PPAAPPAPAAPAPAPAPAPAAAAAAAPPPPAPAPAPAPPPPPAPAAAAAAAPPPPAPAPA
AAPPPPAPPAAAPAPAAPAPAPAPPAPAAAAAAAAPPAPAPAPAAPAPAAAAAAAAPPAA
APPPAPPPPAPPPAAAPAPPAPAPPPPPAPAPAPAPAPPPPPPAAPPPPPAAPAAPPPAP
PPPPAAPAAPPPAPPPPPAPPAPAPPPAPPPPPAPPAPAPAPPPPPPAAPPPAPPPPPAP
...

Comme tout langage, le langage machine est aussi composé d’un ensemble de
mots, qui forment les commandes à exécuter. Une commande est correcte ou exécutable
si :

— Ses mots utilisent l’alphabet {P, A} du langage machine. Par exemple, les séquences
PPPA, AAPPAA, APPAPPAAAA peuvent êtres des mots dans le langages machines
(comme ils peuvent ne pas l’être).
— Chaque mot fasse partie du vocabulaire (ou, dictionnaire) du langage machine.
Autrement dit, il faudra que ce mot aie un sens interprétable par la machine.
Prenons un exemple de la langue française : le mot ”ghjgy” contient des lettres
françaises (il vérifie la première condition) mais il n’appartient pas à la langue
française vu qu’il ne fait pas partie du vocabulaire français.
— Il faudra que la commande elle même aie un sens pour la machine. Si on reprend
l’exemple de la langue française, une phrase comme ”sont fleur il chaise cela”
vérifie les deux premières conditions mais pas la troisième car ses mots sont
correctes mais la phrase elle même n’a pas de sens.

Si l’absence du courant représente une lettre de l’alphabet de la machine, comment

une machine fera la différence entre, par exemple, le mot AAAAP et AAP ?

Afin de répondre à cette question, on va considérer un exemple pratique mais ultra

simplifié. Supposant que j’utilise le clavier de l’ordinateur pour saisir du texte dans un
éditeur de texte (comme Microsoft Word). Je choisis de taper la lettre ”b”. Ce qu’il faut
savoir est que l’ordinateur dispose de :

1. Un horloge interne qui compte les unités du temps.

2. Une information sur la taille (qui doit être fixe) d’un mot de son langage. Dans
l’exemple courant, on va supposer que la taille de chaque mot est fixée à 8.

5
3. Une manière pour reconnaitre et exécuter les actions correspondantes aux signaux
électriques reçus.

Ayant ces capacités, ce qui va se passer au niveau de l’ordinateur suite à la saisie de

la lettre ”b” est le suivant :

— Le bouton du clavier que je vais frapper va envoyer un ensemble de signaux

électriques (des impulsions) en respectant le rythme suivant :APPAAAPA, c-à-d :

— La première unité du temps : pas de courant.

— Deuxième et troisième unité du temps : un courant qui passe.
— Quatrième, cinquième et sixième unité du temps : pas de courant.
— Septième unité du temps : un courant qui passe.
— Huitième (dernière) unité du temps : pas de courant.

— Après la huitième impulsion l’ordinateur arrête d’écouter le courant et passe à

l’exécution (comme il sait que la taille du mot est 8). Ces impulsions avec ce
rythme informent l’ordinateur qu’il exécute l’action d’affichage de la lettre ”b”
sur l’écran.

En effet, l’alphabet utilisé pour traduire la tension ou le passage du courant électrique

est {0, 1} et non pas {A, P }. On l’appelle le langage binaire où 0 représente l’absence
du courant, et 1 représente le passage du courant. En utilisant le langage binaire, la
lettre ”b” de l’exemple ce-dessus correspond à la séquence 01100010. La définition sui-
vante résume le concept du ”langage machine”.

Langage machine :
Représenté par le langage binaire {1, 0} où 0 exprime l’absence du courant et 1
exprime la présence du courant. C’est l’unique langage interprétable par la machine
d’une façon directe.

1.2 Langages de programmation

Comme illustré dans la section 1.1, une machine ne parle et ne comprend que du
langage machine (représenté par le langage binaire). Donc si on veux commander à la
machine de faire quelque chose il faudra communiquer notre commande sous forme de
signaux électriques ce qui ressemble en langage machine à :

6
101010101011010101010010101011001011011101011111001111111111
101010110110010110111010111110011110110111010111110011111111
101010101011010101101100101101011011101111010101010110101101
001011011101011111001111011011101011111001011111111110000001
...

Avez-vous comprit quelque chose ? Moi non plus ! Dans le but de résoudre ce problème,
des gens ont pris la peine de réaliser des logiciels qui traduisent vos commandes, écrites
dans un langage ”plus naturel” que le langage machine, en un langage machine. Le lan-
gage ”plus naturel” que vous allez utiliser est bien un langage de programmation tel
que : Pascal, C++, Python, Java, Matlab, etc.

Les langages de programmation sont très proches du langage humain mais chacun de
ces langages a sa propre syntaxe qui doit être respectée. Par exemple, si on veut com-
mander à l’ordinateur d’afficher le message ”Bonjour” sur l’écran en utilisant le langage
de programmation Pascal. Cette demande s’exprime alors comme suite :

write (’Bonjour’);

Lorsqu’on utilise un autre langage tel que Python, il faudra écrire :

print("Bonjour");

Encore un exemple en Java :

System.out.print("Bonjour");

Langage de programmation :
Un langage plutôt proche du langage humain que du langage machine. Utilisé pour
écrire des programmes informatique.

Programme :
Un ensemble de commandes écrites dans un langage de programmation, et qui
servent à résoudre un problème donné.

7
Il existe tellement de langage de programmation de différentes catégories et objectifs,
mais la classification la plus connue est celle qui les divise en deux catégories :

1. Langages de bas niveau (d’assemblage) : ceux sont des langages avec un

très faible niveau d’abstraction ce qui permet une programmation très avancée
(détaillée en terme d’instructions) mais très difficile. Généralement, ces langages
sont orientés ”machine” vu qu’ils tiennent compte des caractéristiques physiques
du matériel utilisé. D’ailleurs, les électroniciens utilise ce genre de langages pour
programmer les processeurs.
2. Langages de haut niveau : ceux sont les langages souvent utilisés par les
informaticiens. Ces langages sont orientés ”problème” donc ils sont indépendants
des caractéristiques physiques de la machine grâce à leur niveau d’abstraction
très élevé.

1.3 Algorithmique
Devenir un bon maı̂tre de la machine nécessite de passer par un processus d’ap-
prentissage de l’algorithmique. Dans cette phase, on apprend à rédiger les détails
des commandes à communiquer à la machine dans un langage plus ou moins naturel
(compréhensible par les humains). Le texte résultant est bien un algorithme. L’objectif
d’un algorithme est de structurer, formaliser et valider (logiquement) ces commandes
avant de passer à la programmation. Cela aide à minimiser les erreurs logiques dans la
solution proposée par le programmeur.

La procédure de résolution d’un problème peut être complexe comme elle peut se
restreindre à une simple tâche. Cependant, apprendre une simple procédure à un être
non intelligent est un véritable problème. Ceci dit d’aller dans les détails très profonds
de la procédure vu que l’apprenant (la machine) est un appareil d’exécution qui est in-
capable de réfléchir, raisonner, imaginer ou improviser afin qu’il remplisse les trous de la
procédure. D’ailleurs, l’un des objectifs principaux de la science d’algorithmique est de
signaler le niveau d’ignorance de la machine aux maitres (programmeurs). Dans ce but,
un ensemble de règles, conventions et structures ont été mis afin de cerner la description
d’un algorithme. Voici en une seule définition l’essentiel à retenir :

Algorithme :
Un ensemble d’étapes qui servent à résoudre un problème donné. La description
de l’algorithme utilise un langage naturel (français, anglais, etc.) en respectant un
ensemble de règles propres à l’algorithmique.

8
En tête de liste des règles d’algorithmique la règle suivante qui décrit la forme globale
qu’un algorithme devra respecter :

Algorithme <nomDeAlgorithme> :

<Instruction 1> ;
<Instruction 2> ;
<Instruction 3> ;
...

Fin

Notons que :
— Les mots en gras sont des mots clés ou bien des mots réservés. On n’a pas le
droit de modifier ou de supprimer un mot clé, ni de changer sa position. En contre
partie, ce qui est entre ”<>” est à définir par le concepteur de l’algorithme.
— Le mot clé Algorithme suivi du nom de l’algorithme constitue l’entête de l’al-
gorithme.
— Une instruction représente une étape élémentaire de l’algorithme et elle se ter-
mine obligatoirement par un point-virgule (”;”).
— Les mots clés Début et Fin marquent respectivement le début et la fin de l’algo-
rithme.
— Dans tous ce qui suit, on met entre ”< ... >” les éléments variables de l’algo-
rithme. Un élément variable est à définir par le concepteur de l’algorithme selon
ses besoins. Bien évidemment, les symboles ”<” et ”>” sont à enlever lorsqu’un
algorithme effectif est décrit. Regardons l’exemple de l’algorithme 1.3 qui décrit
en cinq étapes les tâche matinales d’un employé :

Algorithme queFaireLaMatinée :

Se réveiller à 8h du matin ;
Prendre une douche ;
Prendre un petit déjeuner ;
Consulter la météo sur Internet ;
Aller au travail ;

Fin

9
Recommandations pour le nom de l’algorithme :
1. Utiliser un nom qui reflète le contenu de l’algorithme.
2. Écrire en minuscule (sauf exception).
3. Si le nom de l’algorithme contient plus qu’un mot, se servir du majuscule
ou du blanc souligné ” ” en tant que séparateur (i.e. ne pas laisser d’espace
entre les mots).
4. Utiliser uniquement les caractères alphanumériques et le blanc souligné (pas
de symboles).

10
1.4 Découvrir Python

Python est un langage de programmation de haut niveau dont la première version

publique date de 1991. Il a été initié par le programmeur ”Guido van Rossum” en
s’inspirant d’un autre langage appelé ”ABC”. Actuellement, ce langage est apprécié par
les professionnels et les pédagogues grâce à ses multiples avantages. A ce stade, il est
inutile de détailler les avantages et les caractéristiques de Python car c’est difficile à
comprendre pour un débutant en programmation. Nous allons plutôt orienter nos efforts
vers la pratique en commençant par l’installation de Python.

1.4.1 Installer et utiliser Python

Dans tous ce qui suit, nous allons utiliser la version 3.5 de Python qui est, comme
toutes les versions de Python, disponible au téléchargement sur la page :

https://www.python.org/downloads/.

Une fois installé, deux raccourcis sont ajoutés à votre menu démarrer (sous Win-
dows). Le premier est appelé Python (command line) illustré dans la figure 1.1, et le
deuxième est bien IDLE (Python 3.5) illustré dans la figure 1.2. Pour faciliter les tâches,
veillez à créer un raccourci de l’application IDLE (Python GUI) sur votre bureau.

Figure 1.1 – Icône de l’application Py- Figure 1.2 – Icône de l’application

thon (command line) IDLE (Python 3.5)

Dans la suite de ce chapitre nous allons tout d’abord essayer Python en mode inter-
actif en suivant ces étapes :

1. Ouvrir l’IDLE de Python (figure 1.3).

2. Taper un code.
3. Appuyer sur la touche Entrée pour exécuter.

11
Figure 1.3 – L’application IDLE (python 3.5)

1.4.2 Opérations arithmétiques

Un premier pas vers la découverte de Python consiste à l’utiliser comme une ”cal-
culette”. Par exemple, en tapant 5 + 3 dans l’IDLE de Python et en appuyant sur la
touche Entrée, un 8 est immédiatement affiché.

1 >>> 5+3
2 8

Les exemples suivants montrent les différents opérateurs arithmétiques qui existent.

1 >>> 10/3
2 3.3333333333333335

1 >>> 10//3
2 3

1 >>> 10%3
2 1

1 >>> 2.5*2
2 5.0

12
1 >>> 2**3
2 8

Les exemples suivants illustrent le concept de priorité des opérateurs qui consiste à
identifier l’ordre dans lequel les calculs sont effectués au sein d’une expression arithmétique
contenant plusieurs opérateurs.

1 >>> (5+2)*2
2 14

1 >>> 5+2*2
2 9

1 >>> 5+5%2
2 6

1 >>> 5*5%2
2 1

La table 1.1 récapitule et trie l’ensemble des opérateurs arithmétiques en Python

selon leurs priorités. Notez que si deux opérateurs ou plus sont de même priorité, alors
la priorité est évaluée de gauche à droite.

Opérateur Rôle Priorité

() 1
* Multiplication 2
/ Division 2
// Division entière 2
** Puissance 2
% Reste de division entière (modulo) 3
+ Addition 4
- Soustraction 4

Table 1.1 – Table des opérateurs arithmétiques et leurs priorités

13
1.4.3 Instruction d’écriture (print)

Instruction d’écriture :
L’instruction d’écriture consiste à afficher un message sur l’écran de l’ordinateur.

— Notation algorithmique −→ écrire ("<le message à afficher>");

— Notation Python −→ print ("<le message à afficher>");

Remarques :
— En python, le message à afficher peut être délimité soit par un simple, double
ou un triple quote.
— Dans certains cas -qui vont être détaillés plus loin dans ce cours- l’utilisation
du triple quote est obligatoire.

Commençons par un petit exemple :

écrire (”comment allez-vous ?”) ;

1 >>> print (’comment allez-vous ?’)

2 comment allez-vous ?

Observez les exemples suivants et remarquez l’effet de l’absence d’un quote lorsque
le message à afficher contient des opérations arithmétiques :

écrire (3+5) ;

1 >>> print (5+3)

2 8

écrire (”le résultat de 5+3 est ”,3+5) ;

1 >>> print ("le résultat de 5+3 est ", 5+3)

2 le résultat de 5+3 est 8

écrire (5-3, ”est égale à”, 1+1) ;

14
1 >>> print (5-3, ’est égale à’, 1+1)
2 2 est égale à 2

écrire (5-3, ”est égale à 1+1”) ;

1 >>> print (5-3, ’est égale à 1+1’)

2 2 est égale à 1+1

écrire (5-3,”\n est égale \n à 1+1”) ;

1 >>> print (5-3,"""\n est égale\n à 1+1""")

2 2
3 est égale
4 à 1+1

écrire (”est\t égale\t à”) ;

1 >>> print (’est\t égale\t à’)

2 est égale à

Remarquez que dans certains exemples le message à afficher est délimité par un
simple quote, alors que d’autres il est délimité par un double ou un triple quote.

La table 1.2 reprend les principales séquences d’échappement disponibles en Python.

1.4.4 Les commentaires

Le commentaire :
Un commentaire est un texte qui est ignoré par le compilateur (il n’est pas exécuté).
— Notation algorithmique −→ /∗ <le message à afficher> ∗/
— Notation Python −→ # <le message à afficher>

15
Séquence Description
\\ Backslash
\’ Guillemet simple (apostrophe)
\” Guillemet double
\n Saut de ligne
\t Tabulation horizontale

Table 1.2 – Séquences d’échappement en Python

Toute ligne du code pourra être commentée afin de faciliter sa compréhension vis-
à-vis le lecteur du programme ou même son codeur. Ci-dessous deux exemples d’une
instruction commentée, en notation algorithmique puis en notation Python, suivie par
l’exécution correspondante en Python.

écrire (”Good morning”) ; /∗ Ceci est un message de bonjour en anglais ∗/

1 >>> print("Good morning") #Ceci est un message de bonjour en anglais

2 Good morning

1.5 Écrire des algorithmes et des programmes Python

En arrivant à cette partie du cours, nous avons entre nos mains tous les moyens
nécessaires pour établir des algorithmes et des programmes, malgré simples, mais qui
font un sens.

Prenons l’exemple de l’algorithme 1 qui affiche un message de ”Bonjour” en trois

langues.

Algorithme bonjourTroisLangues :

écrire(”Bonjour”) ;
écrire(”Good morning”) ; //Ceci est un bonjour en anglais
écrire(”Buongiorno”) ; /∗ Ceci est un bonjour en italien ∗/

Fin

Algorithme 1: Un ”Bonjour” en trois langues

16
Rédiger un programme Python contenant plus qu’une ligne de code nécessite le pas-
sage du mode interactif vers le mode batch. Le mode batch signifie le traitement par
lot où un ensemble d’instructions sont compilées ensemble. Pour passer en mode batch
il faudra suivre les étapes suivantes :

1. Taper le code Python dans un fichier que l’on enregistre sous l’extension ”.py”.
2. On lance la compilation en appuyant sur la touche F5 du clavier.
3. Si le code contient des anomalies, un message d’erreur est affiché, sinon l’exécution
correspondante au code est affichée sur l’IDLE.

Prenons l’exemple du programme Python traduisant l’algorithme 1 suivi par son

exécution correspondante.

1 print (’Bonjour’)
2 print ("Good morning") # Ceci est un bonjour en anglais
3 print ("""Buongiorno""") # Ceci est un bonjour en italien

Programme 1: Un ”Bonjour en trois langues

1 Résultat d’exécution du programme 1

1 Bonjour
2 Good morning
3 Buongiorno

Recommandations pour l’écriture d’un algorithme :

1. Utilisez une écriture rigoureuse.
2. Respectez l’indentation.
3. N’hésitez pas à commenter vos instructions pour que votre algorithme soit
plus compréhensible.
4. Enrichissez l’interactivité de votre algorithme à travers l’affichage des mes-
sages d’informations.

17
Chapitre 2

Les variables

Variable :
Une variable est une donnée qui est enregistrée dans un espace mémoire de la
machine. Une variable est caractérisée par :
1. Un nom alphanumérique (e.g. x, y, var, a1, etc.), représente ainsi le nom
de l’espace mémoire réservé pour la variable.
2. Un type (e.g. entier, réel, chaine de caractères, etc.).
3. Une valeur (e.g. 5, 12.33, ”abc”, etc.).

Généralement, le concept de variable est schématiquement représenté sous forme de

’boite’ dans laquelle on sauvegarde une valeur, comme illustré dans la figure 2.1.

5 Valeur de la variable (de type 'entier')

Espace mémoire réservé pour la variable

X Nom de la variable (nom de l'espace mémoire)

Figure 2.1 – Les composants d’une variable

Le nom d’une variable doit respecter quelques règles de syntaxe incontournables :

— Le nom de la variable ne peut être composé que de lettres, majuscules ou minus-

cules, de chiffres et du symbole souligné ” ”.
— L’espace, le trait d’union , l’apostrophe, les accents et les cédilles ne sont pas
autorisés.
— Le nom de la variable doit commencer par une lettre.
— Majuscules et minuscules sont considérées comme des caractères distincts (e.g.
les noms ”Var”, ”var”, ”VAR” et ”vAr” sont des noms différents).
— Enfin, le nom d’une variable ne doit pas se figurer sur la liste des 33 mots réservés
de Python (table 2.1) :

18
and del from none true as elif
global nonlocal try assert else if not
while break except import or with continue
class false in pass yield finally is
for lambda return raise def

Table 2.1 – Liste des mots réservés en Python

Recommandations pour le nom de la variable :

Mis à part les règles syntaxiques, et par convention, il est préférable d’avoir un
nom de variable qui soit :
1. Significatif : il reflète le contenu de la variable (ex. ”resultat” ou ”res”
pour une variable qui contient une addition, ”stock” pour une variable qui
contient la quantité en stock).
2. Lisible : en utilisant le minuscule par défaut, puis le majuscule ou le blanc
souligné pour la séparation ou la distinction des mots au sein d’un même
nom de variable (ex. resultatAddition, max stock).

2.1 Affectation simple, multiple et parallèle

L’affectation :
L’instruction d’affectation consiste à donner une valeur à une variable.

— Notation algorithmique −→ <le nom de variable>←<valeur>;

— Notation Python −→ <le nom de variable>=<valeur>;

Prenons l’exemple illustré dans la figure 2.3 où nous affectons la valeur 5 à la variable
nommée x. En algorithmique c’est équivalent à écrire :

x ← 5;

En python :

1 >>> x=5

19
5
x
Figure 2.2 – Affectation de la valeur 5 à la variable x

Sous l’IDLE de Python, il suffit de taper le nom de la variable suivie par la touche
Entrée du clavier pour afficher son contenu (sa valeur).

1 >>> x
2 5

Il est recommandé de s’habituer à prononcer correctement l’instruction d’affecta-

tion en disant ”a reçoit 10” et non pas ”a est égale à 10” (pour l’instruction a = 10).
L’expression ”est égal à” sera utilisée dans un autre contexte qui sera détaillé plus
loin dans ce cours.

Lorsqu’une seule valeur est affectée à une seule variable, on parle alors de l’affectation
simple. Sous Python, il existe d’autres types d’affectation dont le rôle est de regrouper
plusieurs instructions d’affectation en une seule, il s’agit de :

1. l’affectation parallèle : plusieurs valeurs sont affectées à plusieurs variables en

utilisant un seul opérateur d’affectation ”=”.

1 >>> x,y,z=3,4,10
2 >>> x
3 3
4 >>> y
5 4
6 >>> z
7 10

2. l’affectation multiple : plusieurs variables recevront une même valeur dans une
même instruction.

20
1 >>> x=y=z=5
2 >>> x
3 5
4 >>> y
5 5
6 >>> z
7 5

2.2 Types de données

Comme déjà expliqué, une variable est caractérisée par un type (entier, réel, chaine de
caractères, etc.). En informatique, l’information sur le type de la données est nécessaire
pour deux raisons :

— Identifier et contrôler l’ensemble des opérations autorisées pour chaque type de

donnée. Par exemple, l’opération de division est permise pour les entiers mais elle
ne l’est pas pour les chaines de caractères.
— Bien gérer l’espace mémoire de la machine en réservant un espace minimal mais
certainement suffisant pour chaque type de données.

En python, il existe 23 types de données dont la liste complète est présentée dans
l’annexe A. À ce stade, nous focalisons sur les types listés dans la table 2.2.

Code du type Description

int Entier compris entre -2 147 483 648 et 2 147 483 647 (codage
sur 32 bits soit 4 octets)
float Un nombre réel où le point est utilisé à la place de la virgule
(e.g. 67.5, 8, 45355.7868767, etc.)
bool Uniquement deux valeurs sont possibles pour ce type : True
ou False
str Suite ordonnée de caractères (e.g. ”abc”, ”je suis étudiant !”,
” ?h ? !”, etc.)

Table 2.2 – Quelques types de données intéressants

Observez l’algorithme 2 qui affiche un ensemble d’informations concernant le jour

actuel (le moment où cet algorithme est établi).

21
Algorithme descriptionJourActuel :

jour ← 2 ;
mois ← 8 ;
annee ← 2016 ;
temperature ← 31.7 ;
pluie ← False ;
phrase1 ← ”Aujourd’hui est le ” ;
phrase2 ← ”La température à ce moment est ” ;
écrire (phrase1,jour,”/”, mois, ”/”, annee) ;
écrire (phrase2, temperature) ;
écrire (”La pluie tombe =”, pluie) ;

Fin

Algorithme 2: Description du jour actuel (date, température, pluie)

Le programme Python correspondant à l’algorithme 2 est présenté ci-dessous ainsi

que le résultat de son exécution.

1 jour=2
2 mois=8
3 annee=2016
4 temperature=31.7
5 pluie=False
6 phrase1="Aujourd’hui est le "
7 phrase2="La température à ce moment est "
8 print (phrase1,jour,"/", mois, "/", annee)
9 print (phrase2, temperature)
10 print ("La pluie tombe =", pluie)

Programme 2: Description du jour actuel (date, température, pluie)

2 Résultat d’exécution du programme 2

1 Aujourd’hui est le 2 / 8 / 2016

2 La température à ce moment est 31.7
3 La pluie tombe = False

22
2.3 Le typage dynamique en Python
La plupart des langage de programmation utilisent ce qu’on appelle un typage sta-
tique. Cela dit que :

— Pour toute variable utilisée dans le programme, il faudra d’abord déclarer son
type avant de lui affecter une valeur.
— Une fois le type de la variable est précisé, on n’est pas autorisé à le changer au
cours le programme (une variable préserve le même type dans tout le programme).

En revanche, Python utilise un typage dynamique où :

— Le type de la variable est automatiquement détecté une fois on lui affecte une
valeur (on n’a pas besoin de déclarer le type au préalable). De ce fait, Python est
capable d’afficher le type de la variable dont la valeur est connu. Cela se fait à
travers la fonction type() comme dans les exemples qui suivent :

1 >>> x=-2
2 >>> y=4.5
3 >>> b=True
4 >>> msg=’Ceci est un texte’
5 >>> type(x)
6 <class ’int’>
7 >>> type(y)
8 <class ’float’>
9 >>> type(x+y)
10 <class ’float’>
11 >>> type(b)
12 <class ’bool’>
13 >>> type(msg)
14 <class ’str’>

— Une nouvelle affectation dans le programme changera automatiquement le type de

la variable (donc, une variable pourra changer son type au cours du programme),
comme dans l’exemple suivant :

1 >>> x=5
2 >>> type(x)
3 <class ’int’>
4 >>> x=’Ceci est un texte’
5 >>> type(x)
6 <class ’str’>

23
2.4 Instruction de lecture (input())

Opération de lecture :
L’instruction de lecture consiste à faire passer une donnée au programme (au cours
de son exécution) à travers un appareil d’entrée tel que le clavier.

— Notation algorithmique −→ lire(<le nom de la donnée à lire>);

— Notation Python −→ <le nom de la donnée à lire>=input(<un
message à afficher>);

Remarques :
— En python, le message à afficher peut éventuellement être vide.
— En algorithmique, si on veut anticiper la lecture de la donnée par un mes-
sage d’information, on place une opération l’écriture écrire() juste avant
l’opération de lecture.
— L’utilisateur devra appuyer sur la touche Entrée une fois la saisie de la
donnée est terminée.

Voici un exemple algorithmique d’un petit traitement de lecture d’une variable x,

suivi par son équivalent en Python :

écrire(”Veuillez saisir la valeur de la variable x”) ;

lire(x) ; //Le message est affiché juste avant la lecture

1 x=input("Veuillez saisir la valeur de la variable x") # Le message est

֒→ affiché juste avant la lecture

Il est fortement recommandé d’afficher un message d’information avant toute saisie

afin que l’utilisateur reconnaisse facilement les moments où son intervention dans
l’exécution du programme est nécessaire. Ainsi, il est souhaitable que le message
d’information précise le type de la donnée à saisir afin d’éviter les erreurs de saisie.

On va conclure ce chapitre avec un exemple plus concret illustrant l’utilité de l’ins-

truction d’écriture (Algorithme 3). L’idée consiste à modifier l’algorithme 2 pour que
les données du jour actuel (date, température, pluie) viennent de la part de l’utilisateur
lorsque l’exécution du programme est lancée.

24
Algorithme saisieDescriptionJourActuel :

lire(jour) ;
lire(mois) ;
lire(annee) ;
lire(temperature) ;
lire(pluie) ;
phrase1 ← ”Aujourd’hui est le ” ;
phrase2 ← ”La température à ce moment est ” ;
écrire (phrase1, jour,”/”, mois, ”/”, annee) ;
écrire (phrase2, temperature) ;
écrire (”La pluie tombe =”, pluie) ;

Fin

Algorithme 3: Saisie de la description du jour actuel (date, température, pluie)

Le programme Python correspondant à l’algorithme 3 ainsi que son le résultat de

son exécution sont listés ci-dessous.

1 jour=input()
2 mois=input()
3 annee=input()
4 temperature=input()
5 pluie=input()
6 phrase1="Aujourd’hui est le "
7 phrase2="La température à ce moment est "
8 print (phrase1, jour,"/", mois, "/", annee)
9 print (phrase2, temperature)
10 print ("La pluie tombe =", pluie)

Programme 3: Saisie de la description du jour actuel (date, température, pluie)

25
3 Résultat d’exécution du programme 3

1 4
2 8
3 2016
4 35.6
5 False
6 Aujourd’hui est le 4 / 8 / 2016
7 La température à ce moment est 35.6
8 La pluie tombe = False

2.5 Conversion des types

Conversion des types :

Convertir le type d’une variable consiste à forcer le changement de son type en un
autre.
— Notation algorithmique −→
<nom de variable>←<nom du nouveau type>(<nom de variable>);
— Notation Python −→
<nom de variable>=<nom du nouveau type>(<nom de variable>);

Remarque : Bien évidemment, certaines conversions ne peuvent pas se produire.

Par exemple, tout entier pourra être converti en une chaine de caractères, mais
l’inverse n’est pas toujours possible.

Dans l’exemple suivant, nous affectons à la variable x une valeur réelle, puis nous
changeons son types trois fois (lignes 4, 7 et 10). Après chaque conversion, nous ré-
affichons le contenu de x afin de vérifier les différents changement que la valeur de x a
subi.

1 >>> x=87.7654 #affectation d’une valeur réelle à x

2 >>> type(x) #s’assurer que x est de type "float"
3 <class ’float’>
4 >>> x=str(x) #conversion depuis "float" vers "str"
5 >>> x #Ré-affichage du contenu de x
6 ’87.7654’
7 >>> x=float(x) #conversion depuis "str" vers "float"
8 >>> x
9 87.7654
10 >>> x=int(x) #conversion depuis "float" vers "int"

26
11 >>> x
12 87

Encore un exemple où la conversion ne marche pas :

Figure 2.3 – Une conversion de type produisant un message d’erreur

Notez que la conversion des types est souvent nécessaire après une opération de
lecture d’une donnée (input()). En effet, la donnée renvoyée suite à l’opération de
lecture est par défaut de type str. Si le programmeur souhaite qu’elle soit de type
différent alors il n’a qu’à convertir son type juste après la lecture. Observez l’exemple
suivant :

écrire(”Entrez une valeur entière : ”) ;

écrire (”Le type de la donnée saisie par l’utilisateur est : ”, type(x)) ;
x←int(x) ;
écrire (”Le type de la donnée après la conversion est : ”, type(x)) ;

1 x=input("Entrez une valeur entière : ")

2 print ("Le type de la donnée saisie par l’utilisateur est : ",
֒→ type(x))
3 x=int(x)
4 print ("Le type de la donnée après la conversion est : ", type(x))

1 Entrez une valeur entière : 67

2 Le type de la donnée saisie par l’utilisateur est : <class ’str’>
3 Le type de la donnée après la conversion est : <class ’int’>

27
Chapitre 3

Les structures conditionnelles

3.1 Comparaisons simples

Comparaison simple :
C’est une évaluation d’une expression logique simple à uniquement deux opérandes
et un seul opérateur de comparaison. Bien évidemment, le résultat d’une
évaluation logique est soit ”vrai” ou ”faux”. Par exemple, ”2 > 7” est une ex-
pression logique simple telle que :

— Opérandes −→ ”2” et ”7”

— Opérateur de comparaison −→ ”>”
— Évaluation −→ ”faux” (parce que ”2” n’est pas supérieur à ”7”).

Sous l’IDLE de Python, il est possible d’avoir directement le résultat d’une compa-
raison juste en tapant l’expression et en appuyant sur la touche Entrée. Python renvoie
la valeur True si la comparaison est vraie et False si elle est fausse.

1 >>> 1>5
2 False
3 >>> 1<5
4 True

Ainsi, un enchainement de comparaisons est possible en Python :

1 >>> 5>3<6
2 True
3 >>> 5==5<3
4 False

28
Une opérande peut s’agir d’une valeur comme il peut s’agir d’une variable. Observez
les deux exemples suivants :

1 >>> x=20 #Ceci est une affectation

2 >>> x>5 #Ceci est une comparaison
3 True

1 >>> x=20 #Ceci est une affectation

2 >>> y=5 #Ceci est une affectation
3 >>> x<y #Ceci est une comparaison
4 False

La liste complète des opérateurs de comparaison en Python est présentée dans la

table 3.1 :

Symbol Signification
== égal à
!= différent de
> supérieur à
≥ supérieur ou égal à
< inférieur à
≤ inférieur ou égal à
is représente le même objet
is not ne représente pas le même objet

Table 3.1 – Les opérateurs de comparaison en Python

Faites bien attention à ne pas confondre l’opérateur d’affectation ”=” qui donne
une valeur à une variable et l’opérateur de comparaison ”==” qui vérifie l’égalité
entre les valeurs de deux variables.

Voici quelques exemples de comparaisons simples qui ont été testés sous l’IDLE de
Python.

29
1 >>> x=5 #Ceci est une affectation
2 >>> x==6 #Ceci est une comparaison
3 False
4 >>> x==5
5 True
6 >>> x!=5
7 False
8 >>> x>1
9 True
10 >>> x<1
11 False
12 >>> y=x #On donne à la variable "y" la m^
eme valeur que "x"
13 >>> x is y
14 True
15 >>> z=10
16 >>> y is z
17 False

Vous pouvez également effectuer des comparaisons sur des chaı̂nes de caractères.

1 >>> c="je suis ici"

2 >>> c=="hh"
3 False
4 >>> c!="hh"
5 True

Lorsqu’on utilise les opérateurs <, >, ≤ et ≥ pour comparer les chaines de caractères,
l’ordre alphabétique est pris en compte. Dans la première ligne de l’exemple ci-dessous,
la position du caractère ”b” (2) dans l’alphabet est supérieure à la position du caractère
”a” (1), donc ”b” est considéré supérieur à ”a”. Cette règle est valable pour les caractères
spéciaux (dont on ne connait pas la position généralement) :

1 >>> "a">"b"
2 False
3 >>> "a"<"b"<"c"<"d"
4 True
5 >>> "+">"-"
6 False
7 >>> "&">"#"
8 True

30
En comparant des chaı̂nes à plus d’un caractère, Python procède comme suite :

— Il compare caractère par caractère, de la gauche vers la droite (le premier avec le
premier, le deuxième avec le deuxième, etc.).
— Tant qu’il trouve les même caractères dans les deux chaines, il les ignore et il
avance jusqu’à ce qu’il trouve le premier caractère différent.
— La comparaison est donc basée sur ce premier caractère différent.

Observez l’exemple suivant (ligne 1) où les deux chaines comparées partagent les trois
premiers caractère (”a”, ”b” et ”c”). Ces caractères seront donc ignorés et la comparaison
sera basée sur le quatrième caractère. Il se trouve que le quatrième caractère dans la
première chaine (”w”) est supérieur au quatrième caractère dans la deuxième chaine
(”d”), ce qui explique le résultat de cette comparaison.

1 >>> "abcw"<"abcd"
2 False
3 >>> "abc"<"abcd"
4 True
5 >>> "je"<"je suis"<"je suis étudiant"
6 True

Notez aussi que l’existence de la relation d’inclusion entre deux chaines comparées
signifie que la plus petite (en longueur) est inférieure à la plus grande en terme de
comparaison (lignes 3 à 6 de l’exemple en dessus).

3.2 Comparaisons multiples

Comparaison multiple :
C’est une évaluation logique qui combine les résultats de plusieurs évaluations
simples (comparaisons simples) à travers les opérateurs logiques (et, ou, non),
puis elle renvoie un seul résultat final. Par exemple, ”(2 > 7) et (7 > 10)” est une
expression logique à comparaisons multiples telle que :

— Évaluations simples −→ ”2 > 7”, ”7 > 10”

— Opérateur logique −→ ”et”
— Évaluation finale −→ ”faux” (car 2 est supérieur à 7 mais 7 n’est pas
supérieur à 10).

31
Remarque : L’opérateur logique ”non” utilise une seule opérande. Il précède
une expression logique et renvoie l’opposition de son évaluation.

En Python, on utilise le mot réservé and pour l’opérateur ”et”, or pour l’opérateur
”ou”, et not pour l’opérateur ”non”. Respectez bien la casse ; and, or et not s’écrivent
en minuscule. Voici quelques exemples primaires :

1 >>> (4==3 and 3>2)or(3==3)

2 True
3 >>> (4==3) and (3>2 or 3==3)
4 False
5 >>> 4==3 and 3>2 or 3==3
6 True
7 >>> 4!=3 and 3>2 and 3==3
8 False
9 >>> not True
10 False
11 >>> not (5==5)
12 False
13 >>> 5==5 and not 5>3
14 False

Remarquez que la priorité est donnée aux parenthèses, sinon l’évaluation va de gauche
à droite. La table 3.2 rappelle le mode de fonctionnement des opérateurs logiques and et
or :

Expression 1 Opérateur Expression 2 Résultat

True or True True
True or False True
False or True True
False or False False
True and True True
True and False False
False and True False
False and False False

Table 3.2 – Fonctionnement des opérateurs logiques (table de vérité)

Notez qu’en Python, on a la possibilité de tester directement l’effet des opérateurs

logiques comme dans les exemples suivants :

32
1 >>> True or False
2 True
3 >>> True or False and True
4 True
5 >>> not True
6 False
7 >>> not (True and False) or (False and False)
8 True
9 >>> not (True or False) and not True
10 False

3.3 Structure Si...Alors

Si...Alors
C’est un traitement qui consiste à exécuter une ou plusieurs instructions dans le cas
où une expression logique donnée (condition) est évaluée à ’vrai’. Si la condition
en question est fausse alors les instructions concernées ne sont pas exécutées.

Notation algorithmique : Notation Python :

Si (<condition>) Alors if (<condition>) :

<instruction 1> ; <instruction 1>
<instruction 2> ; <instruction 2>
... ...
<instruction n> ; <instruction n>
Fin Si

Remarques :
— L’instruction if se termine par le caractère ” :”.
— Contrairement à la notation algorithmique, mettre l’expression à évaluer
entre parenthèses n’est pas obligatoire en Python.
— Les instructions à exécuter si la condition est frai doivent forcément être
indentées.

Ci-dessous un exemple d’une structure ”si...alors” en utilisant la notation algo-

rithmique, la notation Python ainsi que l’exécution correspondante au code Python.

33
Si (1<5) Alors
écrire(”La première instruction a été exécutée”) ;
écrire(”La deuxième instruction a été exécutée”) ;
écrire(”La troisième instruction a été exécutée”) ;
Fin Si

1 if 1<5:
2 print("La première instruction a été exécutée")
3 print("La deuxième instruction a été exécutée")
4 print("La troisième instruction a été exécutée")

1 La première instruction a été exécutée

2 La deuxième instruction a été exécutée
3 La troisième instruction a été exécutée

Encore un exemple où la condition revient à une évaluation multiple :

Si (1<5 ET (10>20 OU 10≤ 5)) Alors

écrire (”Cette instruction est exécutée”) ;
Fin Si

1 if 1<5 and (10>20 or 10<=5):

2 print("Cette instruction est exécutée")

Notez que l’exécution de l’exemple ci-dessus ne retourne aucun résultat vu que l’ex-
pression logique est évaluée à faux.

Prenons un exemple plus concret et qui consiste à réaliser un petit programme de

reconnaissance des principaux opérateurs arithmétiques (+, -, / ou *). Au lancement
du programme, l’utilisateur est appelé à saisir un opérateur arithmétique alors que le
programme devra reconnaitre l’opérateur saisi et prouver sa reconnaissance à travers un
message affiché à l’écran. Dans le cas où le caractère saisi par l’utilisateur ne correspond
à aucun opérateur arithmétique, le programme devra afficher un message d’erreur.

34
Algorithme reconnaissanceOperateurArithmetique :

écrire(”Veuillez entrer une opération arithmétique (+,-,/,*) : ”) ;

lire(operateur) ;
Si (operation==”+”) Alors
écrire(”Une opération d’addition”) ;
Fin Si
Si (operation==”-”) Alors
écrire(”Une opération de soustraction”) ;
Fin Si
Si (operation==”/”) Alors
écrire(”Une opération de division”) ;
Fin Si
Si (operation==”*”) Alors
écrire(”Une opération de multiplication”) ;
Fin Si
Si (operation !=”+” ET operation !=”-” ET operation !=”/” ET opera-
tion !=”*”) Alors
écrire(”Erreur ! Ceci ce n’est pas une opération arithmétique.”) ;
Fin Si

Fin

Algorithme 4: Reconnaissance d’un opérateur arithmétique

1 operation=input("Veuillez entrer une opération arithmétique (+,-,/,*)

֒→ : ")
2 if(operation=="+"):
3 print("Une opération d’addition")
4 if(operation=="-"):
5 print("Une opération de soustraction")
6 if(operation=="/"):
7 print("Une opération de division")
8 if(operation=="*"):
9 print("Une opération de multiplication")
10 if(operation!="+" and operation!="-" and operation!="/" and
֒→ operation!="*"):
11 print("Erreur! Ceci ce n’est pas une opération arithmétique.")

Programme 4: Reconnaissance d’un opérateur arithmétique

35
4 Résultats d’exécution du programme 4 (3 exécutions)

1 Veuillez entrer une opération arithmétique (+,-,/,*) : -

2 Une opération de soustraction

1 Veuillez entrer une opération arithmétique (+,-,/,) :

2 Une opération de multiplication

1 Veuillez entrer une opération arithmétique (+,-,/,*) : a

2 Erreur! Ceci ce n’est pas une opération arithmétique.

3.4 Structure Si...Alors...Sinon

Si...Alors...Sinon
C’est un traitement qui consiste à exécuter une ou plusieurs instructions dans le
cas où une condition donnée (expression logique) est évaluée à ’vrai’. Si la condition
en question est fausse alors un ensemble d’instructions alternatif est exécuté.

Notation algorithmique : Notation Python :

Si (<condition>) Alors if (<condition>) :

<instruction 1> ; <instruction 1>
<instruction 2> ; <instruction 2>
... ...
<instruction n> ; <instruction n>
Sinon else :
<instruction 1> ; <instruction 1>
<instruction 2> ; <instruction 2>
... ...
<instruction n> ; <instruction n>
Fin Si

Dans l’exemple ci-dessous, la condition ”2 > 5” n’est pas vérifiée (elle renvoie ”faux”).
Cela a fait que l’instruction en porté du ”Si” a été ignorée alors que l’instruction en
porté du ”Sinon” a été exécutée.

36
Si (2 > 5) Alors
écrire(”La première instruction est exécutée”) ;
Sinon
écrire(”La deuxième instruction est exécutée”) ;
Fin Si

1 if 2>5:
2 print("La première instruction est exécutée")
3 else:
4 print("La deuxième instruction est exécutée")

1 La deuxième instruction est exécutée

Notez que la structure ”Si...Alors...Sinon” peut être remplacée par deux struc-
tures Si...Alors séquentielles. L’exemple suivant est l’équivalent du précédent donc il
renvoie le même résultat d’exécution :

Si (2 > 5) Alors
écrire(”La première instruction est exécutée”) ;
Fin Si
Si ( ¬(2 > 5)) Alors
écrire(”La deuxième instruction est exécutée”) ;
Fin Si

1 if 2>5:
2 print("La première instruction est exécutée")
3 if not (2>5):
4 print("La deuxième instruction est exécutée")

1 La deuxième instruction est exécutée

Afin d’optimiser le code et éviter un test supplémentaire, il est recommandé d’éviter

de remplacer la structure ”Si...Alors...Sinon” par deux structure ”Si...Alors”

37
3.5 Structures Si...Alors...Sinon imbriquées

Structures Si...Alors...Sinon imbriquées

C’est une structure Si...Alors...Sinon dont le bloc d’instructions à la portée
de ”Sinon” contient une deuxième structure Si...Alors...Sinon. Cette dernière
à son tour pourra contenir une troisième structure Si...Alors...Sinon, et ainsi
de suite.

Notation algorithmique : Notation Python :

Si (<condition>) Alors if (<condition>) :

<instruction 1 1> ; <instruction 1 1>
<instruction 1 2> ; <instruction 1 2>
... ...
<instruction 1 n> ; <instruction 1 n>
Sinon elif (<condition>) :
Si (<condition>) Alors <instruction 2 1>
<instruction 2 1> ; <instruction 2 2>
<instruction 2 2> ; ...
... <instruction 2 n>
<instruction 2 n> ; elif (<condition>) :
Sinon ...
Si (<condition>) Alors
...
...
else :
...
Sinon <instruction n 1>
<instruction n 1> ; <instruction n 2>
<instruction n 2> ; ...
... <instruction n n>
<instruction n n> ;
Fin Si
Fin Si
Fin Si

Observez l’exemple suivant où la variable x est comparée à plusieurs valeurs. À

chaque comparaison il correspond un affichage différent des autres :

38
x ← 3 ; //On affecte 3 à x
Si (x==1) Alors
La variable x est égale à un”) ;
Sinon
Si (x==2) Alors
La variable x est égale à deux”) ;
Sinon
Si (x==3) Alors
La variable x est égale à trois”) ;
Sinon
Si (x==4) Alors
écrire(”La variable x est égale à quatre”) ;
Sinon
écrire(”La variable x est égale à cinq.”) ;
Fin Si
Fin Si
Fin Si
Fin Si

1 x=3
2 if x==1:
3 print("La variable x est égale à un")
4 elif x==2:
5 print("La variable x est égale à deux")
6 elif x==3:
7 print("La variable x est égale à trois")
8 elif x==4:
9 print("La variable x est égale à quatre")
10 else:
11 print("La variable x est égale à cinq")

1 La variable x est égale à trois

À la fin de ce chapitre, on va reprendre l’algorithme 4 et on va le modifier afin

de le rendre plus optimal. Cela consiste à remplacer les cinq structures ”Si...Alors”
existantes dans l’algorithme 4 par une seule structure de tests imbriqués. Notez que
le résultat d’exécution de ce nouveau programme (programme 5) est le même que le
programme 4.

39
Algorithme reconnaissanceOperateurArithmetique version2 :

écrire(”Veuillez entrer une opération arithmétique (+,-,/,*) : ”) ;

lire(operateur) ;
Si (operation==”+”) Alors
écrire(”Une opération d’addition”) ;
Sinon
Si (operation==”-”) Alors
écrire(”Une opération de soustraction”) ;
Sinon
Si (operation==”/”) Alors
écrire(”Une opération de division”) ;
Sinon
Si (operation==”*”) Alors
écrire(”Une opération de multiplication”) ;
Sinon
écrire(”Erreur ! Ceci ce n’est pas une opération
arithmétique.”) ;
Fin Si
Fin Si
Fin Si
Fin Si
Fin

Algorithme 5: Reconnaissance d’un opérateur arithmétique (version 2)

1 operation=input("Veuillez entrer une opération arithmétique (+,-,/,*)

֒→ : ")
2 if(operation=="+"):
3 print("Une opération d’addition")
4 elif(operation=="-"):
5 print("Une opération de soustraction")
6 elif(operation=="/"):
7 print("Une opération de division")
8 elif(operation=="*"):
9 print("Une opération de multiplication")
10 else:
11 print("Erreur! Ceci ce n’est pas une opération arithmétique.")

Programme 5: Reconnaissance d’un opérateur arithmétique (version 2)

40
Chapitre 4

Les structures répétitives

4.1 Fonction range

Fonction range :
C’est une fonction prédéfinie en Python et qui renvoie un intervalle d’entiers en
respectant l’une des syntaxes suivantes :

range (<début>, <fin>, <pas>)

range (<début>, <fin>) −→ Par défaut, pas=1.

range (<fin>) −→ Par défaut, pas=1 et début=0.

Remarque : La valeur de ”fin” n’est pas inclut dans l’intervalle.

Observez les exemples suivants :

Exemple range Intervalle résultant

range(1,5,1) [1,2,3,4]
range(1,5,2) [1,3]
range(0,5,2) [0,2,4]
range(1,5) [1,2,3,4]
range(5) [0,1,2,3,4]
range(5,1,1) []
range(5,1,-1) [5,4,3,2]
range(-5,5,2) [-5,-3,-1,1,3]
range(200,100,-20) [200,180,160,140,120]

41
4.2 Boucle ”Pour”

Boucle Pour :
C’est une structure qui permet de répéter l’exécution d’un bloc d’instructions (ap-
pelé, le corps de la boucle) un certain nombre de fois, fixé à l’entête de la boucle.
La boucle est quittée une fois le nombre d’itérations atteint sa limite.

Notation algorithmique : Notation Python :

Pour <variable> de <début> à for <variable> in <intervalle> :

<fin> faire <instruction 1>
<instruction 1> ; <instruction 2>
<instruction 2> ; ...
... <instruction n>
<instruction n> ;
Fin Pour

Remarques :
— En algorithmique, ”début” et ”fin” à l’entête de la boucle Pour doivent
être des valeurs entière.
— En python, ”intervalle” peut prendre différentes formes, allant d’un simple
intervalle de nombres entiers à une chaine de caractères.
— En python, un intervalle d’entiers est défini en utilisant la fonction range
préalablement définie dans la section 4.1.
— Bien évidemment, les instructions appartenant au corps de la boucle doivent
être indentées.

Nous commençons par un exemple simple où le corps de la boucle pour contient une
seule instruction :

Pour i de 0 à 4 faire
écrire(”La boucle est dans l’indice”,i) ;
Fin Pour

1 for i in range(5): # Ou range(0,5) ou range(0,5,1)

2 print("La boucle est dans l’indice",i)

L’exécution de cette instruction affiche le résultat suivant :

42
1 la boucle est dans l’indice 0
2 la boucle est dans l’indice 1
3 la boucle est dans l’indice 2
4 la boucle est dans l’indice 3
5 la boucle est dans l’indice 4

Notez que la fonction range peut tout simplement être remplacée par un intervalle
équivalent, comme dans l’exemple en bas qui renvoie exactement le même résultat que
le précédent (range(5)) :

1 for i in [0,1,2,3,4]:
2 print("La boucle est dans l’indice",i)

On peut même spécifier le nombre d’itérations à travers une chaine de caractères :

1 for i in "abcde":
2 print("La boucle est dans l’indice",i)

Ce qui va produire le résultat suivant :

1 La boucle est dans l’indice a

2 La boucle est dans l’indice b
3 La boucle est dans l’indice c
4 La boucle est dans l’indice d
5 La boucle est dans l’indice e

Prenons un exemple où le corps de la boucle pour contient deux instructions :

x←1 ;
Pour i de 0 à 4 faire
x←x*2 ;
écrire(”la valeur actuelle de x est”, x) ;
Fin Pour

43
1 x=1
2 for i in range(5):
3 x=x*2
4 print("la valeur actuelle de x est", x)

L’exécution de l’instruction ci-dessus affiche le résultat suivant :

1 la valeur actuelle de x est 2

2 la valeur actuelle de x est 4
3 la valeur actuelle de x est 8
4 la valeur actuelle de x est 16
5 la valeur actuelle de x est 32

4.3 Boucle ”Tant Que”

Boucle Tant Que :

C’est une structure qui permet de répéter l’exécution d’un bloc d’instructions tant
qu’une condition est vérifiée. L’évaluation de la condition à la portée de la boucle
”Tant Que” est refaite à chaque itération. La boucle s’arrêtera une fois l’évaluation
de la condition renvoie ”faux”.

Notation algorithmique : Notation Python :

Tant Que (<condition>) Faire while (<condition>) :

<instruction 1> ; <instruction 1>
<instruction 2> ; <instruction 2>
... ...
<instruction n> ; <instruction n>
Fait

Remarque :
— Indenter le bloc d’instructions à la portée de ”while” est nécessaire.
— Mettre la condition entre parenthèses n’est pas obligatoire en Python.

44
Afin que la boucle ”Tant Que” fonctionne correctement, assurez vous toujours
d’incorporer un mécanisme d’arrêt dans son corps. Autrement dit, il faudra garantir
l’arrivée d’un moment où la condition à la portée de cette boucle ne sera plus valide.

Voici un exemple d’une boucle ”Tant Que” où la variable i est initialisée à 0 puis on
augmente sa valeur à chaque itération. On arrête la boucle une fois i atteint la valeur 5
(On répète l’exécution du corps de la boucle tant que i < 5).

i←0 ;
Tant que (i<5) faire
écrire(”La valeur actuelle de i est”, i) ;
i←i+1 ;
Fait

1 i=0
2 while i<5:
3 print("La valeur actuelle de i est", i)
4 i=i+1

L’exécution de ce code Python affiche le résultat suivant :

1 La valeur actuelle de i est 0

2 La valeur actuelle de i est 1
3 La valeur actuelle de i est 2
4 La valeur actuelle de i est 3
5 La valeur actuelle de i est 4

Si votre boucle ”Tant Que” ne fonctionne pas correctement, on vous recommande

de procéder comme suite :
— Vérifiez si les variables utilisées dans la condition sont toutes initialisées et
que les initialisations sont faites avec les bonnes valeurs.
— Vérifiez si le corps de la boucle contient des instructions modifiant les va-
leurs des variables utilisées dans la condition, et que ces modifications vont
influencer (tôt au tard) le résultat d’évaluation de la condition.

45
Notez que vous pouvez toujours interrompre l’exécution d’un script Python à l’aide
de la combinaison de touches Ctrl+C. Ceci vous sera utile dans le cas du lancement d’une
boucle infinie.

Dans ce qui suit, nous allons reprendre l’algorithme 5 vu au chapitre 3 et qui effectue
la reconnaissance d’un opérateur arithmétique. Le problème dans cet algorithme est qu’il
reconnaisse un seul opérateur à chaque lancement d’exécution. Nous allons le modifier
afin qu’il continue son exécution tant que l’utilisateur le voudra.

Algorithme reconnaissanceOperateurArithmetique version3 :

reponseUser←”o” ;
Tant que (reponseUser==”o” OU reponseUser==”O”) faire
écrire(”Veuillez entrer une opération arithmétique (+,-,/,*) : ”) ;
lire(operateur) ;
Si (operation==”+”) Alors
écrire(”Une opération d’addition”) ;
Sinon
Si (operation==”-”) Alors
écrire(”Une opération de soustraction”) ;
Sinon
Si (operation==”/”) Alors
écrire(”Une opération de division”) ;
Sinon
Si (operation==”*”) Alors
écrire(”Une opération de multiplication”) ;
Sinon
écrire(”Erreur ! Ceci ce n’est pas une opération
arithmétique.”) ;
Fin Si
Fin Si
Fin Si
Fin Si
écrire(”Voulez-vous continuez l’exécution ? O/N ”) ;
lire(reponseUser) ;

Fait
Fin

Algorithme 6: Reconnaissance d’un opérateur arithmétique (version 3)

46
1 reponseUser="o"
2 while(reponseUser=="o" or reponseUser=="O"):
3 operation=input("Veuillez entrer une opération arithmétique
֒→ (+,-,/,*) : ")
4 if(operation=="+"):
5 print("Une opération d’addition")
6 elif(operation=="-"):
7 print("Une opération de soustraction")
8 elif(operation=="/"):
9 print("Une opération de division")
10 elif(operation=="*"):
11 print("Une opération de multiplication")
12 else:
13 print("Erreur! Ceci ce n’est pas une opération
֒→ arithmétique.")
14 reponseUser=input("\nVoulez-vous continuez l’exécution? O/N ")

Programme 6: Reconnaissance d’un opérateur arithmétique (version 3)

5 Résultats d’exécution du programme 6

1 Veuillez entrer une opération arithmétique (+,-,/,) :

2 Une opération de multiplication
3

4 Voulez-vous continuez l’exécution? oui/non oui

5 Veuillez entrer une opération arithmétique (+,-,/,*) : /
6 Une opération de division
7

8 Voulez-vous continuez l’exécution? oui/non oui

9 Veuillez entrer une opération arithmétique (+,-,/,*) : -
10 Une opération de soustraction
11

12 Voulez-vous continuez l’exécution? oui/non Non

13 >>>

Remarquez que nous avons utilisé une variable reponseUser afin de prendre en
compte la réponse de l’utilisateur s’il souhaite ou non continuer l’exécution du pro-
gramme. Nous l’avons initialisé à ”o” (pour dire ”oui”) pour qu’on puisse exécuter ce
programme au moins une fois. Après cette première exécution, si l’utilisateur répond
par ”o” ou bien ”O” à notre question alors on continue l’exécution, sinon on arrête pour
toute autre réponse différente de ”o” ou ”O”.

47
4.4 Instructions ”break” et ”continue”

Instructions break et continue :

Ceux sont des instructions Python qui permettent de modifier le comportement
d’une boucle (Pour ou Tant Que) suite à un test effectué dans le corps de la boucle,
telles que :

— L’instruction break stoppe la boucle.

— L’instruction continue saute à l’itération suivante.

Dans l’exemple suivant, l’instruction ”break” a interrompu l’exécution de la boucle

”for” à la troisième itération (lorsque i a atteint 2) alors qu’elle devait continuer jusqu’au
cinquième itération (i = 4) :

1 for i in range(5):
2 if i==2:
3 break
4 print(i)

1 0
2 1

Dans l’exemple ci-dessous, l’instruction ”continue” a fait que la valeur 2 n’a pas été
imprimée parce que l’instruction d’affichage correspondante à l’itération où i = 2 a été
sautée.0 1 3 4

1 for i in range(5):
2 if i==2:
3 continue
4 print(i)

1 0
2 1
3 3
4 4

48
Chapitre 5

Fonctions

5.1 Définition d’une fonction

En programmation, les fonctions sont très utiles pour réaliser plusieurs fois la même
opération au sein d’un programme. Elles permettent également de rendre le code plus
lisible et plus clair en le fractionnant en blocs logiques.

Vous connaissez déjà certaines fonctions Python, par exemple len(), range(), inverse(),
etc. Pour un utilisateur, une fonction est une boite noire :

— À laquelle on passe une (ou zero ou plusieurs) valeur(s) entre parenthèses. Ces
valeurs sont appelées arguments.
— Qui effectue une action. Par exemple sort() trie une liste.
— Et qui renvoie éventuellement un résultat. Par exemple si on appelle la fonction
range() en lui passant la valeur 5 (range(5)), celle ci vous renvoie une liste de
nombres entiers de 0 à 4 ([0, 1, 2, 3, 4]).

Au contraire, aux yeux d’un programmeur une fonction est une portion de code ef-
fectuant une action bien particulière. Avant de démarrer sur la syntaxe, revenons sur
cette notion de ”boı̂te noire” :

— Une fonction effectue une tâche. Pour cela, elle reçoit éventuellement des argu-
ments et renvoie éventuellement un résultat. Ce qui se passe en son sein n’intéresse
pas directement l’utilisateur. Par exemple, il est inutile de savoir comment la fonc-
tion math.sqrt() calcule la racine carrée, on a juste besoin de savoir qu’il faut
lui passer en argument un nombre x et qu’elle renvoie la racine carrée de x. Ce
qui se passe au sein de la fonction ne regarde que le programmeur (c’est-à-dire
vous dans ce chapitre).
— Chaque fonction effectue en général une tâche unique et précise. Si cela se com-
plique, il est plus judicieux d’écrire plusieurs fonctions (qui peuvent éventuellement
s’appeler les unes les autres). Cette modularité améliore la qualité générale et la

49
lisibilité du code. Vous verrez qu’en Python, les fonctions présentent une grande
flexibilité.

Voici en résumé la définition d’une fonction :

Fonction :
Une fonction est un fragment de programme qui effectue une tâche particulière.
Ce fragment reçoit éventuellement des paramètres (ou, arguments), et renvoie
éventuellement un résultat.

Notation algorithmique :

Fonction <nom de la fonction> (<paramètre 1> :<type 1>,...,

<paramètre n> : <type n> ) :<type du résultat>
<instruction 1> ;
<instruction 2> ;
...
<instruction n> ;
Fin

Notation Python :

def <nom de la fonction> (<paramètre 1>,...,<paramètre n> ) :

Pour renvoyer le résultat de la fonction au programme principal, on utilise le

mot clé ”Retourner” en algorithmique, et le mot clé ”return” en Python.

Dans l’exemple ci-dessous, nous définissons une fonction simple calculons le carré
d’un entier quelconque passé en paramètre :

50
Fonction carre(x : entier) : entier
Retourner x*x ;
Fin

1 def carre(x):
2 return x*x

L’appel à cette fonction se fait comme dans les exemples suivants :

1 >>> carre(5)
2 25
3 >>> carre(2)
4 4
5 >>> carre(-10)
6 100

Dans l’exemple précédent, nous avons passé un argument à la fonction ”carre()” qui
nous a retourné une valeur que nous avons récupéré à travers le mot clé ”Retourner”.
Le résultat d’une fonction contenant le mot clé ”Retourner” peut être enregistrée dans
une variable. Observez l’exemple suivant où la variable y est utilisée pour enregistrer le
résultat de la fonction carre(6) :

1 >>> y=carre(6)
2 >>> y
3 36

Notez qu’une fonction ne prend pas forcément un argument et ne renvoie pas forcément
une valeur, par exemple :

1 >>> def helloFR():

2 print("Bonjour")
3

4 >>> helloFR()
5 bonjour

51
Dans ce cas la fonction ”helloFR()” se contente d’imprimer la chaı̂ne de caractères
”Bonjour” à l’écran. Elle ne prend aucun argument et ne renvoie aucun résultat. Par
conséquent, cela n’a pas de sens de vouloir récupérer dans une variable le résultat ren-
voyé par une telle fonction . Si on essaie tout de même, Python affecte la valeur ”None”
qui signifie ”rien” en anglais :

1 >>> y=helloFR()
2 bonjour
3 >>> print(y)
4 None

5.2 Passage d’arguments

Le nombre d’arguments que l’on peut passer à une fonction est variable. Nous avons
vu ci-dessus des fonctions auxquelles on passait 0 ou 1 argument. Dans les chapitres
précédents, vous avez vu des fonctions internes à Python qui prenaient au moins 2
arguments, pour rappel souvenez-vous de range(1,10) ou encore range(1,10,2). Le
nombre d’arguments est donc laissé libre à l’initiative du programmeur qui est en train
de développer une nouvelle fonction.

Dans le chapitre 2, nous avons expliqué le concept de ”typage dynamique” en Python.

Cette caractéristique permet de reconnaitre (ou, détecter) les types des variables (ou
des valeurs) d’une façons automatique. Ceci confère aux fonctions Python une grande
flexibilité, comme illustré dans l’exemple suivant :

1 >>> def carre(x,y):

2 return x*y
3

4 >>> carre(5,8) #Les arguments dont des entiers

5 40
6 >>> carre(5.5,10.25) #Les arguments sont des réels
7 56.375
8 >>> carre("to",2) #Les arguments sont de types différents
9 ’toto’

L’opérateur ∗ reconnait plusieurs types (entiers, réels, chaı̂nes de caractères), notre

fonction est donc capable d’effectuer plusieurs tâches !

Un autre gros avantage de Python est que ses fonctions sont capables de renvoyer
plusieurs valeurs à la fois, comme dans cette fraction de code :

52
1 >>> def carre_cube(x):
2 return x*x, x*x*x
3

4 >>> carre_cube(3)
5 (9, 27)

Vous voyez qu’en réalité, Python renvoie un objet séquentiel qui peut par conséquent
contenir plusieurs valeurs. Dans notre exemple, Python renvoie un objet ”tuple” car on
a utilisé une syntaxe de ce type. Notre fonction pourrait tout autant renvoyer une liste :

1 >>> def carre_cube(x):

2 return [x*x,x*x*x]
3

4 >>> carre_cube(5)
5 [25, 125]

Enfin, il est possible de passer un ou plusieurs argument(s) de manière facultative

et de leur attribuer une valeur par défaut :

1 >>> def func(x=1):

2 return x
3

4 >>> func()
5 1
6 >>> func(7)
7 7

Notez que si on passe plusieurs arguments à une fonction, le ou les arguments facul-
tatifs doivent être situés après les arguments obligatoires. Observez l’exemple suivant :

1 >>> def func(x,y,z=1):

2 return x,y,z
3

4 >>> func()
5 Traceback (most recent call last):
6 File "<pyshell#26>", line 1, in <module>
7 func()
8 TypeError: func() missing 2 required positional arguments: ’x’ and ’y’

53
9 >>> func(5,7)
10 (5, 7, 1)
11 >>> func(2)
12 Traceback (most recent call last):
13 File "<pyshell#28>", line 1, in <module>
14 func(2)
15 TypeError: func() missing 1 required positional argument: ’y’

5.3 Portée des variables

Portée des variables :

La portée d’une variable reflète le taux de visibilité de cette dernière hors la
fonction dans laquelle a été utilisée. La portée d’une variable est influencée par
quatre règles essentielles :

1. Toute variable utilisée au sein d’une fonction est invisible à l’extérieur de

cette fonction ; elle est donc locale.
2. Toute variable utilisée à la racine du module principal est visible au sein
de la fonction. Le module principale peut être l’IDLE de Python comme il
peut être le fichier où la fonction est déclarée.
3. Toute variable précédée par le mot clé ”global” est visible à l’extérieur ;
elle est donc globale.
4. Le mot clé ”global” ne pourra pas être utilisé avec les arguments d’une
fonction i.e, les arguments d’une fonction doivent être locaux.

Observez le code suivant :

1 >>> def mafonction():

2 x=2
3 print("la valeur de x est", x)
4

5 >>> mafonction()
6 la valeur de x est 2
7 >>> print(x)
8 Traceback (most recent call last):
9 File "<pyshell#5>", line 1, in <module>
10 print(x)
11 NameError: name ’x’ is not defined

54
Lorsque Python exécute le code de la fonction mafonction, il connait le contenu de
la variable x. Par contre, de retour dans le module principal (dans notre cas, il s’agit
de l’interpréteur Python), il ne la connaı̂t plus d’où le message d’erreur. De même,
une variable passée en argument est considérée comme locale lorsqu’on arrive dans la
fonction :

1 >>> def mafonction(x):

2 print("la valeur de x est", x)
3

4 >>> mafonction(3)
5 la valeur de x est 3
6 >>> print (x)
7 Traceback (most recent call last):
8 File "<pyshell#10>", line 1, in <module>
9 print (x)
10 NameError: name ’x’ is not defined

Voici un exemple où la variable x est déclarée dans le module principal (L’IDLE),
d’où elle est visible dans tout le module.

1 >>> def mafonction():

2 print("la valeur de x est", x)
3

4 >>> x=4
5 >>> mafonction()
6 la valeur de x est 4

Toutefois, Python ne permet pas la modification d’une variable globale dans une
fonction :

1 >>> def mafonction():

2 x=x+1
3

4 >>> x=2
5 >>> mafonction()
6 Traceback (most recent call last):
7 File "<pyshell#11>", line 1, in <module>
8 mafonction()

55
9 File "<pyshell#9>", line 2, in mafonction
10 x=x+1
11 UnboundLocalError: local variable ’x’ referenced before assignment

L’erreur renvoyée montre que Python pense que x est une variable locale qui n’a pas
été encore assignée. Si on veut vraiment modifier la variable x, il faut utiliser le mot-clé
global :

1 >>> def mafonction():

2 global x
3 x=x+1
4

5 >>> x=4
6 >>> mafonction()
7 >>> x
8 5

Dans ce dernier cas, le mot-clé global a forcé la variable x a être globale plutôt que
locale au sein de la fonction.

56
Chapitre 6

Listes, dictionnaires et tuples

6.1 Listes
6.1.1 Définition de listes

Liste :
Une liste est une structure de données qui contient une série de valeurs. Python au-
torise la construction de liste contenant des valeurs de type différent (par exemple
entier et chaı̂ne de caractères), ce qui leur confère une grande flexibilité.

— Notation algorithmique −→

<nom de liste>←[valeur 1, valeur 2,...,valeur n]

— Notation Python −→

<nom de liste>=[valeur 1, valeur 2,...,valeur n]

Observez les listes suivantes où la première est une liste d’entiers, la deuxième est
une liste de chaines de caractères alors que la troisième est une liste mixte :

1 >>> nombres=[67,8,56,33]
2 >>> chaines=[’je’,"étudiant",’suis’]
3 >>> mixte=[4,’h’,10.5,"étudiant"]

Lorsque l’on affiche une liste, Python la restitue telle qu’elle a été saisie :

57
1 >>> nombres
2 [67, 8, 56, 33]
3 >>> chaines
4 [’je’, ’étudiant’, ’suis’]
5 >>> mixte
6 [4, ’h’, 10.5, ’étudiant’]

6.1.2 Indexation des listes

Un des gros avantages d’une liste est que vous pouvez appeler ses éléments par leur
position. Ce numéro est appelé indice (ou index) de la liste. Pour une liste de taille n,
l’indice commence à 0 et se termine à n − 1.

1 >>> nombres=[67,8,56,33]
2 >>> chaines=[’je’,"étudiant",’suis’]
3 >>> mixte=[4,’h’,10.5,"étudiant"]
4 >>> nombres[0]
5 67
6 >>> chaines[1]
7 ’étudiant’
8 >>> mixte[3]
9 ’étudiant’
10 >>> nombres[0]+nombres[2]
11 123

La liste peut également être indexée avec des nombres négatifs selon le modèle sui-
vant :

Liste x1 x2 x3 x4
Indice positif 0 1 2 3
Indice négatif -4 -3 -2 -1

Les indices négatifs reviennent à compter à partir de la fin. Leur principal avantage
est que vous pouvez appeler le dernier élément d’une liste à l’aide de l’indice -1 sans
pour autant connaı̂tre la longueur de la liste.

58
1 >>> nombres[-2]
2 56
3 >>> chaines[-1]
4 ’suis’
5 >>> mixte[-4]
6 4

Un autre avantage des listes est la possibilité de sélectionner une partie en utilisant
le modèle [m : n + 1] pour récupérer tous les éléments entre l’indice m (inclus) et l’indice
n (inclus). On dit alors qu’on récupère une tranche de la liste, par exemple :

1 >>> nombres[1:3]
2 [8, 56]
3 >>> nombres[0:-1]
4 [67, 8, 56]
5 >>> nombres[0:-3]
6 [67]
7 >>> nombres[-3:0]
8 []
9 >>> nombres[0:-1]
10 [67, 8, 56]
11 >>> nombres[1:-1]
12 [8, 56]
13 >>> nombres[:]
14 [67, 8, 56, 33]
15 >>> nombres[:2]
16 [67, 8]
17 >>> nombres[1:]
18 [8, 56, 33]

Remarquez que lorsqu’aucun indice n’est indiqué à gauche ou à droite du symbole :,

Python prend par défaut tous les éléments depuis le début ou tous les éléments jusqu’à
la fin respectivement.

Notez que, dans certaines versions de Python, on peut aussi préciser le pas en ajoutant
un ”:” supplémentaire et en indiquant le pas par un entier. Donc il faut suivre la syntaxe
list[début:fin:pas].

59
1 >>> nombres[0:-1:2]
2 [67, 56]

Observez l’exemple suivant où nous utilisons la fonction range() vue au chapitre 4
afin de créer une listes d’entiers de manière simple et rapide :

1 >>> list1=range(20)
2 range(0, 20)
3 >>> list1[7]
4 7
5 >>> list1[19]
6 19

6.1.3 Listes à deux dimensions

Une liste à deux dimensions est une liste où chaque élément est lui-même une liste.
Cette fonctionnalité peut être parfois très pratique. Par exemple :

1 >>> module1=[’Dimanche’,’Java’]
2 >>> module2=[’Lundi’,’BD’]
3 >>> module3=[’Mardi’,’Python’]
4 >>> programme=[module1,module2,module3]
5 >>> programme
6 [[’Dimanche’, ’Java’], [’Lundi’, ’BD’], [’Mardi’, ’Python’]]

Dans l’exemple ci-dessus, chaque sous-liste contient un jour de la semaine plus le nom
d’un module enseigné. Pour accéder à une sous-liste on utilise un indexage simple et
pour accéder à un élément de la sous-liste, on utilise un indexage double :

1 >>> programme[0]
2 [’Dimanche’, ’Java’]
3 >>> programme[0][0]
4 ’Dimanche’
5 >>> programme[1][0]
6 ’Lundi’
7 >>> programme[1][0]
8 ’Lundi’
9 >>> programme[0][1]
10 ’Java’

60
6.1.4 Manipulation des listes
Longueur d’une liste La fonction ”len()” vous permet de connaı̂tre la longueur
d’une liste. Voici un exemple d’utilisation :

1 >>> l=[1,2,3,4]
2 >>> len(l)
3 4

Test d’appartenance Les mots clés Python ”in” et ”not in” permettent de tester
respectivement l’appartenance ou non d’un élément à une liste. Python vous affiche
”true” si le test est positif et ”false” sinon.

1 >>> l=[1,2,3,4]
2 >>> 2 in l
3 True
4 >>> 2 not in l
5 False
6 >>> 8 in l
7 False

Fonctions sur les listes En Python, un ensemble de fonctions ont été définies afin
de faciliter l’usage des listes. Ci-dessous la listes des fonctions les plus importantes avec
un exemple d’usage pour chacune d’elles :

1. La fonction append() : pour ajouter un élément à la fin d’une liste.

1 >>> l=[1,2,3,4]
2 >>> l.append(5)
3 >>> l
4 [1, 2, 3, 4, 5]

Ceci est équivalent à :

1 >>> l=l+[6]
2 >>> l
3 [1, 2, 3, 4, 5, 6]

61
2. La fonction insert() : pour insérer un object dans une liste avec un indice
déterminé.

1 >>> l.insert(3,7)
2 >>> l
3 [1, 2, 3, 7, 4, 5, 6]

3. La fonction del() : pour supprimer un élément d’une liste à partir d’un indice.

1 >>> del(l[1])
2 >>> l
3 [1, 3, 7, 4, 5, 6]

4. La fonction remove() : pour supprimer un élément d’une liste à partir de sa

valeur.

1 >>> l.remove(7)
2 >>> l
3 [1, 3, 4, 5, 6]

5. La fonction sort() : pour trier une liste.

1 >>> l=[7,5,2,9]
2 >>> l.sort()
3 >>> l
4 [2, 5, 7, 9]

6. La fonction reverse() : pour inverser une liste.

1 >>> l.reverse()
2 >>> l
3 [7, 5, 4, 3, 1]

62
7. La fonction count() : pour compter le nombre d’occurrences de la valeur passée
en argument, dans la liste.

1 >>> l.count(7)
2 1
3 >>> l.count(6)
4 0

6.1.5 Copie de listes

Il est très important de savoir que l’affectation d’une liste (à partir d’une liste
préexistante) crée en réalité une référence et non une copie :

1 >>> list1=[1,2,3]
2 >>> list2=list1
3 >>> list1[1]=4
4 >>> list1
5 [1, 4, 3]
6 >>> list2
7 [1, 4, 3]

Remarquez que la modification de ”list1” a amené à une modification de ”list2”

en parallèle. Afin d’éviter ce problème, utilisez l’une des deux méthodes suivantes pour
créer une copie d’une liste :

1. Utilisation de la syntaxe :

<nom de la copie>=<nom de la liste copiée>[ :]

1 >>> list1=[1,2,3]
2 >>> list2=list1[:]
3 >>> list1[1]=4
4 >>> list1
5 [1, 4, 3]
6 >>> list2
7 [1, 2, 3]

2. Utilisation de la fonction ”list()” prédéfinie en Python :

63
1 >>> list1=[1,2,3]
2 >>> list2=list(list1)
3 >>> list1[1]=4
4 >>> list1
5 [1, 4, 3]
6 >>> list2
7 [1, 2, 3]

Attention, les deux techniques précédentes ne fonctionnent que pour les listes à une
dimension, autrement dit les listes qui ne contiennent pas elles-mêmes d’autres listes.

1 >>> list1=[[1,2],[3,4]]
2 >>> list2=list(list1)
3 >>> list1[1][1]=-5
4 >>> list1
5 [[1, 2], [3, -5]]
6 >>> list2
7 [[1, 2], [3, -5]]

La méthode de copie qui marche à tous les coups consiste à appeler la fonction
”deepcopy()” du module ”copy”.

1 >>> import copy #Cette instruction vous permettent de charger

֒→ une bibliothèque "copy" contenant la fonction "deepcopy"
2 >>> list1=[[1,2],[3,4]]
3 >>> list2=copy.deepcopy(list1)
4 >>> list1[1][1]=-5
5 >>> list1
6 [[1, 2], [3, -5]]
7 >>> list2
8 [[1, 2], [3, 4]]

6.1.6 Portée des listes dans une fonction

Soyez extrêmement attentifs avec les types modifiables (tels que les listes) car vous
pouvez les changer au sein d’une fonction :

64
1 >>> def mafonction():
2 liste[1]=5
3

4 >>> liste=[1,2,3]
5 >>> mafonction()
6 >>> liste
7 [1, 5, 3]

De même que si vous passez une liste en argument, elle est tout autant modifiable
au sein de la fonction :

1 >>> def mafonction(x):

2 x[1]=5
3

4 >>> y=[1,2,3]
5 >>> mafonction(y)
6 >>> y
7 [1, 5, 3]

Si vous voulez éviter ce problème, utilisez des tuples, Python renverra une erreur
puisque ces derniers sont non modifiables ! Une autre solution pour éviter la modification
d’une liste lorsqu’elle est passée en tant qu’un argument, est de la passer explicitement
(comme nous l’avons fait pour l’affectation) afin qu’elle reste intacte dans le programme
principal.

1 >>> def mafonction(x):

2 x[1]=-5
3

4 >>> y=[1,2,3]
5 >>> mafonction(y[:])
6 >>> y
7 [1, 2, 3]
8 >>> mafonction(list(y))
9 >>> y
10 [1, 2, 3]

Dans ces deux derniers exemples, une copie de y est créée à la volée lorsqu’on appelle
la fonction, ainsi la liste y du module principal reste intacte.

65
6.2 Les dictionnaires
Les dictionnaires se révèlent très pratiques lorsque vous devez manipuler des struc-
tures complexes à décrire et que les listes présentent leurs limites.

Dictionnaire :
Les dictionnaires sont des collections non ordonnées d’objets, c-à-d qu’il n’y a pas
de notion d’ordre (i. e. pas d’indice). On accède aux valeurs d’un dictionnaire par
des clés.

En premier lieu, un dictionnaire vide doit être définit en utilisant les symboles
{}, ou à travers le mot clé dict() :

<nom de dictionnaire>= {} ou <nom de dictionnaire>= dict()

Ensuite, on remplit le dictionnaire avec différentes clés auxquelles on affecte

des valeurs (une par clé). Vous pouvez mettre autant de clés que vous voulez dans
un dictionnaire.

<nom de dictionnaire>[<nom du clé>]=valeur

Sinon, on peut à la fois définir un dictionnaire et remplir les valeurs de ses clés
en respectant la syntaxe suivante :

<nom de dictionnaire>= {<nom du clé 1> : valeur 1, <nom du clé

2> :valeur 2, ..., <nom du clé n> :valeur n }

Voici un exemple de définition d’un dictionnaire en utilisant deux méthodes différentes :

1 >>> dic=dict()
2 >>> dic[’nom’]=’Dib’
3 >>> dic[’prenom’]=’Mohammed’
4 >>> dic[’age’]=22

1 >>> dic={’age’: 22, ’nom’: ’Dib’, ’prenom’: ’Mohammed’}

Pour récupérer la valeur d’une clé donnée, il suffit d’utiliser une syntaxe du style
dictionnaire[’clé’].

66
1 >>> dic[’age’]
2 22
3 >>> dic[’nom’]
4 ’Dib’

6.2.1 Méthodes keys() et values()

Les méthodes keys() et values() renvoient respectivement les clés et les valeurs
d’un dictionnaire (sous forme de liste) :

1 >>> dic={’age’: 22, ’nom’: ’Dib’, ’prenom’: ’Mohammed’}

2 >>> dic.keys()
3 dict_keys([’age’, ’nom’, ’prénom’])
4 >>> dic.values()
5 dict_values([22, ’Dib’, ’Mohammed’])

6.2.2 Liste de dictionnaires

En créant une liste de dictionnaires possédant les mêmes clés, on obtient une structure
qui ressemble à une base de données :

1 >>> dic1={’nom’:’Dib’,’prénom’:’Mohammed’,’age’:22}
2 >>> dic2={’nom’:’Salmi’,’prénom’:’Yacer’,’age’:24}
3 >>> dic3={’nom’:’Brahami’,’prénom’:’amina’,’age’:30}
4 >>> dic=[dic1,dic2,dic3]
5 >>> dic
6 [{’age’: 22, ’nom’: ’Dib’, ’prénom’: ’Mohammed’}, {’age’: 24, ’nom’:
֒→ ’Salmi’, ’prénom’: ’Yacer’}, {’age’: 30, ’nom’: ’Brahami’,
֒→ ’prénom’: ’amina’}]
7 >>> print(dic1 ,’\n’, dic2 ,’\n’, dic3)
8 {’age’: 22, ’nom’: ’Dib’, ’prénom’: ’Mohammed’}
9 {’age’: 24, ’nom’: ’Salmi’, ’prénom’: ’Yacer’}
10 {’age’: 30, ’nom’: ’Brahami’, ’prénom’: ’amina’}

67
6.3 Les tuples

Dictionnaire :
Les tuples correspondent aux listes à la différence qu’ils sont non modifiables. On a
vu à la section précédente que les listes pouvaient être modifiées par des références ;
les tuples vous permettent de vous affranchir de ce problème. Pratiquement, ils uti-
lisent les parenthèses au lieu des crochets :

<nom de tuple>=(valeur 1, valeur 2,..., valeur n)

Ci-dessous un exemple où nous définissons un tuple puis nous affichons certains de
ses éléments :

1 >>> tuple1=(1,2,3,4)
2 >>> tuple1[2]
3 3
4 >>> tuple1[0:2]
5 (1, 2)

L’affectation et l’indexage fonctionne comme avec les listes, mais si l’on essaie de
modifier un des éléments du tuple, Python renvoie un message d’erreur (regardez la
ligne 15 du code ci-dessus).

1 >>> tuple1=(1,2,3,4)
2 >>> tuple1[4]=5
3 Traceback (most recent call last):
4 File "<pyshell#4>", line 1, in <module>
5 tuple1[4]=5
6 TypeError: ’tuple’ object does not support item assignment

Donc, si vous voulez ajouter un élément(ou le modifier), vous devez créer un autre
tuple :

1 >>> tuple1=tuple1+(5,)
2 >>> tuple1
3 (1, 2, 3, 4, 5)

68
Enfin, on peut utiliser la fonction ”tuple()” qui fonctionne exactement comme la
fonction ”range()”, c-à-d qu’elle prend en argument un objet séquentiel et renvoie le
tuple correspondant :

1 >>> tuple(’hjhhlkbn’)
2 (’h’, ’j’, ’h’, ’h’, ’l’, ’k’, ’b’, ’n’)
3 >>> tuple(range(10))
4 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

69
Bibliographie

[1] Wikiversity. (2016) Python : Les types de base. [Online]. Available :

https://fr.wikiversity.org/wiki/Python/Les types de base

1
Annexe A

Liste des types en Python [1]

Rang Nom du type (anglais) Nom du type (français) Code du type

1 Integer Entier int
2 Long integer Entier long long
3 Floating point number Nombre à virgule flottante float
4 Complex Nombre complexe complex
5 Character string Chaı̂ne de caractères str
6 Unicode character string Chaı̂ne de caractères Unicode unicode
7 basestring Chaı̂ne de caractères basestring
8 N-uplet N-uplet tuple
9 List Liste list
10 X range Intervalle X xrange
11 Dictionary Dictionnaire dict
12 Set Collection set
13 Frozenset Collection figée frozenset
14 File Fichier file
15 None Rien none
16 Type Type type
17 Object Objet object
18 Slice Couper slice
19 Not implemented type Absence d’implémentation NotImplementedType
20 Boolean Valeur booléenne bool
21 Exception Exception exception
22 Function Fonction fonction
23 Module Module module

Table A.1 – Les noms et les codes des types en Python

2
Code du Description
type
int Entier compris entre -2 147 483 648 et 2 147 483 647 (codage sur 32 bits
soit 4 octets)
long Entier compris entre −∞ et -2 147 483 647 ou entre 2 147 483 648 et +∞
float Valeur spécifiée avec un point dans le programme (exemple : a = 2.0)
permettant une approximation de nombre réel
complex Nombre complexe
str Chaı̂ne de caractères
unicode Chaı̂ne de caractères encodés selon la norme Unicode
basestring Chaı̂ne de caractères str + unicode
tuple Tuple de forme (1,2,3,”je suis un tuple”,5,3.14159)
list Liste de forme [1,2,3,”je suis une liste”,’...’]
xrange Liste dont les numéros peuvent être générés automatiquement
dict Dictionnaire de forme {’Œuf’ : 1, ’Jambon’ : 0}
set Collection désordonnée d’éléments uniques
frozenset Collection désordonnée immuable d’éléments uniques
file Fichier informatique
none Type d’un vide (par exemple, par assignation de la valeur none à une
variable)
type Type du type des objets (exemple : type de la valeur renvoyée par la fonction
type())
object Type basique
slice Objet extensible
NotImpleme-
ntedType
bool Type de True et de False (renvoyés par exemple lors de tests ou d’opérations
booléennes)
exception Message d’erreur
fonction Fonction
module Module

Table A.2 – Description des types en Python

Vous aimerez peut-être aussi

Python1a PDF
Pas encore d'évaluation
Python1a PDF
50 pages
Python3v1 1
Pas encore d'évaluation
Python3v1 1
143 pages
Cours Algorithmique
Pas encore d'évaluation
Cours Algorithmique
57 pages
CoursALM Id5868
Pas encore d'évaluation
CoursALM Id5868
50 pages
Eni Algorithmique Technique de Programmation en Python 2ed... Wawacity - Tokyo
100% (6)
Eni Algorithmique Technique de Programmation en Python 2ed... Wawacity - Tokyo
304 pages
Introduction A L'algorithmique Et A La Programmation Avec Python
Pas encore d'évaluation
Introduction A L'algorithmique Et A La Programmation Avec Python
6 pages
Cours Python 3
100% (2)
Cours Python 3
155 pages
Introduction à Python 3 en Français
Pas encore d'évaluation
Introduction à Python 3 en Français
155 pages
0741 Introduction A Lalgorithmique Et A La Programmation Avec Python
Pas encore d'évaluation
0741 Introduction A Lalgorithmique Et A La Programmation Avec Python
57 pages
Poly Python24
Pas encore d'évaluation
Poly Python24
10 pages
Poly Python
Pas encore d'évaluation
Poly Python
210 pages
WWW - Cours Gratuit - Com Id 1947
Pas encore d'évaluation
WWW - Cours Gratuit - Com Id 1947
222 pages
Programmation Python
100% (2)
Programmation Python
222 pages
Introduction à l'Algorithmique et Python
Pas encore d'évaluation
Introduction à l'Algorithmique et Python
40 pages
Cours Python 2PI
Pas encore d'évaluation
Cours Python 2PI
125 pages
Apprendre La Programmation Avec Python Debut
100% (1)
Apprendre La Programmation Avec Python Debut
113 pages
Courspython 3
Pas encore d'évaluation
Courspython 3
132 pages
PolyPython An
Pas encore d'évaluation
PolyPython An
38 pages
Syl Lab Us Python 32
Pas encore d'évaluation
Syl Lab Us Python 32
218 pages
Cours - PHY254 19-20
Pas encore d'évaluation
Cours - PHY254 19-20
18 pages
Cours Algo Python
Pas encore d'évaluation
Cours Algo Python
45 pages
Cours 1
Pas encore d'évaluation
Cours 1
22 pages
Python et Raspberry Pi : Guide Complet
Pas encore d'évaluation
Python et Raspberry Pi : Guide Complet
13 pages
Courspython3 PDF
Pas encore d'évaluation
Courspython3 PDF
138 pages
Python 1
Pas encore d'évaluation
Python 1
11 pages
Cours Python Pierre Pompidor
Pas encore d'évaluation
Cours Python Pierre Pompidor
29 pages
Cours - Chapitre I
Pas encore d'évaluation
Cours - Chapitre I
24 pages
Cours Python
Pas encore d'évaluation
Cours Python
107 pages
Programmation Les Immanquables
Pas encore d'évaluation
Programmation Les Immanquables
6 pages
Cours Python Data Sciences - 2021 - 2022 Seance 2
Pas encore d'évaluation
Cours Python Data Sciences - 2021 - 2022 Seance 2
68 pages
CoursPython-4 241128 104552
Pas encore d'évaluation
CoursPython-4 241128 104552
54 pages
Cours 1
Pas encore d'évaluation
Cours 1
40 pages
01 Informatique2 MIP Rappels
Pas encore d'évaluation
01 Informatique2 MIP Rappels
65 pages
Intro Python Poly
Pas encore d'évaluation
Intro Python Poly
32 pages
Apprendre A Programmer Avec Python 3 PDF
Pas encore d'évaluation
Apprendre A Programmer Avec Python 3 PDF
51 pages
Apprendre Python 3 : Guide Débutant
0% (1)
Apprendre Python 3 : Guide Débutant
41 pages
Cours Python 2023-2024 : Algorithmique et Programmation
Pas encore d'évaluation
Cours Python 2023-2024 : Algorithmique et Programmation
65 pages
Introduction au langage Python
Pas encore d'évaluation
Introduction au langage Python
73 pages
Chapitre 2
Pas encore d'évaluation
Chapitre 2
10 pages
Cours 3 SI
100% (1)
Cours 3 SI
32 pages
Initiation Via Python Ellipse Mai 2010 PDF
Pas encore d'évaluation
Initiation Via Python Ellipse Mai 2010 PDF
336 pages
Introduction Au Python
Pas encore d'évaluation
Introduction Au Python
15 pages
Pycharm
Pas encore d'évaluation
Pycharm
35 pages
Introduction à Python : Histoire et Concepts
Pas encore d'évaluation
Introduction à Python : Histoire et Concepts
31 pages
Courspython20 21 SeanceDu23 10 2020
Pas encore d'évaluation
Courspython20 21 SeanceDu23 10 2020
55 pages
Cours Python CP1 Version 1
Pas encore d'évaluation
Cours Python CP1 Version 1
205 pages
Cours Python
Pas encore d'évaluation
Cours Python
147 pages
Apprendre les bases de Python 3
Pas encore d'évaluation
Apprendre les bases de Python 3
41 pages
Python pour Lycéens Scientifiques
67% (3)
Python pour Lycéens Scientifiques
28 pages
Cours Python - Daf
Pas encore d'évaluation
Cours Python - Daf
19 pages
Cours Gratuits: Programmation Python et Delphi
Pas encore d'évaluation
Cours Gratuits: Programmation Python et Delphi
78 pages
3 - Python 2021 - Pour Les Sciences
Pas encore d'évaluation
3 - Python 2021 - Pour Les Sciences
131 pages
PHY254 - Cours Python PDF
Pas encore d'évaluation
PHY254 - Cours Python PDF
17 pages
PythonOnly Total
Pas encore d'évaluation
PythonOnly Total
20 pages
Cahier d'ALGO 2de - Barbazo - Hachette - 2019
Pas encore d'évaluation
Cahier d'ALGO 2de - Barbazo - Hachette - 2019
81 pages
Chapitre 1
Pas encore d'évaluation
Chapitre 1
61 pages
Algorithmique Et Programmation
Pas encore d'évaluation
Algorithmique Et Programmation
38 pages
Chapitre 4
Pas encore d'évaluation
Chapitre 4
11 pages
Chapitre 3
Pas encore d'évaluation
Chapitre 3
8 pages
Partie 3 (Du Chap1)
Pas encore d'évaluation
Partie 3 (Du Chap1)
8 pages
Présentation 111
Pas encore d'évaluation
Présentation 111
9 pages
Cours Licence L3-Opérations Unitaires
Pas encore d'évaluation
Cours Licence L3-Opérations Unitaires
26 pages
Application Client Serveur
Pas encore d'évaluation
Application Client Serveur
40 pages
Langage C Exam 2324 - Correction
Pas encore d'évaluation
Langage C Exam 2324 - Correction
3 pages
Tutoriel Code::Blocks pour Débutants
Pas encore d'évaluation
Tutoriel Code::Blocks pour Débutants
6 pages
Test 2023-2024 Processus
Pas encore d'évaluation
Test 2023-2024 Processus
2 pages
QCM (35 Points) : Correction
Pas encore d'évaluation
QCM (35 Points) : Correction
15 pages
Votre Site PHP Presque Complet Architecture MVC Et Bonnes Pratiques
Pas encore d'évaluation
Votre Site PHP Presque Complet Architecture MVC Et Bonnes Pratiques
54 pages
Cours et Exercices sur Transact-SQL
80% (20)
Cours et Exercices sur Transact-SQL
36 pages
Langage C
100% (1)
Langage C
80 pages
Implémentation des déclencheurs Oracle
Pas encore d'évaluation
Implémentation des déclencheurs Oracle
7 pages
Algorithmes et Python pour Lycéens
Pas encore d'évaluation
Algorithmes et Python pour Lycéens
3 pages
Cours Master2
Pas encore d'évaluation
Cours Master2
26 pages
Adap
Pas encore d'évaluation
Adap
53 pages
TP JS
Pas encore d'évaluation
TP JS
1 page
Gestion de fichiers en POO Avancée
Pas encore d'évaluation
Gestion de fichiers en POO Avancée
2 pages
Kamel Ibn Aziz Derouiche
Pas encore d'évaluation
Kamel Ibn Aziz Derouiche
20 pages
Programation Declarative - Programation - Logique
Pas encore d'évaluation
Programation Declarative - Programation - Logique
26 pages
Conventions et Recommandations Java
Pas encore d'évaluation
Conventions et Recommandations Java
33 pages
Travaux Pratiques - Bases de La Programmation
Pas encore d'évaluation
Travaux Pratiques - Bases de La Programmation
53 pages
Structures Conditionnelles en Python
Pas encore d'évaluation
Structures Conditionnelles en Python
15 pages
Introduction Au Développement Mobile (Q&R)
Pas encore d'évaluation
Introduction Au Développement Mobile (Q&R)
16 pages
La Gestion Des Erreurs en C
Pas encore d'évaluation
La Gestion Des Erreurs en C
31 pages
Administrateur de Réseaux Informatiques
Pas encore d'évaluation
Administrateur de Réseaux Informatiques
72 pages
Installation Apache Hadoop et MapReduce
Pas encore d'évaluation
Installation Apache Hadoop et MapReduce
20 pages
MySql Est Un Logiciel de Gestion de Base de Données
Pas encore d'évaluation
MySql Est Un Logiciel de Gestion de Base de Données
46 pages
API Grafcet
Pas encore d'évaluation
API Grafcet
345 pages
Introduction à la Programmation Logique
Pas encore d'évaluation
Introduction à la Programmation Logique
78 pages
Cours Informtique Pour La Biologie
Pas encore d'évaluation
Cours Informtique Pour La Biologie
63 pages
Examen TP Mna
0% (1)
Examen TP Mna
8 pages
Cours Algo Programmation (2021-2022) Students
Pas encore d'évaluation
Cours Algo Programmation (2021-2022) Students
173 pages
Communication entre processus en C
100% (1)
Communication entre processus en C
4 pages