Les chaînes de caractères

Avec les nombres et les listes, les chaines de caractères sont les éléments informatiques qu'on utilise le plus couramment. Ce sont tout simplement des objets qui représentent du texte. Elles sont entre guillemets (ou apostrophes).

    >>>a="Ceci est une chaine de caractères"

    >>>b="1+1"

    >>>c=1+1

Ainsi, a et b sont des chaines de caractères alors que c est un entier qui vaut 2.

Il y a énormément d'action possible sur les chaines de caractères, nous allons voir les principales.

1. Les actions de base
   • str(objet) : Transforme (quand c'est possible) l'objet en texte pour pouvoir l'afficher par exemple.
     • >>>c=1+1
     • >>>str(c)
     • "2"
     • Dans c il y a le résultat du calcul. str(c) transforme ce résultat en chaine de caractère contenant ce résultat.
   • len(texte) : Donne la longueur d'un texte.
     • >>>len("abc def")
     • 7
   • texte[n] : Affiche le n-ième terme du texte. Attention : la première lettre commence à l'indice 0 !
     • Petite astuce : Si on veut commencer par la fin : texte[-1] est la dernière lettre, texte[-2] l'avant dernière etc.
       • >>>"Alea jacta est"[0]
       • 'A'
       • >>>"Alea jacta est"[5]
       • 'j'
       • >>>"Alea jacta est"[-1]
       • 't'
   • texte[debut : fin] : Affiche les caractères de texte compris entre l'indice debut et l'indice fin-1.
     • Attention ici aux pièges : la première lettre correspond toujours à l'indice 0 et on ne prend pas la lettre d'indice fin.
     • Astuce : Si on veut commencer du début du texte, on met juste texte[:fin]. De même si on veut aller jusqu'au dernier caractère, on mettra texte[debut : ].
       • >>>"Alea jacta est"[5:10]
       • 'jacta'
       • >>>"Alea jacta est"[:4]
       • 'Alea'
       • >>>"Alea jacta est"[5:]
       • 'jacta est'
   • texte1+texte2 : Concatène les deux textes c'est à dire les met bout à bout.
     • >>>texte1="Vive"
     • >>>texte2="Les Mathématiques"
     • >>>texte1+texte2
     • 'ViveLes Mathématiques'
     • On peut bien sûr enchainer les concaténations : texte1+texte2+texte3+...
   • texte*k : Crée une chaine de caractère dans laquelle on répète le texte k fois d'affilée.
     • >>>texte = "Monsieur, j'ai pas compris ! "
     • >>>texte*5
     • "Monsieur, j'ai pas compris ! Monsieur, j'ai pas compris ! Monsieur, j'ai pas compris ! Monsieur, j'ai pas compris ! Monsieur, j'ai pas compris ! "
   • sous_texte in texte : Renvoie True si la chaine de caractère sous_texte est dans texte et False sinon.
     • A utiliser par exemple comme condition avec if par exemple.
       • if lettre in "aeiouy":
         • print(lettre + " est une voyelle")
       • else :
         • print(lettre + " n'est pas une voyelle")
     • Ce code permettrait par exemple de vérifier si la variable lettre est une voyelle ou pas.
   • for caractere in texte : Nous permet de créer une boucle en énumérant les lettres de texte.
     • Par exemple si je veux afficher les chiffres d'un texte :
       • >>> texte="Quatre bonbons à 0,25 euro chacun coûtent un euro"
       • >>> for car in texte:
       • >>> if car in "0123456789":
       • >>> print(car)
       • 0
       • 2
       • 5
     • Quelques explications : La boucle for va prendre le premier caractère du texte et le placer dans la variable car c'est à dire que car = 'Q'. Ensuite on teste si car fait partie des chiffres. Comme ce n'est pas le cas, et qu'il n'y a rien à faire dans ce cas, on revient à la boucle for avec la deuxième lettre cette fois et on recommence jusqu'au caractère "0" qui faire partie des chiffres donc on l'affiche etc.
   • Comparaisons de chaines de caractères : On peut comparer, comme pour les nombres, des chaines de caractères.
     • Le résultat de la comparaison est True ou False et peuvent donc s'utiliser comme condition avec if .
     • Voici les différentes comparaisons possibles :
       • texte1 == texte2 : Renvoie True si les deux textes sont parfaitement identiques.
       • texte1 != texte2 : Renvoie True si les deux textes ont au moins un caractère de différent.
       • texte1 < texte2 : Renvoie True si le texte1 est strictement avant texte2 dans l'ordre lexicographique (l'ordre du dictionnaire).
       • texte1 <= texte2 : Comme < mais les deux textes peuvent être les mêmes.
       • texte1 > texte2 : Renvoie True si le texte1 est strictement après texte2 dans l'ordre lexicographique (l'ordre du dictionnaire).
       • texte1 >= texte2 : Comme < mais les deux textes peuvent être les mêmes.
       • Pour ranger dans l'ordre lexicographique, on compare les deux premiers caractères de chaque texte. S'ils sont égaux, on compare le second etc.
       • Par exemple : "azerty"<"azfa" car les premiers termes de chaque chaines sont égaux. De même pour le second. Pour le troisième, comme "e"<"f", on a "azerty"<"azfa". (On ne regarde même pas la suite).
       • Ça fonctionne aussi pour les nombres : "1234"<"2". En effet, on les compare comme des chaines de caractères et non comme des nombres. On regarde le premier caractère : "1"<"2" donc "1234"<"2".
       • Pour être plus précis, pour comparer deux caractères, on compare en fait leur code ASCII (voir plus loin). Donc on a "1" < "A" < "_" < "a" par exemple.
