Chaînes et données de caractères en Python

Dans le didacticiel surBasic Data Types in Python, vous avez appris à définir des objetsstrings: contenant des séquences de données de caractères. Le traitement des données de caractères fait partie intégrante de la programmation. Il s'agit d'une application rare qui n'a pas besoin de manipuler les chaînes au moins dans une certaine mesure.

Here’s what you’ll learn in this tutorial: Python fournit un riche ensemble d'opérateurs, de fonctions et de méthodes pour travailler avec des chaînes. Une fois ce didacticiel terminé, vous saurez comment accéder à des parties de chaînes et en extraire des parties, et vous serez également familiarisé avec les méthodes disponibles pour manipuler et modifier les données de chaîne.

Vous serez également présenté à deux autres objets Python utilisés pour représenter des données d'octets brutes, les typesbytes etbytearray.

__ Take the Quiz: Testez vos connaissances avec notre quiz interactif «Chaînes Python et données de caractères». À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps:

Fais le quiz "

Manipulation de chaînes

Les sections ci-dessous mettent en évidence les opérateurs, méthodes et fonctions disponibles pour travailler avec des chaînes.

Opérateurs de chaîne

Vous avez déjà vu les opérateurs+ et* appliqués aux opérandes numériques dans le tutoriel surOperators and Expressions in Python. Ces deux opérateurs peuvent également être appliqués aux chaînes.

L'opérateur`+`

L'opérateur+ concatène les chaînes. Il renvoie une chaîne composée des opérandes réunis, comme indiqué ici:

>>>

>>> s = 'foo'
>>> t = 'bar'
>>> u = 'baz'

>>> s + t
'foobar'
>>> s + t + u
'foobarbaz'

>>> print('Go team' + '!!!')
Go team!!!

L'opérateur`*`

L'opérateur* crée plusieurs copies d'une chaîne. Sis est une chaîne etn est un entier, l'une des expressions suivantes renvoie une chaîne composée den copies concaténées des:

s * n
n * s

Voici des exemples des deux formes:

>>>

>>> s = 'foo.'

>>> s * 4
'foo.foo.foo.foo.'
>>> 4 * s
'foo.foo.foo.foo.'

L'opérande multiplicateurn doit être un entier. Vous penseriez qu'il faudrait un entier positif, mais de manière amusante, il peut être nul ou négatif, auquel cas le résultat est une chaîne vide:

>>>

>>> 'foo' * -8
''

Si vous deviez créer une variable chaîne et l'initialiser à la chaîne vide en lui affectant la valeur'foo' * -8, n'importe qui penserait à juste titre que vous êtes un peu idiot. Mais ça marcherait.

L'opérateur`in`

Python fournit également un opérateur d'appartenance qui peut être utilisé avec des chaînes. L'opérateurin renvoieTrue si le premier opérande est contenu dans le second, etFalse sinon:

>>>

>>> s = 'foo'

>>> s in 'That\'s food for thought.'
True
>>> s in 'That\'s good for now.'
False

Il existe également un opérateurnot in, qui fait le contraire:

>>>

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

Fonctions de chaîne intégrées

Comme vous l'avez vu dans le tutoriel surBasic Data Types in Python, Python fournit de nombreuses fonctions qui sont intégrées à l'interpréteur et toujours disponibles. Voici quelques-uns qui fonctionnent avec des chaînes:

Une fonction La description

Une fonction	La description
`chr()`	Convertit un entier en caractère
`ord()`	Convertit un caractère en entier
`len()`	Renvoie la longueur d'une chaîne
`str()`	Renvoie une représentation sous forme de chaîne d'un objet

chr()

Convertit un entier en caractère

ord()

Convertit un caractère en entier

len()

Renvoie la longueur d'une chaîne

str()

Renvoie une représentation sous forme de chaîne d'un objet

Celles-ci sont explorées plus en détail ci-dessous.

`ord(c)`

Renvoie une valeur entière pour le caractère donné.

Au niveau le plus élémentaire, les ordinateurs stockent toutes les informations sous forme de nombres. Pour représenter les données de caractères, un schéma de traduction est utilisé qui mappe chaque caractère à son numéro représentatif.

Le schéma le plus simple d'usage courant est appeléASCII. Il couvre les caractères latins courants avec lesquels vous êtes probablement le plus habitué à travailler. Pour ces caractères,ord(c) renvoie la valeur ASCII du caractèrec:

>>>

>>> ord('a')
97
>>> ord('#')
35

ASCII est très bien dans la mesure où il va. Mais il existe de nombreuses langues différentes dans le monde et d'innombrables symboles et glyphes qui apparaissent dans les médias numériques. L'ensemble complet de caractères qui peuvent éventuellement devoir être représentés dans un code informatique dépasse de loin les lettres, chiffres et symboles latins ordinaires que vous voyez habituellement.

Unicode est une norme ambitieuse qui tente de fournir un code numérique pour chaque caractère possible, dans toutes les langues possibles, sur toutes les plateformes possibles. Python 3 prend largement en charge Unicode, notamment en autorisant les caractères Unicode dans les chaînes.

For More Information: VoirPython’s Unicode Support dans la documentation Python.

Tant que vous restez dans le domaine des caractères communs, il y a peu de différence pratique entre ASCII et Unicode. Mais la fonctionord() renverra également des valeurs numériques pour les caractères Unicode:

>>>

>>> ord('€')
8364
>>> ord('∑')
8721

`chr(n)`

Renvoie une valeur de caractère pour l'entier donné.

chr() fait l'inverse deord(). Étant donné une valeur numériquen,chr(n) renvoie une chaîne représentant le caractère qui correspond àn:

>>>

>>> chr(97)
'a'
>>> chr(35)
'#'

chr() gère également les caractères Unicode:

>>>

>>> chr(8364)
'€'
>>> chr(8721)
'∑'

len(s)

Renvoie la longueur d'une chaîne.

Aveclen(), vous pouvez vérifier la longueur de la chaîne Python. len(s) renvoie le nombre de caractères ens:

>>>

>>> s = 'I am a string.'
>>> len(s)
14

str(obj)

Renvoie une représentation sous forme de chaîne d'un objet.

Pratiquement n'importe quel objet en Python peut être rendu sous forme de chaîne. str(obj) renvoie la représentation sous forme de chaîne de l'objetobj:

>>>

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('foo')
'foo'

Indexation des chaînes

