ISN-Python3-Chaine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 3 : Le BN pour le traitement des chaines alphanumériques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Caractères ASCII :\n",
    "En informatique tout est numérique..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "chr(0b01000001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "chr(0x41)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ord('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bin(65)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chaine de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine = \"Joyeux Anniversaire\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quel est le type de cette variable ? - fonction type ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type (une_chaine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quelle est la longueur de cette chaîne de caractères ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "len (une_chaine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|J|o|y|e|u|x| |A|n|n|i|v|e|r|s|a|i|r|e| \n",
    "|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|--|\n",
    "|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les indices dans la chaîne de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine[7]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "J|o|y|e|u|x| |A|n|n|i|v|e|r|s|a|i|r|e \n",
    "-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-\n",
    "0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18\n",
    "-19|-18|-17|-16|-15|-14|-13|-12|-11|-10|-9|-8|-7|-6|-5|-4|-3|-2|-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\";>**EN PROGRAMMATION, ON COMMENCE A COMPTER A PARTIR DE ZERO !!!!!!!**</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine.index(\"J\") # donne l'indice du premier J majuscule rencontré dans la chaîne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine.index(\"e\") # donne l'indice du premier e minuscule rencontré dans la chaîne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine[-1] # la première valeur en commençant par la fin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine[-19] # == une_chaine[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine [-len(une_chaine)] # Vous avez compris ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Le slicing\n",
    "\n",
    "Le **_slicing_** est une méthode applicable à tous les objets de type liste ordonnée (liste ou chaîne de caractère mais pas aux dictionnaires). ll s'agit d'un \"découpage en tranches\" des éléments d'une liste de manière à récupérer des objets respectant cette découpe.\n",
    "\n",
    "Pour cela, nous devrons spécifier l'indice de l'élément de départ, l'indice de l'élément d'arrivée (qui ne sera pas compris dans la plage) et le pas de déplacement. Pour une variable v donnée, l'écriture se fera en utilisant la notation entre crochets et en séparant chacun des paramètres par le caractère deux-points: **_v[début:fin:pas]_**. Cette écriture peut se traduire par : les caractères de la variable **_v_** depuis l'indice **_début_** jusqu'à l'indice **_fin_** non compris avec un déplacement de **_pas_** caractère(s).  \n",
    "\n",
    "Pour bien comprendre le fonctionnement du slicing, nous commencerons par l'appliquer aux chaînes de caractères avant de voir les listes et les tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine [1:5] # de l'indice 1 inclus à l'indice 5 exclus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine [2:] # de l'indice 2 inclus jusqu'à la fin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine [:-1] # du début à l'indice -1 exclus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine [::-1] # en partant de la fin et à l'envers vers le début"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine [::2] # afficher tout par pas de 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les indices en pratique avec une boucle while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine = \"Joyeux Anniversaire\"\n",
    "i = 0\n",
    "while i < len (une_chaine):\n",
    "    print (\"A l'indice\", i, \"se trouve la lettre \", une_chaine[i])\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parcours de chaîne avec la boucle for  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine = \"Joyeux Anniversaire\"\n",
    "i = 0\n",
    "for lettre in une_chaine :\n",
    "    print (\"A l'indice\", i, \"se trouve la lettre \", lettre)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Script permettant de distinguer les voyelles, les consonnes et les espaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine = \"Joyeux Anniversaire\"\n",
    "for lettre in une_chaine :\n",
    "    if lettre in \"aeiouyAEIOUY\":\n",
    "        print (lettre, \"est une voyelle\")\n",
    "    elif lettre == \" \":\n",
    "        print (lettre, \"est un espace\")\n",
    "    else :\n",
    "        print (lettre, \"est une consonne\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Script permettant de compter les voyelles, les consonnes et les espaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine = \"Joyeux Anniversaire\"\n",
    "compteur_voyelles = 0\n",
    "compteur_consonnes = 0\n",
    "compteur_espaces = 0\n",
    "for lettre in une_chaine :\n",
    "    if lettre in \"aeiouyAEIOUY\":\n",
    "        print (lettre, \"est une voyelle\")\n",
    "        compteur_voyelles = compteur_voyelles + 1\n",
    "    elif lettre == \" \":\n",
    "        print (lettre, \"est un espace\")\n",
    "        compteur_espaces = compteur_espaces + 1\n",
    "    else :\n",
    "        print (lettre, \"est une consonne\")\n",
    "        compteur_consonnes = compteur_consonnes + 1\n",
    "print (\"Il y a, dans cette phrase,\",compteur_voyelles,\"voyelle(s),\"\\\n",
    "       ,compteur_consonnes,\"consonne(s),\",compteur_espaces,\"espace(s)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les méthodes de la classe str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "help (\"str\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine = \"HELLO\"\n",
    "print (ma_chaine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine.lower ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine_2 = \"hello\"\n",
    "print (ma_chaine_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine_2.upper ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine_2.capitalize ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine_3 = \"   HELLO   \"\n",
    "print (ma_chaine_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine_3.strip ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine_3.strip ().center (40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe de nombreuse méthode pour les chaînes de caratères.\n",
    "tapez alors juste ***ma_chaine. (n'oubliez pas le point) puis appuyez sur la tabulation***, vous devez voir toutes les méthodes.\n",
    "\n",
    "|a | b | c | d |\n",
    "| :-----------: | :----------:|:-----------:|:-----------:|\n",
    "|x.capitalize | x.isalnum      |    x.join      |    x.rsplit |\n",
    "|x.casefold   |   x.isalpha     |  x.ljust        | x.rstrip |\n",
    "|x.center     |   x.isdecimal   |  x.lower       |  x.split|\n",
    "|x.count      |   x.isdigit     |  x.lstrip      |  x.splitlines |\n",
    "|x.encode     |   x.isidentifier |  x.maketrans   |  x.startswith |\n",
    "|x.endswith   |   x.islower     |  x.partition   |  x.strip |\n",
    "|x.expandtabs |   x.isnumeric   |  x.replace     |  x.swapcase|\n",
    "|x.find       |   x.isprintable |  x.rfind       |  x.title|\n",
    "|x.format     |   x.isspace     |  x.rindex      |  x.translate|\n",
    "|x.format_map |   x.istitle     |  x.rjust       |  x.upper|\n",
    "|x.index      |   x.isupper     |  x.rpartition  |  x.zfill|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ma_chaine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formater une chaîne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "langage = \"Python\"\n",
    "prenom = input(\"Saisir votre prénom : \") \n",
    "nom = input(\"Saisir votre nom : \")\n",
    "print (\"{} est mon langage de programmation préféré\".format(langage))\n",
    "print (\"Signé : {} {}\".format(prenom,nom))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (\"{0} {1} {2}\".format(langage,prenom,nom))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "age = input(\"Saisir votre age : \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (\"{0} {2} {3} {1}\".format(langage,age,prenom,nom.upper()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Une chaîne de caractères est immutable (non modifiable) !!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine = (\"paris\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine[0] = \"m\" # ne fonctionne évidemment pas ! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine_2 = \"m\" + une_chaine [1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "une_chaine_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lecture et écriture dans un fichier\n",
    "Un fichier stocke des informations sur un support physique (disque dur, clé USB, CD, DVD, carte mémoire SD...).\n",
    "\n",
    "Ouvrir un fichier consiste à le charger dans la mémoire vive (RAM) de l'ordinateur (c'est une mémoire volatile : elle s'efface quand on éteint l'ordinateur).\n",
    "Enregistrer un fichier consiste à l'écrire sur un support physique de stockage (l'information est alors conservée de manière permanente).\n",
    "\n",
    "Il existe deux types de fichiers :\n",
    "\n",
    "Les fichiers textes : l'information est stockée sous forme de caractères lisibles par un éditeur de texte (principalement des lettres et des chiffres).\n",
    "Les fichiers binaires : l'information est stockée en binaire (une suite d'octets dont la valeur est comprise entre 0x00 et 0xFF).\n",
    "\n",
    "### Ecriture dans un fichier\n",
    "\n",
    "L'écriture dans un fichier se fait avec la fonction **``open()``** en mode écriture :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "NomFichier = 'test.txt'\n",
    "\n",
    "# création et ouverture du fichier test.txt en mode write 'w' (écriture)\n",
    "# si le fichier test.txt existe déjà, il est écrasé\n",
    "Fichier = open(NomFichier,'w', encoding='utf8') # instanciation de l'objet Fichier de la classe file\n",
    "# Fichier = open(NomFichier,'w')\n",
    "\n",
    "# écriture dans le fichier avec la méthode write()\n",
    "Fichier.write('Bonjour à tous !')\n",
    "\n",
    "# fermeture du fichier avec la méthode close()\n",
    "Fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le fichier ``test.txt`` est créé dans le répertoire courant (on peut aussi choisir un autre emplacement en spécifiant le chemin relatif depuis l'enplacement de ce bloc-note ``'Mon dossier/test.txt'``).\n",
    "\n",
    "Vous pouvez vérifier son contenu en l'ouvrant en local avec un éditeur de texte (ou même avec un logiciel de traitement de texte)...\n",
    "\n",
    "Dans l'environnement jupyter, il suffit de double-cliquer sur le fichier ``test.txt`` créé pour le visualiser dans le navigateur.\n",
    "![image fichier texte crée](https://ericecmorlaix.github.io/img/fichierTexte.png \"Fichier du texte sauvegardée\")\n",
    "\n",
    "> <u>Remarques sur le codage des caractères :</u>  \n",
    "Pour Python, le codage par défaut des caractères est ``'cp1252'`` sous Windows, et ``'utf-8'`` sous GNU/Linux.  \n",
    "L'environnement jupyter ne supporte que l'affichage des fichiers textes codés en ``'utf-8'``.  \n",
    "Le paramètre `encoding='utf8'` permet donc de forcer l'encodage du fichier texte en ``'utf-8'`` quelque soit l'OS.  \n",
    "Expérimenter la cellule suivante avec et sans le paramètre `encoding='utf8'` dans la cellule précédente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Fichier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si l'on compare dans un éditeur hexadécimal comme https://www.onlinehexeditor.com/ ou https://hexed.it/ les deux versions du fichier ``test.txt`` créé soit en ``'cp1252'`` ou en ``'utf-8'``, on constate un écart d'un octet : \n",
    "\n",
    "* Avec le codage cp1252, le fichier fait 16 octets :\n",
    "![image Code hexadécimal du texte sauvegardée en cp1252](https://ericecmorlaix.github.io/img/cp1252.png \"Code hexadécimal du texte sauvegardée en cp1252\")\n",
    "\n",
    "\n",
    "* Avec le codage UTF-8, le fichier fait 17 octets !\n",
    "![image Code hexadécimal du texte sauvegardée en utf-8](https://ericecmorlaix.github.io/img/utf-8.png \"Code hexadécimal du texte sauvegardée en utf-8\")\n",
    "\n",
    "La différence est due au codage du caractère accentué à :\n",
    "1 octet (``0xE0``) pour le codage ``'cp1252'`` et 2 octets (``0xC3 0xA0``) pour le codage ``'utf-8'``.  \n",
    "Les autres caractères ont un codage commun sur un octet (codage ``ASCII``).\n",
    "\n",
    "Un bon article sur l'encoding en Python : http://sametmax.com/lencoding-en-python-une-bonne-fois-pour-toute/\n",
    "\n",
    "- https://www.supinfo.com/articles/single/5621-manipuler-contenu-fichiers-aide-hexadecimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ajout dans un fichier :\n",
    "Pour écrire à la fin d'un fichier, on utilise la fonction **``open()``** en mode ajout.\n",
    "\n",
    "Repartons du fichier précédent :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ouverture du fichier test.txt en mode append 'a' (ajout)\n",
    "Fichier = open('test.txt','a', encoding='utf8') # instanciation de l'objet Fichier\n",
    "#Fichier = open('test.txt','a')\n",
    "Fichier.write('\\nUne deuxième ligne.\\n')# '\\n' saut de ligne\n",
    "Fichier.write('abc\\tABC\\t123\\n')\t# '\\t' tabulation\n",
    "Fichier.write(str(126.85)+'\\n')\t\t# str() transforme un nombre en chaîne de caractères\n",
    "Fichier.write('\\x31\\x41\\x61\\n')\t\t# écriture de '1Aa' en code ASCII\n",
    "Fichier.write(chr(0x62)+'\\n')\t\t# écriture de 'b' en code ASCII\n",
    "Fichier.write(chr(99))\t\t\t# écriture de 'c' en code ASCII\n",
    "Fichier.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Fichier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%HTML\n",
    "<center>\n",
    "    <iframe src=\"test.txt\"></iframe>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lecture dans un fichier\n",
    "La lecture dans un fichier texte se fait avec la fonction **``open()``** en mode lecture :    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ouverture du fichier test.txt en mode read 'r' (lecture en mode texte)\n",
    "Fichier = open('test.txt','r')      # instanciation de l'objet Fichier de la classe file\n",
    "# lecture dans le fichier avec la méthode read()\n",
    "chaine = Fichier.read()\n",
    "# affichage du contenu du fichier\n",
    "print('Contenu du fichier :\\n' + chaine)\n",
    "# fermeture du fichier avec la méthode close()\n",
    "Fichier.close() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lecture en mode binaire\n",
    "En mode texte, un fichier est lu caractère par caractère.\n",
    "En mode binaire, un fichier est lu octet par octet : c'est un peu différent !\n",
    "\n",
    "Par exemple, si on veut la taille d'un fichier, il faut utiliser la lecture en mode binaire 'rb' (read binary) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ouverture du fichier test.txt en mode read binary 'rb' (lecture en mode binaire)\n",
    "Fichier = open('test.txt','rb')\n",
    "data = Fichier.read()\n",
    "# affichage de la taille du fichier\n",
    "print('Taille du fichier :',len(data),'octets')\n",
    "# affichage du contenu (en hexadécimal)\n",
    "import binascii\n",
    "print(binascii.hexlify(data))\n",
    "# fermeture du fichier avec la méthode close()\n",
    "Fichier.close() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Applications :\n",
    "\n",
    "### Cryptage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Source :\n",
    "* [Fabrice DUMONT](http://python.lecoinduprogrammeur.org/category/python-decouvertes/) \n",
    "* http://fsincere.free.fr/isn/python/cours_python_fichier.php\n",
    "* http://flot.sillages.info/?portfolio=flot-programmation-pour-debutants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}