Python_intro2_structures_conditionnelles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# INTRODUCTION AU LANGAGE PYTHON appliqué au programme de 2 BCP: les structures conditionnelles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Extrait *BO* Programme de **Mathématiques** 2 BCP domaine *Algorithmique et programmation* :\n",
    "\n",
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <th align=\"center\"><b>Capacités</th>\n",
    "    <th align=\"center\"><b>Connaissances</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Décomposer un problème en sous-problèmes.</td>\n",
    "    <td> </td>\n",
    "  </tr>  \n",
    "    <tr>\n",
    "    <td>Analyser un problème.</td>\n",
    "    <td> </td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Repérer les enchaînements logiques et les traduire en instructions conditionnelles et en boucles.\n",
    "    </td>\n",
    "    <td valign=\"top\">Séquences d’instructions, instructions conditionnelles, boucles bornées (for) et non bornées (while).  \n",
    "    </td>\n",
    "  </tr>  \n",
    "</table>\n",
    "\n",
    "Ce *notebook* (document *interactif*) traite des **structures conditionnelles** en Python. Les prérequis sont *les variables et les fonctions* .  \n",
    "La première partie présente les notions essentielles.  \n",
    "La deuxième partie présente des exercices suggérés dans les paragraphes *Exemples d'algorithmes et d'activités numériques* du programme.   \n",
    "- **Les codes du document peuvent être complétés, testés et modifiés**. Pour celà, `clic` sur le cadre, puis `shift-enter` ou &#x27A7;`Exécuter` dans la barre d'outils ci-dessus.  \n",
    "Pour *rafraîchir* tous les codes, `Kernel` -> `Restart & Clear Output`  \n",
    "Pour *rafraîchir* un seul code (*JupyterLab*), `clic-droit` -> `Clear Outputs`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LES STRUCTURES CONDITIONNELLES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les **structures conditionnelles** permettent d'exécuter une ou plusieurs instructions dans un cas, d'autres instructions dans d'autres cas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les opérateurs de comparaison\n",
    "\n",
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <td align=\"center\"><b><</b></td>\n",
    "    <td>strictement inférieur à</b></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b>></b></td>\n",
    "    <td>strictement supérieur à</b></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b> &lt;= </b></td>\n",
    "    <td>inférieur ou égal</b></td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td align=\"center\"><b>>=</b></td>\n",
    "    <td>supérieur ou égal à</b></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b>==</b></td>\n",
    "    <td>égal à</b></td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td align=\"center\"><b>!=</b></td>\n",
    "    <td>différent de</b></td>\n",
    "  </tr> \n",
    "</table>\n",
    "\n",
    "### Les différentes formes de structures conditionnelles\n",
    "Un test (ou **prédicat**) renvoie un **BOOLEEN** (objet de type *bool*).  \n",
    "- Si le boolléen vaut ***True***, les instructions sont exécutées.\n",
    "- Si le boolléen vaut ***False***, les instructions ne sont pas exécutées."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Forme simple **si** (**if**)\n",
    "*Exécuter le code suivant pour afficher les résultats.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age=input(\"votre âge ?\")\n",
    "age=int(age)\n",
    "\n",
    "if age>=18:                             \n",
    "    print(\"Vous êtes majeur.\")          #DEBUT DU  BLOC CONDITIONNEL avec l'indentation (espacement)\n",
    "\n",
    "#FIN DU BLOC CONDITIONNEL à la fin de l'indentation \n",
    "print(\"Fin du questionnaire\")           #Toutes les instructions hors du bloc sont exécutées.\n",
    "\n",
    "#Modifier l'âge d'entrée et observer les résultats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Forme **si ... alors ...** (**if ... else**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age=input(\"votre âge ?\")\n",
    "age=int(age)\n",
    "\n",
    "if age>=18:\n",
    "    print(\"Vous êtes majeur.\")\n",
    "else:\n",
    "    print(\"Vous êtes mineur.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Forme **si ... sinon si ... alors** (**if ... elif ... else**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valeur=input(\"Entrer une valeur:\")\n",
    "valeur=int(valeur)\n",
    "\n",
    "if valeur>0:\n",
    "    print(\"la valeur est strictement positive\")       #Bloc d'instruction 1\n",
    "elif valeur==0:\n",
    "    print(\"la valeur est nulle\")                      #Bloc d'instruction 2; plusieurs blocs elif peuvent être utilisés\n",
    "else:\n",
    "    print(\"la valeur est strictement négative\")       #Bloc d'instruction 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A RETENIR:**  \n",
    "Ne pas oublier les **:**  \n",
    "Respecter les indentations des blocs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les mots clé **and**, **or**, **not**\n",
    "Ce sont **des opérateurs logiques** qui s'appliquent aux booléens.  \n",
    "Voici la *table de vérité* des opérateurs *and* et *or*:\n",
    "\n",
    "<table align=\"center\">\n",
    "  <tr>\n",
    "    <th align=\"center\">a</th>\n",
    "    <th align=\"center\">b</td>\n",
    "    <th align=\"center\">a <b>and</b> b</th>\n",
    "    <th align=\"center\">a <b>or</b> b</th>\n",
    "  </tr>\n",
    "  <tr align=\"center\">\n",
    "    <td><i>True</i></td>\n",
    "    <td><i>True</i></td>\n",
    "    <td><i>True</i></td>\n",
    "    <td><i>True</i></td>\n",
    "  </tr> \n",
    "  <tr>\n",
    "    <td><i>True</i></td>\n",
    "    <td><i>False</i></td>\n",
    "    <td><i>False</i></td>\n",
    "    <td><i>True</i></td>\n",
    "  </tr> \n",
    "  <tr>\n",
    "    <td><i>False</i></td>\n",
    "    <td><i>True</i></td>\n",
    "    <td><i>False</i></td>\n",
    "    <td><i>True</i></td>\n",
    "  </tr> \n",
    "  <tr>\n",
    "    <td><i>False</i></td>\n",
    "    <td><i>False</i></td>\n",
    "    <td><i>False</i></td>\n",
    "    <td><i>False</i></td>\n",
    "  </tr> \n",
    "</table>\n",
    "\n",
    "*Analysez le code suivant, puis exécutez-le pour observer les résultats.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=10\n",
    "b=20\n",
    "\n",
    "test1=a<15 and b<15\n",
    "test2=a<15 or b<15\n",
    "test3=a>=10 or b!=15\n",
    "\n",
    "print(type(test1))\n",
    "print(test1)\n",
    "print(test2)\n",
    "print(test3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices d'applications"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Géométrie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Compléter la fonction suivante qui permet de savoir si un triangle est rectangle grâce à la réciproque du théorême de Pythagore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def triangle_rectangle(a,b,c):\n",
    "    \"\"\"\n",
    "    En entrée:\n",
    "    a,b,c: longueurs des côtés du triangle\n",
    "    \n",
    "    En sortie:\n",
    "    str: \"Le triangle est rectangle\" ou \"Le triangle n'est pas rectangle\"\n",
    "    \"\"\"\n",
    "    \n",
    "    if a**2+b**2==c**2 or #Votre code: test de toutes les combinaisons\n",
    "        print(\"Le triangle est rectangle.\")\n",
    "    else:\n",
    "        #Votre code\n",
    "        \n",
    "#Tests fonction\n",
    "triangle_rectangle(3,4,5)\n",
    "triangle_rectangle(4,3,5)\n",
    "triangle_rectangle(5,6,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Compléter le programme suivant qui renvoie la longueur manquante d'un côté d'un triangle rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=input(\"hypoténuse:\")\n",
    "b=input(\"côté:\")\n",
    "c=input(\"côté:\")\n",
    "\n",
    "if a==\"\":      #Si l'utilisateur n'a pas entré de valeur\n",
    "    #Votre code\n",
    "    #Penser à convertir les données !!\n",
    "\n",
    "if b==\"\":\n",
    "    #Votre code\n",
    "    \n",
    "if  #Votre code\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonctions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Compléter le programme suivant permettant de déterminer l'équation réduite d'une droite non // à l'axe des ordonnées en ajoutant une condition.  \n",
    "Si x<sub>A</sub> &ge; x<sub>B</sub>, afficher un message \"*x<sub>A</sub> doit être strictement inférieure à x<sub>B</sub>. Entrer d'autres coordonnées.*\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xA=float(input(\"xA?\"))\n",
    "yA=float(input(\"yA?\"))\n",
    "xB=float(input(\"xB?\"))\n",
    "yB=float(input(\"yB?\"))\n",
    "\n",
    "#Détermination du coefficient a\n",
    "a=(yB-yA)/(xB-xA)\n",
    "\n",
    "#Détermination du coefficient b\n",
    "b=yA-a*xA\n",
    "\n",
    "print(\"L'équation réduite de la droite est: y=\",a,\".x +\",b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Ecrire un programme permettant de savoir si 2 droites non // à l'axe des ordonnées sont perpendiculaires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1=float(input(\"coefficient directuer de la droite 1\"))\n",
    "a2=float(input(\"coefficient directuer de la droite 2\"))\n",
    "\n",
    "#Votre code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Compléter le programme suivant permettant de résoudre une inéquation du type **a.x < b**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=float(input(\"a?\"))\n",
    "b=float(input(\"b?\"))\n",
    "\n",
    "if a>0:\n",
    "    #Votre code\n",
    "        \n",
    "        \n",
    "elif a<0:\n",
    "    #Votre code\n",
    "        \n",
    "        \n",
    "elif a==0 and b>0:\n",
    "    #votre code\n",
    "    \n",
    "    \n",
    "else:\n",
    "    print(\"pas de solution\")\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Réaliser un programme renvoyant les solutions d'une équation du type **a.x<sup>2</sup>+b.x+c=0** .  \n",
    "Remarque: La résolution à l'aide du discriminant n'est plus au programme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Votre code\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}