Souvent dans les langages de programmation, les éléments individuels d'un ensemble ordonné de données sont accessibles directement à l'aide d'un index numérique ou d'une valeur clé. Ce processus est appelé indexation.

En Python, les chaînes sont des séquences ordonnées de données de caractères et peuvent donc être indexées de cette manière. Les caractères individuels d'une chaîne sont accessibles en spécifiant le nom de la chaîne suivi d'un nombre entre crochets ([]).

L'indexation des chaînes en Python est basée sur zéro: le premier caractère de la chaîne a l'index0, le suivant a l'index1, et ainsi de suite. L'index du dernier caractère sera la longueur de la chaîne moins un.

Par exemple, un diagramme schématique des indices de la chaîne'foobar' ressemblerait à ceci:

Les caractères individuels sont accessibles par index comme suit:

>>>

>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> len(s)
6
>>> s[len(s)-1]
'r'

Une tentative d'indexation au-delà de la fin de la chaîne entraîne une erreur:

>>>

>>> s[6]
Traceback (most recent call last):
  File "", line 1, in 
    s[6]
IndexError: string index out of range

Les indices de chaîne peuvent également être spécifiés avec des nombres négatifs, auquel cas l'indexation se produit à partir de la fin de la chaîne vers l'arrière:-1 fait référence au dernier caractère,-2est l'avant-dernier caractère, etc. . Voici le même diagramme montrant les indices positifs et négatifs dans la chaîne'foobar':

Voici quelques exemples d'indexation négative:

>>>

>>> s = 'foobar'

>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)]
'f'

Une tentative d'indexation avec des nombres négatifs au-delà du début de la chaîne entraîne une erreur:

>>>

>>> s[-7]
Traceback (most recent call last):
  File "", line 1, in 
    s[-7]
IndexError: string index out of range

Pour toute chaîne non vides,s[len(s)-1] ets[-1] renvoient toutes deux le dernier caractère. Aucun index n’a de sens pour une chaîne vide.

Tranchage de cordes

Python permet également une forme de syntaxe d'indexation qui extrait les sous-chaînes d'une chaîne, connue sous le nom de découpage de chaîne. Sis est une chaîne, une expression de la formes[m:n] renvoie la partie des commençant par la positionm, et jusqu'à la positionn, mais non comprise :

>>>

>>> s = 'foobar'
>>> s[2:5]
'oba'

Remember: Les indices de chaîne sont basés sur zéro. Le premier caractère d'une chaîne a l'index0. Cela s'applique à la fois à l'indexation et au découpage standard.

Là encore, le deuxième index spécifie le premier caractère qui n'est pas inclus dans le résultat - le caractère'r' (s[5]) dans l'exemple ci-dessus. Cela peut sembler un peu peu intuitif, mais cela produit ce résultat qui a du sens: l'expressions[m:n] renverra une sous-chaîne d'une longueur den - m caractères, dans ce cas,5 - 2 = 3.

Si vous omettez le premier index, la tranche commence au début de la chaîne. Ainsi,s[:m] ets[0:m] sont équivalents:

>>>

>>> s = 'foobar'

>>> s[:4]
'foob'
>>> s[0:4]
'foob'

De même, si vous omettez le deuxième index comme danss[n:], la tranche s'étend du premier index à la fin de la chaîne. C'est une alternative intéressante et concise auxs[n:len(s)] plus encombrants:

>>>

>>> s = 'foobar'

>>> s[2:]
'obar'
>>> s[2:len(s)]
'obar'

Pour toute chaînes et tout entiern (0 ≤ n ≤ len(s)),s[:n] + s[n:] sera égal às:

>>>

>>> s = 'foobar'

>>> s[:4] + s[4:]
'foobar'
>>> s[:4] + s[4:] == s
True

L'omission des deux indices renvoie la chaîne d'origine, dans son intégralité. Littéralement. Ce n'est pas une copie, c'est une référence à la chaîne d'origine:

>>>

>>> s = 'foobar'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

Si le premier index d'une tranche est supérieur ou égal au deuxième index, Python renvoie une chaîne vide. C'est encore une autre façon obscurcie de générer une chaîne vide, au cas où vous en cherchiez une:

>>>

>>> s[2:2]
''
>>> s[4:2]
''

Les indices négatifs peuvent également être utilisés avec le découpage. -1 fait référence au dernier caractère,-2 à l'avant-dernier, et ainsi de suite, comme pour une simple indexation. Le diagramme ci-dessous montre comment découper la sous-chaîne'oob' de la chaîne'foobar' en utilisant à la fois des indices positifs et négatifs:

Voici le code Python correspondant:

>>>

>>> s = 'foobar'

>>> s[-5:-2]
'oob'
>>> s[1:4]
'oob'
>>> s[-5:-2] == s[1:4]
True

Spécification d'une foulée dans une tranche de chaîne

Il existe une autre variante de la syntaxe de découpage à discuter. L'ajout d'un: supplémentaire et d'un troisième index désigne une foulée (également appelée étape), qui indique le nombre de caractères à sauter après avoir récupéré chaque caractère de la tranche.

Par exemple, pour la chaîne'foobar', la tranche0:6:2 commence par le premier caractère et se termine par le dernier caractère (la chaîne entière), et chaque deuxième caractère est ignoré. Ceci est illustré dans le diagramme suivant:

De même,1:6:2 spécifie une tranche commençant par le deuxième caractère (index1) et se terminant par le dernier caractère, et encore une fois la valeur de foulée2 fait sauter tous les autres caractères:

Le code REPL illustratif est illustré ici:

>>>

>>> s = 'foobar'

>>> s[0:6:2]
'foa'

>>> s[1:6:2]
'obr'

Comme pour tout découpage, le premier et le deuxième index peuvent être omis, et par défaut respectivement au premier et au dernier caractère:

>>>

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'

Vous pouvez également spécifier une valeur de pas négative, auquel cas Python recule dans la chaîne. Dans ce cas, l'index de départ / premier doit être supérieur à l'index de fin / deuxième:

>>>

>>> s = 'foobar'
>>> s[5:0:-2]
'rbo'

Dans l'exemple ci-dessus,5:0:-2 signifie "commencer au dernier caractère et reculer de2, jusqu'au premier caractère, mais sans l'inclure."

Lorsque vous reculez, si les premier et deuxième indices sont omis, les valeurs par défaut sont inversées de manière intuitive: le premier index par défaut à la fin de la chaîne, et le second index par défaut au début. Voici un exemple:

>>>

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'

Il s'agit d'un paradigme commun pour inverser une chaîne:

