Aller au menu - Aller au contenu

[Plan du site] Vous êtes ici --- > Le Site du Zéro > Les tutoriels > Non-Officiels > Programmation > Python > Apprenons Python ! > Le début, la base de tout... > Les chaînes de caractères > Lecture du tutoriel

Les chaînes de caractères

Vous vous apprêtez à lire un tutoriel rédigé par un membre de ce site. Malgré tout le soin que ce membre a pu apporter au tutoriel, nous ne pouvons pas garantir que les informations contenues sur cette page sont exactes à 100%. Merci de garder cela en tête lorsque vous lirez cette page ;o)
Auteurs : Communauté Pythonienne, iPoulet et Pmol
Note : 19 / 20 (8 votes)
Visualisations : 32 983

Plus d'informations Plus d'informations
Jusqu'à maintenant, nous avons manipulé des nombres (entiers, ou à virgule).
C'est un bon début, mais il existe d'autres types de données avec lesquels nous devons nous familiariser. ;)

Parmi eux, il y'a les chaînes de caractères. Dans ce nom plus ou moins barbare, on reconnaît le mot "caractère" : c'est désormais à des lettres que nous allons avoir affaire. Comme ce ne sont pas des nombres, il va nous falloir apprendre plusieurs nouvelles choses. Le mot "chaîne", lui, signifie que l'on traite un ensemble de lettres, et plus une seule.
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant

Introduction et révisions

Tout d'abord, il faut savoir que dans une chaîne de caractères, vous pouvez tout stocker, tant que l'encodage le permet. L'encodage, c'est la façon dont la machine se représente les caractères. Vous savez en effet que les ordinateurs ne sont capables de traiter que des nombres ; l'encodage est la règle qui leur permet de convertir leur nombre dans nos symboles. Voici une petite annexe sur l'encodage ;) .

Si vous pouvez vraiment tout mettre, en revanche, il ne faut pas vous attendre à ce que Python comprenne ce qu'il y'a marqué : si vous avez écrit un nombre dans une chaîne, Python identifiera la chaîne, mais pas le nombre contenu dans la chaîne. C'est un peu comme si vous écriviez quelque chose sur une feuille un lundi, que vous rajoutiez quelque chose un mardi sans marquer de séparation, et qu'après vous ne sachiez plus séparer les deux jours le mercredi. Ainsi, Python ne pourra pas compter avec des nombres contenus dans des chaînes de caractères - il faudra les en extraire (ce qui n'est pas si difficile)

Vous savez déjà utiliser des chaînes dans vos programmes : il suffit d'entourer du texte avec les guillemets. Par exemple, dans
Code : Python
1
print "Salut les gens !"

Python peut distinguer le code du texte, car le texte est entre guillemets.

On peut créer des variables à volonté de la même façon :
Code : Python
1
2
maChaine = "Salut les gens !"
print maChaine


Vous comprenez ici que Python va d'abord analyser la ligne entière, et "calculer" la chaîne (il va créer un objet chaîne en mémoire. Je ne détaille pas le procédé, qui est intéressant passionant, mais incompréhensible pour nous, humbles débutants :D ) et va tout de suite la rattacher à une nouvelle variable nommée maChaine. Ensuite, nous pouvons l'afficher tout simplement.

Manipulation des chaînes

Autant que je vous le dise tout de suite, les chaînes sont extrèmement utilisées. La preuve, combien de programmes que vous possédez n'affiche jamais de caractères :p ? Pour cette raison, Python possède énormément de matériel pour les traiter - nous ne pouvons tout voir en une fois. Commençons par la base : comment lire du texte entré par l'utilisateur ?

Vous connaissez déjà la fonction input qui permet à l'utilisateur d'entrer des nombres. Hé bien en fait, la fonction input accepte toutes les entrées. Depuis la ligne de commande Python, nous allons faire des tests :
Code : Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
>>> print input("Entrez quelque chose : ")
Entrez quelque chose : 5
5 
>>> print input("Entrez quelque chose : ")
Entrez quelque chose : 14.3
14.3 
>>> print input("Entrez quelque chose : ")
Entrez quelque chose : 47+5
52 
>>> print input("Entrez quelque chose : ")
Entrez quelque chose : Une chaine sans guilleemets !
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<string>", line 1
    Une chaine sans guilleemets !
             ^
SyntaxError: invalid syntax
>>> print input("Entrez quelque chose : ")
Entrez quelque chose : "Une chaine avec des guillemets"
Une chaine avec des guillemets

Hé oui, input permet d'entrer de vraies expression en Python ! :o
Cela pose deux problèmes :

Nous allons voir la fonction raw_input qui, elle, sert exclusivement à lire du texte, et est à 100% fiable. Vous pouvez déjà l'utiliser comme input. Voici un programme exemple :
Code : Python
1
2
3
print "Bonjour ! Quel est ton nom ?"
nom = raw_input()
print "Ah ! tu t'appelles", nom

Vous voyez, les chaînes de caractères sont, pour des opérations basiques, identiques aux nombres pour ce qui est de leur manipulation. Notez qu'on peut, comme toujours, composer les instructions :
Code : Python
1
2
print "Bonjour ! Quel est ton nom ?"
print "Ah ! tu t'appelles", raw_input()

Et on fait ainsi l'économie d'une variable.

Et pour l'addition des chaînes, alors ?


Comme nous l'avons vaguement dit, il est possible d'additionner deux chaînes. :)
Mais ça n'a pas le même sens que pour les nombres, naturellement. En fait, on appelle ça une "concaténation", et c'est en réalité une fusion de deux chaînes. Dans certains langages (Caml par exemple) elles se font à l'aide d'un opérateur particulier. Dans d'autres, c'est carrément une fonction qui le fait. En Python, grâce à un mécanisme que nous verrons beaucoup plus tard (nommé "surcharge des opérateurs"), cela se fait tout simplement avec l'opérateur '+'. Petite démonstration :
Code : Python
1
2
3
nom = raw_input()
message = "Bonjour " + nom
print message