2. Fonctions plus spécifiques aux chaines de caractères
   1. Ce sont des fonctions que l'on applique à une chaine de caractères et qui donc devront se mettre après la chaine de caractère à laquelle on l'applique en mettant un point entre.
   • .find(sous_chaine) : Donne l'indice où se trouve pour la première fois sous_chaine.
     • >>> texte="J'ai posé ma brosse sur le bureau"
     • >>> texte.find("brosse")
     • 13
     • >>> texte.find("o")
     • 6
     • On fera bien attention au fait que les indices commencent à 0 ! Le 'b' de brosse étant le 14e caractère, son indice est donc 13.
     • Pour le deuxième exemple, on voit que le "o" de brosse n'est pas pris en compte. La fonction find ne renvoie que l'indice du premier "o" qu'il rencontre.
   • .count(sous_chaine) : Donne le nombre de fois où sous_chaine se trouve dans la chaine à qui l'on applique la fonction.
     • >>> texte="J'ai posé ma brosse sur le bureau"
     • >>> texte.count("os")
     • 2
     • >>> texte.count("e")
     • 3
     • Il y a 2 fois "os" dans texte et 3 "e". On remarquera que "é" n'est pas compté comme un "e".
   • .replace(sous_chaine1, sous_chaine2) : Remplace toutes les sous_chaine1 par les sous_chaine2.
     • >>> texte= "Une foncttttion ttttrès prattttique si vous répéttttez ttttrop les tttt"
     • >>> texte.replace("tttt","t")
     • 'Une fonction très pratique si vous répétez trop les t'
   • .lower(), .upper() : La première permet de mettre tout le texte en minuscule et la deuxième en majuscule.
     • Pas les plus utiles mais elles dépannent car pour Python, "e" est différent de "E". donc pour chercher les voyelles par exemple, il est plus simple de mettre d'abord tous le texte en minuscule sinon il faudra chercher parmi "aeiouyAEIOUY".
