En Python, vous pouvez générer une nouvelle liste à partir d’une liste de chaînes en extrayant, remplaçant ou transformant des éléments qui satisfont à certaines conditions avec des compréhensions de liste.
Cet article explique brièvement les compréhensions de la liste, puis décrit ce qui suit avec un exemple de code.
- Extraire les chaînes qui contiennent ou ne contiennent pas une chaîne spécifique
- Remplacer une chaîne spécifique dans une liste
- Extraire les chaînes qui commencent ou ne commencent pas par une chaîne spécifique
- Extraire les chaînes qui se terminent ou ne se terminent pas par une chaîne spécifique
- Extraire les chaînes en majuscules ou minuscules
- Convertir majuscule et minuscule
- Extraire les chaînes par ordre alphabétique ou numérique
- Conditions multiples
- Expression régulière (regex)
Consultez l’article suivant pour plus d’informations sur l’extraction et le remplacement de chaînes.
Lister les compréhensions
Pour générer une nouvelle liste à partir d’une liste, vous pouvez utiliser les compréhensions de liste, qui sont plus simples à écrire que la boucle for.
[expression for variable_name in iterable if condition]
Si vous souhaitez simplement extraire des éléments qui remplissent la condition, vous n’avez pas besoin de les traiter avec expression ; utilisez simplement variable_name.
[variable_name for variable_name in iterable if condition]
Si vous remplacez la condition if par la condition if not, vous pouvez extraire les éléments qui ne satisfont pas la condition.
Pour plus d’informations sur l’extraction, le remplacement et la conversion d’éléments de liste à l’aide des compréhensions de liste, reportez-vous à l’article suivant.
specific_string dans target_string renvoie True si target_string contient une specific_string. Utilisez pas dans pour la négation.
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']
l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']
Remplacer une chaîne spécifique dans une liste
Si vous souhaitez remplacer la chaîne d’éléments d’une liste, utilisez la méthode de chaîne replace () pour chaque élément avec la compréhension de la liste.
S’il n’y a pas de chaîne à remplacer, l’application de replace() ne la changera pas, vous n’avez donc pas besoin de sélectionner un élément avec la condition if.
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Pour remplacer un élément entier contenant une chaîne spécifique, extrayez-le avec in et utilisez des expressions conditionnelles (opérateur ternaire), X si condition sinon Y.
Utilisez des expressions conditionnelles pour la partie expression des compréhensions de liste.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Il peut être plus facile de comprendre et d’éviter les erreurs avec des parenthèses. Grammaticalement, peu importe qu’il y ait des parenthèses ou non.
[('ZZZ' if ('XXX' in s) else s) for s in l]
La méthode de chaîne startswith() renvoie True si la chaîne commence par la chaîne spécifique.
l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']
l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']
La méthode de chaîne endswith() renvoie True si la chaîne se termine par la chaîne spécifique.
l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']
l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']
Vous pouvez utiliser les méthodes de chaîne isupper(), islower() pour déterminer si une chaîne est entièrement en majuscules ou entièrement en minuscules.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
Convertir majuscule et minuscule
Si vous souhaitez convertir toutes les lettres en majuscules ou en minuscules, utilisez les méthodes de chaîne upper() ou lower(). D’autres méthodes sont également fournies, telles que capitalize() pour mettre en majuscule la première lettre et swapcase() pour permuter les majuscules et les minuscules.
Utilisez des expressions conditionnelles pour convertir uniquement les éléments qui satisfont aux conditions.
l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']
l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']
Vous pouvez utiliser les méthodes de chaîne isalpha() et isnumeric() pour déterminer si une chaîne est entièrement alphabétique ou entièrement numérique.
l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']
l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']
Conditions multiples
Vous pouvez également spécifier plusieurs conditions en utilisant et et ou dans la partie condition de la liste des compréhensions. Vous pouvez également utiliser la négation non.
Si vous utilisez plus de trois conditions, entourer chaque groupe de () est plus sûr car les résultats seront différents selon l’ordre.
l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']
l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']
Expression régulière (regex)
Vous pouvez utiliser des expressions régulières (regex) pour un traitement plus flexible.
re.match() renvoie un objet match s’il correspond, ou None s’il ne correspond pas.
Étant donné que les objets match sont évalués comme True et None comme False, si vous souhaitez extraire uniquement les éléments qui correspondent à un modèle regex, vous devez appliquer re.match() à la partie condition des compréhensions de liste comme dans les exemples précédents.
import re
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']
Vous pouvez également utiliser re.sub() pour remplacer la partie qui correspond à un modèle regex. Si vous souhaitez extraire et remplacer uniquement les éléments correspondants, ajoutez la condition if.
l_re_sub_all = [re.sub('(.*)XXX(.*)', r'2---1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']
l_re_sub = [re.sub('(.*)XXX(.*)', r'2---1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']