Chapitre 1

Chapitre 1
GENERALITES
PYTHON
Professeur BENMOUSSA Nasr Eddine
Email : nasreddinebenmoussa@yahoo.fr
But de ce cours :
• Apprendre à établir des algorithmes pour résoudre des problèmes

scientifiques .
• Apprendre le langage de programmation Python.

• Apprendre les algorithmes des différentes méthodes numériques de
base et apprendre à les programmer .
Exemples :
 Résoudre dans R l’équation suivante :
 Calculer l’intégrale suivante :
 Résoudre un système linéaire de 20 équation à 20 inconnues …

Notions d’algorithme
Définitions:
Un algorithme est une suite ordonnée d‘actions élémentaires qui,
exécutées par un processeur bien défini, réalisera un travail bien
précis . Il transforme des grandeurs données (données d‘entrée)
en d‘autres grandeurs (données de sortie).
 Exemple 1 : Addition de deux nombres réels
Début
1) Lire (A)
2) Lire (B)
3) Somme=A+B
4) Écriture (Somme)
Fin
 Exemple 2 : Calcul des racines d'un polynôme du 2ème ordre :

a x² + b x + c = 0 ,  (a,b,c)≠0
Entrée : Sortie :
Un algorithme possède une ou Un algorithme possède une ou
plusieurs données d’entrée (input plusieurs données de sortie
data), c-à-d des valeurs qui sont (output data), c-à-d des valeurs
connues avant son exécution et produites par lui lui-même. Ces
sur lesquelles l’algorithme est données sont en relation avec les
appliqué données d’entrée.
 Propriétés:
– L’algorithme doit tenir compte de tous les cas possibles.
Il traite le cas général et les cas particuliers
– Il contient toujours un nombre fini d'actions

– L’ordre d‘actions est important (exécution séquentielle)
– Chaque action doit être définie avec précision, sans

aucune difficulté
– Certaines actions peuvent être raffinées (décomposées)

– L’algorithme n’est pas nécessairement unique .
– Il doit produire le résultat désiré .
 Exemple 1 : Addition de deux nombres réels
Début
1) Lire (A)
2) Lire (B)
3) Somme=A+B
4) Écriture (Somme)
Fin
 Exemple 2 : Résoudre dans  l‘équation du 2 èmé degré

a x² + b x + c = 0 ,  (a,b,c)≠0
organigramme
 Définitions:
Un organigramme est un schéma
symbolique conventionnel qui illustre les étapes d‘un
algorithme et leurs relations.
 Nous utilisons l’ organigramme parce qu‘une

représentation graphique aide à la compréhension et à
l‘écriture du programme.
 L‘organigramme est un schéma fonctionnel qui représente

les différentes parties d‘un programme les unes à la suite
des autres en utilisant des symboles graphiques pour
visualiser l‘exécution du programme et le cheminement des
opérations.
Principaux Symboles utilisés dans un Organigramme:
NOMS SYMBOLES DEFINITIONS
Flèches Elles indiquent le sens du
traitement(Droite, gauche,
haut, bas)
Début / Fin Ce symbole indique le
début et la fin d’un
organigramme
Entrée / Sortie Ce symbole indique une
opération d’entrée ou de
sortie
Boite de traitement Ce symbole indique une
opération d’affectation
Boite dedécision Elle permet d ’orienter le

(Test) traitement vers un chemin
ou un autre selon le
résultat du test
Entête d‘un Elle indique le début du
Sous-programme sous programme en
spécifiantle nom et les
données
 Exemple 1 :Addition de deux nombres réels
Début
Lire (A)
Lire (B)
Somme=A+B
Écrire (Somme)
Fin
 Exemple 2 :Calcul des racines d'un polynôme du 2e degré:
a x² + b x + c = 0 ,  (a,b,c)≠0
Etapes a suivre pour résoudre
un problème scientifique
3. Étapes de Résolution d’un Problème Informatique
Pour résoudre un problème informatiquement , il faut :
 Poser le problème, l‘analyser et définir avec précision les données et les

résultats à obtenir .
 Déterminer les méthodes de résolution: il s'agit de déterminer la suite des

opérations à effectuer pour obtenir à partir des données, la solution au problème
posé. Cette suite d'opérations constitue un algorithme.
 Formuler l‘algorithme définitif : cette étape doit faciliter la résolution sur

ordinateur par l'expression de l'algorithme dans un formalisme adéquat :
c‘est l‘Etablissement de l‘organigramme
 Traduire l'algorithme (l‘organigramme) dans un langage de

programmation : ceci revient à écrire le programme dans le langage disponible.
 Exécution du programme .
Correction des erreurs et finalisation du programme

Langages de programmation
Machine, Langage et Programmation
Pour communiquer avec un ordinateur, il faut un langage de communication
On appellera langage de programmation un ensemble de « mots-clés »

(choisis arbitrairement) associé à un ensemble de règles très précises
indiquant comment on peut assembler ces mots pour former des « phrases
» que l'interpréteur ou le compilateur puisse traduire en langage machine
(binaire).
LANGAGES DE COMMUNICATION
- Les langage de communication avec la machine peuvent classés en trois catégories :
 Chaque processeur possède un langage propre, directement

exècutable : le langage machine. Il est formé de 0 et de 1 et
n’est pas portable; c’est le seul langage que l’ordinateur comprend ;
le langage d’assemblage est un codage alphanumérique du

langage machine. Il est plus lisible que le langage machine,
mais n’est toujours pas portable. On le traduit en langage
machine par un assembleur ;
les langages de haut niveau ou évolués. Souvent normalisés, ils

permettent le portage d’une machine à l’autre. Ils sont
traduits en langage machine par un compilateur ou un
interpréteur.
- Il existe des centaines de langages de programmation permettant de traduire un

algorithme en une suite d’opérations élémentaires connues de l’ordinateur
(C, C++, FORTRAN, JAVA, PASCAL, COBOL, SIMSCRIPT, GPSS, ADA, APL, …).
Programme - Script
 Un programme est une séquence d'instructions écrites dans un langage de
programmation traduisant un algorithme. Chacune de ses instructions spécifie
l'opération que doit exécuter l'ordinateur.
 Un programme ou un scipt est une suite d‘instructions s‘enchaînant de

manière séquentielle pour résoudre un problème donné.
 Une instruction est composée d‘un ou plusieurs mots clés du langage pour
effectuer une tâche donnée - Chaque instruction du programme est une action.
Une instruction respecte une grammaire et une syntaxe.

Programme en PYTHON :
 Exemple 1: Addition de deux nombres réels
A=float(input(‘donnez la valeur de A:’))
B=float(input(‘donnez la valeur de B:’))
Somme=A+B
print(‘La somme est :’,Somme)
 Exemple 2 : Calcul des racines d'un polynôme du 2 ème ordre :

a x² + b x + c = 0 ,  (a,b,c)≠0
Programme en PASCAL :
Program somme;
Var A,B,Somme : real;
Begin
Read (A);
Read(B);
Somme := A + B ;
write(‘La somme est :’,Somme)
End.

a x² + b x + c = 0 ,  (a,b,c)≠0
Programme en FORTRAN
Read (*,*)A
Read (*,*)B
Somme = A + B ;
write(*,10)somme
10 format(‘La somme est :’,f10.5)
stop
End

a x² + b x + c = 0 ,  (a,b,c)≠0
Compilation et interprétation
• Le programme est écrit à l'aide d'un logiciel appelé
éditeur.(= sorte de traitement de texte spécialisé)- Il est
appelé programme source ( ou code source).
• Il existe deux techniques principales pour effectuer la

traduction d'un programme source en code binaire exécutable
par la machine :
la compilation et l'interprétation
5
Compilation
•La compilation consiste à traduire la totalité du texte source en une fois.

•Le logiciel compilateur lit toutes les lignes du programme source et produit
une nouvelle suite de codes que l'on appelle programme objet (ou code
objet).
•Celui-ci peut désormais être exécuté indépendamment du compilateur et
être conservé tel quel dans un fichier, c’est un fichier exécutable.
Interprétation
•Dans la technique appelée interprétation, le logiciel interpréteur doit être

utilisé chaque fois que l'on veut faire fonctionner le programme.
•Dans cette technique en effet, chaque ligne du programme source analysé
est traduite au fur et à mesure en quelques instructions du langage
machine, qui sont ensuite directement exécutées.
Aucun programme objet n'est généré.
7
Chacune de ces deux techniques a ses avantages et ses inconvénients :
•L'interprétation est idéale lorsque l'on est en phase d'apprentissage

du langage, ou en cours d'expérimentation sur un projet.
Avec cette technique, on peut en effet tester immédiatement toute
modification apportée au programme source, sans passer par une phase de
compilation qui demande toujours du temps.
Par contre, lorsqu'un projet comporte des fonctionnalités
complexes qui doivent s'exécuter rapidement, la
compilation est préférable.
•Un programme compilé fonctionnera toujours nettement plus vite que son
homologue interprété, puisque dans cette technique l'ordinateur n'a plus à
(re)traduire chaque instruction en code binaire avant qu'elle puisse être
exécutée.
Certains langages modernes tentent de combiner les deux techniques afin

