02-variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4d41f04b-cd62-447f-a89e-5f03ba6775f6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Les variables\n",
    "\n",
    "Ce cours est téléchargeable à l'adresse https://github.com/sdunesme/formation-python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0acad9fb-419f-4dbb-a5c0-69417398fda5",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Une variable est une zone de mémoire dans laquelle une valeur est stockée. En Python, on définit et fait appel à une variable par un nom qui est traduit par l'interpréteur en adresse dans la mémoire vive. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9eda7b90-b9f5-4381-ada9-11ab0b1f829b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "message = \"hello geographers!\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bcbb805-d9ff-4093-a3f3-6d1cd87fd094",
   "metadata": {
    "tags": []
   },
   "source": [
    "Ici, rien ne s'affiche et c'est normal ! Vous avez simplement stocké la chaine de caractères \"hello geographers!\" dans la variable **message**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c68d449b-4416-4c31-8304-579ff5281227",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(message) # On utilise la fonction \"print\" pour afficher le contenu de la variable message"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "264474a7-10d3-403a-8329-a4324aa34e54",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Si je fais référence à une variable qui n'a pas été définie au préalable, Python me renvoie une erreur de type \"NameError\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "769e3128-ab52-40e1-823b-4beeb9d14c6d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(message2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21c8a422-8f7e-4b0b-9e1c-35dc1671b683",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Il est possible de réaliser des opérations arithmétiques avec les variables. Toutes ces opérations sont [listées ici](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b2c9cfd-f62d-4122-9b14-a3bbe3323455",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "var_a = 6\n",
    "var_b = 8\n",
    "\n",
    "print(var_a + var_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4308bebe-3de5-40ca-82f8-b870ca18ba36",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "### Quelques conventions de nommage pour les variables\n",
    "\n",
    "* Utiliser des noms complets et descriptifs\n",
    "* Utiliser la norme snake_case\n",
    "* Commencer par une lettre ou un _, proscrire les autres caractères spéciaux"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "83b776b0",
   "metadata": {},
   "source": [
    "> ✍️ Initialiser deux variables contenant des entiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7d5026a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "56a16526-45eb-42a2-8037-d96ec3549273",
   "metadata": {},
   "source": [
    "> ✍️ Dans une nouvelle variable, stocker le résultat de la soustraction des deux premières"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59ba79cc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "90eccfaf-802b-414f-bf9e-a3e37b7788d2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Quelques types pour commencer\n",
    "\n",
    "Python détecte tout seul le type d'une variable au moment de son initialisation : il ne nécessite pas de déclaration préalable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfb302de-773e-4d5d-8da1-21cc42705046",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(var_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9feac4da-8046-46ff-8e40-6628c29f159e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f89498c-693f-451c-976c-26ebbe9fbb79",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Chaines de caractères (str)\n",
    "- Booléens (bool) : True ou False (attention à la casse)\n",
    "- Numériques: entiers (int) et flottants (float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27ee091e-9f99-45bc-9f2a-8a71a508515e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Listes (list) et les tuples (tuple)\n",
    "\n",
    "- Les listes sont des variables contenant plusieurs éléments pouvant être de même type ou de types différents. \n",
    "- Les tuples sont des listes qui ne sont plus modifiables une fois créées : principalement utilisé pour retourner les résultats d'une fonction. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d401a04-c65e-4c63-8cfe-c1bed000f355",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "eleves = ['geographers', 'statisticians', 'historians']\n",
    "liste_entiers = [51, 52, 53, 54, 55, 56, 57, 58, 59]\n",
    "liste_vide = []\n",
    "liste_de_listes = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "liste_de_bool = [True, False, False, True]\n",
    "liste_multi_types = [5, \"lapins\", 3.7]\n",
    "\n",
    "print(eleves)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "444cfada-eff4-44a1-9ac1-7a09f188c147",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "On fait appel à un élément d'une liste en utilisant son index. Attention: en Python les index démarrent à 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25743e60-ae35-4dad-9490-430b3826a11e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "liste_entiers = [51, 52, 53, 54, 55, 56, 57, 58, 59]\n",
    "print(liste_entiers[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af62d354-8811-406b-99bd-4d0f755798a5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(liste_entiers[2:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "660f5cc9-3b33-48e6-b42d-018b81e57510",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(liste_entiers[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bfab940-bcf5-464c-99ef-56b584876980",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(liste_entiers[-1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a32c445d",
   "metadata": {},
   "source": [
    "Il est possible de faire référence à un élément d'une liste imbriquée dans une autre comme ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16b8f9df-5138-4e94-bdbe-f4ba52eba3e6",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "liste_de_listes = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "print(liste_de_listes[1][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b244641d-d751-40b9-9b5c-60a58bac1a56",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Point très important : Python est sensible à l'indentation. Une indentation = 4 espaces en début de ligne. Un exemple avec une première boucle :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8aeed1d9-aa98-4076-949b-591af8ec9f5c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "eleves = ['geographers', 'statisticians', 'historians']\n",
    "\n",
    "for discipline in eleves:\n",
    "    print(\"hello \" + discipline)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c6cd5cd-3639-4856-9e98-4b60147cc27b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(\"je ne suis pas encore dans la boucle \\n\")\n",
    "\n",
    "for discipline in eleves:\n",
    "    print(\"hello \" + discipline)\n",
    "    print(\"je suis dans la boucle \\n\")\n",
    "    \n",
    "print(\"je ne suis plus dans la boucle\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c7525fb8-19f8-4d15-ad6a-196bb265580d",
   "metadata": {},
   "source": [
    "> ✍️ Définir une liste contenant au moins un objet de type booléen, une chaine de caractères et un flottant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fc4b134",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3a066fb2-0d10-4870-b753-147a88c9c660",
   "metadata": {},
   "source": [
    "> ✍️ Affichez le troisième élément de cette liste avec la fonction `print()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea65eb56",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "879bba39-3131-4c9f-9fbc-80ce4305c382",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Dictionnaires (dict)\n",
    "\n",
    "Les dictionnaires ressemblent aux listes, mais les éléments y sont nommés par des clés. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "519b96eb-e098-447a-9596-8ec933024fb7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "eleves = {\n",
    "    'geographers': 5,\n",
    "    'statisticians': 8,\n",
    "    'historians': 3\n",
    "}\n",
    "print(eleves['geographers'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8c74b7b-a905-4b78-b562-1302a77e68ef",
   "metadata": {},
   "source": [
    "Comme pour les listes, il est possible d'imbriquer des dictionnaires. On retrouve régulièrement la dénomination \"nested dict\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a498e5f-445b-439e-9790-8a7e8a4ad05d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "infos_personnelles = {\n",
    "    'jdupont': {'nom': 'Dupont', 'prenom': 'Jean', 'age': 37},\n",
    "    'gabitbol': {'nom': 'Abitbol', 'prenom': 'Georges', 'age': 71},\n",
    "}\n",
    "print(infos_personnelles['jdupont']['age'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ab1d20ec-ab26-4c38-9ed6-5b0045f383a0",
   "metadata": {},
   "source": [
    "> ✍️ Compléter ce dictionnaire pour qu'il contienne des informations sur 4 villes de France"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18e3430a-6dcf-46f9-96af-248a30f89f27",
   "metadata": {},
   "outputs": [],
   "source": [
    "populations = {\n",
    "    'Amiens': 132900,\n",
    "    'Orléans': 114644, \n",
    "    '': \n",
    "}\n",
    "\n",
    "print(populations)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f4c992cf-d524-4c8a-bcb9-f7d0e7409cf7",
   "metadata": {},
   "source": [
    "> ✍️ Sans redéfinir le dictionnaire, corriger la population de la ville d'Amiens qui est erronnée : la vraie valeur est 132874 habitants. Vérifier que la correction est bien faite avec un print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15dcb867",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a2368283-1370-433f-9ef5-3ca7bfcee27a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Objet nul (Null, None)\n",
    "\n",
    "L'objet nul permet notamment :\n",
    "\n",
    "- D'initialiser une variable avec rien dedans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30247790-ba62-47a0-83e9-155a3720d2e9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "objet_nul = None\n",
    "print(objet_nul)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1b6746e-0fc6-4a63-b3d3-07b5ef1feb3f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- De libérer de la mémoire vive en vidant le contenu d'une variable volumineuse (une image par exemple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56bfa534-bf43-4028-841c-780291052ad4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# On affiche le contenu de la variable\n",
    "print(eleves)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "addf0971",
   "metadata": {},
   "outputs": [],
   "source": [
    "# On l'écrase avec un objet None\n",
    "eleves = None\n",
    "print(eleves)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb9879c2-762c-40cd-b18d-b14ec5da7653",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- De tester l'existence de contenu dans une variable dans une structure conditionnelle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9bb8109-7c75-48cf-ad86-09a6ce50e7cc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "if eleves:\n",
    "    print('il y a des élèves')\n",
    "else:\n",
    "    print('il n\\'y a aucun élève') # Remarquez l'antislash pour échapper le quote"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87d138a8-5c06-4b73-bcda-18167732cc74",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Comment tester le type d'une variable ?\n",
    "\n",
    "La fonction `type()` permet cela."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84e1f2bc-4ab6-43e6-a317-ab82a83bdf71",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(eleves)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d528357-bcca-4a7e-950d-aae6c7540fe3",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "Il est possible de convertir le type de certaines variables :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fddda8ec-cec1-4d9b-a8bb-d40d39938025",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Dans ce cas, Python réalise une troncature à l'unité\n",
    "valeur = int(3.0)\n",
    "print(valeur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "723cddc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pour faire un arrondi, utiliser la fonction round()\n",
    "valeur = round(3.965)\n",
    "print(valeur)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a029a54f-325e-459b-8a39-dc52bc4ed04f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Les comparaisons et opréateurs logiques\n",
    "\n",
    "On peut utiliser également des opérateurs de comparaison pour tester une variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8afb83a9-7113-4183-8741-22f3f3bcf77f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(eleves) == str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e0658ac-7d27-4334-8610-3a2eaaa29b3a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(eleves) == list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "181b4600-0ad4-43f5-b2ae-cbbda1be7b9d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(eleves) != bool"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d8290653",
   "metadata": {},
   "source": [
    "Plusieurs opéateurs logiques peuvent être combinés avec des opérateurs de comparaison pour créer des tests logiques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f72f318d-a8ea-413f-8b0e-9f456ecf7def",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "eleves = {\n",
    "    'geographers': 5,\n",
    "    'statisticians': 8,\n",
    "    'historians': 3\n",
    "}\n",
    "\n",
    "type(eleves) != bool and len(eleves) > 5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f00b938b",
   "metadata": {},
   "source": [
    "Toutes les com et opérateurs logiques sont [détaillés ici](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d7faf31c",
   "metadata": {},
   "source": [
    "> ✍️ Ecrire un test logique permettant de vérifier qu'il y a au moins 5 historiens dans la variable `eleves`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7050e3c3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "344a842b-507d-4bb3-9b01-c407bb64e7c6",
   "metadata": {},
   "source": [
    "> ✍️ Ecrire un test logique permettant de vérifier qu'il y a au moins 5 historiens OU au moins 5 géographes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b618191",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7c583d81-5b26-47e2-b687-84cf6e570e8f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Quelques méthodes et fonctions utiles pour chaque type\n",
    "\n",
    "> Une méthode est une fonction qui \"appartient à\" un objet. \n",
    "\n",
    "Des méthodes peuvent être définies pour chaque classe (type) d'objet. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfc135e7-fb63-4025-a2e8-2caf3f83e3b8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Chaines de caractères (str)\n",
    "[Toutes les méthodes pour les chaines de caractères](https://docs.python.org/3/library/stdtypes.html#string-methods)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4aba0068-378a-4dd4-b537-51f2ebf3f965",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Passer en majuscules\n",
    "chaine = 'ma chaine de caractères'\n",
    "print(chaine.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35e43ada-ef5d-4225-b225-df96dc1a1fe1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Vérifier que la fin de la chaine correspond\n",
    "chaine = 'ma chaine de caractères'\n",
    "print(chaine.endswith(\"caractères\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "656989b2",
   "metadata": {},
   "source": [
    "> ✍️ Essayez de modifier la chaine à tester ci-dessus pour observer le réultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3780194-40db-423a-9cd7-23dc06239e8c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Vérifier que la chaine est en minuscules\n",
    "chaine = 'ma chaine de caractères'\n",
    "print(chaine.islower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "990f105e-241a-419d-941e-2601ab04656a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "chaine = 'ma chaine de caractères'\n",
    "\n",
    "# Tester la présence d'une sous-chaine\n",
    "\"ma\" in chaine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7471c9ca-3910-455c-ba45-edcdc8ef9b70",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Remplacer une sous-chaine\n",
    "chaine = 'ma chaine de caractères'\n",
    "print(chaine.replace(\"ma\", \"ta\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b143ede-4445-48a5-832e-938e94f543a9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Séparer la chaine par un caractère\n",
    "chaine = 'ma chaine de caractères'\n",
    "liste_mots = chaine.split(\" \")\n",
    "print(liste_mots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93a63c11-a42a-4cc4-a956-84b48a9141eb",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# \"Additionner\" (concaténer) des chaines de caratères\n",
    "print(chaine + \" est vraiment superbe !\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "008a2ecd",
   "metadata": {},
   "source": [
    "Attention : on ne peux concaténer que des chaines de caractères entre elles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89fa36cc-7271-4ffe-9d40-0774da6c84ab",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "taille_arbre = 5.68\n",
    "print('Cet arbre mesure ' + taille_arbre + ' mètres')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a534749",
   "metadata": {},
   "outputs": [],
   "source": [
    "taille_arbre = 5.68\n",
    "print('Cet arbre mesure ' + str(taille_arbre) + ' mètres')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8301b404-411c-4f31-ac73-3631c4b4d724",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Le string substitution\n",
    "Jusqu'en python 2, on utilisait majoritairement la méthode `.format()` ou la substitution par l'opérateur `%`. En python 3, la string substitution est beaucoup plus fluide et lisible. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "275e30be-eb1e-4a7e-9dda-25a0ef36a118",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "prenom = 'Jean'\n",
    "age = 37\n",
    "\n",
    "# Méthode .format()\n",
    "print('L\\'individu {} a {} ans.'.format(prenom, age))\n",
    "\n",
    "# Méthode %\n",
    "print('L\\'individu %s a %d ans.' % (prenom, age))\n",
    "\n",
    "# Méthode la plus moderne : les f-string\n",
    "print(f'L\\'individu {prenom} a {age} ans.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aef7db2-124e-4ea7-9767-0b9260986003",
   "metadata": {},
   "source": [
    "Il est possible d'exécuter du code directement entre les accolades :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dc6ada9-57d6-4f5a-8a1f-899709988f7d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(f\"Le résultat de l'opération 15 puissance 53 est {pow(15, 53)}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "806d29cb-cfeb-49de-b0e6-52e750099981",
   "metadata": {},
   "source": [
    "> ✍️ Stocker dans les variables `message1` et `message_2` une chaine de caractère de type \"Le département ... est découpé en ... communes\" en utilisant les variables ci-dessous.\n",
    "> 1. En utilisant la concaténation de chaines de caractères (avec les `+`)\n",
    "> 2. En utilisant le string substitution (avec les `f'{}'`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "106f01e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "departement = 'Rhone'\n",
    "nombre_communes = 208\n",
    "\n",
    "message_1 = \n",
    "message_2 = "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "528e172b-a15a-413a-aca1-d506565c03ea",
   "metadata": {},
   "source": [
    "> ✍️ Mettre ce message entièrement en majuscules et stocker le résultat dans une nouvelle variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "168d1d24",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8a0afeff-14ef-4ebb-9516-78cc3bd7a9b6",
   "metadata": {},
   "source": [
    "> ✍️ Transformer la chaine de caractères en liste de mots et extraire le nom du département via son index dans la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac83c956",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0ed0d81b-5948-4dd8-8a91-af3f6625ebc0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "### Listes (list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43d5b2bf-e317-45cf-8b22-37d79093b6c5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Tester la présence d'un élément\n",
    "liste_chaines = ['jeanne', 'julie', 'huguette', 'pierre', 'paul', 'georges']\n",
    "'jeanne' in liste_chaines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "354b57ee-b37e-4af3-84eb-a8ef0fae01a9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Trier les éléments\n",
    "liste_entiers = [2,5,4,3,5,1,2,6,8]\n",
    "liste_entiers.sort()\n",
    "print(liste_entiers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25970b6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Le tri fonctione aussi pour les listes de chaines\n",
    "liste_chaines = ['jeanne', 'julie', 'huguette', 'pierre', 'paul', 'georges']\n",
    "liste_chaines.sort()\n",
    "print(liste_chaines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "852f7490-4fbd-4fd8-8629-9dbba74e9f13",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Réaliser un tri inversé\n",
    "liste_entiers = [2,5,4,3,5,1,2,6,8]\n",
    "liste_entiers.reverse()\n",
    "print(liste_entiers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e8fa1df-9c98-4304-9466-299190b1ac74",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Ajouter un élément\n",
    "liste_chaines = ['jeanne', 'julie', 'huguette', 'pierre', 'paul', 'georges']\n",
    "liste_chaines.append('suzanne')\n",
    "print(liste_chaines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85e00ab8-31b9-4cd5-8e02-d2c5e66f05ff",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Ajouter un élément à une position précise\n",
    "liste_chaines = ['jeanne', 'julie', 'huguette', 'pierre', 'paul', 'georges']\n",
    "liste_chaines.insert(3, 'françois')\n",
    "print(liste_chaines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be947549-0741-4174-ae2d-8826b751b872",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Supprimer un élément via son contenu\n",
    "liste_chaines = ['jeanne', 'julie', 'huguette', 'pierre', 'paul', 'georges']\n",
    "liste_chaines.remove('julie')\n",
    "print(liste_chaines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd782ae6-2eb5-490b-b084-d5df24292cd8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Supprimer un élément via son index dans la liste\n",
    "liste_chaines = ['jeanne', 'julie', 'huguette', 'pierre', 'paul', 'georges']\n",
    "liste_chaines.pop(2)\n",
    "print(liste_chaines)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a99f779b-d3cf-4e0b-a6c4-15018fc36dcf",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "#### Quelques fonctions utiles avec des listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f06a9646-6e3d-4788-a025-9f820d2f207e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Quelques informations sur une liste\n",
    "ma_liste = [2,5,4,3,5,1,2,6,8,0,2,7,9,5,1,3,6,4,0,1,5,4,7,8,5,3]\n",
    "\n",
    "print(len(ma_liste)) # Sa longueur\n",
    "print(max(ma_liste)) # Son maximum\n",
    "print(min(ma_liste)) # Son minimum\n",
    "print(sum(ma_liste)) # Sa somme"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "218c9e27-d870-4dd0-965d-10b2d30015b1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "D'autres statistiques comme la moyenne, la médiane, etc. sont implémentées dans le package statistics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9495d82-3df0-4bd6-bea2-6e18a788c98b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# On importe le package (il ne contient qu'un seul module)\n",
    "import statistics\n",
    "\n",
    "# On fait appel à une fonction de ce module\n",
    "statistics.mean(ma_liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b837f3cd-b6ce-438e-9d2e-d55ee18a96a5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Il est possible de stocker un module entier dans une variable\n",
    "import statistics as stats\n",
    "\n",
    "# On appelle alors les fonctions de ce module via cette variable\n",
    "stats.median(ma_liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04737d13-ee87-45ae-906f-20abca9d81d2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Enfin, il est possible d'importer uniquement un module ou une fonction d'un module\n",
    "from statistics import median\n",
    "\n",
    "# On peux alors faire appel directement à la fonction\n",
    "median(ma_liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26d4977f-e276-470a-a70b-c129b30a7d00",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import statistics\n",
    "\n",
    "# Très important : afficher l'aide d'un module et le lien vers sa documentation complète\n",
    "help(statistics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf19bf76",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Avec l'interpréteur IPython (utilisé par Jupyter Lab), on peux aussi afficher l'aide comme cela\n",
    "?statistics"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "25735a30",
   "metadata": {},
   "source": [
    "> ✍️ Stocker un message de type \"La moyenne de la liste ma_liste est ...\" dans une variable en utilisant le string substitution. Afficher ensuite cette variable avec un print."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7eede93",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}