Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
0-M02 – Introduction ` a la programmation
Camille Coti
camille.coti@iutv.univ-paris13.fr
IUT de Villetaneuse, d´epartement R&T
2013 – 2014
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Plan du cours
1
Introduction ` a l’algorithmique Les variables
Les tests Boucles
Programmation structur´ ee
2
Introduction ` a Python Les variables en Python Structures de contrˆ ole Fonctions
3
Structures de donn´ ees
4
Modularit´ e
´ Ecriture d’un module Utilisation d’un module Utilisation d’un module Variables globales
5
Param` etres optionnels de fonctions
6
Les exceptions Lever une exception Attraper une exception D´ efinir un type d’exception
7
Manipulation de fichiers en Python
Ouverture et fermeture de fichier
Lecture d’un fichier
Ecriture dans un fichier ´
Autres fonctions utiles
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Site web
Slides des cours, versions ´ electroniques des polys, TD, TP...
http://www.lipn.fr/~coti/cours
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Boucles Programmation structur´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Introduction
´ Etymologie du mot ”informatique”
Form´ e de la contraction des mots information et automatique.
L’informatique est un outil de traitement automatique de l’information.
On doit alors d´ efinir comment des informations vont ˆ etre trait´ ees (automatiquement) par l’ordinateur.
La science informatique n’est pas plus la science des ordinateurs que l’astronomie n’est celle des t´ elescopes – Edsger Dijkstra
L’ordinateur est un outil qui traite l’information comme le programme lui
dit de la traiter.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Boucles Programmation structur´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Pourquoi l’algorithmique
Qu’est-ce qu’un algorithme ?
Un algorithme d´ efinit ce que fait un programme
Il d´ efinit quel comportement suivre selon la situation rencontr´ ee Algorithme : d´ efinition
S´ erie d’instructions qui doit ˆ etre ex´ ecut´ ee par un programme.
D´ efinition de Wikipedia :
Processus syst´ ematique de r´ esolution d’un probl` eme permettant de d´ ecrire les ´ etapes vers le r´ esultat;
Suite finie et non-ambigu¨ e d’instructions permettant de donner la r´ eponse
`
a un probl` eme.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Boucles Programmation structur´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Comment d´ ecrire un algorithme
D´ efinition de Wikipedia :
L’algorithmique est l’ensemble des r` egles et des techniques qui sont impliqu´ ees dans la d´ efinition et la conception d’algorithmes.
Algorithmique
Formalisme permettant de d´ ecrire la s´ erie d’instructions ex´ ecut´ ee par un programme ind´ ependamment d’un langage de programmation en particulier.
Les algorithmes sont d´ ecrits en pseudo-code, compr´ ehensible par le lecteur
humain mais assez pr´ ecis pour transcrire les structures et les instructions de
l’algorithme.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Boucles Programmation structur´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Par quoi est constitu´ e un algorithme
Un algorithme permet d’obtenir un r´ esultat ` a partir de donn´ ees d’entr´ ee. Il est donc constitu´ e des ´ el´ ements suivants :
Un d´ ebut et une fin ; Un nom ;
Des donn´ ees d’entr´ ee ; Des donn´ ees de sortie, qui sont le r´ esultat du calcul effectu´ e par l’algorithme ; Un ensemble d’instructions ex´ ecut´ ees par l’algorithme.
Exemple : algorithme de calcul d’une valeur absolue
1
d´ ebut fonction abs( i: Entier ): Entier
2
si i > 0 alors
3
r ←− i
4
sinon
5
r ←− −i
6
fin si
7
retourner r
8
fin fonction
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Boucles Programmation structur´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Importance d’un bon algorithme
Compr´ ehension et mod´ elisation du probl` eme
L’algorithme mod´ elise le comportement du programme Correction du r´ esultat
Algorithme faux → r´ esultat du calcul faux Efficacit´ e du calcul
Coˆ ut d’un calcul = nombre d’op´ erations et quantit´ e d’information manipul´ ee
Ces quantit´ es sont d´ efinies par l’algorithme
Algorithme efficace → calcul efficace (et inversement) L’´ etude algorithmique d’un probl` eme est indispensable
La bonne conception d’un algorithme est fondamentale et absolument
n´ ecessaire pr´ ealablement ` a l’´ ecriture d’un programme informatique.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Boucles Programmation structur´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
G´ en´ ericit´ e des algorithmes
Les algorithmes sont ´ ecrits dans un langage de descriptions des algorithmes (pseudo-code)
Ind´ ependant du langage de programmation
→ Un algorithme peut ˆ etre impl´ ement´ e dans n’importe quel langage
Probleme Algorithme Programme Resultats
Analyse Codage Execution
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les tests Boucles Programmation structur´etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Repr´ esentation des donn´ ees
D´ efinition
Une variable correspond ` a l’emplacement m´ emoire d’une donn´ ee. Elle sert ` a stocker une valeur d’un certain type ` a un instant donn´ e de l’ex´ ecution du programme.
Les variables d’un algorithmes sont :
D’entr´ ee : donn´ ees d’entr´ ee de l’algorithme
De sortie : r´ esultat du calcul effectu´ e par l’algorithme
Interne ` a l’algorithme : ni d’entr´ ee ni de sortie mais utilis´ ee ` a l’int´ erieur de
l’algorithme
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les tests Boucles Programmation structur´etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Type de variables
D´ efinition
Le Type d’une variable est le type de donn´ ee qui pourra ˆ etre contenu dans cette variable.
Exemples :
Entier : tout nombre entier Bool´ een : vrai ou faux Caract` ere
Nombre r´ eel Chaˆıne de caract` eres Tableau...
On ne peut pas mettre une donn´ ee d’un type dans une variable d’un autre type
Exception : un transtypage est parfois possible (entier dans r´ eel...)
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les tests Boucles Programmation structur´etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Affectation
Affectation d’une valeur ` a une variable
Pour ´ ecrire une valeur dans une variable, on dit que l’on affecte cette valeur ` a la variable. On le note de la fa¸ con suivante :
variable ←− valeur
1
d´ ebut
2
maV ariable : Entier
3
maV ariable ←− 42
4
fin
On d´ eclare le type de la variable avant de l’utiliser
Les d´ eclarations sont g´ en´ eralement rassembl´ ees au d´ ebut de l’algorithme
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les tests Boucles Programmation structur´etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Les tableaux
Tableaux
Un tableau est un type particulier de variable. Il contient un ensemble de variables de mˆ eme type, stock´ ees de fa¸ con contigu¨ e en m´ emoire.
Exemple : tableau d’entiers 3 5 2 1 12 5 2 9
Caract´ eristiques d’un tableau Un tableau a une taille fixe
Il contient un certain type de donn´ ees D´ eclaration d’un tableau
On le d´ eclare avec le type de donn´ ees qu’il contient et sa taille
1
d´ ebut
2
monT ableau[10] : T ableau d
0Entiers
3
fin
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les tests Boucles Programmation structur´etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonee
Les tableaux (suite)
Tableau ` a plusieurs dimensions
On donne la taille dans chaque dimension
Exemple en 2D (ordre C) : d’abord le nombre de lignes, puis le nombre de colonnes
Acc` es aux donn´ ees d’un tableau
Les cases du tableau sont num´ erot´ ees de 0 ` a N − 1 (si N est la taille du tableau)
On acc` ede aux donn´ ees d’un tableau en utilisant l’indice dans ce tableau
1
d´ ebut
2
/* Variables d’entree */
3
maM atrice[10][10] : T ableau d
0Entiers
4
/* Variables de sortie */
5
i : entier
6
/* Affectation */
7
i ←− maM atrice[2][3]
8
fin
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les testsetres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Bool´ een
Bool´ een
Un bool´ een est une variable ` a deux ´ etats : Vrai ou Faux. On repr´ esente aussi parfois ces deux ´ etats par 1 et 0.
Les op´ erateurs de comparaison renvoient un bool´ een. Exemple : 1 > 0 renvoie Vrai
1 == 0 renvoie Faux
Lorsqu’une condition est ´ evalu´ ee, on regarde sa valeur (bool´ een). Exemple :
1
d´ ebut
2
maV ar : Entier
3
maV ar ←− 0
4
si maV ar < 5 alors
5
maV ar ←− maV ar + 1
6
fin si
7
fin
maV ar est initialis´ e ` a 0 On teste maV ar < 5
´ Equivalent ` a tester 0 < 5 La condition vaut Vrai
Donc on ex´ ecute le bloc d’instruction
apr` es le mot-cl´ e alors
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les testsetres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Un peu d’alg` ebre de Boole
On peut ´ evaluer des expressions bool´ eennes en utilisant des op´ erateurs : Op´ erateurs logiques
ET logique : . OU logique : + OU exclusif : ⊕ N´ egation : ¯ ou !
Exemples : a.b a + b a ⊕ b
a + b =!(a + b) a + b = a+!b
Tables de v´ erit´ e :
. 0 1
0 0 0
1 0 1
+ 0 1
0 0 1
1 1 1
⊕ 0 1
0 0 1
1 1 0
La n´ egation transforme un Vrai en Faux et inversement : V rai = F aux
F aux = V rai
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les testsetres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Un peu d’alg` ebre de Boole (suite)
Prenons a = V rai et b = F aux.
Exemples d’expressions bool´ eennes : a + b = V rai + F aux = V rai
a + b = V rai + F aux = V rai + V rai = V rai a.b = V rai.F aux = V rai.V rai = V rai = F aux
Attention aux parenth` eses ! (a + b).(c + d)
Exemples de compositions d’expressions bool´ eennes sur des variables en algorithmique :
(a > b)ET (a > 0)
Si a = 1 et b = 2 : (a > b) = F aux donc l’expression vaut F aux Si a = 3 et b = 2 : (a > b) = V rai et (a > 0) = V rai donc l’expression vaut V rai
(a > b)OU(a > 0)
Si a = 1 et b = 2 : (a > b) = F aux et (a > 0) = V rai donc l’expression vaut V rai
Si a = 3 et b = 2 : (a > b) = V rai et (a > 0) = V rai donc l’expression
vaut V rai
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les testsetres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Les tests
Un test est une structure conditionnelle : les instructions ex´ ecut´ ees d´ ependent de la r´ ealisation ou non d’une condition.
D´ efinition
Un test d´ efinit une condition et un comportement ` a suivre si elle est r´ ealis´ ee.
Optionnellement, il peut d´ efinir un comportement ` a suivre dans le cas contraire.
Syntaxe :
La condition est donn´ ee entre les mot-cl´ es si et alors
L’action r´ ealis´ ee si la condition est v´ erifi´ ee est donn´ ee apr` es le mot-cl´ e alors
Si on donne une action ` a r´ ealiser si la condition n’est pas v´ erifi´ ee, elle est introduite par le mot-cl´ e sinon Le test est termin´ e par le mot-cl´ e finsi
1
si condition alors
2
action1
3
sinon
4
action2
5
fin si
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les testsetres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Condition d’un test
La condition d’un test est une expression bool´ eenne Valeurs possibles : VRAI ou FAUX
Elle est ´ evalu´ ee pour d´ ecider quel bloc d’instructions ex´ ecuter.
On peut tester :
l’´ egalit´ e entre deux variables : var1 == var2
la non-´ egalit´ e entre deux variables : var1! = var2
une relation d’ordre entre deux variables : var1 > var2
ou toute expression renvoyant V rai ou F aux
1
d´ ebut
2
maV ar : Entier
3
maV ar ←− 0
4
si maV ar < 5 alors
5
maV ar ←− maV ar + 1
6
fin si
7
fin
On peut combiner des expressions bool´ eennes en utilisant les op´ erateurs logiques ET et OU (attention aux parenth` eses) :
((var1 == var2) ET (var1 > 0)) OU (var2 < 0).
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les testsetres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Blocs d’instructions
Un algorithme est structur´ e par blocs d’instructions contenant plusieurs instructions ` a ex´ ecuter s´ equentiellement.
Exemple : les instructions ` a ex´ ecuter si la condition d’un test est r´ ealis´ ee
Les lignes 5 et 6 sont un bloc La ligne 8 est un bloc
Des blocs peuvent ˆ etre imbriqu´ es Un bloc d’instructions peut ˆ etre inclus dans un autre bloc.
Les lignes 2 ` a 9 sont un bloc Les deux blocs dans la condition sont des blocs imbriqu´ es dans ce bloc
1
d´ ebut
2
maV ar : Entier
3
maV ar ←− 0
4
si maV ar < 5 alors
5
maV ar ←− maV ar + 1
6
afficher( mavar )
7
sinon
8
maV ar ←− 0
9
fin si
10
fin
Des instructions d’un bloc sont d´ ecal´ ees vers la droite au mˆ eme niveau
Un bloc est indiqu´ e par une ligne verticale sur la gauche
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variablese Param`Les testsetres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Tests imbriqu´ es
On peut imbriquer des tests, c’est-` a-dire qu’un test peut ˆ etre effectu´ e dans le corps d’un autre test.
On effectue un test ligne 4
Si la condition est r´ ealis´ ee, on ex´ ecute le bloc situ´ e entre les lignes 5 et 8
On effectue alors un autre test ligne 6
Si la condition est r´ ealis´ ee, on ex´ ecute le bloc ligne 7
Sinon, on ex´ ecute le bloc ligne 10.
Le test situ´ e entre les lignes 6 et 8 est imbriqu´ e dans le test situ´ e entre les lignes 4 et 11.
1
d´ ebut
2
maV ar : Entier
3
maV ar ←− 0
4
si maV ar < 5 alors
5
maV ar ←− maV ar + 1
6
si maV ar > 2 alors
7
afficher( mavar )
8
fin si
9
sinon
10
maV ar ←− 0
11
fin si
12
fin
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Les boucles
Condition d’arrˆ et
La condition d’arrˆ et d’une boucle est une condition (une expression bool´ eenne) qui d´ etermine le moment o` u une boucle doit arrˆ eter d’ex´ ecuter le bloc
d’instructions.
Une boucle sert ` a r´ ep´ eter un bloc d’instructions tant qu’une condition de continuation est satisfaite ou que la condition d’arrˆ et n’est pas satisfaite.
Exemples d’utilisation :
Parcours d’un tableau, calcul it´ eratif...
* Une boucle utilise un bloc d’instructions : c’est tout le bloc d’instructions correspondant qui est r´ ep´ et´ e.
Il est possible que le bloc d’instructions ne soit pas ex´ ecut´ e du tout (si la
condition d’arrˆ et est d´ ej` a satisfaite) ou un nombre infini de fois (souvent un
bug).
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Boucle Pour
On d´ efinit un compteur et :
Une initialisation de ce compteur i ← 0
Une condition d’arrˆ et pour sortir de la boucle
` a 9
Un pas qui modifie le compteur ` a la fin de chaque it´ eration
pas 1
On termine le bloc avec finpour
Exemple : algorithme de remplissage d’un tableau de 10 cases.
1
d´ ebut
2
tab[10] : T ableau d
0entiers
3
pour i ←− 0 a 9 pas 1 faire
4
tab[i] = 2 ∗ i
5
fin pour
6
fin
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Boucle Pour (suite)
Le pas est n’importe quel modificateur sur le compteur : il peut ˆ etre n´ egatif, non lin´ eaire...
1
d´ ebut
2
pour i ←− 10 a 0 pas −2 faire
3
afficher( i )
4
fin pour
5
fin
Affichage par le programme : 10
8 6 4 2 0
1
d´ ebut
2
pour i ←− 1 a 35 pas ∗2 faire
3
afficher( i )
4
fin pour
5
fin
Affichage par le programme : 1
2 4 8 16 32
La boucle s’ex´ ecute tant que i est
inf´ erieur ` a 35 : on s’arrˆ ete ` a 32.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Boucle Tant que... faire
La boucle Tant que ex´ ecute un bloc d’instructions tant qu’une condition est vraie : c’est la condition de boucle.
La condition de boucle est d´ efinie apr` es le mot-cl´ e Tant que
L’action ` a effectuer est donn´ ee entre les mot-cl´ es faire et fintq : on d´ efinit un bloc d’instructions qui est r´ ep´ et´ e
Attention aux boucles infinies !
Il faut que la condition de boucle finisse par ˆ etre invalid´ ee...
Exemple : algorithme de calcul des puissances de 2 inf´ erieures ` a 50.
1
d´ ebut
2
puissance : Entier
3
puissance ←− 1
4
tant que puissance < 50 faire
5
afficher( puissance )
6
puissance ←− puissance ∗ 2
7
fin tq
8
fin
Affichage : 1
2
4
8
16
32
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Boucle Tant que... faire (suite)
1
d´ ebut
2
puissance : Entier
3
puissance ← 1
4
tant que puissance < 50 faire
5
afficher( puissance )
6
puissance ← puissance ∗ 2
7
fin tq
8
fin
D´ etail de l’ex´ ecution : puissance vaut 1
puissance est-il inf´ erieur ` a 50 ? oui donc on ex´ ecute le bloc
Affichage : 1 puissance vaut 2
Retour ` a la ligne 4 : puissance est-il inf´ erieur ` a 50 ? oui donc on ex´ ecute le bloc
Affichage : 2 puissance vaut 4 ...
Lorsque puissance prend la valeur 64 :
la condition ligne 4 n’est plus satisfaite
et on sort de la boucle
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Equivalence entre les boucles ´ for et tant que ... faire
On peut ´ ecrire une boucle faire ... tant que ´ equivalente ` a une boucle for : Le compteur est initialis´ e avant d’entrer dans la boucle faire ... tant que La condition de boucle est la mˆ eme que la condition d’arrˆ et de la boucle for
Le compteur est modifi´ e ` a la fin du bloc d’instruction ex´ ecut´ e par la boucle faire ... tant que
1
d´ ebut
2
pour i ←− 0 a 9 pas 1 faire
3
tab[i] = 2 ∗ i
4
fin pour
5
fin
1
d´ ebut
2
i : entier
3
i ←− 0
4
tant que i < 10 faire
5
tab[i] = 2 ∗ i
6
i ←− i + 1
7
fin tq
8
fin
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Boucle Faire ... tant que
La boucle Faire ... tant que ex´ ecute un bloc d’instructions puis ´ evalue une condition de boucle
Le bloc d’instructions est r´ ep´ et´ e si la condition de boucle est satisfaite
1
d´ ebut
2
puissance : Entier
3
puissance ← 1
4
faire
5
afficher( puissance )
6
puissance ← puissance ∗ 2
7
tant que puissance < 20;
8
fin
D´ etail de l’ex´ ecution : puissance vaut 1 Affichage : 1 puissance vaut 2
puissance est-il inf´ erieur ` a 20 ? oui donc on r´ e-ex´ ecute le bloc : retour ` a la ligne 4
Affichage : 2 puissance vaut 4 ...
Lorsque puissance a pris la valeur 32 :
la condition ligne 7 n’est plus satisfaite
et on sort de la boucle
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les testse Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonBoucles Programmation structur´ee
Diff´ erence entre les boucles Faire ... tant que et Tant que ... faire
La boucle Faire ... tant que commence par ´ evaluer la condition de boucle
Puis elle ex´ ecute le bloc d’instructions si la condition de boucle est valid´ ee La boucle Tant que ... faire ex´ ecute le bloc d’instructions puis elle
´
evalue la condition de boucle
Algorithme d’attente ` a un stop :
1
d´ ebut
2
vitesse : Entier
3
faire
4
vitesse ←− 0
5
tant que voituresArrivent == V rai;
6
vitesse ←− 50
7
fin
Algorithme d’attente ` a un feu rouge :
1
d´ ebut
2
vitesse : Entier
3
tant que couleurF eu == rouge faire
4
vitesse ←− 0
5
fin tq
6
vitesse ←− 50
7
fin
Avec un stop on s’arrˆ ete, puis on regarde si on peut avancer. ` A un feu de
circulation, on s’arrˆ ete si le feu est rouge ; si le feu n’est pas rouge, on avance.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
D´ ecomposition d’un probl` eme en sous-probl` emes
”... diviser chacune des difficult´ es que j’examinerais en autant de parcelles qu’il se pourrait et qu’il serait requis pour mieux les r´ esoudre.”
Discours de la m´ ethode (1637)
Ren´ e Descartes
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Fonctions
D´ efinition
Une fonction d´ efinit une action effectu´ ee sur un ensemble de param` etres qui produit un r´ esultat retourn´ e comme valeur de sortie de la fonction.
Elle fournit une abstraction pour cette action vis-` a-vis des algorithmes qui l’appellent.
Analogie avec les fonctions math´ ematiques : f : x 7→ f(x) On d´ efinit la fonction une fois
On l’appelle autant de fois qu’on veut
Avantages : factorisation de code, abstraction pour la conception de
l’algorithme... Permet de se concentrer sur l’algorithme lui-mˆ eme plutˆ ot que
sur les d´ etails.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Param` etres et r´ esultat
On donne les param` etres et leur type
On d´ eclare les param` etres entre parenth` eses
On les utilise dans la fonction en utilisant ce nom : ce sont des variables Il existe des param` etres
D’entr´ ee : utilis´ es dans la fonction De sortie : modifi´ es dans la fonction
Ou les deux : utilis´ es et modifi´ es dans la fonction On d´ eclare le type retourn´ e
D´ eclaration de la fonction suivie par : type
On sort de la fonction avec le mot cl´ e retourner et la valeur retourn´ ee
1
d´ ebut fonction carre( nombre: Entier ): Entier
2
resultat : Entier
3
resultat ←− nombre × nombre
4
retourner resultat
5
fin fonction
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Appel de fonction
On appelle la fonction ` a partir d’un autre algorithme
On lui passe en param` etres des variables de l’algorithme appelant La valeur retourn´ ee est mise dans une variable de l’algorithme appelant
1
d´ ebut programme
2
nombreDepart : Entier
3
calcul : Entier
4
calcul ←− carre ( nombreDepart )
5
fin programme
1
d´ ebut fonction carre( nombre: Entier ): Entier
2
resultat : Entier
3
resultat ←− nombre × nombre
4
retourner resultat
5
fin fonction
La fonction fournit donc une abstraction de l’action qu’elle r´ ealise param´ etr´ ee
par les variables pass´ ees lors de l’appel.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Proc´ edures
Une proc´ edure effectue une action. Elle ne retourne rien.
Affichage : pas de r´ esultat de calcul ` a r´ ecup´ erer Calcul sur des variables de sortie
On sort de la proc´ edure
A la fin du bloc d’instructions principal `
Ou quand on rencontre le mot-cl´ e Retour
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Proc´ edures (exemple)
1
d´ ebut programme
2
puissance : Entier
3
puissance ( puissance )
4
afficher ( puissance )
5
fin programme
1
d´ ebut proc´ edure puissance( petitepuissance: Entier Sortie )
2
petitepuissance ←− 1
3
tant que V rai faire
4
petitepuissance ←− petitepuissance × 2
5
if petitepuissance > 200 then
6
retourner
7
end if
8
fin tq
9
fin proc´ edure
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Visibilit´ e des variables
Les variables d´ eclar´ ees dans la fonction ne sont visibles que dans la fonction
Les variables d´ eclar´ ees dans le programme appelant ne sont visibles que dans le programme appelant ne sont pas visibles dans la fonction
Les variables pass´ ees en param` etre
sont appel´ ees par leur nom dans le programme appelant dans l’appel de la fonction
sont appel´ ees par le nom utilis´ e pour les d´ eclarer dans la fonction elle-mˆ eme
Visibilit´ e des variables
Les variables sont visibles uniquement dans la fonction, la proc´ edure ou le
programme dans lequel elles ont ´ et´ e d´ eclar´ ees, et dans aucune des fonctions ou
proc´ edures appel´ ees ou qui l’appellent.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Approche descendante
Les fonctions et les proc´ edures fournissent une abstraction sur les actions r´ ealis´ ees par le programme
Possibilit´ e de les utiliser pour se concentrer sur la structure du programme plutˆ ot que sur la r´ esolution des sous-probl` emes
On d´ ecompose le probl` eme en sous-probl` emes
On fait dans un premier temps l’hypoth` ese qu’ils sont r´ esolus On s’en occupe plus tard
La conception de l’algorithme dans sa globalit´ e est ainsi plus simple D´ ecomposer pour mieux maˆıtriser
On retarde le plus possible le moment d’effectuer les calculs
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Approche descendante : exemple
Th´ eor` eme de Pythagore : ”le carr´ e de l’hypot´ enuse d’un triangle rectangle est
´ egal ` a la somme des carr´ es des longueurs des deux autres cˆ ot´ es”.
1
d´ ebut fonction hypo( cote1: Entier, cote2: Entier ): Entier
2
/* variables internes */
3
carre1 : Entier
4
carre2 : Entier
5
hypotenusecarre : Entier
6
hypotenuse : Entier
7
/* on calcule la somme des carr´ es des cˆ ot´ es */
8
carre1 ←− carr´ e( cote1 )
9
carre2 ←− carr´ e( cote2 )
10
hypotenusecarre ←− carre1 + carre2
11
/* on prend la racine carr´ ee de la somme et on retourne le r´ esultat */
12
hypotenuse ←− racine( hypotenusecarre )
13
retourner hypotenuse
14
fin fonction
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
Approche descendante : exemple (suite)
1
d´ ebut fonction carr´ e( nombre: Entier ): Entier
2
moncarre : Entier
3
moncarre ←− nombre × nombre
4
retourner moncarre
5
fin fonction
1
d´ ebut fonction racine( nombre: Entier ): Entier
2
maracine : reel
3
maracine ←− √ nombre
4
retourner maracine
5
fin fonction
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables Les tests Bouclese Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonProgrammation structur´ee
R´ ecursivit´ e
Une fonction ou une proc´ edure peut s’appeler elle-mˆ eme Elle est alors partiellement d´ efinie ` a partir d’elle-mˆ eme
1
d´ ebut fonction calcul( var: Entier ): Entier
2
si var == 1 alors
3
retourner var
4
sinon
5
retourner var×calcul( var − 1 )
6
fin si
7
fin fonction
Correspond bien aux relations de r´ ecurrence
Attention au point d’arrˆ et !
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Introduction ` a Python
Python est un Langage de script Rapidit´ e de d´ eveloppement
Utilisation pour des scripts d’administration syst` eme, analyse de fichiers textuels (logs...)
Langage pour le web : d´ eveloppement d’applications web, scripts CGI, serveurs...
Acc` es aux bases de donn´ ees relationnelles Python est un langage de programmation
Programmes complets en Python
Interfa¸ cage facile avec des biblioth` eques dans d’autres langages (C, C++, Fortran...)
Acc` es aux interfaces graphiques facilit´ e
Permet de se concentrer sur l’algorithme plutˆ ot que l’impl´ ementation :
calcul scientifique pour les non-informaticiens...
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Ex´ ecution de programmes Python
Deux moyens d’ex´ ecuter des scripts Python :
En ligne de commande: dans l’interpr´ eteur interactif On lance l’interpr´ eteur
1 c o t i @ m a x i m u m :~ $ p y t h o n
2 P y t h o n 2 . 7 . 3 rc2 ( default , Apr 22 2012 , 2 2 : 3 0 : 1 7 ) 3 [ GCC 4 . 6 . 3 ] on l i n u x 2
4 T y p e " h e l p " , " c o p y r i g h t " , " c r e d i t s " or " l i c e n s e " for m o r e i n f o r m a t i o n .
5 > > > p r i n t 3
6 3
Rapidit´ e de mise en place Permet de tester des choses En ex´ ecutant un script
Fichier ex´ ecutable Deux possibilit´ es :
Ex´ecution directe et le script appelle l’interpr´eteur Attention aux droits (+x)
1 c o t i @ m a x i m u m :~ $ ./ m o n s c r i p t . py
Lancement dans l’interpr´eteur
1 c o t i @ m a x i m u m :~ $ p y t h o n ./ m o n s c r i p t . py
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Scripts Python
Si il est lanc´ e seul, un script Python doit remplir deux conditions : Etre ˆ ex´ ecutable (+x)
Sp´ ecifier le chemin vers l’interpr´ eteur : c’est le shebang On place le shebang au d´ ebut du fichier :
1 # !/ u s r / b i n / p y t h o n
Attention : si le shebang ne pointe pas vers le bon interpr´ eteur, erreur.
1 c o t i @ t h o r i m :/ t m p $ cat d e m o . py 2 # !/ u s r / p y t h o n
3 c o t i @ t h o r i m :/ t m p $ ./ d e m o . py
4 - b a s h : ./ d e m o . py : / usr / p y t h o n : bad i n t e r p r e t e r : No s u c h f i l e or d i r e c t o r y
Possibilit´ e de faire coexister plusieurs versions de Python sur le syst` eme.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Commentaires en Python
Pour commenter une ligne de code on utilise # Une ligne comment´ ee n’est pas ex´ ecut´ ee Commente tout ce qui suit la ligne
Commente une et une seule ligne : le commentaire s’arrˆ ete ` a la fin de la ligne
Pour commenter plusieurs lignes, on encadre la section ` a commenter par ’’’
(triple quote) ou """ (triple double quote) Le commentaire commence au triple quote Il se termine au triple quote suivant
Impossible d’imbriquer des commentaires sur plusieurs lignes
1 # !/ u s r / b i n / p y t h o n 2
3 ’ ’ ’
4 un c o m m e n t a i r e 5 s u r p l u s i e u r s l i g n e s 6 ’ ’ ’
7
8 # un c o m m e n t a i r e s u r u n e l i g n e
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Affichage d’une chaˆıne de caract` eres
On affiche une chaˆıne de caract` eres avec l’instruction print En suivant directement l’instruction print
1 > > > p r i n t " t o t o "
2 t o t o 3 > > > a = 2 4 > > > p r i n t a
5 2
Ou n’importe quoi entre parenth` eses
1 > > > p r i n t ( a )
2 2
Les chaˆınes de caract` eres sont donn´ ees entre guillemets, sinon elles sont interpret´ ees comme des noms de variables
1 > > > p r i n t " t o t o "
2 t o t o
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Affichage d’une chaˆıne de caract` eres
Op´ erateur de concat´ enation : +
Attention, le + est d’abord interpr´ et´ e comme un op´ erateur math´ ematique si il est utilis´ e sur autre chose que des chaˆınes de caract` ere
1 > > > p r i n t a + 3
2 5
3 > > > p r i n t a , 3 4 2 3
Possibilit´ e d’afficher deux ´ el´ ements de types diff´ erents ` a la suite avec , (s´ epar´ es par un espace)
On ne peut concat´ ener que des variables de mˆ eme type :
1 > > > p r i n t " t o t o " + 3
2 T r a c e b a c k ( m o s t r e c e n t c a l l l a s t ) : 3 F i l e " < stdin > " , l i n e 1 , in < module >
4 T y p e E r r o r : c a n n o t c o n c a t e n a t e ’ str ’ and ’ int ’ o b j e c t s
Solution : convertir la variable en chaˆıne de caract` eres
1 > > > p r i n t " t o t o " + str ( 3 ) 2 t o t o 3
3 > > > p r i n t " t o t o " , 3 4 t o t o 3
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Type des variables
Type implicite :
On ne d´ eclare pas les variables
Le type d´ epend de la premi` ere initialisation Exemple :
1 m a V a r 1 = 5 # un e n t i e r
2 m a V a r 2 = 3.0 # un r e e l
3 m a C h a i n e = " T o t o " # u n e c h a i n e de c a r a c t e r e s
Si on change de type :
La premi` ere variable est d´ etruite
Une nouvelle est cr´ e´ ee sous le mˆ eme nom
1 m a V a r = 5 # un e n t i e r
2 m a V a r = 3.0 # un r e e l
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Types fournis par Python
Entiers :
integer : 32 bits long integer : 64 bits
1 > > > a = 3 # e n t i e r 2 > > > b = 1 L # e n t i e r l o n g
R´ eels :
type float : 64 bits, virgule flottante Complexes :
partie r´ eelle et partie imaginaire type float pour chacun des nombres
1 > > > z = 9+5 J
2 > > > p r i n t z . i m a g
3 5.0
4 > > > p r i n t z . r e a l
5 9.0
6 > > > p r i n t z
7 ( 9 + 5 j )
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Chaˆınes de caract` eres
Chaˆınes de caract` eres :
donn´ ees entre ’ (simple quote) ou entre " (double quote)
si la chaˆıne contient un ’ ou un " : on l’´ echappe avec un \ pour qu’il ne soit pas interpr´ et´ e
1 str = " V i v e la p r o g "
2 s t r 2 = ’ P y t h o n c \ ’ est bon ’ 3 s t r 3 = " P r u c h \ ’ e l l a d u r i "
Concat´ enation avec + :
1 > > > t o t o = " b l a b l a "
2 > > > t i t i = " b l u b l u "
3 > > > t a t a = t o t o + t i t i 4 > > > p r i n t t a t a 5 b l a b l a b l u b l u
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Introspection
D´ efinition : Connaissance qu’une entit´ e a d’elle-mˆ eme.
Ici : possibilit´ e qu’a le programme d’examiner la structure d’une variable, de connaitre son type.
On utilise la fonction type()
1 > > > i = 5 2 > > > t y p e ( i ) 3 < t y p e ’ int ’ >
4 > > > j = 6 L 5 > > > t y p e ( j ) 6 < t y p e ’ l o n g ’ >
7 > > > z = 9+5 J 8 > > > t y p e ( z ) 9 < t y p e ’ c o m p l e x ’ >
10 > > > t y p e ( z . r e a l ) 11 < t y p e ’ f l o a t ’ >
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Conversion de type
But : obtenir une variable d’un type donn´ e contenant la mˆ eme valeur qu’une autre variable d’un autre type.
On utilise une fonction qui construit la nouvelle variable du type voulu Cette fonction porte le nom de ce type
Exemple : pour un entier, fonction int()
1 > > > a = 7.0 2 > > > t y p e ( a ) 3 < t y p e ’ f l o a t ’ >
4 > > > b = int ( a ) 5 > > > p r i n t b
6 7
7 > > > t y p e ( b ) 8 < t y p e ’ int ’ >
Si la variable r´ esultat ne peut pas contenir toute l’information de la variable initiale, la valeur est tronqu´ ee
Exemple : un r´ eel converti en entier → l’entier contient la partie enti` ere du r´ eel
1 > > > a = 7.7 2 > > > b = int ( a ) 3 > > > p r i n t b
4 7
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Saisie d’une valeur par l’utilisateur
Saisie d’une chaˆıne de caract` eres par l’utilisateur : raw input()
Ce qui est lu est toujours consid´ er´ e comme une chaˆıne de caract` eres Param` etre (optionnel) : invite affich´ ee ` a l’´ ecran
1 > > > a = r a w _ i n p u t ( " e n t r e r une v a l e u r " ) ) 2 e n t r e r une v a l e u r t o t o
3 > > > t y p e ( a ) 4 < t y p e ’ str ’ >
5 > > > b = r a w _ i n p u t ()
6 3
7 > > > t y p e ( b ) 8 < t y p e ’ str ’ >
Saisie d’une valeur par l’utilisateur : input()
Le type de la variable obtenue d´ epend de la valeur saisie
1 > > > c = i n p u t ( " - - - > " ) 2 - - - > 4
3 > > > t y p e ( c ) 4 < t y p e ’ int ’ >
5 > > > d = i n p u t ( ) 6 t o t o
7 T r a c e b a c k ( m o s t r e c e n t c a l l l a s t ) : 8 F i l e " < stdin > " , l i n e 1 , in < module >
9 F i l e " < string > " , l i n e 1 , in < module >
10 N a m e E r r o r : n a m e ’ t o t o ’ is not d e f i n e d 11 > > > d = i n p u t ( )
12 " t o t o "
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Blocs en Python
L’indentation est primordiale
C’est le niveau d’indentation qui d´ efinit les blocs Utilisation de la tabulation
Les blocs n’ont pas de d´ elimiteur de fin explicite : c’est le retour au niveau d’indentation inf´ erieur (vers la gauche) qui l’indique.
1 if T r u e :
2 # d e b u t d ’ un b l o c
3 p r i n t " on est d a n s le b l o c "
4 # f i n d ’ un b l o c
5 p r i n t " r e t o u r d a n s le b l o c d ’ o r i g i n e "
Chaque bloc imbriqu´ e est situ´ e ` a un niveau d’indentation sup´ erieur : une
tabulation suppl´ ementaire vers la droite.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Tests
Mot-cl´ e if suivi de deux points :
Le bloc ` a ex´ ecuter est indent´ e vers la droite
1 a = 5
2 if a > 0:
3 p r i n t " a est p o s i t i f "
Alternative : mot-cl´ e else suivi de deux points :
1 a = 5
2 if a >= 0:
3 p r i n t " a est p o s i t i f ou nul "
4 e l s e :
5 p r i n t " a est n e g a t i f "
Possibilit´ e d’enchainer les tests avec elif
1 a = 5
2 if a > 0:
3 p r i n t " a est p o s i t i f "
4 e l i f a == 0:
5 p r i n t " a est nul "
6 e l s e :
7 p r i n t " a est n e g a t i f "
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Boucle for
On peut r´ ep´ eter un ensemble d’instructions avec la boucle for Correspond ` a la boucle Pour vue en algorithmique On it` ere sur un ensemble de valeurs
Par exemple, l’ensemble d’entiers compris entre deux valeurs : fonction range()
Un seul argument : entiers compris entre 0 et cet argument (exclu)
1 > > > p r i n t r a n g e ( 5 )
2 [0 , 1 , 2 , 3 , 4]
Deux arguments : entiers compris entre le 1er et le 2eme argument
1 > > > p r i n t r a n g e ( 2 , 5 )
2 [2 , 3 , 4]
Trois arguments : entiers compris entre le 1er et le 2eme argument avec un pas correspondant au 3eme argument
1 > > > p r i n t r a n g e ( 1 , 10 , 3 )
2 [1 , 4 , 7]
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Boucle for (suite)
Une utilisation de la boucle for consiste donc ` a int´ erer sur un ensemble de valeurs d’un compteur
Ensemble de valeurs suivi de deux points : Le bloc ` a ex´ ecuter est indent´ e d’un cran
1 for i in r a n g e ( 0 , 10 , 2 ) :
2 p r i n t i
correspond ` a :
1
pour i ←− 0 a 9 pas 2 faire
2
af f icher(i)
3
fin pour
Affichage obtenu :
1 c o t i @ t h o r i m :~ $ ./ d e m o . py
2 0
3 2
4 4
5 6
6 8
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Pythone Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en PythonStructures de contrˆole Fonctions
Boucle conditionnelle while
Un autre type de boucle est la boucle conditionnelle : un bloc d’instructions est r´ ep´ et´ e tant qu’une condition est r´ ealis´ ee.
La condition est ´ evalu´ ee avant d’ex´ ecuter le bloc d’instructions Si elle n’est jamais r´ ealis´ ee, on n’entre jamais dans la boucle On utilise le mot-cl´ e while
Condition suivie de deux points : Le bloc ` a ex´ ecuter est indent´ e d’un cran
1 i = 0
2 w h i l e i < 10 :
3 p r i n t i
4 i = i + 1
En langage algorithmique, cela correspondrait ` a une boucle tant que :
1
i : Entier
2
i ←− 0
3
tant que i < 10 faire
4
af f icher(i)
5
i ←− i + 1
6
fin tq
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Fonctions et proc´ edures
La d´ efinition d’une fonction est introduite par le mot-cl´ e def Suivi du nom de la fonction
Entre parenth` eses, ses arguments (parenth` eses vides si aucun) Enfin, la ligne est termin´ ee par deux points :
Le corps de la fonction est un bloc : on l’indente donc d’un cran vers la droite On peut sortir d’une fonction de deux fa¸ cons :
En arrivant ` a la fin de la fonction : retour ` a l’indentation de niveau maximal (compl` etement ` a gauche), dans le cas d’une proc´ edure En ex´ ecutant le mot-cl´ e return
Soit seul : fin d’une proc´ edure (ne retournant rien) Soit suivi d’une variable qui est retourn´ ee par la fonction
1 def m a F o n c t i o n ( a ) :
2 p r i n t " p a r a m e t r e : " + str ( a ) + " de t y p e " + str ( t y p e ( a ) )
3 r e t u r n t y p e ( a )
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Appel d’une fonction
On appelle une fonction par son nom, en lui passant ses param` etres entre parenth` eses
1 def m a F o n c t i o n ( a ) :
2 p r i n t " p a r a m e t r e : " + str ( a ) + " de t y p e " + str ( t y p e ( a ) )
3 r e t u r n t y p e ( a )
4
5 # a i l l e u r s d a n s le p r o g r a m m e 6 m a F o n c t i o n ( 5 )
7 m a F o n c t i o n ( " t o t o " )
Attention : pas de v´ erification du type des arguments pass´ es
Source d’erreurs pas directement d´ etect´ ees : c’est lors de l’utilisation de la variable de type incorrect dans la fonction que l’erreur est annonc´ ee (si elle l’est...)
Rend possible l’appel de la fonction avec des arguments de diff´ erents types
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´Les variables en Python Structures de contrˆe Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Pythonole Fonctions
Point d’entr´ ee dans le programme
L’ex´ ecution d’un script Python commence par la premi` ere ligne en-dehors de toute fonction
On ex´ ecute la premi` ere ligne du bloc de plus haut niveau qui ne soit pas une d´ efinition de fonction
1 def m a F o n c t i o n ( a ) :
2 p r i n t " p a r a m e t r e : " + str ( a ) + " de t y p e " + str ( t y p e ( a ) )
3 r e t u r n t y p e ( a )
4
5 m a F o n c t i o n ( 5 ) # p r e m i e r e l i g n e e x e c u t e e
Les programmes Python complexes sont souvent compos´ es de plusieurs modules (plus de d´ etails plus tard)
Nom du module dans lequel on se trouve : variable name Module principal = main
G´ en´ eralement, on commence par tester si on se trouve dans le module principal Si c’est le cas, on effectue nos appels de fonction
Int´ erˆ et : ´ ecrire des modules auto-suffisants ou utilisables par d’autres scripts
1 if _ _ n a m e _ _ == " _ _ m a i n _ _ " : 2 a p p e l _ f o n c t i o n ()
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Collections
D´ efinition : une collection est une structures de donn´ ees permettant de stocker des ensembles.
Trois types en Python : Les listes
Les tuples Les dictionnaires
Les op´ erations que l’on peut effectuer sur chacune sont sp´ ecifiques au type de collection.
Particularit´ e : les ´ el´ ements contenus dans les collections ne sont pas forc´ ement
tous du mˆ eme type.
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Les listes
Ensemble d’´ el´ ements non tri´ es modifiables Notation :
La liste est donn´ ee entre crochets Les ´ el´ ements sont s´ epar´ es par des virgules
1 > > > l = []
2 > > > t y p e ( l ) 3 < t y p e ’ l i s t ’ >
4 > > > m = [ 5 , 7.6 , " b o n j o u r " ]
Une liste est ordonn´ ee : l’ordre dans lequel ses ´ el´ ements sont dispos´ es a de l’importance.
Pour acc´ eder ` a un ´ el´ ement de la liste : utilisation de l’op´ erateur crochets La num´ erotation des indices commence ` a 0.
1 > > > p r i n t m [0]
2 5
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Op´ erations sur les listes
Nombre d’´ el´ ements dans une liste : fonction len()
1 > > > len ( m )
2 3
Ajouter un ´ el´ ement dans une liste : A la fin de la liste : fonction ` append()
1 > > > j o u r = [ ’ l u n d i ’ , ’ m a r d i ’ , ’ m e r c r e d i ’ , ’ j e u d i ’ , ’ v e n d r e d i ’ ] 2 > > > j o u r . a p p e n d ( ’ d i m a n c h e ’ )
3 > > > p r i n t j o u r
4 [ ’ l u n d i ’ , ’ m a r d i ’ , ’ m e r c r e d i ’ , ’ j e u d i ’ , ’ v e n d r e d i ’ , ’ d i m a n c h e ’ ]
A un endroit pr´ ` ecis de la liste : fonction insert()
1 > > > j o u r . i n s e r t ( 5 , ’ s a m e d i ’ ) 2 > > > p r i n t j o u r
3 [ ’ l u n d i ’ , ’ m a r d i ’ , ’ m e r c r e d i ’ , ’ j e u d i ’ , ’ v e n d r e d i ’ , ’ s a m e d i ’ , 4 ’ d i m a n c h e ’ ]
Compter le nombre de fois o` u un ´ el´ ement apparait dans le liste : fonction count()
1 > > > l s t 5 = [ 3 , 5 , 2 , 4 , 4 , 3]
2 > > > l s t 5 . c o u n t ( 4 )
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Op´ erations sur les listes
Retirer un ´ el´ ement d’une liste : fonction remove()
1 > > > j o u r . r e m o v e ( ’ s a m e d i ’ ) 2 > > > p r i n t j o u r
3 [ ’ l u n d i ’ , ’ m a r d i ’ , ’ m e r c r e d i ’ , ’ j e u d i ’ , ’ v e n d r e d i ’ , ’ d i m a n c h e ’ ]
Si l’´ el´ ement se trouve plusieurs fois dans la liste, seul le premier est retir´ e.
Retirer un ´ el´ ement d’une liste en le retournant : fonction pop()
Si un indice est pass´ e en param` etre : on retire l’´ el´ ement correspondant ` a cet indice
Si pas de param` etre pass´ e : on retire le dernier ´ el´ ement de la liste
1 > > > j o u r . pop () 2 ’ d i m a n c h e ’ 3 > > > p r i n t j o u r
4 [ ’ l u n d i ’ , ’ m a r d i ’ , ’ m e r c r e d i ’ , ’ j e u d i ’ , ’ v e n d r e d i ’ ] 5 > > > j o u r . pop (2)
6 ’ m e r c r e d i ’ 7 > > > p r i n t j o u r
8 [ ’ l u n d i ’ , ’ m a r d i ’ , ’ j e u d i ’ , ’ v e n d r e d i ’ ]
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Op´ erations sur les listes
Concat´ enation de listes : op´ erateur +
1 > > > l s t 1 = [1 , 2 , 3]
2 > > > l s t 2 = [9 , 8 , 7]
3 > > > l s t 3 = l s t 1 + l s t 2 4 > > > p r i n t l s t 3 5 [1 , 2 , 3 , 9 , 8 , 7]
Tri des ´ el´ ements d’une liste : fonction sort()
1 > > > l s t 2 . s o r t () 2 > > > p r i n t l s t 2
3 [7 , 8 , 9]
Assemblage des ´ el´ ements d’une liste sous forme d’une chaˆıne de caract` eres : fonction join() (avec une autre chaˆıne de caract` eres)
1 > > > l s t 4 = [ ’ i ’ , ’ u ’ , ’ tv ’ ] 2 > > > " " . j o i n ( l s t 4 )
3 ’ i u t v ’
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Les tuples
Tuple : structure de donn´ ee proche d’une liste, mais non modifiable La liste est donn´ ee entre parenth` eses
Les ´ el´ ements sont s´ epar´ es par des virgules
Op´ erations sur les tuples : les mˆ emes que pour les listes, en-dehors des op´ erations de modifications.
1 > > > j o u r = ( ’ l u n d i ’ , ’ m a r d i ’ , ’ m e r c r e d i ’ , ’ j e u d i ’ , ’ v e n d r e d i ’ ) 2 > > > j o u r . a p p e n d ( ’ d i m a n c h e ’ )
3 T r a c e b a c k ( m o s t r e c e n t c a l l l a s t ) : 4 F i l e " < stdin > " , l i n e 1 , in < module >
5 A t t r i b u t e E r r o r : ’ t u p l e ’ o b j e c t has no a t t r i b u t e ’ a p p e n d ’
Pourquoi utiliser des tuples :
Impl´ ement´ es de fa¸ con plus simple que les listes : ils utilisent moins de ressources (en particulier en m´ emoire).
Pour s’assurer qu’un ensemble ne sera pas modifi´ e par une autre partie du programme
Pourquoi ne pas utiliser des tuples :
Non modifiables : plus contraignants
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Les dictionnaires
Dictionnaire : structure de donn´ ee qui effectue une association entre une cl´ e et une valeur.
Notation :
D´ efinition en utilisant des accolades.
Couples cl´ e-valeur s´ epar´ es par des virgules Une cl´ e est s´ epar´ ee de sa valeur par deurs points :
1 > > > dic = { ’ p o m m e ’ : ’ f r u i t ’ , ’ p o i r e ’ : ’ f r u i t ’ , ’ p o i r e a u ’ : 2 ’ l e g u m e ’ }
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Op´ erations sur les dictionnaires
Acc´ eder aux valeurs : on donne la cl´ e entre crochets
1 > > > dic [ ’ p o i r e a u ’ ] 2 ’ l e g u m e ’
Ajouter une nouvelle paire : on affecte la valeur ` a sa cl´ e pass´ ee entre crochets.
1 > > > dic [ ’ t o m a t e ’ ] = ’ f r u i t ’ 2 > > > p r i n t dic
3 { ’ p o i r e ’ : ’ f r u i t ’ , ’ t o m a t e ’ : ’ f r u i t ’ , ’ p o i r e a u ’ : ’ l e g u m e ’ , ’ p o m m e ’ : ’ f r u i t ’ }
Suppression d’un couple :
Suppression en retournant la valeur : fonction pop() en passant la cl´ e de l’´ el´ ement ` a supprimer
1 > > > dic . pop ( ’ p o i r e a u ’ ) 2 ’ l e g u m e ’
3 > > > p r i n t dic
4 { ’ p o i r e ’ : ’ f r u i t ’ , ’ t o m a t e ’ : ’ f r u i t ’ , ’ p o m m e ’ : ’ f r u i t ’ }
Suppression simple : op´ erateur del sur un ´ el´ ement d´ esign´ e par sa cl´ e entre crochets
1 > > > del dic [ ’ p o m m e ’ ] 2 > > > p r i n t dic
3 { ’ p o i r e ’ : ’ f r u i t ’ , ’ t o m a t e ’ : ’ f r u i t ’ }
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
Op´ erations sur les dictionnaires
Liste des cl´ es et des valeurs : fonctions keys() et values().
1 > > > dic . k e y s ()
2 [ ’ p o i r e ’ , ’ t o m a t e ’ , ’ p o i r e a u ’ , ’ p o m m e ’ ] 3 > > > dic . v a l u e s ()
4 [ ’ f r u i t ’ , ’ f r u i t ’ , ’ l e g u m e ’ , ’ f r u i t ’ ]
Remarque : ce sont des listes.
Existence d’une cl´ e dans le dictionnaire : fonction has key().
1 > > > dic . h a s _ k e y ( ’ t o m a t e ’ ) 2 T r u e
Introduction `a l’algorithmique Introduction `a Python Structures de donn´ees Modularit´e Param`etres optionnels de fonctions Les exceptions Manipulation de fichiers en Python
El´ ´ ements d’une collection
On peut effectuer une boucle for en it´ erant sur les ´ el´ ements contenus dans une collection : utilisation du mot-cl´ e in
1 lst = [1 , 4 , 6]
2 for i in lst :
3 p r i n t i
La variable d’it´ eration contient l’´ el´ ement de la liste sur lequel on se trouve.
On peut tester l’appartenance ` a une collection :
1 lst = [1 , 4 , 6]
2 if 4 in lst :
3 p r i n t 4 est p r e s e n t