de retirer le meilleur de chacune.
C'est le cas de Python et aussi de Java.
• Lorsque vous lui fournissez un programme source,
Python commence par le compiler
• pour produire un code intermédiaire, similaire à un langage machine,
que l'on appelle bytecode,
• lequel sera ensuite transmis à un interpréteur pour l'exécution finale.
• Du point de vue de l'ordinateur, le bytecode est très facile à interpréter en langage

machine.
• Cette interprétation sera donc beaucoup plus rapide que celle d'un code source.
Mise au point d'un programme.
Recherche des erreurs «debug»
3 types d’erreurs :
1. syntaxe : se réfère aux règles que les auteurs du langage ont établies pour la
structure du programme.
2. sémantique : c’est une erreur de logique, i.e, le programme est sans erreurs
mais les résultats sont inattendus.
3. d’exécution ou « Run-time error » : lorsque votre programme fonctionne

déjà, mais que des circonstances particulières se présentent (par exemple,
votre programme essaie de lire un fichier qui n'existe plus, une division par
zéro).
Les erreurs
1. L’erreur de syntaxe
• Python ne peut exécuter un programme que si sa syntaxe

est parfaitement correct
• Dans le cas contraire, le processus s'arrête et vous
obtenez un message d'erreur.
• Le terme syntaxe se réfère aux règles que les auteurs du
langage ont établies pour la structure du programme.
10
Les erreurs (suite)
2. L’erreur sémantique ou logique
•Le programme s'exécute parfaitement, (pas de message d'erreur) mais le
résultat n'est pas celui que vous attendiez.
•Un instruction ou une séquence d'instructions de votre programme ne
correspond pas à l'objectif poursuivi. La sémantique (la logique) est
incorrecte.
• Rechercher des fautes de logique peut être une tâche ardue.
Exemple : dans un traitement répétitif : au lieu de répéter un traitement 10

fois, on le répète 11 fois : c‘est donc une erraur de programmation.
Le programme est correct d‘un point de vue syntaxe mais le résultat n‘est pas
celui qu‘on attend.
Les erreurs (fin)
3. L’erreur à l’exécution
Le troisième type d'erreur est l'erreur en cours d'exécution (Run-time error),
qui apparaît seulement lorsque votre programme fonctionne déjà,
mais que des circonstances particulières se présentent
(par exemple, votre programme essaie de lire un fichier qui n'existe plus
ou bien il obtient une division par zéro lors d‘un calcul).
Ces erreurs sont également appelées des exceptions,

