Chap. 10 — Structures de données, les séquences 2 : chaînes de caractères

Chap. 10 — Structures de données, les séquences 2 : chaînes de caractèresLes chaînes de caractèresUtilisation des fonctions et opérateurs destinés aux séquencesAccès aux caractères et découpageTest de l'appartenance d'un caractère à une chaîneComparaison de chaînes de caractèresLongueur et parcours des chaînesConcaténation et répétition des chaînesModification des chainesQuelques méthodes spécifiques aux chaînes de caractèresUtilisation des triples guillemetsExercices du chapitreExercice 1Exercice 2Exercice 3 : Longueur d'une chaîne de caractèresExercice 4 : Recherche dans une chaîne de caractèresExercice 5 : Inversion de la casse d'une chaîne de caractèresExercice 6 : Recherche de la position d'un caractère dans une chaîne de caractèresExercice 7 : Simulation d'une méthodeExercice 8 : Palindrome

Les chaînes de caractères

Les chaînes de caractères forment une structure de donnée scalaire, séquentielle et immuable.
Elles sont formées de caractères délimités par des guillemets simples* ', des guillemets doubles " ou, pour des cas plus spécifiques tels que la documentation des fonctions, des guillements triples """.


x
>>> chaine_1 = 'Bonjour à tous'    # utilisation des doubles côtes
>>> chaine_2 = "Python, c'est super"  # on peut placer une simple côte  
                                          # entre des doubles
>>> print(chaine_1)
Bonjour à tous
>>> s = str(55)         # utilisation de la fonction intégrée str()
>>> print(chaine_1, chaine_2)    # print() concatène les chaînes
Bonjour à tous Python, c'est super

Utilisation des fonctions et opérateurs destinés aux séquences

Accès aux caractères et découpage


x
>>> chaine_1 = 'Bonjour à tous'
>>> chaine_1[0]
'B'
>>> chaine_1[0:3]
'Bon'
>>> chaine_1[-1]
's'
>>> chaine_1[:]
'Bonjour à tous'

Test de l'appartenance d'un caractère à une chaîne


x
>>> chaine_1 = 'Bonjour à tous'
>>> 'b' in chaine_1
False
>>> 'jour' in chaine_1
True
>>> ' ' not in chaine_1
False

Comparaison de chaînes de caractères


x
>>> a = "abc"
>>> b = "def"
>>> a == b
False
>>> a < b    # L'ordre lexicographique est utilisé ici
True

Longueur et parcours des chaînes


x
>>> c = "ajksd"
>>> len(c)
5
>>> len("")    # chaîne vide
0
>>> for caractere in c:
....:     print(caractere, end=' ')
....:     
a j k s d

Concaténation et répétition des chaînes


x
>>> "-" * 15
'---------------'
>>> "a" + "b"
'ab'

Modification des chaines

Les chaînes de caractères étant immuables, il est impossible de les modifier. Il est cependant possible de combiner des opérations pour créer de nouvelles chaînes comportant la modification souhaitée.


x
>>> c1 = "Hello World!"
>>> c1 = c1[:6] + "Python" + c1[11:]
>>> c1
>>> 'Hello Python!'

Quelques méthodes spécifiques aux chaînes de caractères

La programmation objet n'étant pas au programme, nous considérerons cette année qu'une méthode est une fonction agissant sur un type d'objets.

Remarque : La liste complète des méthodes, avec leur définition, est accessible en consultant la documentation depuis la console :


xxxxxxxxxx
>>> help(str)

