+
+
input¶
Contrairement à ce que l'on a fait hier on ne met plus rien dans les parenthèses d'un input.
input() est une commande qui va demander à l'utilisateur une information
-
@@ -13218,7 +13304,7 @@ Ah! Tu t'appelles Ivan
In [20]:
+In [4]:
print("Comment t'appelles tu?")
@@ -13190,8 +13276,8 @@ div#notebook {
-
+
+
In [21]:
+In [5]:
a = 2
@@ -13260,6 +13346,58 @@ Ah! Tu t'appelles Ivan
Boucles for¶
Les boucles for permettent de répéter un certain nombre de fois la même action.
+- Générer plusieurs valeurs:
+
+
+
+
+
+
+
+
+In [6]:
+
+
+
+
+
+
+for x in range(10):
+ print(x)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Python a créé une variable x puis lui a fait prendre toutes les valeurs entre 0 et 9.
- Ajouter 5 fois 100 d'affilé
-
In [22]:
+In [7]:
a = 2
@@ -13320,7 +13458,7 @@ Finalement a vaut 502
-
In [23]:
+In [8]:
phrase = "boujour toi"
@@ -13377,7 +13515,7 @@ Toutes les lettres ont été énumérées
-
In [24]:
+In [9]:
liste = ["premier element", 2, "coucou", 1, "aie", 0]
@@ -13428,7 +13566,7 @@ Tout a été énuméré
-
In [25]:
+In [10]:
u = 2
@@ -13477,7 +13615,7 @@ u a depassé 50 et vaut 20
-
In [26]:
+In [11]:
aPasTrouve = True # True signifie vrai en anglais.
@@ -13507,13 +13645,10 @@ u a depassé 50 et vaut 20
-In [27]:
+In [12]:
def f(x):
@@ -13571,7 +13706,7 @@ Cette fonction $f$ prend un nombre, le multiplie par 3 puis ajoute 2. On pourra
-In [28]:
+In [13]:
print(f(4))
@@ -13620,7 +13755,7 @@ f(-2) = -4
-In [29]:
+In [14]:
def programme(nombre):
@@ -13636,7 +13771,7 @@ f(-2) = -4
-In [30]:
+In [15]:
print(programme(60))
@@ -13676,7 +13811,7 @@ f(-2) = -4
-In [31]:
+In [16]:
def entoure(titre):
@@ -13690,7 +13825,7 @@ f(-2) = -4
-In [32]:
+In [17]:
print(entoure('Mon titre'))
@@ -13733,7 +13868,7 @@ f(-2) = -4
-In [33]:
+In [18]:
def entoure(texte, symbole):
@@ -13747,7 +13882,7 @@ f(-2) = -4
-In [34]:
+In [19]:
print(entoure('La belle au bois dormant', '-'))
@@ -13775,6 +13910,578 @@ f(-2) = -4
+
+
+
+
+Listes¶
+
+
+
+
+
+In [20]:
+
+
+L = [5, 2, 1, 2, 4, 5, 5]
+
+
+
+
+
+
+
+
+
+
+
+max: valeur maximal de la liste
+
+
+
+
+
+
+In [21]:
+
+
+print(max(L))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+min: valeur minimal de la liste
+
+
+
+
+
+
+In [22]:
+
+
+print(min(L))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+len: calculer le nombre d'éléments dans la liste
+
+
+
+
+
+
+In [23]:
+
+
+print(len(L))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+sum: calculer la somme des éléments de la liste
+
+
+
+
+
+
+In [24]:
+
+
+print(sum(L))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+sorted: trier les éléments de la liste
+
+
+
+
+
+
+In [25]:
+
+
+print(sorted(L))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+- Récupérer le i-ième élément de la liste (/!\ on commence à compter à partir de 0)
+
+
+
+
+
+
+
+In [26]:
+
+
+# Le premier élément de la liste
+print(L[0])
+# le 3e élément de la liste
+print(L[2])
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+- Compter l'effectif d'une valeur
+
+
+
+
+
+
+
+In [27]:
+
+
+L.count(2)
+
+
+
+
+
+
+
+
+
+
+
+
+ Out[27]:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+- Faire une boucle sur tous les éléments de la liste
+
+
+
+
+
+
+
+In [28]:
+
+
+for x in L:
+ print(x)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Graphiques¶
Pour faire des graphiques, il faut que la ligne suivante fasse partie des premières lignes de votre programme.
+
+
+
+
+
+
+In [29]:
+
+
+import matplotlib.pyplot as plt
+
+
+
+
+
+
+
+
+
+
+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).
+
+
+
+
+
+
+In [30]:
+
+
+abscisses = [1, 2, 3, 4, 5, 6]
+ordonnees = [4, 10, 1, -3, 6, 0]
+
+
+
+
+
+
+
+
+
+
+On peut tracer une courbe:
+
+
+
+
+
+
+In [31]:
+
+
+plt.plot(abscisses, ordonnees)
+
+
+
+
+
+
+
+
+
+
+
+
+ Out[31]:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Un nuage de points
+
+
+
+
+
+
+In [32]:
+
+
+plt.plot(abscisses, ordonnees, '+')
+
+
+
+
+
+
+
+
+
+
+
+
+ Out[32]:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Un diagramme bar
+
+
+
+
+
+
+In [33]:
+
+
+plt.bar(abscisses, ordonnees)
+
+
+
+
+
+
+
+
+
+
+
+
+ Out[33]:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PreStSauveur/Programmation/Memo.ipynb b/PreStSauveur/Programmation/Memo.ipynb
index b5cba79..e640845 100644
--- a/PreStSauveur/Programmation/Memo.ipynb
+++ b/PreStSauveur/Programmation/Memo.ipynb
@@ -10,11 +10,14 @@
"\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",
@@ -49,7 +52,69 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "--------------------------------------\n",
+ "## 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",
@@ -59,7 +124,7 @@
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": 4,
"metadata": {},
"outputs": [
{
@@ -67,8 +132,8 @@
"output_type": "stream",
"text": [
"Comment t'appelles tu?\n",
- "Ivan\n",
- "Ah! Tu t'appelles Ivan\n"
+ "bobo\n",
+ "Ah! Tu t'appelles bobo\n"
]
}
],
@@ -96,7 +161,7 @@
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": 5,
"metadata": {},
"outputs": [
{
@@ -132,7 +197,7 @@
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 6,
"metadata": {},
"outputs": [
{
@@ -168,7 +233,7 @@
},
{
"cell_type": "code",
- "execution_count": 22,
+ "execution_count": 7,
"metadata": {},
"outputs": [
{
@@ -203,7 +268,7 @@
},
{
"cell_type": "code",
- "execution_count": 23,
+ "execution_count": 8,
"metadata": {},
"outputs": [
{
@@ -243,7 +308,7 @@
},
{
"cell_type": "code",
- "execution_count": 24,
+ "execution_count": 9,
"metadata": {},
"outputs": [
{
@@ -282,7 +347,7 @@
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": 10,
"metadata": {},
"outputs": [
{
@@ -316,21 +381,18 @@
},
{
"cell_type": "code",
- "execution_count": 26,
+ "execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "Quelle est la couleur du cheval blanc d'Henri 4?\n",
- "bleu\n",
- "Non! Recommence!\n",
"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",
- "jaune\n",
+ "rouge\n",
"Non! Recommence!\n",
"Quelle est la couleur du cheval blanc d'Henri 4?\n",
"blanc\n",
@@ -378,7 +440,7 @@
},
{
"cell_type": "code",
- "execution_count": 27,
+ "execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
@@ -395,7 +457,7 @@
},
{
"cell_type": "code",
- "execution_count": 28,
+ "execution_count": 13,
"metadata": {},
"outputs": [
{
@@ -429,7 +491,7 @@
},
{
"cell_type": "code",
- "execution_count": 29,
+ "execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
@@ -441,7 +503,7 @@
},
{
"cell_type": "code",
- "execution_count": 30,
+ "execution_count": 15,
"metadata": {},
"outputs": [
{
@@ -469,7 +531,7 @@
},
{
"cell_type": "code",
- "execution_count": 31,
+ "execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
@@ -479,7 +541,7 @@
},
{
"cell_type": "code",
- "execution_count": 32,
+ "execution_count": 17,
"metadata": {},
"outputs": [
{
@@ -507,7 +569,7 @@
},
{
"cell_type": "code",
- "execution_count": 33,
+ "execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
@@ -517,7 +579,7 @@
},
{
"cell_type": "code",
- "execution_count": 34,
+ "execution_count": 19,
"metadata": {
"scrolled": true
},
@@ -534,6 +596,380 @@
"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": [
+ "[]"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "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": [
+ "[]"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "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": [
+ ""
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.bar(abscisses, ordonnees)"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -558,7 +994,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.7.1"
+ "version": "3.7.3"
}
},
"nbformat": 4,