parce qu'elles indiquent généralement que
quelque chose d'exceptionnel s'est produit (et qui n'avait pas été prévu).
Vous rencontrerez davantage ce type d'erreur

lorsque vous programmerez des projets de plus en plus volumineux.
Langage python
INSTALLATION DU LANGAGE PYTHON
( Sous windows )
 Installer Python sous Windows :
Pour installer Python sous Windows, téléchargez votre version du site officiel
du langage https://www.python.org/downloads/
Il installera aussi IDLE qui permet d’utiliser le shell python, d’écrire et
exécuter nos codes
Après installation
Présentation de l'environement Python
Python est un langage interprété, portable, dynamique, extensible, gratuit, qui
permet une approche modulaire et orientée objet de la programmation.
Il est doté d'un typage dynamique fort, d'une gestion automatique de la

mémoire par ramasse-miettes et d'un système de gestion d'exceptions ; il est
ainsi similaire àPerl, Ruby, Scheme, Smalltalk et Tcl.
Le langage Python est placé sous une licence libre proche de la licence
BSD et fonctionne sur la plupart des plates-formes informatiques,
des supercalculateurs aux ordinateurs centraux, de Windows à Unix en
passant par GNU/Linux, Mac OS, ou encore Android, iOS, et aussi
avec Java ou encore .NET.
Il est conçu pour optimiser la productivité des programmeurs en offrant des

outils de haut niveau et une syntaxe simple à utiliser.
Il est également apprécié par les pédagogues qui y trouvent un langage où la

syntaxe, clairement séparée des mécanismes de bas niveau, permet une
initiation aisée aux concepts de base de la programmation.
 Historique :
1991 : Guido van Rossum publie Python au CWI (Pays-
Bas) à partir du langage ABC et du projet AMOEBA
(système d'exploitation distribué) – Il tire son nom d’une
célèbre série TV des années 70 "Monty Python"
1994 : sortie de la version 1.0
1996 : sortie de Numerical Python
2000 : sortie de la version 2.0 Guido van Rossum,

créateur du Python
2001 : naissance de de la PSF (Python Software Fundation)
2008 : sorties simultanées de Python 2.6 et de Python 3
2009 : sorties simultanées de Python 2.7 et de Python 3.1
Octobre 2014 : versions 2.7.8 et 3.4.2 (c’est la version que nous allons utiliser)
La version 2x n’évolue plus, elle est remplacée progressivement par la version 3x

 Interpréteur interactif du Python :
L'interpréteur interactif permet d'écrire et d'exécuter du code Python à la
volée, de faire des tests rapides, d'obtenir facilement des informations sur
une fonction ou un module, ...
La distribution standard de Python en propose 2:
o Shell interactif (command line): console Python la plus basique
o IDLE: console écrite avec le toolkit Tkinter
Le signe >>> constituent le signal d’invite, ou prompt principal, lequel

vous indique que Python est prêt à exécuter une commande.
IDLE « Integrated DeveLopment Environment » : est un environnement de
développement intégré pour le langage Python.
Les principales fonctionnalités de IDLE sont :
o l'éditeur de texte ;
o le terminal Python avec coloration syntaxique ;
o le débogueur intégré avec avancement par étape, point
d'arrêts persistants et pile d'appels.
1. Présentation de l'environement Python(suite)
IDLE peut être utilisé comme une simple calculatrice : on tape les
expressions mathématiques qui sont immédiatement évaluées pour afficher
le résultat.
>>> 45.25+(12.25*4)/2
69.75
>>>
Si la commande/l'expression n'est pas reconnue : erreur
>>> pi/2
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
pi/2
NameError: name 'pi' is not defined
>>>
1. Présentation de l'environement Python
 Ecriture d’un script (programme) Python :
IDLE en plus d'être un Shell interactif est aussi un éditeur spécialement
conçu pour des programmes Python.
Pour ouvrir IDLE en mode éditeur, vous
pouvez, à partir du mode interactif, aller
dans le menu File → New Window.
S'ouvrira alors l'éditeur de IDLE.
Vous pouvez alors écrire un programme Python et l'enregistrer dans un

fichier d'extension .py.
2. Les Identificateurs
Pour manipuler différents objets dans un programme, il
faut leur donner des noms.
Les noms utilisés pour les objets manipulés sont des

identificateurs.
Définition :
L’identificateur est un nom symbolique utilisé pour nommer

(identifier) un objet dans un programme informatique.
2. Les Identificateurs(suite)
 Règles d’écriture d’un identificateur :
Les identificateurs sont représentés par une suite de lettres

et/ou de chiffres avec les restrictions suivantes :
 le premier caractère doit être alphabétique, donc une lettre

obligatoirement ;
 les caractères suivant le premier peuvent être numériques ;
 Seules les lettres ordinaires sont autorisées. Les lettres

accentuées, les cédilles, les espaces, les caractères spéciaux
tels que $, #, @, etc. sont interdits, à l’exception du
caractère _ (souligné).
 Règles d’écriture d’un identificateur :
 La casse est significative (les caractères majuscules et

minuscules sont distincts).
Exemple: LMDSM, lmdSM, LMDsm, lmdsm
Isont 4 identificateurs différents.
 l’utilisation des mots clés (réservés) du langage est interdite.
Exemples :
Sont des identificateurs
ValeurM, Valeur_A, AB, B7, Nom
corrects
Sont des identificateurs
Valeur M, Valeur-A, A/B, 7B, Nom$
incorrects
 Les 33 mots clés (mots réservés) du langage
:
and, as, assert, break, class, continue,
def, del, elif, else, except, False,
finally, for, from, global, if, import, in,
is, lambda, None, nonlocal, not, or, pass,
raise, return, True, try, while, with,
yield.
sont des mots standards imposés par Python ; leur

signification et leur rôle sont parfaitement définis. On les
appelle mots clés ou mots réservés.
 Conventions de nommage :
Au-delà de ces règles de syntaxe incontournables, il existe des

conventions définies par les programmeurs eux-mêmes
 écrire l’identificateur en minuscules et à remplacer les
espaces éventuels par un espace souligné. Ex: mon_age
 passer en majuscule le premier caractère de chaque mot, à

l'exception du premier mot constituant l’identificateur
Ex: monAge
 Utiliser des noms significatifs. Ex: Au lieu de a, b, c, et d,

préférer prix_unitaire, nbr_art, tva, montant.
 Nommer les constantes (les variables que vous ne voulez

pas changer) TOUT EN MAJUSCULES.
4. Types de Données en Python
La notion de type est liée à la notion de donnée. C'est l'ensemble
des valeurs que peut prendre une donnée.
Donc le type désigne, pour un langage de programmation, deux

ensembles :
• un ensemble de valeurs désigné explicitement ou par des valeurs
extrêmes,
• un ensemble d'opérations permises par le type.
Sous Python, il n’est pas nécessaire d’écrire des lignes de programme
spécifiques pour définir le type des variables avant de pouvoir les
utiliser.
Le typage des variables sous Python est un typage dynamique, par

opposition au typage statique qui est de règle par exemple en C ou en
Pascal. Dans ces langages, il faut d’abord déclarer le nom et le type
4. Types de Données en Python(suite)
 Types de Données Simples (Standards)
En Python, il existe 5 types de données simples (standards) :
 Le type Entier (Integer) → int
 Le type Réel (Float) → float
 Le type Complexe → complex
 Le type Booléen (Boolean)
 Le type Chaîne de caractères (String)→ str
Rem: Il existe des types de données plus avancés, que nous verrons par
la suite.
A. Type Entier (Int) : (provient de Integer qui veut dir entier)

Le type Entier spécifié par l'identificateur standard int correspond à
l'ensemble des nombres entiers (éléments de )
Représentation des valeurs

Les entiers s’écrivent en notation décimale avec éventuellement un
signe + ou – devant et ne doit pas commencer par un zéro (sauf pour
la valeur 0)
Exemple : +23 23 0 -6 521487932644558112
(pas de limite en Python, tant que la RAM est suffisante)
Il peut être écrit en binaire (base 2) en le faisant précéder par 0b, en
octal (base 8) avec 0o ou en hexadécimal (base 16) avec 0x
Exemple : 42 0b101010 0o52 0x2a ont la même valeur
B. Type Réel (float) :
Le type Réel spécifié par l'identificateur standard float

correspond à l'ensemble des nombres réels.
Un nombre réel comporte obligatoirement soit une virgule décimale
sous forme d'un point (pas une virgule), soit un symbole e/E signifiant
"10 puissance...".
Exemple : 12.43 -0.45 20E+2 0.45e-4 -1.5E1
Il peut ne rien y avoir avant ou après le point :

Exemple : .18 égale 0.18 et 18. égale 18.0 (mais ne sont
pas du même type que 18 qui est un entier)
C. Type Complexe (complex) :
Le type complexe spécifié par l'identificateur standard

complex correspond à l'ensemble des nombres complexe.
Elles sont utilisées pour écrire la partie imaginaire des nombres
complexes. Si un nombre complexe a une partie réelle, on additionne
la partie imaginaire à un float.
Elles sont constituées d'un nombre réel ou entier suivi de la lettre j
Exemple : 1.25j -5.j 5j 0.05j -1.5e1j -12.25+2j
Rem : le nombre imaginaire i (racine carrée de -1) s’écrit donc 1j

D. Type Booléen :
Le type booléen, dit type logique, est un type symbolique qui

ne peut recevoir que deux valeurs logiques : True (Vrai) et
False (Faux).
Exemple :
>>> a=True
>>> b=False
>>> print(a,b)
True False
>>>
E. Type Chaîne de caractères (str) :
Une chaîne de caractères est une suite de caractères codée sous la

forme d’une séquence de code ASCII.

Les chaînes s’écrivent sous la forme d’une suite de caractères
encadrées soit par des guillemets" " ou par des apostrophes ‘ ’.
Elles sont constituées de n’importe quels caractères (lettres, chiffres,
espaces, ponctuation...).
Exemple : "Salam" ‘bonjour’ "12547" ‘12xA= B’
"j’ai dit Bonjour! :)"
E. Type Chaîne de caractères (str) : (suite)

Pour représenter certains caractères, on doit souvent utiliser une des
séquences d'échappement telles que :
\' pour le caractère ', \" pour le caractère ", \\ pour le caractère \,
\n pour un retour à la ligne , \t pour une tabulation
Exemple :
>>> print("Je suis étudiant(e) à l\'Université de Tlemcen \nFaculté
des Sciences\\\t\„2ème L2 Physique\"")
Je suis étudiant(e) à l'Université de Tlemcen
Faculté des Sciences\ "1ère LMD SM"
>>>
 Typage dynamique
On peut connaitre le type courant d'une variable avec la

fonction type . On utilise pour cela la syntaxe suivante :
type(identificateur)
Exemple :
>>> a=20 >>> ch="Bonjour"

>>> type(a) >>> type(ch)
<class 'int'> <class 'str'>
>>> b=12.25
>>> B=True
>>> type(b)
>>> type(B)
<class 'float'>
<class 'bool'>
>>> z=-4.25+2j
>>> type(z) >>>
<class 'complex'>
 Conversion de type
Il existe plusieurs fonctions qui permettent de forcer le type d'une
variable en un autre type.
Fonction de
Signification Exemples
conversion
permet de modifier une variable >>> x=1.25
int() en entier, provoque une erreur si >>> int(x)
cela n'est pas possible 1
>>> x=1
permet la transformation en
float() >>> float(x)
flottant (réel)
1.0
permet de transformer la plupart >>> x=1.25

str() des variables d'un autre type en >>> str(x)
chaînes de caractère '1.25'
>>> x=1.25
permet la transformation en
complex() >>> complex(x)
complex (complexe)
(1.25+0j)
 Conversion de type (suite)
Exemple :
>>> x='157'
>>> int(x)
157
>>> float(x)
157.0
>>> y='157a12'
>>> int(y)
int(y)
ValueError: invalid literal for int() with base 10: '157a12'
>>> float(y)
float(y)
ValueError: could not convert string to float: '157a12
5. Affectation (ou Assignation)
Définition :
L’affectation permet d’attribuer une valeur ou une expression à
une variable de même type.
 Syntaxe
Dans les algorithmes, on note souvent l'opérateur

d'affectation par une flèche gauche
En Python, l'opérateur d'affectation est le symbole = et se lit

« reçoit » (pour ne pas le confondre avec le symbole
d'égalité ==). La syntaxe de l'instruction est donc :
identificateur_variable = valeur
5. Affectation (ou Assignation)(suite)
Exemple 1:
>>> n=5
>>> message="Salut tout le monde"
>>> pi=3.14159
Les exemples ci-dessus illustrent des instructions d’affectation Python tout

à fait classiques.
Après qu’on les ait exécutées, il existe dans la mémoire de l’ordinateur, à

des endroits différents:
o trois noms de variables, à savoir n , message et pi ;
o trois séquences d’octets, ou sont encodées le nombre entier 5, la
chaine de caractères Salut tout le monde et le nombre réel
3,14159.
Exemple 1 (suite):
Pour afficher leur valeur à l’écran, il existe deux possibilités. La première
consiste à entrer au clavier le nom de la variable, puis <Enter>. Python
répond en affichant la valeur correspondante :
>>> n
5
>>> message
'Salut tout le monde'
>>> pi
3.14159
Il s’agit cependant la d’une fonctionnalité secondaire de l’interpréteur, qui

est destinée à vous faciliter la vie lorsque vous faites de simples exercices
à la ligne de commande.
Exemple 1 (suite):
A l’intérieur d’un programme, vous utiliserez toujours la fonction print()
>>> print(n)
5
>>> print(message)
Salut tout le monde
>>> print(pi)
3.14159
La fonction print() n’affiche strictement que la valeur de la variable,

telle qu’elle a été encodée, alors que l’autre méthode (celle qui consiste
à entrer seulement le nom de la variable) affiche aussi des apostrophes
afin de vous rappeler que la variable traitée est du type « chaine de
caractères »
Les variables évoluent c.à.d. que la valeur d’une même variable peut
changée au cours du temps.
Exemple 2:
>>> energie
File "<pyshell#0>", line 1,
1, in <module>
energie
NameError: name 'energie' is not defined
>>> energie=120
>>> print(energie)
120
>>> energie=50.45
>>> print(energie)
50.45
>>>
On peut affecter à une variable une expression qui contient non seulement
des constantes littérales et/ou d'autres variables mais aussi la même
variable, ce qui peut sembler étrange si on oublie que = n'a pas la même
signification qu'en mathématiques.
Exemple 3:
>>> x=1.02
>>> y=0.05
>>> x=2*x-4*y
>>> print(x)
1.84
>>>
L’expression x=2*x-4*y signifie calculer la valeur de 2x-4y et remplacer la
valeur qui se trouve dans x par le résultat de ce calcul.
Une affectation qui est souvent utilisée est celle qui permet d'augmenter
(on dit incrémenter) la valeur d'une variable de 1.
De même, on peut décrémenter.
Exemple 4:
>>> x=1
>>> x=x+1
>>> print(x)
2
>>> x=x-1
>>> print(x)
1
>>>
Il existe des instructions d' affectation augmentée qui permettent de
raccourcir ces écritures.
Expression Python équivaut à Exemples

>>> x=1
>>> x+=1
a += b a=a+b
>>> print(x)
2
>>> x=1
>>> x-=1
a -= b a=a-b
>>> print(x)
0
>>> x=2
>>> x*=3
a *= b a=a*b
>>> print(x)
6
Expression Python équivaut à Exemples
>>> x=6
>>> x/=2
a /= b a=a/b
>>> print(x)
3.0
>>> x=6
>>> x//=4
a //= b a = a // b
>>> print(x)
1
>>> x=6
>>> x%=4
a %= b a=a%b
>>> print(x)
2
>>> x=2.0
>>> x**=3
a **= b a = a ** b
>>> print(x)
8.0
 Affectation multiple
Python autorise l’affectation multiple.
Sous Python, on peut assigner une valeur a plusieurs variables

simultanément :
>>> x=y=12
>>> print(x,y)
12 12
>>>
On peut aussi effectuer des affectations parallèles a l’aide d’un seul
opérateur
>>> x,y = 10,11
>>> print(x,y)
10 11
>>>
 Affectation multiple (suite)
Sous Python, parmi les avantages de l'affectation parallèle: elle permet

d'échanger les valeurs de 2 variables sans avoir à utiliser une variable
auxiliaire (contrairement à d’autres langages sans affectation multiple).
>>> x,y = 10,11 >>> x,y = 10,11

>>> print(x,y) >>> z = x
10 11 >>> x = y
>>> x,y = y,x >>> y = z
>>>print(x,y) >>> print(x,y)
11 10 11 10
>>> >>>
Affectation directe Utilisation d’une variable
auxiliaire z
 ATTENTION
Affecter n’est pas comparer.
>>> a=2
>>> b=2
>>> a=b
L’affectation n’est pas commutative (le sens de lecture se fait toujours de

droite à gauche)
>>> a=2
>>> 2=a
SyntaxError: can't assign to literal
>>>
6. Les Séparateurs
Séparateurs Définition Exemple
Sépare 2 instructions sur une

>>> a=123 ; b=145
; même ligne dans le shell ou
>>> a ; b
dans un script
123
145
La virgule entre 2 expressions >>> a , b
, est un constructeur de (123, 145)
séquence
>>> for i in range(0,3):

C’est un composant syntaxique print(i)
: des boucles et instructions 0
conditionnelles 1
2
7. Les opérateurs
Un opérateur est un signe qui agit sur une ou plusieurs valeurs (appelées
opérandes), pour produire un résultat. Les opérandes sont les valeurs
combinées a l’aide des opérateurs.
Exemple : + , - , * , / , ** , // , %, …
Il existe plusieurs familles d’opérateurs :
o Opérateursarithmétiques
o Opérateurs alphanumériques
o Opérateurs de comparaison
o Opérateurs logiques
7. Les opérateurs(suite)
Type Notation Signification Exemples
+ Addition >>> 12.25+10
22.25
- Soustraction >>> 12*5
60
* Multiplication >>> 15/2
Opérateurs / Division 7.5
arithmétiques >>> 15//2
// Division entière 7
>>> 15%2
% Modulo (reste d’une division) 1
>>> 2**4
** Puissance 16
>>> ch1='Bonjour'
Concaténations de >>> ch2=' Monsieur'
+
chaînes de caractères >>> ch3=ch1+ch2
Opérateurs >>> ch4=(ch1+'! ')*3
alphanumériques >>> print(ch3)
Répéter une même Bonjour Monsieur
* chaîne de caractères >>> print(ch4)
autant de fois qu’on veut
Bonjour! Bonjour! Bonjour!
Priorité des opérations
PEMDAS pour le mémoriser !
1. P pour parenthèses. Ce sont elles qui ont la plus haute priorité. Elles vous
permettent donc de « forcer » l'évaluation d'une expression dans l'ordre que vous
voulez. Ainsi 2*(3-1) = 4 , et (1+1)**(5-2) = 8.
2. E pour exposants. Les exposants sont évalués avant les autres opérations. Ainsi
2**1+1 = 3 (et non 4), et 3*1**10 = 3 (et non 59049 !).
3. M et D pour multiplication et division, qui ont la même priorité. Elles sont

évaluées avant l'addition A et la soustraction S, lesquelles sont donc effectuées en
dernier lieu. Ainsi 2*3-1 = 5 (plutôt que 4), et 2/3-1 = -1 (Rappelez-vous que par
défaut Python effectue une division entière).
4. Si deux opérateurs ont la même priorité, l'évaluation est effectuée de

gauche à droite. Ainsi dans l'expression 59*100/60, la multiplication est
effectuée en premier, et la machine doit donc ensuite effectuer 5900/60, ce
qui donne 98. Si la division était effectuée en premier, le résultat serait 59
(rappelez-vous ici encore qu'il s'agit d'une division entière).
 ATTENTION
On ne peut concaténer que des chaînes de caractères
Si on veut concaténer une chaine de caractères et une valeur numérique, il
faut d'abord convertir la valeur numérique en chaine de caractères avec la
fonction str .
>>> vitesse=50
>>> print("La valeur de la vitesse est " + vitesse + " km/h")
print("La valeur de la vitesse est" + vitesse + "km/h")
TypeError: Can't convert 'int' object to str implicitly
>>> print("La valeur de la vitesse est " + str(vitesse) + " km/h")

La valeur de la vitesse est 50 km/h
Type Notation Signification Exemples
== Égale (=) >>> 2 == 5
False
< Inférieur >>> 12 > 5
True
> Supérieur >>> 12 < 5
Opérateurs de
False
comparaison <= Inférieur ou égale (≤)
>>> V=10
>= >>> 2 <= V <= 15
Supérieur ou égale (≥)
True
>>> 2!=4
!= Différent (≠) True
>>> a=2 ; b=5 ; c=3 ; d=6

and Et (Conjonction)
>>> (a < b)and(c < d)
True
Opérateurs
logique
or Ou (Disjonction) >>> (a < b)or(c > d)
True
>>>not(a < b)
not Non ( Négation) False
Les valeurs comparées peuvent être à priori de n’importe quel type
(numériques, caractères,…) , mais la comparaison n’a de sens que si les
deux valeurs comparées sont de même type.
On peut très bien comparer des caractères (leur code ASCII est comparé -
ordre alphabétique, avec les majuscules avant les minuscules), et des
chaînes de caractère .
>>> "a" < "b"

True
>>> "vitesse 1" > "vitesse 2"
False
>>> "12" < "2"
True
8. Entées – Sorties
Définition :
Pour faire fonctionner un programme il faut lui fournir des
données et prévoir la possibilité de récupérer les résultats. Ces
deux opérations portent le nom générique d’opérations
d’entrée/sortie. Donc il s’agit de deux opérations distinctes :
 Entrée de données (Lecture des données par la machine)

 Sortie de résultats (Écriture des résultats par la machine)
En Python, les opérations d’entrée/sortie sont réalisées par deux

fonctions prédéfinis :
input – fonction standard de lecture
print – fonction standard d’écriture
8. Entées – Sorties (suite)
A. Instruction de Lecture (input) :
L’instruction de lecture permet à l’utilisateur de saisir des valeurs

au clavier (ou a partir d’un fichier) pour qu’elles soient utilisées par
le programme.
Dès que le programme rencontre une instruction input
l’exécution s’interrompe attendant la saisi d’une valeur
.
On peut invoquer la fonction input()en laissant les parenthèses
vides. On peut aussi y placer en argument un message explicatif
destiné à l’utilisateur.
>>> a=input() >>> a=input('Donnez la valeur de a ')

10 Donnez la valeur de a 10
>>> a >>> a
'10' '10'
A. Instruction de Lecture (input) : (suite)
Le type de la variable créée par la fonction input() renvoie toujours

une chaine de caractères. Si vous souhaitez que l’utilisateur entre une
valeur numérique, vous devrez donc convertir la valeur entrée (qui sera
donc de toute façon de type string) en une valeur numérique du type qui
vous convient, par l’intermédiaire des fonctions intégrées:
o int()(si vous attendez un entier)
o float()(si vous attendez un réel)
o complex()(si vous attendez un complexe – sans l’utilisation d’un message explicatif)
>>> A=int(input('A= ')) >>> C=complex(input())

A= 10
4+1j
>>> A
10 >>> C
>>> B=float(input('B= ')) (4+1j)
B= 5.25
>>> B
5.25
B. Instruction d’Écriture (print) :
L’instruction d’écriture permet au programme de communiquer des

valeurs (ou des messages) à l’utilisateur en les affichant à l’écran
(ou sur un fichier).
La fonction print permet d’afficher n’importe quel nombre de
valeurs fourniesen arguments(c’est-a-dire entre les parenthèses).
Par défaut, ces valeurs seront séparées les unes des autres par
un espace, et le tout se terminera par un saut a la ligne.
>>> A=float(input('A= '))
A= 12.25
>>> B=float(input('B= '))
B= 5.35
>>> print(A,B)
12.25 5.35
8. Entées – Sorties (suite) (suite)
On peut remplacer le séparateur par défaut (l’espace) par un

autre caractère quelconque (ou même par aucun caractère),
grâce a l’argument « sep ».
>>> print('Bonjour tout le monde')
Bonjour tous le monde
>>> print('Bonjour','tout','le monde')
Bonjour tous le monde
>>> print('Bonjour','tout','le monde',sep='+')
Bonjour+tous+le monde
>>> print('Bonjour','tout','le monde',sep="")
Bonjourtousle monde
>>>
B. Instruction d’Écriture (print) : (suite)
De même, on peut remplacer le saut à la ligne terminal avec

l’argument « end »
>>> =============== RESTART =================

>>>
a= 12
b= 3.05
a= 12b= 3.05
>>>
 Imposition d’un format d’affichage :

Tous les types d’expressions figurant dans une instruction
print peuvent se voir imposer un gabarit (nombre de cases).
La liste des principaux formats possibles :

o %d : entier
o %f : réel
o %s : chaine de caractères
o %r : booléen
 Imposition d’un format d’affichage :(suite)

>>> A=10
>>> print(A)
10
>>> print("%15d"%A)
10
>>> a=12.34
>>> b=1.024
>>> c=a/b
>>> print(c)
12.05078125
>>> print("%5.2f"%c)
12.05
>>>
8. Entées – Sorties (suite) (suite)
 Imposition d’un format d’affichage :(suite)

>>> vitesse=50
>>> print("La valeur de la vitesse est %d km/h"%vitesse)
La valeur de la vitesse est 50 km/h
>>> print("La valeur de la vitesse est %f km/h"%vitesse)
La valeur de la vitesse est 50.000000 km/h
>>> print("La valeur de la vitesse est %7.3f km/h"%vitesse)
La valeur de la vitesse est 50.000 km/h
>>> nom='vitesse'
>>> print('la %s est égale à %f Km/h'%(nom,vitesse))
la vitesse est égale à 50.000000 Km/h
>>>
9. Les Commentaires
Comme tout langage évolué, Python permet la présence de

commentaires.
Les commentaires sont des textes explicatifs destinés aux lecteurs
du programme et qui ne seront pas lus par la machine.
En Python les commentaires commencent toujours par le
caractère # jusqu'a la fin de la ligne.
#Ceci est un commentaire

Vitesse=50 #nous affectant la valeur 50 à la variable vitesse
print(vitesse) #Affichage de la variable vitesse
10.Fonctions Prédéfinies – Notion de Module
Les fonctions permettent de décomposer un programme complexe
en une série de sous-programmes plus simples, lesquels peuvent
à leur tour être décomposés en fragments plus petits, et ainsi de
suite.
Il existe des fonctions intégrées au langage lui-même, comme la
fonction float() par exemple. Ces fonctions sont associées à
des fonctions intégrées à l’interface qu’on utilise, appelées aussi
builtins functions
Pour avoir la liste complète de ces fonctions et l’aide pour leur
utilisation, nous écrivons:
>>> import builtins; dir(builtins)
>>> help(builtins)
10.Fonctions Prédéfinies – Notion de Module (suite)
Cependant il n’est pas possible d’intégrer toutes les fonctions dans
le corps standard de Python, car il en existe une infinité.
Les fonctions intégrées au langage sont relativement peu
nombreuses : ce sont seulement celles qui sont susceptibles d’être
utilisées très fréquemment.
Les autres sont regroupées dans des fichiers séparés que l’on
appelle des modules .
Les modules sont des fichiers qui regroupent des ensembles de
fonctions.
Il existe un grand nombre de modules qui sont fournis d’office avec
Python. Souvent on essaie de regrouper dans un même module
des ensembles de fonctions apparentées, que l’on appelle des
bibliothèques.
Le module math, par exemple, contient les définitions de
nombreuses fonctions mathématiques telles que sinus, cosinus,
tangente, racine carrée, etc.
utilisation, nous écrivons:

>>> import math; dir(math)
>>> help(math)
Pour pouvoir utiliser ces fonctions, il vous suffit d’incorporer la

ligne suivante au début de votre programme :
from math import *
Cette ligne indique a Python qu’il lui faut inclure dans le programme courant
toutes les fonctions (c’est la signification du symbole * ) du modulemath, lequel
contient une bibliothèque de fonctions mathématiques préprogrammées.
Exemple :
>>> sqrt(25)
sqrt(25)
NameError: name 'sqrt' is not defined
>>> from math import *
>>> sqrt(25)
5
>>>
Structures de Contrôle
1. Introduction
Définition :
Une structure de contrôle sert à contrôler le déroulement

d’un traitement.
Un traitement peut s’exécuter de différentes manières :
Séquentielle
Alternative (condition) : traitement conditionnel
Répétitive (boucle) : traitement répétitif

2. Le traitement séquentiel
Le traitement séquentiel est une suite d’instruction qui s’exécutent
l’une à la suite de l’autre.
Début
Début
Instruction 1 Instruction 1
Instruction 2
Séquence d’instructions
Instruction 2 …
Instruction N
Fin
Instruction N
Exemple:
Fin
2. Le traitement séquentiel (suite)
Exemple : Addition de deux nombres A et B
A=float(input('donnez la valeur de A: '))

B=float(input('donnez la valeur de B: '))
Somme = A+B
print('La somme est :',Somme)
Suite d’instructions
s’exécutant
séquentiellement
3. Le traitement alternatif (structures de choix)
L’instruction de choix permet la sélection entre deux possibilité

(appelée sélection binaire).
La condition s’exprime sous la forme:
d’une expression logique booléenne simple (condition
simple).
EX: Si (A=B) alors …
ou combinée, plusieurs conditions composées avec des

opérations logiques ET, OU et NON.
EX: Si (A=B) et (A=C) alors …
3. Le traitement alternatif (suite)
A. Structure conditionnelle simple (if … )
La structure conditionnelle simple se présente sous la forme

suivante:
non oui SI (condition) alors
Exp.logique
séquence
Séquence FSI
lire Fin SI
Principe :
Si la condition est vérifiée (vraie) alors la séquence

d’instructions s’exécute. Dans le cas contraire, ne rien faire.
Traduction en Python:
Instruction simple: la forme générale est :

if <condition> : Instruction
Bloc d’instructions : présentation en pratique .
if <condition> :
Instruction 1
Instruction 2
Bloc d’instructions
…
Instruction n
indentation
Atention à l‘indentation !!!!

L’importance fondamentale de l’indentation en Python:
Dans un même bloc, deux instructions de même profondeur logique

doivent avoir strictement la même indentation (décalage vers la droite).
Avec une telle convention,il est inutile de marquer le début et la fin d’un
bloc par des éléments du langage (comme des accolades { et }, ou les
mots réservés begin et end).
Il faut un respect scrupuleux des indentations, mais on est aidé en cela

par l’éditeur de Idle, qui augmente automatiquement l’indentation après
chaque instruction d’en tête, et qui conserve cette indentation à
l’intérieur du bloc courant.
Exemple: Comparaison de deux variables
Lire A
Lire B
non oui
A>B
Ecrire „A est
supérieur à B“
Programme:
A=float(input('A= '))
B=float(input('B= '))
if A > B :
print (A,'est supérieur à',B)
B. Structure conditionnelle composée (if … else …)
La structure conditionnelle composée se présente sous la forme
suivante:
SI (condition) ALORS
séquence 1
SINON
séquence 2
FSI
Principe :
Si la condition est vérifiée alors la séquence 1 s’exécute.

Dans le cas contraire, c’est la séquence 2 qui va s’exécuter.
La structure conditionnelle composée se présente sous la forme
suivante:
non oui
Exp.logique
Séquence 2 Séquence 1
if <condition> : < Instruction 1>
else : < Instruction 2>
if <condition> :
<séquence1>
else :
<séquence2>
ATTENTION : le else est sur au même niveau d'indentation que le if

Exemple: Comparaison de deux variables
Début
Lire (A,B)
faux vrai
A>B
Écrire (A inférieur ou Écrire (A

égale à B) supérieur à B)
Fin
Programme: Première écriture
if A > B : print (A,'est supérieur à',B)
else : print (A,'est inférieur ou égale à‘ ,B)
Cette écriture est déconseillée
Programme: Deuxième écriture

if A > B :
else :
print (A,'est inférieur ou égale à',B)
Exemple 2: Ecrire un programme python qui lit un entier x et affiche

ensuite s’il est pair ou impair.
Début
Lire X
Y=X%2
faux vrai
Y == 0
Écrire „Y est impair“ Écrire „Y est pair“
Fin
C. Structure conditionnelle multiple (if … elif … else …)
La structure conditionnelle multiple se présente sous la forme
suivante:
SI (condition1) ALORS
séquence 1
SINON SI (condition2) ALORS
séquence 2
SINON SI (condition3) ALORS
séquence 3
…
SINON
séquence n
FSI
Principe :
Si la condition1 est vérifiée alors la séquence 1 s’exécute.

Sinon si la condition2 est vérifiée alors la séquence 2
s’exécute . Sinon si la condition 3 est vérifiée alors la
séquence 3 s’exécute … Dans le cas contraire (SINON) ,
c’est la séquence n qui vas s’exécuter.
Remarque :
Cette structure de contrôle présente plusieurs cas d’exécutions
du traitement mais un seul cas sera exécuté.
Le mot clé elif est une contraction de
if <condition1>:
« else if », que l'on peut traduire très
<séquence 1>
littéralement par « sinon si ».
elif <condition2>:
ATTENTION : De même que le else, le
<séquence 2>
elif est sur le même niveau d'indentation
elif <condition3>: que le if initial. Il se termine aussi par
<séquence 3> deux points. Cependant, entre le elif et
………… les deux points se trouve une nouvelle
else : condition.
<séquence n>
if <condition1>:
non oui
Condition 1
<séquence 1>
elif <condition2>: Séquence 1
non oui
Condition 2
<séquence 2>
elif <condition3>: Séquence 2
oui
<séquence 3> Condition 3
…………
non Séquence 3
else :
<séquence n>
Organigramme
Début
Lire (A,B)
faux vrai
A>B
faux vrai
A=B
Écrire (A est
Écrire (A est inférieur à B) Écrire (A est égale à B) supérieur à B)
Fin
Programme
if A > B :
elif A == B :
print (A,'est égale à',B)
else :
print (A,'est inférieur à',B)
Exemple: Calcul du produit, somme et la moyenne de trois réels
suivant un choix
Début
1) Lire (nb1, nb2, nb3)
2) Lire (Choix)
3) SI Choix=‘1’ Alors Écrire (‘Le produit est : ’, nb1*nb2*nb3)
4) SINON SI Choix=‘2’Alors Écrire (‘La somme est : ’,nb1+nb2+nb3)
5) SINON SI Choix=‘3’Alors Écrire (‘La moyenne est : ’,(nb1+nb2+nb3)/3)
6) SINON Écrire (‘Choix incorrecte’)FSI
Fin
Programme
# Programme menu
print('Entrer trois nombres réels: ')
nb1=float(input('Donnez la valeur du 1er nombre: '))
nb2=float(input('Donnez la valeur du 2ème nombre: '))
nb3=float(input('Donnez la valeur du 3ème nombre: '))
print(20*'-')
choix=input('Donnez un choix= ')
print(20*'-')
if choix == '1' :
print ('Le produit est:',nb1*nb2*nb3)
elif choix == '2' :
print ('La somme est:',nb1+nb2+nb3)
elif choix == '3' :
print ('La moyenne est:',(nb1+nb2+nb3)/3)
else :
print ('Choix incorrect')
4. Le traitement répétitif (les boucles)
Dans un programme, il arrive souvent qu’une ou plusieurs instructions
doivent être exécuter plusieurs fois dans une structure répétitive appelée
boucle.
Dans une boucle, le nombre de répétitions:

Peut dépendre d’une condition permettant l’arrêt et la sortie de cette
boucle.
Peut être connu, fixé à l’avance.
Dans le langage Python on dispose de deux structures pour contrôler

un traitement répétitif:
La boucle "Tant que ".
La boucle "Pour " .
4. Le traitement répétitif (suite)
A. La boucle "Tant que " (while )
La boucle "Tant que " se présente sous la forme suivante:
non
Tant que (condition) faire
Condition
oui séquence
Séquence
Fin tant que
Principe :
Tant que la condition est vérifiée la séquence s’exécute. Elle ne
s’arrêtera que lorsque la condition n‘est pas vérifiée .
Première écriture:
WHILE <condition> : < Instruction >
Attention à l’indentation !!! Lorsqu'on a un

Deuxième écriture bloc d’instructions après l’instruction while,
WHILE <condition> : il est délimité par l'indentation.
<séquence> L'instruction Python "while" exécute de
manière répétitive le bloc indenté tant que
le test de condition est réalisé. Si la
condition est d'emblée fausse le bloc ne
sera jamais exécuté.
Exemple: Afficher les 100 premiers nombre entiers positifs
Début
1) i1
2) Tant que i 100 faire
3) Écrire(i)
4) i i+1 Fin tant que
Fin
Programme
i=1 # Initialisation
while i<=100 :
print(i,end=' ')
i+=1 # Incrémentation
Attention ! Il faut bien choisir le test d’arrêt de la