Les deux chaînes ont été correctement ajoutées l'une à l'autre :) Cet exemple est peu utile, car on aurait aussi bien fait avec une virgule, dans print. Mais dans le futur, il faudra vous habituer à utiliser cet opérateur.

Il y'a un autre opérateur utilisable, cette fois-ci avec une chaîne et un entier. Il s'agit de la répétition, utilisant le '*'. Regardez le programme suivant, qui vous fera récapituler au passage :
Code : Python
1
2
3
4
5
6
print "Ce programme est très poli. Combien de fois va-t'il dire bonjour ?"
nombre = input()
if nombre > 0:
   print "Bonjour ! " * nombre
else:
   print "Vous ne voulez pas être salué ? Ok"

Notez que pour les nombres, on peut continuer à utiliser input, en priant pour que l'utilisateur ne fasse pas de bêtise (sans quoi le programme se terminerait immédiatement sur une erreur, ou partirait sur un autre code). Mais si vous avez peur et que vous souhaitez empêcher tout détournement, il y'a toujours moyen de récuperer une chaîne fiable avec raw_input, et de la convertir en nombre, avec une nouvelle fonction nommée int, qui prend une chaîne ou un nombre en argument, et renvoie un nombre. Ainsi, notre programme devient
Code : Python
1
2
3
4
5
6
7
print "Ce programme est très poli. Combien de fois va-t'il dire bonjour ?"
chaine = raw_input()
nombre = int(chaine)      # On transforme chaine en entier si possible
if nombre > 0:
   print "Bonjour ! " * nombre
else:
   print "Vous ne voulez pas être salué ? Ok"

Ou encore plus simplement
Code : Python
1
2
3
4
5
6
print "Ce programme est très poli. Combien de fois va-t'il dire bonjour ?"
nombre = int(raw_input())
if nombre > 0:
   print "Bonjour ! " * nombre
else:
   print "Vous ne voulez pas être salué ? Ok"

