lafrite
/
2018-2019
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
2018-2019/PreStSauveur/Programmation/Memo.ipynb

1003 lines
41 KiB
Plaintext
Raw Blame History

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Mémo Python\n",
"\n",
"[Python par Repl.it](#Avec-Repl.it)\n",
"\n",
"-----------\n",
"Notions de programmation\n",
"* [Les variables](#Les-variables)\n",
"* [input](#input)\n",
"* [Les conditions if](#Condition-if)\n",
"* [Les boucles for](#Boucles-for)\n",
"* [Les boucles while](#Boucles-while)\n",
"* [Les fonctions](#Fonctions)\n",
"* [Les listes](#Listes)\n",
"* [Les graphiques](#Graphiques)\n",
"------------\n",
"Ressouces Python\n",
"* [site du zero](http://openclassrooms.com/courses/apprenez-a-programmer-en-python) (cours en ligne)\n",
"* [codeacademy](http://www.codecademy.com/) (cours en ligne)\n",
"* [code conbat](http://codecombat.com) (jeu en ligne qui se joue en codant)\n",
"* [checkio](http://www.checkio.org/) (jeu en ligne - anglais - avec beaucoup de langage différents)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Avec Repl.it\n",
"\n",
"Se rendre sur le site de [repl.it](https://repl.it/repls/SpiffyOpulentBackend). \n",
"\n",
"L'interface se sépare en 2 parties:\n",
"\n",
"![interface replit](./fig/replit_global.png)\n",
"\n",
"- **Zone Script**: Éditeur de texte où l'on pourra écrire notre programme python. Pour executer son contenu, il faudra cliquer sur ![replit run](./fig/replit_run.png)\n",
"- **Zone Shell**: Line de commande pour interagir avec python. Ici vous pouvez tester vos commandes python et presser la touche *entrer* pour l'executer. Par contre on ne peut pas écrire sur plusieurs lignes.\n",
"\n",
"Il est conseillé d'utiliser en priorité la **zone script** car elle permet d'écrire sur plusieurs lignes et de corriger après l'execution. La **zone shell** servira à tester des commandes pour voir directement leurs effets. \n",
"\n",
"Pour sauvergarder votre travail, vous cliquerez sur les 3 points à côté de *Files* puis sur *download as zip*.\n",
"\n",
"![replit save](./fig/replit_files.png)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les variables\n",
"\n",
"Les variables sont des *enveloppes* où l'on stockera des nombres, des mots, des phrases ou des choses plus compliqués."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"un_nombre = 10"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ainsi dans *l'enveloppe* appelée **un_nombre** on y met le nombre 10.\n",
"\n",
"C'est ce que l'on appelle **assigner** une **valeur** à une variable ou **stocker** une valeur dans une variable."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10\n"
]
}
],
"source": [
"un_nombre = 10\n",
"print(un_nombre) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour stocker des mots ou des phrases, il faut les mettre entre guillemets"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"un_mot = \"Coucou\"\n",
"une_phrase = \"ceci est une phrase\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"## input\n",
"\n",
"Contrairement à ce que l'on a fait hier on ne met plus rien dans les parenthèses d'un `input`.\n",
"\n",
"`input()` est une commande qui va demander à l'utilisateur une information "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Comment t'appelles tu?\n",
"bobo\n",
"Ah! Tu t'appelles bobo\n"
]
}
],
"source": [
"print(\"Comment t'appelles tu?\")\n",
"nom = input()\n",
"print(\"Ah! Tu t'appelles\", nom)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Après avoir afficher la question, l'ordinateur se met en pose et attend que l'utilisateur réponde quelque chose. Une fois que l'utilisateur a répondu (a appuyé sur `entrer`) la réponse est stocké, ici, dans la variable `nom`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Condition if\n",
"\n",
"Pour différencier plusieurs cas, on utilisera la commande `if` (si), `elif` (sinon si) et `else` (sinon)."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a est plus petit que b\n"
]
}
],
"source": [
"a = 2\n",
"b = 3\n",
"\n",
"if a > b: # Si\n",
" print(\"a plus grand que b\")\n",
"elif a == b: # Sinon si\n",
" print(\"a est égal à b\")\n",
"else: # Sinon\n",
" print(\"a est plus petit que b\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Boucles for\n",
"\n",
"Les boucles **for** permettent de répéter un certain nombre de fois la même action.\n",
"\n",
"* Générer plusieurs valeurs:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n",
"7\n",
"8\n",
"9\n"
]
}
],
"source": [
"for x in range(10):\n",
" print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python a créé une variable `x` puis lui a fait prendre toutes les valeurs entre 0 et 9.\n",
"\n",
"* Ajouter 5 fois 100 d'affilé"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Au debut a vaut 2\n",
"a vaut maintenant 102\n",
"a vaut maintenant 202\n",
"a vaut maintenant 302\n",
"a vaut maintenant 402\n",
"a vaut maintenant 502\n",
"Finalement a vaut 502\n"
]
}
],
"source": [
"a = 2\n",
"print(\"Au debut a vaut\", a)\n",
"for i in range(5):\n",
" a = a + 100\n",
" print(\"a vaut maintenant\", a)\n",
"print(\"Finalement a vaut\", a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* On peut aussi parcourir les lettres d'un mot ou d'une phrase"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"On enumere >>> boujour toi\n",
"b\n",
"o\n",
"u\n",
"j\n",
"o\n",
"u\n",
"r\n",
" \n",
"t\n",
"o\n",
"i\n",
"Toutes les lettres ont été énumérées\n"
]
}
],
"source": [
"phrase = \"boujour toi\"\n",
"print(\"On enumere >>> \", phrase)\n",
"for l in phrase:\n",
" print(l)\n",
"print(\"Toutes les lettres ont été énumérées\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ou encore tous les éléments d'une liste"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"On enumère >>> ['premier element', 2, 'coucou', 1, 'aie', 0]\n",
"premier element\n",
"2\n",
"coucou\n",
"1\n",
"aie\n",
"0\n",
"Tout a été énuméré\n"
]
}
],
"source": [
"liste = [\"premier element\", 2, \"coucou\", 1, \"aie\", 0]\n",
"print(\"On enumère >>>\", liste)\n",
"for i in liste:\n",
" print(i)\n",
"print(\"Tout a été énuméré\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Boucles while\n",
"\n",
"En anglais, `while` signifie **tant que**. On l'utilisera quand on veut refaire quelque plusieurs fois **tant que** quelque chose n'est pas vrais.\n",
"\n",
"Ajouter 3 **tant que** que `u` n'a pas dépassé 19: "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"u vaut 5\n",
"u vaut 8\n",
"u vaut 11\n",
"u vaut 14\n",
"u vaut 17\n",
"u vaut 20\n",
"u a depassé 50 et vaut 20\n"
]
}
],
"source": [
"u = 2\n",
"while u < 19:\n",
" u = u + 3\n",
" print(\"u vaut \", u)\n",
"print(\"u a depassé 50 et vaut\", u)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Poser toujours la même question quand que l'utilisateur n'a pas bien répondu:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Quelle est la couleur du cheval blanc d'Henri 4?\n",
"vert\n",
"Non! Recommence!\n",
"Quelle est la couleur du cheval blanc d'Henri 4?\n",
"rouge\n",
"Non! Recommence!\n",
"Quelle est la couleur du cheval blanc d'Henri 4?\n",
"blanc\n",
"Bravo!\n",
"Voila tu as réussi!\n"
]
}
],
"source": [
"aPasTrouve = True # True signifie vrai en anglais.\n",
"while aPasTrouve:\n",
" print(\"Quelle est la couleur du cheval blanc d'Henri 4?\")\n",
" rep = input()\n",
" if rep == \"blanc\":\n",
" print(\"Bravo!\")\n",
" aPasTrouve = False # False signifie faux en anglais\n",
" else:\n",
" print(\"Non! Recommence!\")\n",
"print(\"Voila tu as réussi!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fonctions\n",
"\n",
"Une fonction est un morceau de programme qui évitera de coder plusieurs fois la même chose. Quand on programme on dit souvent `Si c'est la 3e fois que l'on écrit ces lignes c'est qu'il faut en faire une fonction`.\n",
"\n",
"Voici différentes utilisations de fonctions."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fonctions numériques\n",
"\n",
"En math, on utilise les fonctions pour décrire les transformations (de nombres le plus souvent). \n",
"\n",
"Par exemple:\n",
"$$ f:x \\mapsto 3x + 2$$\n",
"Cette fonction $f$ prend un nombre, le multiplie par 3 puis ajoute 2. On pourra la coder de la façon suivante:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"def f(x):\n",
" return 3*x+2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On vient de coder cette fonction, on peut ensuite l'utiliser"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"14\n",
"L'image de 2.5 par la fonction f est 9.5\n",
"f(-2) = -4\n"
]
}
],
"source": [
"print(f(4))\n",
"print(\"L'image de 2.5 par la fonction f est \", f(2.5))\n",
"print(\"f(-2) = \", f(-2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Au collège, on a vu les \"programmes de calculs\". Ils peuvent eux aussi être codé avec des fonctions.\n",
"\n",
"- Choisir un nombre\n",
"- Ajouter 5\n",
"- Diviser par 10\n",
"\n",
"Se code de la façon suivante:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def programme(nombre):\n",
" reponse = nombre + 5\n",
" reponse = reponse / 10\n",
" return reponse"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6.5\n"
]
}
],
"source": [
"print(programme(60))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### D'autres fonctions\n",
"\n",
"Les fonctions numériques sont très utilisées en math mais en programmation, on manipule beaucoup d'autres types de fonctions.\n",
"\n",
"On pourrait vouloir transformer un texte en un titre entouré de symboles `#`."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"def entoure(titre):\n",
" return '##### ' + titre + ' #####'"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"##### Mon titre #####\n",
"##### L'histoire du petit chaperon rouge #####\n",
"##### Fin #####\n"
]
}
],
"source": [
"print(entoure('Mon titre'))\n",
"print(entoure(\"L'histoire du petit chaperon rouge\"))\n",
"print(entoure('Fin'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut même mettre un autre argument (en plus de `titre`) pour entourer avec autre chose que `#`."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"def entoure(texte, symbole):\n",
" return symbole*4 + ' ' + texte + ' ' + symbole*4"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"---- La belle au bois dormant ----\n"
]
}
],
"source": [
"print(entoure('La belle au bois dormant', '-'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Listes"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"L = [5, 2, 1, 2, 4, 5, 5]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `max`: valeur maximal de la liste"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n"
]
}
],
"source": [
"print(max(L))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `min`: valeur minimal de la liste "
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n"
]
}
],
"source": [
"print(min(L))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `len`: calculer le nombre d'éléments dans la liste"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n"
]
}
],
"source": [
"print(len(L))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `sum`: calculer la somme des éléments de la liste"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"24\n"
]
}
],
"source": [
"print(sum(L))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `sorted`: trier les éléments de la liste"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 2, 4, 5, 5, 5]\n"
]
}
],
"source": [
"print(sorted(L))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Récupérer le i-ième élément de la liste (**/!\\ on commence à compter à partir de 0**)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"1\n"
]
}
],
"source": [
"# Le premier élément de la liste\n",
"print(L[0])\n",
"# le 3e élément de la liste\n",
"print(L[2])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Compter l'effectif d'une valeur"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"L.count(2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Faire une boucle sur tous les éléments de la liste"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"2\n",
"1\n",
"2\n",
"4\n",
"5\n",
"5\n"
]
}
],
"source": [
"for x in L:\n",
" print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Graphiques\n",
"\n",
"Pour faire des graphiques, il faut que la ligne suivante fasse partie des premières lignes de votre programme."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ensuite, on définit les abscisses et les ordonnées sous forme de listes (il faut que les 2 listes aient le même nombre d'éléments)."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"abscisses = [1, 2, 3, 4, 5, 6]\n",
"ordonnees = [4, 10, 1, -3, 6, 0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut tracer une courbe:"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f0ad9c090b8>]"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD8CAYAAABjAo9vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl0FIeVLvDvakELCLFIAiEBktgxYIPFLnnDG5jYHuN4BWNbOj5nTiaTvPfGDnacl8mbTOyxk0xmkowTIuGNxQvgeI+3eJHYxb4b0M6mZl+FkHTfH92NGwFSS13V1VX1/c7hIIl21VWMvxQfdbtEVUFERM4RZfUARERkLAY7EZHDMNiJiByGwU5E5DAMdiIih2GwExE5DIOdiMhhGOxERA7DYCcicpgYK06akpKiWVlZVpyaiMi21q5de0hVU9t6nSXBnpWVhbKyMitOTURkWyJSFczrWMUQETkMg52IyGEY7EREDsNgJyJyGAY7EZHDBB3sIjJPROpEZEvA13qIyGcissv3c3dzxiQiomC154r9FQC3t/jaHABfqOogAF/4PiciIgsFHeyq+g2AIy2+fBeAV30fvwrgboPmIp8te4+jrLLl/+xERFcWasfeS1X3+z4+AKDXlV4oIk+ISJmIlHk8nhBP6w4HT9Tjob+sxOOvrMHpc41Wj0NENmHYX56q96nYV3wytqrOVdVcVc1NTW1zI9b1VBVPL92Ms+ebcKK+EUvW1Vo9EhHZRKjBflBE0gHA93Nd6CMRACxdtxd/31GHOVOHYXS/bphXWoGm5iv+/yYR0QWhBvt7AGb7Pp4N4N0Qj0fwVjC/eH8rxmZ1x2OTslCYl4PKw2fwxfaDVo9GRDbQntsdFwFYAWCIiNSKSAGA5wHcIiK7ANzs+5xC4K9gGpqa8cK9VyMqSnDbVb2Q0S0BRaUVVo9HRDYQ9Ls7quqDV/ilKQbNQgCW+CqYn00fjuyUzgCAmOgoPDY5C7/8cDs21R7DqMxuFk9JRJGMm6cR5MDxiyuYQPeP7YsucTEo5lU7EbWBwR4hVBXPvLMZ55ua8aKvggmUFB+L+8f2xYeb9mPfsbMWTUlEdsBgjxD+Cuap24Yiy1fBtPTopCw0q+LVFZVhnY2I7IXBHgH8Fcy4rB54tEUFE6hvj0RMHZGORauqubBERFfEYLeY9y6YTTjf1IwX7h11SQXTUkF+Nk7UN2LxWi4sEdHlMdgttnhtLb7c6Wm1ggk0pl93jOnXDfOWcWGJiC6PwW6hA8fr8f8+2NZmBdNSYX4Oqg6fwedcWCKiy2CwW6S9FUygW4d7F5aKS3jrIxFdisFuEX8F85Pbg6tgAvkXllZXHsHGmmMmTUhEdsVgt0BgBTN7YlaHjsGFJSK6EgZ7mKkq5nSwggmUFB+LB8b2xYebubBERBdjsIfZ4rW1+KqDFUxLj07OgnJhiYhaYLCH0YUKJrvjFUygzO6JmDoyHQu5sEREARjsYeKvYBqbFC+GUMG0VJiXjZP1jXi7rMaQ4xGR/THYw+TtCxXMEPTvGVoFE2h0v+64tn93zFtWyYUlIgLAYA+L/cfP4t/e91YwjxhQwbRUkJeN6iNn8Nk2LiwREYPddKqKOUs2o7HZ2Aom0K3DeyGzewKKS8sNPzYR2Q+D3WRvr63F198aX8EE8i4sZWNN5VFs4MISkesx2E3kr2DGm1TBBLovNxNJXFgiIjDYTRNYwYSyiBSspPhYPDCuLz7iwhKR6zHYTfJ2mfkVTEuzfe8Q+eryyrCcj4gikyHBLiL/S0S2isgWEVkkIvFGHNeu9h07i3/7IDwVTKDM7omYOqI3Fq6uxikuLBG5VsjBLiIZAP4ZQK6qjgAQDeCBUI9rV9634/XfBXPpQ6nNVsCFJSLXM6qKiQGQICIxABIB7DPouLbjr2DmTB2Kfj0Tw37+7xaW+IQlIrcKOdhVdS+AXwOoBrAfwHFV/TTU49qRv4KZkNMDsyb0t2yOwrxs1Bw5i8+2HbBsBiKyjhFVTHcAdwHIBtAHQGcRmXmZ1z0hImUiUubxeEI9bcTxvheM7y6YGeGvYALdelVv9O2RgCI+YYnIlYyoYm4GUKGqHlU9D2ApgEktX6Sqc1U1V1VzU1NTDThtZHmrrAbfWFjBBIqOEjw2KRtlVVxYInIjI4K9GsAEEUkUEQEwBcB2A45rG/uOncUvP9hueQUT6L6xfbmwRORSRnTsqwAsBrAOwGbfMeeGely78FcwTWp9BROoS1wMHhzfDx9t3o+9XFgichVD7opR1Z+r6lBVHaGqs1T1nBHHtYNIqmBa4sISkTtx8zQEgRXMzPGRUcEEyuiWgKkjemPRKi4sEbkJg72DIrWCaakwPwcnzzXirTVcWCJyCwZ7B725JnIrmEDX9O2GXC4sEbkKg70D9h47i19+GLkVTEuF+dmoPXoWn27lwhKRGzDY28n/XjDNas17wXTELcN9C0u89ZHIFRjs7eSvYJ6eOhR9e0RuBRMoOkrw+ORsrK06ivXVR60eh4hMxmBvB38FMzGnJx62QQUT6Pu5fZEUz4UlIjdgsAfJ+0SkTWjW8DwRyWhd4mLw4Lh++HjLAdQePWP1OERkIgZ7kN5cU4OSXYdsVcG0xIUlIndgsAfBzhVMoIxuCZg2Mh1vrK7ByfrzVo9DRCZhsLfB7hVMSwV52d6FpbJaq0chIpMw2Nvwhr+CmTbMthVMoGv6dsPYrO54eVkFGpuarR6HiEzAYG/F3mNn8e/+CmZcP6vHMUxBXo53YWnbQatHISITMNivwGkVTKBbhvdCvx6JvPWRyKEY7FfgtAomkHdhKQtrq45iHReWiByHwX4Z/gpm0gBnVTCBuLBE5FwM9hb8FYyq4j9mOKuCCdQ5LgYPjeuHjzfvR80RLiwROQmDvYVFq51bwbQ0e1IWRIQLS0QOw2APUHv0DP79w22YNKAnHnJoBROoT7cE3DEyHW+s4cISkZMw2H28FcxmAHB0BdNSYX42Tp1rxJt8whKRYzDYfRatrkHpbndUMIFGZXbDuKweeGV5JReWiBzCkGAXkW4islhEdojIdhGZaMRxw8VfwUwe2BMPj3d+BdNSgf8JS1xYInIEo67Y/wvA31R1KICrAWw36LimC6xgnr9nFETcUcEEunmYd2GpqKTc6lGIyAAhB7uIJAO4DkAxAKhqg6oeC/W44bJwdbUrK5hA/oWlddXHsLaKC0tEdmfEFXs2AA+Al0VkvYgUiUhnA45rutqjZ/CrD7e7toIJ5F9YmseFJQqDhsZm/PqTndhdd9LqURzJiGCPATAGwEuqOhrAaQBzWr5IRJ4QkTIRKfN4PAacNjQt74JxYwUTqHNcDB4a3w8fb+HCEpnvw8378Icvd+MHC9bjXGOT1eM4jhHBXgugVlVX+T5fDG/QX0RV56pqrqrmpqamGnDa0PgrmGfuGIbM7u6sYFp6dFIWokTwCheWyESqiqKSCvTo3Ak7D57E77/YbfVIjhNysKvqAQA1IjLE96UpALaFelwz1RzxVjB5A1NcsYgUrPTkBNwxKh1vcmGJTLSq4gi27juBJ28bgnuvzcRLX+/Bplrb/LWcLRh1V8wPASwQkU0ArgHwK4OOazhVxZylmwAAz88Y6foKpqWCPC4skbn8V+v/MDoDP5s+HCldOuFf3t7ISsZAhgS7qm7w1SyjVPVuVY3YWysWrq7Gst2HWcFcwajMbhiX3QMvL+PCEhmv3HMKX+w4iJkT+iM+NhrJCbF4/p5R+PbgKfz3F7usHs8xXLV5ygomOAV52dh77Cw+2cqFJTLWy8sqERsVhVkTvnso/I1D03DvtZn409flrGQM4ppg91cwIsIKpg03D+uF/j0TUVTKhSUyzrEzDXh7bQ3uHt0HqUlxF/3az6YPR2qXOFYyBnFNsC9Y5atgprGCaYt3YSkb67mwRAZasKoa9eebUZCXc8mvJSfE4rl7RrKSMYgrgr3myBk895G3gnlwXF+rx7GFe6/NRNf4GBTzqp0M0NDYjFeXVyJ/UAqG9E667GtYyRjH8cGuqvjJElYw7eVdWOqPv205wIUlCtkHm/ah7uQ5FORlt/o6VjLGcHywL1hVjeV7WMF0xOxJ/RElgpeXVVo9CtmYqqK4tAKD0rrg+sGtLycmJ8TiuRmsZELl6GD3VzD5g1jBdER6cgKmj0rHW2U1OMGFJeqgleXehaSCvOyg/sR845A0fJ+VTEgcG+zNzYEVDN8LpqMK8nJw6lwj3uLCEnVQcWk5enbuhLtHZwT9zzzLSiYkjg32Bau9FcxP7xiGjG4JVo9jWyMzk7mwRB1W7jmFz7fXXVhIClZgJfNfn7OSaS9HBntgBfPAWFYwoSr0LSz9besBq0chm5m3rAKdYqIwM2AhKVjfVTJ7sLGGlUx7OC7Ym5sVTy3ehChWMIaZMqwXsnom4i8lFVBVq8chmzh6ugGL19biH67JuGQhKVjPTh+OtKR4VjLt5LhgX7C6GivKWcEYKTpK8HheNjbWHMO6ai4sUXAWrvYuJD3exi2OrfFXMrvqWMm0h6OCnRWMee69NhPJCbEoKuETlqhtwSwkBevGIWm4L5eVTHs4JthZwZgrsZP3CUufbOXCErXNv5BUmH/p2wd0xLPTh6NXV28lU3+elUxbHBPsC1ZVYUX5YTzLCsY0sydmcWGJ2uR/QtKgtC64blCKIcfsGh+LX93jq2S4uNQmRwR7zZEzeO7jHcgflIL7WcGYpndyPKaPSseba6q5sERXtKL8MLbtP4HC/OAWkoLlr2T+zEqmTbYPdlYw4VWQl4PTDU14czUXlujyiksq0LNzJ9x1TfALScFiJRMc2wc7K5jwGpmZjPHZPfDysgouLNEl9nhO4YsddZg1sX0LScHqGh+L52eMYiXTBlsHu7+CuW5wKiuYMCrMz8G+4/X4eAsXluhi80o7vpAUrOsHp+L+3L7489d7sIGVzGXZNtibmxVPLt6IaBE8fw/fjjecpgxNQ1bPRBSVlHNhiS44eroBS9Z5F5JSunRsISlYP50+jJVMK2wb7AtWVWFl+RE8O30Y+rCCCauoKEFBXjY21h7nE5boAv9CUkF+xxeSguWvZHazkrksWwZ7YAVzXy4rGCvM4MISBTjX2IRXllfiusGpGNwrtIWkYLGSuTLDgl1EokVkvYh8YNQxL4cVTGRI7BSDh8f3w6fbDqD6MBeW3O6DjfvhOXkOhSG8fUBHsJK5PCOv2H8EYLuBx7us+axgIsYj/oWl5bxqdzNVRVFpBQb36oJ8gxaSghVYyfyO7yVzgSHBLiKZAO4AUGTE8a6k+vAZPPfRDlzPCiYi9E6Ox/eu7oO31tTg+FkuLLnVij2HsX3/CRTm5VjyJ2h/JTP3mz1YzzepA2DcFfvvADwF4Io3NovIEyJSJiJlHo+nQyf5zWc7ERMleI4VTMQoyMv2LiytqbZ6FLJIUWkFUrp0wp3X9LFsBn8l8+TiTaxkYECwi8h0AHWqura116nqXFXNVdXc1NTWH2h7Jb+8ewSKHx3LCiaCjMhIxoScHnhlWSXOc2HJdXbXncLfd7T/CUlGYyVzMSOu2CcDuFNEKgG8AeAmEZlvwHEvkRQfi3HZPcw4NIWgMI8LS24VyhOSjHb94FQ8MJaVDGBAsKvq06qaqapZAB4A8HdVnRnyZGQbNw1NQ3ZKZy4sucyR0w1Yuq4W94w2fyEpWD+9Yxh68y4Ze97HTpElyveEpU21x1HGhSXXWLiqKuQnJBktKT4Wz80YhT2e0/jPz7+1ehzLGBrsqvqVqk438phkDzPGZCA5IRbFXFhyhXONTXh1RRWuD+NCUrD8lcxfvil37aMcecVOhvAvLH2y7QCqDp+2ehwy2fv+haQwvH1AR/grmSddWskw2MkwsydlISaKT1hyOu8TksoxpFcS8gaGdyEpWEm+u2TcWskw2MkwvbrG43uj+uCtMi4sOdnyPYex48BJFOQZ+4Qko103OBUPjnNnJcNgJ0M9npeNMw1NeGM1F5acqqik3PKFpGA9M82dlQyDnQw1IiMZE3N64pXlXFhyot11J/HlTg9mTciydCEpWBdVMp+5p5JhsJPhCvOzsf94PT7avN/qUchg85ZV+haS+lk9StAuVDIl7qlkGOxkuBuHpCEnpTOKSyu4sOQgR043YMnaWswYk4GeEbKQFKxnpg1DenKCayoZBjsZLipK8BgXlhxnwcoqnGtsxuOTI/MWx9Z4K5mRrqlkGOxkihljMtAtMRZFJeVWj0IG8C8k3TAkFYMibCEpWPmDUvHguH6uqGQY7GSK756wdJALSw7w3oZ9OHTqHArzcqweJSTPTBuK9OQEx7+XDIOdTPPIRC4sOYGqori0AkN7J2HywJ5WjxMSfyVT7vBKhsFOpunV1feEpbIaHD/DhSW7Wrbbu5D0eIQvJAXLDZUMg51MVeBbWFrEJyzZVlFpOVK6xOEuGywkBcvplQyDnUx1VZ9kTBrQk09YsqnddSfx1U4PHpnYH3Exkb+QFKyk+Fj8x4xRKPecxm8dWMkw2Ml0BXnZOHCCC0t2VFxaibiYKDw83j4LScHKG5RyoZJZ67DbchnsZDouLNnT4VPnvE9IGpNpu4WkYD0zbSj6JCfgycXOqmQY7GS6wCcsral01pWRky1YVY1zjc0oyMuyehTTOLWSYbBTWMwYk8mFJRupP9+E11ZU4oYhqRiYZs+FpGDlDUrBQ+OdVckw2CksEjpFY+b4/vhs+0FUHuLCUqR7b+M+HDrVYPuFpGA9M22Yt5JxyF0yDHYKm0cm9vctLPG5qJFMVVFc4oyFpGB1iYvxVjKHTuM3n+60epyQMdgpbNK6xuPOqzPwVlktF5YiWOnuQ9h5MPKfkGQ0fyVTVFqBtVVHrB4nJCEHu4j0FZEvRWSbiGwVkR8ZMRg5U0FeNs6eb8JCPmEpYhWXViClS5wtnpBktO8qmU22rmSMuGJvBPB/VHU4gAkAfiAiww04LjnQ8D5dMWlAT7zKJyxFpF0HvQtJsx22kBSsLnExeOFe+1cyIQe7qu5X1XW+j08C2A4gI9TjknMV5nNhKVLNW1bhXUia0N/qUSwzeWAKHrZ5JWNoxy4iWQBGA1hl5HHJWW4YnIac1M74S0k5F5YiyOFT57Bk3V7cMyYTPTp3snocSz1t80rGsGAXkS4AlgD4saqeuMyvPyEiZSJS5vF4jDot2VBUlKAgLxtb9p7A6gp7XhE50fyV1Whw+EJSsOxeyRgS7CISC2+oL1DVpZd7jarOVdVcVc1NTU014rRkY/eMzkT3xFgUlfLWx0hQf74Jr6+sxI0uWEgKlp0rGSPuihEAxQC2q+pvQx+J3CChUzRmTuiPz7cfRAUXliznfUJSAwrz3bGQFCy7VjJGXLFPBjALwE0issH3Y5oBxyWHmzWxP2KjoriwZDFVRVFpOYb2TsKkAe5YSApWl7gYvOirZH79iX0qGSPuiilVVVHVUap6je/HR0YMR86WluR9wtLbZbU4dqbB6nFcq3T3IXx78BQK83NctZAUrEkDUzBzQj8UL6tAWaU9KhlunpKl/AtLi1bXWD2KaxWVVCA1KQ7fuzrd6lEi1pypvkpmsT0qGQY7WWp4n66YPLAnXllegYZGLiyF27cHT+Lrb927kBQsfyVTYZNKhsFOlivMy8HBE+e4sGSBeaXehaSHxrt3ISlYdqpkGOxkuesHp2JAamcUlXJhKZwOnTqHpev3Ysa1XEgK1tNThyGjm7eSOdsQuZUMg50s511YysGWvSewigtLYTN/ZRUaGpvx+ORsq0exjc5xMXhhhq+SieDFJQY7RYR7xmR4F5ZKeOtjONSfb8LrK6pw09A0DEzrYvU4tuKvZOZFcCXDYKeIEB8bjVkT+uOLHQdR7jll9TiO9+6GvTh8ugGFebxa74hIr2QY7BQxZl5YWKq0ehRHU1UUl1ZgWHpXTORCUod09r2XTKRWMgx2ihhpSfG485o+WLyWC0tmKtnlW0hy2ROSjDZpQApmTeiPecsqsCbCKhkGO0UU/8LSPF61m6ao1L+Q5L4nJBltztSh3krm7Y0RVckw2CmiDEvvijtGpuO/v9iFN/j4PMPtPHAS3/gWkjrF8D//UPkrmcrDZyKqkuG/WYo4v7nvalw/OBVzlm5muBtsXmkF4mO5kGSkSKxkGOwUceJjo/HnWdcy3A3mOXkO72zYixl8QpLh5kwdiszukVPJMNgpIjHcjXdhIYm3OBrOu7h0NSoPn8GLEfBeMgx2ilj+cL9hiDfcFzHcO6z+fBPmr6zClKFpGJDKhSQzTBzQE49M7I+Xl1dY/shHBjtFtPjYaPxppjfcn2a4d5h/Iakgn1frZvrJ7d5K5qnF1lYyDHaKeAz30KgqikoqMDy9KybmcCHJTJFSyTDYyRYY7h33za5D2FV3CgVcSAqLSKhkGOxkGwz3jikqKUcaF5LCyupKhsFOtuIP9xt94b5wFcO9NTsPnETJrkOYPSmLC0lhFFjJvPDJjrCfn/+myXbiY6Pxki/cn3mH4d6a4tJy70LSuH5Wj+I6Ewf0xOyJ/fHK8sqwVzIMdrIlhnvbPCfP4a/r9+HeazPRnQtJlnjKV8k8GeZKxpBgF5HbRWSniOwWkTlGHJOoLQz31r2+sgoNTXxCkpX8lUxVmCuZkINdRKIB/BHAVADDATwoIsNDPS5RMOJjo/GnWQz3lurPN2HByircPCwNOVxIspQVlYwRV+zjAOxW1XJVbQDwBoC7DDguUVDiYi4O9wWrqqweyXJ/Xe9dSOLbB0SGn0wdir7dE/Hk4o0409Bo+vmMCPYMADUBn9f6vnYREXlCRMpEpMzj8RhwWqLvBIb7T9/Z4upwV1UUlXIhKZIkdvK+vW/t0bMo2XXI9POF7S9PVXWuquaqam5qamq4TksuwnD3+vpbD3bXnUJhPheSIsmEnJ746l9uwG1X9Tb9XEYE+14AfQM+z/R9jSjsGO5AcWkF0pLiMH0UF5IiTd8eiWE5jxHBvgbAIBHJFpFOAB4A8J4BxyXqEH+43zQ0zXXhvuPACS4kUejBrqqNAP4JwCcAtgN4S1W3hnpcolDExUTjpZljLoT7/JXuCPfikgokxEbj4fFcSHKzGCMOoqofAfjIiGMRGcUf7v84fx2e/esWAMDMCc59JFzdyXq8u2Ef7h/bF90SuZDkZvyzGjla4JX7s3919pX7/JXVaGhqxmOTs6wehSzGYCfH84f7FAeHu/8JSVxIIoDBTi4RFxON/3FwuL+zfi+OnG5AQV6O1aNQBGCwk2u0DPfXHRLuzc2K4tIKXNWnKybk9LB6HIoADHZylcBw/5lDwv3rXVxIoosx2Ml1/OF+8zBnhHtxSQV6dY3DHSO5kEReDHZypbiYaPzxYfuH+/b9J1C6mwtJdDH+TiDXckK4F5d6F5L4hCQKxGAnV7sk3FdUWj1S0OpO1uO9Dd4nJHEhiQIx2Mn1Lgr3d7faJtznr6jC+WYuJNGlGOxEsF+4159vwusrqzBlaC8uJNElGOxEPnEx0fifh6+1RbgvXbcXR8+cR2E+n5BEl2KwEwXoFBMV8eHuXUgqx4iMrhifzYUkuhSDnaiFluH+2opKq0e6yNfferDHcxqFeTlcSKLLYrATXcZ34d4L/zfCwr2otBy9u8Zj2sh0q0ehCMVgJ7oCb7iPiahw37bvBJbtPoxHJvXnQhJdEX9nELUi0sJ93jIuJFHbGOxEbYiUcK87UY93N+zF93O5kEStY7ATBcEf7rcMty7cX19ZhcZmxWOTeYsjtY7BThSkTjFR+OND1oT72Qb/E5J6ITulc9jOS/bEYCdqB6vCfen6Wu9CUh6v1qltIQW7iLwoIjtEZJOIvCMi3YwajChShTvc/U9IGpmRjHFcSKIghHrF/hmAEao6CsC3AJ4OfSSiyBfOcP/q2zqUe06jII9PSKLghBTsqvqpqjb6Pl0JIDP0kYjswR/ut/rC/dXllaacp6ikggtJ1C5GduyPA/jYwOMRRbxOMVH4gy/cf/6e8eG+bd8JLN9zmE9IonZp83eKiHwuIlsu8+OugNf8FEAjgAWtHOcJESkTkTKPx2PM9EQRwMxw5xOSqCNi2nqBqt7c2q+LyKMApgOYoqraynHmApgLALm5uVd8HZEd+cP9nxauw8/f2woAmD0pK6Rj1p2ox3sb9+Khcf2QnBhrwJTkFqHeFXM7gKcA3KmqZ4wZicie/OF+21XGXLm/toILSdQxoZZ2fwCQBOAzEdkgIn8yYCYi2+oUE4XfP/hduL+yrKJDxznb0IT5q6pwy7BeyOJCErVTm1VMa1R1oFGDEDmFP9x/uGgd/vX9bQCAR9t51b1kXS2OnTmPwvwcM0Ykh+NfsxOZIPDK/V/f39auK/fmZsU830LS2KzuJk5JTsVgJzJJYOfennD/cmcdyg+dRmE+F5KoYxjsRCaKjW5/uBeXciGJQsNgJzJZy3B/uZVw37rvOJbvOYxHJ2chNpr/eVLH8HcOURgEhvsvWgn34tIKJHaKxoNjuZBEHcdgJwqTtsL94Il6vL9xH+7L7cuFJAoJg50ojPzhfvtVvS8J99dWVPoWkrIsm4+cgcFOFGax0VH4/UOjLwr3Mw2NWLCqGrcM64X+PbmQRKEJaUGJiDrGH+4/XLgev3h/Gz7ffpALSWQYXrETWSTwyn3Z7sMYlcmFJDIGr9iJLOQP9z9+uRs3DU3jQhIZgsFOZLHY6Cj8+ObBVo9BDsIqhojIYRjsREQOw2AnInIYBjsRkcMw2ImIHIbBTkTkMAx2IiKHYbATETmMqGr4TyriAVDVwX88BcAhA8exA37P7sDv2R1C+Z77q2pqWy+yJNhDISJlqppr9RzhxO/ZHfg9u0M4vmdWMUREDsNgJyJyGDsG+1yrB7AAv2d34PfsDqZ/z7br2ImIqHV2vGInIqJW2CbYRWSeiNSJyBarZwkXEekrIl+KyDYR2SoiP7J6JrOJSLyIrBaRjb7v+RdWzxQOIhItIutF5AOrZwkHEakUkc0iskFEyqyeJxxEpJuILBaRHSKyXUQmmnYuu1QxInIdgFMAXlPVEVbPEw4ikg4gXVXXiUgSgLUA7lbVbRaPZhrxPkKos6qeEpFYAKUAfqSqKy0ezVQi8r8B5AL5n1spAAACF0lEQVToqqrTrZ7HbCJSCSBXVV1zD7uIvAqgRFWLRKQTgERVPWbGuWxzxa6q3wA4YvUc4aSq+1V1ne/jkwC2A8iwdipzqdcp36exvh/2uProIBHJBHAHgCKrZyFziEgygOsAFAOAqjaYFeqAjYLd7UQkC8BoAKusncR8vlpiA4A6AJ+pqtO/598BeApAs9WDhJEC+FRE1orIE1YPEwbZADwAXvZVbkUi0tmskzHYbUBEugBYAuDHqnrC6nnMpqpNqnoNgEwA40TEsdWbiEwHUKeqa62eJczyVHUMgKkAfuCrWp0sBsAYAC+p6mgApwHMMetkDPYI5+uZlwBYoKpLrZ4nnHx/VP0SwO1Wz2KiyQDu9HXObwC4SUTmWzuS+VR1r+/nOgDvABhn7USmqwVQG/Cnz8XwBr0pGOwRzPcXicUAtqvqb62eJxxEJFVEuvk+TgBwC4Ad1k5lHlV9WlUzVTULwAMA/q6qMy0ey1Qi0tl3MwB8dcStABx9t5uqHgBQIyJDfF+aAsC0myBizDqw0URkEYAbAKSISC2An6tqsbVTmW4ygFkANvs6ZwB4RlU/snAms6UDeFVEouG98HhLVV1xC6CL9ALwjve6BTEAFqrq36wdKSx+CGCB746YcgCPmXUi29zuSEREwWEVQ0TkMAx2IiKHYbATETkMg52IyGEY7EREDsNgJyJyGAY7EZHDMNiJiBzm/wO6MWnycH6sYgAAAABJRU5ErkJggg==\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(abscisses, ordonnees)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Un nuage de points"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f0ad9b9d978>]"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(abscisses, ordonnees, '+')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Un diagramme bar"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<BarContainer object of 6 artists>"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.bar(abscisses, ordonnees)"
]
},
{
"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.3"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
Reference in New Issue View Git Blame Copy Permalink