Algorithmique et programmation Introduction.ppt

© SUPINFO International University – http://www.supinfo.com
Premiers pas.
1ADS Algorithm in Python

Objectifs de ce module
• Introduire les notions d’algorithmes et de
programmes informatiques.
• Présenter plus particulièrement le langage
Python et deux de ses environnements de
développement.
• Effectuer ses premières manipulations de
variables.
Premiers pas.

Plan de ce module
1. Généralités sur l’algorithmique et la
programmation.
2. Prise en main de l’environnement de
développement.
3. Notion de variables.
4. Opérations sur les variables.
5. Structures de contrôle.
Premiers pas.

1. Généralités sur l’algorithmique et
la programmation.
Premiers pas.

Plan de ce chapitre
a. Autour de la notion d’algorithme.
b. De l’algorithme au programme.
c. Pourquoi le choix du Python pour débuter ?
d. Quelle version de Python ?
1. Généralités sur l’algorithmique et la programmation.

• Un algorithme est une suite d’instructions permettant la
résolution d’un problème en un nombre fini d’étapes.
• À partir de données, les entrées de l’algorithme, on va
donc parvenir à un résultat, la sortie.
• Il est important de noter que les instructions d’un
algorithme doivent être indépendantes des données sur
lesquelles il va s’appliquer.

Exemple : recette de cuisine.
• Problème : comment faire une pâte à crêpes ?
• Résolution :
① Casser trois œufs dans 250 grammes de farine.
② Mélanger.
③ Diluer avec ½ litre de lait.
④ Ajouter une cuillère à soupe d’huile.

Origine du mot algorithme
• Le mot algorithme vient du nom du mathématicien perse
Abu Abdullah Muhammad ibn Musa al-Khwarizmi (9 ème
siècle après Jésus Christ).
• Son nom a ensuite été latinisé au Moyen Age en
« algoritmi » .
• Origine du mot algorithme ne veut pas dire origine du
principe. On écrivait des algorithmes dès l’antiquité
comme nous allons le voir sur des exemples.

Algorithme de calculs d’intérêts (1800 avant J.-C.)
•Problème : trouver en combien d’années on double un
montant soumis à un certain taux annuel.
•Résolution :
① Initialiser le taux t à la valeur voulue, a à 0 et b à 1
② Tant que b < 2, remplacer b par b*(1+t) et ajouter 1 à a.
③ La valeur finale de a est le nombre d’années cherché.

Exemple (pour un taux de 20%) et photo du manuscrit :
a b
0 1
1 1,2
2 1,44
3 1,728
4 2,0736
Il faut 4 ans

Algorithme de multiplication égyptienne (1650 avant J.-C.)
•Problème : multiplier deux entiers a et b.
•Résolution :
① Décomposer a comme somme de puissances de 2.
② Calculer les puissances de 2, 4, 8, etc. de b.
③ Additionner les puissances de b qui correspondent aux
puissances de 2 trouvées dans a.

Exemple et photo du manuscrit :
2n
a = 25 b = 14
1 1 14
2 0 28
4 0 56
8 1 112
16 1 224
a * b = 14 + 112 + 224 = 350

Algorithme d’Euclide (300 avant J.-C.)
• Problème : trouver le PGCD de deux entiers a et b.
• Résolution :
① Si b est non nul, diviser a par b. On note r le reste de cette
division euclidienne.
② Remplacer a par b et b par r.
③ Recommencer tant que cela est possible à partir de
l’étape 1.
④ Le PGCD est alors la dernière valeur non nulle de r.

Exemple et photo du manuscrit :
a b r
142 38 28
38 28 10
28 10 8
10 8 2
8 2 0
PGCD(142,38) = 2

Définition d’un algorithme
•C’est une suite finie d’instructions, qu’on applique à un
nombre fini de données, dans un ordre bien déterminé pour
résoudre un problème donné.
Autre définition
•Un algorithme est la description de la méthode de
résolution d’un problème posé.
L’algorithmique :
•L’algorithmique est la science qui étudie l’application des
algorithmes à l’informatique

Construction d’un algorithme:
Définition:
Construire un algorithme consiste à concevoir les
actions qu'il faut organiser dans le temps, et à choisir la
manière de les organiser pour obtenir le résultat
escompté par leurs effets cumulés.