Appel de la méthode	Description de l'action
`chaine.capitalize()`	Met en lettre capitale le premier caractère de `chaine`.
`chaine.count(str)`	Compte le nombre d'occurences de `str` dans `chaine`.
`chaine.endswith(str)`	Détermine si `chaine` se termine par `str`. Retourne `True` si c'est le cas.
`chaine.find(str)`	Détermine si `str` se trouve dans `chaine`. Retourne l'indice de la position si `str` se trouve bien dans `chaine`, -1 dans le cas contraire.
`chaine.index(str)`	Similaire à `find()` mais lève une exception si `str` ne se trouve pas dans `chaine`.
`chaine.isalnum()`	Retourne `True` si `chaine` contient au moins un caractère et si tous les caractères sont alphanumériques. Si la chaîne est vide ou si l'un des caractère est non alphanumérique, retourne `False`.
`chaine.isalpha()`	Retourne `True` si `chaine` contient au moins un caractère et si tous les caractères sont alphabétiques. Si la chaîne est vide ou si l'un des caractère est non alphabétique, retourne `False`.
`chaine.isdecimal()`	Retourne `True` si `chaine` ne contient que des chiffres décimaux, retourne `False` sinon.
`chaine.isdigit()`	Retourne `True` si `chaine` ne contient que des chiffres, retourne `False` sinon.
`chaine.islower()`	Retourne `True` si `chaine` contient au moins un caractère alphabétique et si tous les caractères alphabétiques sont en minuscules, retourne `False` sinon.
`chaine.isnumeric()`	Retourne `True` si `chaine` ne contient que des caractères numériques, retourne `False` sinon.
`chaine.isspace()`	Retourne `True` si `chaine` ne contient que des blancs, retourne `False` sinon.
`chaine.isupper()`	Retourne `True` si `chaine` contient au moins un caractère alphabétique et si tous les caractères alphabétiques sont en majuscules, retourne `False` sinon.
`chaine.join(seq)`	Fusionne (concatène) les représentations sous forme de chaînes des éléments de la séquence `seq` en une chaîne, avec le séparateur `chaine`.
`chaine.lower()`	Convertit toutes les majuscules de `chaine` minuscules.
`chaine.lstrip()`	Supprime au début de `chaine` tous les blancs.
`chaine.replace(str1, str2)`	Remplace toutes les occurences de `str1` dans `chaine` par `str2`.
`chaine.rstrip()`	Supprime à la fin de `chaine` tous les blancs.
`chaine.startwidth(str)`	Déterminer si `chaine` commence par `str`. Retourne `True` si c'est le cas.
`chaine.split(str)`	Fractionne `chaine` selon le délimiteur `str` (l'espace par défaut) en partant de la fin de la chaîne et retourne une liste de sous-chaînes.
`chaine.strip()`	Supprime tous les blancs dans `chaine`.
`chaine.swapcase()`	Inverse la casse de toutes les lettres de `chaine`.
`chaine.title()`	Retourne une version de `chaine` où l'initiale de chaque mot est une majuscule, comme dans un titre anglais.
`chaine.upper()`	Convertit les minuscules de `chaine` en majuscules.


x
>>> c = "une-chaine-avec-des-sous-chaines-séparées-par-des-tirets"
>>> liste_sous_chaines = c.split("-") # création d'une liste de sous-chaînes
>>> print(liste_sous_chaines)
['une', 'chaine', 'avec', 'des', 'sous', 'chaines', 'séparées', 'par', 'des', 
'tirets']
>>> c2 = ":".join(liste_sous_chaines) # on reforme une chaîne. 
>>> print(c2)
une:chaine:avec:des:sous:chaines:séparées:par:des:tirets

Utilisation des triples guillemets

Les triples guillemets permettent aux chaînes de caractères de s'étendre sur plusieurs lignes (même si elles comportent des caractères « nouvelle ligne ») :


xxxxxxxxxx
errHTML = """
<html>
    <head>
        <title>
            Page inaccessible !
        </title>
    </head>
    <body>
        <h1>Cette page est inacessible !</h1>
        <p> ... </p>
    </body>
</html>
"""
print(errHTML)

Exercices du chapitre

Exercice 1

Prédire le retour des instructions suivantes :


x
>>> data = "monprogramme.exe"
>>> data[2]
>>> data[-1]
>>> data[3:6]
>>> len(data)
>>> data[0:8]
>>> "gram" in data and "pro" in data
>>> "mon" in data or "ze" in data

Solution

'n'
'e'
'pro'
16
'monprogr'
True
True

Exercice 2

À partir de l'instruction data = "monprogramme.exe", déterminer les expressions qui permettent d'affiche, à partir de data :

la sous-chaîne « gram » ;
la sous-chaîne « exe »
le caractère au centre de la chaîne.

Solution

data[6:10]
data[-3:]
data[len(data) // 2]

Exercice 3 : Longueur d'une chaîne de caractères

Écrire une fonction nommée longueur, qui détermine la longueur d'une chaîne de caractères (il est bien évidemment interdit d'utiliser la fonction len).

Solution


xxxxxxxxxx
def longueur(chaine: str) -> int:
    """
    Détermine la longueur de la chaine passée en argument.
    """
    long = 0
    for element in chaine:
        long += 1
    return long

Exercice 4 : Recherche dans une chaîne de caractères

Écrire un prédicat nommée est_dans, qui, à partir d'un caractère e et d'une chaîne de caractères c, détermine si ce caractère appartient à la chaîne.

Solution


xxxxxxxxxx
def est_dans(chaine: str, caractere: str) -> bool:
    """
    Détermine si le caractère passé en argument appartient ou pas à
    la chaîne passée en argument.
    """
    for car in chaine:
        if car == caractere:
            return True
    return False

Exercice 5 : Inversion de la casse d'une chaîne de caractères

Écrire une fonction qui, à partir d'une chaîne, inverse la casse. Par exemple, "Mr. Ed" doit devenir "mR. eD".

Solution

Exercice 6 : Recherche de la position d'un caractère dans une chaîne de caractères

Écrire une fonction nommée rang, qui, à partir d'un caractère e et d'une chaîne de caractères c, détermine la (première) position de ce caractère dans la chaîne. Si le caractère n'est pas présent, retourner un entier négatif.

Solution


xxxxxxxxxx
def rang(chaine: str, car: str) -> int:
    """
    Détermine le premier indice de car dans chaine.
    Retourne -1 si car n'appartient pas à chaine.
    """
    for i, elt in enumerate(chaine):
        if elt == car:
            return i
    return -1
def rang_2(chaine: str, car: str) -> int:
    """
    Détermine le premier indice de car dans chaine.
    Retourne -1 si car n'appartient pas à chaine.
    """
    i = 0
    for i in range(len(chaine)):
        if chaine[i] == car:
            return i
    return -1

Exercice 7 : Simulation d'une méthode

Écrire une fonction qui réalise une opération identique à la méthode chaine.strip() : pour une chaîne donnée, tous les caractères « blancs » au début et à la fin de la chaîne doivent être supprimés.

Remarque : Il sera profitable d'étudier les attributs disponibles dans le module string.

Solution

Exercice 8 : Palindrome

Écrire une fonction qui détermine si une chaîne de caractères est un palindrome.
À partir d'une chaîne donnée, créer un palindrome en lui ajoutant une copie inversée.

Solution