Observez bien la deuxième ligne : Python va l'analyser, et repérer l'appel de la fonction raw_input *dans* les arguments de la fonction int. Cela veut dire "Appelle raw_input et passe le résultat en argument à int". Souvenez vous du schéma avec input, dans le chapitre des boucles... Ici, on peut doubler le schéma, en mettant une flêche qui indique le résultat de raw_input, et qui va directement dans les arguments de int.

Puis le résultat final (notre entier) est stocké dans la variable nombre ;)

Hélas si l'utilisateur rentre une bêtise, nous ne pouvons toujours pas la contrôller pour l'instant, et empêcher un plantage. Mais au moins, l'utilisateur rentrera son nombre, ou n'utilisera pas le programme :D

Notez l'existence de la fonction inverse, str, qui elle transforme une donnée en chaîne, ainsi que de la fonction float, qui ne produit pas un entier mais un nombre à virgule.

Les chaînes sont divisibles

Comme dans beaucoup de langages, les chaînes de caractères peuvent être considérés comme ce qu'on appelle des tableaux. C'est à dire qu'on peut schématiser la chaîne en tableau de deux colonnes, l'une contenant des nombres augmentant de 1 à chaque ligne appelés "indexes", l'autre contenant les caractères. Vous l'aurez peut-être deviné, les nombres servent à repérer les caractères. Voici un petit schéma de la chaîne "Bonjour !" :
Image utilisateur
Comme vous voyez, on peut associer à chaque caractère un index, en partant de 0 pour le premier. Et alors, il devient possible de demander à Python d'extraire certains caractères, en utilisant une syntaxe un peu particulière :
Citation :
maChaine[i : int] -> renvoie le caractère numéro i

Ceci ne veut pas dire que le nombre entre crochet est une variable int nommée i, hein ;)


C'est simplement une façon de noter qu'entre les crochets on doit trouver un nombre entier, ou un calcul dont le résultat est un entier (comme nous le verrons plus tard).

Par exemple, avec le programme suivant
Code : Python
1
2
3
print "Entrez votre nom s'il vous plaît"
nom = raw_input()
print "Votre nom commence par un", nom[0]

Arrivé à la troisième ligne, Python prend le premier caractère du nom (le caractère n°0, donc celui qui se trouve au début), et le donne à print pour qu'il soit affiché. Toutefois, ce programme est susceptible de ne pas fonctionner : si l'utilisateur appuie directement sur entrée, on obtiendra une chaîne particulière, qui est dite "vide" (car elle ne contient rien :p ).

Alors, lorsque Python essaiera de prendre le premier caractère du nom :

Code : Python
1
2
3
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
IndexError: string index out of range

Ce qui veut dire que vous avez cherché votre caractère trop loin, car l'index était supérieur à la taille de la chaîne - donc que vous avez demandé un numéro qui n'existait pas. Il nous faudrait donc être capables de mesurer la chaîne, et de signaler à l'utilisateur qu'il utilise mal le programme si jamais la chaîne est vide.

Python met à disposition la fonction len, qui mesure une chaîne (ou d'autres éléments, encore une fois on attendra d'en savoir un peu plus ^^ ) que l'on passe en argument, et qui renvoie la longueur mesurée. Plus clairement, entre parenthèses vous mettez la chaîne, et len calculera la taille, en comptant le nombre de caractères, que vous pourrez utiliser directement de l'endroit où vous appelez len, ou après avoir stocké la longueur dans une variable.

Citation :
len(maChaine : str) -> taille : entier

Cette notation signifie que lorsqu'on lui passe une chaîne (de type "str"), len renvoie sa taille.

Nous pouvons ensuite vérifier que la taille n'est pas égale à 0 avec une condition. Nouvelle version :
Code : Python
1
2
3
4
5
6
print "Entrez votre nom s'il vous plaît"
nom = raw_input()
if len(nom) > 0:     # Si la longueur du nom est supérieure à 0 (c'est tout à fait lisible non ?)
   print "Votre nom commence par un", nom[0]