>>>

>>> s = 'If Comrade Napoleon says it, it must be right.'
>>> s[::-1]
'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'

Interpolation de variables dans une chaîne

Dans Python version 3.6, un nouveau mécanisme de formatage de chaînes a été introduit. Cette fonctionnalité est officiellement appelée littéral de chaîne formatée, mais elle est plus généralement désignée par son surnomf-string.

La capacité de formatage fournie par les chaînes f est étendue et ne sera pas traitée en détail ici. Si vous voulez en savoir plus, vous pouvez consulter l'articlePython 3’s f-Strings: An Improved String Formatting Syntax (Guide) sur Real Python. Il existe également un didacticiel sur la sortie formatée à venir plus tard dans cette série qui approfondit les chaînes f.

L'interpolation variable est une caractéristique simple des chaînes f que vous pouvez commencer à utiliser immédiatement. Vous pouvez spécifier un nom de variable directement dans un littéral de chaîne f, et Python remplacera le nom par la valeur correspondante.

Par exemple, supposons que vous souhaitiez afficher le résultat d'un calcul arithmétique. Vous pouvez le faire avec une instructionprint() simple, séparant les valeurs numériques et les chaînes littérales par des virgules:

>>>

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('The product of', n, 'and', m, 'is', prod)
The product of 20 and 25 is 500

Mais c'est lourd. Pour accomplir la même chose en utilisant une f-string:

Spécifiez unf minuscule ou unF majuscule juste avant le guillemet ouvrant du littéral de chaîne. Cela indique à Python qu'il s'agit d'une chaîne f au lieu d'une chaîne standard.
Spécifiez toutes les variables à interpoler entre accolades ({}).

Refonte en utilisant une chaîne f, l'exemple ci-dessus semble beaucoup plus propre:

>>>

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'The product of {n} and {m} is {prod}')
The product of 20 and 25 is 500

N'importe lequel des trois mécanismes de citation de Python peut être utilisé pour définir une chaîne f:

>>>

>>> var = 'Bark'

>>> print(f'A dog says {var}!')
A dog says Bark!
>>> print(f"A dog says {var}!")
A dog says Bark!
>>> print(f'''A dog says {var}!''')
A dog says Bark!

Modification de chaînes

En un mot, vous ne pouvez pas. Les chaînes sont l'un des types de données que Python considère comme immuables, ce qui signifie qu'elles ne peuvent pas être modifiées. En fait, tous les types de données que vous avez vus jusqu'à présent sont immuables. (Python fournit des types de données qui sont mutables, comme vous le verrez bientôt.)

Une déclaration comme celle-ci entraînera une erreur:

>>>

>>> s = 'foobar'
>>> s[3] = 'x'
Traceback (most recent call last):
  File "", line 1, in 
    s[3] = 'x'
TypeError: 'str' object does not support item assignment

En vérité, il n'est vraiment pas nécessaire de modifier les chaînes. Vous pouvez généralement facilement accomplir ce que vous voulez en générant une copie de la chaîne d'origine qui a le changement souhaité en place. Il existe de nombreuses façons de le faire en Python. Voici une possibilité:

>>>

>>> s = s[:3] + 'x' + s[4:]
>>> s
'fooxar'

Il existe également une méthode de chaîne intégrée pour accomplir cela:

>>>

>>> s = 'foobar'
>>> s = s.replace('b', 'x')
>>> s
'fooxar'

Lisez la suite pour plus d'informations sur les méthodes de chaîne intégrées!

Méthodes de chaîne intégrées

Vous avez appris dans le tutoriel surVariables in Python que Python est un langage hautement orienté objet. Chaque élément de données dans un programme Python est un objet.

Vous connaissez également les fonctions: procédures appelables que vous pouvez invoquer pour effectuer des tâches spécifiques.

Les méthodes sont similaires aux fonctions. Une méthode est un type spécialisé de procédure appelable étroitement associé à un objet. Comme une fonction, une méthode est appelée pour effectuer une tâche distincte, mais elle est invoquée sur un objet spécifique et a connaissance de son objet cible lors de son exécution.

La syntaxe pour appeler une méthode sur un objet est la suivante:

obj.foo()

Cela appelle la méthode.foo() sur l'objetobj. <args> spécifie les arguments passés à la méthode (le cas échéant).

Vous en apprendrez beaucoup plus sur la définition et l'appel de méthodes plus loin dans la discussion sur la programmation orientée objet. Pour l'instant, l'objectif est de présenter certaines des méthodes intégrées les plus couramment utilisées par Python pour fonctionner sur des objets chaîne.

Dans les définitions de méthode suivantes, les arguments spécifiés entre crochets ([]) sont facultatifs.

Conversion de cas

Les méthodes de ce groupe effectuent une conversion de casse sur la chaîne cible.

s.capitalize()

Met la chaîne cible en majuscule.

s.capitalize() renvoie une copie des avec le premier caractère converti en majuscules et tous les autres caractères convertis en minuscules:

>>>

>>> s = 'foO BaR BAZ quX'
>>> s.capitalize()
'Foo bar baz qux'

Les caractères non alphabétiques sont inchangés:

>>>

>>> s = 'foo123#BAR#.'
>>> s.capitalize()
'Foo123#bar#.'

s.lower()

Convertit les caractères alphabétiques en minuscules.

s.lower() renvoie une copie des avec tous les caractères alphabétiques convertis en minuscules:

>>>

>>> 'FOO Bar 123 baz qUX'.lower()
'foo bar 123 baz qux'

s.swapcase()

Remplace la casse des caractères alphabétiques.

s.swapcase() renvoie une copie des avec des caractères alphabétiques majuscules convertis en minuscules et vice versa:

>>>

>>> 'FOO Bar 123 baz qUX'.swapcase()
'foo bAR 123 BAZ Qux'

s.title()

Convertit la chaîne cible en «casse de titre».

s.title() renvoie une copie des dans laquelle la première lettre de chaque mot est convertie en majuscules et les lettres restantes sont en minuscules:

>>>

>>> 'the sun also rises'.title()
'The Sun Also Rises'

Cette méthode utilise un algorithme assez simple. Il n'essaie pas de faire la distinction entre les mots importants et les mots sans importance, et il ne gère pas les apostrophes, les possessifs ou les acronymes avec élégance:

>>>

>>> "what's happened to ted's IBM stock?".title()
"What'S Happened To Ted'S Ibm Stock?"

s.upper()

Convertit les caractères alphabétiques en majuscules.

