diff --git "a/01-Repr\303\251sentation_information.pdf" "b/01-Repr\303\251sentation_information.pdf"
new file mode 100644
index 0000000000000000000000000000000000000000..f4d55836b99aaf1ff3fc4da17b56363fe68632a3
Binary files /dev/null and "b/01-Repr\303\251sentation_information.pdf" differ
diff --git "a/01-Repr\303\251sentation_information.tex" "b/01-Repr\303\251sentation_information.tex"
new file mode 100644
index 0000000000000000000000000000000000000000..9491f849d4e3d7a9549eb7c950232964d745210b
--- /dev/null
+++ "b/01-Repr\303\251sentation_information.tex"
@@ -0,0 +1,627 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+\chapter{Représentation numérique de l’information}
+
+
+\section{Introduction}
+
+Lorsque nous utilisons un logiciel, chaque action que nous effectuons avec la souris ou le clavier par exemple est traduite en langage informatique puis exécutée par l’ordinateur.
+
+{\it “Transmettre des informations sous forme numérique suppose entre autres d'optimiser la taille des messages transmis pour éviter de surcharger les canaux de transmission, d'être capable de rectifier des erreurs apparues en cours de transmission, de crypter les contenus et d'authentifier les émissaires et les destinataires…” }(Dunod, 2006)
+
+Les images, le son, le texte et les vidéos sont des informations qu’un ordinateur peut traiter. Un ordinateur est composé de circuits électroniques qui fonctionnent à l'électricité. L’information est représentée physiquement par un\textbf{ signal électrique ou magnétique qui, au-delà d'un certain seuil, correspond à la valeur 1 si non par 0}. Par conséquent, l’information est toujours sous forme d’un ensemble de nombres écrit en \textbf{base 2 par exemple 011001.}
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/electric_binary}
+\end{center}
+\end{figure}
+
+En 1939, Claude Shannon a été le premier à faire un parallèle entre l'algèbre booléenne (une algèbre binaire, n'acceptant que vrai et faux comme valeurs, et trois fonctions logiques “Et (*), Ou(+), Non(-)”) et le fonctionnement des circuits électriques. Le vrai/faux se transforme en 1 : le courant passe, 0 : il ne passe pas. C'est Shannon qui popularise le terme de bit:
+
+\begin{defi}
+Le terme {\bf bit} (b minuscule dans les notations) signifie {\it binary digit }, c'est-à-dire 0 ou 1 en numérotation binaire. Il s'agit de la plus petite unité d'information manipulable par une machine numérique.
+
+
+L'{\bf octet} (en anglais {\bf byte} ou B majuscule dans les notations) est une unité d'information composée de 8 bits. Il permet par exemple de stocker un caractère comme une lettre ou un chiffre.
+\end{defi}
+
+D'autres termes sont aussi utilisés pour définir certaines longueurs de nombre:
+\begin{itemize}
+\item Une unité d'information composée de 16 bits est généralement appelée {\bf mot} (en anglais {\bf word}).
+
+\item Une unité d'information de 32 bits de longueur est appelée {\bf mot double} (en anglais {\bf double word}, d'où l'appellation dword).
+\end{itemize}
+
+Jusqu'en 1998; 1024 octets valaient 1 kilooctet. Et depuis les nouvelles unités standardisées par l'organisme international IEC sont les suivantes :
+\begin{itemize}
+\item Un kilooctet (ko) = $10^3$ octets
+\item Un mégaoctet (Mo) = $10^6$ octets
+\item Un gigaoctet (Go) = $10^9$ octets
+\item Un téraoctet (To) = $10^{12}$ octets
+\item Un pétaoctet (Po) = $10^{15}$ octets
+\item Un exaoctet (Eo) = $10^{18}$ octets
+\item Un zettaoctet (Zo) = $10^{21}$ octets
+\item Un yottaoctet (Yo) = $10^{24}$ octets
+\end{itemize}
+
+\begin{remarque}
+Un mégaoctet devrait en principe valoir 1000 x 1000 octets, c'est-à-dire 1'000'000 d'octets, mais il vaut 1024 x 1024 octets en informatique, c'est-à-dire 1'048'576 octets... ce qui correspond à une différence de 4.63 \% !
+\end{remarque}
+
+\section{Les bases décimales, binaires et hexadécimales}
+
+
+\subsection{La base décimale}
+
+Le système décimal (base 10) est celui que nous utilisons dans la vie quotidienne parce que nous avons commencé à compter avec nos doigts. Il comporte 10 symboles de 0 à 9. C'est un système positionnel, c'est-à-dire que l'endroit où se trouve le symbole définit sa valeur.
+
+Par exemple: $(9'875)_{(10)}=9 \cdot 10^3 + 8 \cdot 10^2 + 7\cdot 10^1 + 5 \cdot 10^0$
+
+10 représente la base et les puissances de 0 à 3 le rang de chaque chiffre. Quelle que soit la base, le chiffre de droite est celui des unités. Celui de gauche est celui qui a le poids le plus élevé.
+
+\subsection{Binaire}
+
+Dans les domaines de l'automatisme, de l'électronique et de l'informatique, nous utilisons la base 2. Tous les nombres s'écrivent avec deux chiffres uniquement, 0 et 1. Car l'algèbre booléenne est à la base de l'électronique numérique. Par exemple, un interrupteur est ouvert ou fermé, une diode électroluminescente (ou LED en anglais) est allumée ou éteinte, une tension est présente ou absente, un champ magnétique est orienté Nord-Sud ou Sud-Nord.
+
+Le chiffre binaire, qui peut prendre ces deux états, est nommé {\bf Bit} (Binary digit). Les règles sont les mêmes que pour le décimal.
+
+Par exemple, $1101_{(2)}=1 \cdot 2^3 + 1 \cdot 2^2 + 0 \cdot 2^1 + 1\cdot 2^0=13_{(10)}$
+
+\subsubsection{Conversion binaire décimale}
+
+Une autre façon d'obtenir le nombre en base 10, connaissant son écriture en base 2, est d'établir la valeur de chaque chiffre du nombre: celui le plus à droite représente 1, le deuxième représente 2, le troisième représente $2^2=4$, le quatrième représente $2^3=8$, etc. comme dans la grille ci-dessous :
+
+\begin{center}
+\begin{tikzpicture}
+ \draw (-1,1) rectangle (0,0) rectangle (1,1) rectangle (2,0) rectangle (3,1) rectangle (4,0) rectangle (5,1) rectangle (6,0);
+ \draw (5.5,0.5) node {$1$};
+ \draw (4.5,0.5) node {$2$};
+ \draw (3.5,0.5) node {$4$};
+ \draw (2.5,0.5) node {$8$};
+ \draw (1.5,0.5) node {$16$};
+ \draw (0.5,0.5) node {$32$};
+ \draw (-.5,0.5) node {$64$};
+
+\end{tikzpicture}
+\end{center}
+
+Par exemple si nous voulons connaitre la valeur décimale du nombre 10110, nous établissons d'abord une grille avec les différentes puissances de 2; ensuite, nous plaçons le nombre en binaire sous cette grille en mettant bien le chiffre des unités sous le carré le plus à droite et nous barrons les cases dont le chiffre associé est 0:
+
+\begin{center}
+\begin{tikzpicture}
+ \draw (-1,1) rectangle (0,0) rectangle (1,1) rectangle (2,0) rectangle (3,1) rectangle (4,0) rectangle (5,1) rectangle (6,0);
+ \draw (5.5,0.5) node {$1$};
+ \draw (4.5,0.5) node {$2$};
+ \draw (3.5,0.5) node {$4$};
+ \draw (2.5,0.5) node {$8$};
+ \draw (1.5,0.5) node {$16$};
+ \draw (0.5,0.5) node {$32$};
+ \draw (-.5,0.5) node {$64$};
+
+ \draw (5.5,-0.5) node {$0$};
+ \draw (4.5,-0.5) node {$1$};
+ \draw (3.5,-0.5) node {$1$};
+ \draw (2.5,-0.5) node {$0$};
+ \draw (1.5,-0.5) node {$1$};
+ \draw (0.5,-0.5) node {$ $};
+ \draw (-.5,-0.5) node {$ $};
+
+% \draw (-1,0) -- (0,1)
+% (0,0) -- (1,1)
+% (2,0) -- (3,1)
+% (5,0) -- (6,1);
+ \draw (-1,-1) rectangle (0,0) rectangle (1,-1) rectangle (2,0) rectangle (3,-1) rectangle (4,0) rectangle (5,-1) rectangle (6,0);
+
+\end{tikzpicture}
+\end{center}
+
+Il ne reste plus qu'à additionner les nombres qui restent: $16 + 4 + 2=22$
+
+\begin{exercice}
+\'Ecrire en base 10 les nombres suivants:
+\begin{multicols}{2}
+\begin{enumerate}
+\item $101_{(2)}$
+\item $10 000_{(2)}$
+\item $1111_{(2)}$
+\item $10101_{(2)}$
+\item $10_{(2)}$
+\item $111 000_{(2)}$
+
+\end{enumerate}
+\end{multicols}
+
+Vous pouvez utiliser le tableau ci-dessous :
+
+\begin{center}
+\begin{tikzpicture}
+ \draw (-3,1) rectangle (-2,0) rectangle (-1,1) rectangle (0,0) rectangle (1,1) rectangle (2,0) rectangle (3,1) rectangle (4,0) rectangle (5,1) rectangle (6,0);
+ \draw (5.5,0.5) node {$1$};
+ \draw (4.5,0.5) node {$2$};
+ \draw (3.5,0.5) node {$4$};
+ \draw (2.5,0.5) node {$8$};
+ \draw (1.5,0.5) node {$16$};
+ \draw (0.5,0.5) node {$32$};
+ \draw (-.5,0.5) node {$64$};
+ \draw (-3,-4) rectangle (-2,0) rectangle (-1,-4) rectangle (0,0) rectangle (1,-4) rectangle (2,0) rectangle (3,-4) rectangle (4,0) rectangle (5,-4) rectangle (6,0);
+
+\end{tikzpicture}
+\end{center}
+
+\end{exercice}
+
+\subsubsection{Conversion décimale binaire}
+
+Pour trouver l'écriture binaire d'un nombre écrit en base 10, il existe principalement deux méthodes.
+
+
+\;
+
+La première méthode consiste à décomposer le nombre en somme de puissance de 2 et à utiliser la grille précédente.
+
+Plus concrètement, si nous voulons écrite 99 en binaire. La plus grande puissance de 2 que nous pouvons prendre dans 99 est 64 (128, la suivante, est trop grande). Il reste ensuite:
+
+99-\textbf{64}= 35. Dans 35 on peut mettre 32, et il restera
+
+35-\textbf{33}= 3. Dans 3 on ne peut ni mettre 16, ni mettre 8, ni mettre 4. On peut mettre 2 :
+
+3-\textbf{2} = 1 Il reste 1. Dans 1 on peut mettre 1 :
+
+1-\textbf{1} = 0
+
+Cela signifie que 99=64+32+2+1. Sur notre grille cela donne:
+
+\begin{center}
+\begin{tikzpicture}
+ \draw (-1,1) rectangle (0,0) rectangle (1,1) rectangle (2,0) rectangle (3,1) rectangle (4,0) rectangle (5,1) rectangle (6,0);
+ \draw (5.5,0.5) node {$1$};
+ \draw (4.5,0.5) node {$2$};
+ \draw (3.5,0.5) node {$4$};
+ \draw (2.5,0.5) node {$8$};
+ \draw (1.5,0.5) node {$16$};
+ \draw (0.5,0.5) node {$32$};
+ \draw (-.5,0.5) node {$64$};
+
+ \draw (5.5,-0.5) node {$1$};
+ \draw (4.5,-0.5) node {$1$};
+ \draw (3.5,-0.5) node {$0$};
+ \draw (2.5,-0.5) node {$0$};
+ \draw (1.5,-0.5) node {$0$};
+ \draw (0.5,-0.5) node {$1$};
+ \draw (-.5,-0.5) node {$1$};
+
+% \draw (1,0) -- +(1,1)
+% (2,0) -- +(1,1)
+% (3,0) -- +(1,1)
+% ;
+
+\end{tikzpicture}
+\end{center}
+
+Donc $99_{(10)}=1100011_{(2)}$.
+
+
+\;
+
+La deuxième méthode consiste effectuer des divisions successives par 2. Le nombre en binaire se lira à l'aide des restes des différentes divisions:
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/divisionbinaire}
+\end{center}
+\end{figure}
+
+Ainsi, $79_{(10)}=1001111_{(2)}$
+
+\begin{exercice}
+Les nombres suivants sont écrits en base 10. Donner leur écriture en base 2:
+\begin{multicols}{2}
+\begin{enumerate}
+\item 75
+\item 12
+\item 27
+\item 153
+\item 100
+\item 200
+\item 1000
+\item 2000
+\end{enumerate}
+\end{multicols}
+\end{exercice}
+
+\subsection{*La base hexadécimale}
+
+C'est le code utilisé dans la programmation de certains automates et microprocesseurs. Il est composé de : 10 chiffres de 0 à 9, et 6 lettres de A à F. Les adresses MAC (adresses uniques associées à chaque carte réseau dans le monde) sont aussi écrites en base hexadécimale.
+
+La manipulation des nombres écrits en binaire est difficile pour l'être humain et la conversion en décimal n'est pas simple. C'est pourquoi nous utilisons de préférence le système hexadécimal (base 16).
+
+Le tableau ci-dessous montre la représentation des nombres de 0 à 15 dans les bases 10, 2 et 16.
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/tableaubase}
+\end{center}
+\end{figure}
+
+
+Par exemple, $B4F_{(16)}= B \cdot 16^2 + 4 \cdot 16^1 + F\cdot 16^1= 11 \cdot 16^2 + 4 \cdot 16^1 + 15\cdot 16^0=2 895_{(16)}$
+
+\subsubsection{Conversion en binaire}
+
+Pour convertir un nombre binaire en hexadécimal il suffit de remarquer que chaque groupe de 4 bits représente un chiffre en hexadécimal:
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/hexadecimal}
+\end{center}
+\end{figure}
+
+\begin{exercice}
+Écrire les nombres suivants en base hexadécimale:
+\begin{multicols}{2}
+\begin{enumerate}
+\item $10010010110_{(2)}$
+\item $111110_{(2)}$
+\item $1000110101110101_{(2)}$
+\item $11110000000011_{(2)}$
+\end{enumerate}
+\end{multicols}
+\end{exercice}
+
+\subsubsection{Conversion en décimal}
+
+La méthode par division (par 16) s'applique comme en binaire (par 2).
+
+\begin{exercice}
+Écrire les nombres suivants en hexadécimal:
+\begin{multicols}{2}
+\begin{enumerate}
+\item 92
+\item 256
+\item 500
+\item 1023
+\end{enumerate}
+\end{multicols}
+\end{exercice}
+
+
+
+\subsection{Opération sur les nombres en binaires}
+
+Tout comme pour l'addition en colonne, pour additionner deux nombres écrits en binaires il faut les additionner bit à bit.
+
+\begin{exercice}
+Quel est le résultat des calculs binaires suivants:
+\begin{enumerate}[a)]
+\item $0+0=$
+\
+
+\item $1+0=$
+\
+
+\item $0+1=$
+\
+
+\item $1+1=$
+\
+
+\item $1+1+1=$
+\end{enumerate}
+\end{exercice}
+
+À l'aide de l'exercice suivant effectué l'addition suivante:
+
+$$1100101001 + 101110101$$
+
+Pour cela, compléter l'addition en colonne suivante:
+
+\;
+
+\begin{center}
+\begin{tikzpicture}
+ \draw (0,0) node{$1$}
+ (0.5,0) node{$1$}
+ (1,0) node{$0$}
+ (1.5,0) node{$0$}
+ (2,0) node{$1$}
+ (2.5,0) node{$1$}
+ (3,0) node{$1$}
+ (3.5,0) node{$0$}
+ (4,0) node{$0$}
+ (4.5,0) node{$1$};
+ \draw (-0.5,-.5) node{$+$}
+ (0.5,-.5) node{$1$}
+ (1,-.5) node{$0$}
+ (1.5,-.5) node{$1$}
+ (2,-.5) node{$1$}
+ (2.5,-.5) node{$1$}
+ (3,-.5) node{$0$}
+ (3.5,-.5) node{$1$}
+ (4,-.5) node{$0$}
+ (4.5,-.5) node{$1$};
+ \draw (-1,-.8) -- +(6,0);
+\end{tikzpicture}
+\end{center}
+
+\vskip+1cm
+
+\begin{exercice}
+Effectuer les additions binaires suivantes:
+\begin{multicols}{2}
+\begin{enumerate}
+\item $1001 + 101$
+\item $10011 + 110011$
+\item $110001 + 11010$
+\item $110101 + 101110$
+\end{enumerate}
+\end{multicols}
+\end{exercice}
+
+
+\begin{exercice}
+\begin{enumerate}
+\item On voudrait encoder des emojis en binaire; en d'autres mots, on voudrait faire correspondre chaque emoji à un code binaire différent.
+\begin{enumerate}
+\item Combien peut-on encoder de symboles (ici des emojis) différents sur 3 bits ?
+\item Sur 5 bits ?
+\item Sur 11 bits ?
+\end{enumerate}
+
+\item Quel est le plus grand nombre qu'on peut écrire sur 5 bits ?
+
+\vspace{10pt}
+\item On se pose maintenant la question inverse :
+\begin{enumerate}
+\item Combien me faut-il de bits pour encoder 8 symboles différents ?
+\item 9 symboles ?
+\item 69 symboles ?
+\end{enumerate}
+
+\end{enumerate}
+\end{exercice}
+
+
+\section{Représentation des nombres entiers}
+
+Nous arrivons à écrire tous les nombres entiers naturels en binaire. Il faut maintenant utiliser un certain nombre de règles pour pouvoir représenter n'importe quel nombre avec un ordinateur: nombres entiers, nombres relatifs, nombres rationnels...
+
+\subsection{Représentation des nombres entiers naturels}
+
+{\it Rappel: Les nombres entiers naturels sont l'ensemble des nombres entiers et positifs. Il est désigné par la lettre $\mathbf{N}=\{0,1,2,\ldots\}$.}
+
+\
+
+Nous pouvons par exemple décider que les nombres seront codés sur un octet (8 bits). Le plus petit nombre sera 00000000 = 0 et le plus grand sera 11111111=255.
+
+\,
+
+{\bf Problème:} En faisant ainsi, nous ne pouvons pas représenter des nombres négatifs.
+
+\subsection{Représentation des nombres entiers relatifs signés}
+
+{\it Rappel: Les nombres entiers sont l'ensemble des nombres entiers négatifs et positifs. Il est désigné par la lettre $\mathbf{Z}=\{\ldots,-2,-1.0,1,2,\ldots\}$.}
+
+\
+
+La première façon pour représenter les nombres négatifs est de décider que le bit le plus gauche représente le signe du nombre.
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/nombresigne}
+\end{center}
+\end{figure}
+
+Sur 8 bits plus grand nombre sera 01111111=127 et le plus petit sera 111111111=-127.
+
+\
+
+Il est possible d'additionner deux nombres pour autant qu'ils soient tous les deux positifs et que le résultat ne dépasse pas le nombre plus grand nombre pouvant être écrit:
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/Operationsigne}
+\end{center}
+\end{figure}
+
+Le résultat de 104 + 30=134 amène un dépassement de capacité. Le nombre entier signé maximum sur 8 bits est 127.
+
+
+\
+
+{\bf Problème:} Bien que pratique, cette façon de coder les nombres négatifs présente deux problèmes:
+\begin{enumerate}
+\item zéro est représenté de deux façons différentes: 1000000 et 00000000.
+\item si on additionne deux nombres opposés, nous n'obtenons pas 0.
+\end{enumerate}
+
+\subsection{* Représentation des nombres en complément à deux}
+
+Cette représentation résout les problèmes de la représentation signée. Dans cette représentation, pour obtenir l'opposé d'un nombre positif écrit en binaire, nous allons effectuer les deux étapes suivantes:
+\begin{enumerate}
+ \item On inverse tous les bits du nombre positif (on change les 0 en 1 et inversement). Cela s'appelle le {\bf complément à 1}.
+ \item On ajoute 1.
+\end{enumerate}
+
+Par exemple, nous aimerions écrire le nombre -80.
+
+Premièrement, 80 s'écrit en binaire: {\bf 01010000}.
+
+\
+
+On prend le complément à 1 de ce nombre, ce qui donne: {\bf 10101111}
+
+\
+
+Puis on ajoute 1:
+
+\begin{center}
+\begin{tikzpicture}
+ \draw (0,0) node{$1$}
+ (0.5,0) node{$0$}
+ (1,0) node{$1$}
+ (1.5,0) node{$0$}
+ (2,0) node{$1$}
+ (2.5,0) node{$1$}
+ (3,0) node{$1$}
+ (3.5,0) node{$1$};
+ \draw (-0.5,-.5) node{$+$}
+
+ (3.5,-.5) node{$1$};
+
+
+
+ \draw (-1,-.8) -- +(6,0);
+
+ \draw (0,-1.3) node{$1$}
+ (0.5,-1.3) node{$0$}
+ (1,-1.3) node{$1$}
+ (1.5,-1.3) node{$1$}
+ (2,-1.3) node{$0$}
+ (2.5,-1.3) node{$0$}
+ (3,-1.3) node{$0$}
+ (3.5,-1.3) node{$0$};
+\end{tikzpicture}
+\end{center}
+
+L'avantage de cette méthode est que la somme deux nombres opposés donnera bien 0.
+
+\begin{exercice}
+En supposant que les nombres soient écrits sur 8 bits, vérifier que 80 + (-80) = 0.
+\end{exercice}
+
+
+\subsection{Résumé}
+
+\begin{figure}[h!]
+\begin{center}
+\includegraphics[scale=.45]{images/tablerepresentation}
+\end{center}
+\end{figure}
+
+
+%\begin{exercice}
+%Utiliser un tableur pour faire une conversion d'une base à l'autre.
+%\end{exercice}
+
+
+\begin{exercice}
+Donner la représentation signée sur un octet des nombres suivants:
+\begin{multicols}{2}
+\begin{enumerate}
+ \item -100
+ \item 38
+ \item -200
+ \item -83
+\end{enumerate}
+\end{multicols}
+\end{exercice}
+
+
+\begin{exercice}\textbf{* Complément à deux }
+\begin{enumerate}[a)]
+\item Donner la représentation en complément à deux des nombres suivants:
+
+\begin{enumerate}
+\item -95
+\item -64
+\end{enumerate}
+
+\item Vérifier que 95+(-95) donne bien 0 sur un octet.
+\item Vérifier que 64+(-6) donne bien 0111010 sur un octet.
+\end{enumerate}
+\end{exercice}
+
+
+\begin{exercice}
+Nous donnons trois nombres binaires:
+\begin{enumerate}[a)]
+\item 00101010
+\item 1011
+\item 10111111
+\end{enumerate}
+
+\begin{enumerate}
+\item Que valent ces nombres en représentation non signée?
+\item Que valent ces nombres en représentation signée?
+\item * Que valent ces nombres en complément à 2?
+\end{enumerate}
+\end{exercice}
+
+
+
+
+\section{Les codes de caractères}
+
+\subsection{La table ASCII}
+
+\begin{center}
+\begin{figure}[h!]
+\centerline{\includegraphics[width=18cm]{images/ASCII2}}
+\end{figure}
+\end{center}
+
+Le binaire permet de coder les nombres que les systèmes informatiques peuvent manipuler. Cependant, l'ordinateur doit aussi utiliser des caractères alphanumériques pour mémoriser et transmettre des textes par exemple de l’ordinateur vers l’imprimante, d’un automate programmable vers un terminal, d’un clavier vers un processeur, etc.
+
+Le code {\bf ASCII} (American Standard Code for Information Interchange) représente les caractères sur 7 bits (c'est-à-dire 128 caractères possibles, de 0 à 127). Les codes 0 à 31 ne sont pas des caractères. On les appelle caractères de contrôle car ils permettent de faire des actions telles que : retour à la ligne (CR). Bip sonore (BEL). Les codes 65 à 90 représentent les majuscules. Les codes 97 à 122 représentent les minuscules. Le caractère A par exemple à pour code 65 soit 01000001 en binaire.
+
+
+Par exemple:
+\begin{enumerate}[a)]
+\item Le caractère f : 102
+\item le point d'interrogation ? : 63
+\item Le chiffre 2 : 50
+\end{enumerate}
+
+Le code ASCII a été mis au point pour la langue anglaise, il ne contient donc pas de caractères accentués, ni de caractères spécifiques à une langue. Le code ASCII a donc été étendu à 8 bits pour pouvoir coder plus de caractères (on parle d'ailleurs de code ASCII étendu...)
+
+\subsection{Unicode}
+
+Le code ASCII est utilisable pour l'anglais mais limité pour les autres langues. Il n'y a que 95 caractères imprimables.
+
+Le code Unicode est un système de codage des caractères sur 16 bits mis au point en 1991. Le système Unicode permet de représenter n'importe quel caractère par un code sur 16 bits, indépendamment de tout système d'exploitation ou langage de programmation (environ 64 000 caractères).
+
+Il regroupe ainsi la quasi-totalité des alphabets existants (arabe, arménien, cyrillique, grec, hébreu, latin, ...) et est compatible avec le code ASCII.
+
+L'ensemble des codes Unicode est disponible sur le site {\bf http://www.unicode.org}.
+
+
+\subsection{Exercices}
+\begin{exercice}
+Traduire en code ASCII binaire les textes :
+\begin{multicols}{2}
+\begin{enumerate}
+\item { Sismondi}
+\item { Cc cv ?}
+\end{enumerate}
+\end{multicols}
+\end{exercice}
+
+\begin{exercice}
+Traduire en lettres les mots suivants qui sont codés en ASCII (binaire):
+\begin{enumerate}
+\item 01100011 01101111 01110101 01100011 01101111 01110101
+\item 01001000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100 00100000 00100001
+\end{enumerate}
+\end{exercice}
+
+\begin{exercice}
+* En s’aidant de la table ASCII, classer par ordre croissant les caractères suivants (ne pas tenir compte des virgules) : ESC, A, NUL, Delete, m, 8, <, a, ?
+\end{exercice}
+
+
+\begin{exercice}
+Complétez le tableau ci-dessous:
+
+\begin{figure}[h!]
+\begin{center}
+\includegraphics[scale=.25]{images/tableauconversion}
+\end{center}
+\end{figure}
+\end{exercice}
+
+
+\end{document}
diff --git a/02-images.tex b/02-images.tex
new file mode 100644
index 0000000000000000000000000000000000000000..1a8ff8a28439310dd88b88b24409bfca1c94c9ac
--- /dev/null
+++ b/02-images.tex
@@ -0,0 +1,406 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{1}
+\chapter{Représentation numérique de l’information - Images}
+
+\subsection{Image numérique}
+
+Grâce aux nombres, les ordinateurs stockent des dessins, des photos et d’autres types d’images.
+{\it Wikipedia} définit l'image numérique comme toute image (dessin, icône, photographie…) acquise, créée, traitée et stockée sous forme binaire.
+
+On distingue deux types d’images numériques:
+\begin{enumerate}[a)]
+\item {\bf L'image matricielle (ou bitmap}:
+Elle est composée de points appelés pixels que l’on voit pas à l'œil nu. Lors de l’agrandissement l’image peut devenir floue car les pixels ressortent ( les carrés sur l’écran).
+\item {\bf L'image vectorielle}:
+Elle est composée de lignes et de segments qui sont liés entre eux par des formules mathématiques. Grâce à la vectorisation, chaque élément a une place définie qui empêche la déformation de l’image. Au lieu de mémoriser une mosaïque de points élémentaires, on stocke la succession d’opérations conduisant au tracé.
+
+L’usage de ce type d’image concerne les schémas générés par certains logiciels de DAO(Dessin assisté par ordinateur) ou pour les animations Flash utilisées sur internet pour la création de bannières publicitaires.
+
+\end{enumerate}
+
+\begin{center}
+\begin{figure}
+\centering
+\includegraphics[width=10cm]{images/bitmapvectoriel}
+\caption{Différence entre une image bitmap (à gauche) et vectorielle (à droite)}
+\end{figure}
+\end{center}
+
+\begin{remarque}
+
+Il n’est pas possible de tout vectoriser car les photos et les dégradés de couleurs ne se vectorisent pas. En effet, la vectorisation aplatit les couleurs et élimine des dégradés.
+
+\end{remarque}
+
+\subsection{Coder une image en noir et blanc}
+
+\subsubsection{Première méthode}
+
+\begin{defi}
+Les écrans d’ordinateur sont divisés en une grille de petits points appelés pixels (picture elements, qui signifie éléments d’image)
+\end{defi}
+
+Chaque pixel de l'image est codé soit par un 0, représentant un point blanc ou un 1, représentant un point noir. Donc un bit permet de coder un pixel d’une image en noir et blanc.
+
+Pour stocker une image en noir et blanc, il suffit de convertir le noir par 0 et le blanc par 1.
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+\foreach \x in {0,...,8}
+ {\draw (0,\x) -- +(8,0);
+ \draw (\x,0) -- +(0,8);
+ }
+\foreach \x in {0,...,7}{
+ \foreach \y in {0,...,7}{
+ \draw (\x+.5,\y+.5) node {$1$};
+ }
+ }
+
+\foreach \x in {(2,0),(3,0),(5,0),(6,0),
+ (3,1),(4,1),(5,1),
+ (2,2),(3,2),(5,2),(6,2),
+ (2,3),(3,3),(5,3),(6,3),
+ (3,4),(4,4),(5,4),
+ (4,5),
+ (2,6),(3,6),(4,6),(5,6),
+ (3,7),(4,7),(5,7)
+ }{
+ \filldraw[fill=black] \x rectangle +(1,1);
+ \draw[color=white] \x +(.5,.5) node {0};
+}
+
+\end{tikzpicture}
+\end{center}
+
+\subsubsection{Deuxième méthode}
+
+Une autre façon consiste à indiquer pour chaque ligne le nombre de points blancs et de points noirs consécutifs.
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+\foreach \x in {0,...,5}
+ {\draw (0,\x) -- +(5,0);
+ \draw (\x,0) -- +(0,6);
+ }
+\draw (0,6) -- (5,6);
+
+\foreach \x in {(1,0),(2,0),(3,0),(4,0),
+ (0,1),(4,1),
+ (0,2),(4,2),
+ (1,3),(2,3),(3,3),(4,3),
+ (4,4),
+ (1,5),(2,5),(3,5)
+ }{
+ \filldraw[fill=black] \x rectangle +(1,1);
+
+}
+
+\draw (6,0.5) node[right] {1,4};
+\draw (6,1.5) node[right] {0,1,3,1};
+\draw (6,2.5) node[right] {0,1,3,1};
+\draw (6,3.5) node[right] {1,4};
+\draw (6,4.5) node[right] {4,1};
+\draw (6,5.5) node[right] {1,3,1};
+
+\end{tikzpicture}
+\end{center}
+
+L’image de la lettre “a” nous montre comment une image peut être représentée par des nombres. Le premier nombre représente toujours le nombre de pixels blancs. Si le premier pixel est noir, la ligne commencera par un 0.
+\begin{enumerate}[a)]
+\item La première ligne est représentée par 1, 3, 1.
+\item La première ligne contient 1 pixel blanc, 3 noirs puis 1 blanc.
+\item La quatrième ligne est représentée par 0, 1, 3, 1.
+\end{enumerate}
+
+\begin{exercice}
+Décoder l'image suivante:
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+\foreach \x in {0,...,16}{
+ \draw (\x,0) -- +(0,9);
+ }
+
+\foreach \x in {0,...,9}{
+ \draw (0,\x) -- +(16,0);
+ }
+
+\draw (17,8.5) node[right] {4,11};
+\draw (17,7.5) node[right] {4,9,2,1};
+\draw (17,6.5) node[right] {4,9,2,1};
+\draw (17,5.5) node[right] {4,11};
+\draw (17,4.5) node[right] {4,9};
+\draw (17,3.5) node[right] {4,9};
+\draw (17,2.5) node[right] {5,7};
+\draw (17,1.5) node[right] {0,16};
+\draw (17,0.5) node[right] {1,14};
+
+\end{tikzpicture}
+\end{center}
+\end{exercice}
+
+
+\subsection{Coder une image en couleur}
+
+Pour stocker une image en couleur en mémoire, il suffit de convenir que chaque point de l’image est représenté par un nombre.
+
+Ce dernier correspond à une certaine couleur.
+
+Pour une image en 16 couleurs, il faut que chaque point de l’image soit codé par un nombre en 4 bits.
+
+Si chaque point est codé sur 8 bits l’image peut contenir 256 couleurs différentes.
+
+Si l'on souhaite que l'image contient plus de couleurs, on pourra utiliser plus de bits pour chaque pixel.
+
+Pour représenter des images avec des couleurs réalistes,
+le code le plus utilisé est le codage {\bf RVB} (Rouge, Vert, Bleu) (RGB en anglais).
+
+Chacune de ces couleurs est codée sur 1 octet (8 bits).
+Avec ce système, chaque pixel est codé sur 3 octets pour un total de 24 bits.
+
+La valeur décimale pour chaque couleur peut s’étendre de 0 à 255, cette limite est fixée par la valeur maximale qu’un octet peut représenter avec le système binaire.
+
+L’avantage du système RVB est sa simplicité,
+il s’appuie sur les caractéristiques de la vision humaine pour fournir à l’utilisateur une reproduction des couleurs au plus proche de la réalité.
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+\foreach \x in {0,...,10}{
+ \draw (0,\x) -- +(30,0);
+ }
+
+\draw (6,0) -- +(0,10);
+\draw (14,0) -- +(0,10);
+\draw (22,0) -- +(0,10);
+\draw (30,0) -- +(0,10);
+\draw (0,0) -- +(0,10);
+
+\filldraw[fill=lightgray] (6,9) rectangle (30,10);
+
+\draw (18,10.5) node {codage pixel en décimal};
+
+\filldraw[fill=black] (0,0) rectangle (6,1);
+\draw[white] (3,0.5) node {Noir};
+\draw (10,0.5) node {0};
+\draw (18,0.5) node {0};
+\draw (26,0.5) node {0};
+
+\definecolor{magenta}{rgb}{255,0,255}
+
+\filldraw[fill=magenta] (0,1) rectangle +(6,1);
+\draw (3,1.5) node {Magenta};
+\draw (10,1.5) node {255};
+\draw (18,1.5) node {0};
+\draw (26,1.5) node {255};
+
+
+\filldraw[fill=blue] (0,2) rectangle +(6,1);
+\draw[white] (3,2.5) node {Bleu};
+\draw (10,2.5) node {0};
+\draw (18,2.5) node {0};
+\draw (26,2.5) node {255};
+
+\definecolor{cyan}{rgb}{0,255,255}
+
+\filldraw[fill=cyan] (0,3) rectangle +(6,1);
+\draw (3,3.5) node {Cyan};
+\draw (10,3.5) node {0};
+\draw (18,3.5) node {255};
+\draw (26,3.5) node {255};
+
+\filldraw[fill=green] (0,4) rectangle +(6,1);
+\draw (3,4.5) node {Vert};
+\draw (10,4.5) node {0};
+\draw (18,4.5) node {255};
+\draw (26,4.5) node {0};
+
+\definecolor{jaune}{rgb}{255,255,0}
+
+\filldraw[fill=jaune] (0,5) rectangle +(6,1);
+\draw (3,5.5) node {Jaune};
+\draw (10,5.5) node {255};
+\draw (18,5.5) node {255};
+\draw (26,5.5) node {0};
+
+\filldraw[fill=red] (0,6) rectangle +(6,1);
+\draw (3,6.5) node {Rouge};
+\draw (10,6.5) node {255};
+\draw (18,6.5) node {0};
+\draw (26,6.5) node {0};
+
+\filldraw[fill=white] (0,7) rectangle +(6,1);
+\draw (3,7.5) node {Blanc};
+\draw (10,7.5) node {255};
+\draw (18,7.5) node {255};
+\draw (26,7.5) node {255};
+
+\filldraw[fill=gray] (0,8) rectangle +(6,1);
+\draw (3,8.5) node {Gris moyen};
+\draw (10,8.5) node {127};
+\draw (18,8.5) node {127};
+\draw (26,8.5) node {127};
+
+
+\draw (3,9.5) node {\bf Couleur};
+\draw (10,9.5) node {\bf R};
+\draw (18,9.5) node {\bf V};
+\draw (26,9.5) node {\bf B};
+
+\end{tikzpicture}
+\end{center}
+
+Comme pour les systèmes de codage noir \& blanc et en niveau de gris, le système RVB utilise une norme pour le codage des couleurs.
+
+Le codage sur 16 bits permet d'obtenir 65536 couleurs différentes.
+Le codage sur 24 bits permet d'obtenir plus de 16 millions de couleurs ($2^{24}$ couleurs).
+
+On considère souvent qu'un codage sur 32 bits permet de coder plus de couleurs que l’œil humain peut en distinguer.
+
+Une photo de haute qualité est codée sur 32 bits.
+
+On peut se contenter de 24 bits (soit 3 octets). Chaque octet représente une nuance des trois couleurs (rouge, vert et bleu), qui sont mélangées.
+
+\subsubsection{Compression}
+
+\begin{remarque}
+La taille (poids) de l’image augmente en augmentant le nombre de nuances de couleurs.
+\end{remarque}
+
+
+Une technique consistent à réduire l’information nécessaire pour représenter une image ou un son.
+
+Pour pallier les inconvénients des images trop lourdes en particulier lors du stockage ou de la transmission et publication sur le web.
+
+Ce qui permet de réduire les exigences quant à l’espace disponible sur le disque ainsi que les coûts de communications lorsque l’image ou le son sont téléchargés.
+
+
+Malgré les techniques de compression, les images ou sons occupent encore souvent une place importante dans le programme.
+
+\subsubsection{Les formats d'images}
+
+\begin{defi}
+Un format d'image est une représentation informatique de l'image, associée à des informations sur la façon dont l'image est codée et fournissant éventuellement des indications sur la manière de la décoder et de la manipuler.
+\end{defi}
+
+Voici quelques formats d'images très utilisés:
+\begin{enumerate}[a)]
+
+\item {\bf BMP} : (prononcé {\it bitmap}) pas de compression, profondeur de couleurs au choix
+\item {\bf JPG ou JPEG} : (prononcé {\it j-peg}) compression possible ; qualité entre 0 et 100\%. Perte de qualité. Profondeur de
+couleurs au choix. Bien adapté aux photos.
+\item {\bf GIF} : compression sans perte de qualité. 256 couleurs max.
+\item {\bf PNG} : compression sans perte. Intéressant pour les images avec peu de couleurs
+(schémas), mais pas pour des photos.
+
+\end{enumerate}
+
+
+\section{Représentation du son}
+\subsubsection{Échantillonage}
+
+Un son est un signal physique qui correspond à la pression de l'air au cours du temps. C'est ces variations de pressions que captent nos oreilles. Une fois enregistré, ce son peut-être encodé de manière similaire aux images : on sélectionne une valeur à intervalles de temps régulières et on encode chacune de ces valeurs en binaire. Cela revient à "pixeliser" le son.
+
+
+\begin{center}
+\begin{figure}[h!]
+\includegraphics[width=12cm]{images/son}
+\end{figure}
+\end{center}
+
+Ce processus est nommé l'échantillonnage et on échantillonne en général les sons à 44 kHz (ce qui correspond à une valeur toutes les 1/44000 secondes, soit toutes les 23 $\mu s$), soit 2x plus que le son le plus aigu que l'oreille humaine peut entendre (22kHz).
+
+\subsubsection{Les formats d'images}
+\begin{enumerate}
+\item Cette technique est celle utilisée dans certains formats de sons "bruts" comme le RAW ou WAV.
+
+\item D'autres formats comme le MP3, compressent encore ces informations, comme le fait le JPG pour les images.
+
+\item D'autres formats, comme le MIDI, n'utilise pas cette méthode et font le choix de noter directement l'équivalent des notes de musique et des instruments sur lesquels elles sont jouées. Ce format est adapté aux musiques composées sur synthétiseurs, mais pas aux sons enregistrés dans la nature.
+
+\end{enumerate}
+
+\section{Exercices}
+\begin{exercice}
+Traduire les mots suivants en code ASCII binaire :
+\begin{enumerate}
+\item \#MeToo
+\item 2+2<5
+\end{enumerate}
+\end{exercice}
+
+
+\begin{exercice}
+Traduire en lettres la phrase suivante qui est codée en ASCII (binaire):
+\begin{enumerate}
+\item 01000011 01100001 00100000 01100011 00100111 01100101 01110011 01110100 00100000 01100100 01110101 00100000 01100010 01101001 01101110 01100001 01101001 01110010 01100101 00101110
+\end{enumerate}
+\end{exercice}
+
+\begin{exercice}
+Traduire en lettre les mots suivants qui sont codés en ASCII (hexadécimal):
+\begin{enumerate}
+\item 42696E76656E7521
+\item 31323D332A342C204F4B3F
+\end{enumerate}
+\end{exercice}
+
+
+\begin{exercice}
+Décoder l'image suivante:
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+\foreach \x in {0,...,16}{
+ \draw (\x,0) -- +(0,13);
+ }
+
+\foreach \x in {0,...,13}{
+ \draw (0,\x) -- +(16,0);
+ }
+
+\draw (17,12.5) node[right] {6,5,2,3};
+\draw (17,11.5) node[right] {4,2,5,2,3,1};
+\draw (17,10.5) node[right] {3,1,9,1,2,1};
+\draw (17,9.5) node[right] {3,1,9,1,1,1};
+\draw (17,8.5) node[right] {2,1,11,1};
+\draw (17,7.5) node[right] {2,1,10,2};
+\draw (17,6.5) node[right] {2,1,9,1,1,1};
+\draw (17,5.5) node[right] {2,1,8,1,2,1};
+\draw (17,4.5) node[right] {2,1,7,1,3,1};
+\draw (17,3.5) node[right] {1,1,1,1,4,2,3,1};
+\draw (17,2.5) node[right] {0,1,2,1,2,2,5,1};
+\draw (17,1.5) node[right] {0,1,3,2,5,2};
+\draw (17,0.5) node[right] {1,3,2,5};
+
+\end{tikzpicture}
+\end{center}
+\end{exercice}
+
+\newpage
+\begin{exercice}
+Encoder l'image suivante:
+
+\begin{center}
+\begin{figure}[h!]
+\includegraphics[width=8cm]{images/moustache}
+\end{figure}
+\end{center}
+
+\end{exercice}
+
+
+\begin{exercice}
+Quel est d'après vous le code RGB du violet foncé ? %160-0-160
+\end{exercice}
+
+
+\begin{exercice}
+Quel est d'après vous la couleur correspondant au code RGB suivant : (255, 128, 0) ? % orange
+\end{exercice}
+
+\end{document}
\ No newline at end of file
diff --git a/03-ordinateur.tex b/03-ordinateur.tex
new file mode 100644
index 0000000000000000000000000000000000000000..3540ae51bb6ff948357273c5c4fbfbc502718b07
--- /dev/null
+++ b/03-ordinateur.tex
@@ -0,0 +1,331 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{4}
+
+\chapter{Ordinateurs}
+
+\section{Qu’est-ce qu’un ordinateur (computer) ?}
+
+\begin{defi}
+ Un ordinateur est une machine électronique capable de traiter (calculer, stocker) des données de manière automatisée et optimisée à l'aide de logiciels, ainsi que de les partager au travers d'un réseau et de périphériques.
+\end{defi}
+
+\begin{center}
+\begin{figure}[ht!]
+ \includegraphics[scale=.4]{images/shema_ordinateur.png}
+ \caption{Schéma fonctionnel de l'ordinateur}
+\end{figure}
+\end{center}
+
+ On parle souvent de PC (Personnal Computer) ou ordinateur personnel. C'est tout simplement un ordinateur qui répond aux besoins des utilisateurs (humains).
+
+\begin{center}
+\begin{figure}[h]
+ \includegraphics[scale=.3]{images/ordinateur}
+ \caption{Exemple d'ordinateur personnel}
+\end{figure}
+\end{center}
+
+
+
+Il existe des ordinateurs plus puissants qui sont spécialement conçus pour fournir des informations et des logiciels à d'autres ordinateurs reliés via un réseau. On les appelle des {\bf serveurs}. Ces derniers sont capables de traiter des charges de travail plus importantes et d'exécuter davantage d'applications.
+
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.4]{images/serveur}
+ \caption{Salle de serveurs du CERN}
+ \label{serveur}
+\end{figure}
+
+
+Les ordinateurs les plus puissants au monde sont appelés supercalculateur. Ils contiennent des centaines, voire des milliers de processeurs. Ils sont souvent utilisés dans la recherche médicale, les applications scientifiques (cf Figure \ref{serveur}), le domaine de la finance, la météorologie et à des fins militaires.
+
+
+\section{L'intérieur d'un ordinateur}
+
+\subsection{Les composants}
+
+Pour fonctionner, l’ordinateur est constitué de composants électroniques comme la mémoire (4) ou le processeur (2). Ces composants sont regroupés sur une carte mère (1) qui est le circuit imprimé \footnote{Le circuit imprimé est un support, en général une plaque, permettant de maintenir et de relier électriquement un ensemble de composants électroniques entre eux.} principal. Elle permet de prendre en charge la mémoire vive (4), la lecture du disque dur (7) et l'utilisation du processeur. Cette carte mère est fixée à l'unité centrale également nommée : la tour, le boîtier, desktop, etc.
+
+\begin{center}
+\begin{figure}[h]
+ \includegraphics[scale=.6]{images/composants}
+ \caption{L'ordinateur, l'unité centrale et sa composition}
+ \label{composants}
+\end{figure}
+\end{center}
+
+Les principaux composants constituant un ordinateur sont :
+\begin{itemize}%[label=\textbullet]
+ \item Le {\bf processeur} (CPU, Central Processing Unit) (2) : il gère tous les calculs pour permettre à l'ordinateur de fonctionner. Il va exécuter une suite l'instruction cadencée par une horloge (la fréquence du processeur). Il permet donc d'exécuter différents programmes. Il va s'appuyer sur la mémoire vive pour stocker ses calculs.
+
+ \item La {\bf mémoire vive} (Random Access Memory) (4) : c'est une mémoire très rapide où se trouvent les informations traitées par le processeur. Lorsque l'ordinateur est éteint, les informations contenues en mémoire vive ne sont plus maintenues, on perd l'information.
+
+ \item La {\bf mémoire permanente} : est une mémoire moins rapide que la mémoire vive, mais de plus grande capacité utilisée pour sauvegarder des données. Le disque dur (hard drive) (7) est un exemple de mémoire permanente.
+
+ \item Le {\bf lecteur/graveur CD/DVD/Blu-ray } (8) : il lit l'ensemble des CD, DVD et Blu-ray, que ce soit de la musique, des logiciels, des jeux, des films, etc.
+
+ \item L'{\bf alimentation} (9) : branchée sur le réseau électrique 220 [V], elle alimente tous les composants électroniques.
+
+ \item La {\bf carte graphique} (graphic card) (5) : elle transmet les images qu'elle possède en mémoire sur les écrans. Elle permet donc d'afficher à l'écran des images, du texte, des vidéos, etc. en allumant des points lumineux (pixels). À noter que certains processeurs comportent une unité graphique rendant obsolète l'ajout d'une carte graphique sur un ordinateur, typiquement pour un usage de type bureautique.
+\end{itemize}
+
+\begin{remarque}
+Dans un smartphone, c'est le {\bf SoC, (system on a chip)} qui rassemble quasiment tous ces composants: CPU, GPU (processeur de la carte graphique), modem (connexion réseau), mémoire RAM... Dans une petite puce (M1 ou A11 par exemple chez apple ou Exynos chez Samsung) se retrouve concentrée la puissance d'un ordinateur d'il y a quelques années.
+\end{remarque}
+
+\subsection{ Caractéristiques des composants}
+
+
+\subsubsection{La carte mère}
+
+Une {\bf carte mère} se distingue principalement par la génération de processeur qu'elle peut accueillir, par le type de mémoire vive pouvant être connecté, le nombre et les différents types de connecteurs (6) (IDE, sata, PCI, etc.) qu'elle comporte et par son jeu de composants électroniques (chipset) lui permettant de gérer l'échange de données entre les disques, la mémoire, la carte graphique et les différents périphériques externes d'entrée/sortie. La carte mère comporte également un ensemble de fonctions nommé BIOS ({\it Basic Input Output System}) ou plus récemment UEFI ({\it Unified Extensible Firmware Interface}) lui permettant, lors de sa mise sous tension, d'identifier le matériel connecté sur la carte mère.
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.4]{images/cartemere}
+
+\end{figure}
+
+\subsubsection{Processeur}
+
+Un processeur se distingue principalement par sa fréquence de fonctionnement et son architecture. À l’heure actuelle, sa fréquence se traduit en gigahertz [GHz]. Concrètement, une fréquence de 2 GHz signifie que le processeur peut réaliser deux milliards d'opérations à la seconde. Parmi les entreprises réputées dans la conception de processeur, on trouve : AMD, IBM, Intel, Hewlett-Packard, Hitachi, Oracle, Motorola, Texas Instrument.
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.15]{images/processeur}
+
+\end{figure}
+
+
+\subsubsection{Mémoire}
+
+Qu'il s'agisse de {\bf mémoire vive} ou {\bf mémoire permanente}, la mémoire est principalement caractérisée par sa capacité de stockage et sa rapidité d'accès en lecture et en écriture. Actuellement, sa capacité est traduite en gigaoctets [Go] ou téraoctets [To]. La vitesse de lecture et d'écriture est donnée en Mo/s.
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.3]{images/sdram}
+
+\end{figure}
+
+
+
+
+
+\subsubsection{L'alimentation}
+
+L’{\bf alimentation } est caractérisée par sa puissance. La puissance de l'alimentation détermine la quantité d'électricité délivrée en watts [W]. Elle permet de fournir un courant continu nécessaire aux circuits électroniques. Les alimentations comportent une certification (label) donnant une garantie d'économie d'énergie. Ce label est accordé aux alimentations dont le rendement – rapport entre puissance fournie et consommée – est supérieur à 80 \%.
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.5]{images/alimentation}
+
+\end{figure}
+
+\subsubsection{La carte graphique}
+
+ La {\bf carte graphique} se caractérise principalement par l'architecture de son processeur graphique (GPU) et sa mémoire vive. À ce jour, Nvidia et AMD sont leaders dans la conception des processeurs graphiques. On distingue très facilement les cartes graphiques les plus puissantes par le système de refroidissement qu’elle possède.
+
+ \begin{figure}[h]
+ \centering
+ \includegraphics[scale=.2]{images/carte_graphique}
+
+\end{figure}
+
+
+
+\section{Périphériques externes}
+
+\subsection{Exemples de périphériques}
+
+Pour interagir avec l’ordinateur, des périphériques d’entrée/sortie sont nécessaires. Il en existe de toutes sortes et ces derniers sont connectés à l’ordinateur par différent type de câbles (réseau, USB, DVI, série, etc.) ou à l’aide d’une connexion sans fils (infrarouge, wifi, Bluetooth, lasers, etc).
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.3]{images/peripherique}
+ \caption{Périphériques d'un ordinateur}
+\end{figure}
+
+
+Les différents types de périphériques externes sont :
+\begin{enumerate}[1)]
+ \item Le {\bf scanner} permet la numérisation de document dans une certaine résolution.
+ \item Le {\bf lecteur} CD ou DVD ou Blu-ray sont des lecteurs permettant de lire un support amovible à l’aide d’un faisceau laser.
+ \item Le {\bf haut-parleur} permet de diffuser du son.
+ \item L’{\bf écran} permet d’afficher les informations, mais lorsqu’il est tactile, il offre la possibilité de se passer de la souris et du clavier. Il est caractérisé par sa taille et sa définition d’écran qui est le nombre de points ou pixels que peut afficher un écran. Actuellement, les définitions (nombre de points H x V) les plus courantes sur un écran pour ordinateur sont :
+ \begin{itemize}
+ \item XGA : 1024 x 768
+ \item HD : 1280 x 768
+ \item Full HD : 1920 x 1080
+ \item WUXGA : 1920 x 1200
+ \item WQHD : 2560 x 1440
+ \item 8K Full Format : 8192 x 4320
+ \end{itemize}
+ \item le {\bf clavier}. utilisé pour écrire, mais également se déplacer rapidement dans un texte ou dans des menus, voire même effectuer une copie d’écran (screenshot).
+ \item La {\bf souris} sert à déplacer le curseur sur l’écran, de choisir des applications et aussi de cliquer sur des icônes pour démarrer des logiciels. Elle permet de naviguer sur votre ordinateur, mais également de dessiner, sélectionner des textes, etc. Elle est mobile avec ou sans fil.
+ \item Le {\bf disque externe} est un disque dur qui n’est pas intégré dans l’ordinateur. En fonction de sa taille, il peut être facilement déplacé. En fonction du modèle, les disques externes sont soit alimentés par un branchement USB, soit avec une alimentation sur secteur 220[V].
+ \item L’{\bf imprimante} 2D permet l’impression de texte, image, graphique. Il existe plusieurs technologies d’impressions telles que laser, jet d’encre, sublimation, etc. Depuis les années 2010, l’impression 3D prend de l’ampleur avec l’arrivée de nouvelles technologies innovantes basées sur de nouveaux matériaux comme le plastique, la cire, le métal, la céramique, le verre. Il est même possible d’imprimer en 3D une forme en chocolat !
+ \item L’{\bf interface graphique} ou l’{\bf environnement graphique} est un dispositif logiciel permettant le dialogue entre l’utilisateur·trice et l’ordinateur.
+En fonction de son utilisation, un périphérique est considéré soit en entrée, soit en sortie, soit comme étant bidirectionnel. Le tableau suivant résume le type de périphérique.
+\end{enumerate}
+
+
+
+
+
+\subsection{Périphériques d'entrée et de sortie}
+
+En fonction de son utilisation, un périphérique est considéré soit en entrée, soit en sortie, soit comme étant bidirectionnel. Le tableau suivant résume le type de périphérique.
+
+Si le périphérique envoie des données à l'ordinateur, on l'appelle un {\bf périphérique d'entrée}.
+
+Si le périphérique reçoit des données de l'ordinateur, on l'appelle un {\bf périphérique de sortie}
+
+Un périphérique peut aussi envoyer et recevoir des données de l'ordinateur: c'est un {\bf périphérique d'entrée et de sortie}.
+
+\section{Système d'exploitation}
+
+Pour qu’un ordinateur soit capable de faire fonctionner un programme informatique (appelé parfois application ou logiciel), la machine doit être en mesure d’effectuer un certain nombre d’opérations préparatoires afin d’assurer les échanges entre le processeur, la mémoire, et les ressources physiques (périphériques). C'est le système d'exploitation qui s'en occupe:
+
+\begin{defi}
+ Le {\bf système d’exploitation} (noté SE ou OS, abréviation du terme anglais Operating System) est chargé d’assurer la liaison entre les ressources matérielles, l'utilisateur et les applications (traitement de texte, jeu vidéo..).
+\end{defi}
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.3]{images/systemeexploitation}
+\end{figure}
+
+ Ainsi, lorsqu’un programme désire accéder à une ressource matérielle, il ne lui est pas nécessaire d’envoyer des informations spécifiques au périphérique, il lui suffit d’envoyer les informations au système d’exploitation, qui se charge de les transmettre au périphérique concerné via son pilote:
+
+ \begin{defi}
+ Un {\bf pilote} (ou {\bf driver} est un programme particulier qui permet la bonne liaison entre l'ordinateur et un périphérique particulier (scanner, imprimante...).
+
+ \end{defi}
+
+ En l’absence de pilotes, il faudrait que chaque programme reconnaisse et prenne en compte la communication avec chaque type de périphérique !
+
+ Le système d’exploitation permet ainsi de « dissocier » les programmes et le matériel, afin
+notamment de simplifier la gestion des ressources et offrir à l’utilisateur une interface humain – machine simplifiée afin de lui permettre de s’affranchir de la complexité de la machine physique.
+
+
+ Il existe de nombreux systèmes d’exploitation. Les plus connus à ce jour sont : Microsoft Windows, GNU/Linux, Apple Mac OS, Oracle Solaris, Google Android, etc.
+
+\begin{figure}[h]
+ \centering
+ \includegraphics[scale=.3]{images/OS}
+ \caption{Différents systèmes d'exploitation}
+\end{figure}
+
+
+\newpage
+
+\section{Exercices}
+
+
+\begin{exercice}
+Relie chaque composant à son nom:
+
+\begin{tikzpicture}
+ \node (image1) at (0,0) {\includegraphics[width=4cm]{images/alimentation}};
+ \node (image2) at (0,3) {\includegraphics[width=4cm]{images/carte_graphique}};
+ \node (image3) at (0,6) {\includegraphics[width=4cm]{images/sdram}};
+ \node (image4) at (0,9) {\includegraphics[width=4cm]{images/cartemere}};
+ \node (image5) at (0,12) {\includegraphics[width=4cm]{images/disquedur}};
+ \node (image6) at (0,15) {\includegraphics[width=4cm]{images/processeur}};
+
+\filldraw[fill=black] (4,0) rectangle +(0.3,0.3);
+\filldraw[fill=black] (4,3) rectangle +(0.3,0.3);
+\filldraw[fill=black] (4,6) rectangle +(0.3,0.3);
+\filldraw[fill=black] (4,9) rectangle +(0.3,0.3);
+\filldraw[fill=black] (4,12) rectangle +(0.3,0.3);
+\filldraw[fill=black] (4,15) rectangle +(0.3,0.3);
+
+\begin{scope}[shift={(3,0)}]
+ \filldraw[fill=black] (4,0) rectangle +(0.3,0.3);
+ \filldraw[fill=black] (4,3) rectangle +(0.3,0.3);
+ \filldraw[fill=black] (4,6) rectangle +(0.3,0.3);
+ \filldraw[fill=black] (4,9) rectangle +(0.3,0.3);
+ \filldraw[fill=black] (4,12) rectangle +(0.3,0.3);
+ \filldraw[fill=black] (4,15) rectangle +(0.3,0.3);
+\end{scope}
+
+\draw (8,9.2) node[right] {L'alimentation};
+\draw (8,6.2) node[right] {Carte graphique};
+\draw (8,3.2) node[right] {Le disque dur};
+\draw (8,0.2) node[right] {Processeur};
+\draw (8,12.2) node[right] {Carte mère};
+\draw (8,15.2) node[right] {Mémoire vive (RAM)};
+
+\end{tikzpicture}
+\end{exercice}
+
+
+
+\begin{exercice}
+Réponds aux questions suivantes :
+\begin{enumerate}
+\item Je suis le circuit imprimé principal où tous les composants sont reliés.
+
+\vskip.5cm
+
+Je suis :
+
+\vskip.5cm
+
+\item Je gère tous les calculs pour permettre à l’ordinateur de fonctionner. \vskip.5cm
+
+Je suis :
+
+\vskip.5cm
+\item Je suis connecté à l’ordinateur et j’affiche tout ce qu’il m’envoie comme du texte, des dessins, des photos, des films, etc.
+\vskip.5cm
+
+Je suis :
+
+\vskip.5cm
+\item Je m’appelle mémoire permanente et je conserve toutes les données même si l’ordinateur est éteint.
+\vskip.5cm
+
+Je suis :
+
+\vskip.5cm
+\item Sans moi, on ne peut pas taper du texte.
+\vskip.5cm
+
+Je suis :
+
+\vskip.5cm
+\item Je suis une mémoire plus rapide que la mémoire permanente et je ne conserve pas les données si l’ordinateur est éteint.
+\vskip.5cm
+
+Je suis :
+
+\vskip.5cm
+
+\end{enumerate}
+
+\end{exercice}
+
+
+
+\begin{exercice}
+{\bf Complète le schéma.}
+
+Le schéma suivant représente les différents périphériques externes d’un ordinateur. Dessine le sens des flèches pour indiquer si le périphérique est en entrée ou en sortie.
+
+{\it Par exemple : le clavier est un périphérique d’entrée, il y a donc une flèche qui part du clavier à l’unité centrale.}
+
+\begin{figure}[h!]
+\centering
+ \includegraphics[width=14cm]{images/ordinateur_ex_3}
+\end{figure}
+\end{exercice}
+
+
+\end{document}
\ No newline at end of file
diff --git a/04-fichier.tex b/04-fichier.tex
new file mode 100644
index 0000000000000000000000000000000000000000..3379d04b5865fc559af1a21933069ada854c69ed
--- /dev/null
+++ b/04-fichier.tex
@@ -0,0 +1,232 @@
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\usepackage{minted}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{3}
+
+\chapter{Notion de fichiers}
+
+\section{Fichiers}
+\subsection{Introduction}
+
+Un fichier informatique est un ensemble de données numériques que l'on souhaite faire persister en le stockant sur un support permanent. Un fichier peut être :une image, un film, du texte, un programme source, un programme exécutable, un fichier compressé, etc. Quant au support permanent (cf. chapitre Ordinateur) il s'agit d'un disque dur, un DVD, une clé USB, etc.
+
+Un disque stocke simplement une suite de bits, une suite de 0 et de 1. Le nombre de bits qu’un disque peut stocker est appelé sa capacité : par exemple un disque d’un téraoctet (binaire) peut stocker 240 mots de 8 bits, soit un peu plus de huit mille milliards de bits. On peut donc facilement stocker un texte, une image, un son ou un programme sur un tel disque. Cependant, comme on souhaite souvent stocker sur un disque plusieurs images, textes, etc., il faut diviser les huit mille milliards de bits dont le disque est constitué en plusieurs espaces plus petits, que l’on appelle des fichiers. Un fichier est simplement une suite de 0 et de 1, à laquelle on associe un nom. Par exemple, le texte "Je pense, donc je suis.» se représente en ASCII étendu comme la suite de 184 bits suivante :
+
+\begin{minted}{latex}
+0100101001100101001000000111000001100101011011
+1001110011011001010010110000100000011001000110
+1111011011100110001100100000011010100110010100
+1000000111001101110101011010010111001100101110
+\end{minted}
+
+Il est possible de stocker cette suite de bits sur un disque en lui donnant le nom cogito.txt, l’extension txt indiquant que cette suite de bits exprime un texte en ASCII. L’extension détermine le type d’information exprimé (texte, image, son, etc.) et le format utilisé pour l’exprimer.
+
+\subsection{Nom de fichier}
+Un fichier comporte donc un {\it nom\_de\_fichier} qui permet de l’identifier et d’y accéder. Ce nom est généralement constitué de deux parties séparées par un point. Par exemple, le fichier nommé {\it Recette\_tarte\_aux\_pommes.odt} se décompose :
+
+\begin{center}
+\begin{tikzpicture}
+ \filldraw[fill=lightgray] (0,0.8) rectangle (10,1.6);
+ \draw (0,0) rectangle (10,0.8)
+ (0,0) rectangle (10,1.6)
+ (0,0) rectangle (5,1.6)
+ (0,0) rectangle (7.5,1.6);
+ \draw (2.5,1.2) node {\bf Nom du fichier};
+ \draw (6.25, 1.2) node {\bf .};
+ \draw (8.75,1.2) node {\bf Extension};
+
+ \draw (2.5,0.4) node {\it Recette\_tarte\_aux\_pommes};
+ \draw (6.25, 0.4) node {\bf .};
+ \draw (8.75,0.4) node {\it odt};
+
+\end{tikzpicture}
+\end{center}
+
+Comme le nom du fichier identifie son contenu, il est important de choisir un nom explicite. En effet, si vous nommez votre rédaction de français avec le nom suivant :
+
+$\rightarrow$ {\it Rédaction\_le\_petit\_prince.odt} : Ce fichier désignera probablement une rédaction avec comme sujet le petit prince.
+
+Par contre, si vous choisissez le nom :
+
+$\rightarrow$ {\it mon\_fichier.odt} : Ce nom ne donne aucune information sur son contenu. On n’aura strictement aucune idée de quoi il s’agit sauf qu’il s’agit d’un fichier !
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item Pour l’utilisateur·trice, il est donc utile et important de bien choisir un nom qui identifie le contenu de son fichier.
+\item Vous remarquez également que des caractères soulignés ( \_ ) ont été utilisés dans la nomenclature. En effet, pendant longtemps, les espaces n’étaient pas autorisés pour nommer des fichiers, car les espaces étaient utilisés comme séparateurs de nom de fichier ! Actuellement, l’espace est accepté sur la plupart des systèmes, mais il existe toujours de vieux programmes qui refusent un espace dans le nom du fichier ou génère une erreur.
+\item Les caractères accentués (é ê è ü à ä î ô û) étaient également interdits. C’est pour cette raison que l’on trouve souvent des fichiers qui n’ont pas d’accent (merci l’orthographe me direz-vous). À noter qu’il subsiste également d’autres caractères qui sont interdits ou déconseillés:
+\begin{itemize}
+\item Microsoft Windows (interdits) $< \; > \, : \; " \; \backslash \; / \; \vert \; . \; ? \; *$
+\item Gnu/Linux et Mac OS (déconseillés): $/$ *
+\end{itemize}
+\item Les noms ont aussi une limite en longueur, jusqu’à 256 caractères (voir plus pour les tout nouveaux systèmes), mais dans les années 80, le système d’exploitation MS-Dos n’autorisait que 8 caractères plus le point et l’extension de 3 caractères !
+\item Certains systèmes de fichier sont sensibles à la casse, mais pas Microsoft Windows. Exemple avec ces trois noms :
+\begin{enumerate}[a)]
+\item {\it recette\_tarte\_aux\_pommes.odt}
+\item {\it Recette\_tarte\_aux\_pommes.odt}
+\item {\it RECETTE\_TARTE\_AUX\_POMMES.odt}
+\end{enumerate}
+Ces trois fichiers indiqueront le même document pour Microsoft Windows, mais bien trois fichiers distincts pour GNU/Linux ou macOS.
+\end{enumerate}
+\end{remarques}
+
+\section{Extension}
+\subsection{Type d'extension}
+Comme cité précédemment, l’extension est formée en général de 3 lettres, mais elle peut en contenir plus (ex. : .html), voir moins ou carrément aucune. L’extension, par convention, indique la nature du fichier. Voici quelques exemples :
+
+\begin{center}
+\begin{tikzpicture}
+ \filldraw[fill=lightgray] (0,8.8) rectangle (12,8);
+ \draw (12,-.8) rectangle
+ (0,0) rectangle (12,0.8) rectangle (0,1.6)
+ rectangle (12,2.4) rectangle (0,3.2)
+ rectangle (12,4) rectangle (0,4.8)
+ rectangle (12,5.6) rectangle (0,6.4)
+ rectangle (12,7.2) rectangle (0,8);
+ \draw (8,-0.8) -- (8,8.8);
+
+ \draw (4,8.4) node {\bf Nature du contenu};
+ \draw (10,8.4) node {\bf Extensions};
+
+ \draw (4,7.6) node {Document texte libre office writer};
+ \draw (10,7.6) node { odt};
+
+ \draw (4,6.8) node {Document tableur libre office calc};
+ \draw (10,6.8) node {ods};
+
+ \draw (4,6) node {Document texte Microsoft Word};
+ \draw (10,6) node {docx};
+
+ \draw (4,5.2) node {Document tableur Microsoft Excel};
+ \draw (10,5.2) node {xlsx};
+
+ \draw (4,4.4) node {Document texte};
+ \draw (10,4.4) node {txt};
+
+ \draw (4,3.6) node {Exemples de formats de fichiers compressés};
+ \draw (10,3.6) node {zip, 7z, rar, lzw};
+
+ \draw (4,2.8) node {Exemples de formats de fichiers audio};
+ \draw (10,2.8) node {mp3, wav, ogg, flac};
+
+ \draw (4,2) node {Images, photos};
+ \draw (10,2) node {png, jpeg, gif};
+
+ \draw (4,1.2) node {Video, film};
+ \draw (10,1.2) node {avi, mpg, mov, flv};
+
+ \draw (4,0.4) node {Page web};
+ \draw (10,0.4) node {htm, html};
+
+ \draw (4,-0.4) node {Exemples de formats de fichiers de code source};
+ \draw (10,-0.4) node {java, c, py};
+
+\end{tikzpicture}
+\end{center}
+\subsection{Type MIME}
+Les systèmes d'exploitation gnu/Linux et MacOS ne demandent pas d'extension aux différents type de fichiers. En effet, ces deux systèmes se basent sur des informations rattachées aux fichiers, les types MIME. Les types MIME sont désormais appelés "types de média Internet". Les types MIME ont été créés à l’origine pour le courrier électronique. "MIME" (Multipurpose Internet Mail Extensions) est un standard qui a été proposé par les laboratoires Bell Communications en 1991 afin d'étendre les possibilités du courrier électronique (courriel), c'est-à-dire de permettre d'insérer des documents (images, sons, texte, ...) lors d'un envoi de message électronique, mais ils se sont étendus à d’autres utilisations.
+
+MS Windows ignore les types MIME et se base uniquement sur les extensions de fichier. Par exemple, vous pouvez avoir un fichier texte nommé "Exemple.txt". MS Windows comprend qu’il s’agit d’un fichier texte en raison de l’extension de fichier .txt. Supprimez le .txt. extension de fichier et renommer le fichier en "Exemple" sans extension de fichier. MS Windows ne saura pas quoi faire avec le fichier résultant. C’est pourquoi MS Windows vous avertit lors de la suppression de l’extension de fichier, en disant "Si vous modifiez une extension de nom de fichier, le fichier peut devenir inutilisable. Êtes-vous sûr de vouloir le changer ?".
+\begin{figure}[h!]
+\centering
+\includegraphics[width=10cm]{images/change_extension.png}
+\end{figure}
+
+Ce fichier ne deviendra pas inutilisable (pour toujours). Vous pouvez le rendre à nouveau "utilisable" en ajoutant l’extension du fichier d’origine.
+C’est une des raisons principales de MS Windows de masquer les extensions de fichiers par défaut dans son explorateur de fichier. Cette option évite que les utilisateurs suppriment accidentellement l'extension d'un fichier. Des attaquants (pirates) peuvent abuser de ce comportement pour cacher du code malveillant et des virus dans des fichiers en choisissant de fausses extensions de fichiers.
+
+Les informations sur la nature du fichier, le type MIME, sont intégrées au début du fichier lui-même. Ainsi, lorsque vous ouvrez un fichier sans extension de fichier, gnu/Linux et MacOS examineront le type MIME du fichier pour déterminer de quel type de fichier il s’agit.
+
+
+\section{Organisation des fichiers}
+
+Lorsque vous prenez une photo avec votre smartphone où se trouve-t-elle ? Quel nom de fichier identifie la photo ? Comment vous y prenez-vous pour classer vos photos ? Ne vous est-il pas arrivé de défiler les photos sur votre écran à la recherche d’une en particulier ? Comment faudrait-il procéder pour retrouver plus rapidement une photo ? Si vos photos sont classées par date et par album n’est-il pas plus simple de retrouver une photo ? Le problème dans notre cas de figure c'est que toutes les photographies se retrouvent au même endroit, sans classement, dans la mémoire permanente du téléphone mobile.
+
+En informatique, pour organiser des fichiers, il est nécessaire de créer des dossiers (ou des répertoires). Dans un dossier, nous pouvons trouver d’autres dossiers et fichiers. Cette structure forme une hiérarchie cohérente. Organiser ses fichiers c’est comme ranger ses feuilles de cours dans plusieurs classeurs avec des pochettes et des séparateurs. Prenons l’exemple suivant pour illustrer le classement de ses feuilles de cours papier. Il s’agit donc de classer différents documents de cours dans leur classeur respectif. Dans notre illustration, nous avons choisi de créer un classeur par discipline ce qui permet, par exemple, de ranger la feuille de géographie Suisse dans la pochette Europe qui se trouve dans le classeur Géographie. Ce classeur sera rangé dans l’armoire des classeurs.
+
+\begin{figure}[h!]
+\centering
+\includegraphics[width=12cm]{images/organisationfichiers}
+\end{figure}
+
+Cette structure se retrouve dans les systèmes de fichiers de manière analogue. Sous GNU/Linux ou macOS le niveau 0 se nomme la racine et le dernier niveau les feuilles (par analogie avec un arbre inversé). Le passage d’un niveau à l’autre, les branches, est décrit par un / (slash). Le chemin pour parvenir au fichier depuis la racine (niveau 0) se nomme le chemin d’accès. Il décrit précisément l’emplacement du fichier (l’itinéraire complet). On appelle une telle organisation des fichiers une organisation arborescente, car on peut la visualiser sous la forme d’un arbre.
+
+Pour résumer:
+\begin{enumerate}[a)]
+\item Un {\bf dossier} peut comporter d’autres dossiers et des fichiers.
+\item Un {\bf fichier} est un ensemble organisé d'informations, désigné par un nom précis, que le système d'exploitation d'un ordinateur manipule comme une simple entité, dans sa mémoire ou sur un support de stockage.
+\end{enumerate}
+
+\begin{figure}[h!]
+\centering
+\includegraphics[width=15cm]{images/arborescence2}
+\end{figure}
+L’organisation arborescente des fichiers n’est pas le seul moyen de structurer l’information : elle est en concurrence avec d’autres méthodes, parmi lesquelles l’utilisation de liens hypertextes, notion qui n’a pas été inventée pour structurer l’information, mais pour simplifier le mécanisme de référence dans une page web.
+
+% SECTION
+\section{Explorateur de fichiers sous différents système d'exploitation}
+Pour nous aider à parcourir l’arborescence des fichiers et des dossiers, chaque système d’exploitation offre un navigateur graphique dans son environnement graphique ou la possibilité de parcourir l'arborescence textuellement dans une console à l'aide de commande.
+
+\subsection{MacOS et GNU/Linux}
+Sous GNU/Linux et macOS, pour chercher la « Feuille Suisse.txt », on écrirait le parcours depuis la racine de manière suivante :
+
+\begin{center}
+{ \bf /Armoire de classeurs/Géographie/Pochette Europe/
+}
+\end{center}
+\begin{figure}[h!]
+\centering
+\includegraphics[width=15cm]{images/fichierMac}
+\end{figure}
+
+En mode console (textuel), la commande $ls$ permet de visualiser le contenu d'un répertoire et la commande $cd\ nom\_du\_dossier$ permet de se déplacer dans le dossier nommé nom\_du\_dossier.
+
+\subsection{Microsoft Windows}
+
+Sous Microsoft Windows, le chemin serait :
+
+\begin{center}
+{\bf C:$\backslash$Armoire de classeurs$\backslash$Géographie$\backslash$Pochette Europe
+}
+\end{center}
+
+\begin{figure}[ht!]
+\centering
+\includegraphics[width=11cm]{images/fichierWindows}
+\end{figure}
+
+Noter la différence entre les deux systèmes. Le caractère / qui délimite les niveaux pour GNU/Linux et macOS et le caractère $\backslash$ pour Microsoft Windows. Il y a aussi la lettre qui détermine la partition ou un périphérique (clé USB, lecteur DVD, etc.) alors que sous GNU/Linux et macOS, une partition est invisible à l’utilisateur·trice en étant considéré comme une branche de l’arbre. L'utilisation de lettre est une spécificité unique du système d'exploitation Microsoft Windows.
+
+\section{Exercices}
+
+\begin{exercice}
+Se connecter sur www.eduge.ch puis aller sur le drive.
+ Organiser le drive en sous fichier: Il devra y avoir un dossier principal nommé: Informatique et au moins 3 sous-dossiers appelés: Microbit, Python et Projet.
+
+ Le prochain petit programme fait en Microbit devra être sauvegardé sur le drive dans le dossier Microbit.
+\end{exercice}
+
+
+\begin{exercice}
+Dans moodle ou classroom, récupérez le fichier Exercice\_1\_fichier.zip et décompressez-le sur votre ordinateur.
+Ouvrez le dossier "A\_Trier\_A\_Renommer", observez chaque fichier qu'il contient, renommez-les et déplacez-les dans le bon dossier. Renommez également les dossiers avec des noms corrects.
+\begin{enumerate}
+ \item Combien y a-t'il de dossiers dans le dossier Nourriture ?
+ \item Combien y a-t'il de fichiers dans le dossier Legumes ?
+ \item Quelle est la taille de l'image avec des carottes ?
+ \item Quelle est l'extension de l'image avec des carottes ?
+ \item Quelle est la taille du dossier Fruits ?
+\end{enumerate}
+\end{exercice}
+
+\begin{exercice} *
+Choisissez une photo prise avec votre smartphone. Donner quelques informations à son sujet en exploitant les métadonnées qui lui sont associées. Quand et où cette photo a-t-elle été prise? Sous quel nom et quel format est-elle stockée dans le smartphone? Quel est son poids? À quelles informations supplémentaires avons-nous accès?
+\textit{Site pour lire les métadonnées : \url{https://www.verexif.com/fr/}}
+\end{exercice}
+
+
+
+\end{document}
\ No newline at end of file
diff --git a/05-stockage.tex b/05-stockage.tex
new file mode 100644
index 0000000000000000000000000000000000000000..0fdbd2e8eae5b3882a596d238e51fb986fb339ac
--- /dev/null
+++ b/05-stockage.tex
@@ -0,0 +1,172 @@
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\usepackage{minted}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{4}
+
+
+\chapter{Stockage de données}
+\section{Introduction}
+
+Les besoins en stockage de données numériques, à l’échelle mondiale, ont été multiplié par plus de vingt au cours de la dernière décennie et devraient dépasser les 50 zettaoctets (1021) d’ici fin 2021. Comme le montre l’infographie ci-dessous, cette quantité de données apparaît finalement dérisoire en comparaison avec ce qui est attendu pour les quinze prochaines années. Les prévisions tablent en effet sur une multiplication par trois ou quatre du volume annuel de données créées tous les cinq ans. Avec ce rythme exponentiel de croissance, le seuil astronomique des 2’000 zettaoctets devrait être franchi à l’horizon 2035.
+
+\begin{figure}[ht!]
+\centering
+\includegraphics[width=8cm]{images/statista.jpeg}
+\end{figure}
+
+Il faudrait se procurer 500 millions de disques durs actuels (100 To) pour être capable de sauvegarder 50 [Zo] ! Cette quantité de données pose autant de problèmes de préservation et d’intégrité des données que de sauvegarde. Sans annoncer les problèmes de places, de consommation électrique, de pollutions dues à la fabrication et au recyclage du matériel vieillissant, de coût et de sauvegarde.
+
+\section{Octet : unités de mesure en informatique}
+Rappel : un octet permet de représenter $2^8$ nombres, soit 256 valeurs différentes.
+\begin{center}
+ \begin{tabular}{| r || c | c | c | c | c | c | c | c |}
+ \hline
+ Symbole & ko & Mo & Go & To & Po & Eo & Zo & Yo \\ \hline
+ Nom & kilooctet & mégaoctet & gigaoctet & téraoctet & pétaoctet & exaoctet & zettaoctet & yottaoctet \\ \hline
+ Valeur & $10^{3}$ & $10^{6}$ & $10^{9}$ & $10^{12}$ & $10^{15}$ & $10^{18}$ & $10^{21}$ & $10^{24}$ \\ \hline
+ \end{tabular}
+\end{center}
+
+Exemples de tailles de fichier (ordre de grandeur):
+\begin{enumerate}
+ \item[-] 2 Ko : fichier texte (2’000 lignes de texte)
+ \item[-] 1 à 20 Mo : photo compressée (jpeg) d’un appareil photo numérique.
+ \item[-] 10 Mo : fichier MP3 d’une durée ~5 min (débit 320 kbit/s)
+ \item[-] 700 Mo : film ~1h30 (compression – qualité DVD)
+ \item[-] 3 Go : film ~1h30 (compression – qualité Blu-ray)
+ \item[-] 25 Go : film Blu-ray
+\end{enumerate}
+
+\section{Support de données}
+
+Quel que soit le type de support, sa taille et son emplacement (local ou distant), ils ont tous certains points communs, comme :
+\begin{enumerate}
+\item Les supports contiennent des 1 et des 0 qu’il s’agisse de votre dernier livre ou de votre musique préférée.
+\item Tous les supports ont un schéma d’organisation des données qui est dépendante du système d’exploitation.
+\item Ils ont tous besoin d’être alimentés électriquement pour fonctionner.
+\item Aucun support n’est fiable à 100 \% !
+\end{enumerate}
+
+\subsection{Supports amovibles}
+Avant d’avoir les clés USB et les cartes mémoires que l’on retrouve dans les téléphones mobiles et les appareils photo, il existait d’autres supports externes. Parmi les premiers supports de données informatiques grand public se trouvait la disquette.
+
+\begin{figure}[ht!]
+\centering
+\includegraphics[width=8cm]{images/floppy-disk.jpg}
+\end{figure}
+
+Inventée dans les années 1970, elle remplaçait les cartes perforées. Quelques exemples de supports amovibles :
+\begin{enumerate}
+\item[] 1970 : disquette 8’’ : 1,2 Mo
+\item[] 1970 : disquette 5,25’’ 360k
+\item[] 1980 : disquette 3,5’’: 1,44 Mo, le standard pendant 20 ans !
+\item[] 1990 : CD-ROM 700Mo (d’autre déclinaison jusqu’à 800Mo)
+\item[] 1990 : ZIP : 700Mo
+\item[] 2004 : DVD-ROM : 4,7 Go
+\item[] 2004 : DVD-ROM double couche : 9,4 Go
+\item[] 2006 : Blu-ray 25Go
+\item[] 2006 : Blu-ray double couche 50Go
+\item[] 2000 : clé USB et carte mémoire
+\end{enumerate}
+
+\subsection{Supports distants}
+Depuis 2010, plusieurs entreprises offrent un service de stockage et de partage de fichiers dans le cloud (ou nuage). Il est donc nécessaire d’avoir une connexion Internet pour accéder à ces espaces de stockage.
+
+\begin{remarques}
+Le terme « cloud » est une forme abrégée de « cloud computing » ou l’informatique en nuage. Un cloud est constitué de serveurs situés à distance et accessibles de n’importe où et à n’importe quel moment via une connexion Internet sécurisée et protégée.
+\end{remarques}
+
+\begin{figure}[ht!]
+\centering
+\includegraphics[width=8cm]{images/Business_Network_Solutions_swisscom.png}
+\end{figure}
+
+Quels sont les avantages et les inconvénients d’avoir ses données dans un cloud qui ne vous appartient pas (dont vous ne gérez pas l’infrastructure) ?
+
+\begin{example} Vous prenez un contrat chez l’entreprise Tartempion 5 chf par mois pour 1 To de place pour vos données.
+\end{example}
+
+\textbf{Avantages principaux du cloud :}
+\begin{enumerate}
+\item[+] Vos données sont accessibles partout, à condition d’être connecté à Internet. Vos données sont donc accessibles depuis votre smartphone, votre PC, etc.
+\item[+] Possibilité de partager ses données. De plus, certains logiciels permettent la modification simultanée et gèrent l’accès concurrent.
+\item[+] Aucun investissement ni installation préalable requise, juste le prix de l’abonnement. Il vous suffit en général d’un navigateur web pour accéder à vos données.
+\item[+] Maintenance, sécurisation des données et mises à jour effectuées par le fournisseur.
+\item[+] Souplesse dans l’espace loué. Si vous avez besoin de 2 To, vous pourrez évoluer votre abonnement.
+\item[+] En cas de panne de votre ordinateur personnel, vous ne perdez pas les données qui sont dans le cloud.
+\end{enumerate}
+\textbf{Inconvénients principaux du cloud :}
+\begin{enumerate}
+\item[-] Pas de contrôle total d’accès aux données par rapport à l’entreprise Tartempion. Confidentialité des données compromise si aucun outil n’est mis en place pour protéger les documents sensibles ;
+\item[-] Savez-vous où sont réellement hébergées vos données ?
+\item[-] Dépendance avec l’entreprise. Si Tartempion fait faillite que se passe-t-il ?
+\item[-] Risque de cyberattaques si les données ne sont pas bien protégées.
+\item[-] Obligation d’être connecté à Internet. Le service peut être dégradé si la liaison n’est pas fiable.
+\item[-] Accès aux fichiers plus lents que sur un support local.
+\item[-] Impact écologique : par ses serveurs nécessaires au fonctionnement du cloud, ce dernier induit une consommation d’énergie croissante.
+
+\end{enumerate}
+
+\section{Stratégie de sauvegarde}
+\subsection{Introduction}
+Aucun support de stockage n’a une durée de vie illimitée et aucun support de stockage n’est fiable à 100\%. Le risque zéro n’existe pas. Une perte de données numériques est donc très vite arrivée. Les causes principales sont:
+\begin{enumerate}
+\item[o] des défaillances techniques matérielles comme un disque dur en panne ou une clé usb qui n’est plus accessible;
+\item[o] des défaillances logicielles comme un fichier corrompu suite à une écriture erronée par le système d’exploitation, une erreur de synchronisation;
+\item[o] des défaillances humaines comme un fichier effacé, un fichier écrasé ou une clé usb perdue;
+\item[o] des catastrophes naturelles comme des incendies ou des dégâts des eaux;
+\item[o] des programmes malveillants et des attaques de virus ou de ransomware;
+\item[o] le vol du matériel comme votre téléphone portable, un disque d’un serveur, une clé usb, une carte mémoire;
+\end{enumerate}
+Le monde professionnel indique une durée de vie moyenne de 5 ans pour un disque dur mécanique ou un disque type SSD. Une clé usb ou une carte mémoire de qualité pourrait tenir 10 ans. Le cloud offert par les entreprises de stockage a une durée de vie quasi illimitée, du moins celle de l’entreprise.
+
+\subsection{Stratégie 3-2-1 de sauvegarde de données}
+
+La stratégie de sauvegarde 3-2-1 représente le b-a-ba et le minimum de la protection des données. Mise au point par un photographe souhaitant protéger ses clichés dans les années 1920, cette stratégie est devenue une référence, car elle permet une protection optimale des données, quel que soit leur format.
+
+Le concept de base de la stratégie 3-2-1 repose sur trois principes :
+\begin{enumerate}
+ \item[->] \textbf{{\huge 3} copies de vos données:} La stratégie recommande d’avoir 2 copies plus la source. Avec trois copies dont deux sauvegardes, le risque que les trois copies aient un problème en même temps est très faible surtout si elles sont stockées sur des supports différents.
+
+ \item[->] \textbf{{\huge 2} supports différents:} La notion de supports différents est essentielle quand on parle de données numériques, car quel est l’intérêt d’avoir deux sauvegardes si elles sont stockées sur le même support ? En cas d’incident, toutes les données seraient perdues. Il est donc important que la source et au moins une de ses copies soient sauvegardées sur des supports différents.
+
+ \item[->] \textbf{{\huge 1} copie hors site:} Quel que soit le support (NAS, disque dur externe, lecteur de bande, etc.), aucune stratégie de sauvegarde de données numériques ne peut être considérée comme sûre si au moins une des copies n’est pas stockée « hors site ». Le récent incendie du 10 mars 2021 d’OVH en est la preuve. En effet, certains utilisateurs avaient leur site en production sur un serveur et leurs copies sur un autre serveur. Certes, les copies étaient sur des supports différents, mais elles étaient stockées dans le même datacenter. Comme une grande partie du site contenant ces serveurs a cessé de fonctionner à cause de l’incendie, aucune des copies n’était utilisable. Or, si au moins une de ces copies avait été stockée chez un autre hébergeur (hors site), ces utilisateurs auraient pu rétablir rapidement leurs services.
+\end{enumerate}
+
+Malgré tout les stratégies de sauvegarde ont leurs limites ! La quantité de données à sauvegarder peut prendre trop de temps et poser des problèmes d’intégrité des données. L’externalisation des sauvegardes selon la méthode 3-2-1 soulève aussi la question de la protection des données.
+
+Et si vous avez bien conservé votre donnée numérique. Serez-vous capable de la relire ?
+
+\section{Exercices}
+
+\begin{exercice}
+En réfléchissant aux derniers cours, essayez de calculez la taille que ferait un fichier texte \texttt{blabla.txt} contentant la chaîne de caractères \texttt{blablabla}.
+Vérifiez ensuite en le créant sur votre ordinateur.
+\end{exercice}
+
+
+\begin{exercice}
+Reprenez le dossier \texttt{Nourriture} de l'exercice 2 du chapitre précédent. Compressez-le et comparez sa taille originale avec sa taille une fois compressé.
+\end{exercice}
+
+\begin{exercice}
+Téléchargez l'image \texttt{sample\_1920x1280.bmp} en haute définition depuis moodle puis convertissez-la dans les formats suivants en comparant la taille et la qualité de l'image à chaque étape.
+
+\textit{Utilisez par exemple le site \url{https://online-converting.com/image} pour faire la conversion en jpg et \url{https://online-converting.com/image/convert2bmp} pour le bmp}
+\begin{center}
+ \begin{tabular}{| l || c | r | }
+ \hline
+ Format & Taille (ko) & Qualité visuelle \\ \hline
+ .bmp en 24 bits & & \\ \hline
+ .bmp en 8 bits & & \\ \hline
+ .jpg & & \\ \hline
+ .png & & \\
+ \hline
+ \end{tabular}
+\end{center}
+\end{exercice}
+
+\end{document}
\ No newline at end of file
diff --git "a/06-structure_de_donn\303\251es.tex" "b/06-structure_de_donn\303\251es.tex"
new file mode 100644
index 0000000000000000000000000000000000000000..26a2c93cb9d271ac13e547f54ab44be72ce1e63f
--- /dev/null
+++ "b/06-structure_de_donn\303\251es.tex"
@@ -0,0 +1,1118 @@
+\documentclass[11pt, a4paper]{book}
+\input{package}
+\pgfplotsset{compat=1.17}
+
+\begin{document}
+
+\setcounter{chapter}{5}
+\chapter{Structure de données finie et bases d'algorithmique}
+
+
+
+\section{La variable}
+\subsection{Définition}
+
+\begin{defi}
+Une {\it structure de données} est une structure logique destinée à stocker et organiser des données de façon à faciliter leur utilisation. Parmi ces structures, on retrouve la {\it variable}, le {\it tableau}, le {\it graphe}, l'{\it arbre}....
+\end{defi}
+
+En programmant en Makecode Microbit ou en Python nous aurons souvent besoin de faire appel à des variables. Nous allons maintenant les définir:
+
+\begin{defi}
+La {\it variable} est une structure de données finie. C'est un élément qui associe un nom (l'identifiant de la variable) à une valeur. Nous pouvons différencier la {\it constante} qui, une fois qu'une valeur lui a été attribuée, ne change plus, et la {\it variable mutable} qui elle peut changer de valeur tout au long du programme.
+
+\end{defi}
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item En Microbit, la variable est créée avant qu'une valeur ne lui soit attribuée. Pour régler ce problème, dès qu'une variable est créée, Microbit lui associe la valeur 0 par défaut. La valeur peut être ensuite modifiée en utilisant le bloc:
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_1}
+\end{center}
+\item En Python, une variable est créée lorsqu'on lui assigne une valeur.
+
+\vskip.5cm
+\begin{lstlisting}[language=python]
+variable = 5
+nombre_eleve = 16
+\end{lstlisting}
+
+\end{enumerate}
+\end{remarques}
+
+
+
+
+
+
+
+\begin{exercice}
+ Regarder le programme suivant, et deviner ce qu'il va se passer quand on va activer le Microbit:
+
+\begin{center}
+\includegraphics[scale=.6]{ch6_images/var_2}
+\end{center}
+\end{exercice}
+
+
+\begin{exercice}
+Regarder le programme en python suivant et deviner ce qu'il va se passer quand on va l'exécuter:
+\vskip.5cm
+\begin{center}
+\begin{lstlisting}[language=python]
+eleve=20
+enseignant=2
+print(eleve)
+print(enseignant)
+
+\end{lstlisting}
+\end{center}
+\end{exercice}
+
+
+
+
+\subsection{Nom d'une variable}
+% Edoardo (14.11.2021)
+Le nom choisi pour chaque variable est important pour faciliter la lisibilité de votre programme. Il vous permet de vous souvenir du rôle de chaque variable. Imaginez des milliers de blocs d'instructions Microbit dans votre programme avec des centaines de variables. Si vous nommez vos variables avec des noms peu explicites comme v1, v2, v3, v4 ... v100 seriez-vous capable de retrouver à quoi sert chaque variable ?
+
+Bien que nous soyons toujours libre d'écrire le nom d'une variable comme bon nous semble, un certain nombre de convention sont utilisées:
+\begin{enumerate}[1)]
+\item Un nom pertinent : essayez d'être le plus précis et concis possible, mais préférez la compréhension à la longueur du nom de la variable.
+\item Toujours commencer par une minuscule
+\item Pas de caractères spéciaux ou d'accents
+\item Si une variable est un mot composé, deux solutions s'offrent à vous :
+\begin{enumerate}[a)]
+\item Notation {\it camel case} : voiciUnExemple. Chaque nouveau mot commence par une majuscule.
+\item Notation {\it snake case} : voici\_ un\_ exemple. Chaque nouveau mot est séparé par un {\it underscore}:\_.
+
+\end{enumerate}
+\end{enumerate}
+
+\begin{exercice}
+Parmi les noms de variables suivants, lesquels respectent les conventions d'écritures des variables?
+\begin{enumerate}
+\item laVariable
+\item la variable
+\item nom\_de\_famille
+\item la\_quantité
+\item nombreDeVoitures
+\item prenom
+\item leNumeroDeTelephone
+\item le\_ Nom
+\item iztrdr3fsfs
+
+\end{enumerate}
+\end{exercice}
+
+
+\subsection{\'Evolution d'une variable}
+
+\subsubsection{En Microbit}
+
+En Microbit il existe deux façon de modifier une variable. La première consiste à lui attribuer une valeur, comme on l'a vu précédemment, avec le bloc {\it Définir variable à ...}:
+
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_1}
+\end{center}
+
+L'autre façon de modifier une variable consiste à lui ajouter ou soustraire un certain nombre avec le bloc:
+
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_3}
+\end{center}
+
+On peut dire qu'on {\bf incrémente} la variable {\it test\_2}. {\bf Incrémenter} signifie ajouter une certaine valeur, souvent 1, à un nombre ou une variable. Dans le bloc précédent, la valeur de {\it test\_2} va changer et son contenu passera de 0 à 1.
+
+On parler de {\bf décrémenter} quand on soustrait une certaine valeur. Par exemple, dans le bloc suivant la variable {\it test\_2} qui valait 1, voit son contenu passer de 1 à 0.
+
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_3a}
+\end{center}
+
+Il est aussi possible de mettre un calcul dans l'attribution d'une valeur à la variable. Le prochain bloc d'instruction définit la valeur de la variable {\it var\_1} au résultat du calcul $2+4$.
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_5}
+\end{center}
+
+Ou même d'utiliser la valeur de la variable elle-même:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_6}
+\end{center}
+Dans ce cas de figure, on additionne 4 au contenu de la {\it var\_1}. La variable {\it var\_1} verra ainsi sa valeur actuelle incrémentée de 4.
+
+\subsubsection{En Python}
+
+En Python, pour donner une valeur à une variable, nous allons utiliser le signe "=":
+
+\vskip.5cm
+\begin{lstlisting}
+classe=16
+\end{lstlisting}
+
+Pour incrémenter une variable nous allons écrire:
+
+\vskip.5cm
+\begin{lstlisting}
+classe=classe+1
+\end{lstlisting}
+
+Cette écriture peut prêter à confusion:
+
+\begin{enumerate}
+\item Elle n'a pas de sens mathématique.
+\item Le signe "=" n'a donc pas la même signification en informatique et en mathématique!
+\item Il s’agit d’un symbole d’affectation (nous plaçons un certain contenu dans une variable) et non un symbole d’égalité.
+\item Il faut le lire comme: {\it la variable classe prend comme nouvelle valeur son ancienne valeur à laquelle on ajoute 4.}
+\end{enumerate}
+
+
+Il est donc très important de comprendre cette finesse liée à la programmation !
+
+\subsection*{Exercices}
+
+\begin{exercice}
+Quel nombre sera affiché par le programme?
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_4}
+\end{center}
+\end{exercice}
+
+\begin{exercice}
+Quel nombre sera affiché par le programme?
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_7}
+\end{center}
+\end{exercice}
+
+\begin{exercice}
+Quel nombre sera affiché par le programme?
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_8}
+\end{center}
+\end{exercice}
+
+
+
+\begin{exercice}
+Quels nombres seront affichés par le programme?
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_9}
+\end{center}
+\end{exercice}
+
+
+\begin{exercice}
+Que fait ce programme?
+
+\vskip.5cm
+\begin{lstlisting}
+argent=10
+argent=argent+5
+argent=argent-3
+argent=argent*2
+print(argent)
+\end{lstlisting}
+\end{exercice}
+
+
+\begin{exercice}
+Que fait ce programme?
+
+\vskip.5cm
+\begin{lstlisting}
+benefice=12
+benefice=benefice+benefice
+benefice=benefice-benefice
+print(benefice)
+\end{lstlisting}
+\end{exercice}
+
+\begin{exercice}
+Que fait ce programme?
+
+\vskip.5cm
+\begin{lstlisting}
+benefice = 12
+perte = -3
+benefice = benefice + perte
+perte = perte + benefice
+benefice = benefice + benefice
+print(benefice)
+print(perte)
+\end{lstlisting}
+\end{exercice}
+
+
+
+\begin{exercice}
+Que fait ce programme?
+
+\vskip.5cm
+\begin{lstlisting}
+premier = 15
+deuxieme = 10
+difference = premier - deuxieme
+deuxieme = premier + difference
+premier = difference - deuxieme
+difference = deuxieme - premier
+print(premier)
+print(deuxieme)
+print(difference)
+\end{lstlisting}
+\end{exercice}
+
+
+
+\section{Les types}
+
+\subsection{Motivation}
+
+\subsubsection{En Microbit}
+
+Une variable n'aura pas toujours comme valeur un nombre. Dans l'onglet {\it Avancé} ensuite {\it Texte} de l'éditeur makecode.microbit.org, il est possible de choisir le symbole " " représentant une chaîne de caractères. Ainsi il est possible d'attribuer comme valeur une chaîne de caractères:
+
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_10}
+\end{center}
+
+Ainsi la variable {\it var\_2} est une chaîne de caractères. Essayons d'imaginer ce qu'il va se passer si nous faisons le programme suivant:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_11}
+\end{center}
+
+Que se passe-t-il?
+
+\vskip4cm
+
+Lorsque Microbit repère un problème, il le signale. Dans l'exercice qui suit, essayez de comprendre le problème qui a été rencontré:
+
+\begin{exercice}
+Quel problème a été rencontré dans chacun de ces programmes?
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_12}
+\end{center}
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_13}
+\end{center}
+
+\end{exercice}
+
+\begin{remarque}
+Chaque langage de programmation aura ses propres spécificités par rapport aux différents types d'erreurs qui peuvent apparaître. Par exemple, en Microbit, le programme ci-dessous fonctionne, et affiche 22!!
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_14}
+\end{center}
+\end{remarque}
+
+\subsubsection{En Python}
+
+En Python, contrairement à Microbit, une variable peut d'abord valoir un nombre puis ensuite un caractère ou un mot.
+
+
+\vskip.5cm
+\begin{lstlisting}
+a=2
+print(a)
+a="bonjour"
+print(a)
+\end{lstlisting}
+\vskip.5cm
+
+Le programme précédent afficher d'abord le nombre 2 puis le mot "bonjour".
+
+\begin{exercice}
+A votre avis, que fait le programme suivant?
+
+{\it (indication: le programme fonctionne})
+
+\vskip.5cm
+\begin{lstlisting}
+a=5
+b="2"
+d=2
+c=a*d
+print(c)
+c=a*b
+print(c)
+\end{lstlisting}
+\end{exercice}
+\vskip.5cm
+
+\subsection{Définition}
+
+On a vu que suivant la valeur attribuée à une variable, le programme va permettre de faire certaines actions et en refuser d'autre. On définit cela formellement:
+
+\begin{defi}
+Le {\it type} d'une variable est l'interprétation que fera l'ordinateur de la valeur associée à cette variable. Ce type pourra être, entre autre, un nombre entier ({\it integer}), un nombre décimal ({\it float}), une chaîne de caractère ({\it string}), un booléen ({\it boolean})...
+\end{defi}
+
+Selon le langage de programmation que l'on utilise, le type d'une variable peut ou ne peut pas être changé. On parlera de {\bf typage statique} ou {\bf typage dynamique}. Par exemple, Microbit a un typage statique (Une variable définit comme un nombre ne peut plus être changé en une chaîne de caractères) alors que Python a un typage dynamique.
+
+On regarde maintenant chacun de ces types en détail.
+
+
+
+\subsection{Les types {\it entier} (integer) et {\it décimal} (float)}
+
+La première catégorie de variables avec laquelle on aimerait travailler est le nombre. Cette catégorie se divise en 2 catégories principales. Comme nous l'avons vu, un nombre entier (positif ou négatif) n'utilise pas le même encodage qu'un nombre à virgule (qui utilise plutôt un encodage sous la forme d'une écriture scientifique). L'espace mémoire n'est donc pas le même.
+
+\begin{defi}
+Le type {\it entier} (integer) caractérise une variable dont la valeur est un nombre entier. Le type {\it décimal} (float) caractérise une variable dont la valeur est un nombre décimal.
+\end{defi}
+
+Pour un programme, {\bf 1} sera un {\it entier} alors que {\bf 1.0} sera un {\it décimal}.
+
+Pour Microbit ou Python, ainsi que pour de nombreux langages de programmation, il n'y a pas de problèmes à passer d'un nombre entier à un nombre décimal au cours du programme sans devoir changer de variable et de type.
+
+
+\subsection{Le type {\it chaîne de caractères} (string)}
+
+Une autre valeur que peut prendre une variable est la chaîne de caractères, ou le type {\it string}.
+
+\begin{defi}
+Le type {\it chaîne de caractères} (string) caractérise une variable dont la valeur est une suite de caractères. Cette suite peut aussi contenir des nombres qui sont alors interprétés comme des caractères.
+\end{defi}
+
+Le programme suivant n'a par exemple aucune signification pour Microbit:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_15}
+\end{center}
+
+Le même problème apparait en Python. Un message d'erreur nous dira que nous ne pouvons pas faire "+" entre un "int" et un "str":
+
+\vskip.5cm
+\begin{lstlisting}
+a=5
+b="2"
+c=a+b
+\end{lstlisting}
+\vskip.5cm
+
+
+Nous ne pouvons pas effectuer d'opération avec les chaînes des caractères (sauf le + que l'on verra par la suite). Il est par contre possible de comparer des chaînes de caractères:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_16}
+\end{center}
+Dans ce cas, comme la lettre a (contenu dans {\it var\_1}) se trouve avant b (contenu dans ({\it var\_2}) en prenant compte de l'ordre alphabétique, le texte contenu dans la {\it var\_1} s'affiche. Le Microbit affiche le texte a.
+
+% Edoardo, 17.11.2021
+Prenons un autre exemple:
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_16a}
+\end{center}
+Dans ce cas, Microbit affiche C. Pourquoi le programme considère t'il que C est plus petit que b ? Tout simplement parce qu'il se base sur son code ASCII pour comparer ! Le code ASCII de C est 67 (base 10) alors que b est 98 (base 10).
+% end Edoardo
+
+\newline
+
+L'opération principale sur les chaînes de caractères est la {\bf concaténation}:
+
+\begin{defi}
+La {\it concaténation} est une action qui prend en entrée plusieurs chaînes de caractères et renvoie une unique chaîne de caractères composée des différentes chaînes de caractères misent bout à bout.
+\end{defi}
+
+Par exemple, {\it concaténation("abc"; "d2")="abcd2"}.
+
+\
+
+Dans Microbit, l'opération + a le même effet que la concaténation si on lui donne deux chaînes de caractères. Ainsi, le programme suivant donnera "32":
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_17}
+\end{center}
+
+Alors que le programme ci-dessous va afficher 5:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_18}
+\end{center}
+
+En Python, la concaténation passe par le +. Le programme suivant affichera "5d":
+
+\vskip.5cm
+\begin{lstlisting}
+a="5"
+b="d"
+c=a+b
+print(c)
+\end{lstlisting}
+\vskip.5cm
+
+\subsubsection{Affichage d'une variable}
+
+Les guillemets précisent qu'on a à faire à une chaine de caractères. Cette différence est importante comme on peut le noter dans le programme suivant:
+
+\vskip.5cm
+\begin{lstlisting}
+test=25
+print(test)
+print("test")
+\end{lstlisting}
+\vskip.5cm
+
+Ce programme afficher d'abord la variable test, donc 25. Puis affichera le texte "test".
+
+\subsection{Le type {\it booléen} (boolean)}
+
+En informatique nous devons souvent tester une condition ("le nombre suivant est il pair?", "la variable vaut-elle 2?"...). Pour cela, nous avons besoin d'un type de variable qui ne correspondra ni à un nombre ni à une chaîne de caractères mais qui pourra nous permettre de résoudre un problème du type: si "il pleut", alors "il faut prendre un parapluie". Le test "il pleut" peut prendre deux valeurs: soit c'est vrai, soit c'est faux. C'est ce que nous appelons une {\bf variable booléenne}:
+
+\begin{defi}
+Le type {\it booléen} caractérise une variable qui peut avoir une des deux valeurs suivantes: "vrai" ou "faux".
+\end{defi}
+
+\subsubsection{En Microbit}
+% Edoardo 27.11.2021
+Dans Microbit, le type booléen est noté par un hexagone vert. Dans le cas suivant la variable {\it var\_1} est initialisée avec la valeur vrai ({\it true}).
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_19a}
+\end{center}
+% End Edoardo
+
+On remarque qu'une variable booléenne ne peut pas être affichée comme un nombre dans Microbit:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_19}
+\end{center}
+
+Mais il peut être affiché comme un texte (le Microbit affiche {\it true} même si votre éditeur de code est configuré en français):
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_20}
+\end{center}
+
+
+\subsubsection{En python}
+
+En Python, un booléen va souvent être sous la forme d'une comparaison ou d'une égalité. On voudra par exemple vérifier que l'âge de quelqu'un est strictement inférieur à 12 ans pour avoir une réduction:
+
+\vskip.5cm
+\begin{lstlisting}
+if age < 12:
+ print("Vous avez le droit à une réduction")
+\end{lstlisting}
+\vskip.5cm
+
+"age<12" est un booléen, c'est soit vrai, soit faux. Si c'est vrai, alors on affichera "Vous avez le droit à une réduction". Et si c'est faux, rien ne sera fait.
+
+D'autres comparaisons peuvent être faites:
+
+\begin{enumerate}
+ \item l'égalité (attention au double "=" qui montre que l'on vérifie si il y a égalité. le symbole "=" seul est gardé pour assigner une valeur à une variable):
+ \vskip.5cm
+\begin{lstlisting}
+if age == 12:
+ print("Vous avez 12 ans.")
+\end{lstlisting}
+ \vskip.5cm
+ \item la différence:
+ \vskip.5cm
+\begin{lstlisting}
+if age != 12:
+ print("Vous n'avez pas 12 ans.")
+\end{lstlisting}
+ \vskip.5cm
+ \item plus petit ou égal:
+ \vskip.5cm
+\begin{lstlisting}
+if age <= 12:
+ print("Vous avez 12 ans ou moins.")
+\end{lstlisting}
+ \vskip.5cm
+\end{enumerate}
+
+
+
+
+\subsection{Le type {\it liste} (list)}
+
+On peut avoir besoin de rassembler en une même variable un ensemble d'éléments: par exemple les noms des élèves d'une classe, ou les cartes d'un jeu de cartes. Pour cela, il existe un type qui est la {\it liste}:
+
+\begin{defi}
+Le type {\it liste} caractérise une variable qui contient une série d'éléments qui peuvent être ou ne pas être du même type (cela dépend du langage de programmation).
+\end{defi}
+
+En Python, les éléments d'une liste ne sont pas forcément du même type et un élément d'une liste peut aussi être une liste. Pour créer une liste contenant les éléments 1,2 et 3 nous écrirons:
+
+\vskip.5cm
+\begin{lstlisting}
+lst = [1,2,3]
+\end{lstlisting}
+\vskip.5cm
+
+Une liste peut être affiché avec la commande: print(lst). On peut rajouter un élément à une liste en l'additionnant (comme pour une concaténation) à la liste existante. Si par exemple nous voulons rajouter le 4 dans notre liste, nous écrirons:
+
+\vskip.5cm
+\begin{lstlisting}
+lst = lst + [4]
+\end{lstlisting}
+\vskip.5cm
+
+Si nous voulons accéder à un élément d'une liste, nous indiquons l'indice de l'élément recherché:
+\begin{itemize}
+\item lst[0] correspond au premier élément de la liste lst, qui ici est 1.
+\item lst[1] correspond au deuxième élément de la liste lst, qui ici est 2... et ainsi de suite.
+\end{itemize}
+
+
+\subsection*{Exercices}
+
+\begin{exercice}
+Définir quel type (entier, décimal, chaîne de caractères, booléen,liste) devrait-on associer à une variable si cette variable représente:
+\begin{enumerate}[a)]
+\item l'âge d'une personne;
+\item si il pleut;
+\item les prénoms des enfants d'une famille;
+\item un mois de l'année;
+\item le prix d'un vêtement;
+\item si une personne est majeure;
+\item une année de naissance;
+\item les sports pratiqués par un élève;
+\item l'aire d'une forme géométrique;
+\item le nom d'une personne;
+\item si un végétal donné est un fruit;
+\end{enumerate}
+\end{exercice}
+
+
+
+\begin{exercice}
+Donner le type de chaque variable de ce programme puis dire si des erreurs vont être reconnues par Microbit (tester le programme si besoin):
+\begin{center}
+\includegraphics[scale=.7]{ch6_images/var_21}
+\end{center}
+\end{exercice}
+
+
+\begin{exercice}
+Reconnaître les différents types apparaissant dans ce programme:
+\vskip.5cm
+\begin{lstlisting}
+pi = 3.14
+rayon = 5
+petit_et_grand = [40,100]
+circonference = pi*2*rayon
+reponse = "C'est un petit cercle"
+if circonference < petit_et_grand[0]:
+ print(reponse)
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+\begin{exercice}
+Dire ce qui va être affiché pour chacun des programmes suivants:
+\begin{enumerate}
+
+\item
+\vskip.5cm
+\begin{lstlisting}
+x = 5
+y = 12
+print(x)
+print("y")
+print(x < y)
+\end{lstlisting}
+\vskip.5cm
+
+\item
+\vskip.5cm
+\begin{lstlisting}
+x = 12
+y = 2 * x
+print(x == 2 * y)
+print(y == 2 * x)
+\end{lstlisting}
+\vskip.5cm
+
+\end{enumerate}
+\end{exercice}
+
+
+\section{Bases de l'algorithmique}
+
+Nous allons commencer à discuter ce que représente un algorithme et comment peut-on décomposer une tâche en tâches plus élémentaires dans le but de résoudre un problème ou d'accomplir un travail. La pensée algorithmique est un pan essentiel de l'informatique. Une fois correctement formulée ou précisée, elle permet, via un langage de programmation, d'implémenter différents traitements sur les machines (par exemple votre ordinateur).
+
+
+\subsection{Définition}
+\begin{defi}
+Un algorithme est une suite finie et non-ambiguë d'opérations ou d'instructions permettant de résoudre un problème.
+
+\end{defi}
+
+On connaît depuis l'antiquité des algorithmes sur les nombres, comme par exemple l'algorithme d'Euclide qui permet de calculer le {\it pgdc}\footnote{pgdc: plus grand diviseur commun.} de deux nombres entiers.
+
+Pour le traitement de l'information, on a développé des algorithmes opérant sur des données non numériques : les algorithmes de tri, qui permettent par exemple de ranger par ordre alphabétique une suite de noms, les algorithmes de recherche d'une chaîne de caractères dans un texte, ou les algorithmes d'ordonnancement, qui permettent de décrire la coordination entre différentes tâches, nécessaire pour mener à bien un projet.
+
+Algorithme provient du nom du mathématicien perse {\it Al-Khawarizmi} ($\sim$ 820), le père de l'algèbre.
+
+\subsection{Les structures de contrôle}
+
+Pour construire un algorithme, nous avons besoin d'une suite d'instructions. Ces instructions sont prises parmi un ensemble de {\it fonctions} pour Python ou de {\it blocs} pour Microbit et sont exécutées les unes après les autres. Afin de {\it répéter} une même action un certain nombre de fois ou de faire une action {\it si} une condition est vraie, nous avons besoin de structure de contrôle:
+
+\begin{defi}
+Une {\it structure de contrôle } détermine dans quel ordre vont être exécutées les actions. Il en existe trois:
+\begin{enumerate}
+\item La {\it séquence}: les instructions sont effectuées les unes après les autres
+\item La {\it sélection}: les instructions sont effectuées si une certaine
+ condition est respectée (par exemple la structure {\it si})
+\item La {\it répétition}: les instructions sont répétées en boucle {\it tant qu}'une certaine condition est respectée.
+\end{enumerate}
+\end{defi}
+
+Ses structures sont récurrentes et apparaissent toujours sous une forme ou sous une autre dans presque tous les langages de programmation. Nous allons maintenant étudier les différentes structures qui sont à notre disposition.
+
+\subsection{La condition {\it si} (if)}
+
+\subsubsection{le {\it if} simple}
+
+Une des premières structures qui nous intéresse est la structure de sélection {\it si} ou {\it if} en anglais. Sa syntaxe en pseudo-code est de la forme:
+
+\
+
+\hskip5cm {\it si} {\bf condition}
+
+\hskip+6cm alors {\bf action}
+
+\
+
+Le {\it si} vérifie si la {\bf condition} est {\it vraie} et si c'est le cas, la ligne avec l'{\bf action} est effectuée. La {\bf condition} est donc forcément un {\bf booléen} qui sera soit vrai soit faux.
+
+Par exemple, on peut avoir le code suivant:
+
+\
+
+\hskip5cm {\it si} {\bf il pleut}
+
+\hskip+6cm alors {\bf je prends mon parapluie}
+
+\
+
+{\bf il pleut} est bien un booléen. Cela est soit vrai soit faux. Si cela est vrai, la ligne {\bf je prends mon parapluie} est exécutée. Si c'est faux, cette ligne ne sera pas évaluée.
+
+Pour un code Microbit, cela donnerait:
+
+\begin{center}
+\includegraphics[scale=.45]{ch6_images/var_22}
+\end{center}
+
+En Python, l'expression d'une condition commence par un {\bf if}, suivi d'un booléen puis de deux points ":". Tout ce qu'il faudra faire si la condition est vérifiée doit être indenté:
+
+\vskip.5cm
+\begin{lstlisting}
+variable=1
+if variable == 2:
+ print(variable)
+\end{lstlisting}
+\vskip.5cm
+
+L'indentation est très importante. Pour le comprendre, voici trois exemple et ce qu'ils affichent:
+
+\vskip.5cm
+\begin{lstlisting}
+variable=1
+if variable == 2:
+ print(variable)
+ print("fin")
+\end{lstlisting}
+\vskip.5cm
+
+Dans ce programme, rien n'est fait. La condition n'est pas vérifiée, donc les instructions incluses dans le {\bf if} (celles avec une indentation) ne sont pas effectuées.
+
+\vskip.5cm
+\begin{lstlisting}
+variable=1
+if variable == 2:
+ print(variable)
+print("fin")
+\end{lstlisting}
+\vskip.5cm
+
+Dans ce programme, "fin" est affiché. La condition du {\bf if} n'est pas vérifiée et donc l'instruction "print(variable)" n'est pas faite. Par contre, en retournant à la ligne par la suite, on indique que nous sortons du {\bf if} et l'instruction "print("fin")" est effectué.
+
+\subsubsection{Multiples conditions}
+
+
+Une condition {\it si} peut vérifier d'autres conditions, qui débutent par {\it sinon si} (else, if) et peut aussi finir par un {\it sinon} (else) qui ne sera exécuté que si toutes les autres conditions étaient fausses:
+
+
+\hskip+5cm {\it Si} {\bf j'ai entre 500 et 1000 .-}
+
+\hskip+6cm alors {\bf je pars en Europe}
+
+\hskip+5cm {\it sinon, si} {\bf j'ai entre 1000 et 2000 .-}
+
+\hskip+6cm alors {\bf je pars en Asie}
+
+\hskip+5cm {\it sinon, si} {\bf j'ai plus que 2000.-}
+
+\hskip+6cm alors {\bf je pars en Amérique}
+
+\hskip+5cm {\it sinon} {\bf je reste chez moi}
+
+\
+
+Le programme équivalent en Microbit serait:
+
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_23}
+\end{center}
+
+\
+
+En python, une condition commence par un {\bf if} et est suivi par autant de {\bf elif} (contraction de {\it else, if} (sinon, si)) nécessaire et fini, si besoin, par un {\bf else} (sinon) qui lui ne vérifie aucune condition.
+
+\vskip.5cm
+\begin{lstlisting}
+if 500 <= argent and argent <= 100 :
+ print("Europe")
+elif 1000 <= argent and argent <= 2000:
+ print("Asie!")
+elif 2000 <= argent:
+ print("Amerique!!!")
+else:
+ print("Maison...")
+\end{lstlisting}
+\vskip.5cm
+
+\subsubsection*{Exercices}
+
+
+\begin{exercice}
+Qu'affiche ce programme?
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_24}
+\end{center}
+\end{exercice}
+
+\begin{exercice}
+Qu'affiche ce programme?
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_25}
+\end{center}
+\end{exercice}
+
+\begin{exercice}
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_26}
+\end{center}
+Dans chacun des cas suivants, dire ce qu'affichera le programme:
+\begin{enumerate}
+ \item si $var\_1=5$, $var\_2=9$ et $var\_3=2$.
+ \item si $var\_1=7$, $var\_2=3$ et $var\_3=3$.
+ \item si $var\_1=3$, $var\_2=5$ et $var\_3=6$.
+ \item si $var\_1=4$, $var\_2=4$ et $var\_3=4$.
+\end{enumerate}
+\end{exercice}
+
+\newpage
+\begin{exercice}
+Qu'affiche le programme suivant:
+\vskip.5cm
+\begin{lstlisting}
+nombre_1 = 3
+nombre_2 = 7
+nombre_3 = 10
+if nombre_1 == nombre_2 :
+ print(nombre_1)
+elif nombre_2 < nombre_3 :
+ print(nombre_2)
+elif nombre_3 == 10 :
+ print(nombre_3)
+if nombre_2 != 7 :
+ print(nombre_2)
+else :
+ print(nombre_3)
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+
+\begin{exercice}
+
+
+\vskip.5cm
+\begin{lstlisting}
+if x < y :
+ if x < z :
+ print(z)
+ else :
+ print(x)
+elif x < z :
+ if x > y :
+ print(y)
+ elif y < z :
+ print(z)
+if z < y :
+ print(y)
+print(x)
+
+\end{lstlisting}
+\vskip.5cm
+Dans chacun des cas suivants, dire ce qu'affichera le programme:
+\begin{enumerate}
+ \item si $x=3$, $y=5$ et $z=1$.
+ \item si $x=3$, $y=5$ et $z=9$.
+ \item si $x=9$, $y=5$ et $z=1$.
+ \item si $x=6$, $y=3$ et $z=4$.
+\end{enumerate}
+
+\end{exercice}
+
+\subsection{La boucle {\it répéter} (repeat)}
+
+\subsubsection{En Microbit}
+
+La condition {\it si} est une structure nous permettant de coder des conditions mais elle n'est pas suffisante. Pour certain problème, nous avons besoin de répéter une certain nombre de fois une action. Le nombre de répétition peut-être connue à l'avance ou ne pas l'être.
+
+Nous aimerions, par exemple, doubler la valeur de $var\_1$ 5 fois de suite. La première possibilité est la suivante:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_27}
+\end{center}
+
+Lorsque nous répétons plusieurs fois la même action, il est plus facile d'utiliser une boucle {\it répéter} (repeat), qui effectuera une même tâche un certain nombre de fois:
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_28}
+\end{center}
+
+L'intérêt de {\it répéter} est que nous pouvons aussi utiliser une variable pour le nombre de fois que nous voulons répéter une tâche et donc obtenir une grande flexibilité dans notre programme.
+
+\subsubsection{En Python}
+
+En Python, pour répéter une même tâche on peut utiliser la fonction {\it for}, qui permet de faire de nombreuses choses, dont la répétition. Considérons le programme suivant qui répète plusieurs fois la même tâche:
+
+\vskip.5cm
+\begin{lstlisting}
+x = 2
+x = 2 * x
+x = 2 * x
+x = 2 * x
+x = 2 * x
+x = 2 * x
+print(x)
+\end{lstlisting}
+\vskip.5cm
+
+On peut écrire le programme suivant qui effectue la même tâche, mais en moins d'instructions:
+
+\vskip.5cm
+\begin{lstlisting}
+x = 2
+for k in range (5) :
+ x = 2 * x
+print(x)
+\end{lstlisting}
+\vskip.5cm
+
+On verra par la suite que la fonction {\it for} permet de faire beaucoup plus qu'une répétition. Dans l'écriture {\it for k in range(5)}, $k$ est une variable et pourrait être nommée avec le nom qu'on souhaite. Il faut par contre éviter de le nommer avec un nom de variable déjà utilisé précédemment.
+
+\subsubsection*{Exercices}
+
+
+\begin{exercice}
+Que fait le programme suivant?
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_29}
+\end{center}
+\end{exercice}
+
+
+\begin{exercice}
+Que fait le programme suivant?
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_30}
+\end{center}
+\end{exercice}
+
+
+\begin{exercice}
+\begin{enumerate}
+\item Que fait ce programme si {\it flocon\_x} = 2?
+\item Que fait ce programme si {\it flocon\_x} = 4?
+\end{enumerate}
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_31}
+\end{center}
+\end{exercice}
+
+\begin{exercice}
+Que fait le programme suivant quand on l'exécute?
+\vskip.5cm
+\begin{lstlisting}
+i = 3
+for k in range (7) :
+ print(i)
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+\begin{exercice}
+Que fait le programme suivant quand on l'exécute?
+\vskip.5cm
+\begin{lstlisting}
+i = 3
+for k in range (7) :
+ i = 2 * i
+print(i)
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+\begin{exercice}
+Que fait le programme suivant quand on l'exécute?
+\vskip.5cm
+\begin{lstlisting}
+i = 5
+n = 10
+for k in range (n) :
+ print(i)
+ i = i + 1
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+\subsection{La boucle {\it tant que} (while)}
+
+{\it répéter} est une structure de répétition qui ne nous permet pas de faire "efficacement" toutes les répétitions, ou boucles, que nous rencontrons en programmation. Pour palier à cette difficulté, deux autres structures se rencontrent souvent: la boucle {\it tant que } (while) et la boucle {\it pour} (for). Nous allons voir dans ce chapitre la première.
+
+Le format de la boucle {\it tant que} se présente sous la forme:
+
+\
+
+\hskip+5cm {\it tant que} {\bf condition est vraie}
+
+\hskip+6cm faire une certaine séquence d'instructions
+
+
+
+\vskip+.5cm
+
+La {\bf condition} consiste souvent à vérifier qu'une variable ne dépasse pas une certaine valeur. Il faudra alors {\bf incrémenter} cette variable avant chaque répétition de la boucle. Lorsque cette valeur est dépassée, on sort de la boucle.
+
+\subsubsection{{\it repeat} et {\it while}}
+
+Il est souvent assez facile de passer d'une boucle {\it tant que} à une boucle {\it répéter}. Par exemple,
+les deux programmes suivants, utilisant les structures de répétition {\it répéter} et {\it tant que} sont équivalents:
+
+\begin{multicols}{2}
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_32}
+\end{center}
+
+\begin{center}
+\includegraphics[scale=.5]{ch6_images/var_33}
+\end{center}
+\end{multicols}
+
+
+\subsubsection{En Python}
+
+Pour montrer comment on utilise la boucle {\it while} en Python, on va partir d'une situation concrète: Alice gagne 1200.- par mois. Et son salaire monte de 130.- par mois. Bob gagne lui 2900.- par mois, et son salaire augment de 70.- par mois. Combien de mois faudra-t-il pour qu'Alice gagne plus que Bob?
+
+Il existe bien sur des techniques mathématiques pour résoudre ce problème mais nous pouvons aussi représenter la situation par un programme. Nous aurons une variable pour chacun des salaires d'Alice et Bob, et une variable qui compte le nombre de mois, et qui vaudra au début 0. On va répéter nos calculs mensuels tant que le salaire d'Alice est plus petit que le salaire de Bob. Et chaque fois, on va calculer les nouveaux salaires d'Alice et de Bob et ajouter un mois en plus. Ce qui donne:
+
+
+\vskip.5cm
+\begin{lstlisting}
+salaire_alice = 1200
+salaire_bob = 2900
+nombre_de_mois = 0
+while salaire_alice <= salaire_bob:
+ salaire_alice = salaire_alice + 130
+ salaire_bob = salaire_bob + 70
+ nombre_de_mois = nombre_de_mois + 1
+print(nombre_de_mois)
+\end{lstlisting}
+\vskip.5cm
+
+Il faudra faire attention lorsqu'on écrit une boucle {\it while} à ne pas avoir une condition qui demeure toujours vrai, sinon le programme ne s'arrêter jamais.
+
+\subsubsection{Exercices}
+
+\begin{exercice}
+Que fait le programme suivant?
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_34}
+\end{center}
+\end{exercice}
+
+\begin{exercice}
+Que fait le programme suivant?
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_35}
+\end{center}
+\end{exercice}
+
+\begin{exercice}
+Que fait le programme suivant?
+\begin{center}
+\includegraphics[scale=.4]{ch6_images/var_36}
+\end{center}
+\end{exercice}
+
+
+
+
+
+\begin{exercice}
+Que fait le programme suivant quand on l'exécute?
+\vskip.5cm
+\begin{lstlisting}
+n = 2
+compteur = 0
+limite = 100
+while n < limite :
+ n = 2 * n
+ compteur = compteur + 1
+print(compteur)
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+
+
+\begin{exercice}
+\vskip.5cm
+\begin{lstlisting}
+abo_a = 50
+abo_b = 0
+nombre_seances = 0
+while abo_b < abo_a :
+ abo_a = abo_a + 9
+ abo_b = abo_b + 15
+ nombre_seances = nombre_seances + 1
+print(nombre_seances)
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+
+\begin{exercice}
+\vskip.5cm
+\begin{lstlisting}
+x = 0
+n = 10
+compteur = 0
+while x < n :
+ z = 0
+ while z < x :
+ compteur = compteur + 1
+ z = z + 1
+ x = x + 1
+print(compteur)
+\end{lstlisting}
+\vskip.5cm
+\end{exercice}
+
+\end{document}
+
diff --git a/07-Programmation.tex b/07-Programmation.tex
new file mode 100644
index 0000000000000000000000000000000000000000..cd2e14a0eaaaad933a31ac1ec14ac8543cb7c3ba
--- /dev/null
+++ b/07-Programmation.tex
@@ -0,0 +1,183 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{5}
+
+\chapter{Programmation - Introduction}
+
+\section{Traitement automatique des données}
+Un algorithme permet de résoudre un problème donné au moyen d'un nombre fini d'opérations élémentaires. L'application manuelle d'un algorithme est une tâche fastidieuse. C'est pourquoi l'ordinateur a été inventé dans le but d'automatiser l'implémentation d'algorithmes. On parle de l'informatique comme \textit{la science du traitement automatique de l'information}.\\
+
+Ce que l'on attend d'un programme c'est qu'il prenne les données d'entrée du problème, qu'il les transforme au moyen de l'algorithme, et qu'il redonne le résultat attendu.
+\begin{center}
+ \includegraphics[trim=0 0 0 20,width=0.5\textwidth]{images/shema_science_info}
+\end{center}
+Pour que le programme s'exécute sur un ordinateur, il faut indiquer à la machine comment s'y prendre.
+D'un côté l'ordinateur qui comprend seulement le langage binaire composé d'une suite de 0 et de 1 et de l'autre, le·la programmeur·euse qui parle un langage destiné à la communication entre humains comme le français, rempli d'ambiguïtés (plusieurs interprétations possibles de la même phrase). Il faut trouver un intermédiaire, c'est ce qu'on appelle un \textbf{langage de programmation}.
+\begin{defi}
+ Un \textbf{langage de programmation} est un langage formel utilisé pour expliquer en détail à un ordinateur comment réaliser une tâche.
+\end{defi}
+Les langages de programmation sont caractérisés par une \textbf{syntaxe} très rigide (afin qu'aucune ambiguïté n'existe) et qui permet aux ordinateurs d'exécuter ce que les humains leur disent de faire. La syntaxe de codage sera constituée d'ensembles de mots et symboles spécifiques qui devront se combiner dans un ordre bien particulier (\textbf{règle de syntaxe}). Chaque fois que cet ordre ne sera pas satisfait, l'ordinateur généra une erreur (\textbf{erreur de syntaxe}).
+\begin{defi}
+ Les \textbf{règles de syntaxe} définissent l’ensemble des programmes qui sont valides et acceptables par l’interpréteur/compilateur.
+ En français, les règles de syntaxe incluent l’orthographe et la grammaire, et déterminent quelles sont les phrases valides.
+\end{defi}
+
+\begin{eclairage}
+ \textbf{Langages naturels Vs Langages de programmation}
+ \begin{multicols}{2}
+ \textbf{Langages naturels}
+ \begin{itemize}
+ \item Communiquer entre humains
+ \item Mots corrects (orthographe)
+ \item Phrases correctes (grammaire)
+ \end{itemize}
+ \newpage
+ \textbf{Langages de programmation}
+ \begin{itemize}
+ \item Indiquer à une machine comment résoudre un problème
+ \item Identificateurs valides
+ \item Syntaxe valide
+ \end{itemize}
+ \end{multicols}
+\end{eclairage}
+
+
+
+\section{Langages de programmation}
+Pour que le programme écrit dans un langage de programmation soit compréhensible par l'ordinateur il devra être traduit par un programme appelé interpréteur ou compilateur (en fonction du type de langage et de son application). À l'heure actuelle plusieurs centaines de langages de programmation sont utilisés en fonction du domaine, des applications et des préférences du·de la programmeur·euse.
+\begin{center}
+ \includegraphics[scale=0.45,trim=0 40 0 160,clip=true]{images/family_tree_languages}
+ \captionof{figure}{Arbre généalogique des langages de programmation les plus utilisés.}
+\end{center}
+Il existe plusieurs critères pour catégoriser tous ces langages de programmation. Nous allons en passer en revue quelques-uns.
+
+\subsection{Paradigmes de programmation}
+Selon Wikipedia, \textit{un \textbf{paradigme de programmation} est une façon d'approcher la programmation informatique et de traiter les solutions aux problèmes et leur formulation dans un langage de programmation approprié}. Les paradigmes les plus communs sont
+\begin{enumerate}
+ \itemb{programmation impérative}
+ \itemb{programmation fonctionnelle}
+ \itemb{programmation orientée objet}
+\end{enumerate}
+Certains langages de programmation permettent de programmer en utilisant plusieurs approches. C'est notamment le cas du langage Python que nous utiliserons dans ce cours, même si nous adopterons principalement l'approche impérative.
+
+\subsection{Proximité avec le langage binaire-machine}
+On différencie des langages de programmation en fonction de leur proximité avec le langage binaire-machine qui est considérée comme le langage de plus bas niveau. On distingue deux niveaux :
+\begin{enumerate}
+ \itemb{bas niveau (proche machine) :} permet de contrôler tout ce qui se passe dans la machine pendant l'exécution du code.\\
+ C'est un langage machine lisible par un humain qui permet simplement de manipuler explicitement des registres, des adresses mémoires, voire des instructions machines. Par exemple~: assembleur, C\ldots.\\
+
+
+ \itemb{haut niveau (proche utilisateur) :} permet à l'utilisateur·trice d'utiliser des fonctions complexes sans se soucier de l'aspect machine (enfin un petit peu quand même). Pour son optimisation, il utilise parfois (souvent) des langages de bas niveau de façon transparente pour l'utilisateur·trice. Par exemple : FORTRAN, Python, PHP, SQlite\ldots
+\end{enumerate}
+
+\subsection{Langage interprété et langage compilé}
+On peut aussi trier les langages entre langages de programmation interprétés et langages de programmation compilés:
+\begin{enumerate}
+ \itemb{interprété :} le langage est lu avec un programme appelé interpréteur pour exécuter le code au fur et à mesure de la lecture du code. \\
+ \begin{tikzpicture}
+ \draw [very thick,->](0,0)node[left]{Code source}--node[above]{\footnotesize interpréteur}++(2.5,0)node[right]{Résultat};
+ \end{tikzpicture}
+ \begin{enumerate}
+ \item{avantage :} Test immédiat
+ \item{inconvénient :} plus lent, le code est interprété à chaque lancement du \textbf{programme interprété}.
+ \end{enumerate}
+ \itemb{compilé :} le langage est converti en langage machine (binaire) par l'intermédiaire d'un programme dédié (compilateur) qui produit un programme qui pourra dorénavant s'exécuter seul.\\
+ \begin{tikzpicture}
+ \draw [very thick,->](0,0)node[left]{Code source}--node[above]{\footnotesize Compilateur}++(2.5,0)node[right](m){code machine};
+ \draw [very thick,->](m)--node[above]{\footnotesize exécuteur}++(2.5,0)node[right](m){Résultat};
+ \end{tikzpicture}
+ \begin{enumerate}
+ \item{avantage :} Rapide
+ \item{inconvénient :} nécessite une première étape de compilation.
+ \end{enumerate}
+\end{enumerate}
+
+\subsection{Langages visuels}
+La rigidité et l'austérité des langages de programmation classique a poussé les programmeur·euse·s à développer des langages de programmation visuels qui simplifient l'apprentissage de la programmation. Dans un langage visuel, les éléments du langage de programmation sont accessibles sous la forme d’éléments graphiques (le plus souvent des blocs).
+\begin{enumerate}
+ \item{avantage :} des symboles clairs et une absence de syntaxe -> les erreurs de saisie sont impossibles
+ \item{inconvénient :} Manque de modularité, il devient très difficile de structurer le programme pour des projets importants.
+\end{enumerate}
+\begin{figure}[!h]
+ \centering
+ \subfloat[Langage visuel]{\includegraphics[scale=0.5]{images/blockly_ex}}
+ \hspace{1cm}
+ \subfloat[Langage textuel]{\includegraphics[scale=0.5]{images/micropython_ex}}
+ \caption{Le même programme écrit dans deux langages différents.}
+\end{figure}\label{CourbeRepr}
+
+
+\section{La langage Python et l'IDE Thonny}
+\subsection{Python}
+Quel est le meilleur langage de programmation? Cette seule question a permis de remplir des centaines de forums de programmeur·euse·s sur internet. Chaque langage ayant ses avantages, ses particularités et spécificités liées au matériel et type d'applications à créer. Cette année, nous utiliserons le langage Python. Voici un échantillon de raisons qui ont motivé notre choix \footnote{Voir l'article sur \url{https://linux-center.org/articles/9812/python.html}}:
+\begin{itemize}
+ \item Python est un langage interprété ce qui le rend le code portable sur la plupart des ordinateurs/systèmes d'exploitation.
+ \item La syntaxe de Python est très simple.
+ \item Code lisible et compact
+ \item Python est gratuit.
+ \item Python est très utilisé, en particulier pour l'apprentissage de la programmation.
+ \item Python est en 2021 le langage le plus utilisé dans le monde selon la classification\footnote{Voir la classification sur \url{https://spectrum.ieee.org/top-programming-languages-2021}} IEEE\footnote{IEEE: Institute of Electrical and Electronics Engineers ou en français: l'Institut des ingénieur·euse·s électricien·ne·s et électronicien·ne·s} Spectrum
+ \item etc...
+\end{itemize}
+
+\subsection{Environnement de Développement Intégré Thonny}
+Python est un langage interprété, donc pour écrire des programmes Python nous aurons besoin d':
+\begin{itemize}
+ \item un éditeur de texte pour écrire le code;
+ \item un interpréteur Python pour tester le code ou des instructions;
+ \item éventuellement, un débogueur pour pouvoir exécuter les instructions du programme les unes après les autres afin d'identifier les erreurs de programmations.
+\end{itemize}
+Un logiciel comme \textbf{Thonny}, intègre ces différents aspects dans un seul logiciel, on appelle ce type de logiciel un Environnement de Développement Intégré (IDE en anglais pour \textit{Integrated Development Environment}),
+\begin{figure}[!h]
+ \centering
+ \includegraphics[scale=0.5]{images/IDE_Thonny_illustre-crop.pdf}
+ \caption{IDE Thonny}
+\end{figure}
+\subsubsection{Interpréteur Python}
+L'interpréteur Python se présente sous la forme d’une fenêtre avec des \lstinline{>>>} après lesquels on peut entrer des instructions. En pressant la touche \textit{Entrée} du clavier, Python interprète les instructions et affiche le résultat.
+
+\subsubsection{L'éditeur}
+Lorsque l'on souhaite taper une suite de commandes, on préfère créer un script (programme) avec l'éditeur. Ainsi on peut sauvegarder son travail dans un fichier texte. Pour exécuter le code tapé dans l'éditeur, il suffit de cliquer sur le bouton vert avec la pointe de flèche.
+\begin{important}
+ On utilisera l'extension .py pour enregistrer les fichiers qui contiennent du code Python. De plus, on veillera à utiliser un nom de fichier cours mais explicatif sans utiliser d'accent et d'espace (les espaces peuvent être remplacer par le caractère \_ \textit{underscore})
+\end{important}
+
+
+\subsection{Première rencontre avec un programme Python}
+Dans un langage impératif, un programme est constitué d'instructions qui vont de la première à la dernière lignes. Comme nous le verrons pas la suite, l'ordre d'exécution entre la première et la dernière instruction pourra varier en fonction d'instructions de contrôle de flux. Prenons le programme suivant, écrit en Python :
+
+\vspace{-0.7cm}
+\begin{monprogramme}
+ \lstinputlisting[label={premierprg}, caption=Premier programme Python ]
+ {Codes/premier_prog_python.py}
+\end{monprogramme}
+%
+\begin{question}
+ Que fait ce programme?
+\end{question}
+
+
+\begin{eclairage}
+ Le but d'un programme est de traiter de l'information en entrée afin de produire le résultat attendu en sortie. Par conséquent, on retrouvera souvent la structure suivante
+ \begin{itemize}
+ \item Une partie entrée où les données du problème sont obtenues (lignes 2 à 5 dans le programme \ref{premierprg}).
+ \item Le corps du programme où un algorithme est exécuté instruction après instruction en fonction des données lues (lignes 7 à 13 dans le programme \ref{premierprg});
+ \item Une partie sortie qui affiche ou stocke le résultat obtenu (ligne 15 dans le programme \ref{premierprg}).
+ \end{itemize}
+ Nous verrons par la suite qu'un programme est essentiellement constitué d’expressions ou structures de données et d’instructions ou structures de contrôles. Il contiendra toujours les 4 ingrédients de base suivants
+ \begin{itemize}
+ \itemb{des structure de données} : les variables (qui représenteront l’Information).
+ \itemb{3 types de structures de contrôle du flux d’instructions} (qui permettront de traiter cette Information) :
+ \begin{itemize}
+ \item les séquences d’instructions.
+ \item les tests conditionnels ou alternatives.
+ \item les boucles ou répétitions.
+ \end{itemize}
+ \end{itemize}
+\end{eclairage}
+
+\end{document}
\ No newline at end of file
diff --git a/08-Variables_types.tex b/08-Variables_types.tex
new file mode 100644
index 0000000000000000000000000000000000000000..7fe60de0e2203f42f824bc7cdda8d2f618e14e10
--- /dev/null
+++ b/08-Variables_types.tex
@@ -0,0 +1,318 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{6}
+
+\chapter{Programmation - Types et Variables}
+
+
+\section{Quelques notions de base}
+
+Tous les langages de programmation ont été créés dans le même but \textbf{traiter de l'information}. Dans un langage impératif, on retrouve toujours les concepts suivants :
+\begin{itemize}
+ \itemb{La notion de valeur} qui représente l'information,
+ \itemb{La notion d'expression} qui produit une valeur,
+ \itemb{La notion d'instruction} qui est une commande à exécuter par la machine,
+ \itemb{La notion de structure de contrôle} qui exécute des instructions d'une manière bien spécifique en fonction des valeurs.
+\end{itemize}
+
+\subsection{La notion de valeur}
+Une valeur est une représentation de l'information. Par exemple le nombre entier \lstinline{3} représente une valeur, de même que la chaîne de caractères \lstinline{"Hello world"} ou le tableau de nombres à virgule flottante \lstinline{[7.31, 1.74, 3.14, 10.0]} (similaire aux nombres décimaux). Une valeur est toujours associée à un type (nombre entier/virgule flottante, chaîne de caractères).\\
+
+\subsection{La notion d'expression}
+Des valeurs, des opérateurs mathématiques et des parenthèses peuvent former une expression. Une expression est évaluée et le résultat de cette évaluation donne une valeur.
+\begin{mydefinition}
+ Une expression est le résultat d'un calcul effectué par le programme. Elle fournit une valeur associé à un type.
+\end{mydefinition}
+
+On peut utiliser l'interpréteur python pour évaluer des expressions
+\begin{myexample}
+ \begin{lstlisting}[numbers=none]
+>>>(1 + 2) * (3 + 4)
+21
+ \end{lstlisting}
+ Ici l'expression produit la valeur \lstinline{21} qui est de type entier.
+\end{myexample}
+
+\subsection{La notion d'instruction}
+Une instruction peut être vue comme une commande ou un ordre que l'on donne à la machine. En Python, il y a deux types d’instruction:
+\begin{itemize}
+ \item affectation : qui effectue un calcul et qui le stocke en mémoire dans une variable.
+ \item fonction : qui est une "commande" prédéfinie.
+\end{itemize}
+\begin{myexample}
+ \vspace{-3mm}
+ \begin{lstlisting}[numbers=none]
+>>> x = 1 + 2 # c'est une affectation
+>>> print(x) # c'est un appel à une fonction
+3
+ \end{lstlisting}
+ \vspace{-3mm}
+\end{myexample}
+
+
+\begin{eclairage}
+ Tout texte qui suit le caractère dièse "\lstinline{#}" est ignoré par Python, on appelle ceci des commentaires. Leur but est d’expliquer le fonctionnement du programme. C’est une bonne habitude de commenter abondamment le code.
+\end{eclairage}
+Pour utiliser une instruction, par exemple la \textbf{fonction} \lstinline{print}, il faut lui fournir une valeur (l'information à afficher). Dans l'exemple
+\begin{lstlisting}[numbers=none]
+>>> print("I love computer science")
+I love computer science
+\end{lstlisting}
+la valeur à afficher est le message \lstinline{"I love computer science"}. En revanche, la commande
+\begin{lstlisting}[numbers=none]
+>>>print(3 * 5 + 2)
+17
+\end{lstlisting}
+ne produit pas le même résultat que
+\begin{lstlisting}[numbers=none]
+>>> print("3 * 5 + 2")
+3 * 5 + 2
+\end{lstlisting}
+car dans le premier cas la valeur est un nombre qui est le résultat de l'évaluation de l'expression $3\cdot 5 +2$ (un nombre entier), et dans le second la valeur est le message \lstinline{"3 * 5 + 2"} qui est une chaîne de caractère (un texte).
+\begin{eclairage}
+ Les fonctions sont des blocs d'instructions déjà définis qui font faire quelque chose au programme. La plupart des langages de programmation, par exemple Python, possède toute une série de fonctions prédéfinies qui permettent de réaliser des tâches standard, comme la fonction \lstinline{print} qui permet d'afficher des messages dans l'interpréteur. L'appel d'une fonction s'effectue en indiquant le nom de la fonction, suivi d'une paire de parenthèses. Ces parenthèses contiennent les éventuels arguments de la fonction, c'est à dire les valeurs nécessaires pour que la fonction puisse être exécutée, séparés par des virgules (exemple :\lstinline{print("J'ai ", 16, " ans")}).
+\end{eclairage}
+
+
+\subsection{La notion de structure de contrôle}
+Les \textbf{structures de contrôle} permettent de gérer le flux d'exécution d'un programme, c'est-à-dire l'ordre dans lequel les \textbf{instructions} seront exécutées.
+
+
+\section{La notion de type}
+Le type d'information qu'une valeur peut encoder varie d'un langage à l'autre. En général, plus le langage est de haut niveau plus il va offrir des types élaborés. La plupart des langages proposent un certain nombre de \textbf{types de base} \footnote{on dit aussi \textbf{types fondamentaux} ou encore \textbf{types primitifs}}. Ils correspondent aux données qui peuvent être traitées directement par le langage. En Python, les quatre types de base incontournables sont
+\begin{enumerate}
+ \itemb{Les entiers (\lstinline{int}) }: \lstinline{-4}, \lstinline{0}, \lstinline{99.}\\
+ $ \longrightarrow$ Ils servent a représenter des nombres de manières exactes.
+ \itemb{Les nombres à virgules flottantes (\lstinline{float})} : \lstinline{20.5 }, \lstinline{10. } ou \lstinline{ 0.001}.\\
+ $ \longrightarrow$ Ils servent a représenter des nombres (éventuellement) approximativement, c’est un genre de notation scientifique en puissance de 2 avec un certains nombres de chiffres significatifs (rappel : en notation scientifique en puissance de $10$, on écrit $7000000001 \approx 7,00 \cdot 10^9$ ).\\
+ \textbf{Attention} : On utilise un point pour séparer la partie entière de la partie décimale (ex : 2.68) et non une virgule !
+ \itemb{Les chaînes de caractères (\lstinline{str})}: \lstinline{"Hello, World"}, \lstinline{'Oui'.}\\
+ $ \longrightarrow$ elles servent a représenter du texte, par exemple lorsque l’on veut afficher une information dans l’interpréteur. Elle sont constituées d'une suite de caractères
+ (lettre, chiffre, signe de ponctuation, espace, ...) placées entre guillemets ou (de manière équivalente) entre apostrophes.
+ \itemb{Les booléens (\lstinline{bool})}: Seulement deux valeurs possibles \lstinline{True} (vrai) ou \lstinline{False} (faux).\\
+ $ \longrightarrow$ Ils servent à représenter \textit{les valeurs de vérité}, par exemple lorsque l'on cherche à évaluer une condition. L'évaluation de l'expression \lstinline{7 < 18} donne la valeur \lstinline{True} tandis que le résultat de \lstinline{0 > 1} donne \lstinline{False}
+\end{enumerate}
+Les 4 types présentés ci-dessus sont ceux qu'on retrouve dans quasiment tous les langages de programmation. Python, étant un langage de haut niveau, propose une grande quantité de types de bases (voir la liste complète à \url{https://fr.wikiversity.org/wiki/Python/Les_types_de_base}).
+
+\begin{apprendre}
+ Pour connaître le type d’une donnée, il suffit de recourir à la fonction \lstinline{type}
+ \begin{lstlisting}[numbers=none]
+>>> type(10)
+<class 'int'>
+>>> type(10.0) # le type float est caractérisé par un point décimal
+<class 'float'>
+>>> type("10") # le type string est caractérisé par les guillemets
+<class 'str'>
+ \end{lstlisting}
+\end{apprendre}
+
+
+\section{Les opérations}
+L’essentiel du travail effectué par un programme consiste à manipuler des données. Peu importe la donnée et son type, ils se ramènent toujours en définitive à une suite finie de bits. Mais alors, pourquoi se compliquer la vie? Deux raisons,
+\begin{enumerate}
+ \item La taille d'une donnée, c'est-à-dire le nombre de bits nécessaire pour la représenter varie en fonction du type de donnée.\\
+ Exemple: la chaîne de caractère \lstinline{"c'est trop long"} nécessite plus de bits que le nombre \lstinline{8}.
+ \item Il existe des opérations associées à la plupart des types. Ces opérations vont permettre de transformer l'information en opérant sur les valeurs d'entrées du programme.
+\end{enumerate}
+
+
+\subsection{Opération sur les nombres (\lstinline{int} et \lstinline{float})}
+Les opérations sur les nombres sont les suivantes :
+
+\def\arraystretch{1.5}
+\begin{table}[h!]
+ \small
+ \begin{tabular}{llllll|c|l|}
+ \cline{7-8}
+ & & & & & & \multicolumn{2}{c|}{\footnotesize \textbf{Seulement pour les int}}\\ \hline
+ \multicolumn{1}{|l|}{\textbf{opérateur}} & \multicolumn{1}{c|}{+} & \multicolumn{1}{c|}{-} & \multicolumn{1}{c|}{*} & \multicolumn{1}{c|}{/} & \multicolumn{1}{c|}{**} & // & \multicolumn{1}{c|}{\%} \\ \hline
+ \multicolumn{1}{|l|}{\textbf{signification}} & \multicolumn{1}{l|}{addition} & \multicolumn{1}{l|}{soustraction} & \multicolumn{1}{l|}{multiplication} & \multicolumn{1}{l|}{division} & exponentiation & \multicolumn{1}{l|}{\begin{tabular}[c]{@{}l@{}}Division \\ entière\end{tabular}} & Modulo \\ \hline
+ \end{tabular}
+\end{table}
+On note que la division entière \lstinline{//} et le modulo \lstinline{}
+(le reste de la division entière) sont des opérations seulement définies sur les entiers (\lstinline{int}).
+
+\subsubsection{Priorité des opérations}
+Comme en mathématique, les opérateurs ont un ordre de priorité. Ainsi si le calcul \lstinline{4+2*3} correspond à \lstinline{4+(2*3)} parce que la multiplication a priorité sur l'addition. L’ordre de priorité est le suivant :
+\begin{enumerate}
+ \item Exponentiation (Puissance)
+ \item Modulo
+ \item Multiplication et division entières
+ \item Addition et soustraction
+\end{enumerate}
+Sur les opérateurs de même priorité, c’est celui qui est le plus à gauche qui est évalué en premier. Les parenthèses permettent de changer ces priorités. Leurs effet sera de forcer une opération avant une autre. Par exemple, Si on veut d'abord effectuer \lstinline{4+2} et multiplier le résultat par \lstinline{3}, alors il faut l'indiquer avec des parenthèses : (4+2)*3
+
+
+\subsection{Opérations sur les booléens et les chaînes de caractère (\lstinline{bool} et \lstinline{str})}
+Les opérations avec les booléens et les chaînes de caractère seront traitées dans des chapitres dédiés.
+
+
+\section{Variables}
+
+%voir : http://www.monlyceenumerique.fr/snt_seconde/python/python_en_seconde.html
+%voir : https://www.maths-cours.fr/cours/python-au-lycee-1/
+%http://info-mounier.fr/snt/python/introduction_variables.php
+
+\subsection{Le concept de variable}
+\begin{wrapfigure}[]{r}{0.3\textwidth}
+ \includegraphics[trim=0 0 0 45,width=0.28\textwidth]{images/variables/variables}
+\end{wrapfigure}
+Le but d'un programme est de transformer de l'information. En général, un programme va commencer par stocker en mémoire les données d’entrée qui seront utilisées lors des étapes de traitement. Pour accéder à ces espaces de stockage et savoir quelle genre d'information ils contiennent, il va falloir leur attribuer un \textbf{nom} (ou \textbf{identifiant}) ainsi qu'un \textbf{type}. Pour finir, leur valeur va varier au fil de l'exécution du programme, c'est pourquoi on les appelle des \textbf{variables}. Chaque fois qu'on modifie la valeur d'une variable, on dit qu'on lui \textbf{affecte} une nouvelle valeur.
+\begin{mydefinitions}
+ \item Une \textbf{variable} est un nom associé à un emplacement de la mémoire. C’est comme une boîte que l’on identifie par une étiquette. On dit aussi que le \textbf{nom de la variable est son identifiant}.
+ \item Une \textbf{affectation} est l’attribution d’une valeur (d’un contenu) à une variable
+\end{mydefinitions}
+Pour résumer, une variable est décrite par
+\begin{itemize}
+ \item Un \textbf{identifiant} unique qui la désigne.
+ \item Un \textbf{type} qui définit de quel « genre » est l’information associée.
+ \item Une \textbf{valeur} qui doit respecter le type.
+\end{itemize}
+
+
+\vspace{1cm}
+\act Indiquez le type des variables permettant de stocker (sur votre smartphone) les informations suivantes :
+\begin{enumerate}
+ \item le nom d’un contact
+ \item l’heure du réveil
+ \item un SMS
+ \item le code de votre de votre compte eduge
+ \item le pourcentage affiché de batterie restante
+ \item la note de votre dernière évaluation de Mathématiques
+ \item l'énoncé d'un devoir d'Histoire
+ \item le fait que vous ayez déjà fini (ou non) ce devoir
+\end{enumerate}
+
+\vspace{1cm}
+
+\newpage
+
+\begin{wrapfigure}[]{r}{0.3\textwidth}
+ \centering
+ \includegraphics[width=0.28\textwidth]{images/variables/memoire}
+ \caption{\small Représentation d'une mémoire d'ordinateur comme des boîtes. Lorsqu'une variable est crée la boite obtient une \textit{étiquette} (en rouge) et une valeur (en bleu).}
+\end{wrapfigure}
+Il faut imaginer la mémoire de l’ordinateur comme une grosse armoire avec plein de petites boîtes.
+Certaines de ces boîtes ont un nom (une étiquette) : ce sont des variables, et elles peuvent contenir une valeur. Chaque fois que l'on a besoin de stocker une donnée on va créer une nouvelle variable, en programmation on dira que l'on \textbf{déclare} une variable.
+
+En Python la déclaration d’une variable (et son typage) se fait dynamiquement à l’exécution du programme dès que cette variable apparaît dans une ligne de code. En fait, il suffit d'une \textbf{affectation} en utilisant le symbole "\lstinline{=}". Le code
+\begin{lstlisting}[numbers=none]
+myInt = 4
+myString = "hello"
+myReal = 2.5
+\end{lstlisting}
+crée 3 variables avec comme identifiant \lstinline{myInt}, \lstinline{myString} et \lstinline{myFloat} qui sont de type \lstinline{int}, \lstinline{str} et \lstinline{float} et qui contiennent les données \lstinline{4}, \lstinline{"hello"} et \lstinline{2.5}.
+\begin{center}
+ \includegraphics[trim=0 0 0 45,width=0.4\textwidth]{images/variables/variables2}
+\end{center}
+
+\begin{important}
+ En Python, les noms de variables doivent en outre obéir à quelques règles simples :\\
+ \begin{itemize}
+ \item Il est exclusivement composé de lettres (majuscules et/ou minuscules) et de chiffres mais doit toujours commencer par une lettre.
+ \item On ne peut pas utiliser l’un des 33 mots réservés du langage Python
+ \begin{multicols}{7}
+ \lstinline{and}\\ \lstinline{as}\\ \lstinline{assert}\\ \lstinline{break}\\ \lstinline{class}\\ \lstinline{continue}\\ \lstinline{def}\\
+ \lstinline{del}\\ \lstinline{elif}\\ \lstinline{else}\\ \lstinline{except}\\ \lstinline{False}\\ \lstinline{finally}\\ \lstinline{for}\\
+ \lstinline{from}\\ \lstinline{global}\\ \lstinline{if}\\ \lstinline{import}\\ \lstinline{in}\\ \lstinline{is}\\ \lstinline{lambda}\\
+ \lstinline{None}\\ \lstinline{nonlocal}\\ \lstinline{not}\\ \lstinline{or}\\ \lstinline{pass}\\ \lstinline{raise}\\ \lstinline{return}\\
+ \lstinline{True}\\ \lstinline{try}\\ \lstinline{while}\\ \lstinline{with}\\ \lstinline{yield}
+ \end{multicols}
+ \item Le Seul symbole autorisé est le tiret du bas "$\_$" (underscore en anglais).
+ Tous les autres caractères spéciaux sont interdits, en particulier l’espace blanc " " !
+ \item Il est sensible à la casse : les minuscules sont différentes des MAJUSCULES. Exemple : les identifiant \lstinline{Age} et \lstinline{age} vont désigner des variables différentes.
+ \end{itemize}
+\end{important}
+
+\begin{eclairage}
+ Il est très important de donner un nom clair et précis aux variables. En lisant le nom de la variable, il faudrait avoir une idée de ce qu'elle représente.
+ Par exemple, si je lis \lstinline{note_eleve_JohanS}, je me dis que cette variable représente la note de l'élève Johan S. et donc c'est probablement un \lstinline{float} entre 0.0 et 6.0. Pour améliorer la lecture, on utilise le seul symbole autorisé l'\textit{underscore} "$\_$"\\
+\end{eclairage}
+
+
+\subsection{L'affectation}
+Chaque variable (déclarée) possède une valeur qui est l’information qu’elle porte. Par exemple, la valeur de la variable \lstinline{nombre_eleves_GR103} pourrait être 23, celle de la variable \lstinline{note} pourrait être 4.5, celle de la variable \lstinline{prenom} pourrait être "Anouk".
+En Python, pour définir ou modifier la valeur d’une variable, il suffit de lui affecter une valeur en utilisant le symbole égal "\lstinline{=}".
+\begin{mydefinition}
+ L’\textbf{affectation} d’une valeur à une variable est l’instruction basique qui permet d’attribuer une valeur à une variable. Par abus de langage, on dit souvent «affectation de variable» ou «assignation de variable».
+\end{mydefinition}
+En Python, l'affectation s’effectue avec l’opérateur \lstinline{=}. L'instruction d'affectation est composée d'une variable, suivie du symbole \lstinline{=} et d'une expression à évaluer. Après avoir exécutée une affectation la variable prendra la valeur de l'expression évaluée.
+\begin{myexample}
+ \begin{lstlisting}[numbers=none]
+>>> x = (1 + 2) * (3 + 4)
+>>> print(x)
+21
+ \end{lstlisting}
+\end{myexample}
+
+\begin{important}
+ \begin{itemize}
+ \item Il ne faut pas confondre l'opérateur \lstinline{=} (l'affectation) et l'opérateur \lstinline{==} qui sert à tester l'égalité de deux valeurs. L'opérateur \lstinline{==} est beaucoup plus proche du concept d'égalité utilisée en mathématiques.
+ \item Il est important de distinguer les expressions, comme \lstinline{x + 2} , des instructions, comme \lstinline{y = x + 2}; . Une expression se calcule, une instruction s’exécute.
+ \end{itemize}
+
+\end{important}
+
+\subsection{Différents types d’affectations}
+
+\begin{myexamples}
+ \itemb{Affectation d'une quantité}
+ \begin{lstlisting}[numbers=none]
+note = 37 * 50 + 1
+ \end{lstlisting}
+ \textbf{Explications :}
+ \begin{minipage}[t]{0.83\linewidth}
+ La valeur \lstinline{37* 50 + 1} (c'est-à-dire \lstinline{4.7}) est injectée dans la case mémoire nommée \lstinline{note}.
+ \end{minipage}
+
+ \itemb{Affectation d’un texte}
+ \begin{lstlisting}[numbers=none]
+prenom = "Robert"
+nom_prenom = "Dupont"+'Robert'
+ \end{lstlisting}
+ \textbf{Remarque :}
+ \begin{minipage}[t]{0.85\linewidth}
+ Un Chaîne de caractères peut être écrite soit entre "guillemets", soit entre 'apostrophes' droits.
+ \end{minipage}
+
+
+ \itemb{Affectations parallèles}
+ \begin{lstlisting}[numbers=none]
+n, x = 1, 7.3
+ \end{lstlisting}
+ \textbf{Explications :}
+ \begin{minipage}[t]{0.83\linewidth}
+ C'est équivalent à effectuer les affectations \lstinline{n = 1} et \lstinline{x = 7.3} simultanément.
+ \end{minipage}
+
+
+ \itemb{Auto-affectation}
+ \begin{lstlisting}[numbers=none]
+k = k ** 2
+t = 3 * t - 2
+ \end{lstlisting}
+ \textbf{Explications :}
+ \begin{minipage}[t]{0.83\linewidth}
+ Une expression avec la valeur de la variable est calculée puis réaffectée à la variable elle-même.\\
+ Par exemple, si \lstinline{t} contient la valeur $5$ alors après avoir exécute \lstinline{t=3*t-2} \lstinline{t} vaudra \lstinline{3*5-2} (c'est-à-dire \lstinline{13}).
+ \end{minipage}
+
+
+
+ \itemb{Incrémentation ou décrémentation}
+ \begin{lstlisting}[numbers=none]
+k = k + 1
+compteur = compteur - 2
+ \end{lstlisting}
+ \textbf{Remarque :}
+ \begin{minipage}[t]{0.85\linewidth}
+ Auto-affectation additionnée ou soustraite d’un certain \textit{pas} (d’un certain nombre) entier.
+ \end{minipage}
+\end{myexamples}
+
+
+\end{document}
\ No newline at end of file
diff --git a/09-Boolens.tex b/09-Boolens.tex
new file mode 100644
index 0000000000000000000000000000000000000000..4dbbc0fcc1047a1f5bdca7a2fb4e5eefa70bf48c
--- /dev/null
+++ b/09-Boolens.tex
@@ -0,0 +1,99 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{7}
+
+\chapter{Programmation - Les booléens}
+
+\vspace{-0.8cm}
+\section{Vrai ou faux?}
+Comme étudié dans le cas des test, un programme se doit de prendre des décisions. Dans notre vie de tous les jours, nos décision dépendent le plus souvent des questions qui se répondent par \textit{oui} ou par \textit{non}. Par exemple, "est-ce qu'il pleut aujourd'hui" ou "êtes-vous mineur". La plupart des langages de programmation comme Python ne possèdent pas de type oui/non mais plutôt un type vrai/faux (\lstinline{True} / \lstinline{False}) qui joue un rôle similaire. Ce type s'appelle \textbf{booléen}. Dans ce contexte, les décisions du programme dépendent plutôt de la véracité d'une \textit{affirmation}. Par exemple, au lieu de répondre à la question "êtes-vous mineur?", on s'intéressera à savoir si l'affirmation "vous êtes mineur" est vraie. Par exemple, en Python, cela ce traduirait par
+\begin{lstlisting}[numbers=none]
+age = int(input("Quel est votre age"))
+mineur = age < 18
+\end{lstlisting}
+
+Comme étudié dans le chapitre sur les tests, un programme est souvent confronté à devoir prendre des décisions.
+\begin{mydefinition}
+ Une \textbf{booléen} est un type de variable à deux états, généralement noté \textit{vrai} (ou 1) et \textit{faux} (ou 0). \\
+
+ En langage \lstinline{python}, le type d’une telle variable est \lstinline{bool}, les deux valeurs possibles sont \lstinline{True} ou \lstinline{False}.
+\end{mydefinition}
+
+\section{Opérateur de comparaison}
+Le plus souvent, un booléen est obtenu lorsque l'on évalue une expression qui compare des valeurs. Les opérateurs de comparaison sont les suivants
+ \begin{center}
+ \begin{tabular}{|c|c|l|}
+ \hline
+% \rowcolor[HTML]{EFEFEF}
+ Opérateur & Expression & Signification \\ \hline
+ ==& x == y& Égal \\ \hline
+ !=& x != y& Non égal \\ \hline
+ >& x > y & Plus grand que \\ \hline
+ <& x < y & Plus petit que \\ \hline
+ >=& x >= y& Plus grand ou égal à \\ \hline
+ <=& x <= y& Plus petit ou égal à \\ \hline
+ is& x is y& est identique \\ \hline
+ is not& x is not y& n’est pas identique \\ \hline
+
+ \end{tabular}
+\end{center}
+\begin{important}
+ Il ne faut pas confondre la simple égalité "\lstinline{=}" qui représente l'affectation de la double égalité "\lstinline{==}" qui teste si deux valeurs sont égales. Par exemple, le programme
+ \begin{lstlisting}[numbers=none]
+ n = 2**4
+ m = 16
+ print(n == m)
+ \end{lstlisting}
+ affiche \lstinline{True} car $2^4$ est égal à $16$.
+\end{important}
+
+\exo Dans l'interpréteur Python, taper les lignes suivantes et compléter celles en pointillés.
+\begin{lstlisting}[numbers=none]
+>>> x=7
+>>> y=17
+>>> x==y
+......................................
+>>> x!=y
+.......................................
+>>> x>y
+.....................................
+>>> x>=y
+.....................................
+>>> x<y
+.....................................
+>>> x<=y
+...................................
+>>> x is y
+...................................
+>>> x is not y
+..................................
+\end{lstlisting}
+
+\exo Evaluer le résultat des expressions suivantes
+\begin{lstlisting}[numbers=none]
+3 == 1 + 2
+1.0 == 1
+"1" == 1
+3 != 1 + 2
+1.0 != 1
+1 < 0
+"c" <= "h"
+"h" > "B"
+1.0 is 1
+1 + 2 is not 3
+\end{lstlisting}
+\begin{important}
+ Si les expressions comparées ne sont pas du « même » type, une \lstinline{TypeError} est générée (sauf pour l’opérateur is).
+\end{important}
+
+
+\section{Opérations booléens}
+Mon réveil sonne le matin lorsque deux conditions sont satisfaites.
+
+
+
+\end{document}
\ No newline at end of file
diff --git a/10-boucles.pdf b/10-boucles.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..96ba1fb1354e77450ec1eccafdf19f97036154ca
Binary files /dev/null and b/10-boucles.pdf differ
diff --git a/10-boucles.tex b/10-boucles.tex
new file mode 100644
index 0000000000000000000000000000000000000000..b7e21b57f8d0e65ee9a70f44acffd29c46ba8203
--- /dev/null
+++ b/10-boucles.tex
@@ -0,0 +1,413 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{7}
+\chapter{Programmation - Structures de contrôle}
+
+\vspace{1cm}
+
+\section{Les Boucles}
+Il est souvent nécessaire en programmation de devoir répéter un bloc d'instructions un certain nombre de fois, que ce soit pour parcourir une liste, pour faire une action de manière cyclique, etc. Ce nombre d'itérations est parfois connu en avance et doit parfois être déterminé au fur et à mesure des répétitions. En fonction de la situation, il existe plusieurs structures de contrôle permettant ces répétitions. Ces structures sont appelées des \textit{boucles}.
+
+
+\subsection{La boucle \textsf{for}}
+
+\begin{defi} En python, la boucle |for| permet de répéter un bloc d'instructions pour chaque élément d'un container (tableau, chaîne de caractères, etc.). Elle est introduite par le mot-clé |for| suivi d'un nom de variable, puis du mot-clé |in| et du container à parcourir, et enfin du symbole ":"
+\end{defi}
+
+\begin{figure}[h]\begin{center}
+\includegraphics[scale=.3]{images/for-loop}
+\caption{Schéma fonctionnel d'une boucle for}
+% Source : https://openclassrooms.com/fr/courses/7168871-apprenez-les-bases-du-langage-python/7296286-repetez-des-taches-facilement-a-l-aide-de-boucles
+%TODO : make smtg similar in latex
+\end{center}\end{figure}
+
+\begin{example}
+L'exemple suivant permet d'afficher 10x le mot "Coucou". À chaque itération de la boucle, le programme va exécuter la ligne contenant l'instruction |print|.
+\end{example}
+
+\lstset{caption={Boucle for - parcours tableau}}
+\begin{lstlisting}
+for k in range(10):
+ print("Coucou")
+\end{lstlisting}
+
+
+\begin{remarque}
+Dans les cas où l'on veut exécuter un bloc d'instructions un nombre précis de fois, la fonction |range(begin,end)| permet de générer un tableau de |begin| à |end-1| qui peut ensuite être utilisé avec une boucle |for|. L'exemple~\ref{ex:counter} peut ainsi être écrit :
+
+\end{remarque}
+
+\lstset{caption={Boucle for - compteur trivial}}
+\begin{lstlisting}
+maxCompteur = 10
+for compteur in range(maxCompteur+1):
+ print(compteur)
+\end{lstlisting}
+
+
+\subsection{La boucle \textsf{while}}
+Si la boucle |for| est la plus pratique à utiliser dans des cas précis, il existe une boucle plus modulable. C'est la boucle |while|.
+
+\begin{defi} La boucle |while| permet de répéter un bloc d'instructions tant qu'une condition n'est pas remplie. En python, elle est introduite par le mot-clé |while| suivi d'un test terminé par le symbole ":"
+\end{defi}
+
+\begin{figure}[h]\begin{center}
+\includegraphics[scale=.3]{images/while-loop}
+\caption{Schéma fonctionnel d'une boucle while}
+% Source : https://openclassrooms.com/fr/courses/7168871-apprenez-les-bases-du-langage-python/7296286-repetez-des-taches-facilement-a-l-aide-de-boucles
+%TODO : make smtg similar in latex
+\end{center}\end{figure}
+
+\begin{example}
+\label{ex:counter}
+L'exemple suivant permet d'afficher un compteur allant de 1 à 10. À chaque début de boucle, le programme va évaluer la condition |compteur <= maxCompteur| puis exécuter le bloc d'instruction si elle vaut |True| et sortir de la boucle si elle vaut |False|.
+\end{example}
+
+\lstset{caption={Boucle while - compteur trivial}}
+\begin{lstlisting}
+maxCompteur = 10
+compteur = 1
+while compteur <= maxCompteur:
+ print(compteur)
+ compteur = compteur + 1
+\end{lstlisting}
+
+%\begin{remarque}
+%L'instruction |compteur += 1| est équivalente à |compteur = compteur + 1| et sert donc à \textit{incrémenter} la variable |compteur| (à l'augmenter de 1).
+%\end{remarque}
+
+
+
+
+
+\subsection{Exercices sur les ordinateurs}
+
+\begin{exercice}
+Écrire un programme listant :
+\item[a)] les nombres de 0 à 50.
+\item[b)] les nombres pairs de 0 à 50.
+\item[c)] les nombres de 50 à 100.
+\item[d)] les nombres de 0 à 20, dans l'ordre décroissant.
+\end{exercice}
+
+\begin{exercice}
+Écrire un programme qui demande à l'utilisateur-trice de saisir un nombre entier et qui affiche la table de multiplication de ce nombre de à 10.
+\end{exercice}
+
+
+\begin{exercice}
+Calculer la somme des entiers de 1 à 100.
+\end{exercice}
+
+\begin{exercice}
+Écrire un programme permettant de réaliser la figure ci-dessous :
+
+\#\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+\end{exercice}
+
+
+\begin{exercice}
+Écrire un programme permettant de réaliser la figure ci-dessous :
+
+\#
+
+\#\#
+
+\#\#\#
+
+\#\#\#\#
+
+\#\#\#\#\#
+
+\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#
+
+\#\#\#\#\#\#\#\#\#\#
+\end{exercice}
+
+
+\begin{exercice}
+Demander à l'utilisateur-trice de saisir un mot jusqu'à ce qu'iel saisisse un mot de plus de 5 caractères.
+\end{exercice}
+
+\begin{exercice}
+Demander à l'utilisateur-trice de saisir un nombre jusqu'à ce qu'iel saisisse un nombre pair.
+\end{exercice}
+
+\begin{exercice}
+Afficher le menu d'un programme jusqu'à ce que l'utilisateur-trice saisisse "q" pour quitter.
+
+\texttt{--- Menu --- \\
+1. Option 1\\
+2. Option 2\\
+q. Quitter\\
+Choisissez une option :}
+\end{exercice}
+
+
+\begin{exercice}
+Écrire un programme qui demande à l'utilisateur-trice de saisir une phrase et qui affiche cette phrase sans les espaces.
+\end{exercice}
+
+
+\begin{exercice}
+Écrire un programme qui demande à l'utilisateur-trice de saisir un mot et qui affiche ce mot à l'envers.
+\end{exercice}
+
+
+
+\begin{exercice}
+Imaginer :
+\item[a)] une boucle infinie, n'atteignant jamais sa condition de fin.
+\item[b)] une boucle qui n'exécute jamais son bloc d'instructions.
+\end{exercice}
+
+\begin{exercice}
+Écrire un programme énumérant les 100 premiers nombres de la suite de Fibonacci.
+\end{exercice}
+
+\begin{exercice}
+Écrire un programme permettant d'additionner les 100 premiers entiers naturels (1, 2, ..., 100). % reponse : 5050.
+\end{exercice}
+
+\begin{exercice}
+En vous inspirant de l'exercice \ref{exo:min}, écrire un programme trouvant le minimum entre N nombres.
+Testez avec N=10.
+\end{exercice}
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\newpage
+
+\section{Les conditions}
+
+\paragraph{} Avec les concepts vus jusqu'ici, un programme exécuté 100 fois de suite donnera 100 fois les mêmes résultats, ce qui présente assez peu d'intérêt. Pour que l'exécution de notre programme dépende de différents paramètres, on utilise des structures de contrôle nommées \textit{conditions}.
+
+\paragraph{} La condition est un élément de base d'algorithmique que l'on utilise au quotidien.
+ \begin{example} S'il fait beau, j'irai en montagne. \end{example}
+
+
+\paragraph{} Ces structures permettent d'exécuter ou de ne pas exécuter certaines instructions en fonction de certaines conditions et de changer ainsi le déroulement du programme.
+
+\paragraph{}
+\begin{tabular}{ c l }
+ Étapes & Instructions \\ \hline
+ 1 & Se lever \\
+ 2 & Regarder la météo \\
+ 3.1 & S'il fait beau, aller en montagne \\
+\end{tabular}
+
+
+\subsection{L'instruction \textsf{if}}
+Un premier moyen d'exprimer des conditions en programmation est l'instruction \textsf{if}. En python, elle s'utilise de la manière suivante :
+
+\lstset{caption={Instruction if}}
+\begin{lstlisting}
+if meteo == "beau":
+ print("Aujourd'hui, je vais en montagne.")
+\end{lstlisting}
+
+\begin{defi}
+L'instruction |if| doit être suivie d'une expression retournant un booléen (|True| ou |False|) puis d'un symbole |:|. Cette expression peut être une variable contenant un booléen ou une opération retournant un booléen comme les opérateurs <, >, == ou != .
+\end{defi}
+
+Dans cet exemple, si la variable |meteo| a été initialisée à |"beau"|, la phrase \textsf{Aujourd'hui, je vais en montagne.} va s'afficher. Si elle a été initialisée à une autre valeur, par exemple |meteo = "moche"|, rien ne s'affichera.
+
+%\begin{remarque} Le début et la fin du bloc d'instructions soumis à l'instruction |if| sont définis par l'indentation de chaque ligne (le nombre d'espace avant le début du texte). La condition va s'appliquer à tout le bloc d'instruction suivant qui sera décalé vers la droite par rapport à l'instruction |if|. \end{remarque}
+
+\begin{exercice}
+Quelle est la différence entre ces deux programmes ? Qu'afficheront-ils respectivement :
+\item[a)] dans le cas |meteo = "beau"| ?
+\item[b)] dans le cas |meteo = "moche"| ?
+
+\lstset{caption={Programme A}}
+\begin{lstlisting}
+if meteo == "beau":
+ print("Aujourd'hui, ")
+ print("je vais en montagne.")
+\end{lstlisting}
+
+
+\lstset{caption={Programme B}}
+\begin{lstlisting}
+if meteo == "beau":
+ print("Aujourd'hui, ")
+print("je vais en montagne.")
+\end{lstlisting}
+
+\end{exercice}
+
+\paragraph{Réponse} :
+\vskip+3cm
+
+
+
+\subsection{L'instruction \textsf{else}}
+L'instruction |if| peut être suivie d'une instruction |else| qui est exécutée lorsque le résultat du test est |False|. Par exemple, on pourrait préciser la situation précédente :
+ \begin{example} S'il fait beau, j'irai en montagne. Sinon, j'irai au cinéma. \end{example}
+ Notre algorithme deviendrait alors :
+\paragraph{}
+\begin{tabular}{ c l }
+ Étapes & Instructions \\ \hline
+ 1 & Se lever \\
+ 2 & Regarder la météo \\
+ 3.1 & S'il fait beau, aller en montagne \\
+ 3.2 & S'il ne fait pas beau, aller au cinéma \\
+\end{tabular}
+
+\paragraph{}
+En python, cela s'écrirait de la manière suivante :
+
+\lstset{caption={Instruction if - else}}
+\begin{lstlisting}
+if meteo == "beau":
+ print("Aujourd'hui, je vais en montagne.")
+else:
+ print("Aujourd'hui, je vais au cinéma.")
+\end{lstlisting}
+
+\subsection{L'instruction \textsf{elif}}
+Dans le cas d'une situation non binaire, on peut introduire des conditions supplémentaires qui sont examinées si les conditions précédentes ne sont pas remplies. On peut par exemple nuancer notre situation ainsi :
+
+ \begin{example} S'il fait beau, j'irai en montagne. S'il ne fait pas beau et qu'il pleut, j'irai au cinéma. Sinon, j'irai courir au bord du Rhône. \end{example}
+
+ \begin{remarque} Ici, le terme \textit{Sinon} signifie "S'il ne fait pas beau et qu'il ne pleut pas". C'est pareil en python, l'instruction conditionnée par |else| est exécutée si toutes les conditions précédentes sont fausses. \end{remarque}
+
+ Notre algorithme devient alors :
+
+\paragraph{}
+\begin{tabular}{ c l }
+ Étapes & Instructions \\ \hline
+ 1 & Se lever \\
+ 2 & Regarder la météo \\
+ 3.1 & S'il fait beau, aller en montagne \\
+ 3.2 & S'il ne fait pas beau et qu'il pleut, aller au cinéma \\
+ 3.3 & S'il ne fait pas beau et qu'il pleut pas, aller courir au bord du Rhône \\
+\end{tabular}
+
+\paragraph{}
+En python, on utilise l'instruction |elif| qui est la contraction de \textit{else if} :
+
+\lstset{caption={Instruction if - else}}
+\begin{lstlisting}
+if meteo == "beau":
+ print("Aujourd'hui, je vais en montagne.")
+elif meteo == "pluie":
+ print("Aujourd'hui, je vais au cinéma.")
+else:
+ print("Aujourd'hui, je vais courir au bord du Rhône.")
+\end{lstlisting}
+
+
+\subsection{Exercices sur papier}
+
+\begin{exercice}
+Que vaut la variable solution à la fin du programme suivant ? % rep : 1202
+Réponse :
+
+\end{exercice}
+\lstset{caption={Exercice}}
+\begin{lstlisting}
+a = True
+b = ((2+2) > 4)
+c = (2==3)
+
+if c:
+ solution=42
+elif b:
+ solution=2021
+elif a:
+ solution=1202
+else:
+ solution=73
+\end{lstlisting}
+
+\begin{exercice}
+Que vaut la variable solution à la fin du programme suivant ? % rep : C
+Réponse :
+\end{exercice}
+
+\lstset{caption={Exercice}}
+\begin{lstlisting}
+a = 42
+b = 2021
+c = 1202
+d = 73
+
+if c < (d+a):
+ solution = "A"
+elif b+c == a:
+ solution = "B"
+elif a<=42:
+ solution = "C"
+else:
+ solution = "D"
+
+\end{lstlisting}
+
+
+
+\subsection{Exercices sur les ordinateurs}
+
+\begin{exercice}
+Écrivez un programme vérifiant si un nombre A est un multiple d'un autre nombre B.
+Utilisez pour cela l'opérateur modulo "\%", qui, pour |x%y|, retourne le reste de la division euclidienne de x par y. \\
+Testez avec A=2941 et B=17.
+\end{exercice}
+
+
+\begin{exercice}
+Écrivez un programme vérifiant si un nombre A est un multiple de 2 nombres B et C.\\
+Testez avec A=26469, B=17 et C=9.
+\end{exercice}
+
+
+\begin{exercice}
+\label{exo:min}
+Écrivez un programme trouvant le minimum entre 3 nombres.
+\end{exercice}
+
+\begin{exercice}
+Écrivez un programme déterminant si une année est bissextile.
+\end{exercice}
+
+%TODO
+%% Joli template pour code, black skin
+%% recap structure elif ?
+%% exo meteo ?
+%% exos prog comprendre fonctionnement complexe ?
+
+
+
+\section{Bibliographie}
+\begin{itemize}
+\item \textit{L’Informatique autrement}, De la pensée computationelle aux applications numériques, Dimitri Racordon, Damien Morard, Emmanouela Stachtiari,Aurélien Coet, Alexandre-Quentin Berger, Didier Buchs
+\item https://openclassrooms.com/fr/courses/7168871-apprenez-les-bases-du-langage-python
+\item https://docs.python.org/fr/3/tutorial/index.html
+\end{itemize}
+
+
+\end{document}
diff --git "a/11-Chapitre r\303\251seau.tex" "b/11-Chapitre r\303\251seau.tex"
new file mode 100644
index 0000000000000000000000000000000000000000..9046ae61dec6ba208881a0184a8371df5279f0b7
--- /dev/null
+++ "b/11-Chapitre r\303\251seau.tex"
@@ -0,0 +1,1532 @@
+\documentclass[11pt, a4paper]{book}
+\input{package}
+\pgfplotsset{compat=1.17}
+
+
+
+
+\begin{document}
+\setcounter{chapter}{6}
+\chapter{Réseaux informatiques}
+
+\section{Introduction}
+
+
+\subsection{Activité 1}
+
+Par groupe de 4 à 6 élèves autour d'une même table.
+
+\
+
+{\bf Objectif:} Trouver la méthode la plus simple pour que chaque élève puisse envoyer un message à un autre élève autour de la table.
+
+\
+
+Proposition:
+
+\vskip+3cm
+
+Solution:
+
+\vskip+3cm
+
+Difficultés:
+
+\vskip+3cm
+
+\subsection{Activité 2}
+Par groupe de 4 à 6 élèves autour d'une même table.
+
+\
+
+{\bf Contrainte:} Chaque élève établit la liste des élèves auxquels il peut envoyer un message. Pour chaque nom inscrit, il doit payer 10 francs. Le {\it prix total de la table} consiste à additionner le prix des listes de chaque élève autour de la table.
+
+\
+
+\begin{remarque}
+Pour illustrer la contrainte, imaginons que 4 personnes, nommées {\it A}, {\it B}, {\it C} et {\it D} se trouvent autour de la table. {\it A} met sur sa liste {\it C} et {\it D} ({\it A} peut donc envoyer un message à {\it C} et {\it D } mais pas {\it C}). {\it B} met sur sa liste {\it A}. {\it C} met sur sa liste {\it A} et {\it B}. {\it D} ne met personne sur sa liste.
+
+Le prix total de la table est donc: $2 \cdot 10 + 1 \cdot 10 + 2 \cdot 10 + 0 \cdot 10=50 Frs$
+
+\end{remarque}
+\
+
+{\bf Objectif:} Trouver une méthode simple pour que chaque élève puisse envoyer un message à un autre élève autour de la table {\bf et} que le {\it prix total de la table} soit le plus bas possible.
+
+\
+
+Proposition :
+
+\vskip+3cm
+
+Solution:
+
+\vskip+3cm
+
+Difficultés:
+
+\vskip+3cm
+
+
+\subsection{Activité 3}
+Par groupe de 4 à 6 élèves autour d'une même table.
+
+\
+
+{\bf Contrainte:} Si un élève $A$ peut envoyer un message à un élève $B$ alors $B$ peut aussi en envoyer à $A$ : si $A$ a inscrit $B$ sur sa liste alors $B$ a aussi inscrit $A$ sur sa liste.
+
+\
+
+{\bf Objectif:} Trouver une méthode simple pour que chaque élève puisse envoyer un message à un autre élève autour de la table {\bf et} que le {\it prix total de la table} soit le plus bas possible.
+
+\
+
+Proposition :
+
+\vskip+3cm
+
+Solution:
+
+\vskip+3cm
+
+Difficultés:
+
+\vskip+3cm
+
+
+
+
+
+\subsection{Activité 4}
+
+Par groupe de 4 à 6.
+
+\
+
+{\bf Objectif:} Trouver une méthode simple pour que chaque élève puisse envoyer un message à un autre élève {\bf dans la classe} et que le prix total de la classe soit le plus bas possible.
+
+\
+
+Proposition :
+
+\vskip+3cm
+
+Solution:
+
+\vskip+3cm
+
+Difficultés:
+
+\vskip+3cm
+
+\newpage
+
+\section{Réseaux et graphes}
+\subsection{Définition}
+
+\begin{defi}
+Un {\bf réseau informatique} est un ensemble d'équipements reliés entre eux pour échanger des informations.
+\end{defi}
+
+\
+\begin{exercice}
+Quels exemples de réseaux connaissez-vous?
+
+\end{exercice}
+
+\subsection{Les types de réseaux}
+
+\subsubsection{Les réseaux personnels}
+
+Les {\bf réseaux personnels} ou {\bf PAN (Personnal Area Network)} en anglais, permettent à des appareils de communiquer entre eux à l'échelle d'une personne. Il couvre des distances ne dépassant pas quelques mètres. Un exemple de PAN est la technologie {\it bluetooth} permettant de connecter une souris ou un clavier à un ordinateur.
+
+\subsubsection{Les réseaux locaux}
+
+Les {\bf réseaux locaux} ou {\bf LAN (Local Area Network)} en anglais, correspondent aux réseaux privés: chez les particuliers, dans les entreprises, les écoles, les universités, les administrations... Ils couvrent le plus souvent des distances allant d'une dizaine à une centaine de mètres. Un exemple est le réseau Wi-Fi d'une habitation.
+
+\subsubsection{Les réseaux étendus}
+
+Les {\bf réseaux étendus} ou {\bf WAN (Wide Area Network)} en anglais, sont les réseaux qui couvrent de vastes régions géographiques, telles qu'un pays ou un continent. Ils couvrent des distances allant jusqu'à plusieurs milliers de kilomètres. Un exemple de WAN est le réseau privé d'une entreprise qui connecte ses différentes branches dans un pays.
+
+\subsubsection{Les inter-réseaux}
+
+Les {\bf inter-réseaux} ou {\bf internetwork} en anglais sont les réseaux les plus connus puisque Internet fait partie de cette catégorie. Comme l'indique leur nom, ces réseaux connectent plusieurs sous-réseaux qui peuvent être de taille et de nature différentes. Ils couvrent de grandes zones géographiques, comme c'est le cas d'Internet.
+
+\begin{exercice}
+Dans quel type de réseaux se classent les réseaux suivants?
+\begin{enumerate}
+\item Le réseau Wi-Fi dans le fast-food où je mange.
+\item Ma manette de jeu sans fil connecté à ma console de jeu.
+\item Le réseau connectant toutes les succursales Toyota.
+\item Le réseau connectant les postes suisses.
+\item Le réseau de l'université de Genève.
+\item Internet.
+\item Mon téléphone connecté à mon ordinateur pour transférer des photos.
+
+\end{enumerate}
+
+
+
+\end{exercice}
+
+
+
+
+\subsection{Graphes}
+
+Afin de bien représenter les différents types de réseaux, nous avons besoin de définir une structure spécifique, qui se nomme le {\bf graphe}:
+
+\begin{defi}
+Un {\bf graphe} est une structure de données composée de {\bf noeuds}, qui représentent les entités avec lesquelles on travaille, et d'{\bf arcs} qui représentent les connections entre les noeuds.
+
+\end{defi}
+
+Par exemple, si nous avons 4 élèves nommés {\it A}, {\it B}, {\it C} et {\it D} et que nous voulons que {\it A} soit relié à {\it B} et {\it D}, et que {\it D} soit relié à {\it B} et {\it C} alors nous pouvons représenter cette situation par le graphe suivant:
+
+
+
+\begin{center}
+\begin{tikzpicture}[scale=.45]
+\filldraw[fill=lightgray] (0,0) circle (1cm);
+\draw (0,0) node {$A$};
+
+\filldraw[fill=lightgray] (6,0) circle (1cm);
+\draw (6,0) node {$B$};
+
+\filldraw[fill=lightgray] (6,6) circle (1cm);
+\draw (6,6) node {$C$};
+
+\filldraw[fill=lightgray] (0,6) circle (1cm);
+\draw (0,6) node {$D$};
+
+\draw[thick] (1,0) -- (5,0);
+\draw[thick] (0,1) -- (0,5);
+\draw[thick] (1,6) -- (5,6);
+\draw[thick] (1.41/2,6-1.41/2) -- (6-1.41/2,1.41/2);
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+Ce graphe a 4 nœuds et 4 arcs. Un arc peut être noté $(A;B)$ pour signifié qu'il y a une connexion entre les nœuds $A$ et $B$.
+
+\begin{exercice}
+Tracer les graphes suivants:
+\begin{enumerate}
+\item Un graphe avec 5 nœuds nommés $A$, $B$, $C$, $D$ et $E$ et tel que $A$ et $E$ soient connectés à tous les autres nœuds.
+\item Un graphe avec 6 nœuds nommés $A$, $B$, $C$, $D$, $E$ et $F$ et avec les arcs suivants: $(A;B)$, $(B;C)$, $(C;D)$, $(D;E)$ et $(E;A)$.
+\item Un graphe avec 4 nœuds $A$, $B$, $C$ et $D$ et chaque nœud est connecté à tous les autres nœuds.
+
+\end{enumerate}
+
+\end{exercice}
+
+
+\section{Topologies des réseaux}
+
+\subsection{Définition}
+
+\begin{defi}
+La {\bf topologie} d'un réseau décrit la façon dont sont connectés ses nœuds entre eux.
+\end{defi}
+
+
+
+\subsection{Topologie en bus}
+
+\begin{defi}
+Dans un {\bf réseau en bus} tous les nœuds du réseau sont connectés au même support (un câble par exemple), appelé bus. Lorsqu’un nœud envoie de l'information sur le bus, tous les autres nœuds la reçoivent.
+\end{defi}
+
+Par exemple, le graphe suivant représente 5 appareils connecté en réseau en bus.
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+\filldraw[fill=lightgray] (0,0) circle (1cm);
+%\draw (0,0) node {$A$};
+
+\filldraw[fill=lightgray] (4,0) circle (1cm);
+%\draw (6,0) node {$B$};
+
+\filldraw[fill=lightgray] (8,0) circle (1cm);
+%\draw (6,6) node {$C$};
+
+\filldraw[fill=lightgray] (12,0) circle (1cm);
+
+\filldraw[fill=lightgray] (16,0) circle (1cm);
+%\draw (0,6) node {$D$};
+
+\draw[thick] (0,1) -- (0,4);
+\draw[thick] (4,1) -- (4,4);
+\draw[thick] (8,1) -- (8,4);
+\draw[thick] (12,1) -- (12,4);
+\draw[thick] (16,1) -- (16,4);
+
+\filldraw[fill=lightgray] (-1,3) rectangle (17,4);
+
+\draw (8,3.5) node {Bus};
+
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item {\bf Avantages} :
+ \begin{enumerate}
+ \item Tous les appareils sont connectés entre eux et peuvent donc communiquer directement.
+ \item Facile à mettre en œuvre et fonctionnement simple.
+ \item Ajout d'un appareil facile.\\
+ \end{enumerate}
+\item {\bf Désavantages} :
+ \begin{enumerate}
+ \item Une rupture de câble produit une déconnexion des appareils.
+ \item Les collisions (plusieurs informations simultanées mises sur le bus) sont fréquentes.
+ \item Plus il y a d'appareils connectés, plus il y a une baisse des performances du réseau.
+ \end{enumerate}
+\end{enumerate}
+\end{remarques}
+
+
+
+
+
+
+
+
+
+
+
+
+\subsection{Topologie en étoile}
+
+
+\begin{defi}
+Dans un {\bf réseau en étoile} les nœuds du réseau sont tous connectés à un même appareil central appelé {\bf concentrateur} ({\bf hub} en anglais) ou {\bf commutateur} ({\bf switch} en anglais). Le rôle de cet appareil central est de gérer les communications entre les appareils connectés au réseau.
+\end{defi}
+
+Par exemple, le graphe suivant représente un réseau en étoile avec 6 appareils connectés à un concentrateur.
+
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+
+\draw (-4,0) -- (4,0);
+\draw (-2,3.8) -- (2,-3.8);
+\draw (-2,-3.8) -- (2,3.8);
+
+\filldraw[fill=lightgray] (0,0) circle (1.2cm);
+%\draw (0,0) node {$A$};
+
+
+
+\filldraw[fill=lightgray] (4,0) circle (1cm);
+%\draw (6,0) node {$B$};
+
+\draw (0,0) node {hub};
+
+\filldraw[fill=lightgray] (-4,0) circle (1cm);
+%\draw (6,6) node {$C$};
+
+\filldraw[fill=lightgray] (-2,3.8) circle (1cm);
+
+\filldraw[fill=lightgray] (2,3.8) circle (1cm);
+
+\filldraw[fill=lightgray] (-2,-3.8) circle (1cm);
+
+\filldraw[fill=lightgray] (2,-3.8) circle (1cm);
+
+
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item {\bf Avantages} :
+ \begin{enumerate}
+ \item Tous les appareils communiquent entre eux aisément, le risque de collision est réduit.
+ \item La panne d'un appareil ne réduit pas l'efficacité du réseau.
+ \item L'ajout d'un appareil est facile.\\
+ \end{enumerate}
+\item {\bf Désavantages} :
+ \begin{enumerate}
+ \item Il est plus coûteux qu'en réseau en bus car nécessite un concentrateur ou un commutateur.
+ \item L'efficacité du réseau est conditionné au bon fonctionnement du concentrateur ou du commutateur.
+ \end{enumerate}
+\end{enumerate}
+\end{remarques}
+
+
+
+\subsection{Topologie en anneau}
+\begin{defi}
+Dans un {\bf réseau en anneau}, chaque appareil est connecté à deux appareils avec lesquels il peut communiquer, formant ainsi une boucle.
+
+\noindent Un ordinateur n'accepte une information que si elle lui est destinée sinon il fait passer l'information à l'ordinateur suivant.
+\end{defi}
+
+Par exemple, le graphe suivant représente un réseau de 6 appareils connectés en anneau.
+
+
+
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+
+\draw (-4,0) -- (-2,3.8) -- (2,3.8) -- (4,0) -- (2,-3.8) -- (-2,-3.8) -- cycle;
+
+
+
+%\draw (0,0) node {$A$};
+
+
+
+\filldraw[fill=lightgray] (4,0) circle (1cm);
+%\draw (6,0) node {$B$};
+
+
+
+\filldraw[fill=lightgray] (-4,0) circle (1cm);
+%\draw (6,6) node {$C$};
+
+\filldraw[fill=lightgray] (-2,3.8) circle (1cm);
+
+\filldraw[fill=lightgray] (2,3.8) circle (1cm);
+
+\filldraw[fill=lightgray] (-2,-3.8) circle (1cm);
+
+\filldraw[fill=lightgray] (2,-3.8) circle (1cm);
+
+
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item {\bf Avantages} :
+ \begin{enumerate}
+ \item Le nombre de câbles est réduit.
+ \item Il y a absence de collision.
+ \item Le réseau est fiable.\\
+ \end{enumerate}
+\item {\bf Désavantages} :
+ \begin{enumerate}
+ \item La panne de deux ordinateurs arrête le réseau.
+ \item L'ajout ou la suppression d'un ordinateur paralyse le système.
+ \end{enumerate}
+\end{enumerate}
+\end{remarques}
+
+
+\subsection{Topologie maillée}
+
+\begin{defi}
+Dans un {\bf réseau maillé} les appareils sont connectés les uns aux autres de manière arbitraire.
+
+\noindent Lorsqu’un nœud veut envoyer un message à un autre, il doit trouver un chemin à travers le réseau pour que l’information puisse atteindre sa destination.
+\end{defi}
+
+Par exemple, le graphe suivant représente un réseau maillé avec 8 noeuds et 11 arcs.
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+
+\coordinate (A) at (-4,0);
+\coordinate (B) at (-2,3);
+\coordinate (C) at (-2,-3);
+\coordinate (D) at (0,0);
+\coordinate (E) at (2,3);
+\coordinate (F) at (2,-3);
+\coordinate (G) at (4,0);
+\coordinate (H) at (6,3);
+
+\draw (A) -- (B);
+\draw (A) -- (C);
+\draw (A) -- (D);
+\draw (D) -- (G);
+\draw (D) -- (H);
+\draw (E) -- (H);
+\draw (G) -- (H);
+\draw (G) -- (F);
+\draw (F) -- (A);
+\draw (F) -- (C);
+\draw (F) -- (D);
+
+
+
+\filldraw[fill=lightgray] (C) circle (1cm);
+%\draw (6,0) node {$B$};
+
+
+\filldraw[fill=lightgray] (0,0) circle (1cm);
+%\draw (6,0) node {$B$};
+
+\filldraw[fill=lightgray] (-4,0) circle (1cm);
+%\draw (6,6) node {$C$};
+
+\filldraw[fill=lightgray] (4,0) circle (1cm);
+
+\filldraw[fill=lightgray] (2,3) circle (1cm);
+
+\filldraw[fill=lightgray] (6,3) circle (1cm);
+
+\filldraw[fill=lightgray] (2,-3) circle (1cm);
+
+\filldraw[fill=lightgray] (-2,3) circle (1cm);
+
+\filldraw[fill=lightgray] (-2,3) circle (1cm);
+
+
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item {\bf Avantages} :
+ \begin{enumerate}
+ \item La panne d'un câble ou d'un appareil n'influence pas l'efficacité du réseau.
+ \item Il est possible de connecter beaucoup d'appareils.\\
+ \end{enumerate}
+\item {\bf Désavantages} :
+ \begin{enumerate}
+ \item Un réseau maillé nécessite une stratégie pour envoyer les informations au bon destinataire.
+ \item Un réseau maillé nécessite de nombreuses connexions pour augmenter sa fiabilité.
+ \end{enumerate}
+\end{enumerate}
+\end{remarques}
+
+
+
+
+
+
+
+\subsection{Topologie maillé complètement}
+
+C'est le réseau le plus évident. Lorsque deux appareils veulent communiquer, ils s'envoient directement les informations car ils sont connectés l'un à l'autre.
+
+\begin{defi}
+Dans un {\bf réseau maillé complètement} tous les nœuds sont connectés à tous les autres. Dans ce cas, les nœuds peuvent communiquer directement entre eux, sans passer par aucun intermédiaire.
+\end{defi}
+
+\
+
+Par exemple, le graphe suivant représente un réseau à 4 nœuds maillé complètement.
+
+
+\begin{center}
+\begin{tikzpicture}[scale=.5]
+\filldraw[fill=lightgray] (0,0) circle (1cm);
+%\draw (0,0) node {$A$};
+
+\filldraw[fill=lightgray] (6,0) circle (1cm);
+%\draw (6,0) node {$B$};
+
+\filldraw[fill=lightgray] (6,6) circle (1cm);
+%\draw (6,6) node {$C$};
+
+\filldraw[fill=lightgray] (0,6) circle (1cm);
+%\draw (0,6) node {$D$};
+
+\draw[thick] (1,0) -- (5,0);
+\draw[thick] (0,1) -- (0,5);
+\draw[thick] (1,6) -- (5,6);
+\draw[thick] (1.41/2,6-1.41/2) -- (6-1.41/2,1.41/2);
+\draw[thick] (1.41/2,1.41/2) -- (6-1.41/2,6-1.41/2);
+\draw[thick] (6,1) -- (6,5);
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item {\bf Avantages} :
+ \begin{enumerate}
+ \item La panne d'une connexion ou d'un appareil n'influence pas le réseau.
+ \item La transmission des informations entre appareils est directe.\\
+ \end{enumerate}
+\item {\bf Désavantages} :
+ \begin{enumerate}
+ \item Ce réseau est coûteux en connexions.
+ \item Il est difficile à mettre en pratique.
+ \item Il est inadapté à des réseaux ayant trop d'appareils.
+ \end{enumerate}
+\end{enumerate}
+\end{remarques}
+
+\subsection{Exercices}
+
+\begin{exercice}
+Combien de connexions faut-il pour faire un réseau maillé complet contenant:
+\begin{enumerate}
+ \item 3 appareils?
+ \item 5 appareils?
+ \item 10 appareils?
+ \item $n$ appareils?
+\end{enumerate}
+\end{exercice}
+
+
+
+
+
+\begin{exercice}
+À quelle topologie correspondent les graphes suivants?
+
+\begin{center}
+\begin{tikzpicture}
+\draw (0,0) node {a)};
+\draw (8,0) node {b)};
+
+\coordinate (A) at (1,-3.5);
+\coordinate (B) at (3,-2.7);
+\coordinate (C) at (5,-3.5);
+\coordinate (D) at (2,-1);
+\coordinate (E) at (4,-1);
+
+\coordinate (F) at (13,0,);
+\coordinate (G) at (15,-2);
+\coordinate (H) at (10,-3);
+\coordinate (I) at (9,-5);
+\coordinate (J) at (12,-4);
+\coordinate (K) at (13,-6);
+
+\draw (F) -- (G) -- (H) -- (I) -- (J) -- (K) -- cycle;
+
+
+\foreach \x in {(A),(B),(C),(D),(E)}
+ \foreach \y in {(A),(B),(C),(D),(E)}
+ \draw \x -- \y;
+
+\foreach \x in {(A),(B),(C),(D),(E),(F),(G),(H),(I),(J),(K)}
+ \filldraw[fill= lightgray] \x circle (.5cm);
+
+
+
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+\begin{center}
+\begin{tikzpicture}[scale=.9]
+\draw (0,0) node {c)} ;
+\draw (8,0) node {d)};
+
+\coordinate (A) at (4,-1);
+\coordinate (B) at (6,-2);
+\coordinate (C) at (1,-3.5);
+\coordinate (D) at (3,-3.5);
+\coordinate (E) at (1,-6);
+\coordinate (F) at (5,-5.5,);
+
+\coordinate (G) at (15,-2);
+\coordinate (H) at (10,-3);
+\coordinate (I) at (9,-5);
+\coordinate (J) at (12,-4);
+\coordinate (K) at (13,-6);
+\coordinate (L) at (11,-1);
+
+
+
+\foreach \x in {(A),(B),(C),(D),(E),(F)}
+ \draw \x -- (B);
+
+\draw (D) -- (E);
+\draw (F) -- (E);
+
+\foreach \x in {(G),(H),(I),(J),(K),(L)}
+ \draw \x -- (H);
+
+\foreach \x in {(A),(B),(C),(D),(E),(F),(G),(H),(I),(J),(K),(L)}
+ \filldraw[fill= lightgray] \x circle (.5cm);
+
+\end{tikzpicture}
+\end{center}
+\end{exercice}
+
+
+\begin{exercice}
+A quel type de réseau correspondent le mieux les situations suivantes? Les représenter ensuite par un graphe.
+\begin{enumerate}
+\item Dans une entreprise, quand un employé veut contacter un autre employé, il doit d'abord appeler un standardiste qui redirige son appel vers la bonne personne.
+\item Le distributeur de journaux fait sa tournée dans un lotissement et pose dans la boite aux lettres d'une personne les revues qui lui sont destinées.
+\item Dans un bureau, trois ordinateurs sont reliés les uns aux autres par un câble. De plus, une imprimante est relié en bluetooth à chaque ordinateur.
+\item Le jeu du téléphone sans fil: un enfant donne une information à son voisin de droite qui la répète lui aussi à son voisin de droite, jusqu'à revenir au premier qui compare ce qu'il a entendu avec ce qu'il avait dit.
+\item La route que je choisis pour aller en voiture d'un point $A$ à un point $B$.
+
+\begin{exercice}
+Dessiner le graphe des réseaux suivants:
+\begin{enumerate}
+\item Un réseau en anneau de 7 ordinateurs.
+\item Un réseau de 6 ordinateurs complètement maillé.
+\item Un réseau en bus de 10 ordinateurs.
+\item Un réseau en étoile de 6 ordinateurs reliés à un commutateur et avec une imprimante reliée à un des ordinateurs.
+\item Deux commutateurs connectés et à chacun des commutateurs sont reliés 5 ordinateurs en étoile.
+
+\end{enumerate}
+\end{exercice}
+
+\end{enumerate}
+
+
+\end{exercice}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{Les connexions réseau}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+\subsection{Les support câblés}
+
+%\subsubsection{Définition}
+
+\begin{defi}
+Un {\bf support câblé} transmet des données d'un ordinateur à un autre ordinateur à travers un câble qui les relie. Les câbles permettent la communication entre deux appareils: cela signifie qu'il n'y a qu'un seul envoyeur et un seul receveur. On appelle cela une {\bf diffusion unicast}.
+\end{defi}
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item L'information dans un support câblé est transmise à l'aide d'un signal électrique ou lumineux.
+\item Le support câblé est plus sûr car il connecte directement deux appareils.
+\end{enumerate}
+
+\end{remarques}
+
+\subsubsection{Les câbles RJ45}
+
+
+
+
+Le câble RJ45 est un câble composé de fils de cuivre qui repose sur la technologie Ethernet. Il permet de connecter de nombreux type d'appareils entre eux.
+
+Les câbles RJ45 transmettent les données par signal électrique. Le débit théorique de ces câbles dépend de la catégorie du câble:
+\begin{enumerate}
+\item Catégorie 5e: jusqu'à 1 Gbit/s
+\item Catégorie 6: jusqu'à 10 Gbit/s
+\item Catégorie 6A: jusqu'à 10 Gbit/s (mais sur une plus haute fréquence et sur une plus longue distance)
+\item Catégorie 7A: jusqu'à 40 Gbit/s
+\end{enumerate}
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/RJ45}
+\caption{connecteur d'un câble RJ45}
+\end{center}
+\end{figure}
+
+\begin{exercice}
+Quels types d'appareils sont fréquemment connectés par ce type de câble?
+\end{exercice}
+
+
+\subsubsection{L'USB}
+
+
+
+L'USB ({\it Universal Serial Bus}) est une norme de bus informatique permettant de connecter des appareils entre eux. Aujourd'hui, l'USB-C est le connecteur utilisé sur tous les appareils et peut être adapté pour recevoir d'autre type de connecteurs.
+
+
+
+
+Les câbles avec des connecteurs USB transmettent les données par signal électrique. Le débit théorique de ces câbles dépend du type du connecteur:
+\begin{enumerate}
+\item Type 1: jusqu'à 12 Mbit/s (1996)
+\item Type 2: jusqu'à 480 Mbit/s (2000)
+\item Type 3: jusqu'à 4.8 Gbit/s (2008)
+\item Type 3.1: jusqu'à 10 Gbit/s
+\item Type 4: jusqu'à 40 Gbit/s (2017)
+\end{enumerate}
+
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.4]{images/usb}
+\caption{Les différents types de connecteur USB}
+\end{center}
+\end{figure}
+
+\begin{exercice}
+Quel est l'usage le plus fréquent des câbles USB?
+\end{exercice}
+
+
+
+\subsubsection{La fibre optique}
+
+La fibre optique est un petit "câble" en verre ou en plastique dans lequel un rayon lumineux "rebondit". L'information est transmise par un signal lumineux.
+
+Les avantages de la fibre optique sont:
+\begin{enumerate}
+\item Sa très faible perte de débit sur de longues distances.
+\item Sa durée de vie (plus de 100 ans).
+\item Une connexion Internet particulière plus rapide (jusqu'à 1 GB/s)
+\end{enumerate}
+
+Son principal désavantage est qu'elle est plutôt fragile et plus vulnérable aux dommages que peuvent l'être les fils de cuivre.
+
+% image ajouté par edba le 18.04.2022
+\begin{figure}[h]
+\begin{center}
+\includegraphics[scale=.5]{images/connecteurs-fibre-optique.png}
+\caption{Les connecteurs optiques les plus utilisés}
+\end{center}
+\end{figure}
+
+
+% complété par edba le 18.04.2022
+\begin{remarque}
+Début 2021, l'entreprise Google a mis en activité son nouveau câble de fibre optique reliant l'Europe aux Etats-Unis, soit 6'400 km de câble. Ce câble a un débit de 250 Tbits/s soit 250 000 Gbit/s. Il existe des milliers câbles sous-marins dans le monde. Certains sites les recensent comme par exemple: https://www.infrapedia.com/app
+\end{remarque}
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\subsection{Les supports aériens}
+
+\begin{defi}
+Les {\bf supports aériens} envoient les données entre machines à travers d'antennes qui jouent le rôle d'émetteurs/receveurs. L'information est envoyée sous la forme d'ondes radio ou d'ondes électromagnétiques. Les supports aériens permettent les communications d'un point vers plusieurs à la fois. On appelle cela une {\bf diffusion broadcast}.
+\end{defi}
+
+
+\begin{remarque}
+La connexion par supports aériens demande plus de sécurité car il est plus facile d'{\it intercepter} la communication entre deux appareils ou de se connecter à un router Wi-Fi afin de bénéficier de sa connexion.
+\end{remarque}
+
+\subsubsection{Wi-Fi}
+
+Le Wi-Fi est un ensemble de protocoles (ou de règles) permettant la communication sans fil d'appareils. Un réseau particulier avec un router Wi-Fi est un bon exemple de réseau en étoile où tous les appareils d'une habitation sont reliés au même dispositif.
+
+La vitesse de connexion d'un routeur Wi-Fi dépend de sa norme:
+\begin{enumerate}
+\item la première norme, la 802.11b (1999): 11 Mbit/s.
+\item la norme 802.11g (2003): 54 Mbit/s.
+\item la norme 802.11ac (2013): 1,3 Gbit/s.
+\item la norme 802.11ax (2021): 10,5 Gbit/s
+\item la norme 802.11be (futur norme): En cours de définition
+\end{enumerate}
+La norme 802.11ax est la dernière norme 802.11 officielle. La distance du réseau dépend aussi de la norme. La dernière norme offre une portée de 70 mètres.
+
+\begin{remarque}
+La distance a un fort impact sur le débit du Wi-Fi. Pour y remédier, il faut augmenter la couverture du réseau en utilisant par exemple des répéteurs (appareils qui prennent le signal Wi-Fi et le répètent plus intensément).
+\end{remarque}
+
+\subsubsection{4G - 5G}
+
+La 4G et la 5G sont les 4e et 5e générations des standards pour la téléphonie mobile. La 4G a remplacé la 3G au début des années 2000 et a permis une multiplication par 500 du débit (1 Gb/s).
+
+L'augmentation du nombre d'appareils connectés rend la 4G obsolète. Elle sera petit à petit remplacée par la 5G qui offre un débit 100 fois plus rapide que la 4G.
+
+\subsubsection{Autres supports aériens}
+
+On peut citer l'infrarouge, le bluetooth (jusqu'à 54 Mbit/s pour la dernière norme), ou les connexions satellites comme autres support aériens.
+
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{La Communication dans les réseaux}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\subsection{Les types de nœuds dans un réseau}
+
+Dans un réseau, différents appareils sont connectés entre eux. Au niveau du graphe représentant ce réseau, ils correspondent aux nœuds. Ces nœuds sont de différentes natures.
+
+\subsubsection{Ordinateurs personnels}
+
+Le nœud le plus évident est l'{\bf ordinateur personnel} puisque c'est avec celui-ci que l'utilisateur rentre dans le réseau. Dans cette catégorie, on retrouve les ordinateurs de bureaux, les ordinateurs portables, les tablettes, les smartphones...
+
+\subsubsection{Les périphériques}
+
+D'autres types de nœud couramment rencontrés sont les {\bf périphériques}. Les périphériques permettent principalement d'accomplir une tâche demandée par un ordinateur personnel. Dans cette catégorie, on retrouve les imprimantes, les photocopieuses, les scanners, les caméras de surveillance, les vidéo-projecteurs...
+
+\subsubsection{Les routeurs}
+
+Moins visible par l'utilisateur mais essentiel au bon fonctionnement du réseau, le {\bf routeurs} est, comme son nom l'indique, l'appareil qui va établir les routes pour que les données arrivent au bon endroit. Cependant, un routeur n'a qu'une information limitée. Il ne connaît que ses voisins directs et ne sait pas ce qu'il se passe au-delà d'eux.
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\subsection{Activité de groupes}
+
+\begin{center}
+\begin{tikzpicture}[scale=.85]
+
+\def\long{.3};
+
+\coordinate (A) at (3,4);
+\coordinate (B) at (8,4);
+\coordinate (C) at (2,8);
+\coordinate (D) at (9,8);
+\coordinate (E) at (3,12);
+\coordinate (F) at (8,12);
+
+\coordinate (AA) at (1,0);
+\coordinate (AB) at (3,0);
+\coordinate (AC) at (5,0);
+\coordinate (AD) at (5,2);
+\coordinate (AE) at (3,2);
+\coordinate (AF) at (1,2);
+
+\coordinate (BA) at (7,1);
+\coordinate (BB) at (8,2);
+\coordinate (BC) at (10,2);
+\coordinate (BD) at (10,4);
+
+\coordinate (CA) at (0,5);
+\coordinate (CB) at (0,7);
+\coordinate (CC) at (0,9);
+
+\coordinate (FA) at (10,13);
+\coordinate (FB) at (10,15);
+\coordinate (FC) at (12,13);
+\coordinate (FD) at (12,15);
+
+\coordinate (EA) at (3,14);
+\coordinate (EB) at (1,14);
+\coordinate (EC) at (0,13);
+\coordinate (ED) at (0,11);
+
+\coordinate (PA) at (0,4);
+\coordinate (PB) at (10,6);
+\coordinate (PC) at (11,8);
+\coordinate (PD) at (11,10);
+\coordinate (PE) at (4,9);
+
+%legende
+\coordinate (triangle) at (0,-1);
+\coordinate (rond) at (0,-2);
+\coordinate (carre) at (0,-3);
+
+\draw (E) -- (F);
+\draw (C) -- (D) -- (F)
+ (E) -- (C)
+ (C) -- (B)
+ (A) -- (D)
+ (AA) -- (AB) -- (AC) -- (AD) -- (AE) -- (AF) -- (AA)
+ (A) -- (AE)
+ (B) -- (BA)
+ (B) -- (BB)
+ (B) -- (BC)
+ (B) -- (BD)
+ (C) -- (CA)
+ (C) -- (CB)
+ (C) -- (CC)
+ (F) -- (FA) -- (FB) -- (FC) -- (FD) -- (FA)
+ (FB) -- (FD)
+ (FA) -- (FC)
+ (E) -- (EA)
+ (E) -- (EB)
+ (E) -- (EC)
+ (E) -- (ED)
+ (PA) -- (CA)
+ (D) -- (PB)
+ (D) -- (PC)
+ (D) -- (PD)
+ (C) -- (PE);
+
+
+%tracer des carrés
+\foreach \x in {(A),(B),(C),(D),(E),(F),(carre)}
+ \filldraw[fill=lightgray] \x ++(-\long,-\long) rectangle ++(2*\long,2*\long);
+
+%tracé des cercle
+\foreach \x in {(AA),(AB),(AC),(AD),(AE),(AF),
+ (BA),(BB),(BC),(BD),
+ (CA),(CB),(CC),
+ (FA),(FB),(FC),(FD),
+ (EA),(EB),(EC),(ED),
+ (rond)}
+ \filldraw[fill=lightgray] \x circle (\long);
+
+
+%tracé des triangles
+\foreach \x in {(PA),(PB),(PC),(PD),(PE),(triangle)}
+ \filldraw[fill=lightgray] \x ++(-\long,-\long) -- ++(2*\long, 0) -- ++(-\long,1.6*\long) -- cycle;
+,
+\draw (carre) +(.5,0) node[anchor=west] {: routeurs} ;
+\draw (triangle) +(0.5,0) node[anchor=west] {: périphériques} ;
+\draw (rond) +(.5,0) node[anchor=west] {: ordinateurs} ;
+
+\end{tikzpicture}
+
+\end{center}
+
+
+Par groupe de 3 ou 4 élèves, prendre connaissance de la situation suivante puis répondre aux différentes questions:
+
+\
+
+Le graphe ci-dessus représente le réseau d'une entreprise, avec des ordinateurs de travail (représentés par des cercles), des routeurs (représentés par des carrés) et des périphériques (représentés par des triangles).
+
+\newpage
+
+{\bf Question 1:} Quels types de sous-réseaux reconnaissez vous dans ce graphe?
+
+\vskip+3cm
+
+{\bf Question 2:} Quels types de périphériques peuvent représenter les triangles?
+
+\vskip+3cm
+
+{\bf Question 3:} Quel est le rôle d'un routeur?
+
+\vskip+3cm
+
+
+{\bf Question 4:} Quelle connaissance du réseau possède chaque routeur, c'est à dire, combien d'autres appareils du réseau connaît-il?
+
+\vskip+3cm
+
+{\bf Question 5:} Chaque ordinateur du réseau doit pouvoir envoyer des informations à n'importe quel autre ordinateur du réseau et recevoir une réponse en échange. Quel ensemble de règles doit respecter ce réseau pour que cela soit possible?
+
+\vskip+3cm
+
+\newpage
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\subsection{Les protocoles}
+
+L'activité a montré que pour avoir une communication fiable entre les ordinateurs d'un réseau, il faut avoir les mêmes règles communes pour que tout le monde puisse se comprendre. C'est ce que nous appelons un {\bf protocole}.
+
+\begin{defi}
+Un {\bf protocole de communication} est un ensemble de règles qui décrivent comment la communication entre deux parties doit se faire à travers un réseau.
+
+\end{defi}
+
+Ces protocoles sont essentiels dans le cas de l'informatique car la communication passe par des ordinateurs. La juste programmation du protocole dans chaque ordinateur devrait garantir la bonne transmission des informations.
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item Le code de la route d'un pays peut-être considéré comme un protocole. C'est un ensemble de règles qui permet d'éviter les accidents.
+\item En informatique, les protocoles les plus connus sont l'{\it Internet Protocol (IP)} qui permet l'adressage des ordinateurs et l'{\it HyperText Transfer Protocol (http)} qui permet de mettre en relation des clients avec des serveurs contenant des sites web.
+
+\end{enumerate}
+
+\end{remarques}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\subsection{L'adressage}
+
+Le premier point à respecter, pour qu'un réseau fonctionne correctement consiste à attribuer à chaque appareil sur le réseau un unique identifiant, qu'on appelle l'adresse. Pour cela on utilise une adresse {\it IP}.
+
+\begin{defi}
+Le {\bf Protocol Internet (IP)} permet l'adressage unique des terminaux connectés à Internet. À chaque terminal est associé une adresse {\it unique} de la forme 134.23.112.20 (4 nombres entre 0 et 255 et séparés par un point).
+\end{defi}
+
+
+\begin{remarques}
+\begin{enumerate}
+\item[]
+\item Le type d'adresse actuelle est l'IPv4. Mais l'augmentation du nombre de terminaux pousse à un nouveau type d'adressage, l'IPv6 permettant de générer beaucoup plus d'adresses.
+\item Une adresse IP est donnée par l'ICANN (Internet Corporation for Assigned Names and Numbers).
+\end{enumerate}
+\end{remarques}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\subsection{Le routage}
+
+Un {\bf routeur} est un terminal qui reçoit des données et les dirige dans la bonne direction afin que ces données arrivent à destination. Un routeur ne connaît que ses voisins directs, ceux avec lesquels il peut communiquer. Il n'a pas connaissance de tout le réseau et il ne choisit pas la prochaine destination en essayant d'optimiser le parcours le plus efficace. Pour choisir la où il va envoyer la donnée qu'il a reçu, le routeur utilise une {\bf table de routage}.
+
+\begin{defi}
+Une {\bf table de routage} est une base de données utilisée par un ordinateur ou un routeur qui associe des adresses IP ou des préfixes d'adresses IP à des adresses appartenant au sous-réseau de l'ordinateur ou du routeur correspondant aux terminaux auxquels il est directement connecté.
+\end{defi}
+
+Dans l'exemple suivant, on utilise un réseau ou les adresses sont simplifiées et son représentées par des paires de lettres:
+
+\begin{center}
+\begin{tikzpicture}
+
+\def\long{.4};
+
+\coordinate (AA) at (1,0);
+\coordinate (AB) at (0,2);
+\coordinate (A0) at (2,2);
+
+\coordinate (BA) at (6,0);
+\coordinate (BB) at (8,2);
+\coordinate (B0) at (6,2);
+\coordinate (BC) at (8,0);
+
+\coordinate (CA) at (3,7);
+\coordinate (CB) at (5,7);
+\coordinate (C0) at (4,5);
+
+\draw (AB) -- (A0) -- (AA)
+ (BC) -- (BA) -- (B0) -- (BB) -- (BA)
+ (CA) -- (C0) -- (CB)
+ (A0) -- (B0) -- (C0) -- cycle;
+
+ \draw[dashed] (CA) -- (-1,7)
+ (C0) -- (-1,4)
+ (CB) -- (9,7)
+ (AB) -- (-1,2)
+ (A0) -- (-1,-1)
+ (AA) -- ++(0,-1)
+ (B0) -- (4,-1)
+ (BA) -- ++(1,-1)
+ (BC) -- ++(2,-1)
+ (BB) -- ++(1,-1);
+
+\foreach \x in {(A0),(B0),(C0)}
+ \filldraw[fill=lightgray] \x ++(-\long,-\long) rectangle ++(2*\long,2*\long);
+
+\foreach \x in {A0,B0,C0}
+ \draw (\x) node {\x};
+
+\filldraw[fill=lightgray] (BC) ++(-\long,-\long) -- ++(2*\long,0) -- ++(-\long, 1.8*\long) -- cycle;
+
+\foreach \x in {(AA),(AB),(BA),(BB),(CA),(CB)}
+ \filldraw[fill=lightgray] \x circle (\long);
+
+\draw (AA) node {AA};
+\draw (AB) node {AB};
+\draw (BA) node {BA};
+\draw (BB) node {BB};
+\draw (CA) node {CA};
+\draw (CB) node {CB};
+\draw (BC) ++(0,-.2) node {BC};
+
+\begin{scope}[shift={(0,-1)}] %table AA
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {A-} (1.5,-.3) node {A0}
+ (0.5,-.8) node {B-} (1.5,-.8) node {A0}
+ (0.5,-1.3) node {C-} (1.5,-1.3) node {A0}
+ (0.5,-1.8) node {} (1.5,-1.8) node {} ;
+\end{scope}
+
+\begin{scope}[shift={(-3,-1)}] %table A0
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {AA} (1.5,-.3) node {AA}
+ (0.5,-.8) node {AB} (1.5,-.8) node {AB}
+ (0.5,-1.3) node {B-} (1.5,-1.3) node {B0}
+ (0.5,-1.8) node {C-} (1.5,-1.8) node {C0} ;
+\end{scope}
+
+\begin{scope}[shift={(-3,2)}] %table AB
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {A-} (1.5,-.3) node {A0}
+ (0.5,-.8) node {B-} (1.5,-.8) node {A0}
+ (0.5,-1.3) node {C-} (1.5,-1.3) node {A0}
+ (0.5,-1.8) node {} (1.5,-1.8) node {} ;
+\end{scope}
+
+
+\begin{scope}[shift={(3,-1)}] %table B0
+\draw (0,0) -- (2,0) -- (2,-2.5) -- (0,-2.5) -- cycle
+ (1,0) -- (1,-2.5)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0,-2) -- (2,-2)
+ (0.5,-.3) node {BB} (1.5,-.3) node {BB}
+ (0.5,-.8) node {BA} (1.5,-.8) node {BA}
+ (0.5,-1.3) node {C-} (1.5,-1.3) node {C0}
+ (0.5,-1.8) node {B-} (1.5,-1.8) node {B0}
+ (0.5,-2.3) node {BC} (1.5,-2.3) node {BA} ;
+\end{scope}
+
+\begin{scope}[shift={(6,-1)}] %table BA
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {BB} (1.5,-.3) node {BB}
+ (0.5,-.8) node {BC} (1.5,-.8) node {BC}
+ (0.5,-1.3) node {Def.} (1.5,-1.3) node {B0}
+ (0.5,-1.8) node {} (1.5,-1.8) node {} ;
+\end{scope}
+
+\begin{scope}[shift={(9,-1)}] %table BC
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {Def.} (1.5,-.3) node {BA}
+ (0.5,-.8) node {} (1.5,-.8) node {}
+ (0.5,-1.3) node {} (1.5,-1.3) node {}
+ (0.5,-1.8) node {} (1.5,-1.8) node {} ;
+\end{scope}
+
+\begin{scope}[shift={(9,2)}] %table BB
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {BA} (1.5,-.3) node {BA}
+ (0.5,-.8) node {Def.} (1.5,-.8) node {B0}
+ (0.5,-1.3) node {} (1.5,-1.3) node {}
+ (0.5,-1.8) node {} (1.5,-1.8) node {} ;
+\end{scope}
+
+
+
+\begin{scope}[shift={(-3,5)}] %table C0
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {CA} (1.5,-.3) node {CA}
+ (0.5,-.8) node {CB} (1.5,-.8) node {CB}
+ (0.5,-1.3) node {A-} (1.5,-1.3) node {A0}
+ (0.5,-1.8) node {B-} (1.5,-1.8) node {B0} ;
+\end{scope}
+
+\begin{scope}[shift={(-3,8)}] %table CA
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {C-} (1.5,-.3) node {C0}
+ (0.5,-.8) node {B-} (1.5,-.8) node {C0}
+ (0.5,-1.3) node {A-} (1.5,-1.3) node {C0}
+ (0.5,-1.8) node {} (1.5,-1.8) node {} ;
+\end{scope}
+
+\begin{scope}[shift={(9,8)}] %table CC
+\draw (0,0) -- (2,0) -- (2,-2) -- (0,-2) -- cycle
+ (1,0) -- (1,-2)
+ (0,-.5) -- (2,-.5)
+ (0,-1) -- (2,-1)
+ (0,-1.5) -- (2,-1.5)
+ (0.5,-.3) node {C-} (1.5,-.3) node {C0}
+ (0.5,-.8) node {B-} (1.5,-.8) node {C0}
+ (0.5,-1.3) node {A-} (1.5,-1.3) node {C0}
+ (0.5,-1.8) node {} (1.5,-1.8) node {} ;
+\end{scope}
+
+
+
+\end{tikzpicture}
+\end{center}
+
+
+À chaque routeur, ordinateur ou périphérique est associé sa table de routage. Dans cette table, la colonne de gauche correspond à l'adresse de destination (ou à un préfixe d'adresse de destination) du paquet de données. L'adresse à droite est l'adresse du terminal auquel il faut envoyer ce paquet (ce qui est appelé le {\bf next-hop}).
+
+Dans la table de routage il faut souvent indiquer une route {\it par défaut}, c'est à dire le routeur auquel envoyer un paquet dont l'adresse de destination n'apparaît pas dans les adresses de la table de routage. Dans notre exemple, cela est signifié par un {\it Def.}.
+
+\begin{exercice}
+Déterminer le chemin parcouru par une information :
+\begin{enumerate}
+\item allant de CA à BC.
+\item allant de BA à AB.
+\end{enumerate}
+\end{exercice}
+
+\newpage
+
+\begin{exercice}
+Dans le diagramme de l'activité de groupe de la section 1.5.2, établir un adressage cohérent de tous les terminaux puis établir les tables de routage afin que chaque terminal du réseau puisse communiquer avec un autre terminal du réseau.
+
+
+\begin{center}
+\begin{tikzpicture}[scale=1.1]
+
+\def\long{.3};
+
+\coordinate (A) at (3,4);
+\coordinate (B) at (8,4);
+\coordinate (C) at (2,8);
+\coordinate (D) at (9,8);
+\coordinate (E) at (3,12);
+\coordinate (F) at (8,12);
+
+\coordinate (AA) at (1,0);
+\coordinate (AB) at (3,0);
+\coordinate (AC) at (5,0);
+\coordinate (AD) at (5,2);
+\coordinate (AE) at (3,2);
+\coordinate (AF) at (1,2);
+
+\coordinate (BA) at (7,1);
+\coordinate (BB) at (8,2);
+\coordinate (BC) at (10,2);
+\coordinate (BD) at (10,4);
+
+\coordinate (CA) at (0,5);
+\coordinate (CB) at (0,7);
+\coordinate (CC) at (0,9);
+
+\coordinate (FA) at (10,13);
+\coordinate (FB) at (10,15);
+\coordinate (FC) at (12,13);
+\coordinate (FD) at (12,15);
+
+\coordinate (EA) at (3,14);
+\coordinate (EB) at (1,14);
+\coordinate (EC) at (0,13);
+\coordinate (ED) at (0,11);
+
+\coordinate (PA) at (0,4);
+\coordinate (PB) at (10,6);
+\coordinate (PC) at (11,8);
+\coordinate (PD) at (11,10);
+\coordinate (PE) at (4,9);
+
+%legende
+\coordinate (triangle) at (0,-1);
+\coordinate (rond) at (0,-2);
+\coordinate (carre) at (0,-3);
+
+\draw (E) -- (F);
+\draw (C) -- (D) -- (F)
+ (E) -- (C)
+ (C) -- (B)
+ (A) -- (D)
+ (AA) -- (AB) -- (AC) -- (AD) -- (AE) -- (AF) -- (AA)
+ (A) -- (AE)
+ (B) -- (BA)
+ (B) -- (BB)
+ (B) -- (BC)
+ (B) -- (BD)
+ (C) -- (CA)
+ (C) -- (CB)
+ (C) -- (CC)
+ (F) -- (FA) -- (FB) -- (FC) -- (FD) -- (FA)
+ (FB) -- (FD)
+ (FA) -- (FC)
+ (E) -- (EA)
+ (E) -- (EB)
+ (E) -- (EC)
+ (E) -- (ED)
+ (PA) -- (CA)
+ (D) -- (PB)
+ (D) -- (PC)
+ (D) -- (PD)
+ (C) -- (PE);
+
+
+%tracer des carrés
+\foreach \x in {(A),(B),(C),(D),(E),(F),(carre)}
+ \filldraw[fill=lightgray] \x ++(-\long,-\long) rectangle ++(2*\long,2*\long);
+
+%tracé des cercle
+\foreach \x in {(AA),(AB),(AC),(AD),(AE),(AF),
+ (BA),(BB),(BC),(BD),
+ (CA),(CB),(CC),
+ (FA),(FB),(FC),(FD),
+ (EA),(EB),(EC),(ED),
+ (rond)}
+ \filldraw[fill=lightgray] \x circle (\long);
+
+
+%tracé des triangles
+\foreach \x in {(PA),(PB),(PC),(PD),(PE),(triangle)}
+ \filldraw[fill=lightgray] \x ++(-\long,-\long) -- ++(2*\long, 0) -- ++(-\long,1.6*\long) -- cycle;
+,
+\draw (carre) +(.5,0) node[anchor=west] {: routeurs} ;
+\draw (triangle) +(0.5,0) node[anchor=west] {: périphériques} ;
+\draw (rond) +(.5,0) node[anchor=west] {: ordinateurs} ;
+
+\end{tikzpicture}
+
+\end{center}
+
+\end{exercice}
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{Les protocoles}
+
+Nous rappelons la définition suivante:
+
+\begin{defi}
+Un {\bf protocole de communication} est un ensemble de règles qui décrivent comment la communication entre deux parties doit se faire à travers un réseau.
+
+\end{defi}
+
+Ces protocoles sont importants car les échanges sur les réseaux sont principalement fait par des machines.
+
+\subsection{Hiérarchies de protocoles}
+
+Les protocoles informatiques servent à définir:
+\begin{enumerate}
+\item comment doit être encodée l'information pour être transmise à travers un support spécifique;
+\item quel type d'information doit être attaché à un message pour qu'il soit acheminé/routé correctement;
+\item l'ordre dans lequel les messages doivent être envoyés entre des machines pour qu'elles puissent se comprendre.
+
+\end{enumerate}
+
+C'est pour cela que nous avons besoin d'une hiérarchie de protocoles de réseaux:
+
+\begin{defi}
+Une {\bf hiérarchie de protocoles de réseaux} décrit les différents niveaux d'abstraction des protocoles qui sont utilisés dans un moyen de communication. Ces niveaux sont représentés par des {\bf couches} empilées les unes au-dessus des autres.
+\end{defi}
+
+L'objectif de chaque couche est de fournir un service à celle qui se trouve au-dessus en d'elle cachant les détails de comment a été implémentée la fonctionnalité offerte.
+
+\subsection{Exemple concret}
+
+Pour envoyer un courrier à un ami dans le monde il faut un ensemble de règles communes afin que cela puisse se dérouler sans problème:
+
+\begin{enumerate}
+\item Premièrement, il faut un réseau postal qui va pouvoir acheminer la lettre de l'émetteur jusqu'au destinataire. C'est le {\bf réseau physique} composé de voies, de routes, et utilisant des trains, des avions, des vélos...
+\item Il faut ensuite un ensemble de règles permettant à chaque lieu où passera la lettre de savoir comment elle sera acheminée au lieu suivant.
+
+ Par exemple, le facteur sait qu'il doit apporter les lettres de la boite de dépôt au centre de triage. Le centre de triage sait que les lettres pour l'Amérique doivent être mise dans un sac postal et prendre tel avion...
+
+ C'est ce que nous appelons la {\bf la couche de liaison de données}.
+
+ \item Selon l'adresse écrite dessus, les différents centres de triage vont envoyer la lettre à d'autres centres de triage afin d'acheminer le courrier. C'est {\bf la couche réseau}.
+
+ \item Un ensemble de règles doit établir si les lettres arrivent bien à destination, s'il faut réorganiser les flux postaux ou gérer des problèmes dans certains centres de triage. C'est {\bf la couche transport}.
+
+ \item Pour bien se comprendre, l'émetteur et le destinataire doivent se mettre d'accord sur le langage utilisé dans la lettre. Un format d'écriture de l'adresse doit aussi être respecté. Enfin, l'émetteur doit aller poser la lettre sur le réseau afin qu'elle soit acheminée. C'est {\bf la couche application}.
+ \end{enumerate}
+
+
+\subsection{Hiérarchie standard}
+
+De la même façon, nous pouvons retrouver un ensemble de règles permettant qu'une information soit envoyée d'un ordinateur ou d'un serveur vers un destinataire.
+
+\begin{enumerate}
+\item {\bf La couche physique} est l'ensemble des connexions reliant tous les terminaux du réseau. La connexion peut être par exemple un câble ou un réseau sans fil.
+\item {\bf La couche de liaison de données} est l'ensemble des règles permettant la communication entre deux terminaux connectés. Un exemple de règles est le protocole Ethernet permettant de relier deux ordinateurs entre eux. Cette couche est aussi la couche qui vérifie s'il y a des erreurs de transmission de données.
+
+\item {\bf La couche réseau} comprend l'ensemble des règles de routage permettant à l'information de circuler de l'émetteur jusqu'au destinataire le plus rapidement possible.
+
+\item {\bf La couche transport} vérifie que les informations arrivent bien à destination, sans erreur et dans le bon ordre.
+
+\item {\bf La couche application} est l'ensemble des protocoles utilisées par les applications utilisateurs d'un réseau pour se comprendre. Elle définit donc le format des messages envoyés entre applications.
+
+
+\end{enumerate}
+
+\begin{exercice}
+Dans quelle couche placeriez-vous ces différentes situations?
+\begin{enumerate}
+\item Le temps que doit mettre un train pour aller d'une ville à une autre et le nombre de passagers qu'il peut prendre.
+\item L'ensemble des autoroutes espagnoles.
+\item La gestion du réseau électrique Suisse et la garantie que chaque foyer ait de l'électricité.
+\item Les formules de politesse lorsque nous envoyons un e-mail à un supérieur hiérarchique.
+\item L'acheminement de l'eau lorsque j'ouvre le robinet.
+
+\end{enumerate}
+\end{exercice}
+
+\subsection{Exemple de protocole: le client-serveur}
+
+\begin{defi}
+Un protocole ou environnement {\bf client-serveur} est un mode de communication entre plusieurs programmes ou processus: l'un est appelé le {\bf client} qui envoie des requêtes, et l'autre un {\bf serveur} qui attend les requêtes des clients et qui y répond. Le serveur offre un {\bf service} au client.
+\end{defi}
+
+Les serveurs ont donc une puissance de calcul, un ensemble d'entrées et de sorties et une connexion réseau bien plus importante qu'un ordinateur personnel afin de pouvoir gérer les nombreuses requêtes des clients.
+
+Afin de communiquer, le client et le serveur doivent utiliser le même protocole de communication. Les exemples de protocole client-serveur sont:
+\begin{enumerate}
+\item un serveur web publie des pages demandées par des navigateurs web (les clients);
+\item un serveur de messagerie électronique transmets les e-mails demandés par des clients de messagerie (outlook, mail, thunderbird,...)
+\item un système {\bf pair à pair } (peer-to-peer en anglais) est un environnement client-serveur ou chaque programme peut être client ou serveur. Le programme est client lorsqu'il demande et récupère des données, et devient serveur lorsqu'il fournit des données.
+\end{enumerate}
+
+\vskip1cm
+
+Le principe de fonctionnement du modèle est le suivant:
+\begin{enumerate}[i)]
+\item Lorsqu'un client veut accéder à une ressource stockée sur un serveur donné (une page web, une image ou une vidéo, par exemple), il envoie à ce dernier une {\it requête} qui spécifie le nom
+ou l'identifiant de la ressource à lui transmettre.
+\item Lorsque le serveur reçoit la requête, il recherche la ressource demandée dans son registre.
+\item S'il la trouve, il envoie une {\it réponse} à la requête du client dans laquelle il inclut la ressource demandée, ainsi qu'un code de confirmation.
+\item S'il ne possède pas la ressource ou qu'une autre erreur est rencontrée, il répond au client avec un code d'erreur qui lui indique le type de problème survenu au cours de leur échange.
+\end{enumerate}
+
+
+\vskip1cm
+
+L'exemple le plus connu d'application de la couche 5 (couche application) qui utilise le modèle client-
+serveur est le {\it World Wide Web} (souvent plus simplement appelé le {\it web}). Il correspond à un réseau international de serveurs qui hébergent les sites web que nous avons aujourd'hui tous l'habitude de consulter quotidiennement. Le web est souvent confondu à tort avec Internet. Internet correspond à un vaste réseau informatique d'envergure internationale qui utilise les protocoles des couches décrites dans ce chapitre pour permettre à des ordinateurs de communiquer entre eux. Le web n'est qu'un exemple d'application de la couche 5 qui utilise Internet pour échanger de l'information entre des utilisateurs. D'autres services utilisent Internet, comme l'e-mail, par exemple, ou encore les plate-formes de streaming vidéo, les jeux-vidéos multijoueurs, etc.
+
+
+
+\subsection{Un autre exemple de protocole: le DNS}
+
+
+Nous avons vu que lorsqu'une machine souhaite envoyer un message à une autre, elle doit spécifier son adresse IP pour que l'information puisse être routée à travers le réseau. Toutefois, l'utilisation directe d'adresses IP présente plusieurs problèmes. Le premier est que ces dernières sont numériques et donc très difficiles à retenir pour les utilisateurs humains d'un réseau (imaginez s'il fallait entrer une adresse du type 192.168.22.1 dans notre navigateur à chaque fois que nous voulons accéder à notre site favori !). Une autre difficulté liée aux adresses IP est que dès qu'un service est déplacé d'une machine vers une autre, son adresse IP change. Par exemple, si un site hébergé sur un serveur doit être migré vers un autre pour des questions de maintenance, son adresse IP va changer et tous ses visiteurs devront en être informés pour pouvoir continuer à y accéder.
+
+L'objectif du protocole DNS est d'associer des noms fixes aux machines connectées à Internet pour qu'elles puissent communiquer sans devoir directement utiliser leurs adresses IP. C'est donc ce protocole qui nous permet d'accéder quotidiennement à nos sites préférés avec des adresses comme {\it www.monsitefavori.com}, plutôt que de longues suites de chiffres difficiles à retenir.
+Le principe de base du {\it Domain Name System} est le suivant :
+\begin{itemize}
+\item Lorsqu'une application souhaite accéder à un service avec un nom donné, elle envoie une
+requête à un serveur DNS pour qu'il lui communique l'adresse IP associée à ce nom ;
+\item Un serveur DNS est un serveur particulier qui maintient un registre associant des noms de domaines à leurs adresses IP. Quand ce serveur reçoit une requête, il recherche le nom demandé dans son registre et s'il trouve une correspondance, il répond avec l'adresse IP associée. Sinon, il retransmet la requête à un autre serveur DNS plus susceptible de connaître
+la réponse, qui va effectuer la même tâche; soit trouver le nom recherché dans son registre, soit retransmettre la requête plus loin. Ces étapes sont répétées jusqu'à ce qu'un serveur qui connaît le nom recherché soit trouvé et retourne l'adresse IP désirée.
+\end{itemize}
+
+
+
+
+
+
+
+\end{document}
+
+
+%% 2022 avril
+%% TZ relecture et corrections de coquilles orthographiques
+
+
+
diff --git a/11-Strings.pdf b/11-Strings.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..37fb555aed59bf16081a8c8422b7fae6115a18f6
Binary files /dev/null and b/11-Strings.pdf differ
diff --git a/11-Strings.tex b/11-Strings.tex
new file mode 100644
index 0000000000000000000000000000000000000000..162d57e0f1bab0809204fad1a4298b156a0546a9
--- /dev/null
+++ b/11-Strings.tex
@@ -0,0 +1,184 @@
+
+\documentclass[11pt, a4paper]{book}
+\input{package.tex}
+\pgfplotsset{compat=1.17}
+\begin{document}
+
+\setcounter{chapter}{8}
+\chapter{Programmation - Chaînes de caractères}
+\section{Introduction}
+
+
+Les chaînes de caractères (type \texttt{str)} en Python sont des séquences de caractères qui peuvent être utilisées pour stocker des textes. Les chaînes de caractères sont définies entre apostrophes ('), guillemets simples ("), ou guillemets triples (""").
+\lstset{caption={Chaînes de caractères}}
+\begin{lstlisting}
+str1 = "Ceci me permet d'écrire l'apostrophe."
+str2 = 'Ceci me permet de "placer" le guillemet.'
+str3 = """Ceci me permet d'écrire
+sur plusieurs lignes"""
+\end{lstlisting}
+
+\section{Boite à outils}
+\subsection{Opérateurs}
+L'opérateur + permet de concaténer des chaînes de caractères.
+L'opérateur * permet de répéter une chaîne de caractères plusieurs fois.
+
+
+\lstset{caption={Opérateurs}}
+\begin{lstlisting}
+chaine1 = "Bonjour"
+chaine2 = " toi !"
+chaine3 = chaine1 + chaine2
+print(chaine3) # affiche "Bonjour toi !"
+
+chaine4 = "Coucou "
+chaine5 = chaine4 * 3
+print(chaine5) # affiche "Coucou Coucou Coucou "
+\end{lstlisting}
+
+\subsection{Fonction len()}
+En Python, la len() fonction intégrée peut être utilisée pour déterminer la longueur d'un objet. Il peut être utilisé pour calculer la longueur de chaînes, de listes, d'ensembles et d'autres objets dénombrables.
+
+
+
+\lstset{caption={Fonction len()}}
+\begin{lstlisting}
+longueur = len("Hello")
+print("La longueur:",longueur) # affiche 5
+\end{lstlisting}
+
+\subsection{in}
+La syntaxe |in| est utilisée pour déterminer si une lettre ou une sous-chaîne existe dans une chaîne.
+
+Elle renvoie |True| si une correspondance est trouvée, sinon |False| est renvoyée.
+
+
+\lstset{caption={in}}
+\begin{lstlisting}
+jeu = "Popular Nintendo Game: Mario Kart"
+
+if "l" in jeu:
+ print("1 est dans la chaîne jeu.")
+else:
+ print("1 n'est pas dans la chaîne jeu.")
+\end{lstlisting}
+
+
+\subsection{Indexation et découpage des chaînes}
+Un seul caractère peut être accédé avec la notation entre crochets |[index]|, ou une sous-chaîne peut être accédée en utilisant le découpage |[start:end]|.
+
+L'indexation avec des nombres négatifs compte à partir de la fin de la chaîne.
+
+
+
+\lstset{caption={indexation}}
+\begin{lstlisting}
+mot = 'orange'
+# 012345
+
+print(mot[0]) # => 'o'
+print(mot[1]) # => 'r'
+print(mot[4:6]) # => 'ge'
+print(mot[:4]) # => 'oran'
+print(mot[-1]) # => 'e'
+\end{lstlisting}
+
+
+\subsection{Itérer la chaîne}
+Pour parcourir une chaîne en Python, la notation |for ... in| est utilisée.
+
+
+
+\lstset{caption={iteration}}
+\begin{lstlisting}
+mot = "hello"
+for c in mot:
+ print(c)
+\end{lstlisting}
+affiche chaque lettre du mot |"hello"| les unes après les autres.
+
+\subsection{Autres fonctions}
+|.lower()| renvoie une chaîne avec tous les caractères majuscules convertis en minuscules.
+
+|.upper()| renvoie la chaîne avec tous les caractères minuscules convertis en majuscules.
+
+\lstset{caption={lower / upper}}
+\begin{lstlisting}
+salutation = "Bienvenue chez Chili's"
+print(salutation.lower()) # affiche bienvenue chez chili's
+\end{lstlisting}
+%
+%dinosaure = "T-Rex"
+%print(dinosaure.upper()) # affiche T-REX
+
+|.isalpha()| renvoie |True| si tous les caractères de la chaîne sont alphabétiques et qu'elle contient au moins un caractère, sinon |False|.
+
+|.isdigit()| renvoie |True| si tous les caractères de la chaîne sont des chiffres et qu'elle contient au moins un caractère, sinon |False|.
+
+\lstset{caption={isalpha / isdigit}}
+\begin{lstlisting}
+texte = "LeGrandParc"
+if texte.isalpha():
+ print("Contient que des lettres")
+else:
+ print("Contient d'autres caractère")
+# affiche Contient que des lettres
+\end{lstlisting}
+%
+%texte = "12345"
+%if texte.digit():
+% print("Contient que des chiffres")
+%else:
+% print("Contient d'autres caractère") # affiche Contient que des chiffres
+
+
+\section{Exercices}
+
+
+\begin{exercice}
+Écrire un programme qui demande à l'utilisateur-trice de saisir une phrase et qui affiche la longueur de cette phrase.
+\end{exercice}
+
+\begin{exercice}
+Écrire un programme qui demande à l'utilisateur-trice de saisir deux mots et qui dit si les deux mots sont les mêmes.
+\end{exercice}
+
+\begin{exercice}
+\begin{itemize}
+\item[a)] Écrire un programme qui demande à l'utilisateur-trice de saisir une phrase et qui affiche les 10 premiers caractères de cette phrase.
+\item[b)] Modifier le code pour demander également à l'utilisateur-trice le nombre de caractères à afficher.
+\end{itemize}
+
+\end{exercice}
+
+\begin{exercice}
+Afficher le menu d'un programme jusqu'à ce que l'utilisateur-trice saisisse "q" pour quitter.
+
+\texttt{--- Menu --- \\
+1. Option 1\\
+2. Option 2\\
+q. Quitter\\
+Choisissez une option :}
+\end{exercice}
+
+\begin{exercice}
+\begin{itemize}
+\item[a)] Écrire un programme qui demande à l'utilisateur-trice de saisir une phrase et dit si elle contient la lettre "a".
+\item[b)] Écrire un programme qui demande à l'utilisateur-trice de saisir une phrase et qui compte le nombre de lettres "a".
+\item[c)] Écrire un programme qui demande à l'utilisateur-trice de saisir une phrase et qui compte le nombre de voyelles.
+\end{itemize}
+
+\begin{exercice}
+Écrire un programme qui demande à l'utilisateur-trice de saisir une phrase et qui affiche cette phrase sans les espaces.
+\end{exercice}
+
+\end{exercice}
+
+
+\begin{exercice}
+Écrire un programme qui demande à l'utilisateur-trice de saisir un mot et qui affiche ce mot à l'envers.
+\end{exercice}
+
+
+
+\end{document}
diff --git a/Codes/premier_prog_python.py b/Codes/premier_prog_python.py
new file mode 100644
index 0000000000000000000000000000000000000000..b942d26ec0a5bee00b48aff756e8b58da222c51f
--- /dev/null
+++ b/Codes/premier_prog_python.py
@@ -0,0 +1,15 @@
+print("A vous de jouer")
+x = int(input("position x : "))
+y = int(input("position y : "))
+x_bateau = 7
+y_bateau = 4
+
+if x_bateau == x and y_bateau == y:
+ message = "Coulé"
+else:
+ if x_bateau == x or y_bateau == y:
+ message = "En vue"
+ else:
+ message = "Dans l'eau"
+
+print(message)
\ No newline at end of file
diff --git a/images/ASCII.png b/images/ASCII.png
new file mode 100644
index 0000000000000000000000000000000000000000..422d2aebc13e8fc01f4495a8ed9cf047935e913c
Binary files /dev/null and b/images/ASCII.png differ
diff --git a/images/ASCII2.png b/images/ASCII2.png
new file mode 100644
index 0000000000000000000000000000000000000000..9a6c44af6c3f215886670525bbb4de71023ec007
Binary files /dev/null and b/images/ASCII2.png differ
diff --git a/images/Business_Network_Solutions_swisscom.png b/images/Business_Network_Solutions_swisscom.png
new file mode 100644
index 0000000000000000000000000000000000000000..f6e723fc1279a59f30e9eca3fde337200ebc7ac7
Binary files /dev/null and b/images/Business_Network_Solutions_swisscom.png differ
diff --git a/images/IDE_Thonny.png b/images/IDE_Thonny.png
new file mode 100644
index 0000000000000000000000000000000000000000..22faa2c6af015fdce3d467662a1832a362179ff8
Binary files /dev/null and b/images/IDE_Thonny.png differ
diff --git a/images/IDE_Thonny_illustre-crop.pdf b/images/IDE_Thonny_illustre-crop.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..4a8cddd9e2b65c0bf2d637b8e3cac97324d2516e
Binary files /dev/null and b/images/IDE_Thonny_illustre-crop.pdf differ
diff --git a/images/IDE_Thonny_illustre.pdf b/images/IDE_Thonny_illustre.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..6b7b91338379c664555502ad7ba24ab791d52c7b
Binary files /dev/null and b/images/IDE_Thonny_illustre.pdf differ
diff --git a/images/MacOS.png b/images/MacOS.png
new file mode 100644
index 0000000000000000000000000000000000000000..e47edc1f1485031954e1c6a0eade23f3c8d7c21d
Binary files /dev/null and b/images/MacOS.png differ
diff --git a/images/OS.jpg b/images/OS.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..7c476e5a1aba72b22f16f240a789cbbaf67f89b3
Binary files /dev/null and b/images/OS.jpg differ
diff --git a/images/Operationsigne.png b/images/Operationsigne.png
new file mode 100644
index 0000000000000000000000000000000000000000..5d7d2ad5d48d28771566a2f6702bf9cbcf30382b
Binary files /dev/null and b/images/Operationsigne.png differ
diff --git a/images/RJ45.png b/images/RJ45.png
new file mode 100644
index 0000000000000000000000000000000000000000..cc5e4e79ff8c205d27833f82a8ba9b27afdac7ab
Binary files /dev/null and b/images/RJ45.png differ
diff --git a/images/Symbole_attention.png b/images/Symbole_attention.png
new file mode 100644
index 0000000000000000000000000000000000000000..11d9387dcfa1ee146d7d1d30ed22fd32fb71ea2d
Binary files /dev/null and b/images/Symbole_attention.png differ
diff --git a/images/Symbole_eclairage.png b/images/Symbole_eclairage.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f21e32bbc39402d8397b4ae2e017e79cfeacf74
Binary files /dev/null and b/images/Symbole_eclairage.png differ
diff --git a/images/Symbole_learn.png b/images/Symbole_learn.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd3e078140e8c2ed51fbedcd5b9af0823e1c39b7
Binary files /dev/null and b/images/Symbole_learn.png differ
diff --git a/images/Windows.png b/images/Windows.png
new file mode 100644
index 0000000000000000000000000000000000000000..dbc10b11e2fe2c6ce6f4e85b0cef42f264fbd477
Binary files /dev/null and b/images/Windows.png differ
diff --git a/images/alimentation.jpg b/images/alimentation.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6e130d4f73f383d4967f66bcc1027baf900bfffd
Binary files /dev/null and b/images/alimentation.jpg differ
diff --git a/images/arborescence.png b/images/arborescence.png
new file mode 100644
index 0000000000000000000000000000000000000000..6292a47d51ec436a37ffca1d8bbd176330a783ee
Binary files /dev/null and b/images/arborescence.png differ
diff --git a/images/arborescence2.png b/images/arborescence2.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6b6dc609006e6827fef385b7ce52343dcaf2400
Binary files /dev/null and b/images/arborescence2.png differ
diff --git a/images/bitmapvectoriel.jpg b/images/bitmapvectoriel.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3113666f375180ba8be0e4ba479d5ef52aeb39b9
Binary files /dev/null and b/images/bitmapvectoriel.jpg differ
diff --git a/images/blockly_ex.png b/images/blockly_ex.png
new file mode 100644
index 0000000000000000000000000000000000000000..c337a4b983378d2bce7f441224cbb4403f2d0db2
Binary files /dev/null and b/images/blockly_ex.png differ
diff --git a/images/carte_graphique.png b/images/carte_graphique.png
new file mode 100644
index 0000000000000000000000000000000000000000..910d37454fe28ef24e7d5df33d731751d1a3b2eb
Binary files /dev/null and b/images/carte_graphique.png differ
diff --git a/images/cartemere.jpg b/images/cartemere.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..741779af27844bfacff4a2c0efdb54a87228cf9b
Binary files /dev/null and b/images/cartemere.jpg differ
diff --git a/images/change_extension.png b/images/change_extension.png
new file mode 100644
index 0000000000000000000000000000000000000000..1948ae7c2e5c1724f86fd018c452746e38528206
Binary files /dev/null and b/images/change_extension.png differ
diff --git a/images/composants.png b/images/composants.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac603dc278144def0c797e182f09fe09237a6f86
Binary files /dev/null and b/images/composants.png differ
diff --git a/images/connecteurs-fibre-optique.png b/images/connecteurs-fibre-optique.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b673ea2341abfb6463552907e305291e3752fe6
Binary files /dev/null and b/images/connecteurs-fibre-optique.png differ
diff --git a/images/data-storage-infographic.jpg b/images/data-storage-infographic.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..73f90680ce2c152f6346da87cf71daea44642666
Binary files /dev/null and b/images/data-storage-infographic.jpg differ
diff --git a/images/disquedur.png b/images/disquedur.png
new file mode 100644
index 0000000000000000000000000000000000000000..3f84bda3f3bbb8da360c11a83943fe7af1e3f05a
Binary files /dev/null and b/images/disquedur.png differ
diff --git a/images/divisionbinaire.png b/images/divisionbinaire.png
new file mode 100644
index 0000000000000000000000000000000000000000..b7ee1de6bdb80c69fe5e3d700609ad290cf11bf8
Binary files /dev/null and b/images/divisionbinaire.png differ
diff --git a/images/electric_binary.png b/images/electric_binary.png
new file mode 100644
index 0000000000000000000000000000000000000000..59f8d7eb277bf21790f4d40556a185ceb614f68f
Binary files /dev/null and b/images/electric_binary.png differ
diff --git a/images/family_tree_languages.jpeg b/images/family_tree_languages.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..229d7a13c44d9b5a946269eb8e75f114f33d8b59
Binary files /dev/null and b/images/family_tree_languages.jpeg differ
diff --git a/images/fichierMac.png b/images/fichierMac.png
new file mode 100644
index 0000000000000000000000000000000000000000..8caeb2a61a8e87c9022f58cb5784415a603f2769
Binary files /dev/null and b/images/fichierMac.png differ
diff --git a/images/fichierWindows.png b/images/fichierWindows.png
new file mode 100644
index 0000000000000000000000000000000000000000..e6227597849acc0d450194f91f2649d8d48144eb
Binary files /dev/null and b/images/fichierWindows.png differ
diff --git a/images/floppy-disk.jpg b/images/floppy-disk.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3391a06444024a00efb00169d442bdd38f7dbfdb
Binary files /dev/null and b/images/floppy-disk.jpg differ
diff --git a/images/for-loop.png b/images/for-loop.png
new file mode 100644
index 0000000000000000000000000000000000000000..62ffa738ed7d16d7b325968a0485f804be2a2931
Binary files /dev/null and b/images/for-loop.png differ
diff --git a/images/hexadecimal.png b/images/hexadecimal.png
new file mode 100644
index 0000000000000000000000000000000000000000..060f18ec48b3df1ce4f0e1a9d3b8ee949aab57c5
Binary files /dev/null and b/images/hexadecimal.png differ
diff --git a/images/icon_voc.jpg b/images/icon_voc.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..66beed5a2fbd022307d183d03f31e89bebb33ec8
Binary files /dev/null and b/images/icon_voc.jpg differ
diff --git a/images/micropython_ex.png b/images/micropython_ex.png
new file mode 100644
index 0000000000000000000000000000000000000000..6727fc965afd46ad7a7ea9a0109e310cc82c6142
Binary files /dev/null and b/images/micropython_ex.png differ
diff --git a/images/moustache.png b/images/moustache.png
new file mode 100644
index 0000000000000000000000000000000000000000..71e3d1d2e7d3e3a7b1c932ee381f86ebcebf0de9
Binary files /dev/null and b/images/moustache.png differ
diff --git a/images/nombresigne.png b/images/nombresigne.png
new file mode 100644
index 0000000000000000000000000000000000000000..6d33ce03cba6fd4aec41d706652707d0b1595ad6
Binary files /dev/null and b/images/nombresigne.png differ
diff --git a/images/ordinateur.jpg b/images/ordinateur.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..cc15cb719b1881041727c5640d0e2950ccb77ae8
Binary files /dev/null and b/images/ordinateur.jpg differ
diff --git a/images/ordinateur_ex_3.png b/images/ordinateur_ex_3.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b370aa5dca5029bebcd1d2d3c9b65639ce5c9c7
Binary files /dev/null and b/images/ordinateur_ex_3.png differ
diff --git a/images/organisationfichiers.png b/images/organisationfichiers.png
new file mode 100644
index 0000000000000000000000000000000000000000..0b8eb136db17b773a044541dc80a5f8cc41f375d
Binary files /dev/null and b/images/organisationfichiers.png differ
diff --git a/images/peripherique.png b/images/peripherique.png
new file mode 100644
index 0000000000000000000000000000000000000000..fe7e16fb30bf1dea69487d73ce0d4d78009ee6f0
Binary files /dev/null and b/images/peripherique.png differ
diff --git a/images/processeur.jpg b/images/processeur.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3922d8bb1f1581e2d1aaef57fdef454cbfc3ced3
Binary files /dev/null and b/images/processeur.jpg differ
diff --git a/images/sdram.jpg b/images/sdram.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..b35a91ead58a36c84b9abb129e582f5eac9a5c33
Binary files /dev/null and b/images/sdram.jpg differ
diff --git a/images/serveur.png b/images/serveur.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b9309de6e837864c793a667ce614084fc8d2475
Binary files /dev/null and b/images/serveur.png differ
diff --git a/images/shema_ordinateur.png b/images/shema_ordinateur.png
new file mode 100644
index 0000000000000000000000000000000000000000..c531612e9834e05db7dea2bf8e43f385c285b38f
Binary files /dev/null and b/images/shema_ordinateur.png differ
diff --git a/images/shema_science_info.png b/images/shema_science_info.png
new file mode 100644
index 0000000000000000000000000000000000000000..9ee33ad57cb7037a5ad5e9aff1f62e348fdf46a4
Binary files /dev/null and b/images/shema_science_info.png differ
diff --git a/images/son.png b/images/son.png
new file mode 100644
index 0000000000000000000000000000000000000000..f407de92b75b16513afb0c96a69b15c1f0f62a83
Binary files /dev/null and b/images/son.png differ
diff --git a/images/statista.jpeg b/images/statista.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..a1a92b8d1984e5d8bd950a9cbcd3312682d82ddd
Binary files /dev/null and b/images/statista.jpeg differ
diff --git a/images/systemeexploitation.png b/images/systemeexploitation.png
new file mode 100644
index 0000000000000000000000000000000000000000..335f974009d38d5ba53b046b4a8fd08c34f8cdac
Binary files /dev/null and b/images/systemeexploitation.png differ
diff --git a/images/tableaubase.png b/images/tableaubase.png
new file mode 100644
index 0000000000000000000000000000000000000000..dcd03a26485f30eabc27485263cc2f89550211d2
Binary files /dev/null and b/images/tableaubase.png differ
diff --git a/images/tableauconversion.png b/images/tableauconversion.png
new file mode 100644
index 0000000000000000000000000000000000000000..d0f294c5e7dedf9c198535a375a2d06f40d1ba80
Binary files /dev/null and b/images/tableauconversion.png differ
diff --git a/images/tablerepresentation.png b/images/tablerepresentation.png
new file mode 100644
index 0000000000000000000000000000000000000000..f506da46e659cc084438371410525545f0f67bc0
Binary files /dev/null and b/images/tablerepresentation.png differ
diff --git a/images/usb.png b/images/usb.png
new file mode 100644
index 0000000000000000000000000000000000000000..07ec5706d51533034274a4f08099fc2fdf411569
Binary files /dev/null and b/images/usb.png differ
diff --git a/images/var_10.png b/images/var_10.png
new file mode 100644
index 0000000000000000000000000000000000000000..1ef4776d586dfbbafd3184a96210b91e74d36f97
Binary files /dev/null and b/images/var_10.png differ
diff --git a/images/var_11.png b/images/var_11.png
new file mode 100644
index 0000000000000000000000000000000000000000..5b72a99e72157a8f39a882cd0f6f802e1e345210
Binary files /dev/null and b/images/var_11.png differ
diff --git a/images/var_12.png b/images/var_12.png
new file mode 100644
index 0000000000000000000000000000000000000000..43d587b4c1d5ad143309ae9762685d629fec75e4
Binary files /dev/null and b/images/var_12.png differ
diff --git a/images/var_13.png b/images/var_13.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf3abe3ff9d0cef4b2574aac54e146a8f04d5b60
Binary files /dev/null and b/images/var_13.png differ
diff --git a/images/var_14.png b/images/var_14.png
new file mode 100644
index 0000000000000000000000000000000000000000..d8115586442352c4afc4d37905fbbf891853c682
Binary files /dev/null and b/images/var_14.png differ
diff --git a/images/var_15.png b/images/var_15.png
new file mode 100644
index 0000000000000000000000000000000000000000..76e1447028562d7c0bd0eba4ef13e9bd4ad08e40
Binary files /dev/null and b/images/var_15.png differ
diff --git a/images/var_16.png b/images/var_16.png
new file mode 100644
index 0000000000000000000000000000000000000000..688c47a6be189936f7a96b3bae71857ddf732a12
Binary files /dev/null and b/images/var_16.png differ
diff --git a/images/var_17.png b/images/var_17.png
new file mode 100644
index 0000000000000000000000000000000000000000..f0f22a264d8767cd5f0d58e07ecdf77525493b23
Binary files /dev/null and b/images/var_17.png differ
diff --git a/images/var_18.png b/images/var_18.png
new file mode 100644
index 0000000000000000000000000000000000000000..a049a97c20c348f7eeadd712d3f0cba73b90e1b3
Binary files /dev/null and b/images/var_18.png differ
diff --git a/images/var_19.png b/images/var_19.png
new file mode 100644
index 0000000000000000000000000000000000000000..2cda134f6a4bbd3f0ab24f548d3e6282b6f4824a
Binary files /dev/null and b/images/var_19.png differ
diff --git a/images/var_24.png b/images/var_24.png
new file mode 100644
index 0000000000000000000000000000000000000000..814c7028e792b09678e195b9b80a5470ba691da1
Binary files /dev/null and b/images/var_24.png differ
diff --git a/images/var_25.png b/images/var_25.png
new file mode 100644
index 0000000000000000000000000000000000000000..0f93418ee9b3ba841a3d91528b0be38fdbf2984a
Binary files /dev/null and b/images/var_25.png differ
diff --git a/images/var_28.png b/images/var_28.png
new file mode 100644
index 0000000000000000000000000000000000000000..d54c9576453583754814509e4534d904587d7dce
Binary files /dev/null and b/images/var_28.png differ
diff --git a/images/var_29.png b/images/var_29.png
new file mode 100644
index 0000000000000000000000000000000000000000..aab9145886e9e80130f2e7a028c57a0860fc792a
Binary files /dev/null and b/images/var_29.png differ
diff --git a/images/var_31.png b/images/var_31.png
new file mode 100644
index 0000000000000000000000000000000000000000..89958fa28d26ba512987bd18a27a7884fccf9f3b
Binary files /dev/null and b/images/var_31.png differ
diff --git a/images/var_6.png b/images/var_6.png
new file mode 100644
index 0000000000000000000000000000000000000000..386481c58e7ac8fa4b6d6c311c1f152902aac13a
Binary files /dev/null and b/images/var_6.png differ
diff --git a/images/var_7.png b/images/var_7.png
new file mode 100644
index 0000000000000000000000000000000000000000..f1844b570520d43366674cbef11197adfc1426ef
Binary files /dev/null and b/images/var_7.png differ
diff --git a/images/var_8.png b/images/var_8.png
new file mode 100644
index 0000000000000000000000000000000000000000..a3850721be7f93d1269152d680fbffade2616ab5
Binary files /dev/null and b/images/var_8.png differ
diff --git a/images/var_9.png b/images/var_9.png
new file mode 100644
index 0000000000000000000000000000000000000000..8a9825090e6b47b07e514f9824665a10f18e93d7
Binary files /dev/null and b/images/var_9.png differ
diff --git a/images/variables/exo_permut.png b/images/variables/exo_permut.png
new file mode 100644
index 0000000000000000000000000000000000000000..5bf45d3723bff4d91b429b79fa96f78facb23ec9
Binary files /dev/null and b/images/variables/exo_permut.png differ
diff --git a/images/variables/memoire.odg b/images/variables/memoire.odg
new file mode 100644
index 0000000000000000000000000000000000000000..341550bc7ac297cf1a912c89315f80495bc82fbb
Binary files /dev/null and b/images/variables/memoire.odg differ
diff --git a/images/variables/memoire.png b/images/variables/memoire.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc4ccdc7075ad286dc68425d86ee8ce21b17565c
Binary files /dev/null and b/images/variables/memoire.png differ
diff --git a/images/variables/variables.png b/images/variables/variables.png
new file mode 100644
index 0000000000000000000000000000000000000000..92e8f16e2f1f07a907d1d16668c23766a4f86df7
Binary files /dev/null and b/images/variables/variables.png differ
diff --git a/images/variables/variables2.png b/images/variables/variables2.png
new file mode 100644
index 0000000000000000000000000000000000000000..f12020ba0d24973a3a22cb94ff699014f6c22ef7
Binary files /dev/null and b/images/variables/variables2.png differ
diff --git a/images/while-loop.png b/images/while-loop.png
new file mode 100644
index 0000000000000000000000000000000000000000..c3a74d3c7eba81875f8aab5dd8ba6c7f49b31582
Binary files /dev/null and b/images/while-loop.png differ
diff --git a/package.tex b/package.tex
new file mode 100644
index 0000000000000000000000000000000000000000..51f562426267b10af195cc4d13ff5b277df93409
--- /dev/null
+++ b/package.tex
@@ -0,0 +1,504 @@
+% Ressources à installer : texlive-science et texlive-lang-french ou texlive-lang-european
+%à compiler avec XeLaTeX à cause des image pstricks
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+
+\usepackage[french]{babel}
+\usepackage{listingsutf8}
+\usepackage{tikz,pgf}
+\usepackage{amsthm,titlesec}
+\usepackage{mdframed} % pour le format des définition, théorèmes...
+\usepackage{xcolor,rotating,systeme}
+\usepackage[Glenn]{fncychap} %pour le format des chapitres
+\usepackage[top=3cm,bottom=3cm,left=3cm,right=2cm,headsep=10pt,a4paper]{geometry} % Page margins
+\usepackage{multicol}
+\usepackage{enumerate,cancel}
+\usepackage{lipsum,minitoc}
+%\usepackage{chngcntr}
+\usepackage{amsmath,amsfonts,minitoc,amsthm,pgfplots}
+\usepackage{mathrsfs}
+\usetikzlibrary{arrows, intersections}
+\usepackage{mathrsfs}
+\usepackage{array,yhmath}
+\usepackage{hyperref}
+\usepackage{caption}
+\usepackage{float}
+\usepackage{wrapfig}
+\restylefloat{figure}
+\usepackage{subfig}
+
+\usepackage{listings}
+\usepackage{color}
+\lstset{ % General setup for the package
+ language=Python,
+ basicstyle=\footnotesize,
+ basewidth=0.7em,
+ numbers=left,
+ numberstyle=\tiny,
+ frame=lines,
+ tabsize=4,
+ columns=fixed,
+ showstringspaces=false,
+ showtabs=false,
+ keepspaces,
+ commentstyle=\color{gray},
+ keywordstyle=\color{blue},
+ stringstyle=\color{magenta},
+ inputencoding=utf8/latin1,
+ extendedchars=true,
+ literate=%
+ {é}{{\'{e}}}1
+ {è}{{\`{e}}}1
+ {ê}{{\^{e}}}1
+ {ë}{{\¨{e}}}1
+ {û}{{\^{u}}}1
+ {ù}{{\`{u}}}1
+ {â}{{\^{a}}}1
+ {à}{{\`{a}}}1
+ {î}{{\^{i}}}1
+ {ô}{{\^{o}}}1
+ {ç}{{\c{c}}}1
+ {Ç}{{\c{C}}}1
+ {É}{{\'{E}}}1
+ {Ê}{{\^{E}}}1
+ {À}{{\`{A}}}1
+ {Â}{{\^{A}}}1
+ {Î}{{\^{I}}}1
+ }
+
+
+
+\usepackage{lipsum}
+\newtheorem{example}{Exemple}
+
+\usepackage{pstricks,pst-plot,pstricks-add}
+\usepackage{pst-func,tkz-tab,tkz-euclide}
+\usepackage{graphicx}
+%macro exo
+\newcounter{mtex}[chapter]
+\newcommand{\mtexlabel}{\cadrexo{\themtex}}
+\newcommand{\cadrexo}[1]{%
+\tikz\node[rectangle,minimum size=6mm,rounded corners=2mm,fill=ocre,inner sep=0pt,text width=0.8cm,align=center]{\large\bfseries\textcolor{white}{#1}};}
+\definecolor{ocre}{RGB}{196,106,106}
+\definecolor{vert}{RGB}{55,120,0}
+\newcommand{\mtexlabelpos}[1]{%
+\makebox[0pt][r]{\raisebox{#1\baselineskip}[0pt][0pt]{\mtexlabel\quad}}}
+\newenvironment{exercice}[1][\empty]{%
+\refstepcounter{mtex}%
+\trivlist\item\relax%
+\ifx#1\empty\mtexlabelpos{-.7}\else\mtexlabelpos{-.5}%
+\hfill\textbf{#1}\hfill\mbox{}\par\fi%
+}{\endtrivlist}
+
+\newcommand{\N}{\mathbb{N}}
+\newcommand{\Z}{\mathbb Z}
+\newcommand{\Q}{\mathbb Q}
+\newcommand{\R}{\mathbb R}
+\newcommand{\C}{\mathbb C}
+
+\newcommand{\ssi}{\;\;\Leftrightarrow\;\;}
+
+\newcommand{\point}[1]{-- +(#1,#1) -- +(-#1,-#1) -- +(0,0) -- +(-#1,#1) -- +(#1,-#1)}
+
+
+\newcommand{\parallele}{\mathbin{\!/\mkern-5mu/\!}} %signe parallèle
+
+\titleformat{\chapter}[frame]
+{\setlength\fboxrule{2.25pt}\color{black}}%
+{\filleft\scshape\LARGE%
+\enspace Chapitre \thechapter\enspace}%
+{20pt}
+{\rule{0pt}{30pt}\Huge\scshape\filleft}
+
+\newcommand\fonction[5]{
+$\begin{array}{rrll}
+#1: & #2 & \rightarrow & #3 \\
+ & #4 & \mapsto & #5
+\end{array}$
+}
+
+%\titleformat
+%{\section} % command
+%[hang] % shape
+%{\bfseries\Large} % format
+%{ \thesection\quad} % label
+%{0em} % sep
+%{
+%} % before-code
+%[
+%\vspace{-1ex}%
+%\textcolor{blue!60}{\rule{10cm}{3pt}}
+%] % after-code
+
+
+%\theoremstyle{break}
+\newtheoremstyle{definition-style} %style des theoreme
+{}
+{}
+{}
+{}
+{\bf\sffamily}
+{~:\\[0.3cm]}
+{.5em}
+{\thmname{#1}\thmnumber{ #2}\thmnote{ (#3)}}
+
+\mdfdefinestyle{defi-frame}{
+linewidth=10pt, %
+linecolor= blue!50, %
+backgroundcolor= blue!20,
+topline=false, %
+bottomline=false, %
+rightline=false,%
+leftmargin=0pt, %
+innerleftmargin=15pt, %
+innerrightmargin=1em,
+rightmargin=0pt, %
+innertopmargin=-2pt,%
+innerbottommargin=6pt, %
+splittopskip=\topskip, %
+%splitbottomskip=\topskip, %
+}%
+
+\mdfdefinestyle{methode-frame}{
+ linewidth=10pt, %
+linecolor= gray!70, %
+backgroundcolor= white,
+topline=false, %
+bottomline=false,%
+rightline=false,%
+leftmargin=0pt, %
+innerleftmargin=15pt, %
+innerrightmargin=1em,
+rightmargin=0pt, %
+innertopmargin=-2pt,%
+innerbottommargin=6pt, %
+splittopskip=\topskip, %
+%splitbottomskip=\topskip, %
+}%
+
+
+\mdfdefinestyle{thm-frame}{
+linewidth=10pt, %
+linecolor= red!50, %
+backgroundcolor= orange!30,
+topline=false, %
+bottomline=false, %
+rightline=false,%
+leftmargin=0pt, %
+innerleftmargin=15pt, %
+innerrightmargin=1em,
+rightmargin=0pt, %
+innertopmargin=-2pt,%
+innerbottommargin=6pt, %
+splittopskip=\topskip, %
+%splitbottomskip=\topskip, %
+}%
+
+\mdfdefinestyle{lem-frame}{
+linewidth=10pt, %
+linecolor= yellow!50, %
+backgroundcolor= yellow!10,
+topline=false, %
+bottomline=false, %
+rightline=false,%
+leftmargin=0pt, %
+innerleftmargin=15pt, %
+innerrightmargin=1em,
+rightmargin=0pt, %
+innertopmargin=-2pt,%
+innerbottommargin=6pt, %
+splittopskip=\topskip, %
+%splitbottomskip=\topskip, %
+}%
+
+\mdfdefinestyle{notation-frame}{
+linewidth=10pt, %
+linecolor= blue!30, %
+backgroundcolor= blue!10,
+topline=false, %
+bottomline=false, %
+rightline=false,%
+leftmargin=0pt, %
+innerleftmargin=15pt, %
+innerrightmargin=1em,
+rightmargin=0pt, %
+innertopmargin=-2pt,%
+innerbottommargin=6pt, %
+splittopskip=\topskip, %
+%splitbottomskip=\topskip, %
+}%
+
+\mdfdefinestyle{remarque-frame}{
+linewidth=0pt, %
+linecolor= black!0, %
+backgroundcolor= blue!0,
+topline=false, %
+bottomline=false, %
+rightline=false,%
+leftmargin=0pt, %
+innerleftmargin=25pt, %
+innerrightmargin=25pt,
+rightmargin=0pt, %
+innertopmargin=-2pt,%
+innerbottommargin=6pt, %
+splittopskip=\topskip, %
+%splitbottomskip=\topskip, %
+}%
+\surroundwithmdframed[style=defi-frame]{defi}
+
+\surroundwithmdframed[style=thm-frame]{thm}
+
+\surroundwithmdframed[style=lem-frame]{lem}
+
+\surroundwithmdframed[style=notation-frame]{notation}
+
+\surroundwithmdframed[style=remarque-frame]{remarque}
+
+\surroundwithmdframed[style=remarque-frame]{remarques}
+
+\surroundwithmdframed[style=methode-frame]{methode}
+
+\theoremstyle{definition-style}
+
+%pour avoir un compteur commun a remarque et remarques
+\newcounter{compteurremarque}[chapter]
+\renewcommand{\thecompteurremarque}{\arabic{compteurremarque}} %définition de l'affichage du compteur
+
+\newtheorem{defi}{Définition}[chapter]
+\renewcommand{\thedefi}{\arabic{defi}} %pour ne pas avoir le numéro du chapitre dans la numération de la def
+\newtheorem{thm}{Théorème}[chapter]
+\renewcommand{\thethm}{\arabic{thm}}
+\newtheorem{lem}{Lemme}[chapter]
+\renewcommand{\thelem}{\arabic{lem}}
+\newtheorem{notation}{Notation}[chapter]
+\renewcommand{\thenotation}{\arabic{notation}}
+%\newtheorem{remarque}{Remarque}[chapter]
+%\renewcommand{\theremarque}{\arabic{remarque}}
+%\newtheorem{remarques}{Remarques}[chapter]
+%\renewcommand{\theremarques}{\arabic{remarques}}
+\newtheorem{methode}{Méthode}[chapter]
+\renewcommand{\themethode}{\arabic{methode}}
+
+
+\newtheorem{remarque}[compteurremarque]{Remarque}
+\newtheorem{remarques}[compteurremarque]{Remarques} %remarque et remarques prennent compteurremarque comme compteur commun
+
+\lstMakeShortInline[columns=fixed]|
+
+%%%%%%%% Commandes de Matthieu
+
+%-------------------------------------------------------------------------------
+%---- Eclairage : en encadré sur fond jaune avec symbôle "ampoule" à gauche ----
+%-------------------------------------------------------------------------------
+\definecolor{coleclairage}{RGB}{255 , 221 , 156}
+\definecolor{contoureclairage}{RGB}{255 , 192 , 0}
+\newenvironment{eclairage}
+{
+ \begin{center}%
+ \begin{tikzpicture}%
+ \node[rectangle, draw=contoureclairage, top color=coleclairage!50, bottom color=coleclairage!140, rounded corners=5pt, inner xsep=5pt, inner ysep=6pt, outer ysep=10pt]\bgroup
+ \begin{minipage}{0.98\linewidth}
+ \begin{minipage}{0.08\linewidth}\centerline{\includegraphics[scale=1]{images/Symbole_eclairage.png}}\end{minipage}
+ \begin{minipage}{0.89\linewidth}\itshape\footnotesize
+ }
+ {
+ \end{minipage}
+ \end{minipage}\egroup;%
+ \end{tikzpicture}%
+ \end{center}%
+}
+
+
+
+\newcommand{\putfigure}[6]{
+ \begin{minipage}{#1\textwidth}
+ \centering
+ \includegraphics[width=#2\textwidth,height=#3\textheight]{#4}
+ \captionof{figure}{#5}
+ \label{#6}
+ \end{minipage}
+}
+
+
+\newcommand{\itemb}[1]{\item \textbf{#1}}
+
+
+
+%-------------------------------------------------------------------------------
+%---- apprendre : en encadré sur fond jaune avec symbole "ampoule" à gauche ----
+%-------------------------------------------------------------------------------
+\definecolor{colapprendre}{RGB}{50,205,50}
+\definecolor{contourapprendre}{RGB}{34,139,34}
+\newenvironment{apprendre}
+{
+ \begin{center}%
+ \begin{tikzpicture}%
+ \node[rectangle, draw=contourapprendre, top color=colapprendre!10, bottom color=colapprendre!50, rounded corners=5pt, inner xsep=5pt, inner ysep=6pt, outer ysep=10pt]\bgroup
+ \begin{minipage}{0.98\linewidth}
+ \begin{minipage}{0.08\linewidth}\centerline{\includegraphics[width=30px]{images/Symbole_learn.png}}\end{minipage}
+ \begin{minipage}{0.89\linewidth}\itshape\footnotesize
+ }
+ {
+ \end{minipage}
+ \end{minipage}\egroup;%
+ \end{tikzpicture}%
+ \end{center}%
+}
+
+\definecolor{colimportant}{RGB}{247 , 189 , 164}
+\definecolor{contourimportant}{RGB}{237 , 125 , 49}
+\newenvironment{important}
+{
+ \begin{center}%
+ \begin{tikzpicture}%
+ \node[rectangle, draw=contourimportant, top color=colimportant!50, bottom color=colimportant!140, rounded corners=5pt, inner xsep=5pt, inner ysep=6pt, outer ysep=10pt]\bgroup
+ \begin{minipage}{0.08\linewidth}\centerline{\includegraphics[scale=0.8]{images/Symbole_attention.png}}\end{minipage}
+ \begin{minipage}{0.89\linewidth}
+ }
+ {
+ \end{minipage}\egroup;
+ \end{tikzpicture}%
+ \end{center}%
+}
+
+%----------------------------------------------
+\newcounter{compteurmonprogramme}
+\setcounter{compteurmonprogramme}{1}
+\newenvironment{monprogramme}
+{
+ \begin{center}%
+ \begin{tikzpicture}%
+ \node[rectangle, draw=black, rounded corners=5pt, inner xsep=5pt, inner ysep=6pt, outer ysep=10pt]\bgroup
+ \begin{minipage}{0.98\linewidth}
+ {\bf Programme \thechapter.\thecompteurmonprogramme\;:}
+
+ \vspace{2mm}\hspace{7.5mm}
+ \begin{minipage}{0.93\linewidth}
+ }
+ {
+ \end{minipage}
+ \stepcounter{compteurmonprogramme}
+ \end{minipage}\egroup;%
+ \end{tikzpicture}%
+ \end{center}%
+}
+
+
+
+%------------------------------------------------
+%---- Définition : en encadré sur fond blanc ----
+%------------------------------------------------
+\newcounter{compteurdef}
+\setcounter{compteurdef}{1}
+\newenvironment{mydefinition}
+{
+ \begin{center}%
+ \begin{tikzpicture}%
+ \node[rectangle, draw=black, rounded corners=5pt, inner xsep=5pt, inner ysep=6pt, outer ysep=10pt]\bgroup
+ \begin{minipage}{0.98\linewidth}
+ {\bf {\underline {Définition \thechapter.\thecompteurdef}}}
+
+ \vspace{2mm}\hspace{4.5mm}
+ \begin{minipage}{0.93\linewidth}
+ }
+ {
+ \end{minipage}
+ \stepcounter{compteurdef}
+ \end{minipage}\egroup;%
+ \end{tikzpicture}%
+\end{center}%
+}
+
+\newenvironment{mydefinitions}
+{
+ \begin{center}%
+ \begin{tikzpicture}%
+ \node[rectangle, draw=black, rounded corners=5pt, inner xsep=5pt, inner ysep=6pt, outer ysep=10pt]\bgroup
+ \begin{minipage}{0.98\linewidth}
+ {\bf {\underline {Définitions \thechapter.\thecompteurdef}}}
+
+ \vspace{3mm}\hspace{4.5mm}
+ \begin{minipage}{0.93\linewidth}\slshape
+ \begin{itemize}\setlength{\itemsep}{1mm}
+ }
+ {
+ \end{itemize}\end{minipage}
+ \stepcounter{compteurdef}
+ \end{minipage}\egroup;%
+ \end{tikzpicture}%
+ \end{center}%
+}
+
+
+
+%------------------------------------------------
+%---- Exemple : en encadré sur fond blanc ----
+%------------------------------------------------
+\newcounter{compteurex}
+\setcounter{compteurex}{1}
+\newenvironment{myexample}{
+ \begin{center}
+ \vspace{-3mm}
+ \begin{minipage}{1\linewidth}
+ \vspace{2mm}
+ {\textsl {\underline {Exemple \thechapter.\thecompteurex}}}
+
+ \vspace{2mm}\hspace{2.5mm}
+ \begin{minipage}{1\linewidth}
+ \begin{mdframed}[topline=false,rightline=false,bottomline=false]
+}
+{
+ \end{mdframed}
+ \end{minipage}
+ \stepcounter{compteurex}
+ \end{minipage}
+ \end{center}
+}
+\newenvironment{myexamples}{
+ \begin{center}
+ \vspace{-3mm}
+ \begin{minipage}{1\linewidth}
+ \vspace{2mm}
+ {\textsl {\underline {Exemples \thechapter.\thecompteurex}}}
+
+ \vspace{2mm}\hspace{2.5mm}
+ \begin{minipage}{1\linewidth}%\slshape
+ \begin{mdframed}[topline=false,rightline=false,bottomline=false]
+ \begin{enumerate}\setlength{\itemsep}{1mm}
+ }
+ {
+ \end{enumerate}
+ \end{mdframed}
+ \end{minipage}
+ \stepcounter{compteurex}
+ \end{minipage}
+ \end{center}
+}
+
+
+
+\newtheorem*{question}{Question}
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%% LABELS activite %%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\newcommand{\act}{\textbf{\textsl{Activité \arabic{compteuract}}} \vspace*{1mm}\\ \addtocounter{compteuract}{1}}
+\newcommand{\actnomme}[1]{{\bf Activité \arabic{compteuract} {\textsl{\small (#1)}}}\vspace*{1mm}\\ \addtocounter{compteuract}{1}}
+\newcounter{compteuract}
+\setcounter{compteuract}{1}
+\newcommand{\getactcompteur}{{\the\numexpr \arabic{compteuract} - 1 \relax}}
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%% LABELS EXERCICES %%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\newcommand{\exo}{\textbf{\textsl{Exercice \arabic{compteurexo}}} \vspace*{1mm}\\ \addtocounter{compteurexo}{1}}
+\newcommand{\exonomme}[1]{{\bf Exercice \arabic{compteurexo} {\textsl{\small (#1)}}}\vspace*{1mm}\\ \addtocounter{compteurexo}{1}}
+\newcommand{\eexo}{\vspace{5mm}} % espace pour séparer les exercices
+\newcounter{compteurexo}
+\setcounter{compteurexo}{1}
+\newcommand{\getexocompteur}{{\the\numexpr \arabic{compteurexo} - 1 \relax}}
\ No newline at end of file