Pour générer une nouvelle liste à partir d'une liste (tableau) dont les éléments sont des chaînes de caractères, en extrayant uniquement les éléments des chaînes de caractères qui satisfont certaines conditions, ou en effectuant des substitutions, des conversions, etc., utilisez les compréhensions de listes.
Après une brève explication des compréhensions de listes, les contenus suivants sont expliqués avec un exemple de code.
- Extraction basée sur l'inclusion ou non d'une chaîne spécifique (correspondance partielle)
- Remplacer une chaîne spécifique
- Extraire en commençant ou non par une chaîne spécifique
- Extraire en se terminant ou non par une chaîne spécifique
- Jugés et extraits par cas
- Convertir les majuscules et les minuscules
- Détermine si les caractères alphabétiques ou numériques sont utilisés et les extrait.
- Conditions multiples
- Expression régulière (informatique)
Notez que les listes peuvent stocker différents types de données et sont strictement différentes des tableaux. Si vous souhaitez manipuler des tableaux dans le cadre de processus nécessitant des adresses mémoire et des tailles de mémoire ou le traitement numérique de données volumineuses, utilisez array (bibliothèque standard) ou NumPy.
- notation d'inclusion de liste
- Contient une chaîne spécifique (correspondance partielle) \ Ne contient pas: in
- Remplacer une chaîne spécifique
- Commence par une chaîne de caractères spécifique \N- ne commence pas: startswith()
- Se termine par une chaîne de caractères spécifique – ne se termine pas: endswith()
- Jugés et extraits par cas
- Convertir les majuscules et les minuscules
- Détermine si les caractères alphabétiques ou numériques sont utilisés et les extrait.
- Conditions multiples
- Expression régulière (informatique)
notation d'inclusion de liste
Lorsqu'il s'agit de générer une nouvelle liste à partir d'une liste, les comprehensions de listes sont plus simples à écrire que les boucles for.
[expression for any variable name in iterable object if conditional expression]
Si l'élément ne doit être sélectionné que par une expression conditionnelle, il n'est pas traité par une expression, il prend alors la forme suivante
[variable name for variable name in original list if conditional expression]
Si l'expression conditionnelle if est transformée en une expression conditionnelle if not, elle devient une négation, et les éléments qui ne satisfont pas l'expression conditionnelle peuvent être extraits.
Contient une chaîne spécifique (correspondance partielle) \ Ne contient pas: in
Dans “chaîne spécifique dans la chaîne originale”, renvoie Vrai si la chaîne originale contient la chaîne spécifique. Il s'agit d'une expression conditionnelle.
La négation de in se fait avec not in.
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
Si vous voulez remplacer une chaîne d'éléments de liste, utilisez la méthode replace() pour chaque élément de la notation de compréhension de la liste.
S'il n'y a pas de chaîne à remplacer, il n'est pas nécessaire de sélectionner l'élément dans l'expression conditionnelle if car il ne sera pas modifié par l'application de replace().
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Si vous voulez remplacer un élément entier qui contient une chaîne de caractères spécifique, extrayez-le avec in et traitez-le avec l'opérateur ternaire. L'opérateur ternaire s'écrit sous la forme suivante.True Value if Conditional Expression else False Value
Il n'y a pas de problème si la partie expression de la notation de compréhension de liste est un opérateur ternaire.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Voici un résumé des résultats, entre parenthèses. Si vous n'avez pas l'habitude d'utiliser des parenthèses, cela peut être plus facile à comprendre et éviter les erreurs. Grammaticalement, il n'y a pas de problème même si vous écrivez entre parenthèses.
[('ZZZ' if ('XXX' in s) else s) for s in l]
L'utilisation de in comme condition est déroutante avec la notation de compréhension de liste in, mais elle n'est pas difficile si vous connaissez la forme syntaxique de la notation de compréhension de liste et des opérateurs ternaires.
Commence par une chaîne de caractères spécifique \N- ne commence pas: startswith()
La méthode startswith() renvoie un résultat vrai si la chaîne commence par la chaîne spécifiée dans l'argument.
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']
Se termine par une chaîne de caractères spécifique – ne se termine pas: endswith()
La méthode endswith() renvoie un résultat vrai si la chaîne se termine par la chaîne spécifiée dans l'argument.
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']
Jugés et extraits par cas
Les méthodes isupper() et islower() peuvent être utilisées pour déterminer si une chaîne est entièrement en majuscules ou en minuscules.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
Convertir les majuscules et les minuscules
Si vous souhaitez convertir tous les caractères en majuscules ou en minuscules, utilisez les méthodes upper() et lower(). Parmi les autres méthodes, citons la méthode capitalize(), qui ne met en majuscule que la première lettre, et la méthode swapcase(), qui permute les majuscules et les minuscules.
Comme dans l'exemple de substitution ci-dessus, utilisez l'opérateur ternaire si vous voulez traiter uniquement les éléments qui satisfont à la condition.
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']
Détermine si les caractères alphabétiques ou numériques sont utilisés et les extrait.
Les méthodes de chaîne isalpha() et isnumeric() peuvent être utilisées pour déterminer si une chaîne est entièrement alphabétique, numérique, etc.
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
La partie expression conditionnelle des compréhensions de listes peut être constituée de plusieurs conditions. Les conditions négatives “pas” peuvent également être utilisées.
Lorsque vous utilisez trois expressions conditionnelles ou plus, il est plus sûr de mettre chaque groupe entre parenthèses () car le résultat variera en fonction de 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 (informatique)
Les expressions régulières permettent un traitement très souple.
L'objet match renvoyé par re.match() lorsqu'il correspond est toujours déterminé comme étant vrai lorsqu'il est évalué avec une expression conditionnelle. S'il ne correspond pas, il renvoie None, qui est faux dans l'expression conditionnelle. Ainsi, si vous voulez extraire uniquement les éléments qui correspondent à l'expression régulière, il suffit d'appliquer re.match() à la partie expression conditionnelle de l'expression de compréhension de liste comme précédemment.
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']
re.sub(), qui remplace la partie appariée d'une expression régulière, est également utile. Pour extraire et remplacer uniquement les éléments mis en correspondance, il suffit d'ajouter “si expression conditionnelle”.
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']
