3_Representation_caracteres_diapo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## <p style=\"text-align: center;\">NSI - Représentation des caractères</p>\n",
    "## <p style=\"text-align: center;\">Lycée Beaussier - F. Lagrave</p>\n",
    "\n",
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Fklag/NSI_iere/master?filepath=3_Representation_caracteres_diapo.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Représentation des caractères"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "En informatique, une information est codée exclusivement par des séquences de $0$ et $1$. On a vu précédemment <a href=\"http://lycee.lagrave.free.fr/nsi/numerisation/1_Representation_donnees_base_diapo.pdf\" target=\"_blank\">comment coder des entiers et des réels en binaire</a> mais on a également besoin de trouver un moyen de coder du texte (caractères $\\text{'0'}$, $\\text{'1'}$, $\\text{'A'}$, $\\text{'é'}$ ; ponctuation $\\text{'!'}$ , $\\text{'?'}$ espace, $\\ldots$ ; symboles spéciaux comme €, $\\$$, @) comme une séquence de $0$ et $1$. Pour coder/décoder des caractères, il faut se mettre d'accord sur le nombre de bits utilisés pour représenter un caractère (pour pouvoir ségmenter une longue séquence de $0$ et de $1$ en caractères) et sur une table associant un mot binaire à un caractère. on associe à chaque caractère (une lettre, un signe de ponctuation, une espace…) un nombre. Un texte est alors une suite de ces nombres, on parle de **chaîne de caractères**. Dans les années 1980-1990, il y avait plusieurs normes pour coder les caractères qui sont apparues à travers le monde : l'$\\texttt{ASCII}$ aux Etat-unis, le <a href=\"https://fr.wikipedia.org/wiki/KOI8-R\" target=\"_blank\">KOI8-R</a> en Russie, $\\ldots$   \n",
    "\n",
    "Ces normes proposaient d'encoder les caractères sur $7$ ou $8$ bits mais le fait que les normes\n",
    "soient nées indépendemment les unes des autres rendait les systèmes difficilement interopérables et très spécifiques (en Russe, il faut pouvoir représenter l'alphabet cyrillique). Par exemple, l'**$\\texttt{ASCII}$ (American Standard Code for Information Interchange)** développé aux Etat-Unis, utilise $7$ bits ($128$ valeurs possibles) pour coder des caractères dont les codes apparaissent sur la table suivante .  \n",
    "(Certains systèmes de transmission utilisent le huitième bit pour autre chose, par exemple pour transmettre une somme de contrôle qui permet de détecter les erreurs de transmission les plus communes. On parle dans ce cas d'un <a href=\"http://vanconingsloo.be/les-cours/bacbes/structure-des-ordinateurs/controle-des-erreurs/methode-du-bit-de-parite/\" target=\"_blank\">bit de parité</a> *On compte le nombre de $1$ parmi les $7$ bits envoyés, si ce nombre est pair, on envoie $0$ comme $8$ième bit, sinon $1$. Au final le nombre de bits à $1$ de l’octet ($1$ octet = $8$ bits) est pair. On peut ainsi détecter une erreur de transmission si à la réception le nombre de bits d’un octet est impair, mais on ne peut pas corriger d’erreurs.*. )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./images/ASCII-Table.png\" alt=\"ASCII-Table\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Conversion  \n",
    "Deux fonctions prédéfinies permettent d'effectuer la conversion entre un caractère et son identifiant numérique correspondant. La fonction $\\texttt{ord}$ donne l'identifiant numérique correspondant à un caractère tandis que la fonction $\\texttt{chr}$ fait l'opération inverse. Examinons l'exemple suivant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(124, 'A', '0b110001', 49, '1', '\\x01')"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('|'),chr(65),bin(ord(\"1\")),ord(\"1\"),chr(49),chr(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = bytearray([0b1100001, 0b1100010, 0b1100011, 0b1100100])     \n",
    "data.decode('ascii')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Cet exemple nous montre comment les informaticiens inventent une façon de coder un texte en mémoire. Il y a des caractères particuliers, dits « de contrôle », qui ne servent pas pour un symbole « imprimable » mais donnent des indications aux programmes qui manipulent les chaînes de caractères. Le plus important est le caractère « fin de chaîne » qui sert à indiquer où s’arrête la chaîne (sinon, le programme n'aurait pas de moyen de le savoir et continuerait à lire ce qui se trouve après, ce qui nous vaudrait de belles erreurs).\n",
    "\n",
    "<kbd>LF</kbd></em> (0x0A)&nbsp;: nouvelle ligne (<em>line feed</em>), le <code data-claire-semantic=\"c\">' '</code> des programmeurs&nbsp;;</p></li><li id=\"r-455340\" data-claire-element-id=\"455340\"><p id=\"r-455339\" data-claire-element-id=\"455339\"><em><kbd>CR</kbd></em> (0x0D)&nbsp;: retour chariot (<em>carriage return</em>), le <code data-claire-semantic=\"c\">' '</code> des programmeurs&nbsp;; marque la fin d’une ligne&nbsp;;</p>\n",
    "\n",
    "> <a href=\"https://fr.wikipedia.org/wiki/Fin_de_ligne\" target=\"_blank\">Attention</a>, il peut être utile de savoir si   $\\texttt{CR}$ ou $\\texttt{CR+LF}$  a été utilisé comme fin de ligne dans un fichier texte ;  \n",
    "En effet, <a href=\"https://www.developpez.com/actu/202693/Le-Bloc-notes-de-Windows-prend-enfin-en-charge-les-caracteres-de-fin-de-ligne-Unix-Linux-et-Mac-plus-de-30-ans-apres-la-sortie-de-l-editeur-de-texte/\" target=\"_blank\">les retours à la ligne sont codés</a> sous Windows par CR+LF, c'est-à-dire l'association des caractères $\\texttt{ASCII}  13$ (CR pour Carriage Return, retour chariot) et $10$ (LF pour Line Feed, saut de ligne). Les systèmes Unix n'utilisent quant à eux que le caractère $\\texttt{ASCII} 10$ (LF), tandis que les systèmes Mac utilisaient uniquement le caractère $13$ (CR).   \n",
    "$\\texttt{\\n}$ : saut à la ligne (retour chariot) en $\\texttt{Python}$\n",
    "\n",
    "* Premièrement, on décide de l'**ensemble des caractères** dont on a besoin, et on assigne à chacun **un identifiant numérique unique appelé code**. Cet ensemble est appelé **jeu de caractères codés** (en anglais $\\texttt{charset}$, abréviation de *character set*) et peut se résumer dans un tableau de correspondance comme ci-dessus.  \n",
    "* Ensuite, il faut déterminer l'**encodage** (*encoding*), c'est-à-dire la façon de transcrire un texte grâce aux codes des caractères qui le composent, selon un jeu de caractères donné. Le moyen le plus simple est d'écrire directement chaque code (auquel cas on parle de **page de code** — *charmap*) ; le jeu et l'encodage sont alors confondus  mais ce n'est pas toujours satisfaisant. C'est pourquoi il faut bien retenir la différence entre jeu de caractères et encodage (c'est-à-dire une **manière de représenter chaque identifiant numérique en une suite de bits**). On s'arrangera dans nos encodages pour que les codes de notre jeu tiennent tous sur un ou deux octets par exemple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Le code $\\texttt{ASCII}$ présente quelques limites qui sont dues au petit nombre de caractères qu'il peut coder ; il lui manque des caractères importants, comme $\\times$ le symbole de la multiplication. (Pour cette raison, les informaticiens ont pris l'habitude de noter la multiplication en utilisant le caractère $*$ .)  \n",
    "Il manque aussi nos caractères accentués ; en effet, les américains n'utilisent pas de caractères accentués ; et bien sûr bien d'autres caractères manquent pour satisfaire toutes les langues. Il y a eu donc une flopée de normes dont notamment les normes $ISO-8859-x$, avec $x$ variant de $1$ à $16$, chacune encodant des caractères d'une langue différente, sur $8$ bits.  \n",
    "\n",
    "Par exemple, la norme $ISO 8859-1$ couvre les caractères de la plupart des langues européennes, la norme\n",
    "$ISO 8859-5$ couvre l'alphabet cyrillique, $\\ldots$  \n",
    "\n",
    "Ces tableaux, c'est ce qu'on appelle les **encodings**, et il y en a beaucoup. Voici la liste de ceux que $\\texttt{Python}$ gère :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- ascii\n",
      "- base64_codec\n",
      "- big5\n",
      "- big5hkscs\n",
      "- bz2_codec\n",
      "- cp037\n",
      "- cp1026\n",
      "- cp1125\n",
      "- cp1140\n",
      "- cp1250\n",
      "- cp1251\n",
      "- cp1252\n",
      "- cp1253\n",
      "- cp1254\n",
      "- cp1255\n",
      "- cp1256\n",
      "- cp1257\n",
      "- cp1258\n",
      "- cp273\n",
      "- cp424\n",
      "- cp437\n",
      "- cp500\n",
      "- cp775\n",
      "- cp850\n",
      "- cp852\n",
      "- cp855\n",
      "- cp857\n",
      "- cp858\n",
      "- cp860\n",
      "- cp861\n",
      "- cp862\n",
      "- cp863\n",
      "- cp864\n",
      "- cp865\n",
      "- cp866\n",
      "- cp869\n",
      "- cp932\n",
      "- cp949\n",
      "- cp950\n",
      "- euc_jis_2004\n",
      "- euc_jisx0213\n",
      "- euc_jp\n",
      "- euc_kr\n",
      "- gb18030\n",
      "- gb2312\n",
      "- gbk\n",
      "- hex_codec\n",
      "- hp_roman8\n",
      "- hz\n",
      "- iso2022_jp\n",
      "- iso2022_jp_1\n",
      "- iso2022_jp_2\n",
      "- iso2022_jp_2004\n",
      "- iso2022_jp_3\n",
      "- iso2022_jp_ext\n",
      "- iso2022_kr\n",
      "- iso8859_10\n",
      "- iso8859_11\n",
      "- iso8859_13\n",
      "- iso8859_14\n",
      "- iso8859_15\n",
      "- iso8859_16\n",
      "- iso8859_2\n",
      "- iso8859_3\n",
      "- iso8859_4\n",
      "- iso8859_5\n",
      "- iso8859_6\n",
      "- iso8859_7\n",
      "- iso8859_8\n",
      "- iso8859_9\n",
      "- johab\n",
      "- koi8_r\n",
      "- kz1048\n",
      "- latin_1\n",
      "- mac_cyrillic\n",
      "- mac_greek\n",
      "- mac_iceland\n",
      "- mac_latin2\n",
      "- mac_roman\n",
      "- mac_turkish\n",
      "- mbcs\n",
      "- ptcp154\n",
      "- quopri_codec\n",
      "- rot_13\n",
      "- shift_jis\n",
      "- shift_jis_2004\n",
      "- shift_jisx0213\n",
      "- tactis\n",
      "- tis_620\n",
      "- utf_16\n",
      "- utf_16_be\n",
      "- utf_16_le\n",
      "- utf_32\n",
      "- utf_32_be\n",
      "- utf_32_le\n",
      "- utf_7\n",
      "- utf_8\n",
      "- uu_codec\n",
      "- zlib_codec\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import encodings\n",
    "print(''.join('- ' + e + '\\n' for e in sorted(set(encodings.aliases.aliases.values()))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Les normes ISO étendent la norme $\\texttt{ASCII}$ en utilisant les mêmes $128$ premiers caractères. Comme la norme ISO propose un encodage sur $8$ bits, il y a $128$ caractères supplémentaires à utiliser. En pratique ces $128$ caractères supplémentaires ne sont pas tous utilisés mais en tout cas, en fonction de la norme considérée, ils ne représentent pas la même valeur ; Quelques caractères des différentes normes $ISO-8859-x$ sont représentés sur la table suivante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<a href=\"https://fr.wikipedia.org/wiki/ISO/CEI_8859\" target=\"_blank\"><img src=\"./images/iso8859.png\" alt=\"iso8859\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'é'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bytearray([0b11101001]).decode('latin-1') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Le caractère <em><kbd>NBSP</kbd></em> (0xA0) est l'**espace insécable** (<em>non-breaking space</em>), c'est-à-dire une espace qui, contrairement à l'espace habituelle, ne «&nbsp;sépare&nbsp;» pas les mots. Ça veut dire que si vous écrivez «&nbsp;Bonjour&nbsp;!&nbsp;» avec une espace insécable et que ça se retrouve à la fin d'une ligne d'affichage, le «&nbsp;Bonjour&nbsp;» ne sera pas séparé du point d'exclamation (ils iront ensemble au début de la ligne suivante) contrairement à une espace simple. Ce caractère est surtout utilisé avec les signes de ponctuation (avant «&nbsp;?&nbsp;», «&nbsp;!&nbsp;», «&nbsp;;&nbsp;», «&nbsp;:&nbsp;» et entre les guillemets “«” et “»”). Ce sont les espaces bizarres qui apparaissent en gris dans OpenOffice. ;)\n",
    "\n",
    "> Texte à encoder  \n",
    "    « Ô âme oubliée ! »\n",
    "    \n",
    "texte&nbsp;:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;«&nbsp;&nbsp;▒&nbsp;&nbsp;Ô&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;â&nbsp;&nbsp;m&nbsp;&nbsp;e&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;o&nbsp;&nbsp;u&nbsp;&nbsp;b&nbsp;&nbsp;l&nbsp;&nbsp;i&nbsp;&nbsp;é&nbsp;&nbsp;e&nbsp;&nbsp;▒&nbsp;&nbsp;!&nbsp;&nbsp;▒&nbsp;&nbsp;»&nbsp;&nbsp;  \n",
    "valeur&nbsp;en&nbsp;latin-1&nbsp;:&nbsp;AB&nbsp;A0&nbsp;D4&nbsp;20&nbsp;E2&nbsp;6D&nbsp;65&nbsp;20&nbsp;6F&nbsp;75&nbsp;62&nbsp;6C&nbsp;69&nbsp;E9&nbsp;65&nbsp;A0&nbsp;21&nbsp;A0&nbsp;BB  \n",
    "\n",
    "Notez l'emploi d’espaces insécables (symbolisés par ▒ pour qu’on les voit) avant le point d'exclamation et entre les guillemets, conformément aux règles typographiques. :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Sous Windows, vous pouvez insérer n'importe quel caractère de **Windows-1252** (donc de * **latin-1** * et d'$\\texttt{ASCII}$) avec la combinaison <kbd>Alt</kbd>+<kbd>0</kbd><em><kbd>num</kbd></em> où <em>num</em> est le code du caractère en décimal — notez qu'il faut bien entrer un chiffre zéro au début, sinon, vous obtiendrez un caractère de la vieille page de code de votre système (850 ou 437).<br> Les exemples les plus courants pour le français :</p><ul id=\"r-455667\" data-claire-element-id=\"455667\"><li id=\"r-455656\" data-claire-element-id=\"455656\"><p id=\"r-455655\" data-claire-element-id=\"455655\"><kbd>Alt</kbd>+<kbd>0</kbd><kbd>1</kbd><kbd>9</kbd><kbd>2</kbd> → <strong>À</strong></p></li><li id=\"r-455658\" data-claire-element-id=\"455658\"><p id=\"r-455657\" data-claire-element-id=\"455657\"><kbd>Alt</kbd>+<kbd>0</kbd><kbd>1</kbd><kbd>9</kbd><kbd>9</kbd> → <strong>Ç</strong></p></li><li id=\"r-455660\" data-claire-element-id=\"455660\"><p id=\"r-455659\" data-claire-element-id=\"455659\"><kbd>Alt</kbd>+<kbd>0</kbd><kbd>2</kbd><kbd>0</kbd><kbd>1</kbd> → <strong>É</strong></p></li><li id=\"r-455662\" data-claire-element-id=\"455662\"><p id=\"r-455661\" data-claire-element-id=\"455661\"><kbd>Alt</kbd>+<kbd>0</kbd><kbd>1</kbd><kbd>6</kbd><kbd>0</kbd> (ou <kbd>Alt</kbd>+<kbd>2</kbd><kbd>5</kbd><kbd>5</kbd>) → <em>espace insécable</em></p></li><li id=\"r-455664\" data-claire-element-id=\"455664\"><p id=\"r-455663\" data-claire-element-id=\"455663\"><kbd>Alt</kbd>+<kbd>0</kbd><kbd>1</kbd><kbd>7</kbd><kbd>1</kbd> (ou <kbd>Alt</kbd>+<kbd>1</kbd><kbd>7</kbd><kbd>4</kbd>) → <strong>«</strong></p></li><li id=\"r-455666\" data-claire-element-id=\"455666\"><p id=\"r-455665\" data-claire-element-id=\"455665\"><kbd>Alt</kbd>+<kbd>0</kbd><kbd>1</kbd><kbd>8</kbd><kbd>7</kbd> (ou <kbd>Alt</kbd>+<kbd>1</kbd><kbd>7</kbd><kbd>5</kbd>) → <strong>»</strong></p></li></ul><p id=\"r-455668\" data-claire-element-id=\"455668\">Sous Ubuntu, le clavier est plus complet et la touche <kbd>AltGr</kbd>, utilisée en combinaison avec les autres touches (et <kbd>Maj</kbd>), permet d’accéder à de nombreux caractères. Je vous laisse chercher&nbsp;!</p><p id=\"r-455669\" data-claire-element-id=\"455669\">À partir de maintenant, je vous interdit de massacrer le français&nbsp;! :pirate: D’ailleurs, voici <a href=\"https://openclassrooms.com/fr/courses/3013891-ameliorez-limpact-de-vos-presentations/4111211-choisissez-la-typographie-adaptee\">un cours sur la typographie</a> si ça vous intéresse, et arrêtons-là le hors-sujet, voulez-vous ?</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Plus récemment, un nouveau format, issu du standard Unicode et de la norme $ISO 10646$, commence à s'imposer : le format $UTF-8$. Ce format code tout les caractères possibles en utilisant un nombre variable de mots de $8$ bits (le format $UTF-8$ accepte jusqu'à $4$ octets)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Au fait, il y a une notation officielle pour désigner n'importe quel **caractère Unicode** : <strong>U+<em>xxxx</em></strong>, où <em>xxxx</em> est le code hexadécimal (jusqu'à $6$ chiffres).   \n",
    "Par exemple, $U+0041$ correspond à la lettre $A$ majuscule, $U+23CF$ au symbole ⏏…</p><p id=\"r-455697\" data-claire-element-id=\"455697\">*Une astuce* : Certaines distributions Linux offrent le raccourci <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>U</kbd>+<em><kbd>code</kbd></em> pour insérer directement n'importe quel caractère Unicode dont vous spécifiez le code hexadécimal.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$\\texttt{Python}$ fonctionne avec la table de caractères Unicode (ISO 10646), un standard d'échange de texte qui a vu le jour en 1987. Cette table comporte plus de $128000$ caractères (la liste de tous les caractères Unicode peut être consultée sur le site web suivant : <a href=\"http://unicode-table.com/\" target=\"_blank\">http://unicode-table.com/</a>) dans sa dernière version.\n",
    "\n",
    "**Unicode** est basiquement un jeu de caractères (un ensemble de caractères auxquels on attribue à chacun un point de code unique) et non un encodage (façon de représenter ce point de code en mémoire). C'est ici que la distinction prend tout son sens. Auparavant, les deux se confondaient puisque tous les jeux de caractères étaient associés à un encodage simple : vu que leur codes tenaient sur un ou deux octets, on se contentait de les écrire tels quels en mémoire.\n",
    "\n",
    "Or, les points de codes d'Unicode nécessitent beaucoup plus qu'un octet : il leur en faudrait quatre ! Cela voudrait dire que si l'on continuait à faire comme avant, on utiliserait $4$ fois plus de mémoire qu'avec nos jeux précédents tenant sur un octet, comme $ISO 8859$.  \n",
    "\n",
    "Le codage Unicode présente deux inconvénients : les documents sont *plus gros* et il est incompatible avec l'$\\texttt{ASCII}$ . C'est la raison d'être de la norme $UTF$ (*Unicode Translation Format*) , qui permet de maintenir la compatibilité : tous les caractères du code $\\texttt{ASCII}$  sont codés en $UTF$ sur un octet avec la même valeur qu'en $\\texttt{ASCII}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### $UTF-16$   \n",
    "Pour faire des économies, on a donc mis au point des encodages plus futés. Tout d'abord, il y a l'$UTF-16$ (UCS transformation format, $16$ bits). Celui-ci code les $2^{16} = 65 536$ premiers caractères sur $2$ octets, et les codes supérieurs sont représentés sur $4$ octets par le biais d'une petite transformation mathématique. Le $16$ dans son nom indique le nombre minimal de bits nécessaires pour un caractère.  \n",
    "Les caractères de cet encodage ne font donc pas tous la même taille, ce qui complique un poil les traitements (même s'il est facile de distinguer un caractère sur $2$ octets d'un caractère sur $4$).\n",
    "\n",
    "De plus, on a une difficulté technique supplémentaire pour l'$UTF-16$ (et l'$UTF-32$) : le **boutisme** (*endianness*). Ce terme mystique désigne l'ordre dans lequel sont « rangés » les octets d'un nombre multi-octet. Il en existe deux sortes principales : le gros boutisme (big-endian, BE) et le petit boutisme (little-endian, LE).  \n",
    "Le problème, c'est que le boutisme dépend des machines et que ces deux-là sont très répandus. Or en $UTF-16$ on lit les données par groupes de $2$ octets, donc le boutisme influe sur le résultat : si l'on lit du texte $UTF-16$ envoyé par quelqu'un utilisant un boutisme différent du sien, c’est l’erreur assurée !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> Texte à encoder  \n",
    "    « Ô âme oubliée ! »\n",
    "\n",
    "texte&nbsp;:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;«____&nbsp;▒____&nbsp;Ô____&nbsp;&nbsp;____&nbsp;â____&nbsp;m____&nbsp;e____&nbsp;&nbsp;____&nbsp;o____&nbsp;u____&nbsp;b____&nbsp;l____&nbsp;i____&nbsp;é____&nbsp;e____&nbsp;▒____&nbsp;!____&nbsp;▒____&nbsp;»____  \n",
    "valeur&nbsp;en&nbsp;UTF-16&nbsp;:&nbsp;&nbsp;00-AB&nbsp;00-A0&nbsp;00-D4&nbsp;00-20&nbsp;00-E2&nbsp;00-6D&nbsp;00-65&nbsp;00-20&nbsp;00-6F&nbsp;00-75&nbsp;00-62&nbsp;00-6C&nbsp;00-69&nbsp;00-E9&nbsp;00-65&nbsp;00-A0&nbsp;00-21&nbsp;00-A0&nbsp;00-BB\n",
    "\n",
    "Remarquez que ce texte en $UTF-16$ s'encode exactement comme en latin-1, avec des valeurs sur $2$ octets au lieu d'un (donc un octet sur deux valant $0$). On occupe donc deux fois plus de mémoire.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### $UTF-8$  \n",
    "La taille des caractères codés est encore plus variable, et l'économie de mémoire plus grande. Comme vous l'avez deviné, le nombre minimal de bits est $8$. En fait, il représente les premiers caractères (ceux de l'$\\texttt{ASCII}$) sur un octet, les suivants sur $2$ octets, $3$ et jusqu'à $4$ octets.  \n",
    "\n",
    "En plus, cet encodage est compatible avec l'$\\texttt{ASCII}$: les caractères sont codés exactement de la même manière en $UTF-8$ et en $\\texttt{ASCII}$. Ajoutez à cela que l'encodage a été conçu afin que certains algorithmes de traitement (comparaison de texte par exemple) soient réutilisables sans modification. Ainsi, de vieux programmes qui n'ont pas été conçus pour un autre encodage que l'\\texttt{ASCII} fonctionneront aussi si on leur passe du texte en $UTF-8$ : magique !  \n",
    "Enfin, contrairement à l'$UTF-16$, on n'a **pas de problème de boutisme** puisqu'on lit les données octet par octet. :)\n",
    "\n",
    "Bref, $UTF-8$ a de nombreux avantages (économie de mémoire, compatibilité, boutisme, résistance aux erreurs…). Un défaut aussi : la grande variabilité de taille des caractères qui rend les traitements plus compliqués et moins performants. Il n'empêche que ses point forts lui ont assuré un grand succès : il est **sans doute l'encodage le plus répandu aujourd'hui**. Il est utilisé pour les documents et les communications, et les systèmes d'exploitation (Mac et GNU/Linux) s'y mettent aussi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0b11000011', '0b10101001']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(bin, 'é'.encode('utf8')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Pour ne pas changer, exemple de texte en $UTF-8$ :  \n",
    "> Texte à encoder  \n",
    "    « Ô âme oubliée ! »\n",
    "    \n",
    "texte&nbsp;:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;«____&nbsp;▒____&nbsp;Ô____&nbsp;&nbsp;&nbsp;&nbsp;â____&nbsp;m&nbsp;&nbsp;e&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;o&nbsp;&nbsp;u&nbsp;&nbsp;b&nbsp;&nbsp;l&nbsp;&nbsp;i&nbsp;&nbsp;é____&nbsp;e&nbsp;&nbsp;▒____&nbsp;!&nbsp;&nbsp;▒____&nbsp;»____  \n",
    "valeur&nbsp;en&nbsp;UTF-8&nbsp;:&nbsp;&nbsp;&nbsp;C2-AB&nbsp;C2-A0&nbsp;C3-94&nbsp;20&nbsp;C3-A2&nbsp;6D&nbsp;65&nbsp;20&nbsp;6F&nbsp;75&nbsp;62&nbsp;6C&nbsp;69&nbsp;C3-A9&nbsp;65&nbsp;C2-A0&nbsp;21&nbsp;C2-A0&nbsp;C2-BB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Avec ou sans BOM ?\n",
    "\n",
    "La BOM est un **caractère Unicode spécial** qui permet d'indiquer le *boutisme* d'un fichier. Elle se place au tout début de ce fichier. Cette technique est utilisée pour l'$UTF-16$ (et l'$UTF-32$). En revanche, elle est inutile en $UTF-8$ puisqu'on n'a pas de problème de boutisme. Pire, elle peut rendre des fichiers invalides lorsqu'ils sont lus par certains programmes.\n",
    "Pourtant, certains éditeurs dont le fameux Bloc-Notes la rajoutent automatiquement même en $UTF-8$, car ça les aide à détecter l'encodage du fichier. C'est une pratique déconseillée.  \n",
    "Dans votre éditeur favori, **choisissez toujours la version sans BOM si vous avez le choix**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Maîtriser l'encoding de son code  \n",
    "Le fichier dans lequel vous écrivez votre code est dans un encoding et ce n'est pas lié à votre OS.   \n",
    "C'est votre éditeur qui s'en occupe. Apprenez à régler votre éditeur pour qu'il utilise l'encoding que vous voulez : $UTF-8$. \n",
    "\n",
    "Puis on peut **déclarer cet encoding à la première ligne** de chaque script $\\texttt{Python}$ avec l'expression suivante :  \n",
    "$\\texttt{# coding: utf8}\\, $ ou anciennement $\\, \\texttt{# -*- coding=utf-8 -*-}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# coding: utf8 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A-l-o-r-s-,- -ç-a- -a- -f-o-n-c-t-i-o-n-n-é- -o-u- -p-a-s- -?-"
     ]
    },
    {
     "data": {
      "text/plain": [
       "31"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ma_chaine = \"Alors, ça a fonctionné ou pas ?\"\n",
    "mon_codage = ma_chaine\n",
    "#mon_codage = ma_chaine.encode('utf-16')\n",
    "for octet in mon_codage :\n",
    "    print(octet, end=\"-\")\n",
    "\n",
    "\n",
    "len(mon_codage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exemple  \n",
    "Pour terminer cette partie, j'aimerais revenir sur la différence entre une valeur et son représentant.  \n",
    "Si on considère la séquence binaire ci-dessous (représentée en hexadécimal pour rester compact) :  \n",
    "$(626F 6E6A6F 757221)_{16}$  \n",
    "elle peut représenter plusieurs valeurs :\n",
    "* la chaı̂ne de caractères “bonjour !” si je considère que la séquence représente des caractères codés en $\\texttt{ASCII}$  \n",
    "* la valeur $7 093 009 341 547 377 185$ si je considère que la séquence représente un entier codé sur $64$ bits  \n",
    "* l'image <img src=\"./images/im.png\" alt=\"im\"/> si je considère que chaque bloc de $8$ bits code le niveau de gris d'un pixel considéré comme noir pour $0$ et blanc pour $255$,  \n",
    "* $\\ldots$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> Étant donné quatre octets qui contiennent les valeurs binaires $0010\\, 1000$ , $1001\\, 1100$ , $0100\\, 0011$ et $1000\\, 0000$ , que représentent-ils si :\n",
    "1. ce sont quatre nombres non signés (sur $8$ bits) ?\n",
    "2. ce sont deux nombres nombres non signés (sur $16$ bits) ? Que vaut leur somme en binaire ? en décimal ?\n",
    "3. ce sont quatre nombres en complément à deux (sur $8$ bits) ?\n",
    "4. ce sont deux nombres en complement à deux (sur $16$ bits) ? Que vaut leur somme en binaire ? en décimal ?\n",
    "5. S'il s'agit d'un nombre entier sur $32$ bits, quel est son ordre de grandeur ?\n",
    "6. S'il s'agit d'un nombre flottant sur $32$ bits, quel est-il avec la mantisse exprimée en binaire ? En décimal ?\n",
    "7. S'ils sont sensés coder quatre caractères $\\texttt{ASCII}$ ? $ISO-8859-1$ ? $UTF$ ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "1. $0010\\, 1000_{2} = 00\\, 101\\, 000_{2} = 050_{8} = 40_{10}$  \n",
    "   $1001\\, 1100_{2} = 10\\, 011\\, 100_{2} = 234_{8} = (2 \\times 8 + 3) \\times 8 + 4 = 156_{10}$   \n",
    "   $0100\\, 0011_{2} = 01\\, 000\\, 011_{2} = 103_{8} = 67_{10}$   \n",
    "   $1000\\, 0000 = 2^7 = 128_{10}$    \n",
    "  \n",
    "2. En supposant que le premier octet contient les poids forts :  \n",
    "   $0\\, 010\\, 100\\, 010\\, 011\\, 100_{2} = 024234_{8} = (((2\\times 8+4)\\times 8+2)\\times 8+3)\\times 8+4 = 10 396_{10}$  \n",
    "   $0\\, 100\\, 001\\, 110\\, 000\\, 000_{2} = 041600_{8} = ((4 \\times 8 + 1) \\times 8 + 6) \\times 8 \\times 8 = 17 280_{10}$  \n",
    "   Leur somme en binaire : $0\\, 1\\, 1\\, 0\\, 1\\, 1\\, 0\\, 0\\, 0\\, 0\\, 0\\, 1\\, 1\\, 1\\, 0\\, 0$  \n",
    "   Sa valeur en décimal : $0 110\\, 110\\, 000\\, 011\\, 100_{2} = 066034_{8} = 27676_{10}$  \n",
    "   (On peut vérifier facilement que le résultat est correct avec ( $10 396_{10} + 17 280_{10}$ )  \n",
    "\n",
    "3. Si ce sont des nombres en compléments à $2$, le premier et le troisième sont des nombres positifs qui ont la même valeur qu'au 1.  \n",
    "   Le deuxième et le quatrième sont des nombres négatifs. Commme $C_1(10\\,011\\,100) + 1 = 01\\,100\\,001 + 1 = 01\\,100 010_{2} = 142_{8} = 98_{10}$ le deuxième représente $-98$ ; le quatrième vaut $-128$ .\n",
    "\n",
    "4. Si ce sont des nombres en complément à $2$ sur $16$ bits ils sont positifs tous les deux puisque leurs bits de signe sont à $0$ et ils valent (comme au 2.) $10 396_{10}$ et $17 280_{10}$ . Le résultat de leur addition (effectuée au 2) est aussi un nombre positif et vaut donc aussi $27676_{10}$ .  \n",
    "\n",
    "5. Toujours en supposant que les bits de poids forts sont dans le premier octet, le nombre vaut $00\\, 101\\, 000\\, 100\\, 111\\, 000\\, 100\\, 001\\, 110\\, 000\\, 000_{2}$ . Le bit à $1$ le plus à gauche est en position numéro $29$, il code pour $2^{29} = 2^{9} \\times 2^{20}$ soit environ $512 \\times 10^6 = 5.12 \\times 10^8$ . L'ordre de grandeur du nombre est donc de $10^8$   \n",
    "\n",
    "6. En supposant qu'on a d'abord le bit de signe, puis l'exposant, puis la partie fractionnelle de la mantisse :  \n",
    "   Le signe contient $0$ : c'est un nombre positif.  \n",
    "   L'exposant contient $01\\, 010\\, 001_{2} = 121_{8} = 73_{10}$ . L'exposant vaut donc $-127 + 73 = -54$  \n",
    "   La partie fractionnelle de la mantisse contient $100\\, 111\\, 000\\, 100\\, 001\\, 110\\, 000\\, 000$ ,  \n",
    "   la mantisse vaut donc $1.100\\, 111\\, 000\\, 100\\, 001\\, 110_{2}$  \n",
    "   La valeur du nombre est donc $1.100\\, 111\\, 000\\, 100\\, 001\\, 110_{2} \\times 10_{2}^{-110110_{2}}$ en binaire. \n",
    "   La partie fractionnelle de la mantisse est $0.100\\, 111\\, 000\\, 100\\, 001\\, 110_{2} = 0.470416_{8} = 470416\\times 2^{-18}$  donc le nombre vaut $\\left(1 + 470416\\times 2^{-18} \\right) \\times 2^{-54}$ en décimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('(', 'C')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(0b00101000),chr(0b01000011)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "7. Le deuxième et le quatrième sont supérieurs à $127$ : il ne peuvent pas représenter des caractères $\\texttt{ASCII}$.      \n",
    "   L'utilisation de $\\texttt{chr}$ en $\\texttt{Python}$ permet de constater que le premier code une parentèse ouvrante et le troisième le caractère C.  \n",
    "   \n",
    "   En $ISO-8859-1$ le premier et le troisième codent toujours la parenthèse ouvrante et le C majuscule comme dans le code ASCII ; le deuxième et le quatrième codent des caractères qui n'appartiennent pas au code $\\texttt{ASCII}$. Ce sont tous les deux des \"caractères de contrôle étendus\"   ce qui signifie qu'ils ne sont pas imprimables.  \n",
    "   \n",
    "   En $UTF$, le premier octet est inférieur à $128$ et code donc le même caractère que l'$\\texttt{ASCII}$ ; le second est supérieur ou égal à $128$ et devrait donc être le premier octet d'un caractère sur $2$ ou $3$ octets mais comme le caractère suivant est inférieur à $128$, cela signifie qu'il y a une erreur de codage. C'est pareil pour le troisième et le quatrième ($\\texttt{ASCII}$ et erreur)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Manipuler des documents\n",
    "\n",
    "Lorsqu'on consulte un document, que ce soit un fichier texte (code source par exemple) ou une page web, il faut la lire avec le bon encodage. Sinon, les valeurs seront mal interprétées. Exemple ?\n",
    "\n",
    "> Voici un texte encodé en $UTF-8$ :  \n",
    "Martine écrit en Utf-8  \n",
    "Si vous le lisez en latin-1, vous obtiendrez ceci :  \n",
    "Martine Ã©crit en Utf-8  \n",
    "\n",
    "> Réaliser un script qui stocke le string \"Martine écrit en Utf-8\" en Utf-8 puis qui le décode en latin-1. Observez le résultat final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Martine Ã©crit en Utf-8'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mon_encodage = \"Martine écrit en Utf-8\".encode('utf8')\n",
    "mon_encodage.decode('latin_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\xc3\\xa9'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"é\".encode('utf8')  # hexa C3 A9   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Pourquoi ce résultat ? Souvenez-vous qu'$UTF-8$ encode certains caractères, dont les lettres accentuées, sur deux octets ; ici la lettre « é » donne les octets $0xC3$ et $0xA9$. Or, latin-1 encode tous ses caractères sur un octet. Les octets $0xC3$ et $0xA9$ sont donc interprétés séparément, et donnent les caractères « Ã » et « © », respectivement.  \n",
    "Notez que tous les autres caractères sont lus correctement, car ils appartiennent à la base commune $\\texttt{ASCII}$. Vous voyez maintenant l'intérêt de cette compatibilité : même avec un mauvais encodage, le texte reste globalement lisible.\n",
    "\n",
    "Le problème se pose même si tous les caractères font la même taille dans les deux encodages, une même valeur pouvant désigner deux caractères différents d’un encodage à l'autre."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Encodage des fichiers à l'aide de Python  \n",
    "Exemple de script qui va créer un fichier dans un type d'encodage, le fermer, le lire avec le bon encodage puis le relire avec un autre encodage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- CREATION D'UN FICHIER encodé en  latin_1\n",
      "Pause. Appuyer sur ENTREE\n",
      "-- LECTURE DU FICHIER qu'on suppose encodé en  latin_1\n",
      "DebutNuméro 180 : ´\n",
      "Numéro 181 : µ\n",
      "Numéro 182 : ¶\n",
      "Numéro 183 : ·\n",
      "Numéro 184 : ¸\n",
      "Numéro 185 : ¹\n",
      "Numéro 186 : º\n",
      "Numéro 187 : »\n",
      "Numéro 188 : ¼\n",
      "Numéro 189 : ½\n",
      "Numéro 190 : ¾\n",
      "Fin\n",
      "Pause. Appuyer sur ENTREE\n",
      "-- LECTURE DU FICHIER qu'on suppose encodé en  iso8859_2\n",
      "DebutNuméro 180 : ´\n",
      "Numéro 181 : ľ\n",
      "Numéro 182 : ś\n",
      "Numéro 183 : ˇ\n",
      "Numéro 184 : ¸\n",
      "Numéro 185 : š\n",
      "Numéro 186 : ş\n",
      "Numéro 187 : ť\n",
      "Numéro 188 : ź\n",
      "Numéro 189 : ˝\n",
      "Numéro 190 : ž\n",
      "Fin\n"
     ]
    }
   ],
   "source": [
    "encodage_ecriture = \"latin_1\"\n",
    "encodage_lecture = \"iso8859_2\"\n",
    "\n",
    "#################################\n",
    "# PARTIE 1 CREATION\n",
    "#################################\n",
    "\n",
    "print(\"-- CREATION D'UN FICHIER encodé en \",encodage_ecriture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"w\", encoding=encodage_ecriture)\n",
    "\n",
    "obj_fichier.write(\"Debut\")\n",
    "\n",
    "for i in range (180,191):\n",
    "\n",
    "    if chr(i).isprintable():\n",
    "\n",
    "        obj_fichier.write(\"Numéro \"+str(i)+\" : \"+ chr(i)+\"\\n\")\n",
    "\n",
    "obj_fichier.write(\"Fin\")\n",
    "\n",
    "obj_fichier.close()\n",
    "\n",
    "input(\"Pause. Appuyer sur ENTREE\")\n",
    "\n",
    "#################################\n",
    "# PARTIE 2 LECTURE CORRECTE\n",
    "#################################\n",
    "\n",
    "print(\"-- LECTURE DU FICHIER qu'on suppose encodé en \", encodage_ecriture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"r\", encoding=encodage_ecriture)\n",
    "\n",
    "print(obj_fichier.read())\n",
    "\n",
    "obj_fichier.close()\n",
    "\n",
    "input(\"Pause. Appuyer sur ENTREE\")\n",
    "\n",
    "#################################\n",
    "# PARTIE 3 LECTURE AVEC UN AUTRE ENCODAGE\n",
    "#################################\n",
    "\n",
    "print(\"-- LECTURE DU FICHIER qu'on suppose encodé en \", encodage_lecture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"r\", encoding=encodage_lecture)\n",
    "\n",
    "print(obj_fichier.read())\n",
    "\n",
    "obj_fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> Lors de l'ouverture en $UTF-8$ d'un fichier encodé par un encode $1$ octet, lors du décodage, $\\texttt{Python}$ va déclarer une erreur car les caractères UNICODE supérieurs à $127$ sont codés sur plusieurs octets mais avec des valeurs particulières : ces octets codent également le nombre d'octets à lire pour ce caractère par exemple.  \n",
    "Utiliser $UTF-8$ en lecture pour le constater."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "UnicodeDecodeError",
     "evalue": "'utf-8' codec can't decode byte 0x9d in position 0: invalid start byte",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m                        Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-141f12bc2a9d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mcodage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mchr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m157\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'latin_1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mcodage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'utf8'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m: 'utf-8' codec can't decode byte 0x9d in position 0: invalid start byte"
     ]
    }
   ],
   "source": [
    "codage = chr(157).encode('latin_1')\n",
    "codage.decode('utf8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Pour **remplacer les caractères non chiffrables** (hors table d'encodage) ou indéchiffrables, il faut utiliser par exemple $\\texttt{encode('utf-8', 'replace')}$ si vous encodez, ou $\\texttt{decode('utf-8', 'replace')}$ si vous décodez. Cela remplace les erreurs d'encodage par le caractère �.  \n",
    "Cela permet de ne pas tenir compte des erreurs détectées lors de l'encodage comme lors du décodage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'�'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codage.decode('utf8','replace')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- CREATION D'UN FICHIER encodé en  latin_1\n",
      "Pause. Appuyer sur ENTREE\n",
      "-- LECTURE DU FICHIER qu'on suppose encodé en  latin_1\n",
      "DebutNuméro 180 : ´\n",
      "Numéro 181 : µ\n",
      "Numéro 182 : ¶\n",
      "Numéro 183 : ·\n",
      "Numéro 184 : ¸\n",
      "Numéro 185 : ¹\n",
      "Numéro 186 : º\n",
      "Numéro 187 : »\n",
      "Numéro 188 : ¼\n",
      "Numéro 189 : ½\n",
      "Numéro 190 : ¾\n",
      "Fin\n",
      "Pause. Appuyer sur ENTREE\n",
      "-- LECTURE DU FICHIER qu'on suppose encodé en  utf8\n"
     ]
    },
    {
     "ename": "UnicodeDecodeError",
     "evalue": "'utf-8' codec can't decode byte 0xe9 in position 8: invalid continuation byte",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m                        Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-d2f7a721a5a0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[0mobj_fichier\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"mon_test.txt\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"r\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mencodage_lecture\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 48\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj_fichier\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     49\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0mobj_fichier\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Anaconda3/lib/python3.7/codecs.py\u001b[0m in \u001b[0;36mdecode\u001b[0;34m(self, input, final)\u001b[0m\n\u001b[1;32m    320\u001b[0m         \u001b[0;31m# decode input (taking the buffer into account)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    321\u001b[0m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuffer\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 322\u001b[0;31m         \u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconsumed\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_buffer_decode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfinal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    323\u001b[0m         \u001b[0;31m# keep undecoded input until the next call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    324\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuffer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconsumed\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m: 'utf-8' codec can't decode byte 0xe9 in position 8: invalid continuation byte"
     ]
    }
   ],
   "source": [
    "encodage_ecriture = \"latin_1\"\n",
    "encodage_lecture = \"utf8\"\n",
    "\n",
    "#################################\n",
    "# PARTIE 1 CREATION\n",
    "#################################\n",
    "\n",
    "print(\"-- CREATION D'UN FICHIER encodé en \",encodage_ecriture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"w\", encoding=encodage_ecriture)\n",
    "\n",
    "obj_fichier.write(\"Debut\")\n",
    "\n",
    "for i in range (180,191):\n",
    "\n",
    "    if chr(i).isprintable():\n",
    "\n",
    "        obj_fichier.write(\"Numéro \"+str(i)+\" : \"+ chr(i)+\"\\n\")\n",
    "\n",
    "obj_fichier.write(\"Fin\")\n",
    "\n",
    "obj_fichier.close()\n",
    "\n",
    "input(\"Pause. Appuyer sur ENTREE\")\n",
    "\n",
    "#################################\n",
    "# PARTIE 2 LECTURE CORRECTE\n",
    "#################################\n",
    "\n",
    "print(\"-- LECTURE DU FICHIER qu'on suppose encodé en \", encodage_ecriture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"r\", encoding=encodage_ecriture)\n",
    "\n",
    "print(obj_fichier.read())\n",
    "\n",
    "obj_fichier.close()\n",
    "\n",
    "input(\"Pause. Appuyer sur ENTREE\")\n",
    "\n",
    "#################################\n",
    "# PARTIE 3 LECTURE AVEC UN AUTRE ENCODAGE\n",
    "#################################\n",
    "\n",
    "print(\"-- LECTURE DU FICHIER qu'on suppose encodé en \", encodage_lecture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"r\", encoding=encodage_lecture)\n",
    "\n",
    "print(obj_fichier.read())\n",
    "\n",
    "obj_fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> Lors de l'ouverture en *latin_1* d'un fichier encodé en $UTF-8$, on retrouve le fait que certains caractères $UTF-8$ codés sur deux octets vont provoquer l'apparition de deux caractères à l'écran si on pense que le fichier texte est encodé dans un format $1$ octet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ã©'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"é\".encode('utf8').decode('latin_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- CREATION D'UN FICHIER encodé en  utf8\n",
      "Pause. Appuyer sur ENTREE\n",
      "-- LECTURE DU FICHIER qu'on suppose encodé en  utf8\n",
      "DebutNuméro 180 : ´\n",
      "Numéro 181 : µ\n",
      "Numéro 182 : ¶\n",
      "Numéro 183 : ·\n",
      "Numéro 184 : ¸\n",
      "Numéro 185 : ¹\n",
      "Numéro 186 : º\n",
      "Numéro 187 : »\n",
      "Numéro 188 : ¼\n",
      "Numéro 189 : ½\n",
      "Numéro 190 : ¾\n",
      "Fin\n",
      "Pause. Appuyer sur ENTREE\n",
      "-- LECTURE DU FICHIER qu'on suppose encodé en  latin_1\n",
      "DebutNumÃ©ro 180 : Â´\n",
      "NumÃ©ro 181 : Âµ\n",
      "NumÃ©ro 182 : Â¶\n",
      "NumÃ©ro 183 : Â·\n",
      "NumÃ©ro 184 : Â¸\n",
      "NumÃ©ro 185 : Â¹\n",
      "NumÃ©ro 186 : Âº\n",
      "NumÃ©ro 187 : Â»\n",
      "NumÃ©ro 188 : Â¼\n",
      "NumÃ©ro 189 : Â½\n",
      "NumÃ©ro 190 : Â¾\n",
      "Fin\n"
     ]
    }
   ],
   "source": [
    "encodage_ecriture = \"utf8\"\n",
    "encodage_lecture = \"latin_1\"\n",
    "\n",
    "#################################\n",
    "# PARTIE 1 CREATION\n",
    "#################################\n",
    "\n",
    "print(\"-- CREATION D'UN FICHIER encodé en \",encodage_ecriture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"w\", encoding=encodage_ecriture)\n",
    "\n",
    "obj_fichier.write(\"Debut\")\n",
    "\n",
    "for i in range (180,191):\n",
    "\n",
    "    if chr(i).isprintable():\n",
    "\n",
    "        obj_fichier.write(\"Numéro \"+str(i)+\" : \"+ chr(i)+\"\\n\")\n",
    "\n",
    "obj_fichier.write(\"Fin\")\n",
    "\n",
    "obj_fichier.close()\n",
    "\n",
    "input(\"Pause. Appuyer sur ENTREE\")\n",
    "\n",
    "#################################\n",
    "# PARTIE 2 LECTURE CORRECTE\n",
    "#################################\n",
    "\n",
    "print(\"-- LECTURE DU FICHIER qu'on suppose encodé en \", encodage_ecriture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"r\", encoding=encodage_ecriture)\n",
    "\n",
    "print(obj_fichier.read())\n",
    "\n",
    "obj_fichier.close()\n",
    "\n",
    "input(\"Pause. Appuyer sur ENTREE\")\n",
    "\n",
    "#################################\n",
    "# PARTIE 3 LECTURE AVEC UN AUTRE ENCODAGE\n",
    "#################################\n",
    "\n",
    "print(\"-- LECTURE DU FICHIER qu'on suppose encodé en \", encodage_lecture)\n",
    "\n",
    "obj_fichier = open(\"mon_test.txt\",\"r\", encoding=encodage_lecture)\n",
    "\n",
    "print(obj_fichier.read())\n",
    "\n",
    "obj_fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Mini-projet - À rendre par groupe.  \n",
    " * Traiter les activités proposées ici   \n",
    " <a href=\"http://info.blaisepascal.fr/isn/isn-representation-de-linformation/isn-codage-numerique-du-texte\" target=\"_blank\">http://info.blaisepascal.fr/isn/isn-representation-de-linformation/isn-codage-numerique-du-texte</a>   \n",
    " source : <a href=\"http://eduscol.education.fr/cid60671/ressources-isn.html\" target=\"_blank\">http://eduscol.education.fr/cid60671/ressources-isn.htm</a>  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conclusion  \n",
    "\n",
    "Pour représenter des caractères dans un ordinateur, il suffit de <a href=\"http://sametmax.com/lencoding-en-python-une-bonne-fois-pour-toute/\" target=\"_blank\">choisir un codage</a> qui utilise des nombres pour représenter des caractères. Le système de codage le plus utilisé est le codage $\\texttt{ASCII}$, sur $7$ bits, qui ne peut coder que les caractères américains. Le codage $iso8859$ étend l'$\\texttt{ASCII}$ sur $8$ bits, pour coder\n",
    "de nouveaux caractères ; ainsi l' $iso8859-1$ , appelé aussi $iso-latin-1$ , code les caractères utilisés en europe occidentale.  \n",
    "Un autre système de codage utilise en combinaison, Unicode, un code sur $16$ bits pour représenter les informations dans les programmes et $UTF$, un code de longueur variable, pour transmettre les informations.  \n",
    "Entre $iso8859$ et $UTF-8$ , préférez $UTF-8$ .\n",
    "\n",
    "Ce qu'il faut savoir faire à l'issue de cette partie :  \n",
    "* Identifier l'<a href=\"http://sdz.tdct.org/sdz/comprendre-les-encodages.html\" target=\"_blank\">intérêt des différents systèmes d'encodage</a>.\n",
    "* Convertir un fichier texte dans différents formats d'encodage."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Diaporama",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "rise": {
   "autolaunch": true,
   "enable_chalkboard": true,
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}