Étapes de construction d’un algorithme
• Position du problème et précision des conditions de travail:
Objets caractérisant les informations ou les données à
manipuler.
• Réfléchir à une méthode bien définie pour résoudre le
problème.
• Décrire cette méthode sans ambiguïté.
• Évaluer la méthode décrite (temps d’exécution, nombre
d’opérations, taille, etc..).
• Réfléchir aux qualités et aux défauts de la méthode choisie.
• Réfléchir à d’autres méthodes et les comparer selon les
critères de qualité définis.

• En informatique, les instructions d’un algorithme seront
bien sûr à destination d’un ordinateur.
• Pour qu’elles soient compréhensibles par ce dernier, elles
doivent évidemment être écrites dans ce que l’on appelle
un langage de programmation.
• Celui-ci sera lui même traduit par un compilateur en
langage machine ou exécuté par un interpréteur.

• Avant l’étape d’écriture du programme, on peut/doit
concevoir l’algorithme en lui même de façon non formelle,
en version « papier ».
• L’algorithme contient la réflexion, l’abstraction du
programme.
• Ce dernier pouvant être complexifié par des contraintes
techniques.
Problème Algorithme Programme

• Nous n’adopterons pas dans ce cours de syntaxe
formalisée des algorithmes, chacun les rédigera pour lui-
même dans l’unique but de structurer ses idées.
• On peut même tout à fait imaginer faire des schémas en
guise d’algorithme.

Exemple : l’algorithme de calculs d’intérêts du slide 9
deviendra le programme suivant en Python
t = 0.2
a, b = 0, 1
while b < 2:
b = b*(1+t)
a = a + 1
print("Nombre d'années cherché :",a)

c. Pourquoi le choix du Python ?
• Il possède une syntaxe simple.
• On peut donc se concentrer sur la logique algorithmique.
• Le mode “console” permet de tester des portions de codes
immédiatement.
• C’est un langage interprété, c’est-à-dire que les
instructions des programmes seront exécutées au fur et à
mesure.

c. Pourquoi le choix du Python ?
• C’est un langage de haut niveau, on ne souciera pas de la
gestion des ressources mémoires.
• Python possède des structures de données évoluées,
listes, ensembles, dictionnaires, etc.
• Python est de plus en plus populaire et possède de
nombreuses ressources bibliographiques.
• Enfin, c’est un langage open source.

d. Quelle version de Python ?
• Il y a principalement deux “branches” différentes de
Python : 2.x et 3.x
• Même si elles sont assez semblables dans l’esprit, on peut
noter d’importantes différences de syntaxes,
fonctionnalités, etc.
• Ce cours est basé sur la branche 3.x, et plus
particulièrement sur la version 3.3.5

Fin de ce chapitre
Avez – vous des questions ?

2. Prise en main de l’environnement
de développement.
Premiers pas.

Plan de ce chapitre
2. Prise en main de l’environnement de développement.
a. Téléchargement de IDLE et PyCharm.
b. Utilisation de la console.
c. Écriture de scripts.

3. NOTION DE VARIABLES.
Premiers pas.

Plan de ce chapitre
4. Notions de variables.
a.Constantes
b.Variables.
c.Les types de variables.
d.Affectation de variables.
e.Spécificités du Python.
f.Conversions de types.
g.Affichage et saisie.

a.Constantes
Définition : Les constantes sont des quantités fixées et
invariantes au cours de l’algorithme.
• Déclaration d’une constante : Instruction permettant de
réserver de l’espace mémoire pour stocker des données dont
la valeur est fixée pour tout l’algorithme.
Exemple :
constantes MAX=100
e = 2.72

b. Variables.
• Dans un algorithme (ou programme informatique), le
stockage des informations est primordial.
Ces informations sont essentiellement :
• Les données fournies par l’utilisateur (les entrées);
• Les résultats obtenus par l’algorithme (les sorties);
• Les données intermédiaires.
• Un algorithme ou un programme manipulent des données.
Certaines sont connues dès le départ, d’autres sont
calculées lors de son exécution.
• Pour pouvoir manipuler ces données il faut garder leurs
valeurs en mémoire. C’est le rôle des variables.

