{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", " \n", "\n", "
\n", "

- TD5 -

\n", " 		\n", "

UFR de sociologie et d'informatique pour les sciences humaines

\n", "

Programmation en Python

\n", "
\n", "\n", "-----" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Gestion des fichiers et dossiers

\n", "\n", "

Préparation du travail

\n", "\n", "Selon le système d'exploitation de l'ordinateur sur lequel vous travaillez, créez dans le dossier \"Documents\" (ou autre, mais accessible facilement par Jupyter Notebook) un dossier de nom votre numéro d'étudiant (Nautilus ou Fichiers ou Dolphin : Linux, Finder : MacOS, Explorateur de fichiers : Windows)\n", "\n", "> exemple à adapter : Documents > 12345678\n", "\n", "Dans les propriétés de ce nouveau dossier, récupérez son chemin complet et notez-le quelque part. (Attention : avec Windows les noms de certains dossiers ne sont pas les noms réels, par exemple le dossier \"utilisateurs\" visible dans l'explorateur n'existe pas, il se nomme \"users\")\n", "\n", "Nous allons importer une bibliothèque qui gère les fichiers et dossiers simplement. Cette bibliothèque est contenu de façon native dan **Python**. Elle se nomme **os**.\n", "\n", "\n", "

Importation du module os

\n", "\n", "Exécutez la cellule ci-dessous pour cela. Attention, toutes les fonctions disponibles devront être préfixées par le nom **os** suivi d'un point." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os # importation du module (ou bibliothèque) relatif à la gestion des fichiers et dossiers" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ce module renferme plusieurs fonctionnalités bien utiles. Au lancement de Jupyter Notebook, **Python** travaille par défaut dans un répertoire dit \"répertoire de travail\" (workspace).\n", "\n", "

Quelques fonctionnalités

\n", "\n", "Pour connaître le **répertoire de travail** actuel... exécutez" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(os.getcwd()) # get=obtenir, c=courant, w=travail (work), d=dossier (directory)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vous allez **changer ce workspace**, c'est-à-dire positionnez le dossier par défaut sur le dossier préalablement créé (celui qui porte votre numéro d'étudiant).\n", "\n", "Exemple (à adapter) donné ici avec un utilisateur qui s'appelle \"domo\" et un étudiant qui a comme numéro 12345678, sous *Windows* (changer en fonction de votre numéro d'étudiant)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.chdir(\"C:/Users/domo/Documents/12345678\") # chdir = changer de directory" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sous *Linux* ou *MacOS*, on pourrait avoir (changer en fonction de votre numéro d'étudiant)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.chdir(\"/home/domo/Documents/12345678\") # chdir = changer de directory" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pour s'assurer que le changement a bien eu lieu, exécutez à nouveau la ligne suivante" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(os.getcwd())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Avec la commande *chdir()*, on pouvait spécifier aussi un chemin relatif.\n", "\n", "Supposons que le répertoire de travail était\n", "\n", "\"/home/domo/applis\"\n", "\n", "et que vous vouliez le passer en \n", "\n", "\"/home/domo/documents/12345678/work\"\n", "\n", "il suffisait de taper et d'excécuter la commande suivante\n", "\n", "```python\n", " os.chdir(\"../documents/12345678/work\") # chemin relatif \n", "```\n", "\n", "où les 2 points **..** signifient que l'on remonte d'un répertoire dans l'arborescence avant de redescendre sur \"/documents/...\"\n", "\n", "Pour **tester l'existence d'un fichier ou d'un dossier**, il suffit d'exécutez la commande suivante qui renvoie un booléen." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(os.path.exists(\"c:/Users/domo/Documents/12345678\")) # teste l'existence du dossier 12345678\n", "print(os.path.exists(\"coucou.txt\")) # teste l'existence du fichier coucou.txt dans le répertoire de travail" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Création de dossiers, renommer, lister, déplacer et supprimer des fichiers

\n", "\n", "Vous allez d'abord télécharger à partir de Moodle, dans le dossier \"Ressources TD5\", les 5 fichiers de nom *t1.txt* à *t5.txt* et les placer dans votre répertoire de travail (qui devrait être le répertoire 12345678, numéro à adapter à votre propre numéro).\n", "\n", "Vous allez commencer par créer dans le répertoire courant, un répertoire nommé *dos1*. Exécutez la cellule suivante :\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.mkdir(\"dos1\") # créé le dossier " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> 12345678 > dos1\n", "\n", "Vous allez, toujours dans le répertoire courant, **créer cette fois plusieurs dossiers** simultanément. Exécutez la cellule suivante :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.makedirs(\"./dos2/dos3/dos4\") # le point . fait référence au répertoire courant (l'endroit où vous êtes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vous obtenez donc maintenant l'arborescence suivante :\n", "\n", "12345678 > | - - - dos1\n", "\n", " > |--- dos2 > dos3 > dos4\n", "\n", "Vérifiez dans votre gestionnaire de fichiers que vous avez bien cela, et donc que vous avez bien créé ces dossiers. Vous remarquez que le dossier *dos4* est créé avec tous les dossiers intermédiaires.\n", "\n", "Vous allez maintenant **renommer un fichier**. Dans votre répertoire de travail, vous avez placé 5 fichiers de *t1.txt* à *t5.txt*. Renommez le fichier *t1.txt* en *foo.txt*. Exécutez la cellule suivante" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.rename(\"t1.txt\", \"foo.txt\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vérifiez au besoin, dans votre gestionnaire de fichier, que le changement de nom a bien eu lieu. la méthode *rename()* du module **os** permet aussi de **déplacer un fichier**, avec ou sans renommage.\n", "\n", "Exécutez la cellule suivante, qui déplace le fichier *foo.txt* dans le dossier *dos2*, et le renomme en plus en *t1.txt*\n", "\n", "Vérifiez au besoin, dans votre gestionnaire de fichier, que le déplacment et le changement de nom a bien eu lieu." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.rename(\"foo.txt\", \"./dos2/t1.txt\") # le point . fait référence au dossier courant" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "La méthode *listdir()* du module **os** permet d'obtenir la **liste Python de tous les dossiers et fichiers** d'un répertoire donné en argument, sinon du répertoire courant.\n", "\n", "Exécutez la cellule suivante" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.listdir()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pour **supprimer un fichier**, on utilise la méthode *remove()* avec comme argument, le nom et le chemin qui mène au fichier.\n", "\n", "Supprimez le fichier *t5.txt*. Pour cela exécutez la cellule suivante et vérifier dans votre gestionnaire de fichier la suppression. Observez la syntaxe." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.remove(\"./t5.txt\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pour **supprimer un dossier**, on peut utiliser la méthode *rmdir()* mais il faut que le dossier soit préalablement vidé de ses fichiers. Pour cela vous allez créer un dossier (vide) et ensuite le supprimer.\n", "\n", "Exécutez la cellule suivante pour créer le dossier (observez dans votre gestionnaire de fichiers)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.mkdir(\"poub\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "et ensuite supprimez ce répertoire" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "os.rmdir(\"poub\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il existe de nombreuses autres méthodes visibles à cette adresse (version 3.9) [Module os](https://docs.python.org/fr/3/library/os.html?highlight=os#module-os). Voici résumées ici les principales :\n", "\n", "1. **getcwd()** : récupère dans une chaîne le chemin du répertoire de travail.\n", "2. **chdir()** : attend comme argument le nouveau chemin du répertoire de travail (absolu ou relatif).\n", "3. **path.exists()** : teste l'existence du fichier ou dossier dont le chemin est passé en argument.\n", "4. **mkdir()** : crée un répertoire dont le nom est la chaîne passée en argument.\n", "5. **makedirs()** : créé un dossier et les dossiers intermédiaires si nécessaire.\n", "6. **rename(,)** : déplace et/ou renomme un fichier, 2 chemins sont attendus en argument.\n", "7. **listdir()** : liste les fichiers et dossiers du répertoire dont le chemin est passé en argument.\n", "8. **remove()** : supprime un fichier dont le chemin est spécifié en argument.\n", "9. **mkdir()** : supprime le dossier vide dont le chemin est passé en argument.\n", "\n", "> **Exercice** | À partir de votre dossier de travail (normalement celui qui porte comme nom, votre numéro d'étudiant), vous allez commencer par \n", "1. Supprimez tout ce qui s'y trouve et y replacez ensuite les fichiers *t1.txt* à *t5.txt* (qui sont sur Moodle).\n", "2. Reproduisez avec **Python** et le module **os** l'arborescence suivante (à adapter, ici le répertoire de travail est 12345678)\n", "

\n", "3. Affichez la liste des fichiers du dossier **Vus**.\n", "4. Écrivez un court programme qui prend chaque fichier du dossier **Vus** et les renomme avec la lettre **h** à la place de la lette **t** (par exemple *t2.txt* devient *h2.txt*)\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# question 2 et 3\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# question 4\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui vide de ses fichiers le dossier **Vus** et ensuite supprime le dossier **Vus**. Attention, on ne sait pas a priori ce que contient le dossier **Vus** (on sait seulement qu'il n'y a que des fichiers)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Ouverture de fichiers

\n", "\n", "Pour ouvrir un fichier, plusieurs modes sont possibles\n", "\n", "- \"r\" (read) pour la lecture\n", "- \"w\" (write) pour l'écriture (créé le fichier ou l'écrase si il existe déjà)\n", "- \"a\" (append) pour l'ajout de contenu dans le fichier à la suite de ce qu'il y a déjà\n", "\n", "et par ailleurs, on peut spécifier (avec le mode d'ouverture) aussi le mode texte \"t\" (par défaut) ou binaire \"b\" (par exemple \"rb\" ce qui signifie en lecture et en binaire). De plus l'encodage des caractères peut être spécifié, ce qui est une sécurité pour le traitement, l'utf-8 étant la norme sous **Python**. Si le fichier lu ne respecte pas cet encodage, une erreur sera signalée.\n", "\n", "La fait d'ouvrir un fichier ne l'affiche pas à l'écran. Il faut dans un $1^e$ temps récupérer son contenu (ou une partie), et l'afficher. Enfin, il ne faut jamais oublier de refermer un fichier ouvert dès que l'on peut.\n", "\n", "Ouverture du fichier *t1.txt* (le répertoire de travail est toujours 12345678, à adapter) :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fic = open(\"./travail/t5.txt\", \"r\", encoding = 'utf8') # ouvre t5.txt qui est en utf8, en lecture" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plusieurs possibilités pour lire le contenu (ou une partie)\n", "\n", "- lire tout le contenu : **contenu = fic.read()**, contenu est une chaîne\n", "\n", "- lire tout le contenu, ligne par ligne : **contenu = fic.readlines()**, contenu est ici une liste **Python** de chaînes de caractères. Une ligne = du texte jusqu'au \"retour chariot\", c'est-à-dire quand on appuie sur Entrée au clavier (un paragraphe d'un traitement de texte)\n", "\n", "- lire une ligne : **contenu = fic.readline()** contenu est une chaîne. Pour lire la ligne suivante, il faut à nouveau exécuter *fic.readline()*.\n", "\n", "- lire quelques octets : **contenu = fic.read(20)** lit les 20 premiers octets du fichier et renvoie une chaîne. Pour lire, par exemple, les 30 suivants, il faut rappeler cette commande avec 30 comme argument.\n", "\n", "Dès que la lecture est faite, il faut fermer le fichier (sinon, il reste en mémoire inutilement et peut créer desproblèmes de conflit), pour cela exécutez" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fic.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il existe une autre syntaxe pour l'ouverture-fermeture d'un fichier, qui permet de ne pas se soucier de la fermeture, une syntaxe donc à privilégier. Elle utilise le mot clé **with**." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open(\"./travail/t5.txt\", 'r', encoding = 'utf8') as fic:\n", " contenu = fic.read()\n", " print(contenu)\n", "print(\"C'est facile !\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dès que **Python** sort de l'identation (qui débute avec *with*), le fichier est automatiquement fermé ! Quand le texte \"C'est facile !\" est écrit, le fichier est déjà fermé." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme \n", "1. qui ouvre le fichier **t1.txt** (se trouve dans la dossier exercice, sous-dossier de travail), le lit et l'affiche à l'écran\n", "2. qui ouvre le fichier **t4.txt**, puis à l'aide d'une boucle, lit les octets contenus 20 par 20 en les affichant à chaque fois. Vous noterez que la lecture avance dans le fichier au fur et\n", "à mesure." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Écriture dans un fichier

\n", "\n", "L'écriture, comme vous l'avez vu en cours, s'effectue avec **write()** après avoir ouvert un fichier en mode\n", "\"w\".\n", "\n", "Attention, si le fichier existe, vous écrasez son contenu, s'il n'existe pas, vous le créez.\n", "\n", "Commencez par vérifier, avec votre gestionnaire de fichiers, que le fichier **t5.txt** n'est pas vide de texte, en ouvrant simplement le fichier, puis en le refermant.\n", "\n", "Exécutez la cellule suivante :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open(\"./travail/t5.txt\", \"w\", encoding=\"utf8\") as fic:\n", " phrase = \"il pleut tous les jours\"\n", " fic.write(phrase) # notez que le fichier sera fermé seul" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vérifiez avec votre gestionnaire de fichiers que le fichier **t5.txt** a bien changé de contenu.\n", "\n", "Quand on a une liste **Python** de chaînes, on peut utiliser **writelines()** qui écrira l'ensemble des chaînes concaténées.\n", "\n", "> **Exercice** | Écrture dans un fichier\n", "1. Soit les deux phrases *p1* et *p2* suivantes :\n", "p1 = \"La pluie tombe sur la campagne.\" et p2 = \"L'herbe repousse.\"\n", "Dans l'arborescence précédente, dans le dossier **cours**, créez un fichier de nom **poeme.txt** avec\n", "écrit dedans, **sur 2 lignes**, les phrases *p1* et *p2*.\n", "2. Vérifiez avec votre gestionnaire de fichiers que le fichier a bien été créé et vérifiez son contenu.\n", "3. Faites la même chose qu'à la question précédente, mais avec **Python**, c'est-à-dire, créez un programme qui affiche le contenu du fichier **poeme.txt**." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Ajout au contenu d'un fichier

\n", "\n", "Il s'agit cette fois du mode **append**. Vous ouvrez le fichier en mode *append*, puis vous écrivez\n", "dedans (puis fermeture du fichier).\n", "\n", "Vous allez ajouter une ligne au poème précédent.\n", "\n", "Exécutez" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open(\"./travail/cours/poeme.txt\", \"a\", encoding=\"utf8\") as fic: # mode append\n", " p3 = \"Il va falloir tondre...\"\n", " fic.write(\"\\n\" + p3) # sinon la phrase ajoutée est sur la même ligne\n", " \n", "# vérifions\n", "\n", "with open(\"./travail/cours/poeme.txt\", \"r\", encoding=\"utf8\") as fic: # mode lecture\n", " texte = fic.read()\n", " print(texte)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Ajout de contenu\n", "1. Ajoutez à la ligne, une phrase de votre choix au contenu du fichier **t4.txt**.\n", "2. Vérifiez avec **Python** (donc avec un programme) le contenu de ce fichier en affichant le contenu." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Théatre...\n", "1. Recopiez dans un fichier de nom **theatre.txt** du dossier exercice , le contenu sous l'exercice, en tenant compte des sauts de ligne et sans les points et espaces devant chaque phrase.\n", "2. Créez une fonction de nom **filtre()** qui rend en argument un personnage *p* (Jacques ou Jean) et\n", "qui, à partir du fichier **theatre.txt**, créé un fichier **jacques.txt** ou **jean.txt** avec pour contenu\n", "respectivement le texte de Jacques ou celui de Jean. Les fichiers seront dans le dossier **exercice**.\n", "3. Créez les 2 fichiers en lançant\n", "```python\n", " filtre(\"Jacques\")\n", " filtre(\"Jean\")\n", "```\n", "4. Vérifiez avec **Python**, l'existence et le contenu des 2 fichiers créés. (indication : \"Jacques\" a 7 lettres, \"Jean\" a 4 lettres. utilisez *readline()*)\n", "\n", "- Jacques : Que faites-vous ici mon ami ?\n", "- Jean : Oh rien qui ne vaille que je vous en informe !\n", "- Jacques : Que diable faisiez-vous ?\n", "- Jean : Vos questions me fatiguent !" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Gestion de l'aléatoire

\n", "\n", "

Module random

\n", "\n", "On rappelle que tout ce qui touche à l'aléatoire est géré par le module **random**, module inclus dans **Python** de façon native.\n", "\n", "Pensez à importer ce module avant de commencer.\n", "\n", "Exécutez la cellule suivante pour cela" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import random" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Génération de nombre

\n", "\n", "Exécutez plusieurs fois la cellule suivante :" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = random.random()\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Si vous exécutez plusieurs fois les deux lignes précédentes, vous n'obtenez pas la même chose à\n", "chaque fois mais toujours un nombre entre 0 et 1 (1 non compris).\n", "\n", "> **Exercice** | Fiabilité du générateur. \n", "1. Écrivez un court programme (avec l'usage d'une boucle) qui affiche à la suite, 100 nombres\n", "aléatoires compris entre 0 et 1 (1 non compris).\n", "2. Améliorez ce programme pour qu'il compte le nombre de nombre compris entre 0 et 0.5, et le\n", "nombre de nombre compris entre 0.5 et 1 (il devrait y en avoir autant à peu près). Relancez le\n", "programme plusieurs fois pour voir la répartition changer." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Exécutez plusieurs fois la cellule ci-dessous et notez les résultats obtenus." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = random.randint(-2,2)\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vous devez remarquer que parfois les bornes sont atteintes, et cette méthode fournit un nombre\n", "entier (y compris les négatifs) entre les bornes indiquées.\n", "\n", "> **Exercice** | Avec la méthode *randint()*\n", "1. Écrivez un court programme (avec l'usage d'une boucle) qui affiche à la suite, 500 nombres\n", "aléatoires compris entre 1 et 5 (bornes comprises).\n", "2. Améliorez ce programme pour qu'il compte le nombre d'entiers égaux à 1, le nombre d'entiers\n", "égaux à 2, ..., le nombre d'entiers égaux à 5 (il devrait y en avoir autant à peu près). Affichez à la\n", "fin les résultats obtenus. Relancez le programme plusieurs fois pour voir la répartition changer...\n", "(c'est cela le hasard..., rarement la même chose)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Itérables et aléatoire

\n", "\n", "Avec les listes et tuples vous pouvez être amené à faire un choix, ou même plusieurs choix parmi leurs éléments.\n", "\n", "2 méthodes intéressantes pour vous :\n", "- choice() permet de faire un choix dans une liste.\n", "- sample() permet de faire plusieurs choix distincts (une extraction) dans une liste ou tuple. Cette méthode renvoie une liste.\n", "\n", "Exécutez plusieurs fois ces lignes et notez le résultat" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "L = [\"a\",\"e\",\"i\",\"o\",\"u\",\"y\"]\n", "print(random.choice(L))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Faites de même avec" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "L = [\"a\",\"e\",\"i\",\"o\",\"u\",\"y\"]\n", "print(random.sample(L,3)) # arguments : liste, nb d'extraction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Jeu de carte\n", "1. Créez deux listes **Python** de nom, *couleurs* et *valeurs*, la $1^e$ contenant les couleurs des cartes (coeur, carreau, trèffle, pique) et l'autre les valeurs (7, 8, 9, 10, Valet, Dame, Roi, As). Écrivez un programme qui distribue à 2 joueurs 5 cartes (attention de ne pas reprendre les mêmes). Chaque joueur aura pour chaque carte un couple (couleur, valeur).\n", "2. En conservant l'ordre de distribution des cartes, faites jouer ces 2 joueurs à la bataille avec\n", "seulement ces 5 cartes (ie : la plus forte carte l'emporte dans l'ordre de la liste\n", "au-dessus, pour ces 5 cartes seulement, quelque soit la couleur)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Vous programmez un jeu dans lequel 5 personnages \"Arthur\", \"Perceval\", \"Blandine\", \"Igor\" et \"Olga\" affrontent des soldats au cours de leur périples. Les soldats seront nommés (par une\n", "boucle) de \"s1\" à \"s50\".\n", "Il y a 6 épreuves. À chaque épreuve 4 des héros sont choisis au hasard pour affronter 8 des 50\n", "soldats, choisis aussi au hasard (qui, on suppose, meurent à chaque fois et donc disparaissent du jeu).\n", "Simulez ce jeu, et affichez pour chaque héros le nombre de combat faits et le nom des 2 derniers\n", "soldats vivants. relancez votre programme plusieurs fois." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Gestion du temps

\n", "\n", "La gestion du temps, date, jour, fuseau horaire, année, etc. est très complète en **Python**. Vous allez juste utiliser la date du jour, et utiliser une mesure de temps.\n", "\n", "

Date du jour

\n", "\n", "Vous avez besoin pour cela d'importer le module **datetime** inclus de façon native dans **Python**." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import datetime as dt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Comme **datetime** est long à écrire, on a choisi ici de prendre un alias ( dt ) qui désormais va remplacer\n", "( datetime ) quand on en aura besoin...\n", "\n", "Dans le sous-module **date** se trouve une méthode **today()** qui permet d'obtenir la date du jour." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(dt.date.today()) # objet contenant la date attendue" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Maintenant pour extraire ce dont on a besoin, on utilise les attributs liés à cet objet." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "aujourdhui = dt.date.today()\n", "print(aujourdhui.day)\n", "print(aujourdhui.month)\n", "print(aujourdhui.year)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Écrivez un programme qui écrit la phrase suivante avec les bonnes valeurs : \"Aujourd'hui nous sommes le *31/07* et comme cette année, l'année *2045*, est la meilleure, c'est un beau jour!\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Avec un fichier\n", "1. Créez un fichier dans votre répertoire de travail, fichier que vous nommerez **projet.txt** avec\n", "comme contenu la phrase \"*c'est la 1e ligne!*\"\n", "2. Vous voulez gérer les versions de votre projet de sorte que quand vous enregistrez votre projet\n", "(enregistrez le fichier modifié et fermez-le), il ajoute une copie du fichier avec dans le nom du\n", "fichier la date, sur le modèle ci-dessous :\n", "-Exemple : fichier initial enregistré : projet.txt\n", "-Enregistrement suivant le 5 : projet5-11-2019.txt\n", "-Enregistrement suivant le 7 : projet7-11-2019.txt\n", "Écrivez une fonction que vous nommerez **enreg()** qui prend en argument le nom du fichier (sans\n", "extension) et qui ajoute la date (comme ci-dessus avant d'enregistrer le fihier). Testez et vérifiez\n", "que votre fonction ajoute le fichier correspondant." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Mesure du temps

\n", "\n", "Il y a plusieurs façon de procéder, mais en voici une...\n", "\n", "Vous avez déjà besoin d'importer le module **time** inclus nativement dans **Python**. Mais comme nous n'allons utiliser qu'une fonctionnalité de ce module, nous allons directement importer celle-ci avec un nom d'alias plus sympatique et plus court." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from time import perf_counter as pf # notez la syntaxe" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**pf()** va désormais vous renvoyer un nombre qui correspond à un temps avec une résolution en\n", "nanoseconde, temps écoulé depuis un certain \"début\".\n", "\n", "Deux appels successifs de **pf()** vous renvoient à chaque fois un nombre. Lorque que l'on en fait la\n", "différence, cela vous donne le temps en secondes, écoulés entre les deux.\n", "\n", "Observez et exécutez ce programme" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false }, "outputs": [], "source": [ "t1 = pf() # top départ\n", "for i in range(100000):\n", " a = i**2 # des calculs pour occuper le processeur...\n", " a = a // 2 # des calculs pour occuper le processeur...\n", " a = a % 7 # des calculs pour occuper le processeur...\n", " print(a, end=\"-\")\n", "t2 = pf() # top fin\n", "print(\"Il s'est écoulé\", t2-t1, \"secondes\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vous avez vu en cours ce petit jeu où il faut deviner un nombre entre 1 et 100." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import random\n", "nb = random.randint(1,100) # nombre à deviner\n", "while 1 : # boucle sans fin\n", " essai = eval(input(\"Propose un nombre \"))\n", " if nb == essai :\n", " print(\"Gagné !\")\n", " break # on sort de la boucle, qui prend donc fin quand on a trouvé\n", " elif essai > nb :\n", " print(\"Trop grand !\")\n", " else :\n", " print(\"Trop petit\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercice** | Modifiez ce programme ci-dessus, pour qu'il s'arrête si on dépasse 20 secondes (ou plus, ou moins) avec le message \"**PERDU, vous êtes trop lent!**\" (placez le test juste après la ligne où il y a *input()* )" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# FIN du TD5" ] } ], "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.8.3" } }, "nbformat": 4, "nbformat_minor": 4 }