Aller au contenu

Traitement systématique
de séquence

Deux types de problèmes se présentent fréquemment pour les séquences (et donc pour les chaînes de caractères). Les deux algorithmes ci-dessous sont à savoir et à savoir adapter selon la question posée.

Parcourir tous les éléments

On parcourt tous les éléments de la chaîne de caractère lorsqu'on souhaite appliquer un même traitement à chaque élément de cette chaîne. Pour cela, on peut utiliser l'algorithme suivant :

initialisation des variables

Pour chaque élément de la chaîne :
    instructions (bloc)
    traiter le caractère courant de la chaîne

Dans le cas d'une fonction, c'est généralement la chaîne modifiée qui est renvoyée. Or, une chaîne de caractère ne peut pas être modifiée, il faudra donc « tricher ». Pour cela :

  • On initialise une chaîne vide. Par exemple : resultat = ''.

  • On parcourt les caractères de la chaîne à modifier et on place les caractères à conserver dans la chaîne resultat.

  • On renvoie la chaîne resultat qui correspond à la chaîne initiale modifiée.

Exemple

Définir la fonction masquer() qui prend pour paramètre une chaîne de caractères et qui renvoie la même chaîne dans laquelle seuls le premier et le dernier caractère sont conservés, les autres étant remplacés par des étoiles *.

1
2
3
4
5
6
def masquer(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: str - La chaîne dans laquelle tous les caractères sont remplacés par des '*',
            hormis le premier et le dernier
    """

On pourra effectuer le test ci-dessous :

>>> masquer('Ceci est un exemple')
'C*****************e'

Algorithme
1
2
3
4
5
reponse <- premier caractère de chaine
Pour chaque caractère de la chaîne à traiter, du 2ème à l'avant-dernier :
    On place un '*' dans reponse
On place le dernier caractère de chaine dans reponse
On renvoie reponse
Solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def masquer(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: str - La chaîne dans laquelle tous les caractères sont remplacés par des '*',
            hormis le premier et le dernier
    """
    reponse = chaine[0]
    for indice in range(1, len(chaine)-1):
        reponse = reponse + '*'
    reponse = reponse + chaine[len(chaine)-1]
    return reponse
Solution améliorée

La fonction len() permet d'obtenir le nombre de caractères de la chaîne passée en paramètre donc ce nombre de caractères moins 2 correspond au nombre de caractères à « remplacer » par des *.

1
2
3
4
5
6
7
8
9
def masquer(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: str - La chaîne dans laquelle tous les caractères sont remplacés par des '*',
            hormis le premier et le dernier
    """
    nb_carac = len(chaine)
    reponse = chaine[0] + '*'*(nb_carac-2) + chaine[nb_carac-1]
    return reponse

Recherche dans une séquence

Lorsqu'on recherche un élément d'une chaîne qui possède une certaine propriété, on parcourt les caractères jusqu'à trouver celui qui convient. Il est possible qu'aucun ne convienne...

initialisation des variables
Le premier élément est-il celui cherché ?

Tant que l'indice traité n'a pas dépassé la longueur et qu'on n'a pas trouvé :
    accéder à l'élément suivant
    instructions (bloc)    
Dans cet algorithme, « avoir trouvé » signifie qu'un des éléments de la séquence vérifie la propriété recherchée.
Dans le cas d'une fonction, c'est généralement l'indice de cet élément qui est renvoyé.

Exemple

Définir la fonction indice_premier_chiffre() qui prend pour paramètre une chaîne de caractères et qui renvoie l'indice du premier chiffre contenu dans cette chaîne si elle contient un chiffre ou bien -1 dans le cas où elle ne contient aucun chiffre.

1
2
3
4
5
6
def indice_premier_chiffre(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: int - indice du premier chiffre contenu dans chaine,
            -1 sinon
    """

On pourra effectuer les tests ci-dessous :

>>> indice_premier_chiffre("abcd")
-1

>>> indice_premier_chiffre("9876543210")
0

>>> indice_premier_chiffre("J'ai 16 ans.")
5

Une piste

On pourra introduire une chaîne de caractères nommée chiffres qui contient tous les chiffres de 0 à 9.

Algorithme
1
2
3
4
5
6
7
indice_chiffre <- -1        # Indice du premier chiffre trouvé
indice <- 0                 # Indice du caractère traité
Tant que indice n'a pas dépassé la longueur et que indice_chiffre vaut -1 :
    Si l'élément courant est un chiffre
        Alors indice_chiffre <- indice
    indice augmente de 1
On renvoie indice_chiffre
Une première solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def indice_premier_chiffre(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: int - indice du premier chiffre contenu dans chaine,
            -1 sinon
    """
    chiffres = "0123456789"
    indice_chiffre = -1
    indice = 0
    while indice < len(chaine) and indice_chiffre == -1:
        if chaine[indice] in chiffres:
            indice_chiffre = indice
        indice += 1
    return indice_chiffre
Une deuxième solution

On peut utiliser une boucle for et sortir de manière anticipée de cette boucle grâce à un return :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def indice_premier_chiffre(chaine):
    """
    chaine - str, chaîne de caractères
    Sortie: int - indice du premier chiffre contenu dans chaine,
            -1 sinon
    """
    chiffres = "0123456789"
    for i in range(len(chaine)):
        if chaine[i] in chiffres:
            return i
    return -1