{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Tests et Boucles\n",
"\n",
"Ludovic Deneuville\n",
"\n",
"## Avant de commencer\n",
"\n",
"- Téléchargez ce\n",
" notebook Jupyter\n",
"- Connectez-vous au\n",
" Jupyter\n",
" ENSAI avec id et mot de passe\n",
" - ou une autre plate-forme (SSPCloud, Jupyter Lab, Google Colab,\n",
" Kaggle…)\n",
"- Importez le fichier .ipynb\n",
"\n",
"## 1 Structures condionnelles et boucles\n",
"\n",
"Dans ce Notebook, nous allons aborder les thèmes suivants :\n",
"\n",
"- les structures **if, else**\n",
"- la boucle **for**\n",
"- la boucle **while**\n",
"- les instructions **break** et **continue**\n",
"\n",
"------------------------------------------------------------------------\n",
"\n",
"## 2 Structures conditionnelles\n",
"\n",
"Nous allons tester différentes conditions booléennes (voir Notebook 1)\n",
"en utilisant les mots clés : **if**, **else** et **elif**.\n",
"\n",
"Le principe est le suivant :\n",
"\n",
" if condition1:\n",
" # Bloc de code à exécuter si la condition1 est vraie\n",
" elif condition2:\n",
" # Bloc de code à exécuter si la condition1 est fausse et condition2 est vraie\n",
" else:\n",
" # Bloc de code à exécuter si la condition1 et 2 sont fausses\n",
"\n",
"**Remarques** :\n",
"\n",
"- il peut y avoir autant de **elif** que nécessaire (entre 0 et\n",
" infini)\n",
"- le **else** est facultatif\n",
"\n",
"**Attention** : Il est important de respecter la syntaxe, en particulier\n",
"l’indentation !"
],
"id": "69fd9637-8e45-4584-974e-77a214a3ffcc"
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"a = 12\n",
"\n",
"# Simple if\n",
"if a > 5:\n",
" print(\"la variable a({}) est strictement supérieure à 5\".format(a))"
],
"id": "b63f48aa"
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"a = 3\n",
"\n",
"# if else\n",
"if a > 5:\n",
" print(\"la variable a({}) est strictement supérieure à 5\".format(a))\n",
"else:\n",
" print(\"la variable a({}) est inférieure ou égale à 5\".format(a))"
],
"id": "dda5dd2d"
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"nb_habitants = 750\n",
"\n",
"if nb_habitants < 500:\n",
" print(\"village\")\n",
"elif nb_habitants < 10000:\n",
" print(\"ville\")\n",
"else:\n",
" print(\"grande ville\")"
],
"id": "bddb36fa"
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"# Conditions multiples\n",
"\n",
"note_maths = 14\n",
"note_info = 20\n",
"validation_anglais = True\n",
"\n",
"if note_maths > 10 and note_info > 10 and validation_anglais:\n",
" print(\"Année validée\")"
],
"id": "c0243bd6"
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Conditions en cascade\n",
"if note_maths > 10:\n",
" if note_info > 10:\n",
" if validation_anglais:\n",
" print(\"Félicitation, continuez comme ça !\")\n",
" else:\n",
" print(\"Work harder\")\n",
" else:\n",
" print(\"il y a 10 types de personnes, ceux qui sont bons en info et les autres\")\n",
"else:\n",
" print(\"1+1=2\")"
],
"id": "5b195430"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"------------------------------------------------------------------------\n",
"\n",
"## 3 Boucles\n",
"\n",
"Les boucles sont utiles pour répéter de nombreuses fois la même\n",
"opération. \n",
"Par exemple si l’on souhaite afficher tous les éléments d’une liste,\n",
"écrire autant de **print** qu’il y a d’éléments serait assez pénible.\n",
"\n",
"Comme pour les structures conditionnelles, il est très important de\n",
"respecter l’indentation !\n",
"\n",
"### 3.1 La boucle for\n",
"\n",
"Il y a plusieurs manières d’utiliser la boucle **for**, voici quelques\n",
"exemples.\n",
"\n",
"Il est très fréquent d’utiliser avec les boucles la méthode\n",
"**range(start, stop, step)** qui génére une suite d’entiers\n",
"\n",
"- start : Valeur de départ de la séquence (optionnelle). Par défaut,\n",
" elle est définie à 0.\n",
"- stop : Valeur de fin de la séquence (exclue).\n",
"- step : Pas d’incrément (optionnel). Par défaut, il est défini à 1."
],
"id": "ddd748aa-4892-4951-805e-d8bd80609447"
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# Afficher les entiers entre 1 et 6\n",
"for i in range(1, 6):\n",
" print(i)"
],
"id": "35ab6979"
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"for i in range(6):\n",
" print(i, i ** 2, sep=\"\\t\")"
],
"id": "a1afb790"
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# Parcours d'une liste\n",
"personnages = [\"Luke\", \"Leia\", \"Han\", \"Obi-Wan\"]\n",
"\n",
"for p in personnages:\n",
" print(\"Hello \" + p)"
],
"id": "9f6b0e8a"
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"# Parcours d'une liste par indice\n",
"for i in range(len(personnages)):\n",
" print(\"Personnage \" + str(i) + \" : \" + personnages[i])"
],
"id": "6a00333f"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La fonction **enumerate()** est utilisée pour itérer simultanément sur\n",
"les indices et les éléments. \n",
"Elle permet de générer un tuple(indice, élément)"
],
"id": "03253790-d936-469d-bf28-67de23c2c3ce"
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"list(enumerate(personnages))"
],
"id": "8c8acd46"
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"# Parcours d'une liste en utilisant enumerate\n",
"for numero, nom in enumerate(personnages):\n",
" print(\"Personnage \" + str(numero) + \" : \" + nom)"
],
"id": "65ca7fe9"
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"# Parcours d'une chaîne de caractères\n",
"for char in \"Dark Vador\":\n",
" print(char, end=\" - \")"
],
"id": "aed456fd"
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"import time\n",
"\n",
"message = \"Salut les lapinous\"\n",
"for i in range(len(message)):\n",
" time.sleep(0.5)\n",
" print(message[i], end=\"\")"
],
"id": "7b57647b"
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"ingredients = {'sucre': '100g', 'poire': 2, 'lait': '1L', 'sel': True}\n",
"\n",
"# Parcours des clés d'un dictionnaire\n",
"for cle in ingredients:\n",
" print(cle)"
],
"id": "26645612"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.2 La boucle while\n",
"\n",
"Le principe de la boucle **while** est le suivant :\n",
"\n",
"- une condition d’entrée dans la boucle est définie\n",
"- tant que la condition est vérifiée, le code dans la boucle est\n",
" exécuté\n",
"- et ainsi de suite, jusqu’à ce que l’on sorte de la boucle (ou que\n",
" l’on reste coincé dedans à tout jamais…)"
],
"id": "3d7a36ff-efd3-49b4-8140-597929591b4b"
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"cpt = 5\n",
"while cpt >= 0:\n",
" print(cpt, end=\"...\")\n",
" cpt -= 1 # cpt = cpt - 1\n",
"print(\"Boom\")"
],
"id": "b83c3046"
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"user_input = input(\"Entrez un nombre pair : \")\n",
"while int(user_input) % 2 != 0:\n",
" print(\"Ce n'est pas un nombre pair.\")\n",
" user_input = input(\"Entrez un nombre pair : \")\n",
"print(\"Merci, vous avez entré un nombre pair.\")"
],
"id": "5dc2ce94"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Critère d’arrêt\n",
"\n",
"La différence principale avec la boucle **for** est le critère\n",
"d’arrêt. \n",
"Dans une boucle **for**, ce critère est clair : la boucle itère sur les\n",
"éléments d’un objet itérable, nécessairement de taille finie.\n",
"\n",
"Au contraire, dans la boucle **while**, ce critère peut ne jamais se\n",
"réaliser et l’on se retrouve alors dans une boucle infinie…\n",
"\n",
"Par exemple si l’on se trompe dans le nom des indices, voici le résultat\n",
":"
],
"id": "108f8034-8897-49de-8a84-8dc2765c6b7c"
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"# Utilisez le bouton \"Stop\" (carré noir) de Jupyter pour arrêter le programme en cours\n",
"i = 1\n",
"j = 1\n",
"while i <= 5:\n",
" j = j + 1"
],
"id": "bb8cd470"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Comme `i = 1` et ne change jamais, la condition `i <= 5` est toujours\n",
"égale à **True**"
],
"id": "fcbfa6fa-8444-47d4-9a29-3083fe3c6264"
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"print(i)\n",
"print(j)"
],
"id": "74e5ba34"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.3 L’instruction break\n",
"\n",
"Une autre possibilité pour sortir d’une boucle **for** ou **while** est\n",
"d’utiliser l’instruction **break**.\n",
"\n",
"Le code ci-dessous montre une utilisation de cette instruction :\n",
"\n",
"- On rentre dans une boucle infinie (`While true`)\n",
"- Le seul moyen d’en sortir est de trouver le bon nombre, ce qui nous\n",
" envoie vers le `break`\n",
"\n",
"Le code contient également des instructions `try` et `except` qui gérent\n",
"le cas ou la valeur saisie n’est pas numérique.\n",
"\n",
"Remarque : en cas de boucles imbriquées, le **break** ne met fin qu’à la\n",
"boucle de niveau supérieur."
],
"id": "3973f4b0-8364-41e9-824f-b7ef10e9c29f"
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"\n",
"nombre_aleatoire = random.randint(1, 20)\n",
"\n",
"print(\"Entrez un nombre entre 1 et 20\")\n",
"while True:\n",
" nombre_saisi = input()\n",
" try:\n",
" nombre_saisi = int(nombre_saisi)\n",
" if nombre_saisi == nombre_aleatoire:\n",
" break\n",
" elif nombre_saisi < 1 or nombre_saisi > 20:\n",
" print(\"Entre 1 et 20 !!!\") \n",
" elif nombre_saisi > nombre_aleatoire:\n",
" print(\"c'est moins\")\n",
" elif nombre_saisi < nombre_aleatoire:\n",
" print(\"c'est plus\")\n",
" except ValueError:\n",
" print(\"Veuillez entrer un entier valide\")\n",
" \n",
"print(\"Félicitations, vous avez trouvé le nombre secret :\", nombre_aleatoire)"
],
"id": "a5eb026c"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3.4 L’instruction continue\n",
"\n",
"L’instruction **continue** permet de passer à l’itération suivante de la\n",
"boucle.\n",
"\n",
"Dans l’exemple ci-dessus :\n",
"\n",
"- on rentre dans une boucle infinie\n",
"- tant que l’on ne rentre pas le bon prénom, on recommence au début de\n",
" la boucle\n",
" - puis on ne sort de la boucle que lorsque l’on a rentré le bon\n",
" mot de passe"
],
"id": "5ff1462b-323e-41b0-a7fe-e5de1b7c599f"
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"votre_prenom = \"alice\"\n",
"\n",
"while True:\n",
" print(\"Veuillez entrer votre prénom.\")\n",
" prenom = input()\n",
" if prenom != votre_prenom:\n",
" continue\n",
" print(\"Veuillez entrer votre mot de passe.\")\n",
" mdp = input()\n",
" if mdp == \"123456\":\n",
" break\n",
"print(\"Bienvenue \" + votre_prenom)"
],
"id": "284c7a2b"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4 Exercices\n",
"\n",
"### 4.1 Exercice 1\n",
"\n",
"Ecrire un programme qui calcule la somme des 10 premiers entiers au\n",
"carré. \n",
"Ecrire un programme qui calcule la somme des 5 premiers entiers impairs\n",
"au carré."
],
"id": "ade113aa-2c43-4963-8f8c-180d5fc8f73f"
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "381a522e"
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"# Remarque : avec Python il est possible parfois de condenser l'écriture\n",
"sum(i**2 for i in range(1,11) if i%2 == 1)"
],
"id": "5d54d3e5"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.2 Exercice 2\n",
"\n",
"Ré-écrivez le code ci-dessous à l’aide d’une boucle **for**. \n",
"Indice : explorez les différentes utilisations de la méthode **range()**"
],
"id": "9d69de6f-8926-492b-90e7-4bae20c64b7e"
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"cpt = 5\n",
"while cpt >= 0:\n",
" print(cpt)\n",
" cpt -= 1 # cpt = cpt - 1\n",
"print(\"Boom\")"
],
"id": "77098aba"
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "2359d213"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.3 Exercice 3\n",
"\n",
"Réécrivez la boucle `for` suivante à l’aide d’une boucle `while`."
],
"id": "b61fd785-df5a-4b12-a93d-61a9f1cfa2a7"
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"gamme = ['do', 're', 'mi', 'fa', 'sol', 'la', 'si']\n",
"\n",
"for i, note in enumerate(gamme):\n",
" print(\"La note numéro \" + str(i) + \" de la gamme de do majeur est \" + note)"
],
"id": "2a0aabda"
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "fab4565c"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.4 Exercice 4\n",
"\n",
"Triez la liste ci-dessous à l’aide de 2 boucles **for** (sans utiliser\n",
"de méthode toute faite de tri) :\n",
"\n",
"- `liste = [34, 7, 20, 12, 50, 23, 16, 28, 6, 11, 19, 13, 26, 8, 9]`"
],
"id": "c77bc308-4706-4765-9dbc-0d3d4db6773f"
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "880cb7a7"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.5 Exercice 5\n",
"\n",
"Ecrivez un programme permettant de calculer les 10 premiers termes de la\n",
"suite de Fibonacci à l’aide d’une boucle **for**. \n",
"Même question avec une boucle **while**.\n",
"\n",
"Rappel : La suite de Fibonacci se définit de la manière suivante :\n",
"\n",
"- les deux premiers nombres sont 0 et 1\n",
"- chaque autre nombre de la suite s’obtient en additionnant les deux\n",
" nombres qui le précèdent"
],
"id": "80a285a7-59de-4205-b5a3-80cb859c8a04"
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "bee6a1e1"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.6 Exercice 6\n",
"\n",
"Calculer le minimum et le maximum de la série de valeurs suivantes, sans\n",
"utiliser les fonctions `min` et `max` de Python.\n",
"\n",
"x = \\[8, 18, 6, 0, 15, 17.5, 9, 1\\]"
],
"id": "0ee2cf72-2ce3-4bc3-bf3b-0272c677918f"
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "74b7ea2c"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.7 Exercice 7\n",
"\n",
"À l’aide de boucles **for** et **while**, parcourez ce dictionnaire et\n",
"affichez la moyenne de chaque élève."
],
"id": "8a13c8a7-03c8-47dc-baf5-0f894b16f27e"
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"notes = {\n",
" \"Miranda\" : [16, 5, 8, 12],\n",
" \"Celestin\" : [19, 1, 7, 10],\n",
" \"Hypolyte\" : [18, 3, 12],\n",
" \"Josephine\": [12, 15, 14, 14]\n",
"}"
],
"id": "51b1d678"
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "b00d9d40"
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4.8 Exercice 8\n",
"\n",
"Calculer la moyenne et la variance de la série de valeurs suivantes,\n",
"sans utiliser des fonctions déjà codées :\n",
"\n",
"x = \\[8, 18, 6, 0, 15, 17.5, 9, 1\\]\n",
"\n",
"Pour rappel, les formules sont :\n",
"\n",
"- moyenne : $$\\bar{x} = {\\frac {1}{n}}\\sum_{i=1}^{n}x_{i}$$\n",
"- variance :\n",
" $$\\sigma^2 = {\\frac {1}{n}}\\sum_{i=1}^{n} (x_{i}-\\bar{x})^2$$"
],
"id": "dfd26fab-d3df-41a6-b3ac-7ac355bc5547"
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Testez votre réponse dans cette cellule"
],
"id": "2f5eca2c"
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
"# Pour vérifier vos résultats\n",
"import numpy as np\n",
"\n",
"# Create an array of numbers\n",
"x = [8, 18, 6, 0, 15, 17.5, 9, 1]\n",
"\n",
"print(\"Mean : \", np.mean(x))\n",
"print(\"Variance : \", np.var(x))"
],
"id": "6d7a052d"
}
],
"nbformat": 4,
"nbformat_minor": 5,
"metadata": {
"kernelspec": {
"name": "python3",
"display_name": "Python 3 (ipykernel)",
"language": "python",
"path": "/opt/hostedtoolcache/Python/3.10.14/x64/share/jupyter/kernels/python3"
},
"language_info": {
"name": "python",
"codemirror_mode": {
"name": "ipython",
"version": "3"
},
"file_extension": ".py",
"mimetype": "text/x-python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.14"
}
}
}