| Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente |
| python:bases:chaines [2021/07/24 08:32] – [Pour aller plus loin] phil | python:bases:chaines [2022/10/10 08:05] (Version actuelle) – phil |
|---|
| | [[python:bases:listes|{{ :suivant.png?nolink&30|Listes}}]] |
| | [[:python:bases:sequences|{{ :retour.png?nolink&30|Généralités}}]] |
| | [[:python:accueilpython|{{ :iconemaison.jpg?nolink&30|Sommaire Python et microPython}}]] |
| |
| | ===== Python - Chaînes de caractères ===== |
| | |
| | [Mise à jour le : 10/10/2022] |
| | |
| | * **Sources** |
| | * **Documentation** sur Python.org : <html><a href="https://docs.python.org/fr/3.6/reference/index.html" target="_blank">référence du langage</a>, <a href="https://docs.python.org/fr/3.7/library/string.html#" target="_blank">opérations usuelles sur les chaînes</a>, <a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">fonctions natives</a></html> (built-in) |
| | |
| | * **Lectures connexes** |
| | * **Real Python** |
| | * <html><a href="https://realpython.com/python-data-types/" target="_blank">Basic Data Types in Python</a></html> |
| | * <html><a href="https://realpython.com/python-strings/" target="_blank">Strings and Character Data in Python</a></html> |
| | * <html><a href="https://realpython.com/python-string-formatting/" target="_blank">Python String Formatting Best Practices</a></html> |
| | * <html><a href="https://realpython.com/convert-python-string-to-int/" target="_blank">How to Convert a Python String to int</a></html> |
| | * <html><a href="https://realpython.com/python-sort/" target="_blank">How to Use sorted() and sort() in Python</a></html> |
| | |
| | * ** Mots-clés** : collection, séquence, indexation, insertion, concaténation, formatage, accès, parcours, sélection. |
| | |
| | <callout type="warning" icon="true">Les mots ci-dessous sont dits "réservés". Ils ne peuvent pas être utilisés comme nom de variable. Les mots __soulignés__ sont une nouveauté de Python 3. Les mots en **gras** sont utilisés dans cette page.</callout> |
| | |
| | | and | continue | finally | is | raise | |
| | | as | def | **for** | lambda | return | |
| | | assert | del | from | __None__ | __True__ | |
| | | __async__ | elif | global | __nonlocal__ | try | |
| | | __await__ | else | if | not | **while** | |
| | | break | except | import | or | with | |
| | | class | __False__ | **in** | pass | yield | |
| | |
| | * <html><a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">Fonctions natives</a></html>** (built-in)**((Fonctions toujours disponibles.)) utilisées dans les exemples : **print**(), **len**(), **ord**(), **chr**(). |
| | |
| | ---- |
| | |
| | ==== 1. Introduction ==== |
| | En programmation, le texte s'appelle chaîne de caractères. Pour créer une chaîne de caractères, il faut encadrer le texte de guillemets **" "** ou d'apostrophes **' '**. Une chaîne de caractères est une **__séquence__**, ce qui signifie que c'est une **collection ordonnée** de valeurs. Le premier élément de la chaîne est **indexé** par **0**. Les chaînes de caractères sont des instances de la classe **str**. |
| | |
| | <callout type="warning" icon="true">En Python une chaîne de caractères est **immuable** (ou **non mutable**) c'est-à-dire q'elle ne peut être modifiée après sa création. \\ Toutes les **méthodes** de manipulation des chaînes **renvoient** une **chaîne de caractères**. \\ \\ Il faut encadrer le texte de **guillemets** simples **' '** ou doubles **" "**.</callout> |
| | |
| | //Exemple// |
| | {{ :python:bases:pointeur.png?nolink|}} |
| | <code python *.py> |
| | # deux variables pointent vers le même objet chaîne de caractères |
| | s1 = 'abc' |
| | s2 = s1 |
| | </code> |
| | |
| | {{ :python:bases:pointeur2.png?nolink|}} |
| | <code python *.py> |
| | # on essaie de modifier l'objet |
| | s1 += 'def' # une deuxième chaîne est créée pour s1, |
| | # s2 continue à pointer vers s1 initial |
| | </code> |
| | |
| | <callout type="tip" icon="true">La liste des méthodes peut être obtenue dans l'interpréteur python avec **dir(str)** et une aide sur une méthode avec **help(str**.//méthode//**)**.</callout> |
| | |
| | //Exemple// |
| | {{ :python:poo:composites:help.png?nolink&500 |}} |
| | ==== 2. Mise en forme du texte ==== |
| | Les caractères d'une chaîne sont mis en forme avec les méthodes de la classe str. Par exemple en minuscules avec la méthode **lower**, en majuscules avec la méthode **upper**, etc. |
| | |
| | //Exemple// |
| | |
| | <code python *.py> |
| | texte = "Le manuel de Python" |
| | # Conversion en majuscules |
| | print(texte.upper()) # Résultat : LE MANUEL DE PYTHON |
| | # Conversion en minuscules |
| | print(texte.lower()) # Résultat : le manuel de python |
| | </code> |
| | |
| | <callout type="tip" icon="true">Par défaut l'instruction **print** provoque un retour à la ligne après l'affichage. On peut changer ce comportement en fournissant une autre chaîne de caractère à accoler à l'affichage comme ci-dessus ou même rien.</callout> |
| | |
| | // Exemple // |
| | <code python *.py> |
| | print("Ce texte s'affiche", end=" ") # Renvoie : Ce texte s'affiche sur une seule ligne. |
| | print("sur une seule ligne.", end=" ") |
| | </code> |
| | ==== 3. Formatage ==== |
| | * **Depuis Python 3.6** |
| | * Source : <html><ahref="https://he-arc.github.io/livre-python/fstrings/index.html" target="blank">Bibliothèques Python</a></html> |
| | |
| | <callout type="tip" icon="true">L'utilisation de **f-strings** permet d’insérer des expressions dans des chaines de caractères en utilisant une syntaxe minimale.</callout> |
| | |
| | //Exemple// |
| | <code python *.py> |
| | monscore = 1000 |
| | f"Vous avez obtenu {monscore} points" # Résultat : Vous avez obtenu 1000 points |
| | </code> |
| | |
| | <callout type="primary" icon="true">Pour **associer** des chaînes (**concaténation**) on utilise l'opérateur **+**.</callout> |
| | |
| | //Exemple// |
| | |
| | <code python *.py> |
| | texte1 = "Hello" |
| | texte2 = " World" |
| | texte3 = texte1 + texte2 # Résultat texte3 = "Hello World" |
| | </code> |
| | |
| | * Pour **répéter** des chaînes, on utilise l'opérateur ** * **. |
| | |
| | //Exemple// |
| | |
| | <code python *.py> |
| | texte2 = " World" |
| | texte3 = texte2*3 # Résultat texte3 = " World World World |
| | </code> |
| | |
| | * **Avant python 3.6** |
| | <callout type="primary" icon="true">Pour **insérer des valeurs** dans une chaîne on utilise **%s** à l'emplacement retenu, la méthode **format** ou des **virgules**.</callout> |
| | |
| | //Exemple// |
| | |
| | <code python *.py> |
| | score = 1000 |
| | |
| | # Utilisation de %s (à éviter, car lourd par rapport aux autres méthodes) |
| | points = "Vous avez obtenu %s points" |
| | print(points % score) # Résultat : Vous avez obtenu 1000 points |
| | |
| | # Utilisation de la méthode format() |
| | # Solution 1 |
| | print("Vous avez obtenu {0} points".format(score)) # Résultat : Vous avez obtenu 1000 points |
| | # Solution 2 |
| | print("Vous avez obtenu {score} points".format(score=monscore)) # Résultat : Vous avez obtenu 1000 points |
| | |
| | # Utilisation de virgules |
| | print("Vous avez obtenu",monscore,"points") # Résultat : Vous avez obtenu 1000 points |
| | </code> |
| | |
| | |
| | |
| | |
| | ==== 4. Longueur d'une chaîne, parcours et sélection (slice) ==== |
| | * **Ressource** |
| | * <html><a href="https://codesolid.com/python-indexing-slicing-exercises/" target="_blank">Python Indexing and Slicing: Complete Tutorial With Hands-On Exercises</a></html> |
| | |
| | <callout type="primary" icon="true">Une chaîne de caractères est une séquence constituée de chaînes de caractères constituées d'un seul caractère.</callout> |
| | |
| | * **Longueur d'une chaîne** |
| | <callout type="primary" icon="true">La longueur d'une chaîne (son **nombre d'éléments**) est déterminée avec la fonction built-in **len**(). |
| | |
| | Exemple : **len**("Le jour le plus long") # renvoie 20</callout> |
| | |
| | * **Accès** aux caractères d'une chaîne |
| | |
| | <callout type="warning" icon="true">Pour accéder à un caractère dans une chaîne, on précise son indice entre crochets **[**//indice//**]**. \\ **L'indice du premier caractère est 0**.</callout> |
| | |
| | //Exemple// |
| | <code python *.py> |
| | texte = "Le manuel de Python 3" |
| | texte[0] # Résultat : L |
| | texte[13] # Résultat : P |
| | </code> |
| | |
| | * **Parcours** des éléments d'une chaîne |
| | |
| | //Exemple// |
| | <code python *.py> |
| | texte = "Le manuel de Python 3" |
| | |
| | # Parcours avec une boucle while |
| | i=0 |
| | while i<len(texte): |
| | print(texte[i]) |
| | i+=1 |
| | |
| | # Parcours avec une boucle for |
| | for i in texte: |
| | print(i) |
| | </code> |
| | |
| | * **Sélection** de chaîne (slice) |
| | La sélection consiste à extraire une partie de la chaîne (//slicing//). Pour sélectionner une partie d'une chaîne, on précise la valeur du premier et du dernier indice entre crochet et éventuellement un pas. |
| | |
| | <callout type="primary" icon="true">//Chaine//**[**//début// **:** //fin// **:** //pas//**]**</callout> |
| | {{ :python:poo:composites:brackets.png?nolink&300 |}} |
| | |
| | <callout type="warning" icon="true">L'élément du **dernier indice** est **exclu**.</callout> |
| | |
| | // Exemple// |
| | |
| | <code python *.py> |
| | texte = "Le manuel de Python 3" |
| | texte[:9] # Résultat : 'Le manuel' (borne début omise) |
| | texte[3:12] # Résultat : 'manuel de' |
| | texte[13:len(texte)] # Résultat : 'Python' |
| | # ou |
| | texte[13:] # Résultat : 'Python' (borne fin omise) |
| | texte[:] # Résultat : 'Le manuel de Python 3' (shadow copy) |
| | # Utilisation du pas |
| | texte[:9:2] # Résultat : 'L aul' |
| | texte[9::2] # Résultat : ' ePto ' |
| | # Indices négatifs |
| | texte[3:-2] # Résultat : 'manuel de Python' |
| | texte[-21:-14] # Résultat : 'Le manu' |
| | texte[::-1] # Résultat : '3 nohtyP ed leunam eL' (inverse le texte) |
| | </code> |
| | |
| | ==== 5. Encodage, décodage ==== |
| | * **Ressource** : <html><a href="https://docs.python.org/fr/3/howto/unicode.html" target="_blank">Guide Unicode</a></html> |
| | |
| | "//Le type de chaîne de caractères de Python utilise le standard Unicode pour représenter les caractères, ce qui permet aux programmes Python de travailler avec tous ces différents caractères possibles. UTF-8 est l’un des encodages les plus couramment utilisés et Python l’utilise souvent par défaut. //" |
| | |
| | {{ :python:poo:composites:encode-decode.png?nolink |}} |
| | |
| | * **Caractère -> Unicode** |
| | La fonction **ord**(//car//) envoie le nombre entier représentant le code Unicode du caractère représenté par la chaîne //car//donnée. |
| | |
| | //Exemple// |
| | |
| | <code python *.py> |
| | ord('a') # donne 97 |
| | hex(ord('a')) # donne 0x61 |
| | </code> |
| | |
| | * **Code Unicode -> caractère** |
| | La fonction **chr**(//i//) renvoie la chaîne représentant un caractère dont le code de caractère Unicode est le nombre entier //i//. |
| | |
| | //Exemple// |
| | |
| | <code python *.py> |
| | chr(ox26) # donne '&' |
| | </code> |
| | ==== 6. Quelques méthodes de la classe str ==== |
| | ^**Mise en forme**^^ |
| | |**format**(arguments)|Place la liste des arguments, dans l'ordre, aux emplacements réservés par {0} dans la chaîne.<code python *.py>nom = "Célestin" |
| | age = 4 |
| | print("{} a {} ans".format(nom,age)) # Célestin à 4 ans</code> | |
| | ^ **Découpage** - **assemblage** ^^ |
| | |**split**() |Transforme une chaîne en une liste de sous-chaînes. Le **séparateur par défaut** est un **espace**, mais il est possible de lui donner en argument n’importe quel autre séparateur. <code python *.py>s="Le petit chat de la voisine boit du lait" |
| | s.split() # Renvoie : ['Le', 'petit', 'chat', 'de', 'la', 'voisine', 'boit', 'du', 'lait']</code>| |
| | |**join**(**liste**) |Effectue l’opération **inverse** de split. Commence par des **guillements** dans lesquels on place le **caractère de séparation**.<code python *.py>l=['Le', 'petit', 'chat', 'de', 'la', 'voisine', 'boit', 'du', 'lait'] |
| | " ".join(l) # Renvoie : 'Le petit chat de la voisine boit du lait'</code>| |
| | ^**Remplacement**^^ |
| | |**replace**(**old,new**) |Remplace le ou les caractères //old// par le ou les caractères //new//.<code python *.py>s = "Le petit chat de la voisine boit du lait" |
| | s.replace("chat","chien") # Renvoie : 'Le petit chien de la voisine boit du lait'</code>| |
| | ^**Nettoyage**^^ |
| | |**strip**() |Supprime les espaces, tabulations et retours à la ligne éventuels en début et en fin de chaîne.<code python *.py>" \tune chaîne avec des trucs qui dépassent \n".strip() |
| | # Renvoie : 'une chaîne avec des trucs qui dépassent'</code>| |
| | |**lstrip**() |Enlève les espaces éventuels seulement en début de chaîne. | |
| | |**rstrip**() |Enlève les espaces éventuels en fin de chaîne. | |
| | ^**Recherche d'une sous-chaîne**^^ |
| | |**find**(**x**) |Fait exactement la même chose que index() sauf que si elle ne trouve pas la sous-chaîne, elle renvoie -1.<code python *.py># L'exemple ci-dessous renvoie l'indice du début de la première occurrence |
| | "abcdefcdefghefghijk".find("def") # soit ici 3 |
| | # rfind fait la même chose que find mais en partant de la fin |
| | "abcdefcdefghefghijk".rfind("fgh") # Renvoie 13</code> | |
| | |**index**(**y**) |Renvoie l’indice de la première occurrence de la chaîne passée en argument. Lève une exception en cas d'absence. | |
| | |**count**() |Renvoie le nombre d'occurrences d'une sous-chaîne.<code python *.py>"abcdefcdefghefghijk".count("ef") # renvoie 3 </code>| |
| | |**startswith**() |Renvoie True si la chaîne commence par la sous-chaîne passée en argument. Sinon, elle renvoie False. <code python *.py>"abcdefcdefghefghijk".startswith("abcd") # Renvoie True</code> | |
| | |**endswith**() |Renvoie True si la chaîne se termine par la sous-chaîne passée en argument. Sinon, elle renvoie False.<code python *.py> "abcdefcdefghefghijk".endswith("ghijk") # Renvoie True</code>| |
| | ^**Changement de casse**^^ |
| | |**upper**() |Convertit la chaîne de caractères en majuscules.<code python *.py> |
| | "monty PYTHON".upper() # Renvoie : 'MONTY PYTHON'</code> | |
| | |**lower**() |Convertit la chaîne de caractères en minuscules.<code python *.py> |
| | "monty PYTHON".lower() # Renvoie : 'monty python'</code> | |
| | |**capitalize**() |Convertit la première lettre d'un mot en majuscule.<code python *.py> |
| | "monty PYTHON".capitalize() # Renvoie : 'Monty python'</code> | |
| | ^**Ajout de caractères**^^ |
| | |**zfill**(**n**) |Complète la chaîne par des zéros (à gauche) jusqu'à ce qu'elle contienne le nombre **n** de caractères passés en paramètres. <code python *.py> bin(0)[2:].zfill(8) # Renvoie '00000000'</code> | |
| | |
| | ---- |
| | |
| | ==== Résumé ==== |
| | * Les chaînes sont des **objets**. |
| | * Un objet est une **instance** de **classe**. |
| | * Une classe possède des **méthodes**, accessibles à partir de l'objet grâce à **objet.methode(arguments)**. |
| | * On peut accéder à un caractère dans la chaîne grâce à //chaine[indice]// ou à une partie de la chaîne grâce à //chaine[premier_indice:dernier_indice]// |
| | |
| | ---- |
| | |
| | |
| | {{ :python:bases:realpython.png?nolink|}} |
| | ==== Quiz ==== |
| | * <html><a href="https://realpython.com/quizzes/python-data-types/" target="_blank">Basic Data Types in Python</a></html> |
| | * <html><a href="https://realpython.com/quizzes/python-split-strings/" target="_blank">Splitting, Concatenating, and Joining Strings in Python Quiz</a></html> |
| | |
| | ---- |
| | |
| | {{ :python:bases:realpython.png?nolink|}} |
| | ==== Pour aller plus loin ==== |
| | * <html><a href="https://realpython.com/python-formatted-output/" target="_blank">A Guide to the Newer Python String Format Techniques</a></html> |
| | * <html><a href="https://realpython.com/convert-python-string-to-int/" target="_blank">How to Convert a Python String to int</a></html> |
| | * <html><a href="https://realpython.com/regex-python/" target="_blank">Regular Expressions: Regexes in Python (Part 1)</a></html> <html><a href="https://realpython.com/regex-python-part-2/" target="_blank">(Part 2)</a></html> |
| | * Les expressions régulières dans la <html><a href="https://docs.python.org/3/library/re.html#regular-expression-syntax" target="_blank">documentation Python</a></html> - Outil <html><a href="https://pythex.org/" target="_blank">pythex</a></html> |
| | * <html><a href="https://realpython.com/python-string-split-concatenate-join/" target="_blank">Splitting, Concatenating, and Joining Strings in Python</a></html> |
| | * <html><a href="https://bas.codes/posts/python-slicing" target="_blank">A Comprehensive Guide to Slicing in Python</a></html> |
| | * <html><a href="https://realpython.com/replace-string-python/" target="_blank">How to Replace a String in Python</a></html> |
| | * <html><a href="https://realpython.com/python-string-contains-substring/" target="_blank">How to Check if a Python String Contains a Substring</a></html> |
| | * <html><a href="https://realpython.com/inherit-python-str/" target="_blank">Custom Python Strings: Inheriting From str vs UserString</a></html> |