Listes_1dimension.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les listes - partie 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Définition :</u> Les listes sont des structures ordonnées de données. Les éléments d'une liste sont donnés entre crochets, séparés par des virgules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L=[12,'toto',False,3.14]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque 1 : les données peuvent être de types différents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque 2 : dans ce notebook, on ne s'intéresse qu'aux listes à \"1 dimension\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Construire les listes et accéder à leurs éléments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créer une liste contenant des éléments :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses=['fromage','pain','chocolat']\n",
    "print(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créer une liste vide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste=[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rajouter un élément à une liste existante : méthode **append()**\n",
    "<br> L'élément est rajouté en fin de liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses.append('yaourts')\n",
    "print(courses)\n",
    "liste.append('élément')\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Récupérer la taille de la liste : méthode **len()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"La liste course contient \",len(courses),\" élément(s).\")\n",
    "print(\"La liste liste contient \",len(liste),\" élément(s).\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accéder à un élément à l'aide de son indice :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(courses[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : on peut utiliser des indices négatifs ; cela revient à partir de la fin de la liste.<br>\n",
    "Attention : le dernier élément correspond à l'indice - 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(courses[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Récupérer l'indice d'un élément avec la méthode **index()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('pain a pour indice ',courses.index('pain'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarques : \n",
    "<br> **index()** retourne le premier indice correspondant à l'élément.\n",
    "<br> Si l'élément n'est pas dans la liste, le système génère une erreur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses.index('fruits')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parcourir les éléments d'une liste (si on n'a pas besoin de leur indice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for aliment in courses :\n",
    "    print(aliment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : on utilise ici le mot clé **in** qui permet de savoir si un élément est dans une liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C1=['camembert','fromage']\n",
    "for aliment in C1 :\n",
    "    if aliment in courses :\n",
    "        print(\"je vais acheter du \",aliment)\n",
    "    else :\n",
    "        print(\"je ne vais pas acheter de \",aliment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice 1 : Calculer la moyenne brute puis la moyenne pondérée de la liste de notes (sur 20) avec la liste des coefficients correspondants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "notes=[10,8,14,7,12,5,13]\n",
    "coefs=[2,1,1,4,2,1,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Modifier des listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insérer un élément : méthode **insert(indice,élément)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses.insert(2,'biscuits')\n",
    "print(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter une liste avec les éléments d'une autre liste : **extend()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses.extend(C1)\n",
    "print(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concaténer deux listes avec l'opérateur **+** : cela ne modifie aucune des listes d'origine mais crée une nouvelle liste contenant les éléments de la première liste suivis des éléments de la deuxième."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C3 = C1+courses+C1\n",
    "print(C3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compter le nombre d'occurences d'une valeur : méthode **count()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C3.count('fromage')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enlever un élément par sa valeur : méthode **remove()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courses.remove('pain')\n",
    "print(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enlever un élément par son indice : méthode **del**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(courses[0])\n",
    "print(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention : L=[] ne vide pas la liste L si elle a déjà été créée mais crée un nouvel objet liste vide.<br>\n",
    "Pour vider une liste L existante : **del(L[:])**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supprimer et récupérer le dernier élément de la liste : **pop()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('le dernier élément de la liste de courses est ',courses.pop())\n",
    "print('et maintenant il a disparu :',courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice 2 : supprimer les doublons dans la liste C3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Méthodes avancées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a. Compréhensions de liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La **compréhension de liste** est une expression qui permet de construire une liste à partir de tout autre type itérable (liste, tuple, chaîne de caractères…). Le résultat obtenu est toujours une liste."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "exemple 1 : construction de la liste des carrés des entiers de 0 à 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carres=[n**2 for n in range(10)]\n",
    "print(carres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "exemple 2 : construction de la liste des multiples de 3 inférieurs à 100 non pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mult3=[n*3 for n in range(100//3) if n%2 != 0]\n",
    "print(mult3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice 3 : \n",
    "1. créer la liste des carrés des nombres entiers compris entre 1 et 30\n",
    "2. créer la liste des carrés qui sont la somme de deux carrés (on pourra penser à enlever les doublons ensuite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b. Comparaisons et conséquences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les méthodes **min()** et **max()** retournent les valeurs minimale et maximale d'une liste de valeurs numériques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"La note minimale est \",min(notes))\n",
    "print(\"Le coefficient maximum est \",max(coefs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice 4 : recalculer les moyennes brute et pondérée en enlevant les notes minimale et maximale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tri d'une liste : la méthode **sort()** permet de trier une liste en place. Elle fonctionne pour des listes numériques mais aussi pour des listes de chaînes de caractères.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aTrier1=[2,1,5,3,9,6]\n",
    "aTrier2=['toto','tata','tutu','titi','turlututu']\n",
    "aTrier1.sort()\n",
    "aTrier2.sort()\n",
    "print(aTrier1)\n",
    "print(aTrier2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : Les méthodes **min()** et **max()** fonctionnent aussi sur des listes de chaînes de caractères. Par contre, elles ne fonctionnent pas sur des listes mixtes mélangeant des valeurs numériques et des chaînes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(min(aTrier2))\n",
    "print(max(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c. Chaînes de caractères et listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transformer une chaîne de caractères en liste de caractères : méthode **list()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=\"Bonjour, comment ça va ?\"\n",
    "print(list(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transformer une chaîne de caractères en liste de mots : méthode **split()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : par défaut, c'est l'espace qui sert de séparateur entre les mots. On peut passer en argument de la méthode **split()** un autre caractère de séparation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s.split(','))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour transformer une liste en chaîne de caractères, on peut utiliser la méthode **join()** précédé du caractère de séparation des éléments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "codeAscii=[chr(i+32) for i in range(128-32)]\n",
    "lettres=\",\".join(codeAscii)\n",
    "print(lettres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice 5 :\n",
    "1. Créer une chaîne de caractères nommée *phrase* contenant une phrase assez longue.\n",
    "2. Créer une liste nommée *voyelles* contenant toutes les voyelles de l'alphabet.\n",
    "3. Transformer *phrase* en liste de caractères et enlever les voyelles.\n",
    "4. Reconstituer et afficher la chaîne de caractères ainsi obtenue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode **reverse()** permet d'inverser en place les éléments d'une liste. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(courses)\n",
    "courses.reverse()\n",
    "print(courses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice 6 :\n",
    "<br>Un palindrome est un mot qui peut se lire dans les deux sens. \n",
    "Exemple : LAVAL est un palindrome mais RENNES n'est pas un palindrome.\n",
    "<br>Construire une fonction qui retourne **True** si le mot passé en argument est un palindrome et **False** sinon.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Les slices** : ils permettent de récupérer une partie de la liste.\n",
    "<br> L[n:p] retourne la liste des éléments numérotés de n à p-1\n",
    "<br> L[:p] retourne la liste des éléments numérotés de 0 à p-1\n",
    "<br> L[p:] retourne la liste de tous les éléments à partir du p-ième"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [10*i for i in range(10)]\n",
    "print(L)\n",
    "print(L[3:7])\n",
    "print(L[:4])\n",
    "print(L[5:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention : on crée une copie "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[1:4].remove(30)\n",
    "print(L[1:4])\n",
    "L2=L[1:4]\n",
    "L2.remove(30)\n",
    "print(L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice 6 bis : construire une nouvelle fonction qui retourne **True** si le mot passé en argument est un palindrome et **False** sinon en utilisant les slices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Enigme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "« Chargé d'organiser la défense de la Galilée, Flavius Josèphe se retrouva pris dans le siège de la ville de Jotapata par l'empereur romain Vespasien en l'an 67. Il dut se retirer en cachette dans une caverne qui abritait déjà 40 nobles de la ville.<br>\n",
    "Retrouvé par les troupes romaines, il fut pressé de quitter sa retraite et on lui promit la vie sauve. Alors qu'il s'apprêtait à se rendre, ses nobles compagnons d'infortune lui rappelèrent qu'il était leur chef et qu'ils préféraient la mort avec lui au déshonneur de la reddition.<br>\n",
    "Cependant décidé à ne pas perdre la vie, Flavius leur aurait proposé le macabre dénouement suivant : après avoir choisi la personne numéro 1, tout le monde se disposerait en cercle (41 personnes en tout) . Puis, on commencerait à compter, à partir du numéro 1. Toutes les 3 positions, la personne désignée devrait mourir, de la main de la personne désignée juste après elle, évitant ainsi que chacun commette un suicide, jugé alors plus grave qu'un meurtre. Le dernier survivant devrait cependant se donner la mort lui-même ».<br>\n",
    "Le problème : <br>\n",
    "à quelle place devrait se positionner Flavius pour être le dernier survivant ?<br>\n",
    "Historiquement, Flavius était l'avant dernier survivant et a négocié avec le dernier pour se rendre tous les deux. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}