2015-10-19 - TD9 - Les chaînes de caractères.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Quelques rappels sur les chaînes de caractères**\n",
    "\n",
    "Les chaînes de caractères s'écrivent entre guillemets (*quotes* en anglais), simples ou doubles. Elles peuvent être comparées entre elles avec les opérateurs classiques de comparaison :  ==, !=, <, <=, >, >=.\n",
    "\n",
    "Attention : l'ordre des chaînes ressemble à l'ordre alphabétique, mais comporte des différences. Par exemple, les majuscules sont avant les minuscules ; les caractères accentués sont \"en dehors\" de l'alphabet.\n",
    "\n",
    "La concaténation (ou assemblage) de deux chaînes s'effecture grâce à l'opérateur +. \n",
    "\n",
    "La fonction len permet d'obtenir le nombre de caractères (longueur) d'une chaîne.\n",
    "\n",
    "Dans une chaîne, chaque caractère a un indice. Le premier caractère se situe à l'indice 0, le second à l'indice 1, etc. Pour accéder au caractère à l'indice i, dans une chaîne ch, on utilise la notation entre crochets ch[i].\n",
    "\n",
    "Les chaînes sont des objets immutables : on ne modifie jamais l'intérieur d'une chaîne, on en crée une autre. \n",
    "\n",
    "Le code suivant illustre ces propos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "Ceci est un textececi est un autre texte\n",
      "17\n",
      "23\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "txt1 = \"Ceci est un texte\"\n",
    "txt2 = 'ceci est un autre texte'\n",
    "print(\"A\" < txt1)\n",
    "print(\"B\" < txt2)\n",
    "print(\"A\" >\"a\")\n",
    "print(\"Z\" < \"a\"  and  \"z\" < \"é\")\n",
    "print(txt1 + txt2)\n",
    "print(len(txt1))\n",
    "print(len(txt2))\n",
    "print(txt1[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercices** \n",
    "\n",
    "1. Calculer le nombre d'occurrences d'un caractère dans une chaîne, de deux façons différentes. \n",
    "2. Calculer le nombre de caractères en minuscules dans une chaîne. \n",
    "3. Déterminer l'indice de la première occurrence d'un caractère dans une chaîne. \n",
    "4. Déterminier l'indice maximum d'un caractère dans une chaîne, c'est-à-dire de sa dernière occurrence. \n",
    "5. Inverser une chaîne de caractères.\n",
    "6. Calculer le nombre de mots dans une chaîne de caractères. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Corrigé de l'exo 1 avec un for\n",
    "def nbEfor(chaine):\n",
    "    '''\n",
    "    :entree chaine: une chaine de caractères dans laquelle on va compter le nb de e\n",
    "    :sortie compteur: le nb de e dans la chaine\n",
    "    '''\n",
    "    compteur = 0\n",
    "    for i in range (len(chaine)):\n",
    "        if chaine[i] == 'e':\n",
    "            compteur +=1\n",
    "    return compteur\n",
    "nbEfor(\"Bonjour comment allez vous ce matin ?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice maison (facile) :** Modifiez le code précédent de sorte à ce que l'on passe le caractère à rechercher en paramètre... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Corrigé de l'exo 1 avec un while\n",
    "def nbEwhile(chaine):\n",
    "    '''\n",
    "    :entree chaine: une chaine de caractères dans laquelle on va compter le nb de e\n",
    "    :sortie compteur: le nb de e dans la chaine\n",
    "    '''\n",
    "    compteur = 0\n",
    "    i = 0\n",
    "    while (i < len(chaine)):\n",
    "        if chaine[i] == 'e':\n",
    "            compteur +=1\n",
    "        i +=1\n",
    "    return compteur\n",
    "nbEwhile(\"Je veux un café !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exercice : qu'est-ce qui ne fonctionne pas dans cet algorithme (supposé répondre à l'exo 1) ? \n",
    "def nbEBis(chaine):\n",
    "    compteur = 0\n",
    "    for lettre in chaine:\n",
    "        if lettre == 'e':\n",
    "            compteur +=1\n",
    "        return compteur\n",
    "nbEBis(\"Moi ça roule !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice maison :** identifiez le problème du code précédent et corrigez-le."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque sur le code ci-dessous : la recherche d'un caractère dans une chaîne est rendue très facile en Python... mais nous faisons de l'algo ici... nous cherchons donc des solutions génériques et transposables à d'autres langages de programmation. C'est pourquoi nous allons éviter de prendre ce genre de raccourci !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le caractère est dans la chaîne\n",
      "Le caractère n'est pas dans la chaîne...\n"
     ]
    }
   ],
   "source": [
    "if \"c\" in \"abc\":\n",
    "    print(\"Le caractère est dans la chaîne\")\n",
    "    \n",
    "if \"d\" in \"abc\":\n",
    "    print(\"Le caractère est dans la chaîne\")\n",
    "else:\n",
    "    print(\"Le caractère n'est pas dans la chaîne...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Corrigé de l'exo 2\n",
    "def compteurMinuscules(chaine):\n",
    "    '''\n",
    "    :entree chaine: une chaîne de caractères\n",
    "    :sortie nombre: le nombre de minuscules dans la chaîne\n",
    "    '''\n",
    "    nombre = 0\n",
    "    for i in range(len(chaine)):\n",
    "        if chaine[i] <= \"z\" and chaine[i] >= \"a\":\n",
    "            nombre +=1\n",
    "    return nombre\n",
    "\n",
    "compteurMinuscules(\"J'écris TouT PeTIT i\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# Corrigé de l'exo 3\n",
    "\n",
    "def premiereOccurence(chaine, car):\n",
    "    \"\"\"\n",
    "    :entree chaine: une chaine de caractère\n",
    "    :entree car: le caractère recherché\n",
    "    :sortie occu: la position de la premiere occurence du caractere\n",
    "    :post-cond: occu = -1 si le caractere n'est pas dans la chaîne\n",
    "    \"\"\"\n",
    "    \n",
    "    i=0\n",
    "    occu = -1\n",
    "    while(occu == -1 and i < len(chaine)):\n",
    "        if(chaine[i] == car):\n",
    "            occu = i\n",
    "        i +=1\n",
    "    return occu\n",
    "\n",
    "print(premiereOccurence(\"Bonjour\", \"j\"))\n",
    "print(premiereOccurence(\"Bonjour\", \"e\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "10\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# Corrigé de l'exo 4\n",
    "def derniereOccurence(chaine, car):\n",
    "    '''\n",
    "    :entree chaine: une chaîne de caractères\n",
    "    :entre car: le caractère recherché\n",
    "    :sortie occu: l'indice de la dernière apparition du caractère dans la chaîne \n",
    "    :post-cond: occu = -1 si le caractère n'est pas présent...\n",
    "    '''\n",
    "    retour =-1\n",
    "    for pos in range (len(chaine)):\n",
    "        if chaine[pos] == car:\n",
    "            retour = pos\n",
    "    return retour\n",
    "    \n",
    "print(derniereOccurence(\"Hello world\", \"l\"))\n",
    "print(derniereOccurence(\"Hello world\", \"d\"))\n",
    "print(derniereOccurence(\"Hello world\", \"f\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice maison :** Réécrivez cette méthode de recherche de la dernière occurrence en parcourant la liste à partir de la fin. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "suov uocuoc\n"
     ]
    }
   ],
   "source": [
    "#Corrigé de l'exercice 5 \n",
    "def miroir(chaine):\n",
    "    '''\n",
    "    :entre la chaine de caractère\n",
    "    :sortie la chaine de caractere avec les caracteres inversés\n",
    "    '''\n",
    "    stri=\"\"\n",
    "    for i in range(0,len(chaine)):\n",
    "        stri+=chaine[len(chaine)-i-1]\n",
    "        \n",
    "    return stri\n",
    "\n",
    "print(miroir(\"coucou vous\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice maison :** Pour chaque algorithme vu dans ce TD, donner la complexité moyenne et la complexité dans le pire des cas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Corrigé de l'exercice 6\n",
    "ch=str(input(\"Entrez votre caractere\"))\n",
    "\n",
    "def mots (ch):\n",
    "    '''\n",
    "    :entree:une chaine de caracteres\n",
    "    :sortie: nbr de mots\n",
    "    '''\n",
    "    mot=int()\n",
    "    for i in range (0,len(ch)-1):\n",
    "        if ch[i]!=' ' and ch[i+1]==' ':\n",
    "            mot+=1\n",
    "    return (mot+1)\n",
    "print (mots(ch))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice maison :** Cet algo est presque parfait... sauf quand la chaîne de caractères se termine par des espaces.\n",
    "    \n",
    "Pourquoi ?\n",
    "\n",
    "Vous en profiterez pour écrire la spécification de ce problème. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}