Cet article décrit comment extraire une sous-chaîne d’une chaîne en Python. Vous pouvez extraire une sous-chaîne en spécifiant la position et le nombre de caractères, ou avec des modèles d’expression régulière.
- Extraire une sous-chaîne en spécifiant la position et le nombre de caractères
- Extraire un caractère par index
- Extraire une sous-chaîne en la découpant
- Extraire en fonction du nombre de caractères
- Extrayez une sous-chaîne avec des expressions régulières :
re.search(), re.findall() - Exemples de modèles d’expressions régulières
- Modèles de type joker
- Gourmand et non gourmand
- Extraire une partie du motif avec des parenthèses
- Faites correspondre n’importe quel caractère unique
- Faire correspondre le début/la fin de la chaîne
- Extraire par plusieurs motifs
- Insensible à la casse
Si vous souhaitez remplacer une sous-chaîne par une autre chaîne, consultez l’article suivant.
Extraire une sous-chaîne en spécifiant la position et le nombre de caractères
Vous pouvez obtenir un caractère à la position souhaitée en spécifiant un index dans []. Les index commencent par 0 (indexation de base zéro).
s = 'abcde'
print(s[0])
# a
print(s[4])
# e
Vous pouvez spécifier une position arrière avec des valeurs négatives. -1 représente le dernier caractère.
print(s[-1])
# e
print(s[-5])
# a
Une erreur est levée si l’index inexistant est spécifié.
# print(s[5])
# IndexError: string index out of range
# print(s[-6])
# IndexError: string index out of range
Vous pouvez extraire une sous-chaîne dans la plage start <= x < stop avec [start:step]. Si début est omis, la plage va du début, et si fin est omise, la plage va jusqu’à la fin.
s = 'abcde'
print(s[1:3])
# bc
print(s[:3])
# abc
print(s[1:])
# bcde
Vous pouvez également utiliser des valeurs négatives.
print(s[-4:-2])
# bc
print(s[:-2])
# abc
print(s[-4:])
# bcde
Si début > fin, aucune erreur n’est levée et un caractère vide » est extrait.
print(s[3:1])
#
print(s[3:1] == '')
# True
Hors plage est ignoré.
print(s[-100:100])
# abcde
En plus du début de la position de départ et de l’arrêt de la position de fin, vous pouvez spécifier un pas d’incrément comme [start:stop:step]. Si le pas est négatif, il est extrait par l’arrière.
print(s[1:4:2])
# bd
print(s[::2])
# ace
print(s[::3])
# ad
print(s[::-1])
# edcba
print(s[::-2])
# eca
Pour plus d’informations sur le découpage, consultez l’article suivant.
La fonction intégrée len() renvoie le nombre de caractères. Par exemple, vous pouvez l’utiliser pour obtenir le caractère central ou extraire la première ou la seconde moitié de la chaîne avec un découpage.
Notez que vous ne pouvez spécifier que des valeurs entières entières pour l’index [] et la tranche [:]. La division par / génère une erreur car le résultat est un nombre à virgule flottante float.
L’exemple suivant utilise la division entière //. La virgule décimale est tronquée.
s = 'abcdefghi'
print(len(s))
# 9
# print(s[len(s) / 2])
# TypeError: string indices must be integers
print(s[len(s) // 2])
# e
print(s[:len(s) // 2])
# abcd
print(s[len(s) // 2:])
# efghi
Vous pouvez utiliser des expressions régulières avec le module re de la bibliothèque standard.
Utilisez re.search() pour extraire une sous-chaîne correspondant à un modèle d’expression régulière. Spécifiez le modèle d’expression régulière comme premier paramètre et la chaîne cible comme deuxième paramètre.
import re
s = '012-3456-7890'
print(re.search(r'd+', s))
#
d correspond à un caractère numérique et + correspond à une ou plusieurs répétitions du motif précédent. Ainsi, d+ correspond à un ou plusieurs chiffres consécutifs.
Étant donné que la barre oblique inverse est utilisée dans les séquences spéciales d’expressions régulières telles que d, il est pratique d’utiliser une chaîne brute en ajoutant r avant » ou « ».
Lorsqu’une chaîne correspond au modèle, re.search() renvoie un objet match. Vous pouvez obtenir la partie correspondante sous forme de chaîne str par la méthode group() de l’objet match.
m = re.search(r'd+', s)
print(m.group())
# 012
print(type(m.group()))
# <class 'str'>
Comme dans l’exemple ci-dessus, re.search() renvoie uniquement l’objet match de la première partie, même s’il existe plusieurs parties correspondantes.
re.findall() renvoie toutes les parties correspondantes sous forme de liste de chaînes.
print(re.findall(r'd+', s))
# ['012', '3456', '7890']
Exemples de modèles d’expressions régulières
Cette section présente quelques exemples de modèles d’expressions régulières avec des méta-caractères/séquences spéciales.
Modèles de type joker
. correspond à n’importe quel caractère unique à l’exception d’un retour à la ligne, et * correspond à zéro ou plusieurs répétitions du modèle précédent.
Par exemple, a.*b correspond à la chaîne commençant par a et se terminant par b. Puisque * correspond à zéro répétition, il correspond également à ab.
print(re.findall('a.*b', 'axyzb'))
# ['axyzb']
print(re.findall('a.*b', 'a---b'))
# ['a---b']
print(re.findall('a.*b', 'aあいうえおb'))
# ['aあいうえおb']
print(re.findall('a.*b', 'ab'))
# ['ab']
+ correspond à une ou plusieurs répétitions du motif précédent. a.+b ne correspond pas à ab.
print(re.findall('a.+b', 'ab'))
# []
print(re.findall('a.+b', 'axb'))
# ['axb']
print(re.findall('a.+b', 'axxxxxxb'))
# ['axxxxxxb']
? correspond à zéro ou à un motif précédent. Dans le cas de a.?b, il correspond à ab et à la chaîne avec un seul caractère entre a et b.
print(re.findall('a.?b', 'ab'))
# ['ab']
print(re.findall('a.?b', 'axb'))
# ['axb']
print(re.findall('a.?b', 'axxb'))
# []
Gourmand et non gourmand
*, + et ? sont toutes des correspondances gourmandes, correspondant à autant de texte que possible. * ?, + ? et ?? sont des correspondances minimales non gourmandes, correspondant au moins de caractères possible.
s = 'axb-axxxxxxb'
print(re.findall('a.*b', s))
# ['axb-axxxxxxb']
print(re.findall('a.*?b', s))
# ['axb', 'axxxxxxb']
Si vous placez une partie d’un modèle d’expression régulière entre parenthèses (), vous pouvez extraire une sous-chaîne dans cette partie.
print(re.findall('a(.*)b', 'axyzb'))
# ['xyz']
Si vous souhaitez faire correspondre les parenthèses () en tant que caractères, échappez-les avec une barre oblique inverse .
print(re.findall(r'(.+)', 'abc(def)ghi'))
# ['(def)']
print(re.findall(r'((.+))', 'abc(def)ghi'))
# ['def']
Faites correspondre n’importe quel caractère unique
Entourer une chaîne de [] correspond à n’importe lequel des caractères de la chaîne.
Si vous connectez des points de code Unicode consécutifs avec -, comme [az], tous les caractères entre eux sont couverts. Par exemple, [az] correspond à n’importe quel caractère de l’alphabet minuscule.
print(re.findall('[abc]x', 'ax-bx-cx'))
# ['ax', 'bx', 'cx']
print(re.findall('[abc]+', 'abc-aaa-cba'))
# ['abc', 'aaa', 'cba']
print(re.findall('[a-z]+', 'abc-xyz'))
# ['abc', 'xyz']
Faire correspondre le début/la fin de la chaîne
^ correspond au début de la chaîne et $ correspond à la fin de la chaîne.
s = 'abc-def-ghi'
print(re.findall('[a-z]+', s))
# ['abc', 'def', 'ghi']
print(re.findall('^[a-z]+', s))
# ['abc']
print(re.findall('[a-z]+$', s))
# ['ghi']
Utiliser | pour extraire une sous-chaîne qui correspond à l’un des multiples modèles. Par exemple, pour les modèles d’expressions régulières A et B, vous pouvez écrire A|B.
s = 'axxxb-012'
print(re.findall('a.*b', s))
# ['axxxb']
print(re.findall(r'd+', s))
# ['012']
print(re.findall(r'a.*b|d+', s))
# ['axxxb', '012']
Insensible à la casse
Le module re est sensible à la casse par défaut. Définissez l’argument flags sur re.IGNORECASE pour ne pas tenir compte de la casse.
s = 'abc-Abc-ABC'
print(re.findall('[a-z]+', s))
# ['abc', 'bc']
print(re.findall('[A-Z]+', s))
# ['A', 'ABC']
print(re.findall('[a-z]+', s, flags=re.IGNORECASE))
# ['abc', 'Abc', 'ABC']