{
 "nbformat_minor": 0, 
 "nbformat": 4, 
 "cells": [
  {
   "source": [
    "$$\n", 
    "\\def\\CC{\\bf C}\n", 
    "\\def\\QQ{\\bf Q}\n", 
    "\\def\\RR{\\bf R}\n", 
    "\\def\\ZZ{\\bf Z}\n", 
    "\\def\\NN{\\bf N}\n", 
    "$$\n", 
    "# Types de donn\u00e9es de Python"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "from __future__ import division, print_function   # Python 3"
   ], 
   "outputs": [], 
   "metadata": {}
  }, 
  {
   "source": [
    "Nous avons vu dans les chapitres pr\u00e9c\u00e9dents quelques types de donn\u00e9es comme les entiers et les nombres flottants de Python ainsi que quelques structures de donn\u00e9es (listes, tuples, dictionnaires) utilis\u00e9es comme argument ou comme valeur de retour de certaines fonctions de SymPy. Dans ce chapitre, nous allons pr\u00e9senter avec plus de d\u00e9tails les types de donn\u00e9es qui sont les plus souvent utilis\u00e9es en programmation.\n", 
    "\n", 
    "## Le type d'un objet\n", 
    "\n", 
    "Construisons le nombre entier 4 de deux fa\u00e7ons diff\u00e9rentes, avec Python puis avec SymPy:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "a = 4\n", 
    "from sympy import S\n", 
    "b = S(4)"
   ], 
   "outputs": [], 
   "metadata": {}
  }, 
  {
   "source": [
    "Le nombre 4 est stock\u00e9 dans la variable `a` et dans la variable `b` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "a"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "4"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "b"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "4"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Bien qu'ils repr\u00e9sentent tous deux le nombre 4 et qu'ils s'affichent de la m\u00eame fa\u00e7on \u00e0 l'\u00e9cran, ils ne se comportent pas de la m\u00eame fa\u00e7on:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "a/5"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "0.8"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "b/5"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "4/5"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "C'est que les *objets* stock\u00e9s dans les variables `a` et `b` ne sont pas du m\u00eame *type*. La fonction `type` permet de conna\u00eetre le type d'un `objet` avec la syntaxe `type(objet)` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(a)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'int'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(b)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<class 'sympy.core.numbers.Integer'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Cela explique le comportement diff\u00e9rent de `a/5` qui retourne un nombre d\u00e9cimal et `b/5` qui retourne un nombre rationel de SymPy:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(a/5)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'float'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(b/5)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<class 'sympy.core.numbers.Rational'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Comme le comportement d'un objet d\u00e9pend de son type, il est souvent pertinent de v\u00e9rifier le type d'un objet avant de l'utiliser. Les autres types tr\u00e8s communs que nous allons voir dans les sections suivantes sont ci-dessous:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(4)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'int'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(4.0)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'float'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(True)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'bool'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type('bonjour')"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'str'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type([3,4,5])"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'list'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type((3,4,5))"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'tuple'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type({2:3, 4:5})"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'dict'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Nombres entiers (type `int`)\n", 
    "\n", 
    "Les nombres entiers sont cr\u00e9\u00e9s simplement en Python:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "4"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "4"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Ils sont aussi obtenus par le r\u00e9sultat d'op\u00e9rations sur les nombres entiers comme l'addition, la multiplication, la soustraction, le modulo et le quotient:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "4 + 6"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "10"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "7 * 9"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "63"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "4 - 6"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "-2"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "27 % 10"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "7"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "27 // 10"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "2"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "On peut v\u00e9rifier que le r\u00e9sultat des op\u00e9rations ci-haut est bel et bien un entier Python de type `int` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(27 // 10)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'int'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "En Python, la fonction `int` permet de cr\u00e9er un entier de type `int` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "int()"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "0"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "int(4)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "4"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Cette fonction permet aussi de traduire un objet d'un autre type en un nombre entier de Python de type `int` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "int(4.02)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "4"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "int('41234')"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "41234"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Pour stocker des nombres entiers un peu plus grand, Python utilise une autre structure de donn\u00e9es appel\u00e9 entier `long`. On peut tester \u00e0 partir d'o\u00f9 cela se produit:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(2 ** 61)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'int'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(2 ** 62)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'int'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(2 ** 63)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'long'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(2 ** 64)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'long'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Nombres flottants (type `float`)\n", 
    "\n", 
    "Les nombres d\u00e9cimaux aussi appel\u00e9 nombre flottants ou nombre \u00e0 virgule flottante sont cr\u00e9\u00e9s simplement en Python:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "4."
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "4.0"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Ils sont aussi obtenus par le r\u00e9sultat d'op\u00e9rations sur les nombres flottants comme l'addition, la multiplication, la soustraction, le modulo et le quotient:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "4. * 3.41"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "13.64"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "On v\u00e9rifie que le type du r\u00e9sultat pr\u00e9c\u00e9dent est bel et bien un nombre flottant de type `float` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(_)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'float'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Les nombres flottants peuvent aussi \u00eatre obtenus comme r\u00e9sultats d'op\u00e9rations impliquant des nombres d'autres types comme la multiplication par un nombre entier ou la division de deux nombres entiers:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "4. * 3"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "12.0"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "4 / 5"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "0.8"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Finalement, les nombres flottants peuvent \u00eatre cr\u00e9\u00e9s avec la fonction `float` qui permet aussi de transformer un objet d'un autre type en nombre flottant:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "float()"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "0.0"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "float(34)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "34.0"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "float('1234')"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "1234.0"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "float('1234.56')"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "1234.56"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Bool\u00e9ens (type `bool`)\n", 
    "\n", 
    "Les bool\u00e9ens permettent de repr\u00e9senter les valeurs *vrai* et *faux*. On les \u00e9crit en anglais avec un majuscule:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "True"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "False"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Les valeurs `True` et `False` sont des objets de type `bool` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(False)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'bool'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "type(True)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "<type 'bool'>"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Les op\u00e9rations de base sur les bool\u00e9ens retournent aussi des bool\u00e9ens:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "True or False"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "False and True"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Si cela est n\u00e9cessaire, voici toutes les possibilit\u00e9s de valeurs d'entr\u00e9es pour le ET logique `and` qui retourne *vrai* lorsque les deux valeurs d'entr\u00e9es sont vraies:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "True and True"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "True and False"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "False and True"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "False and False"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Pareillement le OU logique (`or`) retourne `True` d\u00e8s qu'une des deux valeurs est vraie:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "True or True"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "True or False"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "False or True"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "False or False"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "La n\u00e9gation (`not`) retourne l'oppos\u00e9 d'une valeur bool\u00e9enne:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "not True"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "not False"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Un bool\u00e9en peut \u00eatre retourn\u00e9 par des fonctions ou des tests de comparaison:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "13 == 5 + 8"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "20 > 34"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "La fonction `bool` permet de transformer un objet en un bool\u00e9en. En g\u00e9n\u00e9ral, les valeurs z\u00e9ro ou les listes vides sont transform\u00e9es en `False` et les valeurs non nulles ou les listes non vides sont transform\u00e9es en `True` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "bool(113)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "bool(0)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "False"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "bool(1)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "True"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "## Cha\u00eenes de caract\u00e8res (type `str`)\n", 
    "\n", 
    "En Python, les cha\u00eenes de caract\u00e8res sont d\u00e9finies par l'utilisation des simple guillemets (`'`) ou des doubles guillemets (`\"`):"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "'bonjour'"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'bonjour'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "\"bonjour\""
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'bonjour'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Si on veut utiliser les simples guillemets \u00e0 l'int\u00e9rieur de la cha\u00eenes de caract\u00e8res, on doit utiliser les doubles pour l'entourer et vice versa:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "\"aujourd'hui\""
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "\"aujourd'hui\""
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "'Je suis \"ici\"'"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'Je suis \"ici\"'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Pour utiliser \u00e0 la fois des simples et des doubles guillemets dans la cha\u00eene de caract\u00e8res, on utilise des triple double guillemets pour entourer la cha\u00eene de caract\u00e8res:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "\"\"\"Je suis \"ici\" aujourd'hui\"\"\""
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'Je suis \"ici\" aujourd\\'hui'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "On peut cr\u00e9er des cha\u00eenes de caract\u00e8res \u00e0 partir d'autres objets en utilisant la fonction `str` :"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "str(12345)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'12345'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "str(12345.789)"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'12345.789'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Pour acc\u00e9der aux lettres d'une cha\u00eene de caract\u00e8res, on utilise les crochets apr\u00e8s la variable de la fa\u00e7on suivante:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "w = 'bonjour'\n", 
    "w[0]"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'b'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "w[1]"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'o'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Comme vous remarquez, l'indexation commence \u00e0 z\u00e9ro et non pas \u00e0 un. C'est comme \u00e7a en Python. Ainsi la septi\u00e8me et derni\u00e8re lettre du mot bonjour est \u00e0 la position 6:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "w[6]"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'r'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "On peut aussi compter \u00e0 partir de la fin avec des indices n\u00e9gatifs. La position `-1` retourne la derni\u00e8re lettre:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "w[-1]"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'r'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "On peut acc\u00e9der aux sous-cha\u00eenes de la position `i` \u00e0 la position `j-1` avec la syntaxe `w[i:j]` de la fa\u00e7on suivante:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "w[2:5]"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'njo'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }, 
  {
   "source": [
    "Si on ne sp\u00e9cifie pas le d\u00e9but ou la fin, alors le comportement par d\u00e9faut est d'aller jusqu'au bout:"
   ], 
   "cell_type": "markdown", 
   "metadata": {}
  }, 
  {
   "execution_count": null, 
   "cell_type": "code", 
   "source": [
    "w[:4]"
   ], 
   "outputs": [
    {
     "execution_count": 1, 
     "output_type": "execute_result", 
     "data": {
      "text/plain": [
       "'bonj'"
      ]
     }, 
     "metadata": {}
    }
   ], 
   "metadata": {}
  }
 ], 
 "metadata": {
  "kernelspec": {
   "display_name": "python2", 
   "name": "python2"
  }
 }
}