{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Le BN pour découvrir comment traiter des textes en machine" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## L'objet chaine de caractères :\n", "\n", "

A faire vous même n°1 :

\n", "\n", "- **Tester** les intructions en Python des cellules de code suivantes :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine = \"Joyeux Anniversaire\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Quel est le type de cette variable ? - fonction type ()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "type (une_chaine)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Quelle est la longueur de cette chaîne de caractères ?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "len (une_chaine)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
JoyeuxAnniversaire
0123456789101112131415161718
-19-18-17-16-15-14-13-12-11-10-9-8-7-6-5-4-3-2-1
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Les indices dans la chaîne de caractères" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine[0]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine[7]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "***!!! On commence à compter à l'indice 0 !!!***" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine.index(\"J\") # donne l'indice du premier J majuscule rencontré dans la chaîne" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine.index(\"e\") # donne l'indice du premier e minuscule rencontré dans la chaîne" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine[-1] # la première valeur en commençant par la fin" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine[-19] # == une_chaine[1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine [-len(une_chaine)] # Vous avez compris ?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Quelques manipulations de chaine de caractères :\n", "\n", "### Parcours d'une chaîne de caractères\n", "\n", "Il y a différentes solutions pour parcourrir une chaîne de caractères afin d'accéder à chaque lettre (ou symbole)...\n", "\n", "

A faire vous même n°2 :

\n", "\n", "- **Tester** les scripts Python des cellules de code suivantes ;\n", "- **Proposer** une autre solution utilisant une boucle `for` :" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Avec une boucle while :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine = \"Joyeux Anniversaire\"\n", "i = 0\n", "while i < len (une_chaine):\n", " print (f\"A l'indice {i}, se trouve la lettre {une_chaine[i]} ;\")\n", " i = i + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Avec une boucle for :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine = \"Joyeux Anniversaire\"\n", "i = 0\n", "for lettre in une_chaine :\n", " print (f\"A l'indice {i}, se trouve la lettre {une_chaine[i]} ;\")\n", " i = i + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Autre solution avec une boucle for :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Transformation d'une chaîne de caractères\n", "\n", "Une chaine de caractères est **immutable** (non modifiable).\n", "\n", "Pour la transformer il faudra la réécrire dans une nouvelle variable en y intégrant les modifications.\n", "\n", "

A faire vous même n°3 :

\n", "\n", "- **Vérifier** le caractère immutable d'un `str` en testant les cellules suivantes ;\n", "\n", "- **Ecrire** une fonction qui prend en entrée une chaine de caractère, la recopie (dans une nouvelle variable) en insérant des `§` entre chaque caractère et renvoie cette nouvelle chaine ainsi modifiée." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine = (\"paris\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine[0]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine[0] = \"m\" # ne fonctionne évidemment pas ! " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine = \"m\"\n", "for i in range(1, len(une_chaine)) :\n", " ma_chaine += une_chaine[i]\n", "ma_chaine" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def modifie(chaine) :\n", " # A compléter\n", " \n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tests de comparaison entre chaines de caractères\n", "On peut utiliser les opérateurs de comparaison entre des chaines de caractères dans des structures conditionnelles telles que par exemple :\n", "### Script permettant de distinguer les voyelles, les consonnes et les espaces" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine = \"Joyeux Anniversaire\"\n", "for lettre in une_chaine :\n", " if lettre in \"aeiouyAEIOUY\":\n", " print (lettre, \"est une voyelle\")\n", " elif lettre == \" \":\n", " print (lettre, \"est un espace\")\n", " else :\n", " print (lettre, \"est une consonne\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Script permettant de compter les voyelles, les consonnes et les espaces" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine = \"Joyeux Anniversaire\"\n", "compteur_voyelles = 0\n", "compteur_consonnes = 0\n", "compteur_espaces = 0\n", "for lettre in une_chaine :\n", " if lettre in \"aeiouyAEIOUY\":\n", " print (lettre, \"est une voyelle\")\n", " compteur_voyelles = compteur_voyelles + 1\n", " elif lettre == \" \":\n", " print (lettre, \"est un espace\")\n", " compteur_espaces = compteur_espaces + 1\n", " else :\n", " print (lettre, \"est une consonne\")\n", " compteur_consonnes = compteur_consonnes + 1\n", "print (f\"Il y a, dans cette phrase {compteur_voyelles} voyelle(s), {compteur_consonnes} consonne(s), {compteur_espaces} espace(s)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

A faire vous même n°4 :

\n", "\n", "> On peut choisir un caractère au hasard dans la chaîne, avec le module **random** et la fonction **choice()** :\n", ">```python\n", "from random import choice\n", "choice(ma_chaine)\n", "```\n", "\n", "- Reprendre votre programme de CHI-FOU-MI en utilisant la fonction `choice()` à la place de `randint()`.\n", "\n", " On demandera au joueur de saisir \" p \" pour pierre, \" f \" pour feuille et \" c \" pour ciseau." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from random import choice # on importe seulement la fonction choice !\n", "\n", "# Une nouvelle version du CHI-FOU-MI" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

A faire vous même n°5 :

\n", "\n", "- **Ecrire** une fonction qui prend en entrée une chaine de caractère, met en majuscule le premier caractère s'il s'agit d'une lettre minuscule puis renvoie une nouvelle chaine avec la première lettre en majuscule." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def capitalise(chaine) :\n", " # A compléter\n", " \n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Les méthodes de la classe `str`\n", "\n", "

A faire vous même n°6 :

\n", "\n", "- **Tester** les intructions en Python des cellules de code suivantes :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "help(\"str\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine = \"HELLO\"\n", "print(ma_chaine)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine.lower()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine_2 = \"hello\"\n", "print(ma_chaine_2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine_2.upper()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine_2.capitalize()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine_3 = \" HELLO \"\n", "print(ma_chaine_3)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine_3.strip()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine_3.strip().center(40)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il existe de nombreuse méthode pour les chaînes de caratères.\n", "\n", "|a | b | c | d |\n", "| :-----------: | :----------:|:-----------:|:-----------:|\n", "|x.capitalize | x.isalnum | x.join | x.rsplit |\n", "|x.casefold | x.isalpha | x.ljust | x.rstrip |\n", "|x.center | x.isdecimal | x.lower | x.split|\n", "|x.count | x.isdigit | x.lstrip | x.splitlines |\n", "|x.encode | x.isidentifier | x.maketrans | x.startswith |\n", "|x.endswith | x.islower | x.partition | x.strip |\n", "|x.expandtabs | x.isnumeric | x.replace | x.swapcase|\n", "|x.find | x.isprintable | x.rfind | x.title|\n", "|x.format | x.isspace | x.rindex | x.translate|\n", "|x.format_map | x.istitle | x.rjust | x.upper|\n", "|x.index | x.isupper | x.rpartition | x.zfill|\n", "\n", "\n", "Dans la cellule suivante, placez votre curcseur après le point de `ma_chaine.` puis enfoncer la touche `Tab`, vous devez voir toutes les méthodes possibles..." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ma_chaine." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(ma_chaine.count('e')) # on indique le nombre de fois où le caractère e apparaît dans la chaîne\n", "print(ma_chaine.find('n')) # on cherche l'indice de la première occurence du caractère v" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

A faire vous même n°7 :

\n", "\n", "- **Reprendre** le \"A faire vous même n°5\" en utilisant une méthode de la class `str`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

A faire vous même n°8 :

\n", "\n", "- **Tester** le script Python de la cellule de code suivante pour le comprendre ;\n", "- **Commenter** chaque ligne du code pour expliquer son fonctionnement." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def nouveau(message):\n", " \"\"\" Spécifications:\n", " #à compléter\n", " \n", " \"\"\"\n", " message = message.upper()\n", " m = \"\"\n", " for lettre in message:\n", " d = ord(lettre)\n", " d = d + 2\n", " m = m + chr(d)\n", " return m\n", "\n", "message = input(\"Entrez un message\")\n", "if message :\n", " nouveau_message = nouveau(message)\n", " print(nouveau_message)\n", " print(message)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Le slicing\n", "\n", "Le **_slicing_** est une méthode applicable à tous les objets de type liste ordonnée (liste ou chaîne de caractère mais pas aux dictionnaires). ll s'agit d'un \"découpage en tranches\" des éléments d'une liste de manière à récupérer des objets respectant cette découpe.\n", "\n", "Pour cela, nous devrons spécifier l'indice de l'élément de départ, l'indice de l'élément d'arrivée (qui ne sera pas compris dans la plage) et le pas de déplacement. Pour une variable v donnée, l'écriture se fera en utilisant la notation entre crochets et en séparant chacun des paramètres par le caractère deux-points: **_v[début:fin:pas]_**. Cette écriture peut se traduire par : les caractères de la variable **_v_** depuis l'indice **_début_** jusqu'à l'indice **_fin_** non compris avec un déplacement de **_pas_** caractère(s). \n", "\n", "Pour bien comprendre le fonctionnement du slicing, nous commencerons par l'appliquer aux chaînes de caractères avant de voir les listes et les tuples." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine [1:5] # de l'indice 1 inclus à l'indice 5 exclus" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine [2:] # de l'indice 2 inclus jusqu'à la fin" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine [:-1] # du début à l'indice -1 exclus" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine [::-1] # en partant de la fin et à l'envers vers le début" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "une_chaine [::2] # afficher tout par pas de 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "

Application 1 : Le chiffre de César

\n", "\n", "Le chiffre de César est une méthode de chiffrement consistant à décaler les lettres de l'alphabet de quelques crans.\n", "\n", "Par exemple, si on décale les lettres de 3 rangs (comme le faisait Jules César)\n", "\n", "\"ChiffreDeCesar.jpg\"\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "

L'objectif :

\n", "\n", "- Écrire un programme Python qui implémente le chiffre de César en utilisant les fonctions ord() et chr().\n", "\n", "- On doit pouvoir choisir le décalage des lettres entre 1 et 25.\n", "\n", "- L'entrée sera un texte quelconque sans accents et sans ponctuation ; par contre, le texte d'entrée sera composé de majuscules et de minuscules.\n", "\n", "- Le texte de sortie sera écrit tout en majuscules.\n", "\n", "- Les espaces du texte d'entrée se retrouveront aux mêmes endroits dans le texte chiffré.\n", "\n", "- Faites en sorte que l'on puisse crypter, mais aussi décrypter un message.\n", " \n", "
\n", "\n", "\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "

Un peu d'aide :

\n", "\n", "\n", "\n", "**La notion de \"modulo\"**\n", "\n", "Considérons les nombres de $0$ à $25$, il y en a $26$.\n", "\n", "Lorsqu'on divise un nombre par 26, les restes possibles sont compris entre $0$ et $25$.\n", "\n", "**Par exemple :**\n", "- Dans la division Euclidienne de $17$ par $26$ le reste est $17$ ;\n", "- Dans la division Euclidienne de $28$ par $26$ le reste est $ 2$.\n", "\n", "**En Python : l'opération 28 % 26 donne 2 comme résultat**\n", "\n", "Sachant que les lettres majuscules sont sur la plage 65 (pour A) à 90 (pour Z).\n", "\n", "Pour ramener les lettres de l'alphabet sur la plage $[0 ,1,2,...,25]$, il suffit de retirer $65$ au code ASCII de la lettre.\n", "\n", "Cette opération permet de considérer que les nombres associés aux lettres de l'alphabet vont de $0$ à $25$.\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "

Appliquons cela au chiffrement de César :

\n", "\n", "
\n", " \n", "**Comment se code la lettre $C$ :**\n", "\n", "- Le code ASCII de $C$ est $67$ ;\n", "- On retire $65$, on trouve $2$ ;\n", "- On applique le décalage de César : on trouve $5$ ;\n", "- On calcule le reste dans la division Euclidienne de $5$ par $26$ : On trouve $5$ ;\n", "- On ajoute $65$, on trouve $70$ ;\n", "- On transforme ce code ASCII en lettre : $chr(70)$, on trouve $F$.\n", "\n", "
\n", " \n", "**Comment se code la lettre $Y$ :**\n", "\n", "- Le code ASCII de $Y$ est $89$ ;\n", "- On retire $65$, on trouve $24$ ;\n", "- On applique le décalage de César : on trouve $27$ ;\n", "- On calcule le reste dans la division Euclidienne de $27$ par $26$ : On trouve $1$ ;\n", "- On ajoute $65$, on trouve $66$ ;\n", "- On transforme ce code ASCII en lettre : $chr(66)$, on trouve $B$.\n", "
\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Écrire votre code ici" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "****\n", "## Références aux programmes :\n", "\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Compétences développéesCapacités attenduesCommentaires
Représentation d’un texte en machine.

Exemples des encodages ASCII, ISO-8859-1, Unicode		Identifier l’intérêt des différents systèmes d’encodage.

Convertir un fichier texte dans différents formats d’encodage.		Aucune connaissance précise des normes d’encodage n’est exigible.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"Licence
Ce document est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International.\n", "\n", "Pour toute question, suggestion ou commentaire : eric.madec@ecmorlaix.fr" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3.10.1 64-bit", "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.1" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false }, "vscode": { "interpreter": { "hash": "c813da0d88532624e95401f841607d640ef6d724b81c00ab0d0885f617a921c3" } } }, "nbformat": 4, "nbformat_minor": 4 }