boucle sinon on obtient uneboucle infinie.
Exemple:
r = 1.5 # initialisation du nombre réel
while r > 0 : # condition vraie étant donné l'initialisation

print(r)
r += 2 # Incrémentation
C’est une boucle infinie parce que l’incrémentation du nombre r par 2 renvoie
toujours une valeur positive. La conditionr > 0 est toujours vraie.
On peut forcer l’arrêt d’un script Python en tapant [Ctrl] [C]

Exemple: Afficher la table de multiplication d’un nombre

B. La boucle "Pour " (for … in … )
 Notion d’intervalle – Fonction prédéfinie "range" :

On est souvent amené à répéter plusieurs fois un bloc d’instructions en
fonction des valeurs successives d’un compteur.
Une façon simple d’indiquer la plage des valeurs possibles de ce
compteur est d’utiliser un intervalle (ou encore "range" dans le langage
Python).
La syntaxe de la fonction "range" est :
range(a,b,h) où a, b, h sont des valeurs entières
La valeur a représente le début de l’intervalle, et par défaut elle vaut 0.

La valeur b représente la fin de l’intervalle.
La valeur h représente le pas d‘avancement, et vaut 1 par défaut (h  Z
 Notion d’intervalle – Fonction prédéfinie "range" :

L’intervalle range(a,b,h) doit être vu comme une succession de
valeurs, en partant de a, et en progressant vers b (sans jamais
l’atteindre !), dans le sens croissant ou décroissant selon que le pas est
positif ou négatif. Ainsi :
o L’intervalle range(7) représente la succession des valeurs: 0 1 2 3 4 5 6
o L’intervalle range(1,7) représente la succession des valeurs: 1 2 3 4 5 6
o L’intervalle range(1,7,2) représente la succession des valeurs: 1 3 5
o L’intervalle range(7,2)est vide (ici le pas a sa valeur par défaut, c-à-d 1)
o L’intervalle range(7,2,-1) représente la succession des valeurs: 7 6 5 4 3

La boucle "Pour " se présente sous la forme suivante:
Pour compteur dans Intervalle faire
<séquence>
Séquences à répéter intervalle
Fin Pour
Principe :
Pour la variable de contrôle allant d’une valeur initiale jusqu’à
une valeur finale d’un intervalle, exécuter la séquence
d’instruction.
for <compteur> in range(<Plage des données>) :
<séquence>
Le compteur est initialisé par l'instruction for à la valeur initiale et
tant que la valeur d’arrêt n'est pas atteinte, il est automatiquement
incrémenté après l'exécution des instructions du bloc à répéter.
Dans ce cas on a :
b = valeur d’arrêt + 1
Exemple: Afficher les 100 premiers nombre entiers positifs
Début
1) Pour i Dans (1,101) faire
2) Écrire(i) Fin Pour
Fin
Programme
for i in range(1,101):
print(i,end=' ')
Exemple: Ecrire un programme permettant d‘Afficher la table de

