Merge branch 'master' of ssh://forge.cadoles.com:4242/cadoles/formations
This commit is contained in:
commit
b37051c78d
|
|
@ -1,36 +0,0 @@
|
||||||
Initiation à l'algorithmique et présentation de la programmation
|
|
||||||
================================================================
|
|
||||||
|
|
||||||
**Présentation du cours**
|
|
||||||
|
|
||||||
- L'accent est mis sur l'approche **algorithmique scientifique**, dite algorithmique
|
|
||||||
algébrique. L'algorithmique est un sous-domaine de l'algèbre et des
|
|
||||||
approches modulaires (arithmétique modulaire...)
|
|
||||||
|
|
||||||
- Le point de vue mathématique étant assez exigeant, aucun formalisme fort de
|
|
||||||
l'algorithmique mathématique ne sera présenté. Aucun symbole mathématique donc, et
|
|
||||||
seulement du pseudo-code.
|
|
||||||
L'approche mathématique forte utilisant le formalisme mathématique de
|
|
||||||
l'algorithmique algébrique est en général enseignée en France uniquement aux cours
|
|
||||||
des grandes écoles.
|
|
||||||
|
|
||||||
- L'algorithmique présentée ici est donc délibérément pseudo-scientifique mais en revanche
|
|
||||||
ouverte au multi-paradigme. En général l'évocation d'un algorithme en pseudo code est toujours
|
|
||||||
réducteur car limité au style de programmation le plus à la mode actuellement, c'est-à-dire le
|
|
||||||
style impératif. Nous présenterons un éventail des plus grands paradigmes de programmation
|
|
||||||
existants. Nous nous limiterons à la programmation impérative, fonctionnelle, modulaire,
|
|
||||||
générique et objet. Nous envisagerons les structures de données et les structures de contrôle
|
|
||||||
spécifiques à chacun des styles évoqués.
|
|
||||||
|
|
||||||
- Et parce qu'un honnête programmeur doit avoir une vue d'ensemble de l'état de son art,
|
|
||||||
nous évoquerons un panorama des différents langages existants -- historiques et contemporains --
|
|
||||||
en les comparants les uns aux autres.
|
|
||||||
|
|
||||||
- Durant tout le cours, nous souhaitons proposer une pédagogie par l'exemple, et nous nous
|
|
||||||
limiterons l'exposé à deux langages : principalement le Python3 pour la programmation
|
|
||||||
impérative, modulaire et objet, mais nous évoquerons aussi certains exemples en langage OCaml
|
|
||||||
à propos de la programmation fonctionnelle et générique.
|
|
||||||
|
|
||||||
|
|
||||||
- Introduire certains domaines et résultats importants de
|
|
||||||
l’informatique théorique
|
|
||||||
|
|
@ -59,60 +59,6 @@ mathématiques dans certains rôles immuables et ignorerait le fait que les
|
||||||
existants abstraits qui naissent de la structure d'un domaine plus concret
|
existants abstraits qui naissent de la structure d'un domaine plus concret
|
||||||
peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.
|
peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.
|
||||||
|
|
||||||
|
|
||||||
Types d'algorithmes
|
|
||||||
-------------------
|
|
||||||
|
|
||||||
La boucle
|
|
||||||
~~~~~~~~~~
|
|
||||||
|
|
||||||
Différents types de boucles (suites récurrentes, goto, boucle for...)
|
|
||||||
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{My algorithm}\label{euclid}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Procedure{MyProcedure}{}
|
|
||||||
\State $\textit{stringlen} \gets \text{length of }\textit{string}$
|
|
||||||
\State $i \gets \textit{patlen}$
|
|
||||||
\BState \emph{top}:
|
|
||||||
\If {$i > \textit{stringlen}$} \Return false
|
|
||||||
\EndIf
|
|
||||||
\State $j \gets \textit{patlen}$
|
|
||||||
\BState \emph{loop}:
|
|
||||||
\If {$\textit{string}(i) = \textit{path}(j)$}
|
|
||||||
\State $j \gets j-1$.
|
|
||||||
\State $i \gets i-1$.
|
|
||||||
\State \textbf{goto} \emph{loop}.
|
|
||||||
\State \textbf{close};
|
|
||||||
\EndIf
|
|
||||||
\State $i \gets
|
|
||||||
i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
|
|
||||||
\State \textbf{goto} \emph{top}.
|
|
||||||
\EndProcedure
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Euclid's algorithm}\label{euclid}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Procedure{Euclid}{$a,b$}\Comment{The g.c.d. of a and b}
|
|
||||||
\State $r\gets a\bmod b$
|
|
||||||
\While{$r\not=0$}\Comment{We have the answer if r is 0}
|
|
||||||
\State $a\gets b$
|
|
||||||
\State $b\gets r$
|
|
||||||
\State $r\gets a\bmod b$
|
|
||||||
\EndWhile\label{euclidendwhile}
|
|
||||||
\State \textbf{return} $b$\Comment{The gcd is b}
|
|
||||||
\EndProcedure
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
L'algorithme comme généralisation de la calculabilité
|
L'algorithme comme généralisation de la calculabilité
|
||||||
------------------------------------------------------
|
------------------------------------------------------
|
||||||
|
|
||||||
|
|
@ -121,6 +67,93 @@ impose d'élaborer un nouveau mode de description des méthodes de calcul (appel
|
||||||
susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
|
susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
|
||||||
d'implémenter les calculs sur un ordinateur.
|
d'implémenter les calculs sur un ordinateur.
|
||||||
|
|
||||||
|
Exemple d'algorithme
|
||||||
|
---------------------
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
\begin{algorithm}
|
||||||
|
\caption{L'alorithme de Bellman-Kalaba}
|
||||||
|
\begin{algorithmic}[1]
|
||||||
|
\Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
|
||||||
|
\ForAll {$v \in V(G)$}
|
||||||
|
\State $l(v) \leftarrow \infty$
|
||||||
|
\EndFor
|
||||||
|
\State $l(u) \leftarrow 0$
|
||||||
|
\Repeat
|
||||||
|
\For {$i \leftarrow 1, n$}
|
||||||
|
\State $min \leftarrow l(v_i)$
|
||||||
|
\For {$j \leftarrow 1, n$}
|
||||||
|
\If {$min > e(v_i, v_j) + l(v_j)$}
|
||||||
|
\State $min \leftarrow e(v_i, v_j) + l(v_j)$
|
||||||
|
\State $p(i) \leftarrow v_j$
|
||||||
|
\EndIf
|
||||||
|
\EndFor
|
||||||
|
\State $l(i) \leftarrow min$
|
||||||
|
\EndFor
|
||||||
|
\State $changed \leftarrow l \not= l’$
|
||||||
|
\State $l \leftarrow l$
|
||||||
|
\Until{$\neg changed$}
|
||||||
|
\EndProcedure
|
||||||
|
\Statex
|
||||||
|
\Procedure {FindPathBK}{$v$, $u$, $p$}
|
||||||
|
\If {$v = u$}
|
||||||
|
\State \textbf{Write} $v$
|
||||||
|
\Else
|
||||||
|
\State $w \leftarrow v$
|
||||||
|
\While {$w \not= u$}
|
||||||
|
\State \textbf{Write} $w$
|
||||||
|
\State $w \leftarrow p(w)$
|
||||||
|
\EndWhile
|
||||||
|
\EndIf
|
||||||
|
\EndProcedure
|
||||||
|
\end{algorithmic}
|
||||||
|
\end{algorithm}
|
||||||
|
|
||||||
|
Exemple d'algorithme avec son implémentation
|
||||||
|
---------------------------------------------
|
||||||
|
|
||||||
|
Soit l'algorithme de factorielle suivant,
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
\begin{algorithm}
|
||||||
|
\caption{Algorithme de la factorielle d'un nombre}\label{factorielle}
|
||||||
|
\begin{algorithmic}[1]
|
||||||
|
\Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
|
||||||
|
\BState \emph{parametre} : $n$ entier
|
||||||
|
\If{$n = 1$}
|
||||||
|
\BState \emph{Sortie} : 1
|
||||||
|
\Else
|
||||||
|
\BState \emph{Sortie} : $n * \Call{factorielle}{n-1}$ \Comment{On appelle la fonction dans l'algorithme lui-même}
|
||||||
|
\EndIf
|
||||||
|
\EndFunction
|
||||||
|
\end{algorithmic}
|
||||||
|
\end{algorithm}
|
||||||
|
|
||||||
|
et son implémentation en python :
|
||||||
|
|
||||||
|
.. literalinclude:: code/factorielle.py
|
||||||
|
:language: python
|
||||||
|
|
||||||
|
En voici une autre implémentation (en OCaml) :
|
||||||
|
|
||||||
|
.. literalinclude:: code/factorielle.ml
|
||||||
|
:language: ocaml
|
||||||
|
|
||||||
|
On remarque que le **pseudocode** (l'algorithme vague) est très proche de
|
||||||
|
la syntaxe du python :
|
||||||
|
|
||||||
|
.. function:: factorielle(n:int)
|
||||||
|
|
||||||
|
::
|
||||||
|
|
||||||
|
if n=1
|
||||||
|
return 1
|
||||||
|
else
|
||||||
|
return n * factorielle(n-1)
|
||||||
|
end if
|
||||||
|
|
||||||
Qualité d'un algorithme
|
Qualité d'un algorithme
|
||||||
-----------------------
|
-----------------------
|
||||||
|
|
||||||
|
|
@ -245,7 +278,5 @@ C'est utile pour pouvoir comparer des algorithmes.
|
||||||
|
|
||||||
complexité
|
complexité
|
||||||
|
|
||||||
estimer la complexité d'unalgorithme,
|
estimer la complexité d'un algorithme,
|
||||||
c'est-à-dire estimer le nombre de calculs qu'il utilise.
|
c'est-à-dire estimer le nombre de calculs qu'il utilise.
|
||||||
|
|
||||||
analyse de complexité
|
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
Les méthodes agile
|
La planification agile
|
||||||
===================
|
========================
|
||||||
|
|
||||||
Le mode itératif
|
Le mode itératif
|
||||||
-----------------
|
-----------------
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,122 @@
|
||||||
|
Première journée : Le langage Python
|
||||||
|
-------------------------------------
|
||||||
|
|
||||||
|
+------------------------------------------------------+------------------------------------------------------------------------+
|
||||||
|
| Contenus | Précisions et commentaires |
|
||||||
|
+======================================================+========================================================================+
|
||||||
|
| Recherche dans une liste, recherche du maximum dans | |
|
||||||
|
| une liste de nombres, calcul de la moyenne et de la | |
|
||||||
|
| variance. | |
|
||||||
|
+------------------------------------------------------+------------------------------------------------------------------------+
|
||||||
|
| Recherche d’un mot dans une chaîne de caractères. | On se limite ici à l’algorithme "naïf", en estimant sa complexité. |
|
||||||
|
+------------------------------------------------------+------------------------------------------------------------------------+
|
||||||
|
|
||||||
|
|
||||||
|
Séance 1 : Un apercu des possibles utilisations de Python
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
+ Objectif de la formation
|
||||||
|
|
||||||
|
+ les outils de travail avec Python
|
||||||
|
+ éditeur de texte + IPython (commandes intéractives + `%run`)
|
||||||
|
+ environnement de développement intégré (ex. Spyder)
|
||||||
|
+ Notebook IPython (proche de Maple/Mathematica)
|
||||||
|
|
||||||
|
|
||||||
|
Séance 2 : Éléments de base du langage
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
- structures de données
|
||||||
|
+ (),[],{}
|
||||||
|
+ listes en compréhension
|
||||||
|
|
||||||
|
- éléments du langage
|
||||||
|
boucles, conditions, fonctions, itérateur, map , enumerate
|
||||||
|
|
||||||
|
- Exemple en algorithmique de base
|
||||||
|
|
||||||
|
::
|
||||||
|
|
||||||
|
In [1]: def tri1():
|
||||||
|
|
||||||
|
%timeit l1.sort()
|
||||||
|
|
||||||
|
Séance 3 : Chaînes et fichiers
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
+ traitement des chaines de caractères
|
||||||
|
+ s.replace()
|
||||||
|
+ s1 + s2
|
||||||
|
+ un exemple de regexp simple
|
||||||
|
+ type de fichiers
|
||||||
|
+ mode d'accès
|
||||||
|
+ glob.glob
|
||||||
|
+ Sans doute ces points peuvent être intégrés dans la séance 2.
|
||||||
|
|
||||||
|
Séance 8 : Cas pratique de mise en oeuvre
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
+ écrire des instructions conditionnelles avec alternatives,
|
||||||
|
+ démontrer qu’une boucle se termine effectivement.
|
||||||
|
+ organisation modulaire des programmes
|
||||||
|
+ programmation structurée.
|
||||||
|
|
||||||
|
1. Récupérer des données physiques ouvertes sur le réseau (T°, ...)
|
||||||
|
|
||||||
|
|
||||||
|
+ **Variables** : notion de type et de valeur d’une variable, types simples.
|
||||||
|
Les types simples présentés sont les entiers, flottants, booléens et chaînes de caractères.
|
||||||
|
|
||||||
|
+ **Expressions et instructions simples** :
|
||||||
|
affectation, opérateurs usuels, distinction entre expression et instruction
|
||||||
|
Les expressions considérées sont à valeurs numériques, booléennes ou de type chaîne de caractères.
|
||||||
|
|
||||||
|
+ **Instructions conditionnelles**:
|
||||||
|
expressions booléennes et opérateurs logiques simples, structurer et comprendre plusieurs
|
||||||
|
instruction if. Variantes avec alternative (else).
|
||||||
|
|
||||||
|
Les étudiants devront être capables de niveaux d’alternatives implantées par des instructions conditionnelles imbriquées.
|
||||||
|
|
||||||
|
+ **Instructions itératives** :
|
||||||
|
boucles for, boucles conditionnelles while.
|
||||||
|
Les sorties de boucle (instruction break) peuvent être présentées et se
|
||||||
|
justifient uniquement lorsqu’elles contribuent à simplifier notablement la
|
||||||
|
programmation sans réelle perte de lisibilité des conditions d’arrêt.
|
||||||
|
|
||||||
|
+ **Fonctions** :
|
||||||
|
notion de fonction (au sens informatique), définition dans le langage utilisé, paramètres (ou arguments) et résultats, portée des variables.
|
||||||
|
On distingue les variables locales des variables globales et on décourage l’utilisation des variables globales autant que possible.
|
||||||
|
|
||||||
|
La récursivité sera présentée plus tard.
|
||||||
|
|
||||||
|
+ **Manipulation de quelques structures de données**:
|
||||||
|
chaînes de caractères (création, accès à un caractère, concaténation), listes (création, ajout
|
||||||
|
d’un élément, suppression d’un élément, accès à un élément, extraction d’une partie de liste), tableaux à une ou plusieurs dimensions.
|
||||||
|
|
||||||
|
On met en évidence le fait que certaines opérations d’apparence simple cachent
|
||||||
|
un important travail pour le processeur. On met à profit la structure de
|
||||||
|
tableau d’entiers à deux dimensions pour introduire la notion d’image
|
||||||
|
ponctuelle (« bitmap »). Les algorithmes de traitement d’image seront abordés
|
||||||
|
plus tard.
|
||||||
|
|
||||||
|
+ **Fichiers** :
|
||||||
|
notion de chemin d’accès, lecture et écriture de données numériques ou de type chaîne de caractères depuis ou vers un fichier.
|
||||||
|
|
||||||
|
On encourage l’utilisation de fichiers en tant que supports de données ou de résultats avant divers traitements, par exemple graphiques.
|
||||||
|
|
||||||
|
|
||||||
|
+ **Piles**
|
||||||
|
Algorithmes de manipulation : fonctions 'push' et 'pop'. On utilise des listes
|
||||||
|
(ou tableaux à 1 dimension) pour leur implantation.
|
||||||
|
|
||||||
|
+ **Récursivité**
|
||||||
|
|
||||||
|
On en présente les avantages et les inconvénients.
|
||||||
|
|
||||||
|
+ **Tris** d’un tableau à une dimension de valeurs
|
||||||
|
numériques : tri par insertion, tri rapide (ou 'quicksort'),
|
||||||
|
tri par fusion. Application à la
|
||||||
|
recherche de la médiane d’une liste de nombres.
|
||||||
|
|
||||||
|
On étudie et on compare ces algorithmes de tri du point de vue des complexités temporelles dans le meilleur et dans le
|
||||||
|
pire cas.
|
||||||
|
|
@ -4,6 +4,6 @@ Annexes
|
||||||
.. toctree::
|
.. toctree::
|
||||||
:maxdepth: 2
|
:maxdepth: 2
|
||||||
|
|
||||||
|
exercices
|
||||||
agile
|
agile
|
||||||
scrum
|
scrum
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,17 @@
|
||||||
|
let rec fact = function
|
||||||
|
|1 -> 1
|
||||||
|
| n -> n * fact (n-1) ;;
|
||||||
|
|
||||||
|
let print_fact n =
|
||||||
|
Printf.printf "factorielle %i = %i\n" n (fact n)
|
||||||
|
|
||||||
|
let main () =
|
||||||
|
begin
|
||||||
|
print_fact 5 ;
|
||||||
|
print_newline () ;
|
||||||
|
exit 0 ;
|
||||||
|
end
|
||||||
|
|
||||||
|
let _ = main ()
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -0,0 +1,12 @@
|
||||||
|
def factorielle(n):
|
||||||
|
if (n > 1):
|
||||||
|
r = n*factorielle(n-1)
|
||||||
|
else:
|
||||||
|
r = 1
|
||||||
|
return r
|
||||||
|
|
||||||
|
def print_fact(n):
|
||||||
|
print "factorielle {} = {}\n".format(5, factorielle(5))
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
print_fact(5)
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
Structures de contrôle
|
Les tructures de contrôle
|
||||||
======================
|
==========================
|
||||||
|
|
||||||
L'instruction de saut conditionnel
|
L'instruction de saut conditionnel
|
||||||
----------------------------------
|
----------------------------------
|
||||||
|
|
@ -16,11 +16,11 @@ L'instruction de saut conditionnel
|
||||||
\If {$i > \textit{stringlen}$} \Return false
|
\If {$i > \textit{stringlen}$} \Return false
|
||||||
\EndIf
|
\EndIf
|
||||||
\State $j \gets \textit{patlen}$
|
\State $j \gets \textit{patlen}$
|
||||||
\BState \emph{loop}: \Comment{C'est le label (l'étiquette)}
|
\BState \emph{loop}: \Comment{C'est le label (l'étiquette)} \label{etiquette}
|
||||||
\If {$\textit{string}(i) = \textit{path}(j)$}
|
\If {$\textit{string}(i) = \textit{path}(j)$}
|
||||||
\State $j \gets j-1$.
|
\State $j \gets j-1$.
|
||||||
\State $i \gets i-1$.
|
\State $i \gets i-1$.
|
||||||
\State \textbf{goto} \emph{loop}.
|
\State \textbf{goto} \emph{loop}. \label{goto}
|
||||||
\State \textbf{close};
|
\State \textbf{close};
|
||||||
\EndIf
|
\EndIf
|
||||||
\State $i \gets
|
\State $i \gets
|
||||||
|
|
@ -31,11 +31,16 @@ L'instruction de saut conditionnel
|
||||||
\end{algorithm}
|
\end{algorithm}
|
||||||
|
|
||||||
|
|
||||||
- **Ligne 7**, le bloc `loop` est aussi un **label** (une étiquette), c'est-à-dire
|
.. raw:: latex
|
||||||
une marque posée qu'il est possible de retrouver dans le programme.
|
|
||||||
- **Ligne 11**, l'instruction `goto` (aller à ) est un saut.
|
|
||||||
|
|
||||||
D'une manière générale::
|
Ligne \ref{etiquette}, le bloc `loop` est aussi un label (une étiquette),
|
||||||
|
c'est-à-dire une marque posée qu'il est possible de retrouver dans le programme. \\
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
Ligne \ref{goto}, l'instruction \texttt{goto} (aller à ) est le saut vers le label. \\
|
||||||
|
|
||||||
|
Description générique d'une instruction de saut::
|
||||||
|
|
||||||
Instruction 1
|
Instruction 1
|
||||||
Saut Label1
|
Saut Label1
|
||||||
|
|
@ -47,3 +52,88 @@ D'une manière générale::
|
||||||
.. important:: les sauts conditionnels sont à éviter, même s'ils sont implémentés
|
.. important:: les sauts conditionnels sont à éviter, même s'ils sont implémentés
|
||||||
dans le langage cible, car c'est le meilleur moyen d'aboutir à
|
dans le langage cible, car c'est le meilleur moyen d'aboutir à
|
||||||
du **code spaghetti**.
|
du **code spaghetti**.
|
||||||
|
|
||||||
|
L'instruction de test
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
\begin{algorithm}
|
||||||
|
\caption{Exemple d'instruction de test}
|
||||||
|
\begin{algorithmic}[1]
|
||||||
|
\BState \emph{entrée}: $quality\gets 0$ \Comment{C'est cette valeur qui sera testée}
|
||||||
|
\BState \emph{locale}: $a\gets ""$
|
||||||
|
\BState \emph{sortie}: $a$ \Comment{La sortie est la valeur de $a$}
|
||||||
|
\BState \emph{corps}:
|
||||||
|
\If{$quality\ge 9$}
|
||||||
|
\State $a\gets perfect$
|
||||||
|
\ElsIf{$quality\ge 7$}
|
||||||
|
\State $a\gets good$
|
||||||
|
\ElsIf{$quality\ge 5$}
|
||||||
|
\State $a\gets medium$
|
||||||
|
\ElsIf{$quality\ge 3$}
|
||||||
|
\State $a\gets bad$
|
||||||
|
\Else
|
||||||
|
\State $a\gets unusable$
|
||||||
|
\EndIf
|
||||||
|
\end{algorithmic}
|
||||||
|
\end{algorithm}
|
||||||
|
|
||||||
|
|
||||||
|
Les boucles
|
||||||
|
-----------
|
||||||
|
|
||||||
|
.. important:: Toutes les boucles concernent le paradigme de programmation impératif
|
||||||
|
et ne sont pas valides dans le paradigme de programmation fonctionnel
|
||||||
|
(puisque l'ordre d'évaluation importe)
|
||||||
|
|
||||||
|
Répéter ... jusqu'à
|
||||||
|
~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
\begin{algorithm}
|
||||||
|
\caption{Exemple de répéter ... jusqu'à}
|
||||||
|
\begin{algorithmic}[1]
|
||||||
|
\Require $i \gets 1$ \Comment{déclaration et initialisation de i}
|
||||||
|
\Statex
|
||||||
|
\Repeat \Comment{c'est le label de début du répéter}
|
||||||
|
\State $i \gets \textit{i+1}$
|
||||||
|
\Until{i == 100} \Comment{condition de fin de la boucle}
|
||||||
|
\end{algorithmic}
|
||||||
|
\end{algorithm}
|
||||||
|
|
||||||
|
La boucle **pour** (for)
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
\begin{algorithm}
|
||||||
|
\caption{Exemple de boucle for}
|
||||||
|
\begin{algorithmic}[1]
|
||||||
|
\Require $sum\gets 0$
|
||||||
|
\Statex
|
||||||
|
\For{$i\gets 1, n$}
|
||||||
|
\State $sum\gets sum+i$
|
||||||
|
\EndFor
|
||||||
|
\end{algorithmic}
|
||||||
|
\end{algorithm}
|
||||||
|
|
||||||
|
La boucle tant que (while)
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
\begin{algorithm}
|
||||||
|
\caption{Exemple de boucle while}
|
||||||
|
\begin{algorithmic}[1]
|
||||||
|
\Require $sum\gets 0$
|
||||||
|
\Statex
|
||||||
|
\State $i\gets 1$
|
||||||
|
\While{$i\le n$}
|
||||||
|
\State $sum\gets sum+i$
|
||||||
|
\State $i\gets i+1$
|
||||||
|
\EndWhile
|
||||||
|
\end{algorithmic}
|
||||||
|
\end{algorithm}
|
||||||
|
|
|
||||||
|
|
@ -1,6 +1,15 @@
|
||||||
Présentation de l'art de programmer
|
Présentation de l'art de programmer
|
||||||
====================================
|
====================================
|
||||||
|
|
||||||
|
Qu'est-ce que la programmation ?
|
||||||
|
--------------------------------
|
||||||
|
|
||||||
|
programmation
|
||||||
|
|
||||||
|
Description d’un calcul (traitement) dans
|
||||||
|
un langage compréhensible par la machine
|
||||||
|
(langage de programmation)
|
||||||
|
|
||||||
Le processus d'abstraction
|
Le processus d'abstraction
|
||||||
--------------------------
|
--------------------------
|
||||||
|
|
||||||
|
|
@ -99,4 +108,41 @@ plus efficace.
|
||||||
programmation indépendant de l'état de la mémoire de l'ordinateur,
|
programmation indépendant de l'état de la mémoire de l'ordinateur,
|
||||||
ils sont indépendant même du système d'exploitation.
|
ils sont indépendant même du système d'exploitation.
|
||||||
|
|
||||||
|
Qu'est-ce qu'une machine ?
|
||||||
|
---------------------------
|
||||||
|
|
||||||
|
Une machine, ce truc apparemment si complexe, est en fait
|
||||||
|
un assemblage de bric et de brac.
|
||||||
|
|
||||||
|
L'assemblage des connecteurs permet de simuler un additionneur,
|
||||||
|
en prenant en compte les propriétés de **reste euclidien**
|
||||||
|
de l'addition.
|
||||||
|
|
||||||
|
La structure électronique est composée de :
|
||||||
|
|
||||||
|
- un ordonnanceur.
|
||||||
|
- le stockage d'un **état**.
|
||||||
|
- une pile d'instruction
|
||||||
|
|
||||||
|
.. glossary::
|
||||||
|
|
||||||
|
adressage
|
||||||
|
|
||||||
|
Dès lors qu'on dispose de ces bases électronique au dessus du processeur,
|
||||||
|
un langage d'assemblage est possible, c'est le langage de calcul sur les registres.
|
||||||
|
|
||||||
|
registre
|
||||||
|
|
||||||
|
machines ont un espace mémoire et un espace de calcul (registres)
|
||||||
|
|
||||||
|
Un ordinateur, c'est très très stupide, mais ça permet de disposer de :
|
||||||
|
|
||||||
|
- une mémoire très grande et ordonnée,
|
||||||
|
- une capacité à effectuer inlassablement des tâches répétitives
|
||||||
|
- une grande rapidité de calcul
|
||||||
|
|
||||||
|
Apprendre à programmer, c'est-à-dire être capable de
|
||||||
|
contrôler la machine.
|
||||||
|
|
||||||
|
.. important:: Apprendre à programmer, c'est-à-dire apprendre à penser de manière structurée,
|
||||||
|
pour pouvoir accessoirement ensuite communiquer avec une machine.
|
||||||
|
|
|
||||||
|
|
@ -4,12 +4,12 @@ Introduction à l'algorithmique
|
||||||
.. toctree::
|
.. toctree::
|
||||||
:maxdepth: 2
|
:maxdepth: 2
|
||||||
|
|
||||||
|
presentation
|
||||||
fondement
|
fondement
|
||||||
langage
|
langage
|
||||||
modularite
|
|
||||||
algo
|
algo
|
||||||
programme
|
programme
|
||||||
|
fonctions
|
||||||
control
|
control
|
||||||
machine
|
modularite
|
||||||
annexes/index
|
annexes/index
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,6 +1,30 @@
|
||||||
Les langages de programmation
|
Les langages de programmation
|
||||||
=============================
|
=============================
|
||||||
|
|
||||||
|
langage
|
||||||
|
|
||||||
|
Un langage de
|
||||||
|
programmation
|
||||||
|
doit permettre d'écrire des
|
||||||
|
programmes de bonne qualité
|
||||||
|
|
||||||
|
Un programme doit être :
|
||||||
|
|
||||||
|
- correct
|
||||||
|
- robuste
|
||||||
|
- lisible, bien documenté
|
||||||
|
- facile à modifier, extensible
|
||||||
|
|
||||||
|
Un langage de programmation doit permettre :
|
||||||
|
|
||||||
|
- la programmation structurée
|
||||||
|
- la structuration avec les types
|
||||||
|
- proposer un mécanisme d’exceptions
|
||||||
|
- présenter des caractères de généricité, de polymorphisme et de surcharge
|
||||||
|
|
||||||
|
.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
|
||||||
|
Elles sont une nécessité
|
||||||
|
|
||||||
Approche historique et chronologique
|
Approche historique et chronologique
|
||||||
-------------------------------------
|
-------------------------------------
|
||||||
|
|
||||||
|
|
@ -287,3 +311,24 @@ en retour les langages. On reconnaît aujourd'hui :
|
||||||
- Le modèle de programmation système et réseau
|
- Le modèle de programmation système et réseau
|
||||||
- le modèle **Dev Ops** et les méthodes de développement virtualisés
|
- le modèle **Dev Ops** et les méthodes de développement virtualisés
|
||||||
- les langages présentant des **fonctionnalités agiles**
|
- les langages présentant des **fonctionnalités agiles**
|
||||||
|
|
||||||
|
Conclusion
|
||||||
|
-----------
|
||||||
|
|
||||||
|
Les langages de haut niveau sont caractérisés par
|
||||||
|
des concepts tels que :
|
||||||
|
|
||||||
|
- déclaration de valeurs, types, expressions, portée
|
||||||
|
- expressions, variables, instructions, structures de contrôle
|
||||||
|
- fonctions, procédures, fermetures
|
||||||
|
- encapsulation, modules, objets
|
||||||
|
|
||||||
|
=========== ============
|
||||||
|
Paradigmes Concepts
|
||||||
|
=========== ============
|
||||||
|
impératif variables, procédures, modules
|
||||||
|
objets classes, méthodes, héritage, surcharge
|
||||||
|
fonctionnel fonctions, fermetures, modules
|
||||||
|
logique prédicats, modules
|
||||||
|
concurrent tâche/processus, communication
|
||||||
|
=========== ============
|
||||||
|
|
|
||||||
|
|
@ -1,27 +0,0 @@
|
||||||
Machine abstraite
|
|
||||||
-----------------
|
|
||||||
|
|
||||||
une machine, ce truc apparemment si complexe, est en fait
|
|
||||||
un assemblage de bric et de brac.
|
|
||||||
|
|
||||||
l'assemblage des connecteurs permet de simuler un additionneur,
|
|
||||||
en prenant en compte les propriétés de **reste euclidien**
|
|
||||||
de l'addition.
|
|
||||||
|
|
||||||
la structure électronique est composée de :
|
|
||||||
|
|
||||||
- un ordonnanceur.
|
|
||||||
- le stockage d'un **état**.
|
|
||||||
- une pile d'instruction
|
|
||||||
|
|
||||||
dès lors qu'on dispose de ces bases électronique au dessus du processeur,
|
|
||||||
un langage d'assemblage est possible, c'est le langage de calcul sur les registres.
|
|
||||||
|
|
||||||
l'adressage mémoire
|
|
||||||
|
|
||||||
|
|
||||||
registre
|
|
||||||
|
|
||||||
machines ont un espace mémoire et un espace de calcul (registres)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,6 +1,12 @@
|
||||||
L'organisation d'un programme
|
Introduction à la modularité
|
||||||
=============================
|
=============================
|
||||||
|
|
||||||
|
|
||||||
|
Un langage de programmation doit permettre la programmation structurée.
|
||||||
|
|
||||||
|
.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
|
||||||
|
Elles sont une nécessité
|
||||||
|
|
||||||
Structuration d'un programme
|
Structuration d'un programme
|
||||||
-----------------------------
|
-----------------------------
|
||||||
|
|
||||||
|
|
@ -33,6 +39,9 @@ les données. La structuration d'un programme provient des relations entre
|
||||||
classes, en particulier l'héritage permet de définir une classe par extension
|
classes, en particulier l'héritage permet de définir une classe par extension
|
||||||
d'une autre.
|
d'une autre.
|
||||||
|
|
||||||
|
En programmation objet, un **programme** est une collection d’objets qui communiquent
|
||||||
|
entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
|
||||||
|
|
||||||
Comparaison entre les deux paradigmes
|
Comparaison entre les deux paradigmes
|
||||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
|
@ -143,3 +152,20 @@ Les Outils de linting (validation)
|
||||||
|
|
||||||
Exemple en python : pylint
|
Exemple en python : pylint
|
||||||
|
|
||||||
|
Les modules
|
||||||
|
-----------
|
||||||
|
|
||||||
|
Il s'agit de décomposer un grand programme en
|
||||||
|
morceaux (**modules**) connectés entre eux par des **interfaces** bien
|
||||||
|
définies.
|
||||||
|
|
||||||
|
Ces modules doivent être aussi indépendants que possible.
|
||||||
|
|
||||||
|
module
|
||||||
|
|
||||||
|
ensemble de ressources liées sémantiquement
|
||||||
|
|
||||||
|
interface
|
||||||
|
|
||||||
|
mode d’emploi du module, avec en plus un principe de masquage
|
||||||
|
des informations (partie publique, partie secrète)
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,52 @@
|
||||||
|
Avant propos
|
||||||
|
============
|
||||||
|
|
||||||
|
Introduction
|
||||||
|
~~~~~~~~~~~~
|
||||||
|
|
||||||
|
- L'accent est mis sur l'approche **algorithmique scientifique**, dite algorithmique
|
||||||
|
algébrique. L'algorithmique est un sous-domaine de l'algèbre et des
|
||||||
|
approches modulaires (arithmétique modulaire...)
|
||||||
|
|
||||||
|
- Le point de vue mathématique étant assez exigeant, **aucun formalisme fort** de
|
||||||
|
l'algorithmique mathématique ne sera présenté. Aucun symbole mathématique donc, et
|
||||||
|
seulement du pseudo-code.
|
||||||
|
L'approche mathématique forte utilisant le formalisme mathématique de
|
||||||
|
l'algorithmique algébrique est en général enseignée en France uniquement aux cours
|
||||||
|
des grandes écoles.
|
||||||
|
|
||||||
|
- L'algorithmique présentée ici est donc délibérément pseudo-scientifique mais en revanche
|
||||||
|
ouverte au **multi-paradigme**. En général l'évocation d'un algorithme en pseudo code est toujours
|
||||||
|
réducteur car limité au style de programmation le plus à la mode actuellement, c'est-à-dire le
|
||||||
|
**style impératif**. Nous présenterons un éventail des plus grands paradigmes de programmation
|
||||||
|
existants. Nous nous limiterons à la **programmation impérative, fonctionnelle, modulaire,
|
||||||
|
générique et objet**. Nous envisagerons les structures de données et les structures de contrôle
|
||||||
|
spécifiques à chacun des styles évoqués.
|
||||||
|
|
||||||
|
- Et parce qu'un honnête programmeur doit avoir une vue d'ensemble de **l'état de son art**,
|
||||||
|
nous évoquerons un panorama des différents langages existants -- historiques et contemporains --
|
||||||
|
en les comparants les uns aux autres.
|
||||||
|
|
||||||
|
- Durant tout le cours, nous souhaitons proposer une pédagogie par l'exemple, et nous nous
|
||||||
|
limiterons l'exposé à deux langages d'implémentation des algorithmes : le **Python** pour la programmation
|
||||||
|
impérative, modulaire et objet, et nous évoquerons aussi certains exemples en langage **OCaml**
|
||||||
|
à propos de la programmation fonctionnelle, modulaire et générique.
|
||||||
|
|
||||||
|
Objectifs de ce cours
|
||||||
|
~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
|
||||||
|
Il s'agit de :
|
||||||
|
|
||||||
|
- maîtriser et concevoir un algorithmes de base,
|
||||||
|
- choisir une représentations appropriée des données,
|
||||||
|
- décomposer en sous-problèmes et affinements successifs,
|
||||||
|
- organiser les modules ou fonctions.
|
||||||
|
|
||||||
|
Le développement raisonné d’algorithmes et leur implantation
|
||||||
|
permet d'acquérir les qualités suivantes :
|
||||||
|
|
||||||
|
+ Analyser et modéliser un problème,
|
||||||
|
+ Spécifier,
|
||||||
|
+ Exprimer, une problématique, une solution ou un algorithme,
|
||||||
|
+ Traduire un algorithme dans un langage de programmation,
|
||||||
|
+ Concevoir un algorithme répondant à un problème précisément posé.
|
||||||
|
|
@ -2,17 +2,107 @@ Définition d'un programme
|
||||||
==========================
|
==========================
|
||||||
|
|
||||||
Qu'est-ce qu'un programme ?
|
Qu'est-ce qu'un programme ?
|
||||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
----------------------------
|
||||||
|
|
||||||
- Un programme est une suite de phrases
|
- Un **programme** est une suite de **phrases** ;
|
||||||
- Une phrase est une **déclaration** ou une **expression**.
|
- Une **phrase** est une **déclaration** ou une **expression** (*statement* en anglais) ;
|
||||||
- Le signe "égal" est utilisé lorsqu'une une déclaration ou une expression sont équivalentes
|
|
||||||
|
|
||||||
Les déclarations
|
Production d'un programme :
|
||||||
|
|
||||||
|
1. on écrit le code source du programme ;
|
||||||
|
2. on demande au compilateur de le traduire en code machine : c'est la compilation du programme ;
|
||||||
|
3. on demande à la machine d'effectuer le code machine : c'est l'exécution du programme.
|
||||||
|
|
||||||
|
.. important::
|
||||||
|
|
||||||
|
L'introduction à la compilation et les différentes phases de la compilation
|
||||||
|
d'un programme sont des sujets qui ne seront pas traités dans ce cours.
|
||||||
|
|
||||||
|
Dans un programme de base, il y a deux fichiers :
|
||||||
|
|
||||||
|
1. un fichier contenant le code : c'est le source du programme.
|
||||||
|
2. un fichier contenant le code machine : c'est l'exécutable.
|
||||||
|
|
||||||
|
Que peut faire un programme lorsqu'il est exécuté ?
|
||||||
|
Le programme doit communiquer. S'il reste isolé, il ne pourra pas
|
||||||
|
produire quoi que ce soit. Voici les trois moyens de communication qu'a un
|
||||||
|
programme :
|
||||||
|
|
||||||
|
1. communiquer avec l'utilisateur,
|
||||||
|
2. communiquer avec des fichiers,
|
||||||
|
3. communiquer avec d'autres programmes.
|
||||||
|
|
||||||
|
Les expressions
|
||||||
----------------
|
----------------
|
||||||
|
|
||||||
Renseigner une variable
|
expression
|
||||||
|
|
||||||
|
Une expression est une valeur caculée du langage, une opération arithmétique
|
||||||
|
qui retourne une valeur (entier, texte, valeur logique...).
|
||||||
|
C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs**
|
||||||
|
|
||||||
|
Par exemple, la ligne suivante est une expression effectuant une addition::
|
||||||
|
|
||||||
|
5 + 6
|
||||||
|
|
||||||
|
Autres exemples d'expressions :
|
||||||
|
|
||||||
|
- 5 est une expression de type int
|
||||||
|
- 4.5 est une expression de type float
|
||||||
|
- 'c' est une expression de type char
|
||||||
|
- true est une expression de type bool
|
||||||
|
- print ('c') est une expression de type None
|
||||||
|
- raw_input est une expression de type string
|
||||||
|
|
||||||
|
Un autre exemple d'expression :
|
||||||
|
|
||||||
|
.. raw:: latex
|
||||||
|
|
||||||
|
\begin{algorithm}
|
||||||
|
\caption{Exemple d'expression}
|
||||||
|
\begin{algorithmic}[1]
|
||||||
|
\BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée}
|
||||||
|
\ForAll {$v \in V(G)$}
|
||||||
|
\State $l(v) \leftarrow \infty$
|
||||||
|
\EndFor
|
||||||
|
\State $l(u) \leftarrow 0$
|
||||||
|
\Repeat
|
||||||
|
\For {$i \leftarrow 1, n$}
|
||||||
|
\State $min \leftarrow l(v_i)$
|
||||||
|
\For {$j \leftarrow 1, n$}
|
||||||
|
\If {$min > e(v_i, v_j) + l(v_j)$}
|
||||||
|
\State $min \leftarrow e(v_i, v_j) + l(v_j)$
|
||||||
|
\State $p(i) \leftarrow v_j$
|
||||||
|
\EndIf
|
||||||
|
\EndFor
|
||||||
|
\State $l(i) \leftarrow min$
|
||||||
|
\EndFor
|
||||||
|
\State $changed \leftarrow l \not= l’$
|
||||||
|
\State $l \leftarrow l$
|
||||||
|
\Until{$\neg changed$}
|
||||||
|
\end{algorithmic}
|
||||||
|
\end{algorithm}
|
||||||
|
|
||||||
|
On voit qu'une expression peut-être complexe, dans tous les cas une valeur
|
||||||
|
est renvoyée.
|
||||||
|
|
||||||
|
Les déclarations
|
||||||
|
-----------------
|
||||||
|
|
||||||
|
Exemple de déclarations :
|
||||||
|
|
||||||
|
- `a = 1`
|
||||||
|
- `b = 'c'`
|
||||||
|
|
||||||
|
.. important:: Le signe égal est utilisé de deux manières
|
||||||
|
|
||||||
|
- lors d'une déclaration d'une expression
|
||||||
|
- lorsque deux expressions sont équivalentes
|
||||||
|
|
||||||
|
Suivant les langages, il y a deux symboles différents, ou alors
|
||||||
|
ils sont identiques.
|
||||||
|
|
||||||
|
Il s'agit de **renseigner** une valeur dans une expression nommée
|
||||||
|
|
||||||
- en javascript :
|
- en javascript :
|
||||||
|
|
||||||
|
|
@ -38,10 +128,13 @@ Renseigner une variable
|
||||||
|
|
||||||
let a = 1
|
let a = 1
|
||||||
|
|
||||||
(**let** : soit `a` la variable... )
|
Grâce au mécanisme d'inférence de type dans OCaml, le mot-clef **let**
|
||||||
|
signifie ici véritablement l'instanciation d'une valeur au sens
|
||||||
|
mathématique du terme : soit `a` l'entier tel que a soit égal à 1...
|
||||||
|
|
||||||
En OCaml comme dans tous les langages fonctionnels, toutes les "variables"
|
En OCaml comme dans tous les langages fonctionnels, tout ce que nous avons l'habitude
|
||||||
(les affectations) sont en fait des **constantes**.
|
d'appeler des "variables" à propos des affectations, sont en fait des **constantes**
|
||||||
|
au sens du paradigme impératif de la programmation.
|
||||||
|
|
||||||
.. important::
|
.. important::
|
||||||
|
|
||||||
|
|
@ -68,10 +161,9 @@ Exemples dans la langue française :
|
||||||
|
|
||||||
.. glossary::
|
.. glossary::
|
||||||
|
|
||||||
|
|
||||||
affectation
|
affectation
|
||||||
|
|
||||||
une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
|
Une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
|
||||||
|
|
||||||
Il s'agit d'une structure particulièrement courante en programmation impérative, et dispose souvent pour cette raison d'une notation courte et infixée,
|
Il s'agit d'une structure particulièrement courante en programmation impérative, et dispose souvent pour cette raison d'une notation courte et infixée,
|
||||||
comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
|
comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
|
||||||
|
|
@ -97,97 +189,61 @@ Voir aussi :
|
||||||
|
|
||||||
x1 = e1, x2 = e2, ... xn = en;
|
x1 = e1, x2 = e2, ... xn = en;
|
||||||
|
|
||||||
Les fonctions
|
Interaction avec l'utilisateur
|
||||||
-------------
|
------------------------------
|
||||||
|
|
||||||
Préliminaire : rappel de théorie de l'information
|
Il est possible de communiquer de la manière suivante avec un programme :
|
||||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
Théorie de l'information (Claude Shannon, 1949), théorie de la
|
- lire et écrire sur l'entrée/sortie standard
|
||||||
communication
|
- lire et écrire dans un fichier
|
||||||
|
- afficher du texte ou un nombre
|
||||||
|
- lire du texte ou un nombre
|
||||||
|
- manipuler les prompts
|
||||||
|
|
||||||
canal de transmission::
|
La REPL
|
||||||
|
--------
|
||||||
|
|
||||||
entrée -> récepteur -> émetteur -> sortie
|
.. glossary::
|
||||||
|
|
||||||
Description d'une procédure
|
REPL
|
||||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
- une procédure peut prendre des paramètres
|
Read Eval Print Loop : outil principal de communication avec un programme
|
||||||
- elle modifie l'état courant du système
|
ou avec un système. Exemples : la console python, le prompt OCaml.
|
||||||
|
|
||||||
- Déclaration des paramètes
|
interface
|
||||||
- Déclaration du corps
|
|
||||||
- Appel de la procédure
|
|
||||||
|
|
||||||
.. raw:: latex
|
outil de communication avec un programme.
|
||||||
|
|
||||||
\begin{algorithm}
|
- interface texte
|
||||||
\caption{Procédure de permutation de deux entiers}\label{permutation}
|
- interface graphique
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Procedure{permuter}{$a,b$}{}
|
|
||||||
\BState \emph{parametres}:
|
|
||||||
\State $a: \textit{int}$
|
|
||||||
\State $b: \textit{int}$
|
|
||||||
\BState \emph{locales}:
|
|
||||||
\State $z: \textit{int}$ \Comment{Une variable intermédiaire est nécessaire}
|
|
||||||
\BState \emph{corps}:
|
|
||||||
\State $z \gets a$
|
|
||||||
\State $a \gets b$
|
|
||||||
\State $b \gets z$
|
|
||||||
\EndProcedure
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
|
**Exemples de REPL**
|
||||||
|
|
||||||
effet de bord
|
Le prompt python::
|
||||||
|
|
||||||
toute modification de la mémoire ou modification d'un support externe
|
Python 2.7.12 (default, Nov 19 2016, 06:48:10)
|
||||||
|
[GCC 5.4.0 20160609] on linux2
|
||||||
|
Type "help", "copyright", "credits" or "license" for more information.
|
||||||
|
>>>
|
||||||
|
>>> dir()
|
||||||
|
['__builtins__', '__doc__', '__name__', readline', 'rlcompleter']
|
||||||
|
>>>
|
||||||
|
Le prompt ipython::
|
||||||
|
|
||||||
instruction
|
Python 2.7.12 (default, Nov 19 2016, 06:48:10)
|
||||||
|
Type "copyright", "credits" or "license" for more information.
|
||||||
|
|
||||||
commande ou phrase en mesure de modifier l'état du programme ou de la machine hôte
|
IPython 2.4.1 -- An enhanced Interactive Python.
|
||||||
(allocation mémoire, support externe, disque, écran...)
|
? -> Introduction and overview of IPython's features.
|
||||||
|
%quickref -> Quick reference.
|
||||||
|
help -> Python's own help system.
|
||||||
|
object? -> Details about 'object', use 'object??' for extra details.
|
||||||
|
|
||||||
Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.).
|
In [1]:
|
||||||
|
|
||||||
Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur
|
Le prompt OCaml (utop)::
|
||||||
Cela permet de structurer le texte source du programme et améliorer sa
|
|
||||||
lisibilité. Cela permet aussi d'appeler plusieurs fois, et à plusieurs endroit
|
|
||||||
dans le code, cette primitive.
|
|
||||||
|
|
||||||
Appel d'une procédure
|
Type #utop_help for help about using utop.
|
||||||
~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
(ex: pseudo-pascal)
|
─( 09:21:24 )─< command 0 >──
|
||||||
|
utop #
|
||||||
**déclaration de procédure**
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
procedure p(x1, ..., xn);
|
|
||||||
var v1,...,vm;
|
|
||||||
|
|
||||||
- les variables x1,...,xn sont appelées *paramètres formels* de p
|
|
||||||
- les variables v1,...,vm sont appelées *les variables locales* de p
|
|
||||||
|
|
||||||
**appel de procédure**
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
p(e1, ..., en)
|
|
||||||
|
|
||||||
les expressions e1,...,en sont appelées paramètres effectifs de p
|
|
||||||
|
|
||||||
SYRACUSE
|
|
||||||
|
|
||||||
Le niveau d’une déclaration (de variable ou de procédure) est le nombre
|
|
||||||
de procédures sous lesquelles elle est déclarée. Le programme principal
|
|
||||||
a le niveau 0.
|
|
||||||
|
|
||||||
Description d'une fonction
|
|
||||||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
Une fonction renvoie une valeur et ne modifie pas l'état courant du programme
|
|
||||||
en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
|
|
||||||
**toujours** quelque chose (même la valeur ``None`` qui n'est pas rien)
|
|
||||||
|
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
Introduction à l'algorithmique
|
|
||||||
================================
|
|
||||||
|
|
||||||
.. index pour générer de l'HTML
|
|
||||||
|
|
||||||
|
|
||||||
Contents:
|
|
||||||
|
|
||||||
.. toctree::
|
|
||||||
:maxdepth: 2
|
|
||||||
|
|
||||||
fondement
|
|
||||||
langage
|
|
||||||
modularite
|
|
||||||
machine
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Indices and tables
|
|
||||||
==================
|
|
||||||
|
|
||||||
* :ref:`genindex`
|
|
||||||
* :ref:`modindex`
|
|
||||||
* :ref:`search`
|
|
||||||
|
|
||||||
Loading…
Reference in New Issue