Tutorial_1_SimpleThings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Premiers Pas : classes et opérations de base, booléens\n",
    "\n",
    "-------------------------------------------------------------\n",
    "\n",
    "### `Hello World` \n",
    "\n",
    "Commençons par le standard `Hello World`. Nous allons demander à Python d'afficher du texte pour l'utilisateur (c'est vous !). Sélectionnez la cellule ci-dessous en cliquant dessus, puis appuyez sur `Shift` (`Maj` en bon françois) et `Enter` (`Entrée` en bon françois) en même temps pour lancer (on dit _exécuter_) la cellule et obtenir le résultat :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Bonjour tout le monde')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `print` est une des fonctions [_natives_](https://docs.python.org/3/library/functions.html) de Python, c'est à dire qu'elle est automatiquement reconnue par Python. Elle affiche le texte qu'on lui _passe_ en entrée.\n",
    "\n",
    "Vous aurez vu que pour appeler cette fonction et lui _passer_ quelque chose en entrée, on écrit le nom de la fonction, et on met le _quelque chose_ qu'on lui passe entre parenthèses simples `(` et `)` juste après le nom de la fonction. C'est le cas pour toutes les fonctions en Python. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "-------------------------------------------------------\n",
    "\n",
    "### Opérations de base\n",
    "\n",
    "Dans sa version de base, Python est très succinct et ne contient que très peu de fonctions, mais il contient quand même les additions `+`, soustractions `-`, multiplications `*`, divisions `/` et quelques autres opérations comme le _modulo_ `%` pour nous simplifier la vie :-). Ces opérations peuvent produire parfois des résultats surprenants, comme on le verra dans cette section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#### Additions\n",
    "\n",
    "Essayons d'effectuer des additions, et regardons ce que cela produit : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous voyez ici deux choses:  déjà, l'addition s'effectue correctement. Cela veut dire que Python a reconnu que les `1` que nous avons tapés sont bien des entiers (ou des nombres à virgule), ce qui n'est pas le cas dans tous les langages (par exemple le C).\n",
    "\n",
    "Mais en plus ... le résultat de l'opération s'affiche même sans avoir appelé la fonction \"print\" ! C'est une des spécificités du Python 'en cellules' que nous utilisons ici. Nous y reviendrons plus tard. Essayons maintenant d'ajouter des _pommes_ et des _poires_, et regardons si cela est possible :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 'toto'"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous voyez ici qu'il n'est pas possible d'ajouter `1` et `'toto'` à la fois ; vous vous doutez qu'ils ont une nature différente. Vous avez déjà peut-être remarqué que notre `'Bonjour tout le monde'` était entouré de guillemets, comme `'toto'`: c'est ainsi qu'on définit des chaînes de caractère, nommées `str`, pour _string_ (chaîne de caractères). Les simples nombres entiers nommés `int`, pour _integers_ (entiers) -- n'ont, eux, rien du tout. On peut, par contre, tout à fait ajouter des bouts de texte ensemble avec `+` ; le résultat vous surprendra peut-être :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Je suis' + 'assez content'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous voyez ici que le résultat est un 'collage' (on parle de _concaténation_) des chaînes de caractère ensemble. Le résultat ici est un peu approximatif, car il manque une espace entre les deux parties du texte. On peut la rajouter dans le bout de chaîne initial ou final, ou même rajouter un troisième bout de chaîne seulement avec l'espace, par exemple en tapant `'Je suis'`  + `' '` + `'très content'`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiplications\n",
    "\n",
    "Essayons maintenant d'effectuer des multiplications, à l'aide de `*` et faisons volontairement des bêtises : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3*3\n",
    "3*'toto'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'une part, vous voyez que Python ne vous renvoie que le résultat de la dernière ligne, et en plus, on arrive à multiplier des _pommes_ et des _poires_ ! En effet, il est possible de multiplier les chaînes de caractères par un entier, cela va alors _répéter_ la chaîne `n` fois puis vous la renvoyer. Les fonctions en Python peuvent _fonctionner_ de manière différente en fonction des types de variables qu'on leur donne en entrée, et c'est le cas à la fois pour les fonctions `+` et `*` ! On dit que ces opérateurs sont _surchargés_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Divisions, exposants, etc.\n",
    "\n",
    "Il est également possible avec Python d'effectuer d'autres opérations sur les entiers e \n",
    "\n",
    "- `/` représente la division exacte\n",
    "- `//` représente le quotient de la division Euclidienne\n",
    "- `%` représente la fonction _modulo_, qui renvoie le reste de la division Euclidienne\n",
    "- `**` ( __et non__ `^`) représente la fonction puissance\n",
    "\n",
    "Vous pourrez vérifier si ces fonctions donnent des résultats avec des chaînes de caractère en entrée !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2/3)\n",
    "print(7//3)\n",
    "print(2**3)\n",
    "print(2^4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------------------------------------\n",
    "\n",
    "### Nommer ses variables pour réutiliser ses résultats\n",
    "\n",
    "Pour l'instant, nous n'avons jamais demandé à Python de retenir le nom de nos objets, qu'on appelle des _variables_. Désormais, on va leur donner un nom. Les architectes de Python souhaiteraient que vous donniez à vos variables des noms explicites (évitez `truc1`), qui représentent ce que vous faites, et en anglais. Par exemple, `nb_particles` est un bon nom de variable si vous essayez de compter des particules ; `avg_volume_particles` pourrait être une autre variable avec laquelle vous travaillez. \n",
    "\n",
    "Pour donner un nom au résultat d'une opération, on va utiliser la commande \n",
    "```\n",
    "    ma_variable = mon_operation\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_particles = 12                                 \n",
    "avg_volume_particles = 3\n",
    "\n",
    "volume_total = n_particles*avg_volume_particles  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'opérateur `=` est appelé opérateur d'_affectation_. Python interprète le code ci-dessus de la manière suivante :\n",
    "1. Calcul (on parle d'_évaluer_) du résultat de `mon_operation`\n",
    "2. Création une variable `ma_variable`\n",
    "3. J'enregistre le résultat de `mon_résultat` dans `ma_variable`\n",
    "\n",
    "Au niveau de la 1ère et 2ème ligne, `mon_operation` est directement un résultat, car on précise directement les valeurs de `n_particles` et `avg_volume_particles`. Tandis que pour la dernière ligne, Python doit effectuer une multiplication avant d'obtenir le résultat en question. \n",
    "\n",
    "Vous aurez enfin remarqué que cette fois-ci, Python n'affiche pas le résultat ! Vous pouvez rajouter une ligne contenant simplement `volume_total` pour avoir une idée du volume total, ou vous pouvez imprimer le résultat sans lui donner de nom en remplaçant la dernière ligne par :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(n_particles*avg_volume_particles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous aurez constaté ici que Python s'est souvenu du nom des variables déclarées dans la cellule ci-dessus. Pratique ! \n",
    "\n",
    "Revenons à nos variables. Bien que `n_particles` soit un nombre, `avg_volume_particles` a, pour les physiciens, une unité, mais il est difficile de l'ajouter dans les variables Python. Une bonne idée pour ne pas se tromper dans nos applications est de rajouter un petit commentaire à côté de la variable, qui sera ignoré par la partie qui exécute le code Python, mais qui sera utile à quiconque relira votre code :-). Les commentaires courts s'incluent en ajoutant un caractère `#`. N'hésitez pas à mettre ce commentaire en anglais ! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_particles = 12\n",
    "avg_volume_particles = 3        # Volume in m^3\n",
    "total_available_volume = 1718   # Volume in ft^3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Mini quiz__ : \n",
    "1. Calculez, puis affichez la fraction volumique des particules dans cet exemple. Quelle valeur obtenez-vous ? Cela correspond-il à un arrangement particulier ?\n",
    "2. Que se passerait-il si vous essayiez d'ajouter `'5'` à `'douze'` ?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------------------------------------\n",
    "\n",
    "### Transformer ses variables : changer de _type_ !\n",
    "\n",
    "Il est possible de forcer ses variables à changer d'un type à un autre ! Prenons un exemple concret. J'initialise un nombre à une valeur donnée `number = 3`, et je veux ensuite afficher un message du genre `'Le nombre choisi est' + number`. Comme on l'a vu précédemment, Python ne va pas vouloir qu'on ajoute un _int_ à un _str_ ! Pour résoudre notre problème, on va alors forcer l'entier à devenir une chaîne de caractères ! On peut alors tout simplement écrire : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 3\n",
    "print('Le nombre choisi est : ' + str(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut également forcer une chaîne de caractères à devenir un nombre en faisant l'opération inverse :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_number = '12'\n",
    "number = 7\n",
    "result = int(text_number) + number\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous ne l'avez probablement pas remarqué, mais la fonction `print(variable)` fonctionne avec à la fois des nombres et des chaînes de caractère. En fait, la fonction va automatiquement détecter la nature de la variable qu'on lui passe en entrée, et agir en conséquence. La fonction `print` est donc assez _intelligente_, et nous pouvons l'être aussi, en demandant à Python de nous renvoyer le _type_ d'une variable avec la fonction ... `type` ! Le résultat de cette fonction n'est pas une chaîne de caractères, il faut donc le convertir pour l'afficher :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'I am not a string ... or am I ?'\n",
    "number = 13 + 12**7\n",
    "print('Text is of type : ' + str(type(text)))\n",
    "print('Number is of type : ' + str(type(number)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note_: Le _type_ ou la _classe_ d'une variable est essentiellement la même chose. \n",
    "\n",
    "Vous voyez dans un premier temps qu'il est tout à fait possible d'imbriquer les fonctions `str` et `type`, si tant est que la sortie d'une fonction (par exemple `type`) est d'un type compatible avec l'entrée de la fonction qui appelle cette sortie (ici, `str`). \n",
    "\n",
    "Parfois, le type d'une variable change tout seul ! C'est par exemple le cas si nous effectuons l'opération suivante : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_1 = 12\n",
    "number_2 = 1.53286794\n",
    "sum_of_numbers = number_1 + number_2\n",
    "print('Number 1 is of class : ' + str(type(number_1)))\n",
    "print('Number 1 is of class : ' + str(type(number_2)))\n",
    "print('Sum is of class : '      + str(type(sum_of_numbers)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a ici introduit le concept de nombre à virgule _flottante_, également appelé `float`. \n",
    "\n",
    "Vous aurez également remarqué que Python est capable d'ajouter des _pommes_ `int` à des _bananes_ `float`, ce qui n'était pas possible avec les _poires_ `str`. En fait, Python suit notre intuition mathématique, qui sait très bien ajouter des nombres entiers à des nombres non entiers. \n",
    "\n",
    "__Mini-quiz__ (difficile) : d'après vous, quelle est le type (ou classe) des objets suivants ? Vous pouvez les tester un par un en utilisant la fonction `type` !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable_1 = '12'\n",
    "variable_3 = int('seventy-five')\n",
    "variable_4 = type(72)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il y avait pas mal de pièges dans cette sélection :-) . \n",
    "* Le premier résultat est entre guillemets, c'est donc une chaîne de caractères (`str`).\n",
    "* Le deuxième ne fonctionne pas, car Python n'est pas encore capable de convertir un nombre écrit 'en toutes lettres' en un `int` \n",
    "* Le troisième est encore plus retors : la fonction `type()` renvoie une variable de type `type`, qui existe bel et bien, comme les `int` ou les `str`, même si cela nous donne mal à la tête !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------------------\n",
    "\n",
    "### Les nombres complexes, une simple affaire\n",
    "\n",
    "Pour les moins habitués aux mathématiques d'entre nous, sachez qu'il existe un nombre nommé $j$ (parfois $i$) qui n'est pas un nombre réel, et dont la principale propriété est que :\n",
    "\n",
    "$$ j^2 = -1 $$ \n",
    "\n",
    "Ce nombre permet de définir tous les nombres _complexes_ $z = x + j y$ avec $x$ et $y$ _réels_, ce qui signifie en pratique que $x^2 > 0$ et $y^2 > 0$ et que d'autres $j$ ne se _cachent_ pas dans $x$ et $y$. \n",
    "\n",
    "Python, par défaut, sait travailler avec les nombres complexes, et il est très facile d'en créer, comme par exemple ici : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 3 + 4j\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez bien sûr additionner, multiplier et diviser des nombres complexes entre eux. Pour les plus habitués, sachez qu'il est possible d'obtenir le module d'un nombre complexe nommé $|z| = \\sqrt{x^2 + y^2}$ assez simplement avec la fonction Python native nommée `abs()`*\n",
    "\n",
    "<small>*Pour des nombres réels $x$, cette fonction renvoie simplement leur valeur absolue, également notée $|x|$ </small>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour obtenir le complexe conjugué $\\bar{z}$ d'un nombre complexe $z$, vous devrez utiliser la commande `z.conjugate()`. Nous verrons [plus tard](./Tutorial_2_ListsTuplesDicts.ipynb#Manipuler-efficacement-nos-variables-avec-leurs-methodes-associees) ce que signifie cet appel à une fonction _un peu bizarre_ avec ce point `.` !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zbar = z.conjugate()\n",
    "print(zbar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'une manière similaire, on accède à la partie réelle et la partie imaginaire d'un nombre complexe en tapant un point puis `real` ou `imag`, mais cette fois-ci sans les parenthèses : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r_part = z.real\n",
    "i_part = z.imag\n",
    "\n",
    "print(r_part)\n",
    "print(i_part)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, si vous voulez convertir une chaîne de caractères en un nombre complexes, sachez qu'il faut éviter les espaces à l'intérieur de la chaîne de caractères. Essayez donc de 'régler' le code suivant, qui ne s'exécute pas : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_str = '5 + 6j'\n",
    "z = complex(my_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour les plus physico-chimistes d'entre nous, oui, les nombres complexes interviendront principalement dans les transformées de Fourier discrètes, que nous aborderons dans l'[Application A](./Application_A_Numpy.ipynb) au sujet de NumPy. Ils seront un peu plus anecdotiques le reste du temps."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------\n",
    "\n",
    "### La verite est ailleurs : Booleens, comparaisons, conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Booléens \n",
    "\n",
    "Les variables [booléenes](https://fr.wikipedia.org/wiki/George_Boole) (`bool`) sont un type de variable importante en Python. Elles peuvent être soient vraies (`True` avec une majuscule à T en Python) ou fausses (`False` avec une majuscule à F en Python) et rien d'autre. Elles sont les équivalents de `bits` qui peuvent simplement prendre les valeurs $0$ et $1$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = False\n",
    "b = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'ailleurs ce lien est plutôt explicite en Python. On peut s'en rendre compte si on essaie d'ajouter des variables booléennes ensemble, par exemple comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a + b)\n",
    "print(a + b + b)\n",
    "print(a * b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le résultat de ces opérations n'est d'ailleurs plus un booléen, mais un entier (`int`). Vous pouvez vous en convaincre en examinant le `type` de `a` et `b` et de `a + b` par exemple. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparaisons\n",
    "\n",
    "En mathématiques, et dans la vie courante, on est amené à poser des questions ou à tester des hypothèses dont le résultat est soit _vrai_, soit _faux_. Par exemple, on peut se demander si une variable (`float`) est plus grande qu'une autre, si une chaîne de caractères (`str`) est plus courte qu'une autre, ou se trouverait avant l'autre dans le dictionnaire. Python est capable d'effectuer ces opérations de manière rapide et flexible. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### À partir d'entiers ou de flottants\n",
    "\n",
    "Vous connaissez probablement les opérateurs $>, <$ qui comparent des nombres entre eux et nous indiquent que l'un d'entre eux est strictement plus grand (ou plus petit) qu'un autre. En mathématiques, il semble un peu inutile d'écrire :\n",
    "\n",
    "$$ 7 \\geq 6 ~,$$\n",
    "\n",
    "car cette proposition, même si elle est _vraie_, elle reste triviale. Et il est encore plus saugrenu d'écrire :\n",
    "\n",
    "$$ 5 < -4 ~, $$\n",
    "\n",
    "car on se rend vite compte que cette proposition est fausse ! \n",
    "\n",
    "Essayons à nouveau d'effectuer une comparaison entre deux nombres avec $>$, mais cette fois-ci, il est plus difficile de savoir lequel est le plus grand des deux :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = 2**10 > 10**3\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python est plutôt fortiche et sait donc que $2^{10} = 1024 > 1000$. \n",
    "\n",
    "D'un point de vue _informatique_, on a effectué une opération (cette fois-ci, pas une addition, mais une comparaison), qui produit un résultat, ici soit `True` ou `False`, et on peut enregistrer ce résultat dans une variable. Comme le résultat est limité à seulement deux valeurs, il est logique que `result` soit une variable booléenne. \n",
    "\n",
    "Il existe d'autres opérateurs de comparaison en Python en dehors de `>` et `<` :\n",
    "\n",
    "* `!=`, qui examine si deux variables possèdent des valeurs différentes.\n",
    "* `>=` et `<=`, qui sont les versions 'et égale' des opérateurs `>` et `<`.\n",
    "* `==`, qui va enfin examiner si deux variables possèdent les mêmes valeurs.\n",
    "\n",
    "Pourquoi `==` et pas `=` ? Rappelez-vous que `=` est déjà utilisé pour _affecter_ des variables et leur donner un nom. Il aurait été _très très très_ ambigu de donner aussi la possibilité au `=` de comparer deux variables entre elles, d'où le choix d'utiliser `==`.  \n",
    "\n",
    "Examinons quelques cas simples, pour des entiers et des flottants : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 != 5.0)    \n",
    "print(7 >= 6)\n",
    "print(+0 > -0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Entre chaînes de caractères\n",
    "\n",
    "Les opérateurs de comparaison fonctionnent enfin sur les chaînes de caractère. Étonnant, non ? Comment cela fonctionne-t-il ? Voyons quelques exemples : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('tomato' > 'potato')\n",
    "print('tomato pizza' > 'tomato')                       # !\n",
    "print('tomato pizza' > 'tomatoes')                     # !!\n",
    "print('tomato-induced death' > 'tomato induced death') # !!!\n",
    "print('Tomato' > 'tomato')                             # ?!?\n",
    "print('toMato' > 'tomAto')                             # ?!!!?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Euh ... ? Comment cela fonctionne-t-il ? Vous l'avez peut-être soupçonné, dans les trois premiers cas, l'opérateur `A>B` va vérifier que __`A` arrive bien après `B` par ordre alphabétique__ (c'est à dire celui du dictionnaire). On a notamment :\n",
    "* Cas 2 et 3 : Les noms composés avec une espace (`tomato pizza`) arrivent `avant` toutes les rajouts de suffixes au nom initial (`tomatoes`) mais après le nom initial (`tomato`)\n",
    "* Cas 4 : Les noms composés avec un trait d'union (`tomato-induced death`) arrivent après les noms composés avec une espace (`tomato induced death`), même si tout le reste est identique.\n",
    "\n",
    "Pour les cas 5 et 6, la seule différence entre nos chaînes est la _casse_ (majuscule ou minuscule) des lettres, tous les autres caractères étant égaux, donc on ne peut plus se baser sur le dictionnaire pour comparer les chaînes. Dans un tel cas, sachez que __les majuscules 'arrivent' avant les minuscules__ en Python. C'est en fait le cas car les majuscules ont un [numéro d'ordre ASCII](https://www.w3schools.com/charsets/ref_html_ascii.asp) plus petit que les minuscules. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Entre différents types de variables\n",
    "\n",
    "En règle générale, Python privilégie le renvoi d'un résultat un peu _coûte que coûte_, et on ne sait pas trop pourquoi on obtient un résultat. Parfois, cela n'est _vraiment_ pas possible, et Python renvoie une erreur. Faites donc attention quand vous utilisez `>`,`>=`,`==` et `>=` pour comparer deux objets de types différents. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0 >= False)\n",
    "print(14.26 > True)\n",
    "print(True == 1.00000000000000001)       # Testing Python's numerical precision\n",
    "print(5 > '6')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Autres opérateurs : `and`, `or`, `not`\n",
    "\n",
    "Il existe d'autres opérateurs de base qui sont pensées pour les _booléens_. On appelle ces opérateurs avec des _mots-clés_ en Python, et en lisant leurs noms, vous comprendrez rapidement leur rôle :\n",
    "\n",
    "* `or` : c'est l'équivalent du _ou_ inclusif entre deux booléens\n",
    "* `and` : c'est léquivalent du _et_ entre deux booléens\n",
    "* `not` : transforme un `True` en `False` et vice versa\n",
    "\n",
    "On peut combiner presque à l'infini les diverses possibilités offertes par ceux-ci et les opérateurs disponibles sur les nombres ci-dessus :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "condition_1 = 5 > 6 # basically False\n",
    "condition_2 = 7 > 6 # basically True\n",
    "print(not condition_1)\n",
    "print(condition_1 or condition_2)\n",
    "print(condition_1 and condition_2)\n",
    "print((not condition_1) ^ condition_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sachez que les opérateurs `and` et `or` fonctionnent également avec des chaînes de caractère et des nombres, mais leur comportement est alors différent de celui de `and` avec seulement des booléens :  \n",
    "\n",
    "* `a and b` renvoie `a` si `a` vaut `False`, `0` ou `''` (une chaîne vide), et renvoie `b` sinon.\n",
    "* `a or b` renvoie `b` si `a` vaut `False`, `0` ou `''` (une chaîne vide), et renvoie `a` sinon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('--- And ---')\n",
    "print(18 and 5)\n",
    "print(0 and 9)\n",
    "print('toto' and 'toutou')\n",
    "print('' and 'klutz')\n",
    "\n",
    "print('--- Or ---')\n",
    "print(18 or 7)\n",
    "print(0 or -28)\n",
    "print('crimson' or 'clover')\n",
    "print('' or 'silence')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Quiz__ : Essayez maintenant de prédire ce que valent : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True == 5\n",
    "(True == False) == (True < True)                     # This sounds convoluted\n",
    "(not False and False) or (False != False)            # What the ... ?\n",
    "('tomato' > 'toto') + (5 >= 2) == 1                  # Uggghhhh, whyyyyyyyy ?\n",
    "float('tomato' and '8') < float('28' < '36' or '72') # Stop hurting my brain !!!!"
   ]
  }
 ],
 "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.7 (tags/v3.9.7:1016ef3, Aug 30 2021, 20:19:38) [MSC v.1929 64 bit (AMD64)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "cb9c252e610b593a3421828f92740a33c32c552b9658c846af1824aa6c7c0cc9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}