multiplication d’un nombre
M=int(input(‘’ Entrer le nombre M :’’))

for i in range (0,11) :
print(‘’ ‘’,i,’’ x ‘’,M,’’ = ‘’,i*M)
B. VARIABLES RECURRENTES :
Ce sont des variables qui sont calculées grace à des boucles.
Exemple 1 : calculer la somme suivante
Exemple 2 : calculer la factotielle n! du nombre n.

Exercice:
Ecrire les programmes Python qui permetent de calculer les sommes

suivantes: (∀ N ∈ℕ )
N
1. S 1 = 1+ 2+ 3+⋯+ N = ∑i
i =1
N
2. S2= 1× 2× 3×⋯× N= ∏i
i= 1
1 1 5 N 2+ N − 1
3. S 3=− N + N + N +⋯+ N
2 2 2 2
N
i 2+ i − 1
4. S ∑ =
i =− N i+ 1
LES TABLEAUX
1. Introduction
Définition :
Un tableau est une structure de données qui représente un

ensemble de variables auquel on a accès à travers un
numéro d’indice.
Le tableau est caractérisé par un identificateur unique

(nom du tableau).
Les tableaux les plus utilisés sont:
à une dimension (exemple: vecteurs)
à deux dimensions (exemple: matrices)

2. Représentation pratique d’un tableau
On représente un tableau par un ensemble de cases repérées par leurs
indices (leurs positions dans le tableau).
Indices colonnes
1 2 3 j M
1 1
2 2
Indice s lignes
3 3
Indices
Indices
i i
Vec[i]
Tab[i,j]
N N
Tableau à 1 dimension Tableau à 2 dimensions
Dans un tableau à 1 dimension, Vec[i] représente la i ème case du tableau

