2_base_programmation.ipynb

{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# Programmation Python 3 - Conditions et boucles"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Les Opérateurs en Python"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Opérateurs de comparaison"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Il existe des opérateurs permettant de tester l'égalité ou l'inégalité entre différentes données. Ces opérateurs peuvent être utilisés avec différents types de données. Attention, un même opérateur peut avoir un comportement différent en fonction du type de données traité. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Le résultat d'une comparaison est un booléen. C'est-à-dire qu'il ne peut prendre que deux valeurs possibles:\n- True si la comparaison est Vraie\n- False si la comparaison est Fausse"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Opérateur | Signification        |\n",
    "|-----------|----------------------|\n",
    "| ==        | Égale à              |\n",
    "| !=        | Différent de         |\n",
    "| <         | Inférieur à          |\n",
    "| <=        | Inférieur ou égale à |\n",
    "| \\>        | Supérieur à          |\n",
    "| \\>=       | Supérieur ou égale à |\n"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**Attention**: une erreur classique est de confondre les signes `=` et `==`. L'opérateur `=` permet de réaliser une affectation de valeur quand l'opérateur `==` permet de tester une égalité !   "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Opérateurs logiques"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Ils permettent d'associer des expressions dans un contexte booléen. En effet, ils permettent de combiner deux ou plusieurs conditions. \n"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Opérateur | Signification |\n",
    "|-----------|---------------|\n",
    "| and       | ET Logique    |\n",
    "| or        | OU Logique    |\n",
    "| not       | NON Logique   |"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "#### ***Exercice 1***"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Retrouver ou trouver comment se comporte chacune des fonctions booléennes présentées ci-dessus. Pour cela, vous pouvez considérer deux conditions d'entrée et en fonction de leurs états successifs en déduire la valeur de sortie. \n*Vous pouvez présenter vos résultats sous forme de tables de vérité*. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Opérateurs binaires"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Les opérateurs binaires sont utilisés pour effectuer des opérations sur les données au format binaire, c'est-à-dire exprimées sous forme de bits. Un bit étant la plus petite unité de donnée d'un ordinateur. Celle-ci ne peut prendre que deux valeurs possibles 0 ou 1, appelée valeur binaire. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Toutes les valeurs décimales (exprimées en base 10 c.-à-d. 10 symboles) seront converties en valeurs binaires (séquence de bits donc suite de 0 et/ou 1 comme par exemple 0010 1100, ...). Ces opérateurs binaires effectuent donc des opérations bit à bit. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Opérateur | Signification             |\n",
    "|-----------|---------------------------|\n",
    "| &         | ET Logique                |\n",
    "| \\|        | OU Logique                |\n",
    "| ~         | NON Logique               |\n",
    "| ^         | OU Exclusif: XOR          |\n",
    "| \\>\\>      | Décalage binaire à droite |\n",
    "| <<        | Décalage binaire à gauche |"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Opérateurs d'identité"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Les opérateurs d'identité sont utilisés pour vérifier si deux variables ou données pointent vers le même objet donc la même case mémoire. Pour info, l'instruction `id(<variable>)` permet de récupérer l'adresse de la case mémoire pointée par *donnée*. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Opérateur | Signification           |\n",
    "|-----------|-------------------------|\n",
    "| is        | Est le même objet       |\n",
    "| is not    | N'est pas le même objet |"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Opérateurs d'appartenance"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Les opérateurs d'appartenance sont utilisés pour vérifier si une valeur ou une variable, une donnée est présente (ou non) dans un objet sous forme de séquence (chaîne de caractères, liste, tuple, set et dictionnaire que dans la clé). "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Opérateur | Signification          |\n",
    "|-----------|------------------------|\n",
    "| in        | Est dans l'objet       |\n",
    "| not in    | N'est pas dans l'objet |"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Opérateurs d'affectation"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Les opérateurs d'affectation sont utilisés pour attribuer une valeur à u variable. La variable est l'opérande de gauche, sa valeur est celle de droite. En dehors de l'affectation réalisée à l'aide du symbole `=`, les autres opérateurs appelés opérateurs d'affectation augmentée, combinent une opération arithmétique ou binaire et une affectation de valeur à une variable, **préalablement initialisée**. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "| Opérateur | Signification                            | Exemple   | Equivalent à |\n",
    "|-----------|------------------------------------------|-----------|--------------|\n",
    "| +=        | Addition et affectation                  | a += b    | a = a+b      |\n",
    "| -=        | Soustraction et affectation              | a -= b    | a = a-b      |\n",
    "| \\*=       | Multiplication et affectation            | a \\*= b   | a = a\\*b     |\n",
    "| /=        | Division et affectation                  | a /= b    | a = a/b      |\n",
    "| %=        | Modulo et affectation                    | a %= b    | a = a%b      |\n",
    "| //=       | Division entière et affectation          | a //= b   | a = a//b     |\n",
    "| \\*\\*=     | Exponentiation et affectation            | a \\*\\*= b | a = a\\*\\*b   |\n",
    "| &=        | ET bit à bit et affectation              | a &= b    | a = a&b      |\n",
    "| \\|=       | OU bit à bit et affectation              | a \\|= b   | a = a\\|b     |\n",
    "| ^=        | XOR et affectation                       | a ^= b    | a = a^b      |\n",
    "| >>=       | Décalage binaire à droite et affectation | a >>= b   | a = a>>b     |\n",
    "| <<=       | Décalage binaire à gauche et affectation | a <<= b   | a = a<<b     |\n",
    "\n"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Structures conditionnelles"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Les structures conditionnelles permettent d'exécuter une partie du code uniquement si une certaine condition est `True` (=Vraie). L'instruction **if...elif...else** (=Si...Sinon Si...Sinon) est utilisée en langage Python pour la prise de décision. "
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:39.333391Z",
     "start_time": "2024-10-25T15:36:39.290265Z"
    }
   },
   "cell_type": "code",
   "source": "#Syntaxe d'écriture\nif condition1:\n    instruction1\nelif condition2:\n    instruction2\nelif condition3:\n    instruction3\nelse:\n    instruction4",
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'condition1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mNameError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[2], line 2\u001B[0m\n\u001B[1;32m      1\u001B[0m \u001B[38;5;66;03m#Syntaxe d'écriture\u001B[39;00m\n\u001B[0;32m----> 2\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[43mcondition1\u001B[49m:\n\u001B[1;32m      3\u001B[0m     instruction1\n\u001B[1;32m      4\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m condition2:\n",
      "\u001B[0;31mNameError\u001B[0m: name 'condition1' is not defined"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "En fonction de la condition remplie, c'est une instruction précise qui sera exécutée. \n",
    "- Ainsi, si la *condition1* est `True` alors l'*instruction1* sera exécutée, les autres instructions ne seront pas exécutées !\n",
    "- Si la *condition1* est `False`, et que la *condition2* est `True` alors l'*instruction2* sera exécutée, les autres instructions ne seront pas exécutées !\n",
    "- etc...\n",
    "- Si aucune condition précédente n'est `True`, alors l'*instruction4* sera exécutée.\n",
    "C'est l'équivalent du *switch/case* dans d'autres langages."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Le mot-clé `elif` est équivalent à dire **Si les conditions précédentes ne sont pas `True`, alors essayer cette condition**. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Le mot-clé `else` est équivalent à dire **Si toutes les conditions précédentes ne sont pas `True`, alors faire cette instruction**. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "En Python, les instructions sont indentées par rapport aux tests sur les conditions. Le corps de ces instructions commence par une indentation et la première ligne non indentée marque leur fin. "
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Python interprète les valeurs non nulles comme `True`. `None` et `0` sont interprétés comme `False`. "
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:39.345249Z",
     "start_time": "2024-10-25T15:36:39.339260Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#Exemple d'utilisation d'une boucle if\n",
    "val1 = 10\n",
    "val2 = 6\n",
    "if val1 < val2:\n",
    "    print(val1, \" est plus petit que \", val2)\n",
    "elif val1 > val2:\n",
    "    print(val2, \" est plus petit que \", val1)\n",
    "else:\n",
    "    print(\"Les deux variables ont la même valeur: \", val1)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6  est plus petit que  10\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Il est possible d'écrire sur une seule et même ligne l'ensemble de la structure d'un **if...else** à condition de ne réaliser qu'une seule instruction dans chaque cas.  "
  },
  {
   "metadata": {
    "trusted": false,
    "ExecuteTime": {
     "end_time": "2024-10-25T15:36:39.363125Z",
     "start_time": "2024-10-25T15:36:39.356733Z"
    }
   },
   "cell_type": "code",
   "source": "#Exemple d'une boucle if else sur une seule ligne\nval1 = 10\nval2 = 6\nprint(val1, \" est plus petit que \", val2) if val1 == val2 else print(\"les deux variables n'ont pas la même valeur\")",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "les deux variables n'ont pas la même valeur\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "À noter qu'il est possible d'imbriquer une structure **if...elif...else** dans une structure **if...elif...else**, elle-même imbriquée dans une structure **if...elif...else**, ..."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "#### ***Exercice 2***"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Écrire un script Python appelé `isodd.py` qui vérifie si un nombre saisi par l'utilisateur est un nombre pair ou impair. \n",
    "- Attention aux commentaires\n",
    "- Attention aux noms de variables.  \n",
    "*Faites valider votre script ainsi que son exécution.* "
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "#### ***Exercice 3***"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Écrire un script Python appelé `leap_year.py` qui vérifie si une année saisie par l'utilisateur est une année bissextile ou non.\n",
    "Sachant qu'une année est bissextile si elle est divisible par 4 mais pas par 100 à l'exception\n",
    " de celles divisible par 400 (voir https://fr.wikipedia.org/wiki/Ann%C3%A9e_bissextile).\n",
    "- Attention aux commentaires\n",
    "- Attention aux noms de variables.  \n",
    "*Faites valider votre script ainsi que son exécution*. "
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "#### ***Exercice 4***"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Calculer notre masse idéale en connaissant notre taille en fonction de l'IMC (Indice de Masse Corporelle). De même, il est également possible de calculer votre IMC en fonction de votre taille et votre masse réelle. L'IMC est calculée grâce à la formule :\n",
    "- Masse = IMC x Taille²  \n",
    "*Masse est exprimée en kilogramme et la Taille en mètre*\n",
    "\n",
    "Une personne de corpulence \"normale\" a un IMC entre 18.5 et 24,9. Un IMC supérieur à 24,9 signifie que la personne est en surpoids. À l'inverse, un IMC inférieur à 18,5 la personne est en maigreur. Le schéma ci-dessous présente les différentes tranches de corpulence en fonction de la valeur de l'IMC. "
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "1. Écrire un script Python appelé `ideal_bmi.py` qui calcule l'intervalle de poids \"idéal\" d'un utilisateur ayant saisi au préalable sa taille.\n",
    "2. Écrire un script Python appelé `compute_bmi.py` de coaching qui à partir de la taille et de la masse saisies par l'utilisateur, calcule l'IMC et affiche un conseil nutritionnel ou sportif. \n",
    "\n",
    "- Attention aux commentaires\n",
    "- Attention aux noms de variables.  \n",
    "*Faites valider votre script ainsi que son exécution*. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}