Zhentao Li's Homepage

Cours

Les transparents du troisième cours sont disponibles ici et ici.

Parenthèse sur l'encodage de texte (utile si vous ouvrez des fichiers textes en français, par exemple).

Session TP

• Console
• Solution finale à la question 1. À noter que si le fichier poeme.txt existe déjà, un nouveau poème sera ajouté à la fin (plutôt que de remplacer le fichier). Testé sur vers.txt.
• Solution finale à la question 2

Exercice 1 - Cent mille milliards de poèmes

Cent mille milliards de poèmes, est une œuvre de poésie combinatoire de Raymond Queneau, publiée en 1961. Le livre est composé de dix feuilles, chacune séparée en quatorze bandes horizontales, chaque bande portant sur son recto un vers. Le lecteur peut donc, en tournant les bandes horizontales comme des pages, choisir pour chaque vers une des dix versions proposées par Queneau. Les dix versions de chaque vers ont la même scansion et la même rime, ce qui assure que chaque sonnet ainsi assemblé est régulier dans sa forme.

Supposons que l'on dispose d'un fichier vers.txt qui contient une séquence de 14 groupements de 10 vers séparés par des lignes vides.

1. Écrire un script Python chargeant le fichier dans une liste associant aux entiers de 0 à 13, la liste des vers de chaque groupement.

2. Modifier le script pour générer un poème de 14 vers en prenant un vers aléatoirement dans chaque groupement.

   Utiliser pour cela le module random de la bibliothèque standard de Python.

import random

tout_groupe = open("vers.txt").read()
vers_possible = []
for vers in tout_groupe.split("\n\n")[:-1]:
    vers_possible.append(vers.split("\n"))

sortie = open("poeme.txt","w")
for possibilites in vers_possible:
    sortie.write(random.choice(possibilites+"\n"))
sortie.close()

Exercice 2 - Générateur de texte

1. Écrire une fonction Python qui génère une liste des mots consécutifs d'un texte.

   >>> texte = "Ecrire un programme Python qui genere une liste des mots consecutifs d'un texte. Une autre phrase de ce texte. En une derniere."
   >>> consecutifs(texte)
   [('Ecrire', 'un'), ('un', 'programme'), ('programme', 'Python'), ('Python', 'qui'), ('qui', 'genere'), ('genere', 'une'), ('une', 'liste'), ('liste', 'des'), ('des', 'mots'), ('mots', 'consecutifs'), ('consecutifs', "d'un"), ("d'un", 'texte.'), ('texte.', 'Une'), ('Une', 'autre'), ('autre', 'phrase'), ('phrase', 'de'), ('de', 'ce'), ('ce', 'texte.'), ('texte.', 'En'), ('En', 'une'), ('une', 'derniere.')]
   

   (Supposer que "mots" veux dire des chaines de caractères séparés d'espaces.)

2. Écrire une fonction Python qui prends un texte et génère un dictionnaire où les clés sont les mots du texte et les valeurs pour un mot sont les mots qui peuvent le suivre dans le texte.

   >>> suivant = mot_suivant(texte)
   >>> suivant["une"]
   ['liste', 'derniere.']
   

   Fichier appelé mots.py.

   def consecutifs(texte):
       mots = texte.split()
       mots_consecutifs = []
       for i in range(len(mots) - 1):
           mots_consecutifs.append((mots[i], mots[i+1]))
       return mots_consecutifs
   
   def mot_suivant(texte):
       suivant = {}
       for mot1, mot2 in consecutifs(texte):
           if mot1 in suivant:
               suivant[mot1].append(mot2)
           else:
               suivant[mot1] = [mot2]
       return suivant
   

3. Sauvegarder les deux fonctions précédentes en un module. Importer ce module. Écrire un programme Python qui prends le nom d'un fichier en entrée, lit le texte dans ce fichier et écrit dans un deuxième fichier un texte dont tous les mots qui se suivent apparaissent comme mots consécutifs dans le texte original.

   Ce deuxième texte devrait être générer de façon aléatoire (de sorte qu'on obtienne très probablement un texte différent à chaque lancée du programme sur un même texte).

   En supposant que le premier fichier est appelé mots.py.

   import mots
   import random
   
   def genere_texte(nom_fichier, longueur_max):
       texte = open(nom_fichier).read()
       suivant = mots.mot_suivant(texte)
       mot = random.choice(suivant.keys())
       texte = mot
       for i in range(longueur_max):
           if mot in suivant:
               mot = random.choice(suivant[mot])
               texte = texte + " " + mot
           else:
               break
       return texte
   
   longueur_max = 1000
   nom_fichier = "Poe.txt"
   nouveau_texte = genere_texte(nom_fichier, longueur_max)
   open("nouveau_texte.txt", "w").write(nouveau_texte)
   

   Exemple de sortie.

4. * Changer le programme (et module) précédent pour que le texte en sortie et le texte en entrée ont les même triplets consécutifs.