{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ed3c16da",
   "metadata": {},
   "source": [
    "# Découverte des listes et des tuples\n",
    "\n",
    "## Mise en situation\n",
    "\n",
    "On souhaite écrire un programme qui fait une moyenne de notes.\n",
    "\n",
    "1. Écrire une fonction `moyenne3` qui prend en argument 3 notes et qui renvoie la moyenne de ces trois notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "352fd339",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tests\n",
    "assert moyenne3(1, 2, 3) == 2\n",
    "assert moyenne3(10, 0, 5) == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddd2db52",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e58998e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "97396105",
   "metadata": {},
   "source": [
    "2. Écrire une fonction `moyenne_question` qui prend en argument un nombre de notes puis renvoie la moyenne des notes entrée par l'utilisateur (avec input)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dd1cb77",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pas de tests à cause de l'utilisation du input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "572a9917",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af965cbe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "91486d89",
   "metadata": {},
   "source": [
    "3. On voudrait maintenant écrire une fonction qui prend en argument plusieurs notes (qu'on ne connait pas à l'avance) et qui renvoie la moyenne de ces notes. Quels sont les obstacles qui empêchent de réaliser une telle fonction?"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ac18a2ae",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "28501a12",
   "metadata": {},
   "source": [
    "## Les listes\n",
    "\n",
    "Les `list` sont un autre type de variable (au même titre que les `int`, `float`...). Ils ont la particularité de stocker un nombre arbitraire de variables. En voici des exemples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c8dd096",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste1 = [1, 2, 3, 4, 5]\n",
    "liste2 = [\"a\", \"c\" \"uio\", \"éé\"]\n",
    "liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28c340b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(liste1)\n",
    "print(liste2)\n",
    "print(liste3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dd742c8",
   "metadata": {},
   "source": [
    "### Accéder à un élément de liste\n",
    "\n",
    "Pour accéder à un élément particulier d'une liste, on utilise les crochets`[]`.\n",
    "\n",
    "1. Deviner ce qui va être afficher par les commandes ci-dessous avant de l'exécuter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87fc0d29",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(liste1[3])\n",
    "print(liste2[2])\n",
    "print(liste3[0])\n",
    "print(liste1[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61cb8afe",
   "metadata": {},
   "source": [
    "2. Écrire les commandes pour accéder au nombre 2 de la liste1, \"éé\" de la liste2 et \"uio\" de la liste3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f11b02a8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cadb6818",
   "metadata": {},
   "source": [
    "3. Que se passe-t-il quand on essayer d'accéder à une valeur qui n'existe pas?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37903285",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "id": "9a0e4586",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "da97681e",
   "metadata": {},
   "source": [
    "4. On peut aussi modifier un élément d'une liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f594935a",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste1[1] = \"azert\"\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd595043",
   "metadata": {},
   "source": [
    "5. Construire une liste avec les nombres pairs inférieur à 10. Puis modifier la pour que les multiples de 4 soient remplacés par \"a\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4677cbb0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f08d4c53",
   "metadata": {},
   "source": [
    "### Ajouter/supprimer des éléments\n",
    "\n",
    "Pour ajouter des éléments, on utilise la méthode `.append(...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff4e90a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"]\n",
    "print(liste3)\n",
    "liste3.append(\"nsi\")\n",
    "print(liste3)\n",
    "liste3.append(\"azert\")\n",
    "print(liste3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a0f012c",
   "metadata": {},
   "source": [
    "1. Écrire une fonction `table` qui prend en argument un nombre `a` et une longueure `n` et qui renvoie les multiples de a de 0 à a*n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59a55bc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testes\n",
    "assert table(2, 10) == [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
    "assert table(3, 5) == [0, 3, 6, 9, 12, 15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69fb46d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04e04b5d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "36258d27",
   "metadata": {},
   "source": [
    "Pour enlever un élément, on utilise la méthode `.remove(...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "549a996d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, 2.2, 'uio', 10, 100, 10]\n",
      "[-1, 2.2, 10, 100, 10]\n",
      "[-1, 2.2, 100, 10]\n"
     ]
    }
   ],
   "source": [
    "liste3 = [-1, 2.2, \"uio\", 10, 100, 10]\n",
    "print(liste3)\n",
    "liste3.remove(\"uio\")\n",
    "print(liste3)\n",
    "liste3.remove(10)\n",
    "print(liste3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bc67d3c",
   "metadata": {},
   "source": [
    "### Longueur d'une liste\n",
    "\n",
    "Pour mesurer la longueur d'une liste, on utilise la fonction `len(...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9c809de2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "liste1 = [1, 2, 3, 4, 5]\n",
    "print(len(liste1))\n",
    "liste2 = [\"a\", \"c\" \"uio\", \"éé\"]\n",
    "print(len(liste2))\n",
    "liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"] \n",
    "print(len(liste3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88060355",
   "metadata": {},
   "source": [
    "1. Écrire une fonction `somme` qui prend en argument une liste de nombres et qui renvoie la somme des nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19510eb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert somme([1, 2, 3]) == 6\n",
    "assert somme([1]) == 1\n",
    "assert somme([1, 5, 10, 0, 4]) == 20\n",
    "assert somme([1.2, 1, 1.5]) == 3.7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "38c79fed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4cd9cbf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3e7e0a3a",
   "metadata": {},
   "source": [
    "2. Écrire une fonction `moyenne` qui prend en argument une liste de nombres et qui renvoie la moyenne de ces nombres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e83df22f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert moyenne([1, 2, 3]) == 2\n",
    "assert moyenne([1]) = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "750b4e2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35efeef8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9bff74a3",
   "metadata": {},
   "source": [
    "### Boucle for sur une liste\n",
    "\n",
    "Il est possible de faire une boucle `for` sur les éléments d'une liste.\n",
    "\n",
    "Par exemple, la fonction `moyenne` précédement rédigée peut être réécrite de la manière suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c93f43d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne(notes:list)->float:\n",
    "    \"\"\"Calculer la moyenne des notes de la liste\"\"\"\n",
    "    total = 0\n",
    "    for note in notes:\n",
    "        total = total + note\n",
    "    return total / len(notes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53c180b6",
   "metadata": {},
   "source": [
    "1. Ecrire une fonction `somme` qui prend en argument une liste de nombres et qui renvoie la somme de ces nombres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f956b1ec",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4ec924e6",
   "metadata": {},
   "source": [
    "2. Ecrire une fonction `multiplie` qui prend en argument un nombre et une liste de nombres et qui renvoie la liste des nombres multipliées par l'autre nombre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c90251a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#tests\n",
    "assert multiplie(2, [1, 2, 3]) == [2, 4, 6]\n",
    "assert multiplie(0, [1, 3, 6]) == [0, 0, 0]\n",
    "assert multiplie(-1, [1, 10, 100, -1]) == [-1, -10, -100, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "81f3ebdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fonction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd7c1976",
   "metadata": {},
   "source": [
    "3. Ecrire une fonction `filtre_impaire` qui prendre en argument une liste de nombres et qui renvoie une liste contenant uniquement les nombres impaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b484693e",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'filtre_impaire' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [6]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m#tests\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[43mfiltre_impaire\u001b[49m([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m]) \u001b[38;5;241m==\u001b[39m [\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m5\u001b[39m]\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m filtre_impaire([\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m4\u001b[39m]) \u001b[38;5;241m==\u001b[39m []\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m filtre_impaire([]) \u001b[38;5;241m==\u001b[39m []\n",
      "\u001b[0;31mNameError\u001b[0m: name 'filtre_impaire' is not defined"
     ]
    }
   ],
   "source": [
    "#tests\n",
    "assert filtre_impaire([1, 2, 3, 4, 5]) == [1, 3, 5]\n",
    "assert filtre_impaire([2, 4]) == []\n",
    "assert filtre_impaire([]) == []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c43261b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fonctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc069c83",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}