Questo articolo descrive come estrarre una sottostringa da una stringa in Python. È possibile estrarre una sottostringa specificando la posizione e il numero di caratteri o con modelli di espressioni regolari.
- Estrarre una sottostringa specificando la posizione e il numero di caratteri
- Estrai un carattere per indice
- Estrai una sottostringa tagliandola
- Estrai in base al numero di caratteri
- Estrai una sottostringa con espressioni regolari:
re.search(), re.findall() - Esempi di pattern di espressioni regolari
- Modelli simili a caratteri jolly
- Avidi e non avidi
- Estrarre parte del motivo tra parentesi
- Abbina qualsiasi singolo carattere
- Abbina l’inizio/la fine della stringa
- Estrai da più modelli
- Senzacole distinguere tra maiuscole e minuscole
Se si desidera sostituire una sottostringa con un’altra stringa, vedere l’articolo seguente.
Estrarre una sottostringa specificando la posizione e il numero di caratteri
È possibile ottenere un carattere nella posizione desiderata specificando un indice in []. Gli indici iniziano con 0 (indicizzazione in base zero).
s = 'abcde'
print(s[0])
# a
print(s[4])
# e
È possibile specificare una posizione all’indietro con valori negativi. -1 rappresenta l’ultimo carattere.
print(s[-1])
# e
print(s[-5])
# a
Viene generato un errore se viene specificato l’indice inesistente.
# print(s[5])
# IndexError: string index out of range
# print(s[-6])
# IndexError: string index out of range
Puoi estrarre una sottostringa nell’intervallo start <= x < stop con [start:step]. Se start è omesso, l’intervallo è dall’inizio e se end è omesso, l’intervallo è alla fine.
s = 'abcde'
print(s[1:3])
# bc
print(s[:3])
# abc
print(s[1:])
# bcde
Puoi anche usare valori negativi.
print(s[-4:-2])
# bc
print(s[:-2])
# abc
print(s[-4:])
# bcde
Se inizio > fine, non viene generato alcun errore e viene estratto un carattere vuoto ”.
print(s[3:1])
#
print(s[3:1] == '')
# True
Fuori portata viene ignorato.
print(s[-100:100])
# abcde
Oltre alla posizione iniziale di inizio e fine della posizione di arresto, è possibile specificare un passo di incremento come [start:stop:step]. Se il passo è negativo, viene estratto dal retro.
print(s[1:4:2])
# bd
print(s[::2])
# ace
print(s[::3])
# ad
print(s[::-1])
# edcba
print(s[::-2])
# eca
Per ulteriori informazioni sull’affettatura, vedere il seguente articolo.
La funzione incorporata len() contiene il numero di caratteri. Ad esempio, puoi usare per ottenere il carattere centrale o estrarre la prima o la seconda metà della stringa con lo slicing.
Si noti che è possibile specificare solo valori interi int per index [] e slice [:]. La divisione per / generi un errore perché il risultato è un numero a virgola mobile float.
L’esempio seguente usa la divisione intera //. Il punto decimale viene troncato.
s = 'abcdefghi'
print(len(s))
# 9
# print(s[len(s) / 2])
# TypeError: string indices must be integers
print(s[len(s) // 2])
# e
print(s[:len(s) // 2])
# abcd
print(s[len(s) // 2:])
# efghi
È possibile utilizzare espressioni regolari con il modulo re della libreria standard.
Utilizzare re.search() per estrarre una sottostringa che corrisponde a un modello di regolare. Specificare il modello di espressione regolare come primo parametro e la stringa di destinazione come secondo parametro.
import re
s = '012-3456-7890'
print(re.search(r'd+', s))
#
d corrisponde a un carattere numerico e + corrisponde a una o più ripetizioni del modello precedente. Pertanto, d+ corrisponde a una o più cifre consecutive.
Poiché la barra rovesciata viene utilizzata in speciali di espressioni regolari come d, è conveniente utilizzare una stringa grezza aggiungendo r prima di ” o “”.
Quando una stringa corrisponde al modello, re.search() restituisce un oggetto di corrispondenza. Puoi ottenere la parte corrispondente come una stringa str dal metodo group() dell’oggetto match.
m = re.search(r'd+', s)
print(m.group())
# 012
print(type(m.group()))
# <class 'str'>
Come nell’esempio sopra, re.search() restituisce solo l’oggetto match della prima parte, anche se ci sono più parti corrispondenti.
re.fill() contiene tutte le parti associate come un elenco di stringhe.
print(re.findall(r'd+', s))
# ['012', '3456', '7890']
Esempi di pattern di espressioni regolari
Questa sezione presenta alcuni esempi di modelli di espressioni regolari con metacaratteri/sequenze speciali.
Modelli simili a caratteri jolly
. corrisponde a un singolo carattere tranne una nuova riga e * corrisponde a zero o più ripetizioni del modello precedente.
Ad esempio, a.*b corrisponde alla stringa che inizia con ae termina con b. Poiché * corrisponde a zero ripetizioni, corrisponde anche ad ab.
print(re.findall('a.*b', 'axyzb'))
# ['axyzb']
print(re.findall('a.*b', 'a---b'))
# ['a---b']
print(re.findall('a.*b', 'aあいうえおb'))
# ['aあいうえおb']
print(re.findall('a.*b', 'ab'))
# ['ab']
+ corrisponde a una o più ripetizioni del pattern precedente. a.+b non corrisponde ab.
print(re.findall('a.+b', 'ab'))
# []
print(re.findall('a.+b', 'axb'))
# ['axb']
print(re.findall('a.+b', 'axxxxxxb'))
# ['axxxxxxb']
? corrisponde a zero oa uno schema precedente. Nel caso di a.?b, abbina ab e la stringa con un solo carattere tra ae b.
print(re.findall('a.?b', 'ab'))
# ['ab']
print(re.findall('a.?b', 'axb'))
# ['axb']
print(re.findall('a.?b', 'axxb'))
# []
Avidi e non avidi
*, + e ? sono tutte partite avide, corrispondenti a quanto più testo possibile. *?, +? e?? sono corrispondenze non avide, minime, corrispondente al minor numero di caratteri possibile.
s = 'axb-axxxxxxb'
print(re.findall('a.*b', s))
# ['axb-axxxxxxb']
print(re.findall('a.*?b', s))
# ['axb', 'axxxxxxb']
Se racchiudi parte di un modello di espressione regolare tra parentesi (), puoi estrarre una sottostringa in quella parte.
print(re.findall('a(.*)b', 'axyzb'))
# ['xyz']
Se vuoi abbinare parentesi () come caratteri, esegui l’escape con una barra rovesciata.
print(re.findall(r'(.+)', 'abc(def)ghi'))
# ['(def)']
print(re.findall(r'((.+))', 'abc(def)ghi'))
# ['def']
Abbina qualsiasi singolo carattere
Racchiudere una stringa con [] corrisponde a uno qualsiasi dei caratteri nella stringa.
Se colleghi punti di codice Unicode consecutivi con -, come [az], tutti i caratteri tra di loro vengono coperti. Ad esempio, [az] corrisponde a qualsiasi carattere dell’alfabeto minuscolo.
print(re.findall('[abc]x', 'ax-bx-cx'))
# ['ax', 'bx', 'cx']
print(re.findall('[abc]+', 'abc-aaa-cba'))
# ['abc', 'aaa', 'cba']
print(re.findall('[a-z]+', 'abc-xyz'))
# ['abc', 'xyz']
Abbina l’inizio/la fine della stringa
^ corrisponde all’inizio della stringa e $ corrisponde alla fine della stringa.
s = 'abc-def-ghi'
print(re.findall('[a-z]+', s))
# ['abc', 'def', 'ghi']
print(re.findall('^[a-z]+', s))
# ['abc']
print(re.findall('[a-z]+$', s))
# ['ghi']
Usa | per estrarre una sottostringa che corrisponde a uno dei pattern multipli. Ad esempio, per i modelli di espressioni regolari A e B, puoi scrivere A|B.
s = 'axxxb-012'
print(re.findall('a.*b', s))
# ['axxxb']
print(re.findall(r'd+', s))
# ['012']
print(re.findall(r'a.*b|d+', s))
# ['axxxb', '012']
Senzacole distinguere tra maiuscole e minuscole
Il modulo re distingue tra maiuscole e minuscole per la definizione predefinita. Impostare l’argomento flags su re.IGNORECASE per eseguire la distinzione tra maiuscole e minuscole.
s = 'abc-Abc-ABC'
print(re.findall('[a-z]+', s))
# ['abc', 'bc']
print(re.findall('[A-Z]+', s))
# ['A', 'ABC']
print(re.findall('[a-z]+', s, flags=re.IGNORECASE))
# ['abc', 'Abc', 'ABC']