Aller au contenu

TP - Chaînes de caractères modifiables☘

Ce TP doit conduire à créer de A à Z un module utilisable tout le reste de l'année.

Dans le dossier [NSI], créez le dossier [D02-Modularité].

Téléchargez le fichier « à trous » string_var.py (clic droit -> [Enregistrer sous]) et enregistrez-le dans ce dossier.

Ce TP a pour but de définir une structure de données implémentant des chaînes de caractères modifiables.
Conseils

Plutôt que traiter la partie 1 puis la partie 2 puis la partie 3, il est conseillé de programmer quelques méthodes (partie 1), puis les tester (partie 2) puis écrire la documentation de ces méthodes (partie 3) puis programmer d'autres méthodes (partie 1), les tester (partie 2), écrire leur documentation (partie 3), etc...

Partie 1 - Les méthodes de classe☘

Complétez la définition de la classe StringVar dont l'attribut est chaine doit être une chaîne de caractères « classique », vide par défaut. N'hésitez pas à ajouter des méthodes si vous le souhaitez...

Code à compléter
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
class StringVar:
    """

    """

    def __init__(self, chaine=""):
        """
        chaine - str
        Sortie: initialisation d'un objet de type StringVar
        """
        pass

    def __str__(self):
        """
        Sortie: Affichage avec print()
        """
        pass

    def __repr__(self):
        """
        Sortie: Affichage lors de l'appel de l'objet
        """
        pass

    def __len__(self):
        """
        Sortie: int, nombre de caractères de la chaîne
        """
        pass

    def getChaine(self):
        """
        Sortie: str - chaîne de caractères
        """
        pass

    def setChaine(self, newchaine):
        """
        Sortie: None - Remplace la valeur de la chaîne
        """
        pass

    def setCaractere(self, indice, carac):
        """
        indice - int, entier positif ou nul
        carac - str, un caractère
        Sortie: None - Si indice est valide, remplace par carac
                le caractère de la chaîne ayant pour indice indice 
        """
        pass

    def __add__(self, texte):
        """
        texte - StringVar
        Sortie: StringVar - Les deux chaînes sont concaténées
        """

    def __sub__(self, texte):
        """
        texte - StringVar
        Sortie: StringVar - Lorsque texte est le suffixe de la chaîne,
                renvoie cette chaîne privée du suffixe.
                Sinon, renvoie simplement la chaîne à gauche du "-".
        """
        pass

    def renverser(self):
        """
        Sortie: None - la chaîne de caractères est écrite dans le sens inverse.
        """
        pass

    def estPalindrome(self):
        """
        Sortie: bool - Renvoie True lorsque la chaîne est un palindrome,
                False sinon
        """
        pass

Assertions à programmer

Il faudra programmer les assertions suivantes : 

>>> exemple1 = StringVar(4)
AssertionError: str type is required

>>> exemple2 = StringVar('4')
>>> exemple2.setChaine(3)
AssertionError: str type is required

>>> exemple3 = StringVar('exemple')
>>> exemple3.setCaractere(0, 3)
AssertionError: str type is required for carac

>>> exemple3.setCaractere('0', '3')
AssertionError: int type is required for indice

>>> exemple3.setCaractere(-4, 'i')
AssertionError: Il faut 0 <= indice < 7

>>> exemple3.setCaractere(4, 'au')
AssertionError: len(au) != 1
Dans setCaractere(), les messages s'adaptent aux données (f-string).

Une piste pour la soustraction de chaînes

chaine1 - chaine2 renverra chaine1 si chaine2 n'est pas un suffixe de chaine1 et renverra chaine1 privé du suffixe chaine2 sinon.

Partie 2 - Réalisation des tests☘

Complétez le programme principal avec des tests pertinents et exhaustifs de toutes les méthodes programmées dans la partie précédente.

Partie 3 - Documenter et utiliser la classe☘

  1. Complétez le docstring de la classe.
  2. Vérifiez votre documentation dans la console en exécutant l'instruction : 
    >>> help(StringVar)
  3. Dans le répertoire contenant le fichier string_var.py, enregistrez un nouveau fichier nommé main.py.

  4. Dans ce nouveau fichier, importez comme un module le fichier string_var.py : 

    1
    from string_var import *

    Attention

    Si vous travaillez avec Pyzo, vérifiez que vous vous trouvez bien dans le bon répertoire de travail.

  5. Sauvegardez main.py puis exécutez-le.
    Vous pouvez à présent utiliser des chaînes de caractères modifiables dans ce programme... N'hésitez pas à tester !