NSI1_e13a_caracteres-v8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "    <div style=\"display:flex;\">\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "        <div style=\"display:inline;width:15%;\">NSI1</div>\n",
    "        <div style=\"display:inline;width:15%;\">e13a</div>\n",
    "        <div style=\"display:inline;width:70%;text-align:right;\"><b>Représentation d’un texte en machine</b></div>\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;background-color:#EEE\">\n",
    "        <p style=\"width:100%;text-align:center;\">Différents systèmes d’encodage</p>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;\">\n",
    "        <p style=\"width:100%;text-align:center;\">Codage d'un texte</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-success\">\n",
    "    \n",
    "**Objectifs de la séquence:**\n",
    "    \n",
    "- Convertir un fichier texte dans différents formats d’encodage.\n",
    "- Exemples des encodages ASCII, ISO-8859-1, UTF-8\n",
    "- Caractères et chaîne de caractères\n",
    "</div>\n",
    "\n",
    "<div class = \"alert alert-info\">\n",
    "    \n",
    "**Activités**\n",
    "    \n",
    "- Notion de caractère, codage ASCII\n",
    "- Parcours d'une chaîne de caractères\n",
    "- ISO-8859-1\n",
    "- Codage et décodage César d'une chaîne de caractères\n",
    "- Unicode\n",
    "- UTF-8\n",
    "</div>\n",
    "\n",
    "<h3>ASCII - American Standard Code for Information Interchange</h3>\n",
    "\n",
    "Il s'agit d'un encodage de caractères (1963).\n",
    "ASCII est un code de <b>7 bits</b> définissant <b>128</b> caractères (27). L’encodage se compose de 33 caractères non imprimables et 95 caractères imprimables et comprend des lettres, des signes de ponctuation, des chiffres ainsi que des caractères de contrôle Unicode.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![table_ASCII](https://raw.githubusercontent.com/ebuonocore/Cours_NSI1_13_Caracteres/master/img/table_ASCII_wiki.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le code héxadécimal ASCII se lit sur cette table en additionnant les nombres sur les axes.  \n",
    "Ces nombres ont une représentation hexadécimale.\n",
    "\n",
    "Par exemple: Code héxadécimal du caractère 'A' = 0x40 + 0x01 = 0x41.  \n",
    "Ce qui correspond à une valeur décimale de 65\n",
    "\n",
    "Code héxadécimal du caractère 'K' = 0x40 + 0x0B = 0x4B.  \n",
    "Ce qui correspond à une valeur décimale de 75"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La valeur décimale du code ASCII d'un caractère peut être rerouvé avec l'instruction <code>ord()</code>  \n",
    "Source: https://docs.python.org/fr/3/library/functions.html#ord\n",
    "\n",
    "Exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction <coode>ord()</code> renvoie le <b>\"point de code\"</b> du caractère. C'est à dire l'entier qui représente ce caractère.\n",
    "\n",
    "Pour simplifier la lecture du tableau, il est préférable de travailler sur les valeurs hexadécimales ou binaires.\n",
    "\n",
    "Les instructions <code>hex()</code> et <code>bin()</code> permettent de convertir la valeur décimale par défaut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hex(ord('A'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin(ord('A'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A l'inverse l'instruction <code>chr()</code> permet de retrouver le caractère qui correspond à un code:  \n",
    "Source: https://docs.python.org/fr/3/library/functions.html#chr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(65)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(0x41)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(49)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(0x31)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut donc traduire une chaîne de caractères en code ASCII.\n",
    "\n",
    "Par exemple,<b>'NSI'</b> sera la succession des codes ASCII <span style=\"color:green\">0x4e 0x53 0x49</span> (en hexadécimal) ou <span style=\"color:green\">78 83 73</span> en valeurs décimales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>A vous de jouer</h3>\n",
    "Q1. Donnez le code ASCII <b>'BONJOUR'</b> en héxadécimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hex(ord('B'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Quelle séquence est codée par <span style=\"color:green\">0x4d 0x30 0x6c 0x49 0x20 0x52</span> ?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(0x4d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Parcours d'une chaîne de caractères</h3>\n",
    "L'instruction <code>len()</code> permet de récupérer la longueur d'une chaîne de caractères."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mot = \"Ceci\"\n",
    "len(mot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mot[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>mot[i]</code> permet de récupérer le ième caractère de la chaîne.\n",
    "\n",
    "Parcours par <u>indice</u>:\n",
    "Le code suivant permet de parcourir l'ensemble des caractères qui constituent une chaîne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(mot)):\n",
    "    print(mot[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parcours par élément:\n",
    "Python permet aussi de parcourir une structure par <u>élément</u>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for lettre in mot:\n",
    "    print(lettre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Dans le premier cas, quel est le type de la variable <code>i</code> ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Dans le second, quel est le type de la variable <code>lettre</code> ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Modifiez le code suivant (à  l'endroit marqué par '...') pour qu'il affiche le code ASCII (en hexadécimal) de chacun des caractères de la variable <code>chaine</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine = \"Ceci est une chaîne de caractères\"\n",
    "for lettre in chaine:\n",
    "    print(..., end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Quel est l'utilité de <code>end=\" \"</code> dans l'instruction <code>print()</code> ?(Supprimez le pour voir la différence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Donnez 3 exemples de caractères qui ne sont pas représentés dans le code ASCII mais qui sont nécessaires dans la langue française."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une autre norme permet de représenter un plus grand nombre de caractère:\n",
    "La norme <b>ISO-8859-1</b> (souvent appelée <b>Latin-1</b>) est codée sur <b>8 bits</b>.\n",
    "Elle peut être vue comme une extension du jeu de caractères ASCII (codé sur 7 bits).\n",
    "\n",
    "Ce codage a été validé pour une utilisation sur Internet par L’IANA (Internet Assigned Numbers Authority)\n",
    "![table_ISO_8859-1](https://raw.githubusercontent.com/ebuonocore/Cours_NSI1_13_Caracteres/master/img/table_ISO_8859-1_w.png \"Table ISO 8859-1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le programme suivant permet d'effectuer un codage César d'une chaîne de caractères.\n",
    "\n",
    "![schema_fonctionnement_code_Cesar](https://raw.githubusercontent.com/ebuonocore/Cours_NSI1_13_Caracteres/master/img/schema_fonctionnement_code_Cesar.png \"Schéma fonctionnement César\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Codage César d'une chaîne de caractères.\n",
    "\"\"\"\n",
    "\n",
    "def affiche_code_Latin_1_chaine(chaine):\n",
    "    \"\"\"str ---> Nonetype\n",
    "    chaine doit être une chaîne de caractères ISO-8859-1.\n",
    "    La fonction affiche les codes héxadécimaux des caractères de la chaîne.\n",
    "    \"\"\"\n",
    "    for lettre in chaine:\n",
    "        print(hex(ord(lettre)), end=\" \")\n",
    "    print(\"\") # Retourne à la ligne en fin de message.\n",
    "        \n",
    "def decale_code_Latin_1_chaine(chaine,decalage):\n",
    "    \"\"\"str ---> str\n",
    "    chaine doit être une chaîne de caractères ISO-8859-1.\n",
    "    decalage est un entier.\n",
    "    La fonction affiche les codes héxadécimaux des caractères de la chaîne.\n",
    "    \"\"\"\n",
    "    chaine_codee = \"\" # Initialise la chaîne de caractère à construire\n",
    "    for lettre in chaine:\n",
    "        chaine_codee += chr(ord(lettre) + decalage) # Ajoute le caractère codé (concaténation)\n",
    "    return chaine_codee\n",
    "\n",
    "# Corps principal\n",
    "chaine_initiale = \"Message sans code\"\n",
    "print(\"La chaîne avant codage:\",chaine_initiale)\n",
    "affiche_code_Latin_1_chaine(chaine_initiale)\n",
    "chaine_modifiee = decale_code_Latin_1_chaine(chaine_initiale,1)\n",
    "affiche_code_Latin_1_chaine(chaine_modifiee)\n",
    "print(\"La chaîne codée:\",chaine_modifiee)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Quelle transformation a été effectuée sur la chaîne pour la coder?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifiez le programme (...) ci-dessous pour inverrser l'opération de codage:\n",
    "- Mettre la chaîne codée *'Nfttbhf!tbot!dpef'* à la place de la chaine_initiale.\n",
    "- Changer le paramètre lors de l'appel de decale_code_latin_1_chaine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Corps principale\n",
    "chaine_initiale = \"...\"\n",
    "print(\"La chaîne avant codage:\",chaine_initiale)\n",
    "affiche_code_Latin_1_chaine(chaine_initiale)\n",
    "chaine_modifiee = decale_code_Latin_1_chaine(chaine_initiale,...)\n",
    "affiche_code_Latin_1_chaine(chaine_modifiee)\n",
    "print(\"La chaîne codée:\",chaine_modifiee)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Quel paramètre de décalage avez-vous mis lors de l'appel de decale_code_Latin_1_chaine() ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Question bonus</u>: Lors de l'appel de la fonction <i>decale_code_Latin_1_chaine()</i> le code du caractère codée est calculé ainsi: <code>chr(ord(lettre) + decalage)</code>\n",
    "\n",
    "Or, ce calcul peut renvoyer une erreur... Donner un exemple de <code>lettre</code> et de <code>decalage</code> qui poserait problème.\n",
    "Quelle précaution faudrait-il prendre?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. <u>Défi</u>: Le code ci-dessous a été crypté en code César.\n",
    "\n",
    "<span style=\"color:red\">Mo*myno*}o*mk}}o*pkmsvowoxv</span>\n",
    "\n",
    "Trouver le clef de décodage et le message initial.\n",
    "\n",
    "Pistes:\n",
    "- Dans le corps principal faites une boucle qui permette de parcourir tous les décalages de -20 à +20 par exemple\n",
    "- Dans la boucle traduisez le message avec les différentes valeurs de <i>decalage</i> obtenu\n",
    "- Affichez les messages décalés\n",
    "\n",
    "Vous pouvez faire voter programme dans la cellule ci-dessous ou dans IDE(Spyder, Thonny...). Dans ce dernier cas, n'oubliez pas de copier les fonctions définies plus haut: affiche_code_Latin_1_chaine() et decale_code_Latin_1_chaine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "La norme <b>ISO-8859-1</b> (ou Latin-1) ne permet pas non plus de coder l’ensemble des caractères du « répertoire universel de caractères codés ».\n",
    "\n",
    "D'où la définition du système <span style=\"color:green\">Unicode</span>.\n",
    "\n",
    "L'<span style=\"color:green\">Unicode</span> est un standard informatique donnant à tout caractère de n'importe quel système d'écriture un nom et un identifiant numérique (<b>point de code</b>), et ce de manière unifiée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bonjour_japonais = 'もしもし'\n",
    "print(\"Bonjour en japonais : \" , bonjour_japonais)\n",
    "print(\"Le premier caractère : \" , bonjour_japonais[0]) # Affiche le premier caractère de la chaine (indice 0)\n",
    "print(\"Son point de code : \" , ord(bonjour_japonais[0])) # Affiche la valeur décimale du \"point de code\" Unicode de 'も'\n",
    "print(\"Le point de code en hexadécimal : \" , hex(ord(bonjour_japonais[0]))) # Affiche sa valeur hexadécimale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. <u>Défi</u>: Listez tous les caractères dont les points de code vont de 9812 à 9823 (valeurs décimales)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boucle bornée: indice de 9812 à 9823\n",
    "\n",
    "    # Affichage du caractère de point de code 'indice'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici 3 façons d'afficher le caractère 'Δ' en connaissant son point de code.\n",
    "\n",
    "Valeur décimale du point de code = 916\n",
    "\n",
    "Valeur hexadécimale du point de code = 0x394"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(chr(0x394)) \n",
    "print(\"\\U00000394\") # Version 4 octets (32 bits)\n",
    "print(\"\\u0394\")  # Ici, la version 2 octets (soit 16 bits) est suffisante avec le u minuscule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Donnez la valeur hexadécimale du point de code du caractère suivant: ☃"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La mise en oeuvre d'Unicode se fait via le système de codage <span style=\"color:green\">UTF-8</span>\n",
    "\n",
    "l'UTF-8 code les caractères <span style=\"color:green\">Unicode</span> sous forme de séquences de <u><b> un à quatre octet</u></b>.\n",
    "    \n",
    "UTF-8 est rétro-compatible avec le standard ASCII: Un texte en US-ASCII peut être codé identiquement en UTF-8.\n",
    "\n",
    "La méthode <code>str.encode('utf8')</code> permet de retrouver le codage UTF-8 de <code>str</code>.  \n",
    "Par exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'♕'.encode('utf8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce caractère est codé sur 3 octets (b ici signifie Byte et non bit): 0xe2, 0x99 et 0x95. \n",
    "\n",
    "Q13. Pour les caractères suivants <span style=\"color:red\">☃</span>,<span style=\"color:red\">€</span>, <span style=\"color:red\">é</span> et <span style=\"color:red\">m</span>, trouvez leur point de code et leur codage en UTF-8\n",
    "\n",
    "Q14. Sur combien d'octets sont codés ces caractères en UTF-8?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Donnez la valeur binaire de ces octets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour aller plus loin sur les chaînes de caractères et les méthodes de la classe <code>str</code>:\n",
    "http://www.xavierdupre.fr/app/teachpyx/helpsphinx/c_lang/types.html#chaine-de-caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}