b. Variables.
Variable :
• Nom désignant une donnée (nombre, texte…) susceptible
de changer de valeur.
• Une variable possède un type, ce qui permet à l’ordinateur
de savoir quelles valeurs elle peut prendre et quelles
opérations on peut effectuer avec.

c. Les types de variables.
Les différents types utilisés :
• Type Entier : pour manipuler les nombres entiers positifs ou
négatifs. Par exemple : 25, -15, etc.
• Type Réel : pour manipuler les nombres à virgule. Par
exemple : 3.14, -15.5, etc.
• Type Caractère : pour manipuler des caractères alphabétiques
et numériques. Par exemple :
'a', 'A', 'z', ' ?', '1', '2' etc.
• Type Chaîne : pour manipuler des chaînes de caractères
permettant de représenter des mots ou des phrases.
• Type Booléen : pour les expressions logiques. Il n'y a que deux
valeurs booléennes : vrai et faux

c. Les types de variables.
Types “élémentaires” en Python :
•int : nombres entiers.
•float : nombres décimaux.
•complex : nombres complexes.
•bool : booléens (deux valeurs possibles “True” et “False”).
•str : chaînes de caractères.

d. Affectation
C’est une instruction qui consiste à doter une variable d’une
valeur appartenant à son domaine, c’est-à-dire à lui donner
une première valeur ou à changer sa valeur courante. Elle se
réalise au moyen de l’opérateur
Syntaxe :
Nom_variable ← Valeur
Nom_variable ← Nom_variable
Exemple :
x ← 4 signifie:
- mettre la valeur 4 dans la case mémoire identifiée par x (on dit aussi x reçoit 4).
- copier dans x la valeur 4

d. Affectation de variables (python).
• Syntaxe : affectation simple
• Syntaxe : affectation multiple
maVariable = valeur
var1, var2, ... = val1, val2, ...

d. Affectation de variables.
Remarques :
•Comme mentionné précédemment, lorsque l’on veut utiliser
une variable il n’y a donc pas besoin de déclarer son type.
C’est lors de son initialisation que ce typage s’effectue.
•On peut toujours vérifier le type d’une variable avec
l’instruction “type” :
type(maVariable)

Exemple :
>>> i = 4
>>> type(i)
<class 'int'>
>>> x, z = -5.3, 1+1j
>>> z
(1+1j)
>>> type(z)
<class 'complex'>
>>> type(x)
<class 'float'>

>>> texte = 'Street fighting man'
>>> type(texte)
<class 'str'>
>>> texte
'Street fighting man’
>>> '666’ + 111
Traceback (most recent call last):
File "<console>", line 1, in <module>
TypeError: Can't convert 'int' object to str
implicitly
Exemple :

e. Spécificités du Python.
Typage dynamique :
•Avant d’utiliser une variable on n’a pas besoin de déclarer
explicitement son type, c’est l’interpréteur qui s’en charge.
•Cela sera fait dès que l’on attribuera une valeur à notre
variable.

e. Spécificités du Python.
Typage fort :
•Les opérations possibles sur une variable dépendent
intégralement de son type.
•Les conversions de types implicites afin de réaliser certaines
opérations sont donc interdites.

f. Conversions de types.
Opérations de conversions :
Opération Contrainte / Résultat
int(x) x est un décimal (qui sera tronqué) ou une chaîne
int(x,base) x est une chaîne et base un entier
float(x) x est un entier ou une chaîne
complex(x,y) x et y sont des nombres ou x est une chaîne
bool(x) x est un nombre ou un booléen
Vaut False uniquement si x vaut 0 ou ‘ ‘
str(x) x est un nombre ou un booléen
eval(x) x est une chaîne qui est évaluée comme une
expression Python

f. Conversions de types.
Exemple :
>>> x = 666.6
>>> y = int(x)
>>> y
666
>>> eval('y+111')
777
>>> int('10101',2)
21
>>> str(y)
'666'

g. Instructions d’entrée/sorties
(lecture/écriture)
Lecture (saisie)
L’instruction ’’lire’’ permet de lire une ou plusieurs variables :
l’utilisateur doit saisir une ou plusieurs valeurs au clavier et
valider par la touche ‘’Entrée’’.
Syntaxe : lire(variable1, variable2,…)
Exemples :
lire (Nom) ; lire(A); lire(X, Y)
Recommandation : Il est souhaitable que toute instruction de
lecture d’une variable sera précédée par l’affichage d’un
message qui invite l’utilisateur à saisir une variable