s.upper() renvoie une copie des avec tous les caractères alphabétiques convertis en majuscules:

>>>

>>> 'FOO Bar 123 baz qUX'.upper()
'FOO BAR 123 BAZ QUX'

Trouver et remplacer

Ces méthodes fournissent divers moyens de rechercher dans la chaîne cible une sous-chaîne spécifiée.

Chaque méthode de ce groupe prend en charge les arguments optionnels<start> et<end>. Celles-ci sont interprétées comme pour le découpage de chaînes: l'action de la méthode est limitée à la partie de la chaîne cible commençant à la position de caractère<start> et allant jusqu'à la position de caractère<end>, mais non comprise. Si<start> est spécifié mais que<end> ne l'est pas, la méthode s'applique à la partie de la chaîne cible de<start> à la fin de la chaîne.

s.count(_{[, [, ]])}

Compte les occurrences d'une sous-chaîne dans la chaîne cible.

s.count() renvoie le nombre d'occurrences sans chevauchement de la sous-chaîne ens:

>>>

>>> 'foo goo moo'.count('oo')
3

Le nombre est limité au nombre d'occurrences dans la sous-chaîne indiquée par<start> et<end>, si elles sont spécifiées:

>>>

>>> 'foo goo moo'.count('oo', 0, 8)
2

s.endswith([, [, ]])

Détermine si la chaîne cible se termine par une sous-chaîne donnée.

s.endswith(<suffix>) renvoieTrue sis se termine par les<suffix> spécifiés etFalse sinon:

>>>

>>> 'foobar'.endswith('bar')
True
>>> 'foobar'.endswith('baz')
False

La comparaison est limitée à la sous-chaîne indiquée par<start> et<end>, si elles sont spécifiées:

>>>

>>> 'foobar'.endswith('oob', 0, 4)
True
>>> 'foobar'.endswith('oob', 2, 4)
False

s.find(_{[, [, ]])}

Recherche dans la chaîne cible une sous-chaîne donnée.

Vous pouvez utiliser.find() pour voir si une chaîne Python contient une sous-chaîne particulière. s.find() renvoie l'index le plus bas des où la sous-chaîne est trouvée:

>>>

>>> 'foo bar foo baz foo qux'.find('foo')
0

Cette méthode renvoie-1 si la sous-chaîne spécifiée n'est pas trouvée:

>>>

>>> 'foo bar foo baz foo qux'.find('grault')
-1

La recherche est limitée à la sous-chaîne indiquée par<start> et<end>, si elles sont spécifiées:

>>>

>>> 'foo bar foo baz foo qux'.find('foo', 4)
8
>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)
-1

s.index(_{[, [, ]])}

Recherche dans la chaîne cible une sous-chaîne donnée.

Cette méthode est identique à.find(), sauf qu'elle lève une exception si n'est pas trouvé plutôt que de renvoyer-1:

>>>

>>> 'foo bar foo baz foo qux'.index('grault')
Traceback (most recent call last):
  File "", line 1, in 
    'foo bar foo baz foo qux'.index('grault')
ValueError: substring not found

s.rfind(_{[, [, ]])}

Recherche dans la chaîne cible une sous-chaîne donnée commençant à la fin.

s.rfind() renvoie l'index le plus élevé des où la sous-chaîne est trouvée:

>>>

>>> 'foo bar foo baz foo qux'.rfind('foo')
16

Comme pour.find(), si la sous-chaîne n'est pas trouvée,-1 est renvoyé:

>>>

>>> 'foo bar foo baz foo qux'.rfind('grault')
-1

La recherche est limitée à la sous-chaîne indiquée par<start> et<end>, si elles sont spécifiées:

>>>

>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)
8
>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)
-1

s.rindex(_{[, [, ]])}

Recherche dans la chaîne cible une sous-chaîne donnée commençant à la fin.

Cette méthode est identique à.rfind(), sauf qu'elle lève une exception si n'est pas trouvé plutôt que de renvoyer-1:

>>>

>>> 'foo bar foo baz foo qux'.rindex('grault')
Traceback (most recent call last):
  File "", line 1, in 
    'foo bar foo baz foo qux'.rindex('grault')
ValueError: substring not found

s.startswith([, [, ]])

Détermine si la chaîne cible commence par une sous-chaîne donnée.

Lorsque vous utilisez la méthode Python.startswith(),s.startswith(<suffix>) renvoieTrue sis commence par les<suffix> spécifiés etFalse sinon:

>>>

>>> 'foobar'.startswith('foo')
True
>>> 'foobar'.startswith('bar')
False

La comparaison est limitée à la sous-chaîne indiquée par<start> et<end>, si elles sont spécifiées:

>>>

>>> 'foobar'.startswith('bar', 3)
True
>>> 'foobar'.startswith('bar', 3, 2)
False

Classification des personnages

Les méthodes de ce groupe classent une chaîne en fonction des caractères qu'elle contient.

s.isalnum()

Détermine si la chaîne cible se compose de caractères alphanumériques.

s.isalnum() renvoieTrue sis n'est pas vide et que tous ses caractères sont alphanumériques (une lettre ou un nombre), etFalse dans le cas contraire:

>>>

>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

s.isalpha()

Détermine si la chaîne cible se compose de caractères alphabétiques.

s.isalpha() renvoieTrue sis n'est pas vide et que tous ses caractères sont alphabétiques, etFalse sinon:

>>>

>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

s.isdigit()

Détermine si la chaîne cible se compose de caractères numériques.

Vous pouvez utiliser la méthode Python.isdigit() pour vérifier si votre chaîne est composée uniquement de chiffres. s.digit() renvoieTrue sis n'est pas vide et que tous ses caractères sont des chiffres numériques, etFalse sinon:

>>>

>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

s.isidentifier()

Détermine si la chaîne cible est un identifiant Python valide.

s.isidentifier() renvoieTrue sis est un identifiant Python valide selon la définition du langage, etFalse sinon:

>>>

>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

Note:.isidentifier() renverraTrue pour une chaîne qui correspond à un mot-clé Python même si ce ne serait pas réellement un identifiant valide:

>>>

>>> 'and'.isidentifier()
True

Vous pouvez tester si une chaîne correspond à un mot-clé Python à l'aide d'une fonction appeléeiskeyword(), qui est contenue dans un module appelékeyword. Une façon possible de le faire est indiquée ci-dessous:

>>>

>>> from keyword import iskeyword
>>> iskeyword('and')
True