else:
   print "Vous préférez l'anonymat ?"

On peut même l'enrichir :
Code : Python
1
2
3
4
5
6
7
print "Entrez votre nom s'il vous plaît"
nom = raw_input()
longueur = len(nom)
if longueur > 0:
   print "Votre nom commence par un", nom[0], "et mesure", longueur, "caractères !"
else:
   print "Vous préférez l'anonymat ?"

Notez que dans le programme précédent, nous n'avions pas créé de variable longueur, mais directement utilisé len(nom) là où nous en avions besoin. Ici, nous utilisons deux fois la longueur : il est donc préférable de ne pas écrire deux fois le même appel de fonction, mais plutôt de stocker la longueur dans une variable si elle doit être réutilisée.

len va trop loin !

Il est possible d'utiliser n'importe quel index tant qu'il ne dépasse pas la taille de la chaîne, et cette taille est donnée par len. Toutefois, regardons quelque chose à la ligne de commande :
Code : Python
1
2
3
4
5
>>> maChaine = "bonjour" 
>>> len(maChaine)
7
>>> maChaine[6]
'r'


Vous l'aurez compris (déjà rien qu'au titre :p ), len donne la taille de la chaîne en commençant à 1 (puisque 0 n'est donné que si la chaîne est vide). Dans cet exemple, "bonjour", fait 7 caractères de long. Faites attention à cela, c'est bête mais c'est méchant ^^

Par exemple, si nous avions voulu accéder au caractère qui se trouve au milieu de la chaîne, on aurait pu penser que son index était égal à la longueur de la chaîne divisé par 2 (la moitié quoi). Hors si on prend une chaîne de longueur 6, le caractère qui se trouve au milieu est le troisième - c'est à dire celui dont l'index est 2 (car l'index commence à 0).

Donc nous aurions du :

Ça n'est pas évident à retenir, regardez ce qui suit :
Code : Python
1
2
3
4
5
6
7
8
9
chaine1 = "bonbon"    # Test avec un nombre pair de caractères
chaine2 = "bonjour"    # Test avec un nombre impair de caractères
long1 = len(chaine1)
long2 = len(chaine2)
index1 = (long1 - 1)/2
index2 = (long2 - 1)/2
car1 = chaine1[index1]
car2 = chaine2[index2]
print "Voici les caractères qui se situent aux milieux des deux chaînes :", car1, "et", car2

Vous devriez vraiment comprendre cela avant de passer à la suite (même si c'est beaucoup moins compliqué après, pas de panique ! :D ), quitte à faire une pause dans le chapitre (après tout, nous avons déjà vu plein de choses). Ici, il y'a deux chaînes dont nous trouvons les deux milieux selon le procédé qui se trouve au dessus.

Il y'a moyen de sensiblement diminuer le nombre de lignes de code. En effet, le nombre entre les crochets à côté de chaine1 et chaine2 est obtenu à partir d'une variable. Mais nous ne sommes pas obligés de calculer l'index du caractère en milieu de chaîne à l'extérieur de ces crochets - en d'autres termes, le code qui correspond à notre calcul peut être écrit de façon plus courte car il utiliserait alors moins de variables :
Code : Python
1
2
3
4
5
6
7
chaine1 = "bonbon"    # Test avec un nombre pair de caractères
chaine2 = "bonjour"    # Test avec un nombre impair de caractères
long1 = len(chaine1)
long2 = len(chaine2)
car1 = chaine1[(long1 - 1)/2]
car2 = chaine2[(long2 - 1)/2]
print "Voici les caractères qui se situent aux milieux des deux chaînes :", car1, "et", car2

On vient de supprimer une étape, en diminuant la taille du code - mais en perdant en lisibilité. Bien sûr, vous pouvez maintenant remplacer long1 et long2 par len(chaine1) et len(chaine2) directement entre les crochets, et même ne pas passer par les variables car1 et car2 :
Code : Python
1
2
3
chaine1 = "bonbon"    # Test avec un nombre pair de caractères
chaine2 = "bonjour"    # Test avec un nombre impair de caractères
print "Voici les caractères qui se situent aux milieux des deux chaînes :", chaine1[(len(chaine1) - 1)/2], "et", chaine2[(len(chaine2) - 1)/2]

Notre code devient tout simplement illisible :-°

Mais savoir écrire des expressions de cette complexité est important, car cela montre que vous comprenez bien ce qui se passe (le tout est de savoir ce qui est lu par Python en premier, puis ce que cela donne, etc...). Trop de déclarations de variables alourdissent le code, prenez-en bonne note ;)

Utiliser while pour parcourir une chaîne

Comme nous avons appris à faire des boucles équipées de compteurs, nous pouvons les utiliser pour parcourir une chaîne.
Parcourir ?

Oui parcourir une chaîne. C'est-à-dire passer par chaque caractère de la chaîne. Petit exemple :
Code : Python
1
2
3
4
5
6
maChaine = "Salut !"
compteur = 0
longueurChaine = len(maChaine) # Combien de caracteres dans la chaine ?
while compteur < longueurChaine:
    print maChaine[compteur]
    compteur = compteur + 1

Simple non ? On crée une chaîne (maChaine) et un compteur (compteur), ainsi qu'une variable qui va contenir la longueur de la chaîne (longueurChaine). On va afficher le caractère dont le numéro correspond au compteur jusqu'a ce que compteur soit égal à longueurChaine. A ce moment, la condition n'est plus vérifiée, et on sort de la boucle. En effet, si on écrit

Code : Python
1
maChaine[compteur]


alors que compteur est égal à longueurChaine, on dépasse de la chaîne, comme nous venons de le voir.

Nous allons créer un programme qui reprend la forme du précédent, mais qui, au lieu d'afficher les caractères un par un (ce qui est peu intéressant) compte le nombre d'apparitions d'un certain caractère. Comment faire pour cela ? Il suffit de parcourir la chaîne caractère après caractère, et de tester s'ils sont égaux à celui que l'on cherche. Encore une fois, en Python, cela se fait plus simplement que dans d'autres langages, puisque dans certains les comparaisons avec les chaînes sont difficiles à mettre en oeuvre : ici, un == suffit ;)

Pour compter le nombre de fois où on trouve le caractère recherché, on utilisera la variable nombreCar.
Code : Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
maChaine = "Les chaussettes de l'archi-duchesse sont-elles seches et archiseches"
car = "e"
compteur = 0
nombreCar = 0
longueurChaine = len(maChaine)
while compteur < longueurChaine:
   if maChaine[compteur] == car:     # Si on a bien trouvé le caractère cherché
       nombreCar += 1
   compteur += 1
print "On a trouvé", nombreCar,"fois le caractère",car

Si vous êtes observateur, vous avez découvert une nouveauté : le +=. Que signifie-t'il ?

Hé bien c'est simplement une forme condensée de = et +, pour éviter d'écrire nombreCar = nombreCar + 1. Cela revient strictement au même, vous pouvez utiliser celui que vous préférez. Il existe naturellement aussi des opérateurs -=, *=, /= et %= :)

