Objectif

Compiler les données de l’application et envoyer des lettres de réponse en utilisant le module string.

Maintenant que les matériaux pour la nouvelle construction de la ferme ont été pris en compte, il est temps de porter notre attention sur le nouveau personnel pour la ferme. Nous avons plusieurs lettres à envoyer pour les candidatures, ce qui nécessiterait naturellement beaucoup d’écriture, cependant nous pouvons utiliser le module string pour compenser cela, nous permettant de créer des modèles et de formater du texte afin de faciliter la gestion de textes volumineux.

L’importation du module string cette fois-ci sera un peu différente des autres modules, car nous importerons des classes qui étendent le module, et qui seront exécutées de la manière suivante:

import string
from string import Template
from string import Formatter

Cela nous donne accès au module lui-même ainsi qu’aux classes de modèles et de formatage qui incluent leurs propres fonctions. Pour nos besoins, nous utiliserons les fonctions et classes suivantes:

• string.capwords(): Cette fonction convertit les mots d’une chaîne pour leur appliquer une capitalisation appropriée, mettant en majuscule la première lettre d’un mot et le reste en minuscules, quelle que soit la manière dont la chaîne est formatée.
• Template(): Il s’agit d’une classe de chaîne, utilisée pour créer un objet modèle. Elle utilise la fonction substitute() qui permet de configurer une chaîne et de marquer un emplacement à l’aide du signe $ pour substituer des données. Cela vous permet de créer des chaînes modulaires que vous pouvez utiliser à volonté.
• Formatter(): Il s’agit d’une classe de chaîne, utilisée pour formater ou composer une chaîne. Elle fonctionne de manière similaire à la classe Template() mais est plus robuste et mieux adaptée pour de plus longues séquences de chaînes. Elle utilise la fonction format() qui permet de configurer une chaîne et d’insérer des données de texte en utilisant {}.

Commencez par vous diriger vers la croix X lumineuse et utilisez la fonction read() en regardant vers l’armoire à dossiers, cela vous permettra d’accéder aux dossiers portant le nom de divers candidats. Ces dossiers sont présents sous forme de trois constantes de liste nommées : folder_a, folder_b et folder_c.

Dirigez-vous vers la croix X sombre sur le tapis vert et faites face au bureau. Créez trois listes appelées : names_a, names_b et names_c. Utilisez des compréhensions de liste avec la fonction string.capwords() pour formater correctement les noms. Associez les listes aux constantes ayant la même lettre dans leur nom ; par exemple, pour names_a utilisez string.capwords() avec folder_a, de cette manière : names_a = [string.capwords(x) for x in folder_a]. Utilisez cette même formule pour remplir names_b et names_c.

Créez une liste nommée all_names et additionnez les trois listes de noms, comme ceci : all_names = names_a + names_b + names_c. Cela combinera toutes les listes en une seule liste plus grande. Ensuite, utilisez la fonction join() de Python pour joindre tous les éléments de la liste en une chaîne. Vous pouvez également indiquer ce qu’il faut insérer entre chaque élément en le déclarant entre guillemets, par exemple : all_names = ", ".join(all_templates). Utilisez la fonction pré-écrite write() avec la liste all_names pour inscrire tous les noms avec leur capitalisation correcte.

Ensuite, rendez-vous vers la croix X dorée en direction du bureau, ici nous allons configurer des modèles. Nous disposerons de deux objets modèles pré-écrits nommés red_templates et blue_templates:

red_template = Template(
  "Hello, $name , thank you for applying for this position.")
blue_template = Template(
  "Esteemed , $name , your application has been approved.")

Chacun de ces modèles contient un message unique, mais ils ont un point commun : un espace réservé étiqueté $name. Le symbole $ est utilisé pour définir un espace réservé qui peut être remplacé par une chaîne de votre choix, dans ce cas, comme le titre l’indique, il s’agit d’un nom. Si aucune valeur n’est substituée, le modèle utilisera simplement l’espace réservé dans la chaîne. Pour compléter cela, créez une liste nommée all_templates.

Créez une boucle for avec quatre itérations, dans laquelle nous remplacerons les noms dans les trois listes de noms par les modèles contenant les noms. Par exemple, nous appliquerons le red_template à la liste names_a. Utilisez la fonction substitute() de la classe Template() pour remplacer l’espace réservé $name dans le modèle par les noms de la liste.

for x in range(4):
  names_a[x] = red_template.substitute(name=names_a[x]) 

Faites de même avec names_b et names_c, pour names_b utilisez également le red_template et pour names_c utilisez le blue_template.

Une fois que toutes les listes de noms ont été remplies avec les nouveaux modèles, il est temps de les examiner. Créez une nouvelle liste nommée all_templates et ajoutez-y toutes les listes de noms ensemble, comme ceci : all_templates = names_a + names_b + names_c. Utilisez à nouveau la fonction join() pour compiler tous les noms modélisés sous une forme lisible, par exemple : all_templates = "\n".join(all_templates). Utilisez la fonction pré-écrite write() avec all_templates pour répertorier tous les en-têtes des différents noms.

Ensuite, rendez-vous vers la croix X sombre sur le tapis rouge et faites face au bureau. Ici, nous allons formater et rédiger le premier ensemble de lettres. Commencez par créer deux objets formateurs nommés red_1 et red_2 en utilisant la notation de classe, comme ceci : red_1 = Formatter(), red_2 = Formatter(). Pour la composition des lettres, créez une liste nommée red_letters.

Tout comme précédemment, nous allons créer une boucle for avec quatre itérations. Nous disposerons de deux séries de chaînes pré-écrites qui seront formatées à l’aide de la fonction format(), en y ajoutant les variables de noms. Ces chaînes formatées seront ajoutées à la liste red_letters, formant une liste complète de lettres à envoyer. Par exemple, les objets formatés red_1 seront formatés avec la liste names_a et ajoutés à la liste red_letters.

for x in range(4):
  red_letters.append(red_1.format(
    "{} Orientation will begin next week, please report to the office..."
    , names_a[x]))

Faites de même avec l’objet formaté red_2 en utilisant sa chaîne pré-écrite et en ajoutant names_b dans la boucle. Une fois ceci mis en place, utilisez la fonction join() avec red_letters pour compiler les données en un seul fichier, par exemple : red_letters = "\n".join(red_letters). Utilisez la fonction write() avec red_letters pour enregistrer toutes les lettres formatées qui seront envoyées.

Enfin, rendez-vous vers la croix X sombre sur le tapis bleu et faites face au bureau. Ici, nous allons formater et composer le dernier ensemble de lettres. Comme auparavant, créez deux objets formateurs nommés blue_1 et blue_2 en utilisant la notation de classe, comme ceci : blue_1 = Formatter(), blue_2 = Formatter(). Créez une liste blue_letters pour formater et composer toutes les lettres.

Créez à nouveau une boucle for avec quatre itérations et utilisez les chaînes pré-écrites pour formater les listes de noms et les ajouter à la liste blue_letters avec la fonction format(). Dans ce cas, associez les objets formatés blue_1 avec la liste names_c et les objets formatés blue_2 avec la liste names_b. Cela se fait de la même manière que sous le tapis rouge, mais avec des valeurs différentes, démontrant ainsi la polyvalence de l’utilisation des formats et des modèles. Une fois terminé, utilisez la fonction write() avec blue_letters pour enregistrer les dernières lettres et terminer le niveau.