Semaine 2 - Notions de base pour écrire son premier programme en Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1445b1df",
   "metadata": {},
   "source": [
    "# Semaine 2 - Notions de base pour écrire son premier programme en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "326a3d50",
   "metadata": {},
   "source": [
    "##  1 Codage, jeux de caractères et Unicode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6fb3c6cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "utf-8\n"
     ]
    }
   ],
   "source": [
    "# ceci doit être exécuté sur votre machine\n",
    "import sys\n",
    "print(sys.getdefaultencoding())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9284f8c2",
   "metadata": {},
   "source": [
    "##  2 Les chaînes de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "37aa8236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'spam'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "10934e55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"spam\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4771abdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'spam'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2fb61051",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b6ede316",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spam\n"
     ]
    }
   ],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5af25c54",
   "metadata": {},
   "outputs": [],
   "source": [
    "str?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "50846673",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'removeprefix',\n",
       " 'removesuffix',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d639a05e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#si méthode __ alors c'est une méthode avancée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "74480720",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Un Mooc Python'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'un mooc python'.title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "877f00c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "s= \"le poulet c'est bon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "93044e0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"le gâteau c'est bon\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.replace('poulet','gâteau')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8066e2ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"le poulet c'est bon\""
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f63cebd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "s=s.replace('poulet','spam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b6d6b6a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"le spam c'est bon\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "12cf8e51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'123'.isdecimal()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d642bd20",
   "metadata": {},
   "source": [
    "Définir toutes les méthodes non avancées applicables aux chaînes de caractères"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "fc79e1ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sonia a 30 ans'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 'sonia'\n",
    "age = 30\n",
    "\"{} {}\".format(n, age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "5ed55dad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sonia a 30 ans'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{} a {} ans\".format(n, age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0669300c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sonia a 30 ans'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"{n} a {age} ans\"\n",
    "#depuis 3.6 - A UTILISER"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81a0c705",
   "metadata": {},
   "source": [
    "### support d'unicode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3eff85a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'noël, été'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"noël, été\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "2f50eab0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ֆ'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\\u0556\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1b38e95e",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"un noël en été\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "67d216df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "un noël en été\n"
     ]
    }
   ],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "272d9572",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'un no\\xc3\\xabl en \\xc3\\xa9t\\xc3\\xa9'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.encode('utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e8688b68",
   "metadata": {},
   "outputs": [],
   "source": [
    "en = s.encode('utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "af03cf90",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'un no\\xc3\\xabl en \\xc3\\xa9t\\xc3\\xa9'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "en"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f27aa1c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'un noël en été'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "en.decode('utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b65fbc10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'un no\\xebl en \\xe9t\\xe9'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.encode('latin1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c9c562dd",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unterminated string literal (detected at line 1) (606030723.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[48], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    '\"'\"\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m unterminated string literal (detected at line 1)\n"
     ]
    }
   ],
   "source": [
    "'\"'\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d872a539",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Return a formatted version of the string as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the string in memory, in bytes.\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(self, /)\n",
      " |      Return a capitalized version of the string.\n",
      " |      \n",
      " |      More specifically, make the first character have upper case and the rest lower\n",
      " |      case.\n",
      " |  \n",
      " |  casefold(self, /)\n",
      " |      Return a version of the string suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(self, width, fillchar=' ', /)\n",
      " |      Return a centered string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(self, /, encoding='utf-8', errors='strict')\n",
      " |      Encode the string using the codec registered for encoding.\n",
      " |      \n",
      " |      encoding\n",
      " |        The encoding in which to encode the string.\n",
      " |      errors\n",
      " |        The error handling scheme to use for encoding errors.\n",
      " |        The default is 'strict' meaning that encoding errors raise a\n",
      " |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n",
      " |        'xmlcharrefreplace' as well as any other name registered with\n",
      " |        codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(self, /, tabsize=8)\n",
      " |      Return a copy where all tab characters are expanded using spaces.\n",
      " |      \n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(self, /)\n",
      " |      Return True if the string is an alpha-numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is alpha-numeric if all characters in the string are alpha-numeric and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isalpha(self, /)\n",
      " |      Return True if the string is an alphabetic string, False otherwise.\n",
      " |      \n",
      " |      A string is alphabetic if all characters in the string are alphabetic and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isascii(self, /)\n",
      " |      Return True if all characters in the string are ASCII, False otherwise.\n",
      " |      \n",
      " |      ASCII characters have code points in the range U+0000-U+007F.\n",
      " |      Empty string is ASCII too.\n",
      " |  \n",
      " |  isdecimal(self, /)\n",
      " |      Return True if the string is a decimal string, False otherwise.\n",
      " |      \n",
      " |      A string is a decimal string if all characters in the string are decimal and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isdigit(self, /)\n",
      " |      Return True if the string is a digit string, False otherwise.\n",
      " |      \n",
      " |      A string is a digit string if all characters in the string are digits and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isidentifier(self, /)\n",
      " |      Return True if the string is a valid Python identifier, False otherwise.\n",
      " |      \n",
      " |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n",
      " |      such as \"def\" or \"class\".\n",
      " |  \n",
      " |  islower(self, /)\n",
      " |      Return True if the string is a lowercase string, False otherwise.\n",
      " |      \n",
      " |      A string is lowercase if all cased characters in the string are lowercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  isnumeric(self, /)\n",
      " |      Return True if the string is a numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is numeric if all characters in the string are numeric and there is at\n",
      " |      least one character in the string.\n",
      " |  \n",
      " |  isprintable(self, /)\n",
      " |      Return True if the string is printable, False otherwise.\n",
      " |      \n",
      " |      A string is printable if all of its characters are considered printable in\n",
      " |      repr() or if it is empty.\n",
      " |  \n",
      " |  isspace(self, /)\n",
      " |      Return True if the string is a whitespace string, False otherwise.\n",
      " |      \n",
      " |      A string is whitespace if all characters in the string are whitespace and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  istitle(self, /)\n",
      " |      Return True if the string is a title-cased string, False otherwise.\n",
      " |      \n",
      " |      In a title-cased string, upper- and title-case characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |  \n",
      " |  isupper(self, /)\n",
      " |      Return True if the string is an uppercase string, False otherwise.\n",
      " |      \n",
      " |      A string is uppercase if all cased characters in the string are uppercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  join(self, iterable, /)\n",
      " |      Concatenate any number of strings.\n",
      " |      \n",
      " |      The string whose method is called is inserted in between each given string.\n",
      " |      The result is returned as a new string.\n",
      " |      \n",
      " |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
      " |  \n",
      " |  ljust(self, width, fillchar=' ', /)\n",
      " |      Return a left-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(self, /)\n",
      " |      Return a copy of the string converted to lowercase.\n",
      " |  \n",
      " |  lstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string.  If the separator is found,\n",
      " |      returns a 3-tuple containing the part before the separator, the separator\n",
      " |      itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing the original string\n",
      " |      and two empty strings.\n",
      " |  \n",
      " |  removeprefix(self, prefix, /)\n",
      " |      Return a str with the given prefix string removed if present.\n",
      " |      \n",
      " |      If the string starts with the prefix string, return string[len(prefix):].\n",
      " |      Otherwise, return a copy of the original string.\n",
      " |  \n",
      " |  removesuffix(self, suffix, /)\n",
      " |      Return a str with the given suffix string removed if present.\n",
      " |      \n",
      " |      If the string ends with the suffix string and that suffix is not empty,\n",
      " |      return string[:-len(suffix)]. Otherwise, return a copy of the original\n",
      " |      string.\n",
      " |  \n",
      " |  replace(self, old, new, count=-1, /)\n",
      " |      Return a copy with all occurrences of substring old replaced by new.\n",
      " |      \n",
      " |        count\n",
      " |          Maximum number of occurrences to replace.\n",
      " |          -1 (the default value) means replace all occurrences.\n",
      " |      \n",
      " |      If the optional argument count is given, only the first count occurrences are\n",
      " |      replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(self, width, fillchar=' ', /)\n",
      " |      Return a right-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string, starting at the end. If\n",
      " |      the separator is found, returns a 3-tuple containing the part before the\n",
      " |      separator, the separator itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing two empty strings\n",
      " |      and the original string.\n",
      " |  \n",
      " |  rsplit(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the substrings in the string, using sep as the separator string.\n",
      " |      \n",
      " |        sep\n",
      " |          The separator used to split the string.\n",
      " |      \n",
      " |          When set to None (the default value), will split on any whitespace\n",
      " |          character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n",
      " |          empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits (starting from the left).\n",
      " |          -1 (the default value) means no limit.\n",
      " |      \n",
      " |      Splitting starts at the end of the string and works to the front.\n",
      " |  \n",
      " |  rstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the substrings in the string, using sep as the separator string.\n",
      " |      \n",
      " |        sep\n",
      " |          The separator used to split the string.\n",
      " |      \n",
      " |          When set to None (the default value), will split on any whitespace\n",
      " |          character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n",
      " |          empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits (starting from the left).\n",
      " |          -1 (the default value) means no limit.\n",
      " |      \n",
      " |      Note, str.split() is mainly useful for data that has been intentionally\n",
      " |      delimited.  With natural text that includes punctuation, consider using\n",
      " |      the regular expression module.\n",
      " |  \n",
      " |  splitlines(self, /, keepends=False)\n",
      " |      Return a list of the lines in the string, breaking at line boundaries.\n",
      " |      \n",
      " |      Line breaks are not included in the resulting list unless keepends is given and\n",
      " |      true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading and trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(self, /)\n",
      " |      Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
      " |  \n",
      " |  title(self, /)\n",
      " |      Return a version of the string where each word is titlecased.\n",
      " |      \n",
      " |      More specifically, words start with uppercased characters and all remaining\n",
      " |      cased characters have lower case.\n",
      " |  \n",
      " |  translate(self, table, /)\n",
      " |      Replace each character in the string using the given translation table.\n",
      " |      \n",
      " |        table\n",
      " |          Translation table, which must be a mapping of Unicode ordinals to\n",
      " |          Unicode ordinals, strings, or None.\n",
      " |      \n",
      " |      The table must implement lookup/indexing via __getitem__, for instance a\n",
      " |      dictionary or list.  If this operation raises LookupError, the character is\n",
      " |      left untouched.  Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(self, /)\n",
      " |      Return a copy of the string converted to uppercase.\n",
      " |  \n",
      " |  zfill(self, width, /)\n",
      " |      Pad a numeric string with zeros on the left, to fill a field of the given width.\n",
      " |      \n",
      " |      The string is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  maketrans(...)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "677b724d",
   "metadata": {},
   "source": [
    "## 3 Les outils de base sur les chaînes de caractères (str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5e5c690",
   "metadata": {},
   "source": [
    "### Découpage - assemblage : `split` et `join`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b10ebd22",
   "metadata": {},
   "source": [
    "Les méthodes `split` et `join` permettent de découper une chaîne selon un séparateur pour obtenir une liste, et à l'inverse de reconstruire une chaîne à partir d'une liste."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "504895d5",
   "metadata": {},
   "source": [
    "`split` permet donc de découper :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "696003db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi', 'jkl']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc=:=def=:=ghi=:=jkl'.split('=:=')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d54d59b",
   "metadata": {},
   "source": [
    "Et à l'inverse :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b550e8c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc=:=def=:=ghi=:=jkl'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"=:=\".join(['abc', 'def', 'ghi', 'jkl'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62bae99",
   "metadata": {},
   "source": [
    "Attention toutefois si le séparateur est un terminateur, la liste résultat contient alors une dernière chaîne vide. En pratique, on utilisera la méthode `strip`, que nous allons voir ci-dessous, avant la méthode `split` pour éviter ce problème."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "52bed77f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi', 'jkl', '']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc;def;ghi;jkl;'.split(';')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "781a17a8",
   "metadata": {},
   "source": [
    "Qui s'inverse correctement cependant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "51438078",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc;def;ghi;jkl;'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\";\".join(['abc', 'def', 'ghi', 'jkl', ''])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "124930e6",
   "metadata": {},
   "source": [
    "### Remplacement : `replace`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd22529",
   "metadata": {},
   "source": [
    "`replace` est très pratique pour remplacer une sous-chaîne par une autre, avec une limite éventuelle sur le nombre de remplacements :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "55d2e601",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'zoodefzoodefzoodef'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abcdefabcdefabcdef\".replace(\"abc\", \"zoo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "683e35bc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'zoodefzoodefabcdef'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abcdefabcdefabcdef\".replace(\"abc\", \"zoo\", 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76c50fb3",
   "metadata": {},
   "source": [
    "Plusieurs appels à replace peuvent être chaînés comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "99b18ec3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'les chevaliers qui disent Ni'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"les [x] qui disent [y]\".replace(\"[x]\", \"chevaliers\").replace(\"[y]\", \"Ni\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0534063a",
   "metadata": {},
   "source": [
    "### Nettoyage : `strip`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c068fe90",
   "metadata": {},
   "source": [
    "On pourrait par exemple utiliser `replace` pour enlever les espaces dans une chaîne, ce qui peut être utile pour \"nettoyer\" comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b026e4c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc:def:ghi'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" abc:def:ghi \".replace(\" \", \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d1d4f3c",
   "metadata": {},
   "source": [
    "Toutefois bien souvent on préfère utiliser `strip` qui ne s'occupe que du début et de la fin de la chaîne, et gère aussi les tabulations et autres retour à la ligne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b94d8b1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'une chaîne avec des trucs qui dépassent'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \\tune chaîne avec des trucs qui dépassent \\n\".strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3799ec1",
   "metadata": {},
   "source": [
    "On peut appliquer `strip` avant `split` pour éviter le problème du dernier élément vide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a5b01724",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi', 'jkl']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc;def;ghi;jkl;'.strip(';').split(';')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "022411ff",
   "metadata": {},
   "source": [
    "### Rechercher une sous-chaîne"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff4f8715",
   "metadata": {},
   "source": [
    "Plusieurs outils permettent de chercher une sous-chaîne. Il existe `find` qui renvoie le plus petit index où on trouve la sous-chaîne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0c22466e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# l'indice du début de la première occurrence\n",
    "\"abcdefcdefghefghijk\".find(\"def\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0e5212f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ou -1 si la chaîne n'est pas présente\n",
    "\"abcdefcdefghefghijk\".find(\"zoo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "defb42c1",
   "metadata": {},
   "source": [
    "`rfind` fonctionne comme find mais en partant de la fin de la chaîne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c48b0217",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# en partant de la fin\n",
    "\"abcdefcdefghefghijk\".rfind(\"fgh\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "60f39c88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# notez que le résultat correspond\n",
    "# tout de même toujours au début de la chaîne\n",
    "\n",
    "# NB: en python les indices commencent à zéro\n",
    "# donc la notation ma_chaine[n] \n",
    "# permet d'accèder au n+1 ème caractère de la chaine\n",
    "\"abcdefcdefghefghijk\"[13]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc396dc4",
   "metadata": {},
   "source": [
    "La méthode `index` se comporte comme find, mais en cas d'absence elle lève une exception (nous verrons ce concept plus tard) plutôt que de renvoyer -1 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9fd620a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abcdefcdefghefghijk\".index(\"def\")"
   ]
  },
  {
   "cell_type": "raw",
   "id": "25c74dc5",
   "metadata": {},
   "source": [
    "try:\n",
    "    \"abcdefcdefghefghijk\".index(\"zoo\")\n",
    "except Exception as e:\n",
    "    print(\"OOPS\", type(e), e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8554ea67",
   "metadata": {},
   "source": [
    "Mais le plus simple pour chercher si une sous-chaîne est dans une autre chaîne est d'utiliser l'instruction `in` sur laquelle nous reviendrons lorsque nous parlerons des séquences :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "affd179a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"def\" in \"abcdefcdefghefghijk\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "941133aa",
   "metadata": {},
   "source": [
    "La méthode `count` compte le nombre d'occurrences d'une sous-chaîne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d9535107",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abcdefcdefghefghijk\".count(\"ef\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bc538f1",
   "metadata": {},
   "source": [
    "Signalons enfin les méthodes de commodité suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "271a02cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abcdefcdefghefghijk\".startswith(\"abcd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d0db52a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abcdefcdefghefghijk\".endswith(\"ghijk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c343f6d",
   "metadata": {},
   "source": [
    "S'agissant des deux dernières, remarquons que :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad8f727e",
   "metadata": {},
   "source": [
    "`chaine.startswith(sous_chaine)` ⟺\n",
    "`chaine.find(sous_chaine) == 0`\n",
    "\n",
    "`chaine.endswith(sous_chaine)` ⟺\n",
    "`chaine.rfind(sous_chaine) == (len(chaine) - len(sous_chaine))`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19414a87",
   "metadata": {},
   "source": [
    "On remarque ici la supériorité en terme d'expressivité des méthodes pythoniques `startswith` et `endswith`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "add178d7",
   "metadata": {},
   "source": [
    "### Changement de casse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15f14736",
   "metadata": {},
   "source": [
    "Voici pour conclure quelques méthodes utiles qui parlent d'elles-mêmes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2177afe1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MONTY PYTHON'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"monty PYTHON\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ee364a5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'monty python'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"monty PYTHON\".lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2798bf66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MONTY python'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"monty PYTHON\".swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "480f822e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty python'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"monty PYTHON\".capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "cd1b31f4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty Python'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"monty PYTHON\".title()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2447cd1d",
   "metadata": {},
   "source": [
    "### Pour en savoir plus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33bbd7f4",
   "metadata": {},
   "source": [
    "Tous ces outils sont documentés en détail [ici](https://docs.python.org/3/library/stdtypes.html#string-methods) (en anglais)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41eaa369",
   "metadata": {},
   "source": [
    "## 4 Formatage de chaînes de caractères"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "975afb10",
   "metadata": {},
   "source": [
    "### La fonction `print`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c716fbf",
   "metadata": {},
   "source": [
    "Nous avons jusqu'à maintenant presque toujours utilisé la fonction `print` pour afficher nos résultats. Comme on l'a vu, celle-ci réalise un formatage sommaire : elle insère un espace entre les valeurs qui lui sont passées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "54ad60f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 a (12+4j)\n"
     ]
    }
   ],
   "source": [
    "print(1, 'a', 12 + 4j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b66eaecc",
   "metadata": {},
   "source": [
    "La seule subtilité notable concernant `print` est que, par défaut, elle ajoute un saut de ligne à la fin. Pour éviter ce comportement, on peut passer à la fonction un argument `end`, qui sera inséré au lieu du saut de ligne. Ainsi par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2beb0b72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "une seule ligne\n"
     ]
    }
   ],
   "source": [
    "# une première ligne\n",
    "print(\"une\", \"seule\", \"ligne\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e3b30a54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "une autre ligne\n"
     ]
    }
   ],
   "source": [
    "# une deuxième ligne en deux appels à print\n",
    "print(\"une\", \"autre\", end=' ')\n",
    "print(\"ligne\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0430f28",
   "metadata": {},
   "source": [
    "Il faut remarquer aussi que `print` est capable d'imprimer **n'importe quel objet**. Nous l'avons déjà fait avec les listes et les tuples, voici par exemple un module :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3fa93aba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "le module math est <module 'math' (built-in)>\n"
     ]
    }
   ],
   "source": [
    "# on peut imprimer par exemple un objet 'module'\n",
    "import math\n",
    "\n",
    "print('le module math est', math)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "775f19c2",
   "metadata": {},
   "source": [
    "En anticipant un peu, voici comment `print` présente les instances de classe (ne vous inquiétez pas, nous apprendrons dans une semaine ultérieure ce que sont les classes et les instances)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "bff7ec05",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pour définir la classe Personne\n",
    "class Personne:\n",
    "    pass\n",
    "\n",
    "# et pour créer une instance de cette classe\n",
    "personne = Personne()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "4726305c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Personne object at 0x0000026679763A30>\n"
     ]
    }
   ],
   "source": [
    "# voilà comment s'affiche une instance de classe\n",
    "print(personne)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa74fb21",
   "metadata": {},
   "source": [
    "On rencontre assez vite les limites de `print` :\n",
    "- d'une part, il peut être nécessaire de formater une chaîne de caractères sans nécessairement vouloir l'imprimer, ou en tout cas pas immédiatement ;\n",
    "- d'autre part, les espaces ajoutées peuvent être plus néfastes qu'utiles ;\n",
    "- enfin, on peut avoir besoin de préciser un nombre de chiffres significatifs, ou de choisir comment présenter une date.\n",
    "C'est pourquoi il est plus courant de **formater** les chaînes - c'est-à-dire de calculer des chaînes en mémoire, sans nécessairement les imprimer de suite, et c'est ce que nous allons étudier dans ce complément."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c701a094",
   "metadata": {},
   "source": [
    "### Les `f-strings`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2392fd2c",
   "metadata": {},
   "source": [
    "Depuis la version 3.6 de Python, on peut utiliser les *f-strings*, le premier mécanisme de formatage que nous étudierons. C'est le mécanisme de formatage le plus simple et le plus agréable à utiliser.\n",
    "\n",
    "Je vous recommande tout de même de lire les sections à propos de `format` et de `%`, qui sont encore massivement utilisées dans le code existant (surtout `%` d'ailleurs, bien que essentiellement obsolète)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ca58144",
   "metadata": {},
   "source": [
    "Mais définissons d'abord quelques données à afficher :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d416aca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# donnons-nous quelques variables\n",
    "prenom, nom, age = 'Jean', 'Dupont', 35"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "26569629",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jean Dupont a 35 ans'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mon premier f-string\n",
    "f\"{prenom} {nom} a {age} ans\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "495f5d82",
   "metadata": {},
   "source": [
    "Vous remarquez d'abord que la chaine commence par `f\"`, c'est bien sûr pour cela qu'on l'appelle un *f-string*.\n",
    "\n",
    "On peut bien entendu ajouter le `f` devant toutes les formes de strings, qu'ils commencent par `' ` ou `\"` ou `'''` ou `\"\"\"`.\n",
    "\n",
    "Ensuite vous remarquez que les zones délimitées entre `{}` sont remplacées. La logique d'un *f-string*, c'est tout simplement de considérer l'intérieur d'un `{}` comme du code Python (une expression pour être précis), de l'évaluer, et d'utiliser le résultat pour remplir le `{}`.\n",
    "\n",
    "Ça veut dire, en clair, que je peux faire des calculs à l'intérieur des `{}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "d77f68b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dans 10 ans Jean aura 45 ans'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# toutes les expressions sont autorisées à l'intérieur d'un {}\n",
    "f\"dans 10 ans {prenom} aura {age + 10} ans\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a2b90dcf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"nous avons pour l'instant 3 notes\""
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on peut donc aussi mettre des appels de fonction\n",
    "notes = [12, 15, 19]\n",
    "f\"nous avons pour l'instant {len(notes)} notes\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d51ee0c7",
   "metadata": {},
   "source": [
    "Nous allons en rester là pour la partie en niveau basique. Il nous reste à étudier comment chaque `{}` est formaté (par exemple comment choisir le nombre de chiffres significatifs sur un flottant), ce point est expliqué plus bas.\n",
    "\n",
    "Comme vous le voyez, les *f-strings* fournissent une méthode très simple et expressive pour formater des données dans des chaînes de caractère. Redisons-le pour être bien clair : un *f-string* **ne réalise pas d'impression**, il faut donc le passer à `print` si l'impression est souhaitée."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fcd2307",
   "metadata": {},
   "source": [
    "### La méthode `format`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3caf6dbf",
   "metadata": {},
   "source": [
    "Avant l'introduction des *f-strings*, la technique recommandée pour faire du formatage était d'utiliser la méthode `format` qui est définie sur les objets `str` et qui s'utilise comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "442b937f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jean Dupont a 35 ans'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{} {} a {} ans\".format(prenom, nom, age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77b35c0b",
   "metadata": {},
   "source": [
    "Dans cet exemple le plus simple, les données sont affichées en lieu et place des `{}`, dans l'ordre où elles sont fournies.\n",
    "\n",
    "Cela convient bien lorsqu'on a peu de données. Si par la suite on veut changer l'ordre par exemple des nom et prénom, on peut bien sûr échanger l'ordre des arguments passés à format, ou encore utiliser la **liaison par position**, comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "ce251fb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dupont Jean a 35 ans'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{1} {0} a {2} ans\".format(prenom, nom, age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "340cc2a2",
   "metadata": {},
   "source": [
    "Dans la pratique toutefois, cette forme est assez peu utile, on lui préfère souvent la **liaison par nom** qui se présente comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "099d9a9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jean Dupont a 35 ans'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\"{le_prenom} {le_nom} a {l_age} ans\"\n",
    "   .format(le_nom=nom, le_prenom=prenom, l_age=age))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af31b064",
   "metadata": {},
   "source": [
    "Petite digression : remarquez l'usage des parenthèses, qui me permettent de couper ma ligne en deux, car sinon ce code serait trop long pour la PEP8; on s'efforce toujours de ne pas dépasser 80 caractères de large, dans notre cas c'est utile notamment pour l'édition du cours au format PDF.\n",
    "\n",
    "Reprenons : dans ce premier exemple de liaison par nom, nous avons délibérément utilisé des noms différents pour les données externes et pour les noms apparaissant dans le format, pour bien illustrer comment la liaison est résolue, mais on peut aussi bien faire tout simplement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "341f973e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jean Dupont a 35 ans'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{prenom} {nom} a {age} ans\".format(nom=nom, prenom=prenom, age=age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "661f4e5d",
   "metadata": {},
   "source": [
    "### Complément - La toute première version du formatage : l'opérateur `%`¶"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc31b2fe",
   "metadata": {},
   "source": [
    "`format` a été en fait introduite assez tard dans Python, pour remplacer la technique que nous allons présenter maintenant.\n",
    "\n",
    "Étant donné le volume de code qui a été écrit avec l'opérateur `%`, il nous a semblé important d'introduire brièvement cette construction ici. Vous ne devez cependant pas utiliser cet opérateur dans du code moderne, **la manière pythonique de formater les chaînes de caractères est le *f-string***.\n",
    "\n",
    "Le principe de l'opérateur `%` est le suivant. On élabore comme ci-dessus un \"format\" c'est-à-dire le patron de ce qui doit être rendu, auquel on passe des arguments pour \"remplir\" les trous. Voyons les exemples de tout à l'heure avec l'opérateur `%` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "c9d63a46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jean Dupont a 35 ans'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# l'ancienne façon de formater les chaînes avec %\n",
    "# est souvent moins lisible\n",
    "\"%s %s a %s ans\" % (prenom, nom, age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eec1b3b",
   "metadata": {},
   "source": [
    "On pouvait également avec cet opérateur recourir à un mécanisme de liaison par nommage, en passant par un dictionnaire. Pour anticiper un tout petit peu sur cette notion que nous verrons très bientôt, voici comment :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2cb4688d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dupont, Jean, 35 ans'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variables = {'le_nom': nom, 'le_prenom': prenom, 'l_age': age}\n",
    "\"%(le_nom)s, %(le_prenom)s, %(l_age)s ans\" % variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbd25554",
   "metadata": {},
   "source": [
    "### Complément - niveau avancé¶"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b0a6bab",
   "metadata": {},
   "source": [
    "De retour aux *f-string*s et à la fonction `format`, il arrive qu'on ait besoin de spécifier plus finement la façon dont une valeur doit être affichée; cela se fait en précisant un **format** à l'intérieur des `{}` comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "b6d6a6e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bla 2*math.pi=6.28 bla'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"bla {2*math.pi=:.2f} bla\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb466812",
   "metadata": {},
   "source": [
    "- à gauche du `:` vous pouvez mettre **n'importe quelle expression** (opérations arithmétiques, appels de fonctions, …); bien sûr s'il n'y a pas de `:` tout ce qui est entre les `{}` constitue l'expression à évaluer;\n",
    "- à droite du : vous pouvez préciser un **format**, nous allons en voir quelques exemples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13cf7a9b",
   "metadata": {},
   "source": [
    "#### Précision des arrondis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a0865c9",
   "metadata": {},
   "source": [
    "C'est typiquement le cas avec les valeurs flottantes pour lesquelles la précision de l'affichage vient au détriment de la lisibilité.\n",
    "\n",
    "Voici comment on obtient une valeur de pi arrondie :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "52e1e0de",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "dffc30e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2pi avec seulement 2 chiffres apres la virgule 6.28'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# un f-string\n",
    "f\"2pi avec seulement 2 chiffres apres la virgule {2*pi:.2f}\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52a0294f",
   "metadata": {},
   "source": [
    "Vous remarquez que la façon de construire un format est la même pour les *f-strings* et pour `format`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "886b690a",
   "metadata": {},
   "source": [
    "#### 0 en début de nombre"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1e6c4da",
   "metadata": {},
   "source": [
    "Pour forcer un petit entier à s'afficher sur 4 caractères, avec des 0 ajoutés au début si nécessaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "058dde2d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0015'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 15\n",
    "\n",
    "f\"{x:04d}\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e37092cd",
   "metadata": {},
   "source": [
    "Ici on utilise le format `d` (toutes ces lettres `d`, `f`, `g` viennent des formats ancestraux de la libc comme `printf`). Ici avec `04d` on précise qu'on veut une sortie sur 4 caractères et qu'il faut remplir à gauche si nécessaire avec des `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3e2f127",
   "metadata": {},
   "source": [
    "#### Largeur fixe"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7287257",
   "metadata": {},
   "source": [
    "Dans certains cas, on a besoin d'afficher des données en colonnes de largeur fixe, on utilise pour cela les formats `<` `^` et `>` pour afficher à gauche, au centre, ou à droite d'une zone de largeur fixe :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "dfe643f9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apollin    --    Dupont    --      127 €\n",
      "Myrtille   --  Lamartine   --    25432 €\n",
      "Prune      --     Soc      --   827465 €\n"
     ]
    }
   ],
   "source": [
    "# les données à afficher\n",
    "comptes = [\n",
    " ('Apollin', 'Dupont', 127),\n",
    " ('Myrtille', 'Lamartine', 25432),\n",
    " ('Prune', 'Soc', 827465),\n",
    "]\n",
    "\n",
    "for prenom, nom, solde in comptes:\n",
    "    print(f\"{prenom:<10} -- {nom:^12} -- {solde:>8} €\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07e622d7",
   "metadata": {},
   "source": [
    "#### Voir aussi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cb950ef",
   "metadata": {},
   "source": [
    "Nous vous invitons à vous reporter à la documentation de `format` pour plus de détails [sur les formats disponibles](https://docs.python.org/3/library/string.html#formatstrings), et notamment aux [nombreux exemples](https://docs.python.org/3/library/string.html#format-examples) qui y figurent."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f2f57a1",
   "metadata": {},
   "source": [
    "## 5 Obtenir une réponse de l'utilisateur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "711dff47",
   "metadata": {},
   "source": [
    "### La fonction  `input`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb2bb9e1",
   "metadata": {},
   "source": [
    "Occasionnellement, il peut être utile de poser une question à l'utilisateur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "13b09c9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrez le nom de la ville : Paris\n"
     ]
    }
   ],
   "source": [
    "nom_ville = input(\"Entrez le nom de la ville : \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "5c0617df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nom_ville=Paris\n"
     ]
    }
   ],
   "source": [
    "print(f\"nom_ville={nom_ville}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b3b383f",
   "metadata": {},
   "source": [
    "### Attention à bien vérifier / convertir"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f483a4f",
   "metadata": {},
   "source": [
    "Notez bien que `input` renvoie toujours **une chaîne de caractères** (`str`). C'est assez évident, mais il est très facile de l'oublier et de passer cette chaîne directement à une fonction qui s'attend à recevoir, par exemple, un nombre entier, auquel cas les choses se passent mal :"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c8b98a34",
   "metadata": {},
   "source": [
    ">>> input(\"nombre de lignes ? \") + 3\n",
    "nombre de lignes ? 12\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "TypeError: must be str, not int"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "286b0da0",
   "metadata": {},
   "source": [
    "Dans ce cas il faut appeler la fonction `int` pour convertir le résultat en un entier :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "8f43b888",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre de lignes ? 7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(input(\"Nombre de lignes ? \")) + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b99276f8",
   "metadata": {},
   "source": [
    "### Limitations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cae7651",
   "metadata": {},
   "source": [
    "Cette fonction peut être utile pour vos premiers pas en Python.\n",
    "\n",
    "En pratique toutefois, on utilise assez peu cette fonction, car les applications \"réelles\" viennent avec leur propre interface utilisateur, souvent graphique, et disposent donc d'autres moyens que celui-ci pour interagir avec l'utilisateur.\n",
    "\n",
    "Les applications destinées à fonctionner dans un terminal, quant à elles, reçoivent traditionnellement leurs données de la ligne de commande. C'est le propos du module `argparse` que nous avons déjà rencontré en première semaine."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c40dfc6a",
   "metadata": {},
   "source": [
    "## 6 Expressions régulières et le module `re`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16c67d00",
   "metadata": {},
   "source": [
    "Une expression régulière est un objet mathématique permettant de décrire un ensemble de textes qui possèdent des propriétés communes. Par exemple, s'il vous arrive d'utiliser un terminal, et que vous tapez\n",
    "\n",
    "`$ dir *.txt`\n",
    "\n",
    "(ou ls *.txt sur linux ou mac), vous utilisez l'expression régulière `*.txt` qui désigne tous les fichiers dont le nom se termine par `.txt`. On dit que l'expression régulière filtre toutes les chaînes qui se terminent par `.txt` (l'expression anglaise consacrée est le pattern matching).\n",
    "\n",
    "Attention toutefois, la syntaxe des expressions régulières en Python est plus complexe que les expressions de globbing utilisées dans les lignes de commande, mais permet en contrepartie de faire bien plus de choses. Notamment, le globbing `*.txt` que nous avons utilisé plus haut deviendrait `.*\\.txt` dans une expression régulière Python (le point `.` et l'astérisque `*` ayant des significations particulières et différentes de celles du globbing).\n",
    "\n",
    "Le langage Perl a été le premier à populariser l'utilisation des expressions régulières en les supportant nativement dans le langage, et non au travers d'une librairie. En python, les expressions régulières sont disponibles de manière plus traditionnelle, via le module `re` (regular expressions) de la librairie standard. Le propos de ce complément est de vous en donner une première introduction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2cc10bb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7841c262",
   "metadata": {},
   "source": [
    "### Survol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad98ace",
   "metadata": {},
   "source": [
    "Pour ceux qui ne souhaitent pas approfondir, voici un premier exemple; on cherche à savoir si un objet `chaine` est ou non de la forme *`-*.txt`, et si oui, à calculer la partie de la chaine qui remplace le `*` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4068d88f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# un objet 'expression régulière' - on dit aussi \"pattern\"\n",
    "regexp = \"(.*)-(.*)\\.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7afefd28",
   "metadata": {},
   "outputs": [],
   "source": [
    "# la chaine de départ\n",
    "chaine = \"abcdef.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3e2f7af5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# la fonction qui calcule si la chaine \"matche\" le pattern\n",
    "match = re.match(regexp, chaine)\n",
    "match is None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fa1ab39",
   "metadata": {},
   "source": [
    "Le fait que l'objet `match` vaut `None` indique que la chaine n'est pas de la bonne forme (il manque un `-` dans le nom); avec une autre chaine par contre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "854c41db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# la chaine de départ\n",
    "chaine = \"abc-def.txt\"\n",
    "match = re.match(regexp, chaine)\n",
    "match is None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4955b32",
   "metadata": {},
   "source": [
    "Ici `match` est un objet, qui nous permet ensuite d'\"extraire\" les différentes parties, comme ceci :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "80c7da48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "181221a0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'def'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e09cd79",
   "metadata": {},
   "source": [
    "Bien sûr on peut faire des choses beaucoup plus élaborées avec `re`, mais en première lecture cette introduction doit vous suffire pour avoir une idée de ce qu'on peut faire avec les expressions régulières."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfa8e25c",
   "metadata": {},
   "source": [
    "**Synonymes**\n",
    "\n",
    "Avant d'aller plus loin signalons qu'on utilise indifféremment les termes pour désigner essentiellement la même chose :\n",
    "\n",
    "- **expression régulière**\n",
    "- en anglais **regular expression** - d'où le nom du module dans import re\n",
    "- en anglais raccourci **regexp**, c'est de facto devenu un nom commun\n",
    "- en français on trouve aussi parfois le terme d'**expression rationnelle**, c'est plus rare et un peu pédant\n",
    "- en anglais on utilise aussi facilement le terme de **pattern**\n",
    "- qui du coup a été traduit en français par **motif**; bon ça c'est d'un emploi assez rare.\n",
    "\n",
    "Après selon les contextes ces termes peuvent être utilisés pour désigner des choses subtilement différentes - par exemple pour distinguer la chaine qui spécifie un **pattern** de l'objet **regexp** qui en est déduit; mais à ce stade de la présentation on peut signaler tous ces termes et les assimiler en gros à la même notion."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0961e281",
   "metadata": {},
   "source": [
    "### Complément - niveau intermédiaire"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a720ff9",
   "metadata": {},
   "source": [
    "Dans un terminal, `*.txt` est une expression régulière très simple. Le module `re` fournit le moyen de construire des expressions régulières très élaborées et plus puissantes que ce que supporte le terminal. C'est pourquoi la syntaxe des regexps de `re` est un peu différente. Par exemple comme on vient de le voir, pour filtrer la même famille de chaînes que `*-*.txt` avec le module `re`, il nous a fallu écrire l'expression régulière sous une forme légèrement différente.\n",
    "\n",
    "Je vous conseille d'avoir sous la main la [documentation du module re](https://docs.python.org/3/library/re.html) pendant que vous lisez ce complément.\n",
    "\n",
    "Dans ce complément nous serons amenés à utiliser des traits qui dépendent du LOCALE, c'est-à-dire, pour faire simple, de la configuration de l'ordinateur vis-à-vis de la langue.\n",
    "\n",
    "Tant que vous exécutez ceci dans le notebook sur la plateforme, en principe tout le monde verra exactement la même chose. Par contre, si vous faites tourner le même code sur votre ordinateur, il se peut que vous obteniez des résultats légèrement différents"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d675816a",
   "metadata": {},
   "source": [
    "#### un exemple simple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c935c073",
   "metadata": {},
   "source": [
    "##### `findall`\n",
    "\n",
    "On se donne deux exemples de chaînes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ac246c2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentences = ['Lacus a donec, vitae gravida proin sociis.', \n",
    "             'Neque ipsum! rhoncus cras quam.']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79cda516",
   "metadata": {},
   "source": [
    "On peut chercher tous les mots se terminant par `a` ou `m` dans une chaîne avec `findall`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a553a535",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---- dans >Lacus a donec, vitae gravida proin sociis.<\n",
      "['a ', 'gravida ']\n",
      "---- dans >Neque ipsum! rhoncus cras quam.<\n",
      "['ipsum!', 'quam.']\n"
     ]
    }
   ],
   "source": [
    "for sentence in sentences:\n",
    "    print(f\"---- dans >{sentence}<\")\n",
    "    print(re.findall(r\"\\w*[am]\\W\", sentence))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62db6b7f",
   "metadata": {},
   "source": [
    "Ce code permet de chercher toutes (findall) les occurrences de l'expression régulière, qui ici est définie par la chaine :\n",
    "\n",
    "`r\"\\w*[am]\\W\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ed03ae9",
   "metadata": {},
   "source": [
    "##### digression : les raw-strings\n",
    "Pour anticiper un peu, signalons que cette façon de créer un chaine en la préfixant par un `r` s'appelle une **raw-string**; l'intérêt c'est de **ne pas interpréter les backslashs `\\`**\n",
    "\n",
    "On voit tout de suite l'intérêt sur un exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "34cdad03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sans raw-string\n",
      "un newline\n"
     ]
    }
   ],
   "source": [
    "print(\"sans raw-string\\nun newline\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "481a4b76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dans\\nunraw-string\n"
     ]
    }
   ],
   "source": [
    "print(r\"dans\\nunraw-string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ff47697",
   "metadata": {},
   "source": [
    "Comme vous le voyez dans une chaine \"normale\" les caractères backslash ont une signification particulière; mais nous ce qu'on veut faire, quand on crée une expression régulière, c'est de **laisser les backslashs intacts**, car c'est à la couche de regexp de les interpréter."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "719bce37",
   "metadata": {},
   "source": [
    "##### reprenons\n",
    "Nous verrons tout à l'heure comment fabriquer des expressions régulières plus en détail, mais pour démystifier au moins celle-ci, on a mis bout à bout les morceaux suivants.\n",
    "- `\\w*` : on veut trouver une sous-chaîne qui commence par un nombre quelconque, y compris nul (`*`) de caractères alphanumériques (`\\w`). Ceci est défini en fonction de votre LOCALE, on y reviendra.\n",
    "- `[am]` : immédiatement après, il nous faut trouver un caratère a ou m.\n",
    "- `\\W` : et enfin, il nous faut un caractère qui ne soit **pas** alphanumérique. Ceci est important puisqu'on cherche les mots qui **se terminent** par un `a` ou un `m`, si on ne le mettait pas on obtiendrait ceci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "63ad65c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---- dans >Lacus a donec, vitae gravida proin sociis.<\n",
      "['La', 'a', 'vita', 'gravida']\n",
      "---- dans >Neque ipsum! rhoncus cras quam.<\n",
      "['ipsum', 'cra', 'quam']\n"
     ]
    }
   ],
   "source": [
    "# le \\W final est important\n",
    "# voici ce qu'on obtient si on l'omet\n",
    "for sentence in sentences:\n",
    "    print(f\"---- dans >{sentence}<\")\n",
    "    print(re.findall(r\"\\w*[am]\", sentence))\n",
    "    \n",
    "# NB: Comme vous le devinez, ici la notation for ... in ... \n",
    "# permet de parcourir successivement tous les éléments de la séquence"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd31e34",
   "metadata": {},
   "source": [
    "##### `split`\n",
    "Une autre forme simple d'utilisation des regexps est `re.split`, qui fournit une fonctionnalité voisine de `str.split`, mais ou les séparateurs sont exprimés comme une expression régulière"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f23f9181",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---- dans >Lacus a donec, vitae gravida proin sociis.<\n",
      "['Lacus', 'a', 'donec', 'vitae', 'gravida', 'proin', 'sociis', '']\n",
      "\n",
      "---- dans >Neque ipsum! rhoncus cras quam.<\n",
      "['Neque', 'ipsum', 'rhoncus', 'cras', 'quam', '']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for sentence in sentences:\n",
    "    print(f\"---- dans >{sentence}<\")\n",
    "    print(re.split(r\"\\W+\", sentence))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10e0a1ae",
   "metadata": {},
   "source": [
    "Ici l'expression régulière, qui bien sûr décrit le séparateur, est simplement `\\W+` c'est-à-dire toute suite d'au moins un caractère non alphanumérique.\n",
    "\n",
    "Nous avons donc là un moyen simple, et plus puissant que `str.split`, de couper un texte en mots."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11b70137",
   "metadata": {},
   "source": [
    "##### `sub`\n",
    "Une troisième méthode utilitaire est `re.sub` qui permet de remplacer les occurrences d'une regexp, comme par exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "02bbd8ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---- dans >Lacus a donec, vitae gravida proin sociis.<\n",
      "XLacusY XaY XdonecY, XvitaeY XgravidaY XproinY XsociisY.\n",
      "\n",
      "---- dans >Neque ipsum! rhoncus cras quam.<\n",
      "XNequeY XipsumY! XrhoncusY XcrasY XquamY.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for sentence in sentences:\n",
    "    print(f\"---- dans >{sentence}<\")\n",
    "    print(re.sub(r\"(\\w+)\", r\"X\\1Y\", sentence))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "973e200d",
   "metadata": {},
   "source": [
    "Ici, l'expression régulière (le premier argument) contient un **groupe** : on a utilisé des parenthèses autour du `\\w+`. Le second argument est la chaîne de remplacement, dans laquelle on a fait **référence au groupe** en écrivant `\\1`, qui veut dire tout simplement \"le premier groupe\".\n",
    "\n",
    "Donc au final, l'effet de cet appel est d'entourer toutes les suites de caractères alphanumériques par `X` et `Y`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1c6b59b",
   "metadata": {},
   "source": [
    "##### Pourquoi un raw-string ?\n",
    "En guise de digression, il n'y a aucune obligation à utiliser un raw-string, d'ailleurs on rappelle qu'il n'y a pas de différence de nature entre un raw-string et une chaîne usuelle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8e400685",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "both compared with is → True\n",
      "both compared with == → True\n"
     ]
    }
   ],
   "source": [
    "raw = r'abc'\n",
    "regular = 'abc'\n",
    "# comme on a pris une 'petite' chaîne ce sont les mêmes objets\n",
    "print(f\"both compared with is → {raw is regular}\")\n",
    "# et donc a fortiori\n",
    "print(f\"both compared with == → {raw == regular}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e8ea82b",
   "metadata": {},
   "source": [
    "Il se trouve que le backslash `\\` à l'intérieur des expressions régulières est d'un usage assez courant - on l'a vu déjà plusieurs fois. C'est pourquoi on **utilise fréquemment un raw-string** pour décrire une expression régulière. On rappelle que le raw-string désactive l'interprétation des `\\` à l'intérieur de la chaîne, par exemple, `\\t` est interprété comme un caractère de tabulation dans une chaine usuelle. Sans raw-string, il faut doubler tous les `\\` pour qu'il n'y ait pas d'interprétation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5f9fe48",
   "metadata": {},
   "source": [
    "#### un deuxième exemple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5be55c7b",
   "metadata": {},
   "source": [
    "Nous allons maintenant voir comment on peut d'abord vérifier si une chaîne est conforme au critère défini par l'expression régulière, mais aussi extraire les morceaux de la chaîne qui correspondent aux différentes parties de l'expression.\n",
    "\n",
    "Pour cela, supposons qu'on s'intéresse aux chaînes qui comportent 5 parties, une suite de chiffres, une suite de lettres, des chiffres à nouveau, des lettres et enfin de nouveau des chiffres.\n",
    "\n",
    "Pour cela on considère ces trois chaines en entrée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ec9f9eba",
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = ['890hj000nnm890',    # cette entrée convient\n",
    "          '123abc456def789',   # celle-ci aussi\n",
    "          '8090abababab879',   # celle-ci non\n",
    "          ]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff69d43c",
   "metadata": {},
   "source": [
    "##### `match`\n",
    "Pour commencer, voyons que l'on peut facilement vérifier si une chaîne vérifie ou non le critère."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "11f9ed99",
   "metadata": {},
   "outputs": [],
   "source": [
    "regexp1 = \"[0-9]+[A-Za-z]+[0-9]+[A-Za-z]+[0-9]+\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94d6b860",
   "metadata": {},
   "source": [
    "Si on applique cette expression régulière à toutes nos entrées"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "5d79afa1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "890hj000nnm890   → <re.Match object; span=(0, 14), match='890hj000nnm890'>\n",
      "123abc456def789  → <re.Match object; span=(0, 15), match='123abc456def789'>\n",
      "8090abababab879  → None\n"
     ]
    }
   ],
   "source": [
    "for sample in samples:\n",
    "    match = re.match(regexp1, sample)\n",
    "    print(f\"{sample:16} → {match}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a7abae4",
   "metadata": {},
   "source": [
    "Pour rendre ce résultat un peu plus lisible nous nous définissons une petite fonction de confort."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c67032e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pour simplement visualiser si on a un match ou pas\n",
    "def nice(match):\n",
    "    # le retour de re.match est soit None, soit un objet match\n",
    "    return \"no\" if match is None else \"Match!\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02c1b6db",
   "metadata": {},
   "source": [
    "Avec quoi on peut refaire l'essai sur toutes nos entrées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5cb56774",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REGEXP=[0-9]+[A-Za-z]+[0-9]+[A-Za-z]+[0-9]+\n",
      "\n",
      "  890hj000nnm890 → Match!\n",
      " 123abc456def789 → Match!\n",
      " 8090abababab879 → no\n"
     ]
    }
   ],
   "source": [
    "# la même chose mais un peu moins encombrant\n",
    "print(f\"REGEXP={regexp1}\\n\")\n",
    "for sample in samples:\n",
    "    match = re.match(regexp1, sample)\n",
    "    print(f\"{sample:>16} → {nice(match)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a706e34",
   "metadata": {},
   "source": [
    "Ici plutôt que d'utiliser les raccourcis comme `\\w` j'ai préféré écrire explicitement les ensembles de caractères en jeu. De cette façon, on rend son code indépendant du LOCALE si c'est ce qu'on veut faire. Il y a deux morceaux qui interviennent tour à tour :\n",
    "\n",
    "- `[0-9]+` signifie une suite de au moins un caractère dans l'intervalle `[0-9]`,\n",
    "- `[A-Za-z]+` pour une suite d'au moins un caractère dans l'intervalle `[A-Z]` ou dans l'intervalle `[a-z]`.\n",
    "\n",
    "Et comme tout à l'heure on asimplement juxtaposé les morceaux dans le bon ordre pour construire l'expression régulière complète."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "515c50b2",
   "metadata": {},
   "source": [
    "##### Nommer un morceau (un groupe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "af592da5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123abc456def789'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on se concentre sur une entrée correcte\n",
    "haystack = samples[1]\n",
    "haystack"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c581eabd",
   "metadata": {},
   "source": [
    "Maintenant, on va même pouvoir **donner un nom** à un morceau de la regexp, ici on désigne par `needle` le groupe de chiffres du milieu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cc280454",
   "metadata": {},
   "outputs": [],
   "source": [
    "# la même regexp, mais on donne un nom au groupe de chiffres central\n",
    "regexp2 = \"[0-9]+[A-Za-z]+(?P<needle>[0-9]+)[A-Za-z]+[0-9]+\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56c2d597",
   "metadata": {},
   "source": [
    "Et une fois que c'est fait, on peut demander à l'outil de nous **retrouver la partie correspondante** dans la chaine initiale :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cb83d96c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "456\n"
     ]
    }
   ],
   "source": [
    "print(re.match(regexp2, haystack).group('needle'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe9f7236",
   "metadata": {},
   "source": [
    "Dans cette expression on a utilisé un **groupe nommé** `(?P<needle>[0-9]+)`, dans lequel :\n",
    "- les parenthèses définissent un groupe,\n",
    "- `?P<needle>` spécifie que ce groupe pourra être référencé sous le nom `needle` (cette syntaxe très absconse est héritée semble-t-il de perl)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e28c5960",
   "metadata": {},
   "source": [
    "#### un troisième exemple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33e945e0",
   "metadata": {},
   "source": [
    "Enfin, et c'est un trait qui n'est pas présent dans tous les langages, on peut restreindre un morceau de chaîne à être identique à un groupe déjà vu plus tôt dans la chaîne. Dans l'exemple ci-dessus, on pourrait ajouter comme contrainte que le premier et le dernier groupes de chiffres soient identiques, comme ceci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a38373ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "regexp3 = \"(?P<id>[0-9]+)[A-Za-z]+(?P<needle>[0-9]+)[A-Za-z]+(?P=id)\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b8c82c9",
   "metadata": {},
   "source": [
    "Si bien que maintenant, avec les mêmes entrées que tout à l'heure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a38bd7ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REGEXP=(?P<id>[0-9]+)[A-Za-z]+(?P<needle>[0-9]+)[A-Za-z]+(?P=id)\n",
      "\n",
      "  890hj000nnm890 → Match!\n",
      " 123abc456def789 → no\n",
      " 8090abababab879 → no\n"
     ]
    }
   ],
   "source": [
    "print(f\"REGEXP={regexp3}\\n\")\n",
    "for sample in samples:\n",
    "    match = re.match(regexp3, sample)\n",
    "    print(f\"{sample:>16} → {nice(match)}\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d691d59",
   "metadata": {},
   "source": [
    "Comme précédemment on a défini le groupe nommé `id` comme étant la première suite de chiffres. La nouveauté ici est la **contrainte** qu'on a imposée sur le dernier groupe avec `(?P=id)`. Comme vous le voyez, on n'obtient un match qu'avec les entrées dans lesquelles le dernier groupe de chiffres est identique au premier."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adbbc2b9",
   "metadata": {},
   "source": [
    "#### Comment utiliser la librairie - Compilation des expressions régulières"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "464c0354",
   "metadata": {},
   "source": [
    "##### Fonctions de commodité et workflow\n",
    "Comme vous le savez peut-être, une expression régulière décrite sous forme de chaîne, comme par exemple `\"\\w*[am]\\W\"`, peut être traduite dans un **automate fini** qui permet de faire le filtrage avec une chaîne. C'est ce qui explique le workflow que nous avons résumé dans cette figure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "716216fb",
   "metadata": {},
   "source": [
    "La méthode recommandée pour utiliser la librairie, lorsque vous avez le même pattern à appliquer à un grand nombre de chaînes, est de :\n",
    "- compiler **une seule fois** votre chaîne en un automate, qui est matérialisé par un objet de la classe `re.RegexObject`, en utilisant `re.compile`,\n",
    "- puis d'**utiliser directement cet objet** autant de fois que vous avez de chaînes.\n",
    "\n",
    "Nous avons utilisé dans les exemples plus haut (et nous continuerons plus bas pour une meilleure lisibilité) des **fonctions de commodité** du module, qui sont pratiques, par exemple, pour mettre au point une expression régulière en mode interactif, mais qui ne **sont pas forcément adaptées** dans tous les cas.\n",
    "\n",
    "Ces fonctions de commodité fonctionnent toutes sur le même principe :\n",
    "\n",
    "`re.match(regexp, sample)`  ⟺\n",
    "`re.compile(regexp).match(sample)`\n",
    "\n",
    "Donc à chaque fois qu'on utilise une fonction de commodité, on recompile la chaîne en automate, ce qui, dès qu'on a plus d'une chaîne à traiter, représente un surcoût."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "99f044de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  890hj000nnm890 → Match!\n",
      " 123abc456def789 → no\n",
      " 8090abababab879 → no\n"
     ]
    }
   ],
   "source": [
    "# au lieu de faire comme ci-dessus:\n",
    "\n",
    "# imaginez 10**6 chaînes dans samples\n",
    "for sample in samples:\n",
    "    match = re.match(regexp3, sample)\n",
    "    print(f\"{sample:>16} → {nice(match)}\")   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "115d9f44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  890hj000nnm890 → Match!\n",
      " 123abc456def789 → no\n",
      " 8090abababab879 → no\n"
     ]
    }
   ],
   "source": [
    "# dans du vrai code on fera plutôt:\n",
    "\n",
    "# on compile la chaîne en automate une seule fois\n",
    "re_obj3 = re.compile(regexp3)\n",
    "\n",
    "# ensuite on part directement de l'automate\n",
    "for sample in samples:\n",
    "    match = re_obj3.match(sample)\n",
    "    print(f\"{sample:>16} → {nice(match)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e381cbf",
   "metadata": {},
   "source": [
    "Cette deuxième version ne compile qu'une fois la chaîne en automate, et donc est plus efficace."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef0cd517",
   "metadata": {},
   "source": [
    "##### Les méthodes sur la classe `RegexObject`\n",
    "\n",
    "Les objets de la classe `RegexObject` représentent donc l'automate à état fini qui est le résultat de la compilation de l'expression régulière. Pour résumer ce qu'on a déjà vu, les méthodes les plus utiles sur un objet `RegexObject` sont :\n",
    "- `match` et `search`, qui cherchent un match soit uniquement au début (`match`) ou n'importe où dans la chaîne (`search`),\n",
    "- `findall` et `split` pour chercher toutes les occurrences (`findall`) ou leur négatif (`split`),\n",
    "- `sub` (qui aurait pu sans doute s'appeler `replace`, mais c'est comme ça) pour remplacer les occurrences de pattern."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bfffd73",
   "metadata": {},
   "source": [
    "##### Exploiter le résultat\n",
    "Les méthodes disponibles sur la classe `re.MatchObject` sont documentées en détail [ici](https://docs.python.org/3/library/re.html#match-objects). On en a déjà rencontré quelques-unes, en voici à nouveau un aperçu rapide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "8ca71ed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# exemple\n",
    "sample = \"    Isaac Newton, physicist\"\n",
    "match = re.search(r\"(\\w+) (?P<name>\\w+)\", sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eddaea3e",
   "metadata": {},
   "source": [
    "`re` et `string` pour retrouver les données d'entrée du match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "39a601e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'    Isaac Newton, physicist'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d3f1acf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "re.compile(r'(\\w+) (?P<name>\\w+)', re.UNICODE)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.re"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59f59450",
   "metadata": {},
   "source": [
    "`group`, `groups`, `groupdict` pour retrouver les morceaux de la chaîne d'entrée qui correspondent aux **groupes** de la regexp. On peut y accéder par rang, ou par nom (comme on l'a vu plus haut avec `needle`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "a038a9af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Isaac', 'Newton')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "bb1a52e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Isaac'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.group(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ad719bba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Newton'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.group('name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "7fa1a304",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Newton'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.group(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "4af14479",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Newton'}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.groupdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed69f52f",
   "metadata": {},
   "source": [
    "Comme on le voit pour l'accès par rang **les indices commencent à 1** pour des raisons historiques (on pouvait déjà référencer `\\1` dans l'éditeur Unix sed à la fin des années 70 !).\n",
    "\n",
    "On peut aussi accéder au **groupe 0** comme étant la partie de la chaîne de départ qui a effectivement été filtrée par l'expression régulière - qui en général est une sous-chaine de la chaîne de départ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "2d248458",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Isaac Newton'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# la sous-chaine filtrée\n",
    "match.group(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "de9a2581",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'    Isaac Newton, physicist'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# la chaine de départ\n",
    "sample"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56b4e523",
   "metadata": {},
   "source": [
    "`expand` permet de faire une espèce de `str.format` avec les valeurs des groupes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "ec3bee3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'last_name Newton first_name Isaac'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match.expand(r\"last_name \\g<name> first_name \\1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7520e38e",
   "metadata": {},
   "source": [
    "`span` pour connaître les index dans la chaîne d'entrée pour un groupe donné."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "1d185530",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Newton'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NB: seq[i:j] est une opération de slicing que nous verrons plus tard\n",
    "# Elle retourne une séquence contenant les éléments de i à j-1 de seq\n",
    "begin, end = match.span('name')\n",
    "sample[begin:end]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8d64d26",
   "metadata": {},
   "source": [
    "##### Les différents modes (flags)\n",
    "Enfin il faut noter qu'on peut passer à `re.compile` un certain nombre de *flags* qui modifient globalement l'interprétation de la chaîne, et qui peuvent rendre service.\n",
    "\n",
    "Vous trouverez une [liste exhaustive de ces flags ici](https://docs.python.org/3/library/re.html#module-contents). Ils ont en général un nom long et parlant, et un alias court sur un seul caractère. Les plus utiles sont sans doute :\n",
    "- `IGNORECASE` (alias `I`) pour, eh bien, ne pas faire la différence entre minuscules et majuscules,\n",
    "- `UNICODE` (alias `U`) pour rendre les séquences `\\w` et autres basées sur les propriétés des caractères dans la norme Unicode,\n",
    "- `LOCALE` (alias `L`) cette fois `\\w` dépend du `locale` courant,\n",
    "- `MULTILINE` (alias `M`), et\n",
    "- `DOTALL` (alias `S`) - pour ces deux derniers flags, voir la discussion à la fin du complément.\n",
    "\n",
    "Comme c'est souvent le cas, on doit passer à `re.compile` un **ou logique** (caractère `|`) des différents flags que l'on veut utiliser, c'est-à-dire qu'on fera par exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "70b3f3dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAX_REPEAT 0 MAXREPEAT\n",
      "  LITERAL 97\n",
      "MAX_REPEAT 1 MAXREPEAT\n",
      "  LITERAL 98\n",
      "\n",
      " 0. INFO 4 0b0 1 MAXREPEAT (to 5)\n",
      " 5: REPEAT_ONE 6 0 MAXREPEAT (to 12)\n",
      " 9.   LITERAL_UNI_IGNORE 0x61 ('a')\n",
      "11.   SUCCESS\n",
      "12: REPEAT_ONE 6 1 MAXREPEAT (to 19)\n",
      "16.   LITERAL_UNI_IGNORE 0x62 ('b')\n",
      "18.   SUCCESS\n",
      "19: SUCCESS\n"
     ]
    }
   ],
   "source": [
    "regexp = \"a*b+\"\n",
    "re_obj = re.compile(regexp, flags=re.IGNORECASE | re.DEBUG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "09bc7f2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a*b+ -> Match!\n"
     ]
    }
   ],
   "source": [
    "# on ignore la casse des caractères \n",
    "print(regexp, \"->\", nice(re_obj.match(\"AabB\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7ab855f",
   "metadata": {},
   "source": [
    "#### Comment construire une expression régulière"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf4181b5",
   "metadata": {},
   "source": [
    "Nous pouvons à présent voir comment construire une expression régulière, en essayant de rester synthétique (la [documentation du module re](https://docs.python.org/3/library/re.html) en donne une version exhaustive).\n",
    "\n",
    "##### La brique de base : le caractère\n",
    "Au commencement il faut spécifier des caractères.\n",
    "- **un seul** caractère:\n",
    "    - vous le citez tel quel, en le précédent d'un backslash `\\` s'il a par ailleurs un sens spécial dans le micro-langage de regexps (comme `+`, `*`, `[`, etc.);\n",
    "- l'attrape-tout (è*wildcard*):\n",
    "    - un point . signifie \"n'importe quel caractère\";\n",
    "- un **ensemble** de caractères avec la notation [...] qui permet de décrire par exemple:\n",
    "    - `[a1=]` un ensemble in extenso, ici un caractère parmi `a`, `1`, ou `=`,\n",
    "    - `[a-z]` un intervalle de caractères, ici de `a` à `z`,\n",
    "    - `[15e-g]` un mélange des deux, ici un ensemble qui contiendrait `1`, `5`, `e`, `f` et `g`,\n",
    "    - `[^15e-g]` une **négation**, qui a `^` comme premier caractère dans les `[]`, ici tout sauf l'ensemble précédent;\n",
    "- un **ensemble prédéfini** de caractères, qui peuvent alors dépendre de l'environnement (UNICODE et LOCALE) avec entre autres les notations:\n",
    "    - `\\w` les caractères alphanumériques, et `\\W` (les autres),\n",
    "    - `\\s` les caractères \"blancs\" - espace, tabulation, saut de ligne, etc., et `\\S` (les autres),\n",
    "    - `\\d` pour les chiffres, et `\\D` (les autres)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "b522f53b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd / abcd       → Match!\n",
      "abcd / ab[cd][cd] → Match!\n",
      "abcd / ab[a-z]d   → Match!\n",
      "abcd / abc.       → Match!\n",
      "abcd / abc\\.      → no\n"
     ]
    }
   ],
   "source": [
    "sample = \"abcd\"\n",
    "\n",
    "for regexp in ['abcd', 'ab[cd][cd]', 'ab[a-z]d', r'abc.', r'abc\\.']:\n",
    "    match = re.match(regexp, sample)\n",
    "    print(f\"{sample} / {regexp:<10s} → {nice(match)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8882dc4",
   "metadata": {},
   "source": [
    "Pour ce dernier exemple, comme on a backslashé le `.` il faut que la chaîne en entrée contienne vraiment un `.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "feb429bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Match!\n"
     ]
    }
   ],
   "source": [
    "print(nice(re.match (r\"abc\\.\", \"abc.\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ba104a2",
   "metadata": {},
   "source": [
    "##### En série ou en parallèle\n",
    "Si je fais une analogie avec les montages électriques, jusqu'ici on a vu le montage en série, on met des expressions régulières bout à bout qui filtrent (`match`) la chaine en entrée séquentiellement du début à la fin. On a un peu de marge pour spécifier des alternatives, lorsqu'on fait par exemple\n",
    "\n",
    "`\"ab[cd]ef\"`\n",
    "\n",
    "mais c'est limité à **un seul** caractère. Si on veut reconnaitre deux mots qui n'ont pas grand-chose à voir comme `abc` ou `def`, il faut en quelque sorte mettre deux regexps en parallèle, et c'est ce que permet l'opérateur `|`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "693c0700",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc / abc|def → Match!\n",
      "def / abc|def → Match!\n",
      "aef / abc|def → no\n"
     ]
    }
   ],
   "source": [
    "regexp = \"abc|def\"\n",
    "\n",
    "for sample in ['abc', 'def', 'aef']:\n",
    "    match = re.match(regexp, sample)\n",
    "    print(f\"{sample} / {regexp} → {nice(match)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0406b08a",
   "metadata": {},
   "source": [
    "##### Fin(s) de chaîne\n",
    "Selon que vous utilisez `match` ou `search`, vous précisez si vous vous intéressez uniquement à un match en début (`match`) ou n'importe où (`search`) dans la chaîne.\n",
    "\n",
    "Mais indépendamment de cela, il peut être intéressant de \"coller\" l'expression en début ou en fin de ligne, et pour ça il existe des caractères spéciaux:\n",
    "- `^` lorsqu'il est utilisé comme un caractère (c'est à dire pas en début de `[]`) signifie un début de chaîne;\n",
    "- `\\A` a le même sens (sauf en mode MULTILINE), et je le recommande de préférence à `^` qui est déjà pas mal surchargé;\n",
    "- `$` matche une fin de ligne;\n",
    "- `\\Z` est voisin de `$` mais pas tout à fait identique.\n",
    "Reportez-vous à la documentation pour le détails des différences. Attention aussi à entrer le `^` correctement, il vous faut le caractère ASCII et non un voisin dans la ménagerie Unicode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "a98ed123",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd / bc    match → no    , search → Match!\n",
      "abcd / \\Aabc match → Match!, search → Match!\n",
      "abcd / ^abc  match → Match!, search → Match!\n",
      "abcd / \\Abc  match → no    , search → no\n",
      "abcd / ^bc   match → no    , search → no\n",
      "abcd / bcd\\Z match → no    , search → Match!\n",
      "abcd / bcd$  match → no    , search → Match!\n",
      "abcd / bc\\Z  match → no    , search → no\n",
      "abcd / bc$   match → no    , search → no\n"
     ]
    }
   ],
   "source": [
    "sample = 'abcd'\n",
    "\n",
    "for regexp in [ r'bc', r'\\Aabc', r'^abc', \n",
    "                r'\\Abc', r'^bc', r'bcd\\Z', \n",
    "                r'bcd$', r'bc\\Z', r'bc$' ]:\n",
    "    match = re.match(regexp, sample)\n",
    "    search = re.search(regexp, sample)\n",
    "    print(f\"{sample} / {regexp:5s} match → {nice(match):6s},\"\n",
    "          f\" search → {nice(search)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a44e398",
   "metadata": {},
   "source": [
    "On a en effet bien le pattern `bc` dans la chaine en entrée, mais il n'est ni au début ni à la fin."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c176113e",
   "metadata": {},
   "source": [
    "##### Parenthéser - (grouper)\n",
    "Pour pouvoir faire des montages élaborés, il faut pouvoir parenthéser."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "689aeefc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# une parenthése dans une RE \n",
    "# pour mettre en ligne:\n",
    "# un début 'a', \n",
    "# un milieu 'bc' ou 'de' \n",
    "# et une fin 'f'\n",
    "regexp = \"a(bc|de)f\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "3f07b390",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcf → Match!\n",
      "adef → Match!\n",
      "abef → no\n",
      " abf → no\n"
     ]
    }
   ],
   "source": [
    "for sample in ['abcf', 'adef',  'abef', 'abf']:\n",
    "    match = re.match(regexp, sample)\n",
    "    print(f\"{sample:>4s} → {nice(match)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff6c0b50",
   "metadata": {},
   "source": [
    "Les parenthèses jouent un rôle additionel de **groupe**, ce qui signifie qu'on peut retrouver le texte correspondant à l'expression régulière comprise dans les `()`. Par exemple, pour le premier match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "dd726148",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcf, a(bc|de)f → ('bc',)\n"
     ]
    }
   ],
   "source": [
    "sample = 'abcf'\n",
    "match = re.match(regexp, sample)\n",
    "print(f\"{sample}, {regexp} → {match.groups()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2798397",
   "metadata": {},
   "source": [
    "dans cet exemple, on n'a utilisé qu'un seul groupe `()`, et le morceau de chaîne qui correspond à ce groupe se trouve donc être le seul groupe retourné par `MatchObject.group`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2f7a82",
   "metadata": {},
   "source": [
    "##### Compter les répétitions\n",
    "Vous disposez des opérateurs suivants :\n",
    "- `*` l'étoile qui signifie n'importe quel nombre, même nul, d'occurrences - par exemple, `(ab)*` pour indiquer `''` ou `'ab'` ou `'abab'` ou etc.,\n",
    "- `+` le plus qui signifie au moins une occurrence - e.g. `(ab)+` pour `ab` ou `abab` ou `ababab` ou etc,\n",
    "- `?` qui indique une option, c'est-à-dire 0 ou 1 occurence - autrement dit `(ab)?` matche `''` ou `ab`,\n",
    "- `{n}` pour exactement n occurrences de `(ab)` - e.g. `(ab){3}` qui serait exactement équivalent à `ababab`,\n",
    "- `{m,n}` entre m et n fois inclusivement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "265c83a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         / \\A(ab)*\\Z      → Match!\n",
      "      ab / \\A(ab)*\\Z      → Match!\n",
      "  ababab / \\A(ab)*\\Z      → Match!\n",
      "abababab / \\A(ab)*\\Z      → Match!\n",
      "    baba / \\A(ab)*\\Z      → no\n",
      "         / \\A(ab)+\\Z      → no\n",
      "      ab / \\A(ab)+\\Z      → Match!\n",
      "  ababab / \\A(ab)+\\Z      → Match!\n",
      "abababab / \\A(ab)+\\Z      → Match!\n",
      "    baba / \\A(ab)+\\Z      → no\n",
      "         / \\A(ab){3}\\Z    → no\n",
      "      ab / \\A(ab){3}\\Z    → no\n",
      "  ababab / \\A(ab){3}\\Z    → Match!\n",
      "abababab / \\A(ab){3}\\Z    → no\n",
      "    baba / \\A(ab){3}\\Z    → no\n",
      "         / \\A(ab){3,4}\\Z  → no\n",
      "      ab / \\A(ab){3,4}\\Z  → no\n",
      "  ababab / \\A(ab){3,4}\\Z  → Match!\n",
      "abababab / \\A(ab){3,4}\\Z  → Match!\n",
      "    baba / \\A(ab){3,4}\\Z  → no\n"
     ]
    }
   ],
   "source": [
    "# NB: la construction\n",
    "#   [op(elt) for elt in iterable] \n",
    "# est une compréhension de liste que nous étudierons plus tard.\n",
    "# Elle retourne une liste contenant les résultats\n",
    "# de l'opération op sur chaque élément de la liste de départ\n",
    "\n",
    "samples = [n*'ab' for n in [0, 1, 3, 4]] + ['baba']\n",
    "\n",
    "for regexp in ['(ab)*', '(ab)+', '(ab){3}', '(ab){3,4}']:\n",
    "    # on ajoute \\A \\Z pour matcher toute la chaine\n",
    "    line_regexp = r\"\\A{}\\Z\".format(regexp)\n",
    "    for sample in samples:\n",
    "        match = re.match(line_regexp, sample)\n",
    "        print(f\"{sample:>8s} / {line_regexp:14s} → {nice(match)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "158bb8cc",
   "metadata": {},
   "source": [
    "##### Groupes et contraintes\n",
    "Nous avons déjà vu un exemple de groupe nommé (voir `needle` plus haut), les opérateurs que l'on peut citer dans cette catégorie sont :\n",
    "- `(...)` les parenthèses définissent un groupe anonyme,\n",
    "- `(?P<name>...)` définit un groupe nommé,\n",
    "- `(?:...)` permet de mettre des parenthèses mais sans créer un groupe, pour optimiser l'exécution puisqu'on n'a pas besoin de conserver les liens vers la chaîne d'entrée,\n",
    "- `(?P=name)` qui ne matche que si l'on retrouve à cet endroit de l'entrée la même sous-chaîne que celle trouvée pour le groupe `name` en amont,\n",
    "- enfin `(?=...)`, `(?!...)`et `(?<=...)` permettent des contraintes encore plus élaborées, nous vous laissons le soin d'expérimenter avec elles si vous êtes intéressés; sachez toutefois que l'utilisation de telles constructions peut en théorie rendre l'interprétation de votre expression régulière beaucoup moins efficace."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6608ec40",
   "metadata": {},
   "source": [
    "##### Greedy vs non-greedy\n",
    "Lorsqu'on stipule une répétition un nombre indéfini de fois, il se peut qu'il existe **plusieurs** façons de filtrer l'entrée avec l'expression régulière. Que ce soit avec `*`, ou `+`, ou `?`, l'algorithme va toujours essayer de trouver la **séquence la plus longue**, c'est pourquoi on qualifie l'approche de greedy - quelque chose comme glouton en français."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "11f1a9b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<h1>Title</h1>'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# un fragment d'HTML \n",
    "line='<h1>Title</h1>'\n",
    "\n",
    "# si on cherche un texte quelconque entre crochets\n",
    "# c'est-à-dire l'expression régulière \"<.*>\"\n",
    "re_greedy = '<.*>'\n",
    "\n",
    "# on obtient ceci\n",
    "# on rappelle que group(0) montre la partie du fragment\n",
    "# HTML qui matche l'expression régulière\n",
    "match = re.match(re_greedy, line)\n",
    "match.group(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a65c884",
   "metadata": {},
   "source": [
    "Ça n'est pas forcément ce qu'on voulait faire, aussi on peut spécifier l'approche inverse, c'est-à-dire de trouver la **plus-petite chaîne** qui matche, dans une approche dite non-greedy, avec les opérateurs suivants :\n",
    "- `*?` : `*` mais non-greedy,\n",
    "- `+?` : `+` mais non-greedy,\n",
    "- `??` : `?` mais non-greedy,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "8541640e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<h1>'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ici on va remplacer * par *? pour rendre l'opérateur * non-greedy\n",
    "re_non_greedy = re_greedy = '<.*?>'\n",
    "\n",
    "# mais on continue à cherche un texte entre <> naturellement\n",
    "# si bien que cette fois, on obtient\n",
    "match = re.match(re_non_greedy, line)\n",
    "match.group(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50d099ef",
   "metadata": {},
   "source": [
    "##### S'agissant du traitement des fins de ligne\n",
    "Il peut être utile, pour conclure cette présentation, de préciser un peu le comportement de la librairie vis-à-vis des fins de ligne.\n",
    "\n",
    "Historiquement, les expressions régulières telles qu'on les trouve dans les librairies C, donc dans `sed`, `grep` et autre utilitaires Unix, sont associées au modèle mental où on filtre les entrées ligne par ligne.\n",
    "\n",
    "Le module `re` en garde des traces, puisque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "fc210648",
   "metadata": {},
   "outputs": [],
   "source": [
    "# un exemple de traitement des 'newlines' \n",
    "sample = \"\"\"une entrée\n",
    "sur\n",
    "plusieurs\n",
    "lignes\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8ce374f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('une entrée',)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match = re.compile(\"(.*)\").match(sample)\n",
    "match.groups()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef4fe0ee",
   "metadata": {},
   "source": [
    "Vous voyez donc que l'attrape-tout `'.'` en fait n'attrape pas le caractère de fin de ligne `\\n`, puisque si c'était le cas et compte tenu du coté greedy de l'algorithme on devrait voir ici tout le contenu de `ample`. Il existe un flag `re.DOTALL` qui permet de faire de `.` un vrai attrape-tout qui capture aussi les newline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "1045dc3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('une entrée\\nsur\\nplusieurs\\nlignes\\n',)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match = re.compile(\"(.*)\", flags=re.DOTALL).match(sample)\n",
    "match.groups()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd03534",
   "metadata": {},
   "source": [
    "Cela dit, le caractère newline est par ailleurs considéré comme un caractère comme un autre, on peut le mentionner **dans une regexp** comme les autres. Voici quelques exemples pour illustrer tout ceci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "7bac2402",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('une entrée',)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# (depuis Python 3) sans mettre de flag, \\w matche l'Unicode\n",
    "match = re.compile(\"([\\w ]*)\").match(sample)\n",
    "match.groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "5a610a1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('une entr',)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pour matcher les caractères ASCII avec \\w\n",
    "# il faut mentionner le flag ASCII re.A\n",
    "match = re.compile(\"([\\w ]*)\", flags=re.A).match(sample)\n",
    "match.groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "782e95a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('une entrée\\nsur\\nplusieurs\\nlignes\\n',)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# si on ajoute \\n à la liste des caractères attendus \n",
    "# on obtient bien tout le contenu initial\n",
    "\n",
    "match = re.compile(\"([\\w \\n]*)\", flags=re.UNICODE).match(sample)\n",
    "match.groups()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c74b661c",
   "metadata": {},
   "source": [
    "#### Conclusion\n",
    "La mise au point d'expressions régulières est certes un peu exigeante, et demande pas mal de pratique, mais permet d'écrire en quelques lignes des fonctionnalités très puissantes, c'est un investissement très rentable :)\n",
    "\n",
    "Je vous signale enfin l'existence de **sites web** qui évaluent une expression régulière ***de manière interactive** et qui peuvent rendre la mise au point moins fastidieuse.\n",
    "\n",
    "Je vous signale notamment https://pythex.org/, il en existe beaucoup d'autres.\n",
    "\n",
    "Un élève, qui a eu notamment des soucis avec le `\\w` sur pythex.org (dont, on l'a vu, la signification dépend du locale de la machine hôte) recommande pour sa part https://regex101.com/ :\n",
    "\n",
    "*Ce site est très didactique et lui reconnait les caractères accentués sur un `\\w `sans rajouter de flag (même si cette option est possible).*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "690b57ff",
   "metadata": {},
   "source": [
    "#### Pour en savoir plus\n",
    "Pour ceux qui ont quelques rudiments de la théorie des langages, vous savez qu'on distingue en général\n",
    "- **l'analyse lexicale**, qui découpe le texte en morceaux (qu'on appelle des tokens),\n",
    "- et **l'analyse syntaxique** qui décrit pour simplifier à l'extrême l'ordre dans lequel on peut trouver les tokens.\n",
    "Avec les expression régulières, on adresse le niveau de l'analyse lexicale. Pour l'analyse syntaxique, qui est franchement au delà des objectifs de ce cours, il existe de nombreuses alternatives, parmi lesquelles:\n",
    "- [pyparsing](https://pypi.org/project/pyparsing/\n",
    "- PLY (Python Lex-Yacc)\n",
    "- ANTLR qui est un outil écrit en Java mais qui peut générer des parsers en python,\n",
    "..."
   ]
  }
 ],
 "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}