3. Pour aller un peu plus loin
   1. On va voir dans les exercices des problèmes de codage. Ce sont des problèmes classiques en programmation et pour cela, on a besoin de décaler des caractères par exemple ou de les mélanger. Il serait possible (mais forcément très long) d'expliquer ce que l'on fait pour chaque caractère et à chaque fois mais il existe une table 'universelle' qui associe à chaque caractère un numéro. C'est ce qu'on appelle la norme ASCII. On peut retrouver des explications et le tableau récapitulatif des correspondances ici par exemple : Wikipédia : Norme ASCII
   2. Dans cette table, le "a" correspond au numéro 97, le "A" au numéro 65...
   3. Il existe des fonctions en Python qui permettent de passer des caractères aux numéros correspondants :
      • ord(caractere) : Donne le code ASCII du caractère.
        • >>> ord("a")
        • 97
        • >>> ord("#")
        • 35
      • chr(numero) : Donne le caractère correspondant au code ASCII
        • >>> chr(65)
        • 'A'
        • >>> chr(35)
        • '#'
        • Exemple d'utilisation : Je veux transformer un caractère en son suivant.
          • >>>car="e"
          • >>>numero=ord(car)
          • >>>nouveau_car=chr(numero+1)
          • >>>print(nouveau_car)
          • f
          • J'explique un peu : On place "e" dans la variable car. On récupère son code ASCII et on le met dans la variable numero. On récupère le caractère suivant c'est à dire correspondant au code ASCII numero+1. Et on affiche le caractère obtenu.
          • Bien sûr cet exemple utilise beaucoup trop de variables mais c'est pour détailler. On pourrait mettre directement print(chr(ord(car)+1)) mais c'est moins clair... Et petite question pour finir cette partie : Qu'obtiendrait-on si on prenait car = "z" ?
4. Complément : Le formatage
   1. Cette partie est très facultative. Elle intéressera ceux qui veulent approfondir leurs connaissances en programmation.
   2. Le but de cette partie est de faire une présentation de la fonction format des chaines de caractères. Il existe ce que l'on appelle les expressions régulières qui permettent de vérifier ou rechercher un certain formatage dans un texte (comme par exemple vérifier si le format d'un numéro de téléphone ou d'une adresse mail ou d'un numéro de carte bleue est valide) mais nous n'allons pas en parler ici.
   3. Le formatage avec format s'applique comme un texte à trous que l'on complète avec des données que l'on peut formater
   4. Prenons l'exemple de 3 variables dont on veut afficher les valeurs dans un texte :
      1. >>> a=0.5
      2. >>> b=2
      3. >>> c=1/3
      4. >>> "Dans b il y a la valeur {1}, dans a il y a la valeur {0} et dans c la valeur {2}".format(a,b,c)
      5. 'Dans b il y a la valeur 2, dans a il y a la valeur 0.5 et dans c la valeur 0.3333333333333333'
   5. La fonction format va remplacer les accolades par les variables en respectant l'ordre : {0} sera remplacée par la valeur de la première variable donnée (ici a), {1} par b et {2} par c. Déjà on peut voir un intérêt pratique à la fonction car sinon pour obtenir le même résultat à la main, il aurait fallu écrire :
      1. "Dans b il y a la valeur "+str(b)+" , dans a il y a la valeur "+str(a)+ " et dans c la valeur "+str(c)
   6. Imaginez s'il y a 15 variables à insérer dans un texte dont certaines apparaissent plusieurs fois et ont un nom long à taper...
   7. Mais format permet en plus de formater ce que l'ont veut afficher. Par exemple si je veux afficher un nombre arrondi à deux chiffres significatifs après la virgule il suffit de rajouter :.2g dans les accolades concernées. Voici ce que cela donne :
      1. >>> "Dans b il y a la valeur {1:.2g}, dans a il y a la valeur {0:.2g} et dans c la valeur {2:.2g}".format(a,b,c)
      2. 'Dans b il y a la valeur 2, dans a il y a la valeur 0.5 et dans c la valeur 0.33'
   8. Si par hasard on veut arrondir à deux chiffres après la virgule en gardant les 0 inutiles comme pour les prix par exemple, on utilise de la même façon :.2f.
      1. >>> "Dans b il y a la valeur {1:.2f}, dans a il y a la valeur {0:.2f} et dans c la valeur {2:.2f}".format(a,b,c)
      2. 'Dans b il y a la valeur 2.00, dans a il y a la valeur 0.50 et dans c la valeur 0.33'
   9. Voici pour cette initiation à la fonction format. Si on veut aller plus loin (formatage de dates, personnalisés...), internet regorge d'information !
5. Exercices
   1. Pour les exercices c'est ici : Lien vers les exercices.