TP5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP5 Les chaînes de caractères, les fichiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Caractères"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les fonctions Python `ord` et `chr` permettent de passer d'un  caractère à sa représentation numérique, et réciproquement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('z')-ord('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q1** Quelle est le numéro du caractère @ ? Celui de 𝄞 ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(97)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(0x41)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q2** Quel est le numéro du caractère Z en décimal ? Et en hexadécimal ?\n",
    "\n",
    "**Q3** Et pour le caractère $\\alpha$ ? Indication : chercher autour de `0xcebe`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depuis la version 3 de Python, les caractères sont encodés en utf8, ce qui permet d'avoir accès aux accents, mais aussi aux alphabets et caractères du monde entier.\n",
    "Cependant pour d'autres logiciels, en particulier les navigateurs, l'existence de plusieurs encodages possibles reste parfoir un problème."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chr(0x2600)+chr(0x2601)+chr(0x2614)+chr(0x2603)+chr(0x26a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "neko=chr(0x307E)+chr(0x306D)+chr(0x304D)+chr(0x306D)+chr(0x3053)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "neko"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q4** Donner une boucle permettant d'afficher tous les hiragana."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les chaînes de caractères sont itérables avec `for in :`, comme les listes et les tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maneki='招き猫'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in maneki:\n",
    "    print(ord(k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in maneki:\n",
    "    print(hex(ord(k)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q5** Donner une boucle permettant d'afficher tous les caractères ASCII imprimables, du numéro 32 inclus au numéro 127 inclus. Dans `print`, utiliser le paramètre optionnel `end=''` afin de tout afficher sur une même ligne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q6** Que contient la variable `ch` une fois qu'on a exécuté le programme ci-dessous ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch=''\n",
    "for k in range(97,123):\n",
    "    ch=ch+chr(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chaînes de caractères et listes\n",
    "Les slices sont utilisables sur les chaînes de caractères comme sur les listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet='abcdefghijklmnopqrstuvwxyz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet[:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet[6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet[::3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q7** L'instruction `alphabet[a:b:c]` renvoie `'dinsx'`. Quelles sont les valeurs de `a`, `b` et `c` ? Donner toutes les possibilités !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q8** Quel est le type de l'objet renvoyé par l'instruction ci-dessous ? Quel est sa longueur ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(alphabet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'-'.join(list('Python'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'-*-'.join(['Errors','should','never','pass','silently'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'-*-'.join(['','Errors','should','never','pass','silently',''])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q9** Que renvoie l'instruction ci-dessous ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'#'.join(['Tous','ces','moments','se','perdront','dans',\"l'oubli\",\n",
    "           'comme','des','larmes','dans','la','pluie'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s='les:mots:sont:séparés:par:un:deux-points'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.split(':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=s.split(':')\n",
    "' '.join(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les fonctions `split` et `join` sont réciproques l'une de l'autre, et permettent de découper une chaîne en morceaux ou de reconstruire une chaîne à partir de ces morceaux."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'opérateur `+` permet de concaténer des chaînes, ce qui est souvent utile en lien avec la fonction `str` qui permet de transformer la plupart des objets python en une représentation sous forme de chaîne de caractères."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=12\n",
    "a='Le carré de '+str(x)+' est '+str(x**2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q10** Que renvoie l'appel `fonctionmystère(10)` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fonctionmystère(n):\n",
    "    s=0\n",
    "    ch=''\n",
    "    for k in range(n):\n",
    "        s=s+k\n",
    "        ch=ch+str(k)\n",
    "    return s,ch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fonctionmystère(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import binascii,base64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://docs.python.org/2/library/binascii.html\"> La documentation officielle du module binascii</a>, et <a href=\"https://docs.python.org/fr/3/library/base64.html#module-base64\"> celle du module base64</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=b'Bonjour les amis !'\n",
    "e=base64.b64encode(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(s),type(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q11** Quelle est la représentation de l'objet `bytes` `s` en `base64` ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://docs.python.org/fr/3/library/stdtypes.html#bytes\">La documentation Python sur les bytes</a>, <a href=\"https://fr.wikipedia.org/wiki/Base64\">l'article wikipedia sur base64</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La représentation d'un texte dans un fichier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python utilise deux types de fichiers, les fichiers textes qui contiennent des caractères, et les fichiers binaires, qui contiennent des bytes. Un caractère peut être codé par plusieurs octets.\n",
    "Pour travailler avec un fichier, on commence par l'ouvrir avec la fonction `open`. Cela signifie qu'on fournit à Python le chemin d'accès et le nom du fichier.\n",
    "Ensuite àon peut lire ou écrire dans le fichier, suivant le mode sous lequel on a ouvert le fichier.\n",
    "Il faut ensuite penser à fermer le fichier, avec la fonction `close`, pour que le fichier soit écrit sur le disque."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier=open('texteJB.txt','w')   #le fichier texte.txt est ouvert en mode écriture 'w'\n",
    "                                  #dans le répertoire courant\n",
    "    \n",
    "# attention, appeler le fichier texteJB si vous vous appelez John Bercow.\n",
    "# penser à mettre vos propres initiales pour éviter que tout le monde écrase le fichier\n",
    "\n",
    "ligne=input()\n",
    "while ligne:                    #une chaîne est considérée True si elle n'est pas vide\n",
    "    fichier.write(ligne+'\\n')   #le caractère '\\n' est un passage à la ligne\n",
    "    ligne=input()\n",
    "    \n",
    "fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le mode `'r'` est le mode lecture. La construction `with as` permet de ne pas avoir à fermer le fichier explicitement, le fichier sera fermé automatiquement à la fin du bloc indenté. Le fichier texte est un itérable : avec `for in` la variable de boucle prendra comme valeur chaque ligne du fichier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('texteJB.txt','r') as f:\n",
    "    for ligne in f:\n",
    "        print(ligne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour afficher le contenu d'un fichier, on peut utiliser une vidange hexadécimale (un hexdump en Anglais). La commande `hd` sert précisément à cela sous un système Unix/Linux. Sous les autres systèmes, moins performants, il faut ajouter un programme extérieur comme par exemple <a href=\"https://mh-nexus.de/en/hxd/\">HxD</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!hd Documents/Curie19/NSI/texte1.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base64.encode('texte1.txt','texte64.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q12** Quelle est la longueur de chacun des deux fichiers `texte1.txt` et `texte64.txt` ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q13** Ecrire une fonction `somme` qui prend une chaîne d'entiers séparés par des `+` et qui calcule la somme (utiliser `split`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def somme(ch):\n",
    "    liste=...\n",
    "    s=0\n",
    "    for k in liste:\n",
    "        s=...\n",
    "    return \n",
    "\n",
    "assert(somme('12+23+35')==70)\n",
    "assert(somme('1+2+3+4+5+6+7+8+9+10')==55)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q14** Ecrire une fonction `ADN` qui vérifie qu'une chaîne correspond au code génétique formé des quatre lettres ATCG."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ADN(s):\n",
    "    for k in s:\n",
    "        if :\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q15** Ecrire une fonction `complément` qui prend une chaîne représentant un brin d'ADN et qui renvoie une chaîne représentant le brin complémentaire : A, T, C et G sont complémentaires respectivement de T, A, G et C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q16** Ecrire une fonction `prefixes` qui imprime les préfixes d'une chaîne.\n",
    "P.ex `prefixes('Python')` doit afficher\n",
    "\n",
    "P\n",
    "\n",
    "Py\n",
    "\n",
    "Pyt\n",
    "\n",
    "Pyth\n",
    "\n",
    "Pytho\n",
    "\n",
    "Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q17** Ecrire une fonction `suffixes`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ecrire dans un fichier csv\n",
    "Le format Comma Separated Values est un format qui permet de stocker des lignes contenant des champs séparés par des virgules (Comma en Anglais). Ce format est typiquement utilisé par les tableurs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons calculer des valeurs et les ranger dans un fichier qu'on pourra ensuite ouvrir avec un tableur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=open('dataJB.csv','w')\n",
    "for k in range(20):\n",
    "    f.write(str(k)+','+str(100*0.9**k)+'\\n')\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q18** Comment s'appelle la suite de la deuxième colonne ? (Ceux qui n'ont pas pris spé maths, demandez à ceux qui savent)\n",
    "Ouvrir le fichier avec un tableur, puis représenter la suite par un nuage de points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q19** Ecrire un programme qui écrit dans `carreJB.csv` les nombres de -2 à 3 par pas de 0,1 dans la première colonne, et leurs carrés dans la deuxième colonne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q20** Décrire ce que fait le programme ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abscisses=[]\n",
    "ordonnées=[]\n",
    "\n",
    "x=-2\n",
    "h=0.1\n",
    "while x<3:\n",
    "    abscisses.append(x)\n",
    "    ordonnées.append(x*x)\n",
    "    x=x+h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(abscisses,ordonnées,label='Ligne brisée $y=x^2$')\n",
    "plt.title(\"Une parabole\")\n",
    "plt.axis([-2,3,0,10])\n",
    "plt.axis('equal')\n",
    "plt.grid()\n",
    "plt.legend()"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}