TD2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vrai ou faux en python (`True` et `False`)\n",
    "\n",
    "Python donne une valeur vraie ou fausse à une affirmation, par exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5>1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5<1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Il est plus propre d'utiliser la fonction `print` pour afficher un résultat. Nous allons donc le faire à partir de maintenant. Mais il faut bien noter que sans la fonction, le test est tout de même réalisé :*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5<1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut combiner les affirmations avec des \"et\" et des \"ou\", comme on le fait dans le langage courant. Cela fonctionne de la façon suivant :\n",
    "- l'affirmation « A et B » est vraie uniquement si A et B sont tous deux vraies. \n",
    "- L'affirmation « A ou B » est vraie si au moins une des deux affirmations A ou B est vraie.\n",
    "\n",
    "Par exemple la commande suivante teste la valeur de vérité de l'affirmation \"5 est supérieur à 1 et 5 est inférieur à 10\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5>1 and 5<10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "la commande suivante teste l'affirmation \"5 est supérieur à 1 et 5 est inférieur à 2\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5>1 and 5<2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 1.1\n",
    "Avant d'exécuter le programme suivant, devinez si les résultats sont `True` ou `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5>1 or 5<10)\n",
    "print(5>1 or 5<2)\n",
    "print(5<1 or 5<2)\n",
    "print((5<1 or 5<10) and 5>3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test d'une égalité\n",
    "Si on veut tester qu'un nombre est égal à un autre, il faut utiliser l'opérateur `==` et non `=`, qui est réservé à l'affectation d'une variable. Voici deux exemples de test d'égalité :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5==5)\n",
    "print(5==3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exemple suivant illustre la différence entre `=` et `==`. Le premier `print` affiche la valeur de la variable `a`, tandis que les deux suivants affichent la valeur des tests `a==2` et `a==5`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "print(a)\n",
    "print(a==2)\n",
    "print(a==5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 1.2\n",
    "Dans l'exemple suivant, remplacer `==` par `=`, exécuter et commenter le résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=5\n",
    "print(a==2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# Variables booléennes\n",
    "\n",
    "On peut affecter le résultat d'un test à une variable. Cette variable ne peut alors prendre que deux valeurs : `True` ou `False` (avec une majuscule). C'est une variable booléenne. Nous avons déjà vu ce type de variable dans le TD 1. Voici un exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "macondition = (5>1 or 5<10)\n",
    "print(macondition)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans l'ordinateur, le `False` est traité comme un `0` et le `True` comme un `1`. On peut donc faire des opérations mathématiques avec des variables booléenne, comme par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True + True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = True\n",
    "b = a * 4\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 1.3\n",
    "Le programme suivant définit deux variables booléennes `vrai` et `faux`. Avant de l'éxécuter, deviner si les résultats des opérations proposées sont `True` ou `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vrai = True\n",
    "faux = False\n",
    "print(\"vrai et vrai : \", vrai and vrai)\n",
    "print(\"vrai et faux : \", vrai and faux)\n",
    "print(\"faux et faux : \", faux and faux)\n",
    "print(\"vrai ou vrai : \", vrai or vrai)\n",
    "print(\"vrai ou faux : \", vrai or faux)\n",
    "print(\"faux ou faux : \", faux or faux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Les structures conditionnelles (`if`, `elif`, `else`)\n",
    "\n",
    "*Les structures conditionnelles permettent d'effectuer des opérations lorsqu'une ou plusieurs conditions sont remplies, c'est-à-dire lorsqu'un test du type précédent est `True`.*\n",
    "\n",
    "_____________\n",
    "\n",
    "## Structure simple (`if`):\n",
    "Le principe est de dire que si (`if`) telle condition est vérifiée, alors telles commandes sont effectuées.\n",
    "\n",
    "\n",
    "Voici la syntaxe :\n",
    "\n",
    "    if condition :\n",
    "        commande1\n",
    "        commande2\n",
    "\n",
    "- **Attention devant chaque commande liée à la condition testée, il faut placer une tabulation (ou 4 caractères vides). On appelle cela indenter.** Tant que les commandes sont indentées, elle ne seront exécutées que si la condition est satisfaite. Si l'on retire l'indentation, le programme reprend son cours normalement.\n",
    "\n",
    "- **Attention de ne pas oublier les `:` à la fin de la ligne du `if`**\n",
    "\n",
    "Voici un exemple, exécuter le plusieurs fois en modifiant la valeur de la `note` afin de voir le comportement du `if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 10\n",
    "\n",
    "if (note > 10 ) :\n",
    "    print(\"J'ai mon UE !\")\n",
    "    \n",
    "print(\"Ma note est : \", note)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 2.1\n",
    "Écrire un programme qui écrit un message \"note incorrecte\" si la variable note n'est pas comprise entre 0 et 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 22"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 2.2\n",
    "Écrire un programme qui écrit \"ce nombre est pair\" si la variable note est un nombre pair.\n",
    "\n",
    "Aide : afin de savoir si un nombre est pair, on peut faire un test sur le reste de la division. En *python* le reste d'une division s'obtient directement avec la fonction modulo `%` (exemple : `11 % 3`$\\rightarrow$2 ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------\n",
    "\n",
    "## Structure à deux possibilités (`if`...`else`)\n",
    "La structure conditionnelle peut être étendue. Si (`if`) la condition est respectée, je fais cela, sinon (`else`) je fais autre chose.\n",
    "\n",
    "    if condition :\n",
    "        commande1\n",
    "    else :\n",
    "        commande2\n",
    "\n",
    "Voici un exemple, exécuter le plusieurs fois en modifiant la valeur de la note pour voir le compoportement du `if`...`else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 9\n",
    "\n",
    "print (\"Ma note est :\",note)\n",
    "\n",
    "if (note > 10 ) :\n",
    "    print(\"J'ai mon UE !\")\n",
    "else :\n",
    "    print(\"Je dois repasser en session 2.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 3.1\n",
    "Reprendre le code de l'exercice 2.2. Puis le modifier pour qu'il écrive \"ce nombre est pair\" si la variable note est un nombre pair et qu'il écrive \"ce nombre est impair\" dans le cas contraire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------\n",
    "\n",
    "## Structure complexe à plusieurs possibilités (`if`...`elif`...`else`)\n",
    "La structure conditionnelle peut encore être étendue. Il est possible d'ajouter autant de conditions que l'on souhaite en ajoutant le mot clé `elif` , contraction de `else` et `if`, qu'on pourrait traduire par \"sinon si\".\n",
    "\n",
    "    if condition1 :\n",
    "        commande1\n",
    "    elif condition2 :\n",
    "        commande2\n",
    "    elif condition3 :\n",
    "        commande3\n",
    "    else :\n",
    "        commande4\n",
    "\n",
    "Voici un exemple, exécutez-le plusieurs fois en modifiant la valeur de la note pour voir le compoportement du `if`...`elif`...`else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre = -1\n",
    "\n",
    "if (nombre<0) :\n",
    "    print(\"C'est un nombre négatif.\")\n",
    "elif (nombre==0) :\n",
    "    print(\"c'est un nombre nul.\")\n",
    "else :\n",
    "    print(\"C'est un nombre positif\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "\n",
    "## Conditions composées (`and`, `or`)\n",
    "\n",
    "Il est possible de tester des conditions plus complexes, en combinant des conditions comme nous l'avons vu au début. Grâce à la commande `and`, on peut tester si deux conditions sont vérifiées en même temps.\n",
    "Voici un exemple :     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 13\n",
    "if (note >= 12) and (note < 14) :\n",
    "    print(\"J'ai la mention assez bien.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec la commande `or` on peut tester si une condition est vérifiée parmi un ensemble de conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 9\n",
    "if (note < 12) or (note >= 14) :\n",
    "    print(\"Je n'ai pas la mention assez bien.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est également possible de mettre le résultat d'une condition composée dans une variable de type `bool`, vue plus haut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 9\n",
    "condition = (note < 12) or (note >= 14)\n",
    "if  condition :\n",
    "    print(\"Je n'ai pas la mention assez bien.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 3.2 : mention à un examen\n",
    "Écrire un programme qui écrit la mention associée à la note définie à la première ligne, dans la variable `note` (assez bien pour $[12, 14[$ , bien pour $[14, 16[$, très bien pour $[16, 20]$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = 17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 3.3 : discriminant d'un polynôme de degré 2\n",
    "Écrire un programme qui calcule le discriminant `delta` d'un polynôme $ax^2 + bx + c$ et qui écrit \"les solutions sont réelles\" lorsque `delta` est positif ou nul, ou \"les solutions sont complexes\" dans le cas contraire.\n",
    "\n",
    "*On ne cherchera pas ici à calculer les solutions (c'est l'exercice suivant).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = 3\n",
    "\n",
    "delta ="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exercice 3.4 : racines d'un polynôme de degré 2\n",
    "Reprendre le programme écrit à l'exercice 3.3, en calculant puis en affichant les racines du polynôme dans le cas où elles sont réelles. On rappelle que les deux racines sont alors données par :\n",
    "$$x_1 = \\frac{-b - \\sqrt{\\Delta}}{2a}$$\n",
    "et\n",
    "$$x_2 = \\frac{-b + \\sqrt{\\Delta}}{2a}$$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 3.5 : racines d'un polynôme de degré 2\n",
    "Reprendre le programme précédent, en calculant puis en affichant les racines du polynôme dans tous les cas. Pour vous aider, voici un schéma logique du programme.\n",
    "\n",
    "<img src=\"http://lappweb.in2p3.fr/~maurin/expl201/StructuireEnIf.png\" alt=\"drawing\" width=\"500\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "\n",
    "## Exercice 3.6 : année bissextile\n",
    "*Vérifier si une année est bissextile.*\n",
    "\n",
    "On rappelle qu'une année est bissextile si l'une des deux conditions suivantes est vérifiée :\n",
    "- elle est un multiple de 4 mais pas de 100 (écrire un premier test)\n",
    "- elle est un multiple de 400 (faire ce deuxième test, si le premier est faux)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "## Exercice 3.7 : franchise d'assurance auto\n",
    "\n",
    "*Votre assurance auto vous rembourse 10% des frais de réparation suite à un accident à condition que ce remboursement soit supérieur de 150 euros (la franchise). Par ailleurs, votre contrat limite le remboursement à 1000 euros (si le remboursement calculé est plus grand, vous ne touchez que 1000 euros). Écrivez un programme qui affiche le montant du remboursement en fonction du montant des travaux (variable `montant`). Modifiez la valeur de `montant` pour tester que le programme fonctionne comme attendu.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "montant = 2000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "\n",
    "## Exercice 3.8 : jour de la semaine\n",
    "*À partir d'une date quelconque de l'année 2019 (ex. 15/09), calculer le nombre de jours qui se sont écoulés depuis le début de l'année (1/01).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jour = 15\n",
    "mois = 3\n",
    "\n",
    "if mois == 1 :\n",
    "    print(jour)\n",
    "elif mois == 2 :\n",
    "    print(jour + 31)\n",
    "elif mois == 3 :\n",
    "    print(jour + 31 +28)\n",
    "elif mois == 4 :\n",
    "    print(jour + 31 + 28 + 31)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------\n",
    "## Nombre complexe (Partie facultative)\n",
    "\n",
    "En *python*, il existe un type de variable pour traiter les nombres complexes. Mais on utilise le `j` pour noter la partie imaginaire (à la place du $i$ en math).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2 + 4j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4 \n",
    "\n",
    "Reprendre l'exercice 3.5 (racines d'un polynôme de second degré) avec les complexes, mais sans `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}