{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Structures de contrôle"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Présentation des structures de contrôle : Conditions, branchements et boucles"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
""
],
"text/plain": [
""
]
},
"execution_count": 80,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\n",
"# Afficher la table des matières\n",
"\n",
"from jyquickhelper import add_notebook_menu\n",
"add_notebook_menu()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Test : if - elif - else"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La syntaxe Python pour l'exécution conditionnelle du code utilise les mots-clés `if`, `elif` (else if), `else` :"
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Instruction1 et Instruction2 sont toutes les deux False\n"
]
}
],
"source": [
"Instruction1 = False\n",
"Instruction2 = False\n",
"\n",
"if Instruction1:\n",
" print(\"Instruction1 est vrai\")\n",
" \n",
"elif Instruction2:\n",
" print(\"Instruction2 est vrai\")\n",
" \n",
"else:\n",
" print(\"Instruction1 et Instruction2 sont toutes les deux False\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"**Remarque :** être très attentif sur la gestion des `indentations` car la fin\n",
"d’indentation signifie la fin d’un bloc de commandes"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"L'étendue d'un bloc de code est définie par le niveau d'indentation (habituellement une tabulation ou quatre espaces blancs). Cela signifie qu'il faut faire attention à indenter votre code correctement, sinon vous obtiendrez des erreurs de syntaxe."
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"l'Instruction1 et l'Instruction2 sont toutes les deux True\n"
]
}
],
"source": [
"Instruction1 = Instruction2 = True\n",
"\n",
"if Instruction1:\n",
" if Instruction2:\n",
" print(\"l'Instruction1 et l'Instruction2 sont toutes les deux True\")"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "IndentationError",
"evalue": "expected an indented block (510671156.py, line 4)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"/var/folders/2b/cj2pm60x61s5qlxpmr7g7km00000gn/T/ipykernel_5191/510671156.py\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m print(\"l'Instruction1 et l'Instruction2 sont toutes les deux True\") # Cette ligne n'est pas correctement indentée\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
]
}
],
"source": [
"# Mauvaise indentation!\n",
"if Instruction1:\n",
" if Instruction2:\n",
" print(\"l'Instruction1 et l'Instruction2 sont toutes les deux True\") # Cette ligne n'est pas correctement indentée"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"Instruction1 = False \n",
"\n",
"if Instruction1:\n",
" print(\"Afficher si Instruction1 est True\")\n",
" \n",
" print(\"Encore à l'intérieur du bloc if\")"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Maintenant à l'extérieur du bloc if\n"
]
}
],
"source": [
"if Instruction1:\n",
" print(\"Afficher si Instruction1 est True\")\n",
" \n",
"print(\"Maintenant à l'extérieur du bloc if\")"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"##### Syntaxe compacte d'une assignation conditionnelle"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Exemple :"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 87,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x,y = 10, 6\n",
"if x < y:\n",
" minimum = x\n",
"else:\n",
" minimum = y\n",
"\n",
"minimum"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python offre une syntaxe abrégée (inspirée du C) pour faire ceci :"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"minimum = x if x < y else y\n",
"minimum"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Boucles"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En Python, les boucles peuvent être programmées de différentes façons. Il y a deux types de boucles, la boucle **for** parcourt un ensemble, la boucle **while** continue tant qu’une condition est vraie.\n",
"\n",
"La plus courante est la boucle for, qui est utilisée avec des objets itérables, comme des listes. La syntaxe de base est :"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Boucle for :"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n"
]
}
],
"source": [
"for x in [1,2,3]:\n",
" print(x)"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 1 2 3 "
]
}
],
"source": [
"for i in range (4) : # Par défaut range commence à 0\n",
" print(i, end =\" \")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note :** \n",
" - range (4) génère une liste de 0 à n-1 donc, ne comprend pas 4!\n",
" Syntaxe générale de range : range(start, stop, step)\n",
" - la propriété end = \" \" dans la fonction `print` permet de rester sur la même ligne lors de l'affichage"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour itérer sur les paires clé-valeur d'un dictionnaire:"
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'mois' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m/var/folders/2b/cj2pm60x61s5qlxpmr7g7km00000gn/T/ipykernel_5191/576506978.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mcle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvaleur\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmois\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcle\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" = \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvaleur\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'mois' is not defined"
]
}
],
"source": [
"for cle, valeur in mois.items():\n",
" print(cle + \" = \" + str(valeur))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Parfois, il est utile d'avoir accès aux indices des valeurs lors de l'itération sur une liste. Nous pouvons utiliser la fonction enumerate pour cela :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 -3\n",
"1 -2\n",
"2 -1\n",
"3 0\n",
"4 1\n",
"5 2\n"
]
}
],
"source": [
"for idx, x in enumerate(range(-3,3)):\n",
" print(idx, x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Listes en Compréhension"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La liste en compréhension permet d’éviter une écriture en boucle explicite et rend l’exécution plus rapide"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 1, 4, 9, 16]\n"
]
}
],
"source": [
"L = [x ** 2 for x in range (0 ,5)]\n",
"print (L)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"est la version courte de :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 1, 4, 9, 16]\n"
]
}
],
"source": [
"L =list()\n",
"for x in range (0, 5):\n",
" L.append (x ** 2)\n",
"print (L)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Boucle while :"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Parfois, on ne sait pas à l'avance combien de fois on veut exécuter un bloc d'instructions. Dans ce cas, il vaut mieux utiliser une boucle `while` dont la syntaxe est:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [
{
"data": {
"text/plain": [
"'\\nwhile CONDITION:\\n INSTRUCTION 1\\n INSTRUCTION 2\\n ...\\n INSTRUCTION n\\n'"
]
},
"execution_count": 75,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'''\n",
"while CONDITION:\n",
" INSTRUCTION 1\n",
" INSTRUCTION 2\n",
" ...\n",
" INSTRUCTION n\n",
"'''"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le bloc d'instruction est exécuté (au complet) tant que la condition est satisfaite. La condition est testée avant l'exécution du bloc, mais pas pendant. C'est donc toutes les instructions du bloc qui sont exécutées si la condition est vraie. Par exemple, on peut afficher les puissances de 5 inférieures à un million avec une boucle `while` :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"5\n",
"25\n",
"125\n",
"625\n",
"3125\n",
"15625\n",
"78125\n",
"390625\n"
]
}
],
"source": [
"a = 1\n",
"while a < 1000000:\n",
" print(a)\n",
" a = a * 5"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2 4 6 8 "
]
}
],
"source": [
"ct =2\n",
"while ct <= 8:\n",
" print(ct , end =\" \")\n",
" ct = ct + 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Interruptions de boucles avec break et continue"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* La commande `break` permet d'interrompre une boucle for ou while en cours:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n"
]
}
],
"source": [
"for i in range(10):\n",
" if i == 5:\n",
" break\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On remarque que les valeurs plus grandes que 4 n'ont pas été affichées par la fonction `print`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* La commande `continue` permet de continuer le parcours d'une boucle à la valeur suivante :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"6\n",
"7\n",
"8\n",
"9\n"
]
}
],
"source": [
"for i in range(10):\n",
" if i == 5:\n",
" continue\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On remarque que la valeur 5 n'a pas été affichées par la fonction `print`."
]
}
],
"metadata": {
"anaconda-cloud": {},
"interpreter": {
"hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
},
"kernelspec": {
"display_name": "Python [Root]",
"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.8.8"
}
},
"nbformat": 4,
"nbformat_minor": 0
}