Si vous voulez vraiment vous assurer qu'une chaîne servira d'identifiant Python valide, vous devez vérifier que.isidentifier() estTrue et queiskeyword() estFalse.

VoirPython Modules and Packages—An Introduction pour en savoir plus sur les modules Python.

s.islower()

Détermine si les caractères alphabétiques de la chaîne cible sont en minuscules.

s.islower() renvoieTrue sis n'est pas vide et que tous les caractères alphabétiques qu'il contient sont en minuscules, etFalse dans le cas contraire. Les caractères non alphabétiques sont ignorés:

>>>

>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

s.isprintable()

Détermine si la chaîne cible est entièrement composée de caractères imprimables.

s.isprintable() renvoieTrue sis est vide ou si tous les caractères alphabétiques qu'il contient sont imprimables. Il renvoieFalse sis contient au moins un caractère non imprimable. Les caractères non alphabétiques sont ignorés:

>>>

>>> 'a\tb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable()
False

Note: C'est la seule méthode.isxxxx() qui renvoieTrue sis est une chaîne vide. Tous les autres renvoientFalse pour une chaîne vide.

s.isspace()

Détermine si la chaîne cible se compose de caractères d'espacement.

s.isspace() renvoieTrue sis n'est pas vide et que tous les caractères sont des espaces, etFalse dans le cas contraire.

Les caractères d'espacement les plus couramment rencontrés sont l'espace' ', la tabulation' ' et la nouvelle ligne' ':

>>>

>>> ' \t \n '.isspace()
True
>>> '   a   '.isspace()
False

Cependant, il y a quelques autres caractères ASCII qui peuvent être considérés comme des espaces, et si vous tenez compte des caractères Unicode, il y en a quelques-uns au-delà:

>>>

>>> '\f\u2005\r'.isspace()
True

(' ' et' ' sont les séquences d'échappement pour les caractères ASCII Form Feed et Carriage Return;' ' est la séquence d'échappement pour l'espace Unicode Four-Per-Em.)

s.istitle()

Détermine si la chaîne cible est mise en casse de titre.

s.istitle() renvoieTrue sis n'est pas vide, le premier caractère alphabétique de chaque mot est en majuscule et tous les autres caractères alphabétiques de chaque mot sont en minuscules. Il renvoieFalse sinon:

>>>

>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

Note: Voici comment la documentation Python décrit.istitle(), au cas où vous trouveriez cela plus intuitif: «Les caractères majuscules ne peuvent suivre que les caractères sans casse et les caractères minuscules uniquement les caractères avec casse.»

s.isupper()

Détermine si les caractères alphabétiques de la chaîne cible sont en majuscules.

s.isupper() renvoieTrue sis n'est pas vide et que tous les caractères alphabétiques qu'il contient sont en majuscules, etFalse dans le cas contraire. Les caractères non alphabétiques sont ignorés:

>>>

>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False

Formatage de chaîne

Les méthodes de ce groupe modifient ou améliorent le format d'une chaîne.

s.center([, ])

Centre une chaîne dans un champ.

s.center(<width>) renvoie une chaîne composée des centrés dans un champ de largeur<width>. Par défaut, le remplissage se compose du caractère d'espace ASCII:

>>>

>>> 'foo'.center(10)
'   foo    '

Si l'argument optionnel<fill> est spécifié, il est utilisé comme caractère de remplissage:

>>>

>>> 'bar'.center(10, '-')
'---bar----'

Sis est déjà au moins aussi long que<width>, il est renvoyé inchangé:

>>>

>>> 'foo'.center(2)
'foo'

s.expandtabs(tabsize=8)

Développe les onglets dans une chaîne.

s.expandtabs() remplace chaque caractère de tabulation (' ') par des espaces. Par défaut, les espaces sont remplis en supposant un taquet de tabulation à chaque huitième colonne:

>>>

>>> 'a\tb\tc'.expandtabs()
'a       b       c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa     bbb     c'

tabsize est un paramètre de mot-clé facultatif spécifiant des colonnes de tabulation alternatives:

>>>

>>> 'a\tb\tc'.expandtabs(4)
'a   b   c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'

s.ljust([, ])

Justifie à gauche une chaîne dans le champ.

s.ljust(<width>) renvoie une chaîne composée des justifiés à gauche dans un champ de largeur<width>. Par défaut, le remplissage se compose du caractère d'espace ASCII:

>>>

>>> 'foo'.ljust(10)
'foo       '

Si l'argument optionnel<fill> est spécifié, il est utilisé comme caractère de remplissage:

>>>

>>> 'foo'.ljust(10, '-')
'foo-------'

Sis est déjà au moins aussi long que<width>, il est renvoyé inchangé:

>>>

>>> 'foo'.ljust(2)
'foo'

s.lstrip([])

Supprime les premiers caractères d'une chaîne.

s.lstrip() renvoie une copie des avec tous les caractères d'espacement supprimés de l'extrémité gauche:

>>>

>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'

Si l'argument optionnel<chars> est spécifié, il s'agit d'une chaîne qui spécifie le jeu de caractères à supprimer:

>>>

>>> 'http://www.realpython.com'.lstrip('/:pth')
'www.realpython.com'

s.replace(, [, ])

Remplace les occurrences d'une sous-chaîne dans une chaîne.

En Python, pour supprimer un caractère d'une chaîne, vous pouvez utiliser la méthode Python string.replace(). s.replace(<old>, <new>) renvoie une copie des avec toutes les occurrences de la sous-chaîne<old> remplacées par<new>:

>>>

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault')
'grault bar grault baz grault qux'

Si l'argument optionnel<count> est spécifié, un maximum de<count> remplacements est effectué, en commençant à l'extrémité gauche des:

>>>

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2)
'grault bar grault baz foo qux'

s.rjust([, ])

Justifie à droite une chaîne dans un champ.

s.rjust(<width>) renvoie une chaîne composée des justifiés à droite dans un champ de largeur<width>. Par défaut, le remplissage se compose du caractère d'espace ASCII:

>>>

>>> 'foo'.rjust(10)
'       foo'

Si l'argument optionnel<fill> est spécifié, il est utilisé comme caractère de remplissage:

>>>

>>> 'foo'.rjust(10, '-')
'-------foo'

Sis est déjà au moins aussi long que<width>, il est renvoyé inchangé:

>>>

>>> 'foo'.rjust(2)
'foo'

s.rstrip([])

Supprime les caractères de fin d'une chaîne.