Notre programme va donc parcourir la chaîne, et ajouter 1 à nombreCar à chaque fois qu'il trouvera le caractère recherché.

Vous voici un peu plus au point sur les chaînes. Il vous reste encore plein de notions à apprendre, mais nous les verrons plus tard. Les chaînes sont omniprésentes : il faut savoir les utiliser en Python, d'autant plus que ce langage nous donne plein d'outils pour leur manipulation.

Ce qu'il faut retenir !

Quelques exercices !



Certains de ces programmes ne sont pas faciles à réaliser, n'hésitez pas à demander de l'aide sur le forum, sur IRC ou à des amis. Vous pouvez aussi envoyer un MP aux rédacteurs du cours, mais attention ! Certains peuvent partir en vacances ;) De plus, l'aide qu'on vous donne sur un forum peut être réutilisée, pas celle qui passe par MP.

Correction !

Nous corrigeons ici le troisième exercice, à mon avis le plus compliqué. Si vous n'avez pas réussi, dites vous simplement que vous n'avez pas encore l'habitude ;)

Secret (cliquez pour afficher)
D'abord, laissez moi vous dire que tout cela tient vraiment de l'entraînement, car une fonction produisant un effet comparable existe déjà (pour les connaisseurs, c'est une méthode des chaînes). Il est très utile de savoir coder ce qui existe déjà, parce que ça apprend plein de choses :)

Ensuite, le fonctionnement : il suffisait de parcourir la chaîne à la recherche des #, qui délimitent les sous-chaînes. Donc, analyser les caractères un par un était une bonne stratégie : si le caractère n'est pas un #, il suffit de le stocker.

Où ça ? Dans une variable temporaire, c'est à dire une variable dans laquelle le programme stocke ce sur quoi il est en train de travailler. A chaque caractère, on va reprendre la variable, et la concaténer avec le caractère en question, jusqu'au #, où on affichera le morceau découpé. Petit exemple de ce que ça donnerait pour la chaîne "test#retest":

Début de la boucle : varTempo = ""
Tour de boucle n°1 : varTempo = "" + "t"
Tour de boucle n°2 : varTempo = "t" + "e"
Tour de boucle n°3 : varTempo = "te" + "s"
Tour de boucle n°4 : varTempo = "tes" + "t"
Tour de boucle n°5 : varTempo = "test" Ici on rencontre un #, donc on affiche la chaîne et on vide la variable
Tour de boucle n°6 : varTempo = "" + "r" Puis on fait de même avec le morceau suivant
etc...

Code : Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#!/usr/bin/python

maChaine = "poisson#courge#salade#"
long = len(maChaine)
compteur = 0
chaineTemporaire = ""

while compteur < long:
    car = maChaine[compteur]  # On stocke le caractère courant
    if car == "#":
        print chaineTemporaire
        chaineTemporaire = ""
    else:
        chaineTemporaire += car  # On ajoute le caractère courant à la chaine
    compteur += 1


Ce code n'est pas parfait, loin de là. Notamment, si la chaîne ne finit pas par un #, il n'affiche pas la dernière chaîne relevée. De plus, si on trouve deux # à la suite ou un au début, ce sont des print de lignes vide qui seront faits.

Améliorez le ;)

