Per generare una nuova lista da una lista (array) i cui elementi sono stringhe, estraendo solo gli elementi delle stringhe che soddisfano certe condizioni, o eseguendo sostituzioni, conversioni, ecc.
Dopo una breve spiegazione della comprensione delle liste, vengono spiegati i seguenti contenuti con codice di esempio.
- Estrazione basata sull'inclusione o meno di una specifica stringa (corrispondenza parziale)
- Sostituire la stringa specifica
- Estrarre iniziando o non iniziando con una stringa specifica
- Estrarre finendo o non finendo con una stringa specifica
- Giudicato ed estratto per caso
- Convertire maiuscole e minuscole
- Determina se si tratta di caratteri alfabetici o numerici e li estrae
- Condizioni multiple
- (computer) espressione regolare
Notate che le liste possono memorizzare diversi tipi di dati e sono strettamente diverse dagli array. Se volete gestire gli array in processi che richiedono dimensioni e indirizzi di memoria o l'elaborazione numerica di grandi dati, usate array (libreria standard) o NumPy.
- notazione di inclusione della lista
- Contiene una stringa specifica (corrispondenza parziale) \ Non contiene: in
- Sostituire la stringa specifica
- Inizia con una stringa specifica \non inizia: startswith()
- Finisce con una specifica stringa di caratteri \non finisce: endswith()
- Giudicato ed estratto per caso
- Convertire maiuscole e minuscole
- Determina se si tratta di caratteri alfabetici o numerici e li estrae
- Condizioni multiple
- (computer) espressione regolare
notazione di inclusione della lista
Quando si genera una nuova lista da una lista, le list comprehensions sono più semplici da scrivere rispetto ai cicli for.
[expression for any variable name in iterable object if conditional expression]
Se l'elemento deve essere selezionato solo da un'espressione condizionale, non viene processato da un'espressione, quindi assume la seguente forma
[variable name for variable name in original list if conditional expression]
Se l'espressione condizionale if viene trasformata in un'espressione condizionale if not, diventa una negazione, e gli elementi che non soddisfano l'espressione condizionale possono essere estratti.
Contiene una stringa specifica (corrispondenza parziale) \ Non contiene: in
In “stringa specifica nella stringa originale”, restituisce True se la stringa originale contiene la stringa specifica. Questa è un'espressione condizionale.
La negazione di in si fa con 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']
Sostituire la stringa specifica
Se volete sostituire una stringa di elementi della lista, usate il metodo stringa replace() per ogni elemento nella notazione di comprensione della lista.
Se non c'è nessuna stringa da sostituire, non c'è bisogno di selezionare l'elemento nell'espressione condizionale if perché non sarà cambiato applicando replace().
l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']
Se volete sostituire un intero elemento che contiene una specifica stringa, estraetelo con in ed elaboratelo con l'operatore ternario. L'operatore ternario è scritto nella forma seguente.True Value if Conditional Expression else False Value
Va bene se la parte di espressione della notazione di comprensione della lista è un operatore ternario.
l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']
Quello che segue è un riassunto dei risultati, racchiuso tra parentesi. Se non siete abituati a usare le parentesi, può essere più facile capire ed evitare errori. Grammaticalmente, non ci sono problemi anche se si scrivono le parentesi.
[('ZZZ' if ('XXX' in s) else s) for s in l]
L'uso di in come condizione confonde con la notazione di comprensione della lista in, ma non è difficile se si conosce la forma sintattica della notazione di comprensione della lista e degli operatori ternari.
Inizia con una stringa specifica \non inizia: startswith()
Il metodo startswith() restituisce true se la stringa inizia con la stringa specificata nell'argomento.
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']
Finisce con una specifica stringa di caratteri \non finisce: endswith()
Il metodo endswith() restituisce true se la stringa finisce con la stringa specificata nell'argomento.
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']
Giudicato ed estratto per caso
I metodi di stringa isupper(),islower() possono essere usati per determinare se una stringa è tutta maiuscola o tutta minuscola.
l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']
Convertire maiuscole e minuscole
Se volete convertire tutti i caratteri in maiuscolo o minuscolo, usate i metodi stringa upper() e lower(). Altri metodi includono capitalize(), che capitalizza solo la prima lettera, e swapcase(), che scambia lettere maiuscole e minuscole.
Come nell'esempio di sostituzione precedente, usate l'operatore ternario se volete elaborare solo gli elementi che soddisfano la condizione.
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']
Determina se si tratta di caratteri alfabetici o numerici e li estrae
I metodi di stringa isalpha() e isnumeric() possono essere usati per determinare se una stringa è tutta alfabetica, numerica, ecc.
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']
Condizioni multiple
La parte dell'espressione condizionale della comprensione delle liste può essere costituita da condizioni multiple. Si possono anche usare condizioni negative “non”.
Quando si usano tre o più espressioni condizionali, è più sicuro racchiudere ogni gruppo tra parentesi () perché il risultato varia a seconda dell'ordine.
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) espressione regolare
Le espressioni regolari permettono un'elaborazione molto flessibile.
L'oggetto match restituito da re.match() quando corrisponde è sempre determinato ad essere vero quando valutato con un'espressione condizionale. Se non corrisponde, restituisce None, che è falso nell'espressione condizionale. Quindi, se volete estrarre solo gli elementi che corrispondono all'espressione regolare, basta applicare re.match() alla parte dell'espressione condizionale dell'espressione di comprensione della lista come prima.
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']
Anche re.sub(), che sostituisce la parte abbinata di un'espressione regolare, è utile. Per estrarre e sostituire solo gli elementi abbinati, basta aggiungere “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']