{ "cells": [ { "cell_type": "markdown", "id": "e4d596f0", "metadata": {}, "source": [ "# 01 — Bases Python\n", "\n", "**Remise à niveau Python — Master Langue et Informatique**" ] }, { "cell_type": "markdown", "id": "cbae44ab", "metadata": {}, "source": [ "Les termes en saillance devraient être définis dans Vocabulaire.md (en faire un PDF ?)" ] }, { "cell_type": "markdown", "id": "87f39140", "metadata": {}, "source": [ "## 1. Types et transtypage\n", "\n", "On a besoin de distinguer des ``types`` de ``variables`` selon les opérations qu'elles permettent/autorisent.\n", "\n", "On va démarrer avec les entiers (``int`` pour integer) et les chaînes de caractères (``str`` pour string, qui sont entre guillemets).\n", "\n", "On va les afficher et vérifier leur type" ] }, { "cell_type": "code", "execution_count": null, "id": "170aa340-2bd6-45df-8f20-54228d5e2344", "metadata": {}, "outputs": [], "source": [ "entier = 23\n", "chaine = \"toto\"\n", "print(entier)\n", "print(type(entier))\n", "print(chaine)\n", "print(type(chaine))" ] }, { "cell_type": "markdown", "id": "ed7b951e", "metadata": {}, "source": [ "Les types détermine les ``opérations`` (mathématiques ou non que l'on peut faire)\n", "\n", "Imaginons un candidat à la présidentielle qui aura 38 en 2027 on voudrait calculer son âge à la fin de son mandat.\n", "\n", "On crée 2 variables avec l'âge et la durée du mandat et on regarde ce que ça donne.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "0c543f23", "metadata": {}, "outputs": [], "source": [ "#testez cette cellule\n", "age_candidat = 38\n", "duree_mandat = \"5\"\n", "print(age_candidat+duree_mandat)" ] }, { "cell_type": "markdown", "id": "16ebf43f-ba7b-443f-a755-b184918349cd", "metadata": {}, "source": [ " Si l'on a des chaînes de caractères (``string``), on ne peut pas effectuer les mêmes opérations qu'avec des ``integer``, le type détermine donc les opérations possibles et guide l'interprétation des données.\n", "\n", " On va donc réaliser un ``transtypage`` grâce à int()" ] }, { "cell_type": "code", "execution_count": null, "id": "f613d079-5615-4893-a972-50a0703b7f60", "metadata": {}, "outputs": [], "source": [ "age_candidat = 38\n", "duree_mandat = \"5\"\n", "print(age_candidat+int(duree_mandat))" ] }, { "cell_type": "markdown", "id": "08ef371c-4a96-41f6-8433-3898d8558044", "metadata": {}, "source": [ "Inversement si on transtype l'entier pour le transformer en ``string`` (avec str) l'``opérateur`` + permet la ``concaténation``" ] }, { "cell_type": "code", "execution_count": null, "id": "720ba340", "metadata": {}, "outputs": [], "source": [ "print(str(age_candidat)+duree_mandat)" ] }, { "cell_type": "markdown", "id": "588400d8", "metadata": {}, "source": [ "
\n", "\n", "On a donc \"collé\" les deux chaînes.\n", "\n", "Essayez maintenant d'afficher la phrase \"j'ai 23 ans\" à partir des variables fournies ci-dessous en réalisant la bonne série d'``instructions``\n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "538ced1f", "metadata": {}, "outputs": [], "source": [ "debut_phrase = \"j'ai\"\n", "age = 23\n", "fin_phrase = \"ans\"\n", "\n", "#Corrigez l'instruction ci-dessous pour la faire fonctionner :\n", "print(debut_phrase + age+fin_phrase)" ] }, { "cell_type": "markdown", "id": "f4a510cb-de91-4511-88b7-2968e6555f32", "metadata": {}, "source": [ "Enfin, on peut connaître la taille d'une chaîne avec ``len()`` mais ça ne marche pas avec un entier :" ] }, { "cell_type": "code", "execution_count": null, "id": "ca7f7eef-c2c4-4b5d-ae39-8160bfb98291", "metadata": {}, "outputs": [], "source": [ "debut_phrase = \"j'ai\"\n", "age = 23\n", "print(len(debut_phrase))\n", "print(len(age))" ] }, { "cell_type": "markdown", "id": "ad2d9731", "metadata": {}, "source": [ "## 2. Chaînes : normaliser et découper" ] }, { "cell_type": "markdown", "id": "172ea11a", "metadata": {}, "source": [ "On a besoin de découper nos chaînes (nos textes) souvent en mots.\n", "\n", "POur cela, la fonction ``split`` donne une bonne approximation " ] }, { "cell_type": "code", "execution_count": null, "id": "e513bc87", "metadata": {}, "outputs": [], "source": [ "reponse = \" Le TAL analyse des textes. \"\n", "print(reponse.split())#découpe selon les espaces\n", "minuscule = reponse.lower()#On passe en minuscules\n", "print(minuscule)\n", "print(minuscule.split())" ] }, { "cell_type": "markdown", "id": "bfb35971-0c6c-4e1b-8958-e29db823b65d", "metadata": {}, "source": [ "On peut chercher des sous chaînes dans une chaîne avec ``count()``" ] }, { "cell_type": "code", "execution_count": null, "id": "99ca797e", "metadata": {}, "outputs": [], "source": [ "# Exemple : comparer une recherche sensible ou non à la casse\n", "texte = \"Corpus, corpus et CORPUS ne sont pas trois notions différentes.\"\n", "print(\"Comptage exact :\", texte.count(\"corpus\"))\n", "print(\"Comptage normalisé :\", texte.lower().count(\"corpus\"))#notez qu'ici on enchaîne lower et count" ] }, { "cell_type": "markdown", "id": "25df0e0b", "metadata": {}, "source": [ "
\n", "\n", "- Affichez une version en minuscules de la variable texte puis sa taille en caractères.\n", "- Affichez ensuite sa taille en mots (ou tokens)." ] }, { "cell_type": "code", "execution_count": null, "id": "b62b21cc", "metadata": {}, "outputs": [], "source": [ "texte = \" Données Textuelles et Python \"\n", "# à vous de jouer" ] }, { "cell_type": "code", "execution_count": null, "id": "3b22b565-6b1d-4793-8464-aafc9ec33f01", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "b179a464", "metadata": {}, "source": [ "## 3. Une première structure de données : la liste\n", "Quand on a fait un split() ce que l'on obtient est une suite de tokens séparés par des virgules et entourée par des crochets.\n", "\n", "C'est une ``liste`` : " ] }, { "cell_type": "code", "execution_count": null, "id": "5eb69209-e17c-4d22-8310-05c510aa3652", "metadata": {}, "outputs": [], "source": [ "texte = \"Corpus, corpus et CORPUS ne sont pas trois notions différentes.\"\n", "tokens = texte.split()\n", "print(tokens)\n", "print(type(tokens))\n", "print(len(tokens))" ] }, { "cell_type": "markdown", "id": "52944281-3ae8-4a47-a668-22de8ec74f0f", "metadata": {}, "source": [ "Nous reviendrons plus tard sur les structures de données, mais retenez qu'elles servent à stocker plusieurs variables voire d'autres structures de données ..." ] }, { "cell_type": "markdown", "id": "805b0fca-f2f6-4539-8127-9f47cbf1afc8", "metadata": {}, "source": [ "## 4. Booléens et conditions" ] }, { "cell_type": "markdown", "id": "65841b94", "metadata": {}, "source": [ "Une condition transforme un critère de recherche en décision. Elle fait appel à un troisième type de données : les ``booléens`` qui prennent la valeur Vrai (True) ou Faux (False)\n", "\n", "On va utiliser des ``if`` pour vérifier ces conditions. On peut ajouter ``else`` pour faire un \"sinon\".\n", "\n", "Modifiez les valeurs de longueur et largeur ci-dessous pour comprendre le comportement de if et de if +else." ] }, { "cell_type": "code", "execution_count": null, "id": "1ebdcafa", "metadata": {}, "outputs": [], "source": [ "longueur = 145\n", "largeur = 30\n", "if longueur > 100:\n", " print(\"c'est long\") \n", "\n", "if largeur < 20:\n", " print(\"c'est étroit\") \n", "else:\n", " print(\"c'est large\")" ] }, { "cell_type": "markdown", "id": "c371850b-539b-468b-a0e3-c78e09b29dee", "metadata": {}, "source": [ "
\n", "\n", "On peut s'en servir aussi pour des chaînes de caractères.\n", "\n", "On va rajouter ci-dessous dans notre vocaulaire ``elif`` qui permet de faire un \"sinon si\"\n", "\n", "Modifiez la variable texte pour réussir à avoir succesivement les 3 messages affichés\n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "b6659ac0", "metadata": {}, "outputs": [], "source": [ "texte = \"Une réponse suffisamment développée pour l'analyse, c'est pas mal\"\n", "\n", "if \".\" in texte:#si on a un point\n", " print(\"la phrase a bien un point\")\n", "elif \",\" in texte:#sinon si on a une virgule\n", " print(\"on a une virgule, pas mal\")\n", "else:#si ni point ni virgule\n", " print(\"Attention, utilisez de la ponctuation !\")\n", "\n", " " ] }, { "cell_type": "markdown", "id": "42f9714b", "metadata": {}, "source": [ "
\n", "Pour chacune des variables reponse1, reponse2, reponse 3 : classez une réponse : **trop courte** si elle ne contient qu'un mot, **courte** si elle contient plus de 1 mot mais moins de 5, **longue** sinon.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "4247d22b", "metadata": {}, "outputs": [], "source": [ "reponse1 = \"Python facilite le traitement des corpus\"\n", "reponse2 = \"Python\"\n", "reponse3 = \"Python aime les corpus\"\n", "\n", "# utilisez if, elif et else pour" ] }, { "cell_type": "markdown", "id": "7cd0573b", "metadata": {}, "source": [ "## 4. Boucles : filtrer et accumuler" ] }, { "cell_type": "markdown", "id": "6f4ba27b", "metadata": {}, "source": [ "Si vous avez répondu à la question préécdente en copiant collant le code, vous imaginez bien que l'on devrait pouvoir mieux faire car c'set pénible.\n", "\n", "L'informatique c'est la science des fainéants et la solution ici pour se simplifier la vie ce sont les boucles\n", "\n", "POurquoi est-ce particulièrement utile pour les données textuelles ? Car, une opération correcte sur un texte n'est pas encore une analyse de corpus. La boucle permet d'appliquer exactement la même procédure à plusieurs données, qu'il y en ait une, trois ou plusieurs milliers.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "123f745d", "metadata": {}, "outputs": [], "source": [ "textes = [\"un texte court\", \"toto\", \"un autre document assez exploitable\"]# des crochets, des virgules c'est une liste !\n", "for texte in textes:\n", " print(texte)\n", " if len(texte.split())<=1:\n", " print(\"-->très court\")\n", " elif len(texte.split())<5:\n", " print(\"-->court\")\n", " else:\n", " print(\"-->long\")\n" ] }, { "cell_type": "code", "execution_count": null, "id": "f2971e28", "metadata": {}, "outputs": [], "source": [ "# Autre exemple : calculer une longueur pour chaque document du corpus\n", "corpus = [\"Un premier texte\", \"Une réponse beaucoup plus développée\", \"Corpus court\"]\n", "for texte in corpus:\n", " print(len(texte.split()), \"mots\")" ] }, { "cell_type": "markdown", "id": "2f701d4f", "metadata": {}, "source": [ "
\n", "TODO: Parcourez `reponses` et affichez les réponses d’au moins 4 mots.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "130710f0", "metadata": {}, "outputs": [], "source": [ "reponses = [\"Très utile\", \"\", \"Le cours était très progressif\", \"À revoir\"]\n", "# TODO: afficher les réponses contenant 4 mots ou plus" ] }, { "cell_type": "markdown", "id": "1db0305e-943c-484b-aefb-4c2076d4210b", "metadata": {}, "source": [ "NB : On peut aussi avoir besoin de garder des éléments pour s'en servir plus tard. Une façon de faire est de les ranger dans une structure de données. C'est le retour de la ``liste`` avec cette fois la méthode ``append`` pour en faire un ``accumulateur``" ] }, { "cell_type": "code", "execution_count": null, "id": "ca6ccea0-58e2-4529-86d9-532ee8c48dd6", "metadata": {}, "outputs": [], "source": [ "messages = [\"Bonjour, vous allez bien? Une baguette SVP\", \"Une baguette et vite\", \"Une baguette\"]\n", "liste_messages_polis = []#une liste vide pour faire un accumulateur\n", "print(liste_messages_polis)\n", "for message in messages:\n", " if \"Bonjour\" in message:\n", " liste_messages_polis.append(message)#L'accumulation\n", "print(liste_messages_polis)" ] }, { "cell_type": "markdown", "id": "b131c5ee", "metadata": {}, "source": [ "## 5. Comprendre une erreur" ] }, { "cell_type": "markdown", "id": "83c09a17", "metadata": {}, "source": [ "
\n", " Vous avez vu à plusieurs reprises des erreurs dans le code\n", "Pourquoi est-ce utile ?
Dans un corpus, une seule métadonnée mal formée peut arrêter toute une boucle. Comprendre le message d'erreur permet de distinguer une faute de syntaxe, un mauvais type et un nom de variable erroné, plutôt que de modifier le code au hasard.\n", "
" ] }, { "cell_type": "markdown", "id": "7b1bd681", "metadata": {}, "source": [ "
\n", "À vous de jouer
Corrigez les trois erreurs : type incompatible, nom de variable et indentation.\n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "1d2d4625", "metadata": {}, "outputs": [], "source": [ "ages = [\"20\", \"22\", \"24\"]\n", "total = 0\n", "for age in ages:\n", "total += age\n", "print(totale / len(ages))" ] }, { "cell_type": "markdown", "id": "0455194e-f88c-4360-8fa7-26d78b611627", "metadata": {}, "source": [ "## 6. Comprendre les différences structures de données\n", "\n", "En plus des listes, ensembles et dictionnaires, on va parler des ``tuples`` (matérialisés par des parenthèses):\n", "\n", "- ils sont rangés dans un certain ordre (comme les listes)\n", "- mais ne permettent pas de modification interne (``non mutables``)\n", "- par contre ils peuvent servir de clés à un dictionnaire (au contraire des listes)\n", "\n", "Essayez de comprendre ce que font les cellules ci-dessous (sans les modifier)" ] }, { "cell_type": "code", "execution_count": null, "id": "0c6718e3-07e6-4bf2-9dc6-0824738cfbbb", "metadata": {}, "outputs": [], "source": [ "toto = [(\"Gaël\", \"prof\"), (\"Zine\", \"étudiant\")]\n", "print(type(toto))\n", "print(type(toto[0]))\n", "print(toto)\n", "toto[0] = (\"Sophie\", \"prof\")\n", "print(toto)\n", "toto[0][1]=\"Prof\"" ] }, { "cell_type": "code", "execution_count": null, "id": "b469a1a6-9f58-4e91-a82f-bf8e3c0ef1f4", "metadata": {}, "outputs": [], "source": [ "titi = [list(x) for x in toto]\n", "print(type(titi))\n", "print(type(titi[0]))\n", "print(titi)\n", "titi[0][1]=\"Prof\"\n", "print(titi)" ] }, { "cell_type": "code", "execution_count": null, "id": "9c710bf7-eec9-4397-aa1a-f07607694040", "metadata": {}, "outputs": [], "source": [ "dico = {}\n", "print(dico)\n", "dico[toto[0]] = \"Remise à Niveau en programmation\"\n", "print(dico)\n", "dico[tito[i]] = \"Remise à Niveau en programmation\"\n", "print(dico)" ] }, { "cell_type": "markdown", "id": "e8f0c7f5", "metadata": {}, "source": [ "## Validation du notebook" ] }, { "cell_type": "code", "execution_count": null, "id": "d5660f8c", "metadata": {}, "outputs": [], "source": [ "corpus = [\"un deux\", \"trois quatre cinq\"]\n", "longueurs = []\n", "# TODO Écrivez une boucle qui calcule les longueurs en mots des textes et les accumule dans \"longueurs\"\n", "\n", "\n", "assert longueurs == [2, 3]" ] }, { "cell_type": "markdown", "id": "8c4d9ad8", "metadata": {}, "source": [ "Question : Comprenez vous ce que fait assert ?" ] } ], "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.9" } }, "nbformat": 4, "nbformat_minor": 5 }