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
|
||||
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é
|
||||
------------------------------------------------------
|
||||
|
||||
|
|
@ -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é
|
||||
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
|
||||
-----------------------
|
||||
|
||||
|
|
@ -245,7 +278,5 @@ C'est utile pour pouvoir comparer des algorithmes.
|
|||
|
||||
complexité
|
||||
|
||||
estimer la complexité d'unalgorithme,
|
||||
estimer la complexité d'un algorithme,
|
||||
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
|
||||
-----------------
|
||||
|
|
|
|||
|
|
@ -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::
|
||||
:maxdepth: 2
|
||||
|
||||
exercices
|
||||
agile
|
||||
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
|
||||
----------------------------------
|
||||
|
|
@ -16,11 +16,11 @@ L'instruction de saut conditionnel
|
|||
\If {$i > \textit{stringlen}$} \Return false
|
||||
\EndIf
|
||||
\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)$}
|
||||
\State $j \gets j-1$.
|
||||
\State $i \gets i-1$.
|
||||
\State \textbf{goto} \emph{loop}.
|
||||
\State \textbf{goto} \emph{loop}. \label{goto}
|
||||
\State \textbf{close};
|
||||
\EndIf
|
||||
\State $i \gets
|
||||
|
|
@ -31,11 +31,16 @@ L'instruction de saut conditionnel
|
|||
\end{algorithm}
|
||||
|
||||
|
||||
- **Ligne 7**, 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.
|
||||
- **Ligne 11**, l'instruction `goto` (aller à ) est un saut.
|
||||
.. raw:: latex
|
||||
|
||||
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
|
||||
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
|
||||
dans le langage cible, car c'est le meilleur moyen d'aboutir à
|
||||
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
|
||||
====================================
|
||||
|
||||
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
|
||||
--------------------------
|
||||
|
||||
|
|
@ -99,4 +108,41 @@ plus efficace.
|
|||
programmation indépendant de l'état de la mémoire de l'ordinateur,
|
||||
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::
|
||||
:maxdepth: 2
|
||||
|
||||
presentation
|
||||
fondement
|
||||
langage
|
||||
modularite
|
||||
algo
|
||||
programme
|
||||
fonctions
|
||||
control
|
||||
machine
|
||||
modularite
|
||||
annexes/index
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,30 @@
|
|||
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
|
||||
-------------------------------------
|
||||
|
||||
|
|
@ -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 **Dev Ops** et les méthodes de développement virtualisés
|
||||
- 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
|
||||
-----------------------------
|
||||
|
||||
|
|
@ -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
|
||||
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
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
|
|
@ -143,3 +152,20 @@ Les Outils de linting (validation)
|
|||
|
||||
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 ?
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
----------------------------
|
||||
|
||||
- Un programme est une suite de phrases
|
||||
- Une phrase est une **déclaration** ou une **expression**.
|
||||
- Le signe "égal" est utilisé lorsqu'une une déclaration ou une expression sont équivalentes
|
||||
- Un **programme** est une suite de **phrases** ;
|
||||
- Une **phrase** est une **déclaration** ou une **expression** (*statement* en anglais) ;
|
||||
|
||||
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 :
|
||||
|
||||
|
|
@ -38,10 +128,13 @@ Renseigner une variable
|
|||
|
||||
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"
|
||||
(les affectations) sont en fait des **constantes**.
|
||||
En OCaml comme dans tous les langages fonctionnels, tout ce que nous avons l'habitude
|
||||
d'appeler des "variables" à propos des affectations, sont en fait des **constantes**
|
||||
au sens du paradigme impératif de la programmation.
|
||||
|
||||
.. important::
|
||||
|
||||
|
|
@ -68,10 +161,9 @@ Exemples dans la langue française :
|
|||
|
||||
.. glossary::
|
||||
|
||||
|
||||
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,
|
||||
comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
|
||||
|
|
@ -97,97 +189,61 @@ Voir aussi :
|
|||
|
||||
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
|
||||
communication
|
||||
- lire et écrire sur l'entrée/sortie standard
|
||||
- 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
|
||||
- elle modifie l'état courant du système
|
||||
Read Eval Print Loop : outil principal de communication avec un programme
|
||||
ou avec un système. Exemples : la console python, le prompt OCaml.
|
||||
|
||||
- Déclaration des paramètes
|
||||
- Déclaration du corps
|
||||
- Appel de la procédure
|
||||
interface
|
||||
|
||||
.. raw:: latex
|
||||
outil de communication avec un programme.
|
||||
|
||||
\begin{algorithm}
|
||||
\caption{Procédure de permutation de deux entiers}\label{permutation}
|
||||
\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}
|
||||
- interface texte
|
||||
- interface graphique
|
||||
|
||||
**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
|
||||
(allocation mémoire, support externe, disque, écran...)
|
||||
IPython 2.4.1 -- An enhanced Interactive Python.
|
||||
? -> 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
|
||||
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.
|
||||
Le prompt OCaml (utop)::
|
||||
|
||||
Appel d'une procédure
|
||||
~~~~~~~~~~~~~~~~~~~~~
|
||||
Type #utop_help for help about using utop.
|
||||
|
||||
(ex: pseudo-pascal)
|
||||
|
||||
**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)
|
||||
─( 09:21:24 )─< command 0 >──
|
||||
utop #
|
||||
|
|
|
|||
|
|
@ -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