Om een nieuwe lijst te genereren uit een lijst (array) waarvan de elementen strings zijn, door alleen de elementen van strings te extraheren die aan bepaalde voorwaarden voldoen, of door substituties, conversies, enz. uit te voeren, gebruik je list comprehensions.
Na een korte uitleg van list comprehensions, wordt de volgende inhoud uitgelegd met voorbeeldcode.
- Extractie op basis van het al dan niet voorkomen van een specifieke string (gedeeltelijke overeenkomst)
- Vervangen specifieke string
- Uittreksel door te beginnen of niet te beginnen met een specifieke string
- Uittreksel door eindigen of niet eindigen met een specifieke string
- Per geval beoordeeld en geëxtraheerd
- Hoofdletters en kleine letters omzetten
- Bepaalt of alfabetische of numerieke tekens worden gebruikt en extraheert ze
- Meerdere voorwaarden
- (computer) reguliere expressie
Merk op dat lijsten verschillende soorten gegevens kunnen opslaan en strikt verschillend zijn van arrays. Als u arrays wilt verwerken in processen die geheugengrootte en geheugenadressen vereisen of numerieke verwerking van grote gegevens, gebruik dan array (standaardbibliotheek) of NumPy.
- lijst inclusie notatie
- Bevat een specifieke string (gedeeltelijke overeenkomst) \ Bevat geen: in
- Vervangen specifieke string
- Begint met een specifieke string: startswith()
- Eindigt met een specifieke tekenreeks: endswith()
- Per geval beoordeeld en geëxtraheerd
- Hoofdletters en kleine letters omzetten
- Bepaalt of alfabetische of numerieke tekens worden gebruikt en extraheert ze
- Meerdere voorwaarden
- (computer) reguliere expressie
lijst inclusie notatie
Bij het genereren van een nieuwe lijst uit een lijst, zijn list comprehensions eenvoudiger te schrijven dan for loops.
- GERELATEERD:Hoe Python lijst comprehensies te gebruiken
[expression for any variable name in iterable object if conditional expression]
Als het element alleen moet worden geselecteerd door een voorwaardelijke uitdrukking, wordt het niet verwerkt door een uitdrukking, dus neemt het de volgende vorm aan
[variable name for variable name in original list if conditional expression]
Als van de if voorwaardelijke uitdrukking een if niet voorwaardelijke uitdrukking wordt gemaakt, wordt het een negatie, en kunnen elementen die niet aan de voorwaardelijke uitdrukking voldoen, worden geëxtraheerd.
Bevat een specifieke string (gedeeltelijke overeenkomst) \ Bevat geen: in
In “specifieke tekenreeks in originele tekenreeks”, geeft True terug als de originele tekenreeks de specifieke tekenreeks bevat. Dit is een voorwaardelijke uitdrukking.
De ontkenning van in wordt gedaan met 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']
Vervangen specifieke string
Als je een string van lijstelementen wilt vervangen, gebruik je de stringmethode replace() voor elk element in de lijstbegripnotatie.
Als er geen string is die vervangen moet worden, is het niet nodig om het element in de if voorwaardelijke uitdrukking te selecteren, omdat het niet zal worden gewijzigd door het toepassen van replace().
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Als je een heel element wilt vervangen dat een specifieke string bevat, haal je het uit met in en verwerk je het met de ternaire operator. De ternaire operator wordt in de volgende vorm geschreven.True Value if Conditional Expression else False Value
Het is OK als het uitdrukkingsdeel van de lijstbegripnotatie een ternaire operator is.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Hieronder volgt een samenvatting van de resultaten, die tussen haakjes staan. Als u niet gewend bent haakjes te gebruiken, is het misschien gemakkelijker te begrijpen en fouten te vermijden. Grammaticaal is er geen probleem, zelfs niet als u haakjes schrijft.
[('ZZZ' if ('XXX' in s) else s) for s in l]
Het gebruik van in als voorwaarde is verwarrend met de list comprehension notatie in, maar het is niet moeilijk als je op de hoogte bent van de syntactische vorm van list comprehension notatie en ternaire operatoren.
Begint met een specifieke string: startswith()
De string methode startswith() geeft true terug als de string begint met de string gespecificeerd in het 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']
Eindigt met een specifieke tekenreeks: endswith()
De string methode endswith() geeft true terug als de string eindigt met de string die in het argument is opgegeven.
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']
Per geval beoordeeld en geëxtraheerd
De string methodes isupper(), islower() kunnen gebruikt worden om te bepalen of een string allemaal hoofdletters of allemaal kleine letters is.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
Hoofdletters en kleine letters omzetten
Als je alle tekens wilt omzetten naar hoofdletters of kleine letters, gebruik je de string methodes upper() en lower(). Andere methoden zijn capitalize(), die alleen de eerste letter hoofdletter geeft, en swapcase(), die hoofdletters en kleine letters verwisselt.
Net als in het substitutievoorbeeld hierboven, gebruik je de ternaire operator als je alleen elementen wilt verwerken die aan de voorwaarde voldoen.
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']
Bepaalt of alfabetische of numerieke tekens worden gebruikt en extraheert ze
De string methodes isalpha() en isnumeric() kunnen gebruikt worden om te bepalen of een string alfabetisch, numeriek, enz. is.
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']
Meerdere voorwaarden
Het voorwaardelijke uitdrukkingsdeel van list comprehensions kan uit meerdere voorwaarden bestaan. Negatieve “niet”-voorwaarden kunnen ook worden gebruikt.
Wanneer je drie of meer voorwaardelijke uitdrukkingen gebruikt, is het veiliger om elke groep tussen haakjes () te zetten, omdat het resultaat zal variëren afhankelijk van de volgorde.
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']
(computer) reguliere expressie
Reguliere expressies maken een zeer flexibele verwerking mogelijk.
Het match object geretourneerd door re.match() wanneer het matcht wordt altijd bepaald als waar wanneer het geëvalueerd wordt met een voorwaardelijke expressie. Als het niet overeenkomt, geeft het None terug, wat onwaar is in de voorwaardelijke expressie. Dus, als je alleen de elementen wilt extraheren die overeenkomen met de reguliere expressie, pas dan gewoon re.match() toe op het voorwaardelijke expressie deel van de lijst comprehensie expressie zoals eerder.
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(), dat het gematchte deel van een reguliere expressie vervangt, is ook nuttig. Om alleen de gematchte elementen te extraheren en te vervangen, voeg je “if voorwaardelijke expressie” toe.
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']