Q.C.M.

Quel type de caractères pouvons nous stocker dans une chaîne ?
La fonction pour lire une chaîne de caractères entrée au clavier s'appelle...
Comment récuperer un nombre stocké dans une chaîne ?
Quelle expression ci-dessous est utilisable pour obtenir le dernier caractère d'une chaîne ?

Statistiques de réponses au QCM

Vous voici un peu plus au point sur les chaînes. Il vous reste encore plein de notions à apprendre, mais nous les verrons plus tard. Les chaînes sont omniprésentes : il faut savoir les utiliser en Python, d'autant plus que ce langage nous donne plein d'outils pour leur manipulation. :)

Ce chapitre était compliqué - peut-être même que c'est le pire de la partie 1. Il présente des bases auxquelles nous ne pouvons échapper, mais qui seront réutilisées par la suite. Il vous faudra sans doute revenir dessus en cas de pépin ;)
Chapitre précédent Sommaire Chapitre suivant
Retour en haut Retour en haut


Créé : le 02/07/2006 à 19:20:11
Modifié : le 22/08/2008 à 15:53:37
Avancement : 85%
Licence : Copie non autorisée

Changer de design | En savoir plus | Plan du site | Politique d'accessibilité | Règles | RSS tutoriels | RSS news
Édité par Simple IT SARL : Nous contacter | Notre blog | Revue de presse | Publicité

Y'a plus rien à lire, faut remonter maintenant !

Hébergement web - Correction de tutoriels - Créer un site
Vous souhaitez apparaître ici ? Contactez-nous.

Nombre de connectés 330 Zéros connectés | Requêtes SQL 8 requêtes | Temps de génération de la page : Total (SQL) 0.5211s (0.5056s)