TP9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "09059580",
   "metadata": {},
   "source": [
    "# ITC - MPSI\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffcbb584",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f221e8632ecad68f835a7b037d7a8fba",
     "grade": false,
     "grade_id": "cell-45593523e53e761c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# TP9 : Chaînes de caractères\n",
    "Nous explorons ici plus en détails les chaînes de caractères en `python`.\n",
    "\n",
    "Pour rappel, une _chaîne de caractères_ est une suite finie de caractères. En python, les chaînes de caractères s'écrivent entre guillemets simples ou doubles: `'exemple'` ou `\"exemple\"`, ou entre triples guillements simples ou doubles, ce qui permet d'inclure des retours à la ligne:\n",
    "\n",
    "`\"\"\"ceci est un\n",
    "exemple\"\"\"`\n",
    "\n",
    "`'''ceci en\n",
    "est un autre'''`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b36692d8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "880c96e212c137cc1a3728eadf6d2404",
     "grade": false,
     "grade_id": "cell-547fc4c61bc7386a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "On peut accéder à chaque caractère d'une chaîne de caractères, grâce à la notation `[]` (comme pour les cases d'une liste). Le première caractère se trouve à l'indice 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8ed78a1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8ed1c1cf3cf17bde40430e762b268fde",
     "grade": false,
     "grade_id": "cell-e559c28bd128c9d3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "mot = 'abcedf'\n",
    "mot[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76c8b01a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6ccaf032bb92e595daa43b90a5c66322",
     "grade": false,
     "grade_id": "cell-22d12cd8d31466b7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "On peut parcourir les caractères d'une chaîne de caractères avec une boucle `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65ad4964",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a8b45adbf2b3b8e1d15096a80d017d85",
     "grade": false,
     "grade_id": "cell-919cba6e94e157c8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "mot = 'abcdef'\n",
    "for lettre in mot :\n",
    "    print(lettre)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6918477e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "2e9a3d5f1d4262029b937a0baafbca8a",
     "grade": false,
     "grade_id": "cell-7f8c53078ff8802e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "On accède au nombre de caractères d'une chaîne par la fonction `len`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7d633c2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a137ec7f24906942a26fe3a85faf53b2",
     "grade": false,
     "grade_id": "cell-80a54feb8b3ede8c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "len('abcdef')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db88ce40",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b9a9a1bc6e73a87baab7ea5efcac5d5b",
     "grade": false,
     "grade_id": "cell-ed0dd23ae7d04b1d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "len('')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2554d784",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "428bbd87a9b211f8e5df6096fe5c6cf1",
     "grade": false,
     "grade_id": "cell-065792b70b71de24",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**On ne peut pas modifier un caractère dans une chaîne :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95b37fc5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2ba9f6d8b5fc5e1cd846ed00cb549739",
     "grade": false,
     "grade_id": "cell-b3b7fc61ed32df74",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "mot = 'abcdef'\n",
    "mot[1] = 'z'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f579c0ab",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "40c32e7b5e099dcefa38be0504c8a68c",
     "grade": false,
     "grade_id": "cell-202e6824ac063268",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Le fait que les valeurs d'un type ne soient pas modifiables s'appelle l'_immuabilité_. Le type chaîne de caractères est donc immuable en `python`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fe37cfe",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f99930f6d3219a4aa2f0216a98bbeb8d",
     "grade": false,
     "grade_id": "cell-6504d688d0ab3da4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 1 : Trouver une lettre dans une chaîne\n",
    "Écrire et documenter une fonction `appartient` qui prend en argument une première chaîne de longueur 1 (on vérifiera cette longueur avec `assert`) et une deuxième chaîne de longueur quelconque et vérifie si la première chaîne apparaît dans la deuxième en faisant un parcours explicite. (Dans la vraie vie, on peut écrire directement `mot in lettre`, mais ce n'est pas ce qui est attendu ici.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14c19a4f",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "60004b2ae78551f072c791f26c2b10a1",
     "grade": false,
     "grade_id": "cell-46db2defd4c50ce9",
     "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": "f647dd70",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "63b451251cfbf29c5264c08635b8126c",
     "grade": true,
     "grade_id": "cell-0ea737c9a6d1d494",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(not appartient('a', ''))\n",
    "assert(appartient('a', 'a'))\n",
    "assert(appartient('a', 'abcdef'))\n",
    "assert(appartient('a', 'fedcba'))\n",
    "assert(appartient('a', 'cbabcd'))\n",
    "assert(not appartient('a', 'b'))\n",
    "assert(not appartient('a', 'bcdef'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32c339d9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "d8d8be376d22550584d1fe6df2c0e1a8",
     "grade": false,
     "grade_id": "cell-5a1b17e1f5b72d25",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 2 : Voyelles vs. consonnes\n",
    "Écrire et documenter une fonction `comparaison_vc` qui prend en argument une chaîne de caratères et renvoie `True` si et seulement si la chaîne contient strictement plus de voyelles que de consonnes, `False` sinon. On supposera, sans avoir à le vérifier que la chaîne est composée exclusivement de lettres non accentuées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80c08cf1",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4bace9c15fe7b166c024940e00a79187",
     "grade": false,
     "grade_id": "cell-f48771c6cbe491c7",
     "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": "1e478780",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e94c43ff308846ce837448df5a52c1c8",
     "grade": true,
     "grade_id": "cell-c3ff5cbe50c4b891",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(comparaison_vc('aaaabbb'))\n",
    "assert(not comparaison_vc('aaaabbbb'))\n",
    "assert(not comparaison_vc(''))\n",
    "assert(comparaison_vc('abababa'))\n",
    "assert(not comparaison_vc('ababab'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b9d043",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "14aef2079cbeec54a5a74083ccaf81d3",
     "grade": false,
     "grade_id": "cell-b62dbdd1b4691c4f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 3 : Trouver une chaîne dans une autre à un emplacement précis\n",
    "Écrire et documenter une fonction `apparait` qui prend en argument deux chaînes de caractères et un entier et vérifie si la première chaîne apparaît dans la deuxième à l'indice donné.\n",
    "\n",
    "À noter que le \"ou\" entre booléens en `python` s'écrie `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a48f8461",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bc29fc7ac104c9db7adaf5e04a47509c",
     "grade": false,
     "grade_id": "cell-3e5218106f7cc1b7",
     "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": "388032ea",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cf8a74041726edbac36c8bdc4ee46183",
     "grade": true,
     "grade_id": "cell-175ad3b0244afd4d",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(apparait('', 'abcd', 2))\n",
    "assert(not apparait('', 'abcd', 4))\n",
    "assert(apparait('abc', 'abcdef', 0))\n",
    "assert(not apparait('abc', 'abcdef', 1))\n",
    "assert(apparait('def', 'abcdef', 3))\n",
    "assert(not apparait('def', 'abcdef', 2))\n",
    "assert(not apparait('def', 'abcdef', 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f866be85",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f2dd614326fa78ac12906d47805cf797",
     "grade": false,
     "grade_id": "cell-8a5f74f721925f6d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 4 : Trouver une chaîne dans une autre\n",
    "Écrire et documenter une fonction `apparait` qui prend en argument deux chaînes de caractères et un entier et vérifie si la première chaîne apparaît dans la deuxième'.\n",
    "\n",
    "Vous remarquez qu'en `python`, on peut avoir plusieurs fonctions du même nom, à condition qu'elles ne possèdent pas le même nombre de paramètres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7175ab1a",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3a27cc73c25ba9105769a447121957be",
     "grade": false,
     "grade_id": "cell-b77ea53324568a68",
     "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": "be90a58a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "db8f52254baaec9e7270eed56d3ea717",
     "grade": true,
     "grade_id": "cell-2776e4041ff97966",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(apparait('', ''))\n",
    "assert(apparait('', 'abcdef'))\n",
    "assert(apparait('abc', 'abcdef'))\n",
    "assert(apparait('abc', 'abc'))\n",
    "assert(apparait('abc', 'defabc'))\n",
    "assert(apparait('abc', 'defabcdef'))\n",
    "assert(apparait('abc', 'abcabc'))\n",
    "assert(not apparait('abc', 'defab'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325b93ec",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "838283dab0e91f4ec446a43f3948dbb4",
     "grade": false,
     "grade_id": "cell-504bfd92b6096cd9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 5 : Miroir\n",
    "\n",
    "On peut créer une nouvelle chaîne de caractères en concaténant des chaînes existantes grâce à l'opérateur `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a59be7a7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4447981ee89d714fdec2d67dcc3467e5",
     "grade": false,
     "grade_id": "cell-f1f4386c1108420f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'abc' + 'def'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c15b251",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e8865ec731e952d6dc4b85e98f6355a1",
     "grade": false,
     "grade_id": "cell-d1a6a163f809bc92",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Écrire et documenter une fonction `miroir` qui prend en argument une chaîne de caractères et renvoie une chaîne correspondant à la lecture de droite à gauche de la première."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9edc6fd8",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5cb960481a4a5bf8dbf6a1727a0ecf5f",
     "grade": false,
     "grade_id": "cell-f9e981eb6abf5fba",
     "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": "a41d662d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3e2b072964cf387bc158788399466201",
     "grade": true,
     "grade_id": "cell-2bb337270033490a",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(miroir('') == '')\n",
    "assert(miroir('a') == 'a')\n",
    "assert(miroir('aaa') == 'aaa')\n",
    "assert(miroir('abcdef') == 'fedcba')\n",
    "assert(not miroir('abcdef') == 'abcdef')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d261d11",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "26da8b926011d4e998073e59f4fd3464",
     "grade": false,
     "grade_id": "cell-359c5e5da1911e7d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 6 : bégaiement simple\n",
    "On peut créer une chaîne de caractères en répétant le motif d'une chaîne existante avec l'opérateur `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89244bc2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "638588c97bc5fc8c746bd5cfa7f8487c",
     "grade": false,
     "grade_id": "cell-71089eccdc325727",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'abc' * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "551bff25",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "872757e67bc9b70924b191299c3c74bc",
     "grade": false,
     "grade_id": "cell-d78435042d66415e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Écrire et documenter une fonction `begaiement` qui prend en argument une chaîne de caractères et un entier et renvoie une nouvelle chaîne dans laquelle chaque lettre est répétée, comme dans l'exemple suivant:\n",
    "\n",
    "```python\n",
    "begaiement('abc', 3)\n",
    "'aaabbbccc'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3da4add",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "69f99a765a4d66e29290ffb085a46b13",
     "grade": false,
     "grade_id": "cell-4c48d94d4ba57919",
     "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": "e45ff470",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "324709d4c7ec70ba05864ad8af173c0e",
     "grade": true,
     "grade_id": "cell-5e4d8e400367e04c",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(begaiement('', 3) == '')\n",
    "assert(begaiement('abc', 3) == 'aaabbbccc')\n",
    "assert(begaiement('abc', 0) == '')\n",
    "assert(begaiement('aaa', 1) == 'aaa')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "267d062d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "39e7dab730d08212ab1599745e2dc957",
     "grade": false,
     "grade_id": "cell-c5825dbae0e5bad8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exo 7 : bégaiement\n",
    "Écrire et documenter une fonction `begaiement` qui prend en argument une chaîne de caractères et un entier et renvoie une nouvelle chaîne dans laquelle chaque consonne est répétée, comme dans l'exemple suivant:\n",
    "\n",
    "```python\n",
    "begaiement('abc', 3)\n",
    "'abbbccc'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bc20b1b",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2c8c7a82c7e4685d2c759cd202883f0a",
     "grade": false,
     "grade_id": "cell-f851de74fd11c575",
     "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": "a16442b8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6b1caf37b58eff742aab972e3d4c9f6d",
     "grade": true,
     "grade_id": "cell-4d8c26fe25639c9a",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert(begaiement('abc', 3) == 'abbbccc')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7444b972",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "36cd1d9a52ab5712ccdbbf53d01aaf3d",
     "grade": false,
     "grade_id": "cell-aecee730afb0a051",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <h2>Les points à retenir</h2>\n",
    "    \n",
    "* accès à un caractère dans un chaîne par `[]`\n",
    "* parcours d'une chaîne avec une boucle `for`\n",
    "* immuabilité d'une chaîne de caractères\n",
    "* `+` comme opérateur de concaténation de chaînes de caractères\n",
    "* `*` comme opérateur de création d'une nouvelle chaîne\n",
    "</div>"
   ]
  }
 ],
 "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
}