{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# 2A.eco - Rappel de ce que vous savez d\u00e9j\u00e0 mais avez peut-\u00eatre oubli\u00e9\n", "\n", "[pandas](http://pandas.pydata.org/) et [numpy](http://www.numpy.org/) sont essentiels pour manipuler les donn\u00e9es. C'est ce que rappelle ce notebook. Voir aussi [Essential Cheat Sheets for Machine Learning and Deep Learning Engineers](https://startupsventurecapital.com/essential-cheat-sheets-for-machine-learning-and-deep-learning-researchers-efb6a8ebd2e5)."]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["
run previous cell, wait for 2 seconds
\n", ""], "text/plain": [""]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Les quelques r\u00e8gles de Python\n", "\n", "Python est un peu susceptible et protocolaire, il y a quelques r\u00e8gles \u00e0 respecter : \n", "\n", "1) L'indentation est primordiale : un code mal indent\u00e9 ne fonctionne pas. \n", "L'indentation indique \u00e0 l'interpr\u00e9teur o\u00f9 se trouvent les s\u00e9parations entre des blocs d'instructions. Un peu comme des points dans un texte. \n", "Si les lignes ne sont pas bien align\u00e9es, l'interpr\u00e9teur ne sait plus \u00e0 quel bloc associer la ligne.\n", "\n", "2) On commence \u00e0 compter \u00e0 0. Ca peut paraitre bizarre mais c'est comme \u00e7a. Le premier \u00e9l\u00e9ment d'une liste est le 0-\u00e8me. \n", "\n", "3) Les marques de ponctuation sont importantes : \n", "- Pour une liste : []\n", "- Pour un dictionnaire : {}\n", "- Pour un tuple : ()\n", "- Pour s\u00e9parer des \u00e9l\u00e9ments : ,\n", "- Pour commenter un bout de code : #\n", "- Pour aller \u00e0 la ligne dans un bloc d'instructions : \\\n", "- Les majuscules et minuscules sont importantes\n", "- Par contre l'usage des ' ou des \" est indiff\u00e9rente. Il faut juste avoir les m\u00eames d\u00e9but et fin.\n", "- Pour documenter une fonction ou une classe \"\"\" documentation \"\"\" "]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Les outputs de Python : l'op\u00e9ration, le print et le return\n", "\n", "Quand Python r\u00e9alise des op\u00e9rations, il faut lui pr\u00e9ciser ce qu'il doit en faire : \n", "- est-ce qu'il doit juste faire l'op\u00e9ration,\n", "- afficher le r\u00e9sultat de l'op\u00e9ration, \n", "- cr\u00e9er un objet avec le r\u00e9sultat de l'op\u00e9ration ?\n", "\n", "\n", "Remarque : dans l'environnement Notebook, le dernier \u00e9lement d'une cellule est automatiquement affich\u00e9 (print), qu'on lui demande ou non de le faire. Ce n'est pas le cas dans un \u00e9diteur classique comme Spyder."]}, {"cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["5\n"]}], "source": ["# on calcule : dans le cas d'une op\u00e9ration par exemple une somme\n", "2+3 # Python calcule le r\u00e9sultat mais n'affiche rien dans la sortie\n", "\n", "# le print : on affiche\n", "\n", "print(2+3) # Python calcule et on lui demande juste de l'afficher\n", "# le r\u00e9sultat est en dessous du code"]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["2\n", "\n"]}], "source": ["# le print dans une fonction \n", "\n", "def addition_v1(a,b) : \n", " print(a+b)\n", "\n", "resultat_print = addition_v1(2,0) \n", "print(type(resultat_print))\n", "\n", "# dans la sortie on a l'affichage du r\u00e9sultat, car la sortie de la fonction est un print \n", "# en plus on lui demande quel est le type du r\u00e9sultat. Un print ne renvoie aucun type, ce n'est ni un num\u00e9rique,\n", "# ni une chaine de charact\u00e8res, le r\u00e9sultat d'un print n'est pas un format utilisable"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Le r\u00e9sultat de l'addition est affich\u00e9\n", "\n", "La fonction addition_v1 effectue un print\n", "\n", "Par contre, l'objet cr\u00e9e n'a pas de type, il n'est pas un chiffre, ce n'est qu'un affichage.\n", "\n", "Pour cr\u00e9er un objet avec le r\u00e9sultat de la fonction, il faut utiliser __return__"]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\n"]}], "source": ["# le return dans une fonction\n", "def addition_v2(a,b) : \n", " return a+b\n", "\n", "resultat_return = addition_v2(2,5) # \n", "print(type(resultat_return))\n", "## l\u00e0 on a bien un r\u00e9sultat qui est du type \"entier\""]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "Le r\u00e9sultat de addition_v2 n'est pas affich\u00e9 comme dans addition_v1\n", "\n", "Par contre, la fonction addition_v2 permet d'avoir un objet de type int, un entier donc."]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Type de base : variables, listes, dictionnaires ...\n", "\n", "Pyhon permet de manipuler diff\u00e9rents types de base\n", "\n", "On distingue deux types de variables : les immuables qui ne peuvent \u00eatre modifi\u00e9s et les modifiables\n", "\n", "### Les variables - types immuables\n", "\n", "Les variables immuables ne peuvent \u00eatre modifi\u00e9es\n", "\n", "- None : ce type est une convention de programmation pour dire que la valeur n'est pas calcul\u00e9e\n", "- bool : un bool\u00e9en\n", "- int : un entier\n", "- float : un r\u00e9el\n", "- str : une chaine de caract\u00e8res\n", "- tuple : un vecteur\n", "\n"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["3 3.3 exemple None (1, 2)\n"]}], "source": ["i = 3 # entier = type num\u00e9rique (type int)\n", "r = 3.3 # r\u00e9el = type num\u00e9rique (type float)\n", "s = \"exemple\" # cha\u00eene de caract\u00e8res = type str \n", "n = None # None signifie que la variable existe mais qu'elle ne contient rien\n", " # elle est souvent utilis\u00e9e pour signifier qu'il n'y a pas de r\u00e9sultat\n", "a = (1,2) # tuple\n", "\n", "print(i,r,s,n,a) "]}, {"cell_type": "markdown", "metadata": {}, "source": ["Si on essaie de changer le premier \u00e9l\u00e9ment de la chaine de caract\u00e8res __s__ on va avoir un peu de mal. \n", "\n", "Par exemple si on voulait mettre une majuscule \u00e0 \"exemple\", on aurait envie d'\u00e9crire que le premier \u00e9l\u00e9ment de la chaine s est \"E\" majuscule\n", "\n", "Mais Python ne va pas nous laisser faire, il nous dit que les objets \"chaine de caract\u00e8re\" ne peuvent \u00eatre modifi\u00e9s"]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [{"ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "error", "traceback": ["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"E\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"]}], "source": ["s[0] = \"E\" # d\u00e9clenche une exception"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Tout ce qu'on peut faire avec une variable immutable, c'est le r\u00e9affecter \u00e0 une autre valeur : il ne peut pas \u00eatre modifi\u00e9\n", "\n", "Pour s'en convaincre, utilisons la fonction id() qui donne un identifiant \u00e0 chaque objet."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["exemple\n"]}, {"data": {"text/plain": ["2287124957368"]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}], "source": ["print(s)\n", "id(s)"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"text/plain": ["2287124971312"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["s = \"autre_mot\"\n", "id(s)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["On voit bien que s a chang\u00e9 d'identifiant : il peut avoir le m\u00eame nom, ce n'est plus le m\u00eame objet"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Les variables - types modifiable : listes et dictionnaires\n", "\n", "Heureusement, il existe des variables modifiables comme les listes et les dictionnaires. \n", "\n", "#### Les listes - elles s''\u00e9crivent entre [ ]\n", "\n", "\n", "Les listes sont des \u00e9lements tr\u00e8s utiles, notamment quand vous souhaitez faire des boucles\n", "\n", "Pour faire appel aux \u00e9lements d'une liste, on donne leur position dans la liste : le 1er est le 0, le 2\u00e8me est le 1 ..."]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["La longueur de ma liste est de 4\n", "Le premier \u00e9l\u00e9ment de ma liste est : 1\n", "Le dernier \u00e9l\u00e9ment de ma liste est : 4\n", "Le dernier \u00e9l\u00e9ment de ma liste est : 4\n"]}], "source": ["ma_liste = [1,2,3,4]\n", "\n", "\n", "print(\"La longueur de ma liste est de\", len(ma_liste))\n", "\n", "print(\"Le premier \u00e9l\u00e9ment de ma liste est :\", ma_liste[0])\n", "\n", "print(\"Le dernier \u00e9l\u00e9ment de ma liste est :\", ma_liste[3])\n", "print(\"Le dernier \u00e9l\u00e9ment de ma liste est :\", ma_liste[-1])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Les dictionnaires - ils s'\u00e9crivent entre { }\n", "Un dictionnaire associe \u00e0 une cl\u00e9 un autre \u00e9l\u00e9ment, appel\u00e9 une valeur : un chiffre, un nom, une liste, un autre dictionnaire etc.\n", "\n", " - __Format d'un dictionnaire : {Cl\u00e9 : valeur}__\n", " "]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Dictionnaire avec des valeurs int\n", "\n", "On peut par exemple associer \u00e0 un nom, un nombre"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["{'Nicolas': 18, 'Pimprenelle': 15}\n"]}], "source": ["mon_dictionnaire_notes = { 'Nicolas' : 18 , 'Pimprenelle' : 15} \n", "# un dictionnaire qui \u00e0 chaque nom associe un nombre\n", "# \u00e0 Nicolas, on associe 18\n", "\n", "print(mon_dictionnaire_notes) "]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Dictionnaire avec des valeurs qui sont des listes"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Pour chaque cl\u00e9 d'un dictionnaire, il ne faut pas forc\u00e9ment garder la m\u00eame forme de valeur\n", "\n", "Dans l'exemple, la valeur de la cl\u00e9 \"Nicolas\" est une liste, alors que celle de \"Philou\" est une liste de liste"]}, {"cell_type": "code", "execution_count": 11, "metadata": {"collapsed": true}, "outputs": [], "source": ["mon_dictionnaire_loisirs = \\\n", "{ 'Nicolas' : ['Rugby','Pastis','Belote'] , \n", " 'Pimprenelle' : ['Gin Rami','Tisane','Tara Jarmon','Barcelone','Mickey Mouse'],\n", " 'Philou' : [['Maths','Jeux'],['Guillaume','Jeanne','Thimoth\u00e9e','Adrien']]}"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Pour acc\u00e9der \u00e0 un \u00e9l\u00e9ment du dictionnaire, on fait appel \u00e0 la cl\u00e9 et non plus \u00e0 la position, comme c'\u00e9tait le cas dans les listes"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["['Rugby', 'Pastis', 'Belote']\n"]}], "source": ["print(mon_dictionnaire_loisirs['Nicolas']) # on affiche une liste"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["[['Maths', 'Jeux'], ['Guillaume', 'Jeanne', 'Thimoth\u00e9e', 'Adrien']]\n"]}], "source": ["print(mon_dictionnaire_loisirs['Philou']) # on affiche une liste de listes"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Si on ne veut avoir que la premi\u00e8re liste des loisirs de Philou, on demande le premier \u00e9l\u00e9ment de la liste"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["['Maths', 'Jeux']\n"]}], "source": ["print(mon_dictionnaire_loisirs['Philou'][0]) # on affiche alors juste la premi\u00e8re liste"]}, {"cell_type": "markdown", "metadata": {}, "source": ["On peut aussi avoir des valeurs qui sont des int et des listes"]}, {"cell_type": "code", "execution_count": 15, "metadata": {"collapsed": true}, "outputs": [], "source": ["mon_dictionnaire_patchwork_good = \\\n", "{ 'Nicolas' : ['Rugby','Pastis','Belote'] ,\n", " 'Pimprenelle' : 18 }"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## A retenir \n", "\n", " \n", " - L'indentation du code est importante (4 espaces et pas une tabulation)\n", " - Une __liste__ est entre [] et on peut appeler les positions par leur place \n", " - Un __dictionnaire__, cl\u00e9 x valeur, s'\u00e9crit entre {} et on appelle un \u00e9l\u00e9ment en fonction de la cl\u00e9"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Questions pratiques : \n", "\n", " - Quelle est la position de 7 dans la liste suivante"]}, {"cell_type": "code", "execution_count": 16, "metadata": {"collapsed": true}, "outputs": [], "source": ["liste_nombres = [1,2,7,5,3]"]}, {"cell_type": "markdown", "metadata": {}, "source": ["- Combien de cl\u00e9s a ce dictionnaire ? "]}, {"cell_type": "code", "execution_count": 17, "metadata": {"collapsed": true}, "outputs": [], "source": [" dictionnaire_evangile = {\"Marc\" : \"Lion\", \"Matthieu\" : [\"Ange\",\"Homme ail\u00e9\"] , \n", " \"Jean\" : \"Aigle\" , \"Luc\" : \"Taureau\"}"]}, {"cell_type": "markdown", "metadata": {}, "source": ["- Que faut-il \u00e9crire pour obtenir \"Ange\" en r\u00e9sultat \u00e0 partir du dictionnaire_evangile ? "]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Objets : m\u00e9thodes et attributs\n", "\n", "Mainentant qu'on a vu quels objets existaient en Python, nous allons voir comment nous en servir."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Un petit d\u00e9tour pour bien comprendre : Un objet, c'est quoi ? \n", "\n", "Un objet a deux choses : des attributs et des m\u00e9thodes\n", "\n", " - Les attributs d\u00e9crivent sa structure interne : sa taille, sa forme (dont on ne va pas parler ici)\n", " - Les m\u00e9thodes sont des \"actions\" qui s'appliqueront \u00e0 l'objet"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Premiers exemples de m\u00e9thode\n", "\n", "Avec les \u00e9l\u00e9ments d\u00e9finis dans la partie 1 (les listes, les dictionnaires) on peut faire appel \u00e0 des m\u00e9thodes qui sont directement li\u00e9es \u00e0 ces objets.\n", "\n", "Les m\u00e9thodes, c'est un peu les actions de Python. "]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Une m\u00e9thode pour les listes \n", "\n", "Pour ajouter un item dans une liste : on va utiliser la m\u00e9thode _.append()_"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["['Nicolas', 'Michel', 'Bernard', 'Philippe']\n"]}], "source": ["ma_liste = [\"Nicolas\",\"Michel\",\"Bernard\"]\n", "\n", "ma_liste.append(\"Philippe\")\n", "\n", "print(ma_liste)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### Une m\u00e9thode pour les dictionnaires\n", "\n", "Pour connaitre l'ensemble des cl\u00e9s d'un dictionnaire, on appelle la m\u00e9thode _.keys()_"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["dict_keys(['Matthieu', 'Jean', 'Marc', 'Luc'])\n"]}], "source": ["mon_dictionnaire = {\"Marc\" : \"Lion\", \"Matthieu\" : [\"Ange\",\"Homme ail\u00e9\"] , \n", " \"Jean\" : \"Aigle\" , \"Luc\" : \"Taureau\"}\n", "\n", "print(mon_dictionnaire.keys())"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Connaitre les m\u00e9thodes d'un objet\n", "\n", "Pour savoir quelles sont les m\u00e9thodes d'un objet vous pouvez : \n", " - taper help(mon_objet) ou mon_objet? dans la console iPython\n", " - taper mon_objet. + touche tabulation dans la console iPython ou dans le notebook . iPython permet la compl\u00e9tion, c'est-\u00e0-dire que vous pouvez faire appa\u00eetre la liste"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Les op\u00e9rations et m\u00e9thodes classiques des listes"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Cr\u00e9er une liste\n", "\n", "Pour cr\u00e9er un objet de la classe list, il suffit de le d\u00e9clarer. Ici on affecte \u00e0 __x__ une liste"]}, {"cell_type": "code", "execution_count": 20, "metadata": {"collapsed": true}, "outputs": [], "source": ["x = [4, 5] # cr\u00e9ation d\u2019une liste compos\u00e9e de deux entiers\n", "x = [\"un\", 1, \"deux\", 2] # cr\u00e9ation d\u2019une liste compos\u00e9e de 2 cha\u00eenes de caract\u00e8res\n", "# et de deux entiers, l\u2019ordre d\u2019\u00e9criture est important\n", "x = [3] # cr\u00e9ation d\u2019une liste d\u2019un \u00e9l\u00e9ment, sans la virgule,\n", "x = [ ] # cr\u00e9e une liste vide\n", "x = list () # cr\u00e9e une liste vide"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Un premier test sur les listes\n", "\n", "Si on veut tester la pr\u00e9sence d'un \u00e9l\u00e9ment dans une liste, on l'\u00e9crit de la mani\u00e8re suivante : "]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["True\n"]}], "source": ["# Exemple \n", "\n", "x = \"Marcel\"\n", "\n", "l = [\"Marcel\",\"Edith\",\"Maurice\",\"Jean\"]\n", "\n", "print(x in l)\n", "\n", "#vrai si x est un des \u00e9l\u00e9ments de l"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Pour concat\u00e9ner deux listes : \n", "On utilise le symbole +"]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["['Marcel', 'Edith', 'Maurice', 'Jean', 'Antoine', 'David']\n"]}], "source": ["t = [\"Antoine\",\"David\"]\n", "print(l + t) #concat\u00e9nation de l et t"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Pour trouver certains \u00e9l\u00e9ments d'une liste\n", "Pour chercher des \u00e9lements dans une liste, on utilise la position dans la liste. "]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [{"data": {"text/plain": ["'Edith'"]}, "execution_count": 24, "metadata": {}, "output_type": "execute_result"}], "source": ["l[1] # donne l'\u00e9l\u00e9ment qui est en 2\u00e8me position de la liste"]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [{"data": {"text/plain": ["['Edith', 'Maurice']"]}, "execution_count": 25, "metadata": {}, "output_type": "execute_result"}], "source": ["l[1:3] # donne les \u00e9l\u00e9ments de la 2\u00e8me position de la liste \u00e0 la 4\u00e8me exclue"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Quelques fonctions des listes"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["4 Edith Maurice\n"]}], "source": ["longueur = len(l) # nombre d\u2019\u00e9l\u00e9ments de l\n", "\n", "minimum = min(l) # plus petit \u00e9l\u00e9ment de l, ici par ordre alphab\u00e9tique\n", "\n", "maximum = max(l) # plus grand \u00e9l\u00e9ment de l, ici par ordre alphab\u00e9tique\n", "\n", "print(longueur,minimum,maximum)"]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["['Maurice', 'Jean']\n"]}], "source": ["del l[0 : 2] # supprime les \u00e9l\u00e9ments entre la position 0 et 2 exclue\n", "print(l)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Les m\u00e9thodes des listes\n", "\n", "On les trouve dans l'aide de la liste. On distingue les m\u00e9thodes et les m\u00e9thodes sp\u00e9ciales : visuellement, les m\u00e9thodes sp\u00e9ciales sont celles qui pr\u00e9c\u00e9d\u00e9es et suivis de deux caract\u00e8res de soulignement, les autres sont des m\u00e9thodes classiques.\n", "\n"]}, {"cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Help on list object:\n", "\n", "class list(object)\n", " | list() -> new empty list\n", " | list(iterable) -> new list initialized from iterable's items\n", " | \n", " | Methods defined here:\n", " | \n", " | __add__(self, value, /)\n", " | Return self+value.\n", " | \n", " | __contains__(self, key, /)\n", " | Return key in self.\n", " | \n", " | __delitem__(self, key, /)\n", " | Delete self[key].\n", " | \n", " | __eq__(self, value, /)\n", " | Return self==value.\n", " | \n", " | __ge__(self, value, /)\n", " | Return self>=value.\n", " | \n", " | __getattribute__(self, name, /)\n", " | Return getattr(self, name).\n", " | \n", " | __getitem__(...)\n", " | x.__getitem__(y) <==> x[y]\n", " | \n", " | __gt__(self, value, /)\n", " | Return self>value.\n", " | \n", " | __iadd__(self, value, /)\n", " | Implement self+=value.\n", " | \n", " | __imul__(self, value, /)\n", " | Implement self*=value.\n", " | \n", " | __init__(self, /, *args, **kwargs)\n", " | Initialize self. See help(type(self)) for accurate signature.\n", " | \n", " | __iter__(self, /)\n", " | Implement iter(self).\n", " | \n", " | __le__(self, value, /)\n", " | Return self<=value.\n", " | \n", " | __len__(self, /)\n", " | Return len(self).\n", " | \n", " | __lt__(self, value, /)\n", " | Return self None -- append object to end\n", " | \n", " | clear(...)\n", " | L.clear() -> None -- remove all items from L\n", " | \n", " | copy(...)\n", " | L.copy() -> list -- a shallow copy of L\n", " | \n", " | count(...)\n", " | L.count(value) -> integer -- return number of occurrences of value\n", " | \n", " | extend(...)\n", " | L.extend(iterable) -> None -- extend list by appending elements from the iterable\n", " | \n", " | index(...)\n", " | L.index(value, [start, [stop]]) -> integer -- return first index of value.\n", " | Raises ValueError if the value is not present.\n", " | \n", " | insert(...)\n", " | L.insert(index, object) -- insert object before index\n", " | \n", " | pop(...)\n", " | L.pop([index]) -> item -- remove and return item at index (default last).\n", " | Raises IndexError if list is empty or index is out of range.\n", " | \n", " | remove(...)\n", " | L.remove(value) -> None -- remove first occurrence of value.\n", " | Raises ValueError if the value is not present.\n", " | \n", " | reverse(...)\n", " | L.reverse() -- reverse *IN PLACE*\n", " | \n", " | sort(...)\n", " | L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data and other attributes defined here:\n", " | \n", " | __hash__ = None\n", "\n"]}], "source": ["help(l)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## A retenir et questions\n", "\n", "A retenir : \n", "\n", "- Chaque objet Python a des attributs et des m\u00e9thodes\n", "- Vous pouvez cr\u00e9er des classes avec des attributs et des m\u00e9thodes \n", "- Les m\u00e9thodes des listes et des dictionnaires sont les plus utilis\u00e9es : \n", " - list.count()\n", " - list.sort()\n", " - list.append()\n", " - dict.keys()\n", " - dict.items()\n", " - dict.values()\n", " \n", "------"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Questions pratiques : \n", "\n", " - D\u00e9finir la liste allant de 1 \u00e0 10, puis effectuez les actions suivantes :\n", " \n", " \u2013 triez et affichez la liste \n", " \u2013 ajoutez l\u2019\u00e9l\u00e9ment 11 \u00e0 la liste et affichez la liste \n", " \u2013 renversez et affichez la liste \n", " \u2013 affichez l\u2019indice de l\u2019\u00e9l\u00e9ment 7 \n", " \u2013 enlevez l\u2019\u00e9l\u00e9ment 9 et affichez la liste \n", " \u2013 affichez la sous-liste du 2e au 3e \u00e9l\u00e9ment ;\n", " \u2013 affichez la sous-liste du d\u00e9but au 2e \u00e9l\u00e9ment ;\n", " \u2013 affichez la sous-liste du 3e \u00e9l\u00e9ment \u00e0 la fin de la liste ;\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["- Construire le dictionnaire des 6 premiers mois de l'ann\u00e9e avec comme valeurs le nombre de jours respectif. \n", "\n", " - Renvoyer la liste des mois. \n", " - Renvoyer la liste des jours.\n", " - Ajouez la cl\u00e9 du mois de Juillet ?\n", " \n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Passer des listes, dictionnaires \u00e0 pandas"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Supposons que la variable 'data' est un liste qui contient nos donn\u00e9es. \n", "\n", "Une observation correspond \u00e0 un dictionnaire qui contient le nom, le type, l'ambiance et la note d'un restaurant. \n", "\n", "Il est ais\u00e9 de transformer cette liste en dataframe gr\u00e2ce \u00e0 la fonction 'DataFrame'."]}, {"cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["[{'type': 'Bar', 'ambiance': 9, 'note': 7, 'nom': 'Little Pub'}, {'type': 'Sandwicherie', 'ambiance': 2, 'note': 8, 'nom': 'Le Corse'}, {'type': 'Bar', 'ambiance': 1, 'nom': 'Caf\u00e9 Caumartin'}]\n"]}, {"data": {"text/html": ["
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ambiancenomnotetype
09Little Pub7.0Bar
12Le Corse8.0Sandwicherie
21Caf\u00e9 CaumartinNaNBar
\n", "
"], "text/plain": [" ambiance nom note type\n", "0 9 Little Pub 7.0 Bar\n", "1 2 Le Corse 8.0 Sandwicherie\n", "2 1 Caf\u00e9 Caumartin NaN Bar"]}, "execution_count": 29, "metadata": {}, "output_type": "execute_result"}], "source": ["import pandas \n", "\n", "data = [{\"nom\": \"Little Pub\", \"type\" : \"Bar\", \"ambiance\": 9, \"note\": 7},\n", " {\"nom\": \"Le Corse\", \"type\" : \"Sandwicherie\", \"ambiance\": 2, \"note\": 8},\n", " {\"nom\": \"Caf\u00e9 Caumartin\", \"type\" : \"Bar\", \"ambiance\": 1}]\n", "\n", "df = pandas.DataFrame(data)\n", "\n", "print(data)\n", "df"]}, {"cell_type": "code", "execution_count": 29, "metadata": {"collapsed": true}, "outputs": [], "source": []}], "metadata": {"anaconda-cloud": {}, "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.0"}}, "nbformat": 4, "nbformat_minor": 2}