g. Instructions d’entrée/sorties
(lecture/écriture)
L’écriture (sortie)
L’instruction ’’Écrire (ou afficher)’’ permet d’écrire à l’écran
(console) les valeurs des variables et les messages.
Syntaxe : Écrire (variable1, variable2,…)
Écrire (‘message’)
Exemples :
Écrire (‘Bonjour, la séance des TDs commence à 08h.’)
Cette instruction affichera à l’écran le message : Bonjour, la
séance des TDs commence à 08h.
Écrire(X): Cette instruction affichera la valeur de la variable X

g. Affichage et saisie (Python).
• En mode “console” on peut afficher le contenu d’une
variable en tapant juste son nom (voir exemples
précédents).
• Pour réaliser un affichage sur la console à partir d’un
script, et/ou pour réaliser des affichages plus sophistiqués
on aura besoin de l’instruction “print”.

g. Affichage et saisie.
Syntaxe de la fonction “print” :
•Les différentes expressions (en nombre variables) sont soit
des chaînes, soit des résultats de calculs convertis en chaînes,
soit des variables dont on souhaite afficher la valeur.
print(expr_1,expr_2,...,sep=‘ ‘,end=‘n’)

Syntaxe de la fonction “print” : (suite)
•“sep” indique ce qui va séparer ces expressions, par défaut il
s’agit d’un espace.
•“end” indique ce qui sera affiché après toutes les
expressions, par défaut il s’agit d’un retour à ligne.

