{
"nbformat_minor": 0,
"nbformat": 4,
"cells": [
{
"source": [
"$$\n",
"\\def\\CC{\\bf C}\n",
"\\def\\QQ{\\bf Q}\n",
"\\def\\RR{\\bf R}\n",
"\\def\\ZZ{\\bf Z}\n",
"\\def\\NN{\\bf N}\n",
"$$\n",
"# Boucle `for`"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"from __future__ import division, print_function # Python 3\n",
"from sympy import init_printing\n",
"init_printing(use_latex='mathjax',use_unicode=False) # Affichage des r\u00e9sultats"
],
"outputs": [],
"metadata": {}
},
{
"source": [
"Dans ce chapitre et les suivants, nous traitons de la programmation en Python. Les notes ici pr\u00e9sentent les grandes lignes et les \u00e9l\u00e9ments principaux de ce sujet. Le lecteur d\u00e9sirant en savoir plus sera invit\u00e9 \u00e0 consulter les chapitres 1 \u00e0 7 du livre en fran\u00e7ais de G. Swinnen *Apprendre \u00e0 programmer avec Python 3* \\[Swinnen\\]\\_, le syllabus du cours de programmation de Thierry Massart \\[Massart\\]\\_ ou encore les chapitre 1 \u00e0 11 du livre en anglais de Wentworth et al. *How to Think Like a Computer Scientist - Learning with Python* \\[Thinklike\\]\\_.\n",
"\n",
"Une boucle permet de faire des t\u00e2ches r\u00e9p\u00e9titives sur un ordinateur avec un moindre effort.\n",
"\n",
""
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"for a in range(9):"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... print(\"I will not do anything bad ever again.\")\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again.\n",
"I will not do anything bad ever again."
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"## La boucle `for`\n",
"\n",
"La boucle for permet aussi de parcourir les \u00e9l\u00e9ments d'une liste, une cha\u00eene de caract\u00e8res ou en g\u00e9n\u00e9ral de tout objet it\u00e9rable:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"for a in [1,2,3,4]:"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... print(a + 100)\n",
"101\n",
"102\n",
"103\n",
"104"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"for a in 'bonjour':"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... print('A ' + a + ' Z')\n",
"A b Z\n",
"A o Z\n",
"A n Z\n",
"A j Z\n",
"A o Z\n",
"A u Z\n",
"A r Z"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"En Python, une boucle `for` est identifi\u00e9e par une ligne d'en-t\u00eate comman\u00e7ant par `for` se terminant par un deux-points `:` et avec la syntaxe `for TRUC in MACHIN:`. La convention est de toujours utiliser 4 espaces pour indenter les lignes du bloc d'instructions qui appartient \u00e0 la boucle:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"for i in liste: # ligne d'en-t\u00eate\n",
" \n",
" \n",
" ...\n",
" \n",
""
],
"outputs": [],
"metadata": {}
},
{
"source": [
"Le bloc d'instructions est ex\u00e9cut\u00e9 autant de fois qu'il y a d'\u00e9l\u00e9ments dans la liste. Le bloc d'instruction est ex\u00e9cut\u00e9 une fois pour chaque valeur de la variable `i` dans la liste.\n",
"\n",
"## Un exemple de boucle `for` avec Sympy\n",
"\n",
"Supposons que l'on d\u00e9sire factoriser le polyn\u00f4me $x^k-1$ pour toutes les valeurs de $k=1,...,9$. En SymPy, il est possible d'\u00e9crire onze fois le m\u00eame calcul o\u00f9 on change la valeur de l'exposant $k$ \u00e0 chaque fois:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"from sympy import factor\n",
"from sympy.abc import x\n",
"factor(x**1-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"x - 1"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**2-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**3-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x**2 + x + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**4-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x + 1)*(x**2 + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**5-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x**4 + x**3 + x**2 + x + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**6-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x + 1)*(x**2 - x + 1)*(x**2 + x + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**7-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**8-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x + 1)*(x**2 + 1)*(x**4 + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"factor(x**9-1)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"(x - 1)*(x**2 + x + 1)*(x**6 + x**3 + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"La boucle `for` permet r\u00e9p\u00e9ter une action pour toutes les valeurs d'une liste. En utilisant une boucle `for`, l'exemple ci-haut peut se r\u00e9\u00e9crire plus facilement:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"for k in range(1,12):"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... print(factor(x**k-1))\n",
"x - 1\n",
"(x - 1)*(x + 1)\n",
"(x - 1)*(x**2 + x + 1)\n",
"(x - 1)*(x + 1)*(x**2 + 1)\n",
"(x - 1)*(x**4 + x**3 + x**2 + x + 1)\n",
"(x - 1)*(x + 1)*(x**2 - x + 1)*(x**2 + x + 1)\n",
"(x - 1)*(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1)\n",
"(x - 1)*(x + 1)*(x**2 + 1)*(x**4 + 1)\n",
"(x - 1)*(x**2 + x + 1)*(x**6 + x**3 + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"Pour diff\u00e9rencier les lignes, il est possible d'afficher plus d'informations:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"from sympy import Eq\n",
"for k in range(2, 10):"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... expr = x**k-1\n",
"... eq = Eq(expr, factor(expr))\n",
"... print(eq)\n",
"x**2 - 1 == (x - 1)*(x + 1)\n",
"x**3 - 1 == (x - 1)*(x**2 + x + 1)\n",
"x**4 - 1 == (x - 1)*(x + 1)*(x**2 + 1)\n",
"x**5 - 1 == (x - 1)*(x**4 + x**3 + x**2 + x + 1)\n",
"x**6 - 1 == (x - 1)*(x + 1)*(x**2 - x + 1)*(x**2 + x + 1)\n",
"x**7 - 1 == (x - 1)*(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1)\n",
"x**8 - 1 == (x - 1)*(x + 1)*(x**2 + 1)*(x**4 + 1)\n",
"x**9 - 1 == (x - 1)*(x**2 + x + 1)*(x**6 + x**3 + 1)"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"## Affectation d'une variable\n",
"\n",
"Pour affecter une valeur dans une variable, on se rappelle que cela se fait en Python comme en C ou C++ ou Java avec la syntaxe:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"a = 5"
],
"outputs": [],
"metadata": {}
},
{
"source": [
"La syntaxe `a == 5` est r\u00e9serv\u00e9e pour le test d'\u00e9galit\u00e9.\n",
"\n",
"## Mise \u00e0 jour d'une variable\n",
"\n",
"Quand une instruction d'affectation est ex\u00e9cut\u00e9e, l'expression de droite (\u00e0 savoir l'expression qui vient apr\u00e8s le signe `=` d'affectation) est \u00e9valu\u00e9e en premier. Cela produit une valeur. Ensuite, l'assignation est faite, de sorte que la variable sur le c\u00f4t\u00e9 gauche se r\u00e9f\u00e8re maintenant \u00e0 la nouvelle valeur.\n",
"\n",
"L'une des formes les plus courantes de l'affectation est une mise \u00e0 jour, lorsque la nouvelle valeur de la variable d\u00e9pend de son ancienne valeur:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"n = 5\n",
"n = 3 * n + 1"
],
"outputs": [],
"metadata": {}
},
{
"source": [
"Ligne 2 signifie obtenir la valeur courante de `n`, la multiplier par trois et ajouter un, et affecter la r\u00e9ponse \u00e0 `n`. Donc, apr\u00e8s avoir ex\u00e9cut\u00e9 les deux lignes ci-dessus, `n` va pointer / se r\u00e9f\u00e9rer \u00e0 l'entier `16`.\n",
"\n",
"Si vous essayez d'obtenir la valeur d'une variable qui n'a jamais \u00e9t\u00e9 attribu\u00e9e, vous obtenez une erreur:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"W = x + 1"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"Traceback (most recent call last):\n",
"...\n",
"NameError: name 'x' is not defined"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"Avant de pouvoir mettre \u00e0 jour une variable, vous devez l'initialiser \u00e0 une valeur de d\u00e9part, habituellement avec une valeur simple:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"sous_total = 0\n",
"sous_total = sous_total + 1"
],
"outputs": [],
"metadata": {}
},
{
"source": [
"La mise \u00e0 jour d'une variable en lui ajoutant 1 \u00e0 celle-ci est tr\u00e8s commune. On appelle cela un **incr\u00e9ment** de la variable; soustraire 1 est appel\u00e9 un **d\u00e9cr\u00e9ment**.\n",
"\n",
"Le code `sous_total = sous_total + 1` calcule le r\u00e9sultat de la partie droite dans un nouvel espace en m\u00e9moire et ensuite cette nouvelle valeur est affect\u00e9e \u00e0 la variable `sous_total`. Une fa\u00e7on plus efficace d'incr\u00e9menter une variable est de la modifier sans avoir \u00e0 garder en m\u00e9moire un r\u00e9sultat partiel. En Python (comme en C), on peut incr\u00e9menter une variable avec l'op\u00e9rateur `+=`. Donc, il suffit d'\u00e9crire:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"sous_total += 1"
],
"outputs": [],
"metadata": {}
},
{
"source": [
"## Quelques exemples\n",
"\n",
"L'exemple suivant illustre comment calculer la somme des \u00e9l\u00e9ments d'une liste en utilisant une variable `s` initialis\u00e9e \u00e0 z\u00e9ro avant la boucle:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"L = [134, 13614, 73467, 1451, 134, 88]\n",
"s = 0\n",
"for a in L:"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... s = s + a"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"s"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"88888"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"On \u00e9crit la m\u00eame chose en utilisant le signe `+=` pour incr\u00e9menter la variable `s` :"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"s = 0\n",
"for a in L:"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... s += a"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"s"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"88888"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"On v\u00e9rifie que le calcul est bon:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"sum(L)"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"88888"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"L'exemple suivant double chacune des lettres d'une cha\u00eene de caract\u00e8res:"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"s = 'gaston'\n",
"t = ''\n",
"for lettre in s:"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... t += lettre + lettre\n",
"..."
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"t"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"'ggaassttoonn'"
]
},
"metadata": {}
}
],
"metadata": {}
},
{
"source": [
"Lorsque la variable de la boucle n'est pas utilis\u00e9e dans le bloc d'instruction la convention est d'utiliser la barre de soulignement (`_`) pour l'indiquer. Ici, on calcule les puissances du nombre 3. On remarque que l'expression d'assignation `k *= 3` est \u00e9quivalente \u00e0 `k = k * 3` :"
],
"cell_type": "markdown",
"metadata": {}
},
{
"execution_count": null,
"cell_type": "code",
"source": [
"k = 1\n",
"for _ in range(10):"
],
"outputs": [
{
"execution_count": 1,
"output_type": "execute_result",
"data": {
"text/plain": [
"... k *= 3\n",
"... print k\n",
"... \n",
"3\n",
"9\n",
"27\n",
"81\n",
"243\n",
"729\n",
"2187\n",
"6561\n",
"19683\n",
"59049"
]
},
"metadata": {}
}
],
"metadata": {}
}
],
"metadata": {
"kernelspec": {
"display_name": "python2",
"name": "python2"
}
}
}