TP13.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6eac60c7",
   "metadata": {},
   "source": [
    "# ITC - MPSI\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "facbd5b5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "10ce5e4ed5923b37eb5e661ef3796b60",
     "grade": false,
     "grade_id": "cell-c8cf4f90e635e93f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# TP13 : Fichiers\n",
    "Dans ce TP nous allons apprendre à lire et écrire dans un fichier qui se trouve sur le disque.\n",
    "\n",
    "Quand un programme doit accéder au contenu d'un fichier, le système vérifie que cette lecture est autorisée, puis il met en place toute une structure de données pour permettre cette lecture. L'ensemble de ces opérations est désigné par le terme _ouverture d'un fichier en lecture ou en écriture_. Une fois ces opérations faites, le programme peut accéder au contenu du fichier. Quand il a terminé ses manipulations (lecture et/ou écriture), il doit signaler qu'il n'a plus besoin de ces ressources, afin qu'elles puissent être mises à jour si besoin sur le disque.\n",
    "\n",
    "L'ouverture en lecture et/ou en écriture d'un fichier qui s'appelle `toto` se fait en `python` grâce à la fonction `open` à laquelle on fournit comme argument une chaîne de caractères qui contient le nom du fichier. Cette fonction renvoie un flux. Nous ne rentrerons pas dans les détails de ce qu'est un flux, le seul point important est que nous pourrons utiliser cette valeur de retour pour effectuer des lectures et des écritures dans le fichier ainsi ouvert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42c23629",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7f9fa99f0269d721784b9e5ef6a22cd8",
     "grade": false,
     "grade_id": "cell-8208654a064a3bb8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"toto\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a55bd0c8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f6a8fd3e332aa434122bbbed27304e88",
     "grade": false,
     "grade_id": "cell-386c3eac15773349",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Dans l'exemple précédent, le message d'erreur vient du fait qu'il n'y a aucun fichier qui s'appelle `toto`. Recommençons avec le nom d'un fichier existant (vous pouvez voir le contenu de ce fichier : [fichier_0](Fichiers/fichier_0)) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d4821a9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a84394b0b2546fdea33c07a9add70ae3",
     "grade": false,
     "grade_id": "cell-4b85768b263463db",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f = open('Fichiers/fichier_0')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f26b4575",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fcbef9b8d83219513adcd1c3bf588edd",
     "grade": false,
     "grade_id": "cell-38467e122d987f5e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Quand on termine d'utiliser les ressources associées au fichier, il faut les libérer, ce qui se fait par la méthode `close` (attention à la syntaxe) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d03ea56b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1ead74038648e39354ff50d7e806dc34",
     "grade": false,
     "grade_id": "cell-dd092a57b203dbb1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6852b566",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0650a87766d0d8b032483cfa3f26f0b0",
     "grade": false,
     "grade_id": "cell-a49220dcb2b1b5c1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Lecture d'un fichier\n",
    "On peut lire d'un coup toutes les lignes d'un fichier (pas recommandé si le fichier est long), avec la méthode `read` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93bcee36",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1da3ff75f81dda2105d21e5e1a64c2bf",
     "grade": false,
     "grade_id": "cell-114e4d381ce7d0b5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f = open('Fichiers/fichier_0')\n",
    "f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db77a93c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4771cea934c204aa0c4df1a24e479390",
     "grade": false,
     "grade_id": "cell-75418cd1fca9c81f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Vous remarquez que les retours à ligne apparaissent sous la forme du caractère `'\\n'`. Si on affiche cette chaîne à l'aide de la fonction `print`, on a effectivement des retours à la ligne.\n",
    "\n",
    "La pointe de lecture se déplace de gauche à droite au fur et à mesure, une fois la lecture de tout le fichier faite, il n'y a donc plus rien à lire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "743abfcb",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fd8c9a7402abf150dfe5561aeb32fb42",
     "grade": false,
     "grade_id": "cell-6f042f04c548ff88",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "552f6705",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "194b5bf78a24bc40236d178d08642f3e",
     "grade": false,
     "grade_id": "cell-cf20cacff4889ec1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11985b0f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "54f38aa608d82daf8d26d94ca1ce4441",
     "grade": false,
     "grade_id": "cell-81cdf3ea5ca521a2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "On peut également obtenir toutes les lignes d'un fichier sous la forme d'une liste de lignes (la coupure se fait alors à chaque changement de ligne) grâce à la méthode `readlines` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7f82efe",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3b8bc0b53e8620c54e0371b370acd967",
     "grade": false,
     "grade_id": "cell-d74ca70112b96fe6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f = open('Fichiers/fichier_0')\n",
    "lignes = f.readlines()\n",
    "f.close()\n",
    "\n",
    "lignes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9627db2b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "cd068e354b49cb1f8f03787b1756a560",
     "grade": false,
     "grade_id": "cell-38ac8a5534253a9f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "On peut aussi demander lire ligne à ligne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23181ff4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6a0e88837a39e2cebeb153dbcce07403",
     "grade": false,
     "grade_id": "cell-cdd7bd9382c157cb",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f = open('Fichiers/fichier_0')\n",
    "ligne1 = f.readline()\n",
    "ligne2 = f.readline()\n",
    "f.close()\n",
    "\n",
    "ligne2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "514cf6e6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f9649d2a9ea379d35dbfbd138665640d",
     "grade": false,
     "grade_id": "cell-8314a773dfb0c164",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "`readline` renvoie une chaîne vide (`''`) en fin de fichier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "483ec913",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b7244cf7a7611f8ac4dd325246c4e4ec",
     "grade": false,
     "grade_id": "cell-664c98567b803ce2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "f = open('Fichiers/fichier_0')\n",
    "f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc5b48ad",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "073b694b54848140037f61dde56b4be4",
     "grade": false,
     "grade_id": "cell-240d12a015d80299",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Exercice 1 : compter les lignes\n",
    "Écrire et documenter une fonction `wcl` qui prend en argument un nom de fichier et renvoie le nombre de lignes de ce fichier. Ne pas oublier de fermer le fichier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29892697",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4f34cef7bc2b1562bdd34c630b3d0df1",
     "grade": false,
     "grade_id": "cell-92b9a462c3b9957e",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83cac3ef",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2046d35574f201fb6fcab01eaa773c8c",
     "grade": true,
     "grade_id": "cell-fbd6efee6b39eb22",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(wcl('Fichiers/fichier_1') == 0)\n",
    "assert(wcl('Fichiers/fichier_2') == 1)\n",
    "assert(wcl('Fichiers/fichier_3') == 3)\n",
    "assert(wcl('Fichiers/fichier_4') == 10)\n",
    "assert(wcl('Fichiers/fichier_5') == 10)\n",
    "assert(wcl('Fichiers/fichier_6') == 2862)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "935109f3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5b5905ac31dfa8c07dd48958a3e7d506",
     "grade": false,
     "grade_id": "cell-dcd25ea116d3b84a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Exercice 2 : numéroter les lignes\n",
    "Le but de cet exercice est d'écrire une fonction qui affiche les lignes d'un fichier les unes après les autres, en les numérotant. Pour cela, il faut pouvoir afficher du texte: on utilise la fonction `print` avec comme argument la chaîne de caractères à afficher :\n",
    "```python\n",
    "print('texte à afficher')\n",
    "```\n",
    "\n",
    "Quand on veut afficher un entier, on peut donner directement l'entier à `print`, qui se charge de la conversion :\n",
    "```python\n",
    "print(5)\n",
    "n = 3\n",
    "print(n)\n",
    "```\n",
    "\n",
    "En revanche si on veut combiner un entier et une chaîne, il faut explicitement convertir l'entier en utilisant la fonction `str` :\n",
    "```python\n",
    "n = 3\n",
    "print('n vaut ' + str(n))\n",
    "```\n",
    "\n",
    "Écrire et documenter une fonction `catn` qui prend en argument un nom de fichier et affiche son contenu avec le numéro de chaque ligne en début de ligne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12a5e267",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a1206c3f5de8a2588ea1909cbe240c98",
     "grade": true,
     "grade_id": "cell-fda9fe42b1180eb6",
     "locked": false,
     "points": 2,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fa527bb",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ffa7c9868965251812c6699caf0a6994",
     "grade": false,
     "grade_id": "cell-95f40889be8b26e3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "À vous de tester visuellement votre réponse. Voici les sorties attendues sur deux exemples:\n",
    "```\n",
    "catn('Fichiers/fichier_1')\n",
    "```\n",
    "\n",
    "```\n",
    "catn('Fichiers/fichier_7')\n",
    "1 ligne 1\n",
    "\n",
    "2 ligne 2\n",
    "\n",
    "3 \n",
    "\n",
    "4 ligne 4\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "607175f5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "27ed1866ed27533824640633e18bf43d",
     "grade": false,
     "grade_id": "cell-a5f59b0ab61452ae",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "catn('Fichiers/fichier_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b0da3a7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "48e5b58bf8664deef4556fcb4dfdec01",
     "grade": false,
     "grade_id": "cell-26441d5de796eee7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "catn('Fichiers/fichier_7')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c357d91",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "eba91d0d79afac39f6249fa45d8142cb",
     "grade": false,
     "grade_id": "cell-39280a1230916a8e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Exercice 3 : lignes vides\n",
    "Écrire et documenter une fonction `lignes_vides` qui prend en argument un nom de fichier et renvoie le nombre de lignes vides qu'il contient (c'est-à-dire le nombre de lignes qui contiennent uniquement le caractère `'\\n'`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58b6441d",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9137bb3d608026ffd0d7b03fd0235da0",
     "grade": false,
     "grade_id": "cell-737a8df8b57f9696",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd2f0eb5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8fd4c5e4da4a7d5de73f7fd98f194c62",
     "grade": true,
     "grade_id": "cell-dc98bdefaba9fd7a",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(lignes_vides('Fichiers/fichier_1') == 0)\n",
    "assert(lignes_vides('Fichiers/fichier_2') == 1)\n",
    "assert(lignes_vides('Fichiers/fichier_3') == 0)\n",
    "assert(lignes_vides('Fichiers/fichier_4') == 7)\n",
    "assert(lignes_vides('Fichiers/fichier_5') == 3)\n",
    "assert(lignes_vides('Fichiers/fichier_6') == 113)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "883d833b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b06d712a17042038ae4a3456183c1278",
     "grade": false,
     "grade_id": "cell-98fb0b2264e28657",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Exercice 4 : Tester si deux fichiers sont identiques\n",
    "Écrire et documenter une fonction `diff` qui prend en argument les noms de deux fichiers et teste si les deux fichiers sont identiques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff1b3fde",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6b35227e0c22ae20161866545d95aca1",
     "grade": false,
     "grade_id": "cell-34082345e1699b69",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88bfdfc2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a268d0518ca05021ddf4b20cb256dc1c",
     "grade": true,
     "grade_id": "cell-6e4695b857b34c55",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(diff('Fichiers/fichier_6', 'Fichiers/fichier_6') == True)\n",
    "assert(diff('Fichiers/fichier_6', 'Fichiers/fichier_8') == True)\n",
    "assert(diff('Fichiers/fichier_6', 'Fichiers/fichier_7') == False)\n",
    "assert(diff('Fichiers/fichier_6', 'Fichiers/fichier_1') == False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e990d87",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8dd947b10c0870b1c66519fa32716c41",
     "grade": false,
     "grade_id": "cell-c7ba2cf71d5e0c96",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Écriture dans un fichier\n",
    "Pour écrire dans un fichier, il faut spécifier au moment de l'ouverture (`open`) qu'on veut écrire dans le fichier. Pour cela, on donne un deuxième argument à `open` sous forme d'une chaîne de caractères de longueur 1 qui explicite le type d'écriture:\n",
    "* `'a'` pour écrire à la fin du fichier (a pour _append_)\n",
    "* `'w'` pour écrire à la place du contenu du fichier qui est alors perdu (w pour _write_)\n",
    "\n",
    "Pour écrire dans le fichier, on utilise alors la méthode `write` :\n",
    "```python\n",
    "f = open(fichier, 'w')\n",
    "f.write('le texte à écrire')\n",
    "f.close()\n",
    "```\n",
    "\n",
    "Contrairement à `print`, la méthode `write` n'ajoute pas de retour à la ligne en fin de chaîne. Si on veut un retour à la ligne, il faut l'ajouter explicitement, avec le caractère `'\\n'`:\n",
    "```python\n",
    "f = open(fichier, 'w')\n",
    "f.write('un texte avec retour à la ligne à la fin\\n')\n",
    "f.close()\n",
    "```\n",
    "\n",
    "Contrairement à `print`, la méthode `write` ne convertit pas toute seule son argument en chaîne de caractères."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "418d5f34",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "47f4ee0b6938e2242eaa3966db17e8cf",
     "grade": false,
     "grade_id": "cell-baad358da2d3e45a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Exercice 5 : Écrire des nombres\n",
    "Écrire et documenter une fonction `denombrer` qui prend en argument un entier positif ou nul et le nom d'un fichier et écrit dans ce fichier tous les entiers compris entre 0 et le premier argument (compris), avec un retour à la ligne après chaque entier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f1b870a",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5aa546be2b3ece68247e78f98d4997fd",
     "grade": false,
     "grade_id": "cell-5013620503297331",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90f97717",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f5f9080e746c1b3a61ef9677ac9af35b",
     "grade": true,
     "grade_id": "cell-65814ca4b8ecc2cf",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "fic = 'Fichiers/test1'\n",
    "n = 5\n",
    "denombrer(n, fic)\n",
    "with open(fic) as f:\n",
    "    assert(f.readlines() == [ str(i)+'\\n' for i in range(n) ])\n",
    "    f.close()\n",
    "    \n",
    "!rm Fichiers/test1  #pas du python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c90cbf0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ca1fc13ee509bc06b53f43da368c459a",
     "grade": false,
     "grade_id": "cell-5b1e0f77de549a15",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Exercice 6 : Copier un fichier\n",
    "Écrire et documenter une fonction `copie` qui prend en argument deux noms de fichiers et copie le contenu du premier dans le deuxième (en écrasant le contenu existant éventuel)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12b736c9",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5680bdb884bd7bd09686fa1d5fed6954",
     "grade": false,
     "grade_id": "cell-541384f63490d26e",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Écrire votre code ici\n",
    "raise NotImplementedError # effacer cette ligne une fois le code écrit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f622300b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2160f5059c48196ed880422f02c2d64b",
     "grade": true,
     "grade_id": "cell-510231615b1ad552",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "copie('Fichiers/fichier_3', 'Fichiers/copie')\n",
    "assert(diff('Fichiers/fichier_3', 'Fichiers/copie') == True)\n",
    "\n",
    "!rm Fichiers/copie  ## pas du python"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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": 5
}