unidimensionnel Vec.
Dans un tableau à 2 dimensions, Tab[i,j] représente le contenu de la case
située à l’intersection de la i ème ligne et de la j ème colonne.
3. Définition d’un tableau
Quatre éléments fondamentaux définissent un tableau:
1. Son nom: qui sera un identificateur choisi en respectant les règles

usuelles de dénomination des variables.
2. Sa Dimension ( dimension 1 ou dimensions 2)
3. Sa taille: les valeurs maximales de ses indices.

indices (le nombre d‘éléments).
4. Le type de données qu’il contient (entiers ou réels ,,,)

4. Traitements itératifs sur les tableaux
Le principal intérêt de l’utilisation d’un tableau est de permettre d’effectuer des
traitement répétitives sur l’ensembles des éléments du tableau.
Par exemple, il suffit de décrire un traitement en invoquant le terme général

TAB[i,j] et de placer ce traitement dans une boucle qui fait varier les indices i
et j entre les valeurs 0 et leurs valeurs maximales.
Pour afficher ligne par ligne les (N M) éléments d’un tableau de nombres, on
peut utiliser le simple algorithmesuivant:
Pour i Dans (0,N) faire

Pour j Dans (0,M) faire
Ecrire(TAB[i,j])
Fin Pour
Fin Pour
Tout élément d’un tableau peut être utilisé comme une simple variable: lecture,
écriture, affectation, utilisation dans une expression …etc.
5. Les tableaux en langage Python
En Python ils existent deux façons pour définir des tableaux:
o Comme des listes : Type list
o Comme des tableaux de la bibliothèque NumPy: Type array
Les listes sont le moyen intégré en Python pour la définition de

tableaux.
NumPy est une extension du langage de programmation Python,
destinée à manipuler des matrices ou tableaux multidimensionnels
ainsi que des fonctions mathématiques opérant sur ces tableaux.
C’est un module qui doit être télécharger et installer pour une
éventuelle utilisation.
En ce qui nous concerne, et à notre niveau, nous nous contentons
d’utiliser les tableaux sous forme de liste.
6. Les listes en langage Python
Définition :
Une liste est une structure de données qui contient une

série de valeurs. Python autorise la construction de liste
contenant des valeurs de type différent (par exemple entier
et chaîne de caractères), ce qui leur confère une grande
flexibilité.
C’est une liste de valeurs (éléments) entre crochets et séparés par

des virgules. Les éléments d’une même liste n’ont pas
nécessairement le même type :
>>> x = [123, 1+2j, 13, -5, 0, 900.2]
6. Les listes en langage Python(suite)
 Création des listes :
En langage Python, les listes peuvent être créer :
En évaluant l’expression list() ou [] pour obtenir une liste vide
>>> x = list()
>>> type(x)
<class 'list'>
>>> x
[]
En combinant des éléments [elt0, elt1,..., eltn], ou en

convertissant une séquence parlist(seq)
>>> y = [1, 'a', 1.02, -5, 0]

>>> z = list(range(7))
>>> print(z)
[0, 1, 2, 3, 4, 5, 6]
 Création des listes (suite):
En “compréhension”, par [expr for indice in intervalle], ou

[expr for indice in intervalle if condition].
>>> a = [x*x for x in range(1,10)]

>>> print(a)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> b = [x*x for x in range(1,100) if x%10 == 3]
>>> print(b)
[9, 169, 529, 1089, 1849, 2809, 3969, 5329, 6889, 8649]
La condition dans cette écriture est facultative

 Propriétés des listes:
Les listes sont composées d’un nombre fini d’éléments auxquels on peut
accéder par un indice. Ainsi seq[k] désigne l’élément situé en position k
dans la séquence seq : ( Attention si vous écrivez for x in range(0,n)
la numérotation commence à 0 et se termine à n-1 )
Un indice négatif signifie qu’on compte à partir de la fin. Ainsi seq[-1]
désigne le dernier élément d’une séquence.
La longueur d’une séquence seq (le nombre d’éléments dont elle est
constituée) est donnée par len(seq)
>>> x = [123, 1+2j, 13, -5, 0, 900.2]
>>> print(x[0])
123
>>> print(x[3])
-5
>>> print(x[-1])
900.2
>>> print(len(x))
6
7. Les tableaux Liste
Exemple 1 : Lecture et écriture des éléments réels d’un tableau à 1
dimension Vec(N)
Algorithme tableau 1
Début
1) Lire(N)
2) Vec [0 pour i Dans (0,N)]
3) Pour i Dans (0,N)faire
4) Lire(Vec[i]) Fin Pour
5) Pour i Dans (0,N) faire
6) Ecrire(Vec[i]) Fin Pour
Fin
7. Les tableaux Liste (suite)
Programme
N = int(input('Entrer le nombre de lignes N:'))
Vec = [0 for i in range(0,N)] #Initialisation des éléments du vecteur
print("Entrer ligne par ligne les coefficients du tableau Vec(%d):"%N)
for i in range(0,N):
print("Vec[%d]="%(i+1),end=" ")
Vec[i]=float(input())
print("Les coefficients du tableau Vec(%d) sont :"%N)

print("Vec[%d]="%(i+1),Vec[i])
Exemple 2 : Lecture et écriture des éléments réels d’un tableau à 2
dimensions Tab(N,M)
Algorithme tableau 2
Début
1) Lire(N,M)
2) Tab [ [0 pour j Dans (0,M)] pour i Dans (0,N) ]
4) Pour j Dans (0,M) faire
5) Lire(Tab[i,j]) Fin Pour
7) Pour j Dans (0,M) faire
8) Ecrire(Tab[i,j]) Fin Pour
Fin
Programme
N=int(input("Donnez le nombre de lignes de la matrice: "))
M=int(input("Donnez le nombre de colonnes de la matrice: "))
# Initialisation des éléments de la matrice

Tab = [[0 for j in range(0,M)] for i in range(0,N)]
print("Entrer ligne par ligne les coefficients du tableau

Tab(%d,%d):"%(N,M))
for j in range(0,M):
print("Tab[%d,%d]="%(i+1,j+1),end=" ")
Tab[i][j]=float(input())
print("Les coefficients du tableau Tab(%d,%d) sont :"%(N,M))

for j in range(0,M):
print("Tab[%d,%d]="%(i+1,j+1),Tab[i][j])
Exercice:
 Ecrire le programme Python qui permet de calculer et d’afficher la
somme et le produit des éléments d’un vecteur A(N).
 Ecrire le programme Python qui permet de calculer et d’afficher la

somme et le produit des éléments d’une matrice B(N,M).
Fonctions et procedures
1. Introduction
Dans tout langage de programmation évolué, il est
possible de définir un bloc d’instructions qui pourra être
appelé dans n’importe quelle partie du programme
principal en faisant référence uniquement par son
identifiant.
Cette technique de programmation simplifie grandement

les algorithmes (programmes) et fait appel à des sous- programmes
effectuant chacun des tâches précises.
Pour pouvoir utiliser un sous-programme il faut d'abord le

définir.
Cette définition doit être faite avant l’appel du sous-

programme.
2. Notion de Fonction
Définition :
Une fonction est un groupe d'instructions doté d'un nom
générique, qui exécute une tâche déterminée ou un
algorithme. La fonction est identifiée à un type et restitue
une seule valeur en fin d'exécution.
Exemple :
La fonction (prédéfinie) exponentielle en langage Python est
exp(x) .
La syntaxe fait référence à un nom générique (identificateur)
de fonction exp et un argument x.
Remarque : Certaines fonctions peuvent avoir plusieurs
arguments ou aucun argument.
3. Notion de Fonction Définie par l’Utilisateur
Définir une fonction :
La définition d’une fonction se fait, en général, tout au début du script
avant la partie du programme principal.
La définition algorithmique d’une fonction est sous la forme:

Définir <Nom de la fonction> (argument1, argument2,…, argumentN):
<Bloc d’instructions>
retourner <Valeur de la fonction>
Traduction en langage Python

def <Nom_fonction> (argument1, argument2,…, argumentN):
<Bloc_instructions>
return <Valeur_fonction>
Définir une fonction (suite) :
Le mot-clé def annonce la définition d’une fonction.
Le nom de la fonction doit respecter les règles de nomination

des identificateurs. N'utilisez pas un nom de variable déjà
utilisé pour nommer une fonction.
Les parenthèses sont obligatoires, même si la fonction n'attend

aucun argument.
ex: def ma_fonction( ):
Attention à l’indentation: le bloc d’instructions et la ligne (ou les

lignes) comportant return doivent être délimités par
l'indentation.
Exemple 1 : Programme utilisant une fonction qui renvoie le maximum de deux
entiers.
Définir maximum(a1,b1) :
si a1 >= b1 alors max a1
Sinon maxb1 FSI
retourner max
Début { Programme Principal}
1) Lire(A,B)
2) x2maximum(A,B)
3) Écrire(x)
Fin {Programme Principal}
Organigrammes :
Debut
Lire A S/P Fonction maximum(a1,b1)
Lire B
x=maximum(A,B) a1<=b1
max=a1 max=b1
Ecrire x
Retour
Fin
max
Programme Python
# Début du sous-Programme fonction

