Programmation Python/Chaines de caractères

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


Les données alphanumériques[modifier | modifier le wikicode]

Début d’un principe
Fin du principe


A la différence des données numériques, qui sont des entités singulières, les chaînes de caractères (ou string) constituent un type de donnée composite. Nous entendons par là une entité bien définie qui est faite elle-même d'un ensemble d'entités plus petites, en l'occurrence : les caractères. Suivant les circonstances, nous serons amenés à traiter une telle donnée composite, tantôt comme un seul objet, tantôt comme une suite ordonnée d'éléments. Dans ce dernier cas, nous souhaiterons probablement pouvoir accéder à chacun de ces éléments à titre individuel.

En fait, les chaînes de caractères font partie d'une catégorie d'objets Python que l'on appelle des séquences, et dont font partie aussi les listes et les tuples.

Le type « string »[modifier | modifier le wikicode]

Sous Python, une donnée de type string est une suite quelconque de caractères délimitée soit par des apostrophes (simple quotes), soit par des guillemets (double quotes), soit par des triples quotes (''' ou """).

Exemples :

>>> phrase1 = 'les œufs durs.'
>>> phrase2 = '"Oui", répondit-il,'
>>> phrase3 = "j'aime bien"
>>> print(phrase2), phrase3, phrase1
"Oui", répondit-il, j'aime bien les œufs durs.

print("""1, " 2", \n 3,
4""")

Résultat :

1, " 2", 
 3,
4

Les trois variables phrase1, phrase2, phrase3 sont donc des variables de type string.

Accès aux caractères individuels d'une chaîne[modifier | modifier le wikicode]

Les chaînes de caractères constituent un cas particulier d'un type de données plus général que l'on appelle des données composites. Une donnée composite est une entité qui rassemble dans une seule structure un ensemble d'entités plus simples : dans le cas d'une chaîne de caractères, par exemple, ces entités plus simples sont évidemment les caractères eux-mêmes. En fonction des circonstances, nous souhaiterons traiter la chaîne de caractères, tantôt comme un seul objet, tantôt comme une collection de caractères distincts. Un langage de programmation tel que Python doit donc être pourvu de mécanismes qui permettent d'accéder séparément à chacun des caractères d'une chaîne.

Python considère qu'une chaîne de caractères est un objet de la catégorie des séquences, lesquelles sont des collections ordonnées d'éléments. Cela signifie simplement que les caractères d'une chaîne sont toujours disposés dans un certain ordre. Par conséquent, chaque caractère de la chaîne peut être désigné par sa place dans la séquence, à l'aide d'un index.

Pour accéder à un caractère bien déterminé, on utilise le nom de la variable qui contient la chaîne, et on lui accole entre deux crochets l'index numérique qui correspond à la position du caractère dans la chaîne.

 comme vous aurez l'occasion de le vérifier par ailleurs, les données informatiques sont presque toujours numérotées à partir de zéro (et non à partir de un). C'est le cas pour les caractères d'une chaîne.

Exemple :

>>> chaine = "Stéphanie"
>>> print(chaine[0], chaine[3])
S p


Taille des chaines[modifier | modifier le wikicode]

  • Déterminer la longueur (c'est-à-dire le nombre de caractères) d'une chaîne, en faisant appel à la fonction intégrée len() :
>>> print(len(c))
29 #La chaîne de caractères 'c' contient 29 caractères !

>>> print(len('Zowerz'))
6

Sous-chaines[modifier | modifier le wikicode]

L'opérateur d'indiçage ([]) permet aussi de sélectionner des sous-chaines selon leurs indices. On appelle cette technique le slicing (« découpage en tranches »).

Dans la tranche [n,m], le nième caractère est inclus, mais pas le mième. Si vous voulez mémoriser aisément ce mécanisme, il faut vous représenter que les indices pointent des emplacements situés entre les caractères, comme dans le schéma ci-dessous :

illustration du système de numérotation des caractères

Au vu de ce schéma, il n'est pas difficile de comprendre que ch[3:7] extraira iett.

De plus, si la borne de départ est le premier caractère (indice 0) ou si celle d'arrivée est la dernière (indice égal à la longueur de la chaine), il devient facultatif. Exemple :

>>> chain = "123456789"
>>> print(chain[1:3])
23

>>> print(chain[0:-1])
12345678
>>> print(chain[:-1])
12345678

>>> print(chain[1:len(chain)])
23456789
>>> print(chain[1:])
23456789

Pour vérifier le début et la fin d'une chaine sans avoir à déterminer sur quelle longueur , on peut utiliser "startswith()" et "endswith()", mais c'est moins rapide car faisant appel à une fonction de plus haut niveau. (Référence nécessaire)

if chain.startswith('1234'):
    print('ok')
if chain.endswith('89'):
    print('ok')

Concaténation[modifier | modifier le wikicode]

L'opération d'assembler plusieurs petites chaînes pour en construire une plus grande s'appelle concaténation et on la réalise sous Python à l'aide de l'opérateur "+". Exemple :

a = 'Petit poisson'
b = ' deviendra grand'
c = a + b
print(c)
petit poisson deviendra grand

Pour convertir en nombre véritable une chaîne de caractères qui représente un nombre. Exemple :

>>> chaine = '8647'              
>>> print(chaine + 45)
   ==> *** erreur *** on ne peut pas additionner une chaîne et un nombre 

>>> print(int(chaine) + 65)
8712                         # OK : on peut additionner deux nombres

>>> print(chaine + str(65))
864765                       # OK : on peut concaténer deux chaines

Dans cet exemple, la fonction intégrée int() convertit la chaîne en nombre entier, et str() convertit l'entier en chaine.


Parcours d'une séquence : for... in...[modifier | modifier le wikicode]

Il arrive très souvent que l'on doive traiter l'intégralité d'une chaîne caractère par caractère, du premier jusqu'au dernier, pour effectuer à partir de chacun d'eux une opération quelconque. Nous appellerons cette opération un parcours. En nous limitant aux outils Python que nous connaissons déjà, nous pouvons envisager d'encoder un tel parcours sur la base de l'instruction while :

nom = 'Jacqueline'
index = 0
while index < len(nom):
    print(nom[index] + ' *'), 
    index = index + 1

Cette boucle « parcourt » donc la chaîne nom pour en extraire un à un tous les caractères, lesquels sont ensuite imprimés avec interposition d'astérisques. Notez bien que la condition utilisée avec l'instruction while est index < len(nom), ce qui signifie que le bouclage doit s'effectuer jusqu'à ce que l'on soit arrivé à l'indice numéro 9 (la chaîne compte en effet 10 caractères). Nous aurons effectivement traité tous les caractères de la chaîne, puisque ceux-ci sont indicés de zéro à 9.

Le parcours d'une séquence est une opération très fréquente en programmation. Pour en faciliter l'écriture, Python vous propose une structure de boucle plus appropriée, basée sur le couple d'instructions for ... in ... :

Avec ces instructions, le programme ci-dessus devient :

nom = 'Jacqueline'
for character in nom:
    print(character + ' *'),

Comme vous pouvez le constater, cette structure de boucle est plus compacte. Elle vous évite d'avoir à définir et à incrémenter une variable spécifique (un « compteur ») pour gérer l'indice du caractère que vous voulez traiter à chaque itération. La variable caract contiendra successivement tous les caractères de la chaîne, du premier jusqu'au dernier.

L'instruction for permet donc d'écrire des boucles, dans lesquelles l'itération traite successivement tous les éléments d'une séquence donnée. Dans l'exemple ci-dessus, la séquence était une chaîne de caractères. L'exemple ci-après démontre que l'on peut appliquer le même traitement aux listes :

liste = ['chien','chat','crocodile']
for animal in liste:
    print('longueur de la chaîne'), animal, '=', len(animal)

L'exécution de ce script donne :

longueur de la chaîne chien = 5
longueur de la chaîne chat = 4
longueur de la chaîne crocodile = 9

L'instruction for est un nouvel exemple d’instruction composée. N'oubliez donc pas le double point obligatoire à la fin de la ligne, et l'indentation du bloc d'instructions qui suit.

Le nom qui suit le mot réservé in est celui de la séquence qu'il faut traiter. Le nom qui suit le mot réservé for est celui que vous choisissez pour la variable destinée à contenir successivement tous les éléments de la séquence. Cette variable est définie automatiquement (c'est-à-dire qu'il est inutile de la définir au préalable), et son type est automatiquement adapté à celui de l'élément de la séquence qui est en cours de traitement.

Exemple :

divers = ['cheval', 3, 17.25, [5, 'Jean']]
for e in divers:
    print(e)

L'exécution de ce script donne :

cheval
3
17.25
[5, 'Jean']

Bien que les éléments de la liste divers soient tous de types différents (une chaîne de caractères, un entier, un réel, une liste), on peut affecter successivement leurs contenus à la variable e, sans qu'il s'ensuive des erreurs (ceci est rendu possible grâce au typage dynamique des variables Python).


Exercices

  1. Écrivez un script qui détermine si une chaîne contient ou non le caractère « e ».
  2. Écrivez un script qui compte le nombre d'occurrences du caractère « e » dans une chaîne.
  3. Écrivez un script qui recopie une chaîne (dans une nouvelle variable), en insérant des astérisques entre les caractères.
    Ainsi par exemple, « gaston » devra devenir « g*a*s*t*o*n »
  4. Écrivez un script qui recopie une chaîne (dans une nouvelle variable) en l'inversant.
    Ainsi par exemple, « zorglub » deviendra « bulgroz ».
  5. En partant de l'exercice précédent, écrivez un script qui détermine si une chaîne de caractères donnée est un palindrome (c'est-à-dire une chaîne qui peut se lire indifféremment dans les deux sens), comme par exemple « radar » ou « s.o.s ».

Solution

  1. # Recherche d'un caractère particulier dans une chaîne
    
    # Chaîne fournie au départ :
    chain = "Monty python flying circus"
    # Caractère à rechercher :
    letter = "e"
    # Recherche proprement dite :
    i = 0   # indice du caractère en cours d'examen
    found = False   # "drapeau" à lever si le caractère recherché est présent
    while i < len(chain):
        if chain[i] == letter:
            found = True
        i = i + 1
    
    # Affichage :
    print(u"Le caractère"), letter  # Le caractère e
    if t == 1:
        print(u"est présent")
    else:
        print(u"est introuvable")
    print(u"dans la chaîne"), chain  # dans la chaîne Monty python flying circus
    
  2. Réfléchissez !
  3. # Insertion d'un caractère d'espacement dans une chaîne
    
    # Chaîne fournie au départ :
    ch = "Gaston"
    # Caractère à insérer :
    cr = "*"
    # Le nombre de caractères à insérer est inférieur d'une unité au
    # nombre de caractères de la chaîne. On traitera donc celle-ci à
    # partir de son second caractère (en omettant le premier).
    lc = len(ch)    # nombre de caractères total
    i = 1           # indice du premier caractère à examiner (le second, en fait)
    nch = ch[0]     # nouvelle chaîne à construire (contient déjà le premier caractère)
    while i < lc:
        nch = nch + cr + ch[i]
        i = i + 1    
    # Affichage :
    print(nch)
    
  4. # Inversion d'une chaîne de caractères
    
    # Chaîne fournie au départ :
    ch = "zorglub"
    lc = len(ch)    # nombre de caractères total
    i = lc - 1      # le traitement commencera à partir du dernier caractère
    nch = ""        # nouvelle chaîne à construire (vide au départ)
    while i >= 0:
        nch = nch + ch[i]
        i = i - 1    
    # Affichage :
    print(nch)
    
  5. Réfléchissez !

Exercices

  1. Dans un conte américain, huit petits canetons s'appellent respectivement : Jack, Kack, Lack, Mack, Nack, Oack, Pack et Qack. Écrivez un script qui génère tous ces noms à partir des deux chaînes suivantes :
    • prefixes = 'JKLMNOP'
    • suffixe = 'ack'
    Si vous utilisez une instruction for... in... , votre script ne devrait comporter que deux lignes.
  2. Rechercher le nombre de mots contenus dans une phrase donnée.

Solution

  1. prefixes, suffixe = "JKLMNOP", "ack"
    
    for p in prefixes:
        print p + suffixe
    
  2.     # Comptage du nombre de mots dans "chain"
        chain = "Les petits ruisseaux font les grandes rivières"
        if len(chain) == 0:
            print(0)
        nm = 1                  # la chaîne comporte au moins un mot          
        for c in chain:
            if c == " ":        # il suffit de compter les espaces
                nm = nm + 1
        print(nm)
    

Appartenance d'un élément à une séquence : if.. in...[modifier | modifier le wikicode]

L'instruction in peut être utilisée indépendamment de for, pour vérifier si un élément donné fait partie ou non d'une séquence. Vous pouvez par exemple vous servir de in pour vérifier si tel caractère alphabétique fait partie d'un groupe bien déterminé :

car = "e"
voyelles = "aeiouyAEIOUY"
if car in voyelles:
    print car, "est une voyelle"

D'une manière similaire, vous pouvez vérifier l'appartenance d'un élément à une liste :

n = 5
nombrePremiers = [1, 2, 3, 5, 7, 11, 13, 17]
if  n in nombrePremiers:
    print n, "fait partie de notre liste de nombres premiers"

Cette instruction très puissante effectue donc à elle seule un véritable parcours de la séquence. À titre d'exercice, écrivez les instructions qui effectueraient le même travail à l'aide d'une boucle classique utilisant l'instruction while.

Exercices

  1. Écrivez un script qui affiche « vrai » si un caractère est un chiffre.
  2. Écrivez un script qui affiche « vrai » si un caractère est une majuscule.

Solution

        if character in "0123456789":
            print True
        else:
            print False
    
  1.     if character in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
            print True
        else:
            print False
    

Les chaînes sont des séquences non modifiables[modifier | modifier le wikicode]

Vous ne pouvez pas modifier le contenu d'une chaîne existante. En d'autres termes, vous ne pouvez pas utiliser l'opérateur [] dans la partie gauche d'une instruction d'affectation. Essayez par exemple d'exécuter le petit script suivant (qui cherche à remplacer une lettre dans une chaîne) :

salut = 'bonjour à tous'
salut[0] = 'B'
print salut

Au lieu d'afficher « Bonjour à tous », ce script « lève » une erreur du genre : TypeError: object doesn't support item assignment. Cette erreur est provoquée à la deuxième ligne du script. On y essaie de remplacer une lettre par une autre dans la chaîne, mais cela n'est pas permis.

Par contre, le script ci-dessous fonctionne :

salut = 'bonjour à tous'
salut = 'B' + salut[1:]
print salut

Dans cet autre exemple, en effet, nous ne modifions pas la chaîne "salut". Nous en recréons une nouvelle avec le même nom à la deuxième ligne du script (à partir d'un morceau de la précédente, soit, mais qu'importe : il s'agit bien d'une nouvelle chaîne).

Les chaînes sont comparables[modifier | modifier le wikicode]

Tous les opérateurs de comparaison dont nous avons parlé à propos des instructions de contrôle de flux (c'est-à-dire les instructions if ... elif ... else) fonctionnent aussi avec les chaînes de caractères. Cela vous sera très utile pour trier des mots par ordre alphabétique :

mot = raw_input("Entrez un mot quelconque : ")
if mot < "limonade":
    place = "précède"
elif mot > "limonade":
    place = "suit"
else:
    place = "se confond avec"
print "Le mot", mot, place, "le mot 'limonade' dans l'ordre alphabétique"

Ces comparaisons sont possibles, parce que les caractères alphabétiques qui constituent une chaîne de caractères sont mémorisés dans la mémoire de l'ordinateur sous forme de nombres binaires dont la valeur est liée à la place qu'occupe le caractère dans l'alphabet. Dans le système de codage ASCII, par exemple, A=65, B=66, C=67, etc.


Encodage[modifier | modifier le wikicode]

Pour encoder une chaine en Unicode, il faut la préfixer par la lettre "u"[1] :

>>> string = u"il était une fois"
>>> print(string)
'il était une fois'

Au sujet des chaînes de caractères, il est important de savoir que de notions différentes de chaînes de caractères existent en Python.

Pour des raisons historiques dans les versions de Python inférieures à Python 2, on considérait une chaîne de caractère comme une chaîne d'octets. Ceci permettait d'avoir un seul type pour traiter de deux notions différentes, mais pouvait parfois engendrer de la confusion sur le type traité.

  • Le type String contenait à la fois une séquence d'octet et une chaîne de caractères ASCII/UTF-8 (exemple : "Hello World").

Depuis la version 3 de Python, les types chaînes d'octet et chaîne de caractères sont clairement différenciées.

  • Le type chaîne de caractères (String) contient des caractères Unicode (exemple: 'xyzzy', "frobozz")
  • Les octets et tableaux d'octets (objets Bytes et bytearray) ne contiennent que des octets (l'un est immutable alors que l'autre est mutable). Exemple : b'xyzzy'.

Classement des caractères[modifier | modifier le wikicode]

Il est souvent utile de pouvoir déterminer si tel caractère extrait d'une chaîne est une lettre majuscule ou minuscule, ou plus généralement encore, de déterminer s'il s'agit bien d'une lettre, d'un chiffre, ou encore d'un autre caractère typographique.

Nous pouvons bien entendu écrire différentes fonctions pour assurer ces tâches. Une première possibilité consiste à utiliser l'instruction "in". Mais puisque nous savons désormais que les caractères forment une suite bien ordonnée dans le code ASCII, nous pouvons exploiter d'autres méthodes. Par exemple, pour déterminer si on a affaire à une minuscule :

    if 'a' <= character <= 'z' :
        print('bas de casse')
    else:
        print('haut de casse')

Exercices

  1. Écrivez un script qui affiche « vrai » si l'argument transmis est un chiffre (avec une autre méthode que celles exploitées précédemment)
  2. Écrivez un script qui affiche « vrai » si un caractère est une majuscule

Solution

  1.     if character >= "0" and character <= "9":
            print True
        else:
            print False
    
  2.     if character >= "A" and character <= "Z":
            print True
        else:
            print False
    

Afin que vous puissiez effectuer plus aisément toutes sortes de traitements sur les caractères, Python met à votre disposition un certain nombre de fonctions prédéfinies :

  • La fonction ord(character) accepte n'importe quel caractère comme argument. En retour, elle fournit le code ASCII correspondant à ce caractère. Ainsi ord('A') renvoie la valeur 65, et ord(u'é') 233.
  • La fonction chr(number) fait exactement le contraire. L'argument qu'on lui transmet doit être un entier compris entre 0 et 255. En retour, on obtient le caractère ASCII correspondant. Ainsi chr(65) renvoie le caractère A.

Exercices

  1. Écrivez un petit script qui affiche une table des codes ASCII. Le programme doit afficher tous les caractères en regard des codes correspondants. A partir de cette table, établissez les relations numériques reliant chaque caractère majuscule à chaque caractère minuscule.
  2. À partir des relations trouvées, écrivez un script qui convertit tous les caractères d'une phrase donnée en capitales.
  3. À partir des mêmes relations, écrivez un script qui convertit tous les caractères d'une phrase en capitales.
  4. Écrivez un script qui compte le nombre de fois qu'apparaît tel caractère (fourni en argument) dans une phrase donnée.
  5. Écrivez un script qui affiche le nombre de voyelles contenues dans une phrase donnée.

Solution

  1. # Table des codes ASCII :
    c = 32          # Premier code ASCII <imprimable>
    while c < 128 : # caractères non accentués seulement 
        print("Code"), c, ":", chr(c), "  ",
        c = c + 1
    
  2. Réfléchissez !
  3. # Convertir majuscules -> minuscules et inversement :
        # Échange les majuscules et les minuscules de "chaine"
        chain = "Ferdinand-Charles de CAMARET"
        newChain = ""                   # chaîne à construire
        for car in chain:
            code = ord(car)
            if car >= "A" and car <= "Z":
                code = code + 32
            elif car >= "a" and car <= "z":
                code = code - 32
            newChain = newChain + chr(code)
        print(newChain)
    
  4. Réfléchissez !
  5. # Comptage de voyelles :
        # Teste si car est une voyelle"
        if character in "AEIOUYaeiouy":
            print(True)
        else:
            print(False)
    
        # Compte les voyelles présentes dans la chaîne "chaine"
        n = 0
        for c in chaine:
            if voyelle(c):
                n = n + 1
        print(n)
    

Méthodes des objets string[modifier | modifier le wikicode]

Sous Python, les chaînes de caractères sont des objets. On peut donc effectuer de nombreux traitements dessus en utilisant des méthodes appropriées. En voici quelques-unes, choisies parmi les plus utiles. Mais vous pouvez obtenir la liste complète de toutes les méthodes associées à un objet à l'aide de la fonction intégrée dir() ou help(str) :

>>> dir('')
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
  • Les fonctions "str()" et "repr()" (pour représentation d'objet) permettent de transformer un objet Python quelconque en chaîne de caractères. Ces deux fonctions sont différentes : "str('chaine')" retournera 'chaine' tandis que "repr('chaine')" retournera "'chaine'".
  • index(c) : retrouve l'index de la première occurrence du caractère "c" dans la chaîne, ou déclenche une erreur si absent (ValueError: substring not found).
>>> foin = "Portez ce vieux whisky au juge blond qui fume"
>>> print foin.index("w")
16
  • find(aiguille) : cherche la position d'une sous-chaîne aiguille dans la chaîne, en partant du début.
>>> foin = "Cette leçon vaut bien un fromage, sans doute ?"
>>> aiguille = "fromage"
>>> print foin.find(aiguille)
25
  • rfind(aiguille) : pareil que "find" mais en partant de la fin (reverse).
>>> foin = "Cette leçon vaut bien deux fromages, dont un fromage râpé ?"
>>> aiguille = "fromage"
>>> print foin.rfind(aiguille)
46
  • count(aiguille) : compte le nombre de sous-chaînes aiguille dans la chaîne.
>>> foin = "Le héron au long bec emmanché d'un long cou"
>>> aiguille = 'long'
>>> print foin.count(aiguille)
2
  • lower() : convertit une chaîne en minuscules.
>>> phrase ="ATTENTION : Danger !"
>>> print phrase.lower()
attention : danger !
  • upper() : convertit une chaîne en majuscules.
>>> phrase = "Merci beaucoup"
>>> print phrase.upper()
MERCI BEAUCOUP
  • capitalize() : convertit en majuscule la première lettre d'une chaîne.
>>> phrase = "quel beau temps, aujourd'hui !"
>>> print phrase.capitalize()
"Quel beau temps, aujourd'hui !"
  • swapcase() : convertit toutes les majuscules en minuscules et vice-versa.
>>> phrase = "La CIGALE et la FOURMI"
>>> print phrase.swapcase()
lA cigale ET LA fourmi
  • strip() : enlève les espaces éventuels au début et à la fin de la chaîne (trime).
>>> phrase = "   Monty Python   "
>>> phrase.strip()
'Monty Python'
  • replace(old, new) : remplace tous les caractères old par des caractères new dans la chaîne.
>>> phrase = "Si ce n'est toi c'est donc ton frère"
>>> print phrase.replace(" ","_")
Si_ce_n'est_toi_c'est_donc_ton_frère


Dans la plupart de ces méthodes, il est possible de préciser quelle portion de la chaîne doit être traitée, en ajoutant des arguments supplémentaires.

>>> print ch9.index("e")		# cherche à partir du début de la chaîne 
4							# et trouve le premier 'e'
>>> print ch9.index("e",5)		# cherche seulement à partir de l'indice 5
8							# et trouve le second 'e'
>>> print ch9.index("e",15)		# cherche à partir du caractère n° 15
29							# et trouve le quatrième 'e'

Références[modifier | modifier le wikicode]