Merge branch 'master' of ssh://forge.cadoles.com:4242/cadoles/formations

This commit is contained in:
Emmanuel Garette 2017-04-11 11:42:53 +02:00
commit b37051c78d
16 changed files with 697 additions and 289 deletions

View File

@ -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
linformatique théorique

View File

@ -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
-----------------------
@ -247,5 +280,3 @@ complexité
estimer la complexité d'un algorithme,
c'est-à-dire estimer le nombre de calculs qu'il utilise.
analyse de complexité

View File

@ -1,5 +1,5 @@
Les méthodes agile
===================
La planification agile
========================
Le mode itératif
-----------------

View File

@ -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 dun mot dans une chaîne de caractères. | On se limite ici à lalgorithme "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 quune 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 dune 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 dalternatives 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 lorsquelles contribuent à simplifier notablement la
programmation sans réelle perte de lisibilité des conditions darrê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 lutilisation 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
dun élément, suppression dun élément, accès à un élément, extraction dune partie de liste), tableaux à une ou plusieurs dimensions.
On met en évidence le fait que certaines opérations dapparence simple cachent
un important travail pour le processeur. On met à profit la structure de
tableau dentiers à deux dimensions pour introduire la notion dimage
ponctuelle (« bitmap »). Les algorithmes de traitement dimage seront abordés
plus tard.
+ **Fichiers** :
notion de chemin daccès, lecture et écriture de données numériques ou de type chaîne de caractères depuis ou vers un fichier.
On encourage lutilisation 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** dun tableau à une dimension de valeurs
numériques : tri par insertion, tri rapide (ou 'quicksort'),
tri par fusion. Application à la
recherche de la médiane dune 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.

View File

@ -4,6 +4,6 @@ Annexes
.. toctree::
:maxdepth: 2
exercices
agile
scrum

View File

@ -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 ()

View File

@ -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)

View File

@ -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}

View File

@ -1,6 +1,15 @@
Présentation de l'art de programmer
====================================
Qu'est-ce que la programmation ?
--------------------------------
programmation
Description dun 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.

View File

@ -4,12 +4,12 @@ Introduction à l'algorithmique
.. toctree::
:maxdepth: 2
presentation
fondement
langage
modularite
algo
programme
fonctions
control
machine
modularite
annexes/index

View File

@ -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 dexceptions
- 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
=========== ============

View File

@ -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)

View File

@ -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 dobjets 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 demploi du module, avec en plus un principe de masquage
des informations (partie publique, partie secrète)

View File

@ -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é dalgorithmes 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é.

View File

@ -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 dune 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 #

View File

@ -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`