Använd list comprehensions för att generera en ny lista från en lista (array) vars element är strängar, genom att endast extrahera de element av strängar som uppfyller vissa villkor, eller genom att utföra substitutioner, konverteringar osv.
Efter en kort förklaring av listförståelser förklaras följande innehåll med exempelkod.
- Utdragning baserad på om en viss sträng är inkluderad eller inte (partiell matchning).
- Ersätt en specifik sträng
- Extrahera genom att börja eller inte börja med en specifik sträng
- Extrahera genom att sluta eller inte sluta med en specifik sträng
- Bedömd och uttagen per fall
- Konvertera stora och små bokstäver
- Fastställer om alfabetiska eller numeriska tecken används och extraherar dem.
- Flera villkor
- (dator) reguljära uttryck
Observera att listor kan lagra olika typer av data och skiljer sig strikt från matriser. Om du vill hantera matriser i processer som kräver minnesstorlek och minnesadresser eller numerisk behandling av stora data, använd array (standardbiblioteket) eller NumPy.
- Notering för inkludering av en lista.
- Innehåller en specifik sträng (partiell matchning) \ Innehåller inte: in
- Ersätt en specifik sträng
- Börjar med en specifik sträng \ börjar inte: startswith()
- Slutar med en specifik teckensträng \ slutar inte: endswith()
- Bedömd och uttagen per fall
- Konvertera stora och små bokstäver
- Fastställer om alfabetiska eller numeriska tecken används och extraherar dem.
- Flera villkor
- (dator) reguljära uttryck
Notering för inkludering av en lista.
När du skapar en ny lista från en lista är listförståelser enklare att skriva än for-slingor.
- RELATERAT:Hur man använder Pythons listförståelser
[expression for any variable name in iterable object if conditional expression]
Om elementet endast ska väljas med hjälp av ett villkorligt uttryck behandlas det inte med ett uttryck, så det har följande form
[variable name for variable name in original list if conditional expression]
Om det villkorliga if-uttrycket omvandlas till ett villkorligt if not-uttryck blir det en negation, och element som inte uppfyller det villkorliga uttrycket kan extraheras.
Innehåller en specifik sträng (partiell matchning) \ Innehåller inte: in
I ”specifik sträng i ursprunglig sträng” returneras True om den ursprungliga strängen innehåller den specifika strängen. Detta är ett villkorligt uttryck.
Negationen av in görs med 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']
Ersätt en specifik sträng
Om du vill ersätta en sträng av listelement använder du strängmetoden replace() för varje element i listförståelsen.
Om det inte finns någon sträng som ska ersättas behöver du inte välja elementet i det villkorliga if-uttrycket eftersom det inte kommer att ändras genom replace().
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Om du vill ersätta ett helt element som innehåller en specifik sträng, extraherar du det med in och bearbetar det med den ternära operatorn. Den ternära operatören skrivs i följande form.True Value if Conditional Expression else False Value
Det är OK om uttrycksdelen i listförståelsen är en ternär operator.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Nedan följer en sammanfattning av resultaten, inom parentes. Om du inte är van vid att använda parenteser kan det vara lättare att förstå och undvika misstag. Grammatiskt sett är det inget problem även om du skriver parenteser.
[('ZZZ' if ('XXX' in s) else s) for s in l]
Användningen av in som villkor är förvirrande med listförståelsenotationen in, men det är inte svårt om du känner till den syntaktiska formen för listförståelsenotationen och de ternära operatörerna.
Börjar med en specifik sträng \ börjar inte: startswith()
Strängmetoden startswith() returnerar sant om strängen börjar med den sträng som anges i argumentet.
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']
Slutar med en specifik teckensträng \ slutar inte: endswith()
Strängmetoden endswith() returnerar sant om strängen slutar med den sträng som anges i argumentet.
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']
Bedömd och uttagen per fall
Strängmetoderna isupper() och islower() kan användas för att avgöra om en sträng har stora eller små bokstäver.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
Konvertera stora och små bokstäver
Om du vill konvertera alla tecken till versaler eller gemener använder du strängmetoderna upper() och lower(). Andra metoder är capitalize(), som endast kapitaliserar den första bokstaven, och swapcase(), som byter mellan stora och små bokstäver.
Precis som i substitutionsexemplet ovan använder du den ternära operatorn om du vill bearbeta endast element som uppfyller villkoret.
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']
Fastställer om alfabetiska eller numeriska tecken används och extraherar dem.
Strängmetoderna isalpha() och isnumeric() kan användas för att avgöra om en sträng är helt alfabetisk, numerisk osv.
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']
Flera villkor
Den villkorliga uttrycksdelen i listförståelser kan bestå av flera villkor. Negativa ”not”-villkor kan också användas.
När du använder tre eller fler villkorliga uttryck är det säkrare att sätta varje grupp inom parentes () eftersom resultatet kommer att variera beroende på ordningen.
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']
(dator) reguljära uttryck
Reguljära uttryck möjliggör en mycket flexibel behandling.
Matchobjektet som returneras av re.match() när det matchar bestäms alltid vara sant när det utvärderas med ett villkorligt uttryck. Om det inte matchar returneras None, vilket är falskt i det villkorliga uttrycket. Så om du vill extrahera endast de element som matchar det reguljära uttrycket är det bara att tillämpa re.match() på den villkorliga uttrycksdelen av listförståelseuttrycket som tidigare.
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(), som ersätter den matchade delen av ett reguljärt uttryck, är också användbart. Om du vill extrahera och ersätta endast de matchade delarna är det bara att lägga till ”if conditional expression”.
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']
