reorganisation du cours
This commit is contained in:
gwen
parent
9fb80c6b48
commit
26c756a914
@ -1,5 +1,5 @@
|
||||
Structures de contrôle
|
||||
======================
|
||||
Les tructures de contrôle
|
||||
==========================
|
||||
|
||||
L'instruction de saut conditionnel
|
||||
----------------------------------
|
||||
|
||||
@ -9,6 +9,7 @@ Introduction à l'algorithmique
|
||||
langage
|
||||
algo
|
||||
programme
|
||||
fonctions
|
||||
control
|
||||
modularite
|
||||
annexes/index
|
||||
|
||||
@ -2,7 +2,7 @@ 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** (*statement* en anglais) ;
|
||||
@ -33,12 +33,13 @@ programme :
|
||||
3. communiquer avec d'autres programmes.
|
||||
|
||||
Les expressions
|
||||
~~~~~~~~~~~~~~~
|
||||
----------------
|
||||
|
||||
expression
|
||||
|
||||
Une expression est une valeur caculée du langage, une opération arithmétique
|
||||
qui retourne une valeur du langage (entier, texte, valeur logique...)
|
||||
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::
|
||||
|
||||
@ -86,7 +87,7 @@ On voit qu'une expression peut-être complexe, dans tous les cas une valeur
|
||||
est renvoyée.
|
||||
|
||||
Les déclarations
|
||||
~~~~~~~~~~~~~~~~
|
||||
-----------------
|
||||
|
||||
Exemple de déclarations :
|
||||
|
||||
@ -103,7 +104,6 @@ Exemple de déclarations :
|
||||
|
||||
Il s'agit de **renseigner** une valeur dans une expression nommée
|
||||
|
||||
|
||||
- en javascript :
|
||||
|
||||
.. code-block:: javascript
|
||||
@ -217,156 +217,33 @@ La REPL
|
||||
- interface texte
|
||||
- interface graphique
|
||||
|
||||
**Exemples de REPL**
|
||||
|
||||
Le prompt python::
|
||||
|
||||
Les fonctions
|
||||
-------------
|
||||
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::
|
||||
|
||||
Préliminaire : rappel de théorie de l'information
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
Python 2.7.12 (default, Nov 19 2016, 06:48:10)
|
||||
Type "copyright", "credits" or "license" for more information.
|
||||
|
||||
Théorie de l'information (Claude Shannon, 1949), (ou théorie de la communication)
|
||||
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.
|
||||
|
||||
Canal de transmission::
|
||||
In [1]:
|
||||
|
||||
entrée -> récepteur -> émetteur -> sortie
|
||||
Le prompt OCaml (utop)::
|
||||
|
||||
Description d'une procédure
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
Type #utop_help for help about using utop.
|
||||
|
||||
En programmation impérative, un programme est une suite d’instructions qui font
|
||||
évoluer l’état mémoire, le résultat est dans l’état final de la mémoire.
|
||||
|
||||
- une procédure peut prendre des paramètres
|
||||
- elle modifie l'état courant du système
|
||||
|
||||
- Déclaration des paramètes
|
||||
- Déclaration du corps
|
||||
- Appel de la procédure
|
||||
|
||||
.. raw:: latex
|
||||
|
||||
\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
|
||||
\State \Call{permuter}{10, 12} \Comment{appel de la procédure}
|
||||
\end{algorithmic}
|
||||
\end{algorithm}
|
||||
|
||||
effet de bord
|
||||
|
||||
toute modification de la mémoire ou modification d'un support externe
|
||||
|
||||
instruction
|
||||
|
||||
commande ou phrase en mesure de modifier l'état du programme ou de la machine hôte
|
||||
(allocation mémoire, support externe, disque, écran...)
|
||||
|
||||
Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.).
|
||||
|
||||
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.
|
||||
|
||||
Appel d'une procédure
|
||||
~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
(ex: pseudo-pascal)
|
||||
|
||||
**déclaration de procédure**
|
||||
|
||||
.. raw:: latex
|
||||
|
||||
\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}$ \Comment{paramètres formels de la procédure}
|
||||
\State $b: \textit{int}$
|
||||
\BState \emph{locales}:
|
||||
\State $z: \textit{int}$ \Comment{les variables locales de la procédure}
|
||||
\BState \emph{corps}:
|
||||
\State ... \Comment{Le corps de la procedure}
|
||||
\EndProcedure
|
||||
\State \Call{permuter}{10, 12} \Comment{l'appel de la procédure}
|
||||
\end{algorithmic}
|
||||
\end{algorithm}
|
||||
|
||||
|
||||
- les variables x1,...,xn sont appelées *paramètres formels* de p
|
||||
- les variables v1,...,vm sont appelées *les variables locales* de p
|
||||
|
||||
les valeurs effectivement passées en paramètres, ici `10, 12`
|
||||
sont appelées **paramètres effectifs** de p
|
||||
|
||||
signature
|
||||
|
||||
C'est l'ensemble paramètre formel + resultat de l'appel
|
||||
|
||||
fermeture
|
||||
|
||||
L'ensemble procédure + variables locales + signature + parametres effectifs
|
||||
est appelé une **fermeture**. C'est la procédure + son contexte qui permet
|
||||
de l'instancier dans un programme.
|
||||
|
||||
niveau
|
||||
|
||||
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)
|
||||
|
||||
- une procédure peut prendre des paramètres
|
||||
- elle modifie l'état courant du système
|
||||
|
||||
- Déclaration des paramètes
|
||||
- Déclaration du corps
|
||||
- Appel de la fonction
|
||||
|
||||
En programmation fonctionnelle, programme est un ensemble de définitions de fonctions,
|
||||
un résultat est l'application d’une fonction à une structure de données effective.
|
||||
|
||||
- composant de base : la fonction
|
||||
- opération de base : l’application
|
||||
|
||||
.. raw:: latex
|
||||
|
||||
\begin{algorithm}
|
||||
\caption{Exemple de fonction}\label{fonction}
|
||||
\begin{algorithmic}[1]
|
||||
\Function{permuter}{$a,b$}{} \Comment{définition de la fonction}
|
||||
\BState \emph{parametres}: \Comment{déclaration (noms, types) des paramètres formels}
|
||||
\State $a: \textit{int}$
|
||||
\State $b: \textit{int}$
|
||||
\BState \emph{locales}: \Comment{déclaration (noms, types) des valeurs locales}
|
||||
\State $z: \textit{int}$
|
||||
\BState \emph{corps}:
|
||||
\State $z \gets a$
|
||||
\State $a \gets b$
|
||||
\State $b \gets z$
|
||||
\BState \emph{return}: \Comment{La valeur, le résulat renvoyé par la fonction}
|
||||
\EndFunction
|
||||
\State \Call{permuter}{10, 12} \Comment{appel de la fonction}
|
||||
\BState \emph{result}:
|
||||
\State (12, 10) \Comment{Le résultat effectif de la fonction après appel}
|
||||
\end{algorithmic}
|
||||
\end{algorithm}
|
||||
─( 09:21:24 )─< command 0 >──
|
||||
utop #
|
||||
|
||||
Loading…
Reference in New Issue
Block a user