s.rstrip() renvoie une copie des avec tous les espaces blancs supprimés de l'extrémité droite:

>>>

>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'

Si l'argument optionnel<chars> est spécifié, il s'agit d'une chaîne qui spécifie le jeu de caractères à supprimer:

>>>

>>> 'foo.$$$;'.rstrip(';$.')
'foo'

s.strip([])

Supprime les caractères des extrémités gauche et droite d'une chaîne.

s.strip() équivaut essentiellement à invoquer successivements.lstrip() ets.rstrip(). Sans l'argument<chars>, il supprime les espaces de début et de fin:

>>>

>>> s = '   foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'

Comme pour.lstrip() et.rstrip(), l'argument optionnel<chars> spécifie le jeu de caractères à supprimer:

>>>

>>> 'www.realpython.com'.strip('w.moc')
'realpython'

Note: Lorsque la valeur de retour d'une méthode string est une autre chaîne, comme c'est souvent le cas, les méthodes peuvent être appelées successivement en chaînant les appels:

>>>

>>> '   foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar baz\t\t\t'.strip()
'foo bar baz'

>>> 'www.realpython.com'.lstrip('w.moc').rstrip('w.moc')
'realpython'
>>> 'www.realpython.com'.strip('w.moc')
'realpython'

s.zfill()

Remplit une chaîne à gauche avec des zéros.

s.zfill(<width>) renvoie une copie des complétée à gauche avec les caractères'0' vers le<width> spécifié:

>>>

>>> '42'.zfill(5)
'00042'

Sis contient un signe de tête, il reste sur le bord gauche de la chaîne de résultat après l'insertion de zéros:

>>>

>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'

Sis est déjà au moins aussi long que<width>, il est renvoyé inchangé:

>>>

>>> '-42'.zfill(3)
'-42'

.zfill() est le plus utile pour les représentations sous forme de chaîne de nombres, mais Python remplira toujours volontiers une chaîne qui n'est pas:

>>>

>>> 'foo'.zfill(6)
'000foo'

Conversion entre chaînes et listes

Les méthodes de ce groupe convertissent entre une chaîne et un type de données composite en collant des objets ensemble pour créer une chaîne ou en divisant une chaîne en morceaux.

Ces méthodes fonctionnent sur ou renvoientiterables, le terme Python général pour une collection séquentielle d'objets. Vous explorerez le fonctionnement interne des itérables plus en détail dans le prochain tutoriel sur l'itération définie.

Beaucoup de ces méthodes renvoient une liste ou un tuple. Ce sont deux types de données composites similaires qui sont des exemples prototypiques d'itérables en Python. Ils sont traités dans le prochain didacticiel, alors vous êtes sur le point de les découvrir bientôt! Jusque-là, considérez-les simplement comme des séquences de valeurs. Une liste est placée entre crochets ([]) et un tuple est entre parenthèses (()).

Avec cette introduction, examinons ce dernier groupe de méthodes de chaîne.

s.join()

Concatène les chaînes d'un itérable.

s.join(<iterable>) renvoie la chaîne qui résulte de la concaténation des objets en<iterable> séparés pars.

Notez que.join() est appelé surs, la chaîne de séparation. <iterable> doit également être une séquence d'objets chaîne.

Un exemple de code devrait aider à clarifier. Dans l'exemple suivant, le séparateurs est la chaîne', ' et<iterable> est une liste de valeurs de chaîne:

>>>

>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'

Le résultat est une chaîne unique composée des objets de liste séparés par des virgules.

Dans l'exemple suivant,<iterable> est spécifié comme une valeur de chaîne unique. Lorsqu'une valeur de chaîne est utilisée comme un itérable, elle est interprétée comme une liste des caractères individuels de la chaîne:

>>>

>>> list('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'.join('corge')
'c:o:r:g:e'

Ainsi, le résultat de':'.join('corge') est une chaîne composée de chaque caractère en'corge' séparé par':'.

Cet exemple échoue car l'un des objets de<iterable> n'est pas une chaîne:

>>>

>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "", line 1, in 
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found

Cela peut être résolu, cependant:

>>>

>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'

Comme vous le verrez bientôt, de nombreux objets composites en Python peuvent être interprétés comme des itérables, et.join() est particulièrement utile pour créer des chaînes à partir d'eux.

s.partition()

Divise une chaîne basée sur un séparateur.

s.partition(<sep>) divises à la première occurrence de la chaîne<sep>. La valeur de retour est un tuple en trois parties composé de:

La partie des qui précède<sep>
<sep> lui-même
La partie des suivant<sep>

Voici quelques exemples de.partition() en action:

>>>

>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

Si<sep> n'est pas trouvé danss, le tuple retourné contients suivi de deux chaînes vides:

>>>

>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')

Remember: Les listes et les tuples sont traités dans le prochain didacticiel.

s.rpartition()

Divise une chaîne basée sur un séparateur.

s.rpartition(<sep>) fonctionne exactement commes.partition(<sep>), sauf ques est divisé à la dernière occurrence de<sep> au lieu de la première occurrence:

>>>

>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')

s.rsplit(sep=None, maxsplit=-1)

Fractionne une chaîne en une liste de sous-chaînes.

Sans arguments,s.rsplit() divises en sous-chaînes délimitées par n'importe quelle séquence d'espaces et renvoie les sous-chaînes sous forme de liste:

>>>

>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar   baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']

Si<sep> est spécifié, il est utilisé comme délimiteur pour le fractionnement:

>>>

>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']

(Si<sep> est spécifié avec une valeur deNone, la chaîne est séparée par des espaces, tout comme si<sep> n'avait pas du tout été spécifié.)

Lorsque<sep> est explicitement donné comme délimiteur, les délimiteurs consécutifs ens sont supposés délimiter les chaînes vides, qui seront renvoyées:

>>>

>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']

Ce n'est cependant pas le cas lorsque<sep> est omis. Dans ce cas, les espaces blancs consécutifs sont combinés en un seul délimiteur, et la liste résultante ne contiendra jamais de chaînes vides:

>>>

>>> 'foo\t\t\tbar'.rsplit()
['foo', 'bar']

Si le paramètre de mot-clé facultatif<maxsplit> est spécifié, un maximum de ce nombre de fractionnements est effectué, à partir de l'extrémité droite des:

>>>

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1)
['www.realpython', 'com']

La valeur par défaut de<maxsplit> est-1, ce qui signifie que tous les fractionnements possibles doivent être effectués, comme si<maxsplit> était entièrement omis:

>>>

>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=-1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit(sep='.')
['www', 'realpython', 'com']

s.split(sep=None, maxsplit=-1)

Fractionne une chaîne en une liste de sous-chaînes.

s.split() se comporte exactement commes.rsplit(), sauf que si<maxsplit> est spécifié, les divisions sont comptées à partir de l'extrémité gauche des plutôt que de l'extrémité droite:

>>>

>>> 'www.realpython.com'.split('.', maxsplit=1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit('.', maxsplit=1)
['www.realpython', 'com']

Si<maxsplit> n'est pas spécifié,.split() et.rsplit() sont indiscernables.

s.splitlines([])

Coupe une chaîne aux limites de la ligne.

s.splitlines() divises en lignes et les renvoie dans une liste. L'un des caractères ou séquences de caractères suivants est considéré comme constituant une limite de ligne:

Séquence d'échappement Personnage

Séquence d'échappement	Personnage
`\n`	Nouvelle ligne
`\r`	Retour chariot
`\r\n`	Retour chariot + saut de ligne
ou	Tabulation des lignes
ou	Flux de formulaire
`\x1c`	Séparateur de fichiers
`\x1d`	Séparateur de groupe
`\x1e`	Séparateur d'enregistrement
`\x85`	Ligne suivante (code de contrôle C1)
`\u2028`	Séparateur de ligne Unicode
`\u2029`	Séparateur de paragraphes Unicode

\n

Nouvelle ligne

\r

Retour chariot

\r\n

Retour chariot + saut de ligne

Tabulation des lignes

Flux de formulaire

\x1c

Séparateur de fichiers

\x1d

Séparateur de groupe

\x1e

Séparateur d'enregistrement

\x85

Ligne suivante (code de contrôle C1)

\u2028

Séparateur de ligne Unicode

\u2029

Séparateur de paragraphes Unicode

Voici un exemple utilisant plusieurs séparateurs de ligne différents:

>>>

>>> 'foo\nbar\r\nbaz\fqux\u2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']

Si des caractères de limite de ligne consécutifs sont présents dans la chaîne, ils sont supposés délimiter des lignes vides, qui apparaîtront dans la liste des résultats:

>>>

>>> 'foo\f\f\fbar'.splitlines()
['foo', '', '', 'bar']

Si l'argument optionnel<keepends> est spécifié et est vrai, alors les limites des lignes sont conservées dans les chaînes de résultat:

>>>

>>> 'foo\nbar\nbaz\nqux'.splitlines(True)
['foo\n', 'bar\n', 'baz\n', 'qux']
>>> 'foo\nbar\nbaz\nqux'.splitlines(1)
['foo\n', 'bar\n', 'baz\n', 'qux']

Objets`bytes`

L'objetbytes est l'un des principaux types intégrés pour la manipulation de données binaires. Un objetbytes est une séquence immuable de valeursbyte uniques. Chaque élément d'un objetbytes est un petit entier compris entre0 et255.

Définition d'un objet littéral`bytes`

Un littéralbytes est défini de la même manière qu'un littéral chaîne avec l'ajout d'un préfixe'b':

>>>

>>> b = b'foo bar baz'
>>> b
b'foo bar baz'
>>> type(b)

Comme pour les chaînes, vous pouvez utiliser l'un des mécanismes de citation simple, double ou triple:

>>>

>>> b'Contains embedded "double" quotes'
b'Contains embedded "double" quotes'

>>> b"Contains embedded 'single' quotes"
b"Contains embedded 'single' quotes"

>>> b'''Contains embedded "double" and 'single' quotes'''
b'Contains embedded "double" and \'single\' quotes'

>>> b"""Contains embedded "double" and 'single' quotes"""
b'Contains embedded "double" and \'single\' quotes'

Seuls les caractères ASCII sont autorisés dans un littéralbytes. Toute valeur de caractère supérieure à127 doit être spécifiée à l'aide d'une séquence d'échappement appropriée:

>>>

>>> b = b'foo\xddbar'
>>> b
b'foo\xddbar'
>>> b[3]
221
>>> int(0xdd)
221

Le préfixe'r' peut être utilisé sur un littéralbytes pour désactiver le traitement des séquences d'échappement, comme avec les chaînes:

>>>

>>> b = rb'foo\xddbar'
>>> b
b'foo\\xddbar'
>>> b[3]
92
>>> chr(92)
'\\'

Définition d'un objet`bytes` avec la fonction`bytes()` intégrée

La fonctionbytes() crée également un objetbytes. Le type d'objetbytes renvoyé dépend du ou des arguments passés à la fonction. Les formes possibles sont présentées ci-dessous.

bytes(, )

Crée un objetbytes à partir d'une chaîne.

bytes(<s>, <encoding>) convertit la chaîne<s> en un objetbytes, en utilisantstr.encode() selon le<encoding> spécifié:

>>>

>>> b = bytes('foo.bar', 'utf8') >>> b b'foo.bar' >>> type(b)

Technical Note: Dans cette forme de la fonctionbytes(), l'argument<encoding> est requis. «Encodage» fait référence à la manière dont les caractères sont traduits en valeurs entières. Une valeur de"utf8" indique le format de transformation UnicodeUTF-8, qui est un codage qui peut gérer tous les caractères Unicode possibles. UTF-8 peut également être indiqué en spécifiant"UTF8","utf-8" ou"UTF-8" pour<encoding>.

Voir lesUnicode documentation pour plus d'informations. Tant que vous avez affaire à des caractères latins courants, UTF-8 vous sera très utile.

bytes()

Crée un objetbytes composé d'octets nuls (0x00).

bytes(<size>) définit un objetbytes du<size> spécifié, qui doit être un entier positif. L'objetbytes résultant est initialisé à null (0x00) octets:

>>>

>>> b = bytes(8) >>> b b'\x00\x00\x00\x00\x00\x00\x00\x00' >>> type(b)

bytes()

Crée un objetbytes à partir d'un itérable.

bytes(<iterable>) définit un objetbytes à partir de la séquence d'entiers générés par<iterable>. <iterable> doit être un itérable qui génère une séquence d'entiersn dans la plage0 ≤ n ≤ 255:

>>>

>>> b = bytes([100, 102, 104, 106, 108]) >>> b b'dfhjl' >>> type(b) >>> b[2] 104

Opérations sur les objetsbytes

Comme les chaînes, les objetsbytes prennent en charge les opérations de séquence courantes:

Les opérateursin etnot in:

>>>

>>> b = b'abcde' >>> b'cd' in b True >>> b'foo' not in b True

Les opérateurs de concaténation (+) et de réplication (*):

>>>

>>> b = b'abcde' >>> b + b'fghi' b'abcdefghi' >>> b * 3 b'abcdeabcdeabcde'

Indexation et découpage:

>>>

>>> b = b'abcde' >>> b[2] 99 >>> b[1:3] b'bc'

Fonctions intégrées:

>>>

>>> len(b) 5 >>> min(b) 97 >>> max(b) 101

La plupart des méthodes définies pour les objets chaîne sont également valides pour les objetsbytes:

>>>

>>> b = b'foo,bar,foo,baz,foo,qux' >>> b.count(b'foo') 3 >>> b.endswith(b'qux') True >>> b.find(b'baz') 12 >>> b.split(sep=b',') [b'foo', b'bar', b'foo', b'baz', b'foo', b'qux'] >>> b.center(30, b'-') b'---foo,bar,foo,baz,foo,qux----'

Notez cependant que lorsque ces opérateurs et méthodes sont appelés sur un objetbytes, l'opérande et les arguments doivent également être des objetsbytes:

>>>

>>> b = b'foo.bar' >>> b + '.baz' Traceback (most recent call last): File "", line 1, in b + '.baz' TypeError: can't concat bytes to str >>> b + b'.baz' b'foo.bar.baz' >>> b.split(sep='.') Traceback (most recent call last): File "", line 1, in b.split(sep='.') TypeError: a bytes-like object is required, not 'str' >>> b.split(sep=b'.') [b'foo', b'bar']

Bien que la définition et la représentation d'un objetbytes soient basées sur du texte ASCII, elles se comportent en réalité comme une séquence immuable de petits entiers compris entre0 et255 inclus. C'est pourquoi un seul élément d'un objetbytes est affiché sous forme d'entier:

>>>

>>> b = b'foo\xddbar' >>> b[3] 221 >>> hex(b[3]) '0xdd' >>> min(b) 97 >>> max(b) 221

Une tranche est cependant affichée comme un objetbytes, même si elle ne fait qu'un octet:

>>>

>>> b[2:3] b'c'

Vous pouvez convertir un objetbytes en une liste d'entiers avec la fonctionlist() intégrée:

>>>

>>> list(b) [97, 98, 99, 100, 101]

Les nombres hexadécimaux sont souvent utilisés pour spécifier des données binaires car deux chiffres hexadécimaux correspondent directement à un seul octet. La classebytes prend en charge deux méthodes supplémentaires qui facilitent la conversion vers et à partir d'une chaîne de chiffres hexadécimaux.

bytes.fromhex()

Renvoie un objetbytes construit à partir d'une chaîne de valeurs hexadécimales.

bytes.fromhex(<s>) renvoie l'objetbytes qui résulte de la conversion de chaque paire de chiffres hexadécimaux en<s> en valeur d'octet correspondante. Les paires de chiffres hexadécimaux en<s> peuvent éventuellement être séparées par des espaces, ce qui est ignoré:

>>>

>>> b = bytes.fromhex(' aa 68 4682cc ') >>> b b'\xaahF\x82\xcc' >>> list(b) [170, 104, 70, 130, 204]

Note: Cette méthode est une méthode de classe, pas une méthode objet. Il est lié à la classebytes, pas à un objetbytes. Vous approfondirez la distinction entre les classes, les objets et leurs méthodes respectives dans les prochains tutoriels surobject-oriented programming. Pour l'instant, observez simplement que cette méthode est appelée sur la classebytes, pas sur l'objetb.

b.hex()

Renvoie une chaîne de valeur hexadécimale à partir d'un objetbytes.

b.hex() renvoie le résultat de la conversion de l'objetbytesb en une chaîne de paires de chiffres hexadécimaux. Autrement dit, il fait l'inverse de.fromhex():

>>>

>>> b = bytes.fromhex(' aa 68 4682cc ') >>> b b'\xaahF\x82\xcc' >>> b.hex() 'aa684682cc' >>> type(b.hex())

Note: Contrairement à.fromhex(),.hex() est une méthode objet, pas une méthode de classe. Ainsi, il est invoqué sur un objet de la classebytes, pas sur la classe elle-même.

Objetsbytearray

Python prend en charge un autre type de séquence binaire appelébytearray. Les objetsbytearray ressemblent beaucoup aux objetsbytes, malgré quelques différences:

Il n'y a pas de syntaxe dédiée intégrée à Python pour définir un littéralbytearray, comme le préfixe'b' qui peut être utilisé pour définir un objetbytes. Un objetbytearray est toujours créé à l'aide de la fonction intégréebytearray():

>>>

>>> ba = bytearray('foo.bar.baz', 'UTF-8') >>> ba bytearray(b'foo.bar.baz') >>> bytearray(6) bytearray(b'\x00\x00\x00\x00\x00\x00') >>> bytearray([100, 102, 104, 106, 108]) bytearray(b'dfhjl')

Les objetsbytearray sont mutables. Vous pouvez modifier le contenu d'un objetbytearray en utilisant l'indexation et le découpage:

>>>

>>> ba = bytearray('foo.bar.baz', 'UTF-8') >>> ba bytearray(b'foo.bar.baz') >>> ba[5] = 0xee >>> ba bytearray(b'foo.b\xeer.baz') >>> ba[8:11] = b'qux' >>> ba bytearray(b'foo.b\xeer.qux')

Un objetbytearray peut également être construit directement à partir d'un objetbytes:

>>>

>>> ba = bytearray(b'foo') >>> ba bytearray(b'foo')

Conclusion

Ce didacticiel a fourni un aperçu détaillé des nombreux mécanismes que Python fournit pour la gestion destring, y compris les opérateurs de chaîne, les fonctions intégrées, l'indexation, le découpage et les méthodes intégrées. Vous avez également découvert les typesbytes etbytearray.

Ces types sont les premiers types que vous avez examinés qui sont composites, construits à partir d'une collection de pièces plus petites. Python fournit plusieurs types intégrés composites. Dans le prochain didacticiel, vous explorerez deux des plus fréquemment utilisés:lists ettuples.

__ Take the Quiz: Testez vos connaissances avec notre quiz interactif «Chaînes Python et données de caractères». À la fin, vous recevrez un score afin que vous puissiez suivre vos progrès d'apprentissage au fil du temps:

Fais le quiz "

TOC

Chaînes et données de caractères en Python