def maximum(a1,b1) :
if a1 >= b1 :
max = a1
else :
max = b1
return max
# Début du Programme Principal
A=int(input('Entrer le premier nombre entier A:'))
B=int(input('Entrer le deuxième nombre entier B:'))
x=maximum(A,B)
print('La valeur de x:',x)
Dans cet exemple, les arguments "a1" et "b1" sont utilisés pour calculer le
maximum. On les appelle paramètres formels de la fonction. Les paramètres
Formels sont utilisés uniquement dans le traitement à l’intérieur du sous-
programme.
Seul un appel de la fonction avec des paramètres (arguments) effectifs ("A"

et "B" dans notre exemple) en place des paramètres formels déclenche
l’exécutionde la fonction "maximum".
L’instruction return suivie de la variable "max" provoque l’arrêt de la fonction

"maximum" et le retour de l’expression à l’endroit même où la fonction a été
appelée.
On dit de la variable "max" est locale car elle n’est pas visible à
l’extérieur de la fonction. Une variable locale est définie localement dans la
fonction et sa porté est limitée à cette dernière. Elle n’est pas reconnu dans le
programme principal ni dans les autres sous-programmes (s’ils existent).
Une fonction peut aussi faire appel à des variables globales, bien
que pour des raison de sécurité du code, cela devrait être au
maximum évité.
Ces variables sont visibles en dehors de la fonction elle-même (dans

le programme principal par exemple) et doivent être explicitement
déclarées comme telle dans l’en
l’en-tête de la Fonction .
def <Nom_fonction> (argument1, argument2,…, argumentN):

global var1,var2,…,varN
<Bloc_instructions>
return <Valeur_fonction>
Exemple 2 : Programme utilisant une fonction qui calcule le factoriel d’un entier
positif.
Définir fact(n) :
variable globale L
p 1
pour i Dans (0,n+1) faire
si i=0 alors p 1
sinon p pi FSI
Lp+1
retourner p
1) Lire(M)
2) S fact(M)2 +L
3) Écrire(S)
Programme Python
def fact(n):
global L
p=1
for i in range(0,n+1):
if i==0 :
p=1
else:
p=p*i
L=p+1
return p
M=int(input("M= "))
S=fact(M)**2+L
print("S=",S)
4. Notion de Procédure
Définition :
Une procédure est un groupement d'instructions, identifié
par un nom, qui exécutent une tâche ou un algorithme
déterminé. Une procédure modifie quelque chose dans
l’environnement (affichage à l’écran, écriture dans un
fichier …… ) et ne retourne aucune valeur.valeur Elle est une
fonction qui ne renvoie aucune valeur.
Exemple :
exp(x) : une fonction qui renvoie une valeur.
print(end="\n") : c’est une tâche à exécuter mais ne renvoie aucune
valeur.
Définir une procédure :
La définition d’une procédure se fait, en général, tout au début du script
avant la partie du programme principal.
La définition algorithmique d’une procédure est sous la forme:

Définir <Nom de la procédure> (argument1, argument2,…, argumentN):
<Bloc d’instructions>
Traduction en langage Python

def <Nom_procédure> (argument1, argument2,…, argumentN):
<Bloc_instructions>
Exemple : Programme utilisant une procédure qui permet d’avoir des sauts de
lignes.
Définir saut(a) :
pour i Dans (0,a+1) faire
Écrire(end="\n")
1) Lire(N)
2) saut(N)
3) Écrire("fin du programme")
Programme Python
def saut(a):
for i in range(1,a+1):
print(end="\n")

N=int(input('N= '))
saut(N)
print("fin du programme")
5. Fonctions récursives
Définition :
Une fonction (procédure) est dite récursive si elle s’appelle
d’elle-même.
Exemple: Programme permettant de faire le calcul de la factorielle sous

forme récursive.
Algorithme Programme permettant de faire le calcul du factoriel sous forme
récursive.
Définir factoriel(a) :
si a <= 1 alors f 1
Sinon f a factoriel(a-1) FSI
retourner f
1) Lire(n)
2) resultat factoriel(n)
3) Écrire(resultat)
Programme permettant de faire le calcul du factoriel sous forme récursive.
Def factoriel(a):
if a<=1 :
f=1
else:
f=a*factoriel(a-1)
return f

n=int(input("n= "))
resultat=factoriel(n)
print("Le factoriel de ",n," est: ",resultat)
Attention: Il faut toujours vérifier qu'en aucun cas on ne puisse avoir une
boucle infinie qui bloquerait la machine.

Chapitre 1 - PYTHON

Transféré par

Informations du document

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

Chapitre 1 - PYTHON

Transféré par

Droits d'auteur :

Formats disponibles

• Apprendre à établir des algorithmes pour résoudre des problèmes

• Apprendre le langage de programmation Python.

 Résoudre dans R l’équation suivante :

 Calculer l’intégrale suivante :

 Résoudre un système linéaire de 20 équation à 20 inconnues …

 Exemple 2 : Calcul des racines d'un polynôme du 2ème ordre :

– Il contient toujours un nombre fini d'actions

– Chaque action doit être définie avec précision, sans

– Certaines actions peuvent être raffinées (décomposées)

 Exemple 2 : Résoudre dans  l‘équation du 2 èmé degré

 Nous utilisons l’ organigramme parce qu‘une

 L‘organigramme est un schéma fonctionnel qui représente

Boite dedécision Elle permet d ’orienter le

 Poser le problème, l‘analyser et définir avec précision les données et les

 Déterminer les méthodes de résolution: il s'agit de déterminer la suite des

 Formuler l‘algorithme définitif : cette étape doit faciliter la résolution sur

 Traduire l'algorithme (l‘organigramme) dans un langage de

Correction des erreurs et finalisation du programme

Pour communiquer avec un ordinateur, il faut un langage de communication

On appellera langage de programmation un ensemble de « mots-clés »

- Les langage de communication avec la machine peuvent classés en trois catégories :

 Chaque processeur possède un langage propre, directement

le langage d’assemblage est un codage alphanumérique du

les langages de haut niveau ou évolués. Souvent normalisés, ils

- Il existe des centaines de langages de programmation permettant de traduire un

 Un programme ou un scipt est une suite d‘instructions s‘enchaînant de

Une instruction respecte une grammaire et une syntaxe.

 Exemple 1: Addition de deux nombres réels

A=float(input(‘donnez la valeur de A:’))

B=float(input(‘donnez la valeur de B:’))

print(‘La somme est :’,Somme)

 Exemple 2 : Calcul des racines d'un polynôme du 2 ème ordre :

 Exemple 1: Addition de deux nombres réels

 Exemple 2 : Calcul des racines d'un polynôme du 2 ème ordre :

 Exemple 1: Addition de deux nombres réels

 Exemple 2 : Calcul des racines d'un polynôme du 2 ème ordre :

• Il existe deux techniques principales pour effectuer la

•La compilation consiste à traduire la totalité du texte source en une fois.

•Dans la technique appelée interprétation, le logiciel interpréteur doit être

Chacune de ces deux techniques a ses avantages et ses inconvénients :

•L'interprétation est idéale lorsque l'on est en phase d'apprentissage

Certains langages modernes tentent de combiner les deux techniques afin

• Du point de vue de l'ordinateur, le bytecode est très facile à interpréter en langage

3. d’exécution ou « Run-time error » : lorsque votre programme fonctionne

• Python ne peut exécuter un programme que si sa syntaxe

Exemple : dans un traitement répétitif : au lieu de répéter un traitement 10

Ces erreurs sont également appelées des exceptions,

Vous rencontrerez davantage ce type d'erreur

Il est doté d'un typage dynamique fort, d'une gestion automatique de la

Il est conçu pour optimiser la productivité des programmeurs en offrant des

Il est également apprécié par les pédagogues qui y trouvent un langage où la

1994 : sortie de la version 1.0

1996 : sortie de Numerical Python

2000 : sortie de la version 2.0 Guido van Rossum,

2008 : sorties simultanées de Python 2.6 et de Python 3

2009 : sorties simultanées de Python 2.7 et de Python 3.1

La version 2x n’évolue plus, elle est remplacée progressivement par la version 3x

o IDLE: console écrite avec le toolkit Tkinter

Le signe >>> constituent le signal d’invite, ou prompt principal, lequel

Si la commande/l'expression n'est pas reconnue : erreur

Vous pouvez alors écrire un programme Python et l'enregistrer dans un

Les noms utilisés pour les objets manipulés sont des

L’identificateur est un nom symbolique utilisé pour nommer