Exemple :
>>> age = 30
>>> print("J'ai",age,"ans et dans deux ans
j'aurais",age+2,"ans")
J'ai 30 ans et dans deux ans j'aurais 32 ans

Exemple : (suite)
print("des","traits","bas","pour","séparer",
sep='_')
print("et","des","plus","à","la","suite",
sep='_',end='+++ ')
print("et la fin")

Remarque
•Tabulation et retour à la ligne s’obtiennent avec ‘t’ et ‘n’ :
>>> print("The tRolling Stones")
The Rolling Stones
>>> print("The RollingnStones")
The Rolling
Stones

Syntaxe de la fonction “input” :
•“expression” est facultative, elle sert juste à réaliser un
affichage sur la ligne de la saisie.
•Ce que va saisir l’utilisateur sera affecté sous forme de
chaîne de caractère à la variable “var”.
var = input(expression)

Exemple :
>>> a = input()
>? 12
>>> print(a,type(a))
12 <class 'str'>
>>> b = eval(input("saisir un nombre : "))
saisir un nombre : >? 12
>>> print(b,type(b))
12 <class 'int'>

Fin de ce chapitre

4. Opérations sur
les variables.
Premiers pas.

Plan de ce chapitre
a. Opérateurs
b. Opérations arithmétiques.
c. Opérations sur les chaînes.

a. Opérateurs
.
Un opérateur est un symbole significatif qui relie deux objets
(variables ou constantes), pour produire un résultat. Les
opérateurs sont classés comme suit :
• Opérateurs arithmétiques : Ce sont des opérateurs qui
opèrent sur les objets numériques (+, -, *, /, div, mod). On
note que ‘’div’’ est la division entière qui donne la partie
entière du quotient d’une division, et le mod (le modulo)
donne le reste d’une division entière.
• Opérateurs Logiques : Ce sont des opérateurs qui opèrent
sur les booléens (ET, OU,NON,…).
• Opérateurs de comparaison : Ce sont des opérateurs qui
opèrent sur les types numériques (=, < >, <, >, <=, >=)

a. Opérateurs
.

a. Opérateurs
• Instruction : Elle traduit une ou plusieurs consignes (ou
actions) portant sur une ou plusieurs variables.
• Expression : C’est une combinaison de variables, de
constantes et d'opérateurs. Le type d’une expression est
défini par celui des variables et des constantes qui la
constituent.
Exemples : (x+y)*(x-y)/2; a div b; (x>=0) ET (y>=0)

a. Opérateurs
• Incrémentation : C’est l’augmentation de la valeur d’une
variable à chaque phase de l’exécution d’un programme
(algorithme).
• Décrémentation : C’est la diminution de la valeur d’une
variable à chaque phase de l’exécution d’un programme
(algorithme).
Syntaxe :
x ← x+step où ‘’step’’ est le pas d’incrémentation (ou de
décrémentation).

Instruction, expression, affectation,
incrémentation
Écrire un algorithme permettant d’échanger le contenu de
deux variables.

b. Opérations arithmétiques (Python).
Liste des principales opérations arithmétiques :
Opération Résultat
x + y Addition de x et y
x - y Soustraction de y à x
x * y Multiplication de x et y
x ** y Élévation de x à la puissance y
x / y Quotient réel de x par y
x // y Quotient entier de x par y
x % y Reste du quotient entier de x par y

Précisions :
•Si les deux opérandes des opérations +, -, *, ** sont entiers
(resp. réels) le résultat est entier (resp. réel).
•Si un des deux opérandes est réel, le résultat est réel.
•Le résultat de l’opération / est toujours un réel.

Précisions : (suite)
•Si les deux opérandes sont des entiers, le résultat de
l’opération // est le quotient de la division euclidienne et le
résultat de l’opération % le reste.
•Si l’un des deux opérandes est un réel, le résultat de
l’opération // est la partie entière du quotient de la division
réelle.

Exemple :
>>> -3 + 5
2
>>> 3 * 5
15
>>> 5 ** 2
25
>>> 13 / 4
3.25

Exemple : (suite)
>>> 13 // 4
3
>>> 13 % 4
1
>>> 13 // 4.6
2.0
>>> 13 % 4.6
3.8000000000000007

a. Opérations arithmétiques.
Quelques raccourcis :
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x **= y x = x ** y
x /= y x = x / y
x //= y x = x // y
x %= y x = x % y

Exemple :
>>> x = 25
>>> y = 0.5
>>> x **= y
>>> print(x)
5.0
>>> y += 1
>>> print(y)
1.5

Module “math” :
•Pour effectuer des calculs mathématiques plus “élaborés”,
on pourra utiliser un module de fonctions complémentaires.
•Avant de l’utiliser, il convient de l’importer :
from math import *

Exemple :
>>> from math import *
>>> exp(1)
2.718281828459045
>>> pi
3.141592653589793
>>> cos(pi/2)
6.123233995736766e-17

• En Python, une chaîne de caractères est considérée
comme une suite de caractères.
• Cela signifie entre autres que l’on pourra avoir accès à
n’importe lequel de ces caractères via sa position dans la
chaîne.
• Particularité importante, une variable dont le type est
“str” est en fait une constante.

Exemple : la chaîne “street”
s t r t
e
0
-6
1
-5
2
-4
4
-2
5
-1
Indexation des caractères
à partir du début
Indexation des caractères
à partir de la fin
e
3
-3

Accès aux éléments (“slicing”) :
s[i] i-ème élément de s
s[i:j] Sous-chaîne de s constituée des éléments entre
le i-ème (inclus) et le j-ème (exclus)
s[i:j:k] Sous-chaîne de s constituée des éléments entre
le i-ème (inclus) et le j-ème (exclus)
pris avec un pas de k

Exemple :
>>> s = 'street'
>>> print(s[0],s[-1])
s t
>>> s[2:]
'reet'
>>> s[1:4]
'tre'
>>> s[2] = 'z'
Traceback (most recent call last):
File "<console>", line 1, in <module>
TypeError: 'str' object does not support item
assignment

Opérations de traitement :
x in s Teste si x appartient à s
x not in s Teste si x n’appartient pas à s
s + t Concaténation de s et t
s * n ou n * s Concaténation de n copies de s
len(s) Nombre d’éléments de s
min(s) Plus petit élément de s
max(s) Plus grand élément de s
s.count(x) Nombre d’occurences de x dans s
s.index(x) Indice de x dans s.

Exemple :
>>> texte = "street"
>>> 'z' not in texte
True
>>> len(texte)
6
>>> 3*texte
'streetstreetstreet'
>>> texte.count('e')
2
>>> max(texte)
't'

Opérations de conversions en minuscules et majuscules :
s.lower() Convertit la chaîne de caractères s en
minuscules
s.upper() Convertit la chaîne de caractères s en
majuscules

Exemples :
>>> texte = "The Rolling Stones"
>>> texte.upper()
'THE ROLLING STONES'
>>> texte.lower()
'the rolling stones’
>>> texte
'The Rolling Stones'

Fin de ce chapitre

Structures de contrôle
En général, trois structures de contrôle sont à distinguer :
• a. Structure séquentielle,
• b. Sélection (Choix ou test),
• c. Boucles (ou itérations).
4. Structures de contrôle
.

a. Structure Séquentielle
Dans un algorithme, les instructions sont exécutées
séquentiellement c’est-à-dire l’une après l’autre.
Un bloc est une suite d’instructions délimitée par ‘’début’’
et ‘’fin’’, qui s’exécutent séquentiellement.
4. Structures de contrôle.

b. Sélection (instruction alternative)
L’instruction Si : Cette instruction peut être représentée
dans un algorithme sous deux formes:
• Syntaxe 1 :
Si (Condition) alors
Bloc 1
finSi.

b. Sélection (instruction alternative)
L’instruction Si : Cette instruction peut être représentée
dans un algorithme sous deux formes:
Syntaxe 2 :
Si (Condition) alors
Bloc 1
Sinon
Bloc 2
finSi.

b.Sélection (instruction alternative)
Sélection (instruction alternative)
Exercice : Calcul de la valeur absolue d’un nombre réel x.

c. Les boucles
Intérêt des boucles
Problème : Dans un algorithme, il arrive souvent que la
même action soit répétée plusieurs fois. Ainsi, il est ennuyant
d’écrire un algorithme qui contient de nombreuses fois la
même instruction.
Solution : Pour pallier à ce problème, on fait appel à des
instructions en boucle qui ont pour effet de répéter plusieurs
fois une même action.

c. Les boucles
On distingue deux formes de boucles :
1. Répétitions inconditionnelles où le nombre de répétitions
est connu avant l’exécution de l’algorithme,
2. Répétitions conditionnelles où le nombre de répétitions
est inconnu avant l’exécution de l’algorithme.
Itération : C’est l’exécution de la liste des instructions dans
une boucle

c. Les boucles
Répétitions inconditionnelles : la boucle ‘’Pour’’
Cette boucle est utilisée surtout si le nombre d’itérations à
effectuer est connu au préalable.8
• Syntaxe :
pour variable ← valeur initiale à variable ← valeur finale faire
liste d’instructions
finpour

Exercice : Effectuer la somme de 0 à n (nombres entiers
naturels)

c. Les boucles
La boucle ‘’Tant que...Faire’’
Quand il est à priori impossible de connaître à l’avance au
bout de combien d’itérations une condition cessera d’être
satisfaite, on utilise Tant que…Faire
Syntaxe :
Tantque (condition) Faire
Liste d’instructions
FinTant
La liste d’instructions est répétée autant de fois que la
condition est vraie.

Exercice: Effectuer la somme des n premiers nombres entiers
naturels

c. Les boucles
Exemple : Saisir au clavier un nombre n compris entre 0 et
10.
Répéter
ecrire(‘Donner un nombre n compris entre 0 et 10’)
lire(n)
Tant que ((n<0) OU (n>10))

c. Les boucles
Boucles imbriquées
On dit qu’une boucle est imbriquée s’elle contient d’autres
boucles.
Exemple :
Variables i, j : entiers
Début
Pour i← 1 à i← 10 Faire
ecrire("Première boucle")
Pour j ← 1 à j← 6 Faire
ecrire("Deuxième boucle") ;
Finpour(j) ;
Finpour(i) ;
Fin.

c. Les boucles
Les instructions break et continue
Le principe des boucles est de parcourir un bloc de code
jusqu’à ce que la condition soit
fausse, mais parfois nous souhaitons :
• Mettre fin à l’itération en cours
• Mettre fin à la totalité de la boucle sans vérifier la
condition.
Les instructions break et continue sont utilisées dans ces
deux cas (voir figure ci-dessus).

c. Les boucles
L’instruction break est utilisé pour quitter une boucle while/for, alors que continue
est utilisé pour ignorer le bloc actuel et revenir à l’instruction while/for

Algorithmique et programmation Introduction.ppt

Contenu connexe

Similaire à Algorithmique et programmation Introduction.ppt

Plus de belkharras

Algorithmique et programmation Introduction.ppt

Notes de l'éditeur