7 modi per verificare se una stringa Python contiene una sottostringa

Lavorare con le stringhe è un compito comune in Python. Spesso è necessario capire se una stringa contiene un'altra stringa.

I metodi più semplici per verificare se una stringa Python contiene una sottostringa includono l'operatore 'in', la funzione find() e il metodo index(). Scenari più complessi possono essere risolti con espressioni regolari o una libreria esterna come Pandas.

Questo articolo ti mostra:

• quattro semplici metodi

• due funzioni regex più complesse

• un metodo che utilizza la libreria Pandas

Imparerai ogni tecnica attraverso esempi della loro sintassi e utilizzo. Riceverai anche suggerimenti su quale metodo è il migliore per requisiti diversi.

Iniziamo!

Sommario

• Nozioni di base sulle stringhe Python
• 4 modi più semplici per verificare la presenza di sottostringhe
  • 1. In Operatore
  • 2. Metodo Find()
  • 3. Metodo Index()
  • 4. Metodo Count()
• 2 modi per abbinare stringhe con espressioni regolari
  • 1. re.Ricerca()
  • 2. re.Findall()
• Come trovare le sottostringhe con i panda
  • Funzione str.contains() in Panda
• Suggerimenti per la scelta di un metodo specifico in Python
  • 1. Velocità di elaborazione
  • 2. Posizione della sottostringa
  • 3. Conteggio della sottostringa
  • 4. Schemi complessi
  • 5. Esecuzione dell'analisi del testo
• Pensieri finali

Nozioni di base sulle stringhe Python

Una stringa in Python è una sequenza di caratteri utilizzata per rappresentare dati basati su testo. Possono includere lettere, cifre, simboli e spazi bianchi.

È uno dei tipi di dati incorporati in Python e può essere creato utilizzando:

• virgolette singole (' ')

• virgolette (" ")

• virgolette triple (”' ”' o “”” “””)

Le stringhe sono indicizzate, il che significa che puoi accedere a caratteri specifici facendo riferimento al loro numero di indice. L'indice iniziale è 0, il che significa che il primo carattere di una stringa ha indice 0, il secondo ha indice 1 e così via.

Successivamente, esaminiamo i modi per verificare la presenza di sottostringhe.

4 modi più semplici per verificare la presenza di sottostringhe

Python fornisce molti modi per verificare se una certa sottostringa esiste all'interno di una stringa più grande. Alcuni sono più complessi di altri. Per i controlli più basilari, i metodi più semplici sono l'operatore in o uno dei tre metodi stringa.

1. nell'operatore

2. metodo find()

3. metodo indice()

4. metodo conteggio()

1. In Operatore

L'operatore 'in' in Python è un modo semplice e intuitivo per verificare se una stringa esiste all'interno di un'altra stringa. Questo operatore verifica l'appartenenza e restituisce un valore booleano:

• Vero se la sottostringa si trova all'interno della stringa principale

• Falso se non lo è

Ecco un po' di codice di esempio:

s = "Hello, world!"
sub = "world"
result = sub in s
print(result)  # Output: True

L'operatore 'in' fa distinzione tra maiuscole e minuscole. Ciò significa che tratta i caratteri minuscoli e maiuscoli come diversi. Il codice precedente non troverà la sottostringa "hello", quindi l'operatore restituisce false.

Se si desidera eseguire un controllo senza distinzione tra maiuscole e minuscole, è possibile convertire sia la stringa principale che la sottostringa nello stesso caso prima di eseguire il controllo:

s = "Hello, world!"
sub = "hello"
result = sub.lower() in s.lower()
print(result)  # Output: True

Lo svantaggio dell'operatore in è che non fornisce la posizione della sottostringa all'interno della stringa principale. Per questo, avresti bisogno di un altro metodo in questa sezione. Continuare a leggere…

2. Metodo Find()

Il metodo find() restituisce il primo indice in cui appare la sottostringa, o -1 se la sottostringa non viene trovata.

Si chiama il metodo find() su una stringa s , passando la sottostringa sub come argomento. Ecco un esempio:

s = "Hello, world!"
sub = "world"
index = s.find(sub)

if index != -1:
     print("Found at index:", index)  # Output: Found at index: 7
else:
     print("Not found")

È possibile specificare facoltativamente un indice iniziale o finale per limitare la ricerca. Lo svantaggio di questo metodo è che si ferma alla prima occorrenza.

3. Metodo Index()

Il metodo index() è abbastanza simile al metodo find() , tranne per il fatto che solleva un ValueError quando la sottostringa non viene trovata. Ciò significa che dovresti avvolgere la chiamata in una sezione Try/Except.

Per utilizzare il metodo index() , chiamalo su una stringa s e passa la sottostringa sub come argomento.

s = "Hello, world!"
sub = "world"

try: 
     index = s.index(sub)
     print("Found at index:", index)  # Output: Found at index: 7
except ValueError:
     print("Not found")

Questo metodo si ferma anche alla prima sottostringa all'interno del testo.

4. Metodo Count()

Il metodo .count() conta quante volte si verifica una sottostringa nella stringa originale. Restituisce un numero intero che rappresenta questo conteggio. Se la sottostringa non viene trovata nella stringa principale, restituisce 0.

Ecco un semplice esempio che cerca la lettera "o" nel testo "Hello, world!":

s = "Hello, world!"
sub = "o"
print(s.count(sub))  # Output:2

2 modi per abbinare stringhe con espressioni regolari

L'uso delle espressioni regolari (regex) è un po' più complesso rispetto ai metodi della sezione precedente. Tuttavia, ti danno più opzioni per la ricerca e l'analisi del testo con cui hai a che fare.

Due dei modi più semplici all'interno del modulo re sono:

1. ricerca()

2. trova tutto()

1. re.Ricerca()

La funzione search() nel modulo re cerca uno schema in una data stringa e restituisce un oggetto match se viene trovata una corrispondenza. In caso contrario, restituisce None .

Per impostazione predefinita, la funzione fa distinzione tra maiuscole e minuscole. È possibile utilizzare il flag re.IgnoreCase per evitare la distinzione tra maiuscole e minuscole.

Ecco un semplice esempio che utilizza istruzioni condizionali in base al fatto che la stringa venga trovata:

import re
pattern = "python"
text = "I love Python programming"
match = re.search(pattern, text, re.IGNORECASE)

if match: 
     print("Pattern found")
else:
     print("Pattern not found")

Si noti che questo metodo trova la prima corrispondenza e quindi interrompe la ricerca. Se vuoi trovare tutte le corrispondenze, allora il prossimo in questo elenco è per te.

2. re.Findall()

Questo metodo trova tutte le occorrenze di un modello di ricerca in una data stringa e restituisce un elenco contenente tutte le corrispondenze.

Questo esempio utilizza un modello che corrisponde a una o più cifre in una stringa. La stringa di testo "123, 456, 789" contiene tre sequenze di cifre.

import re 

pattern = "d+" 
text = "123, 456, 789" 
numbers = re.findall(pattern, text) 

print(numbers)

Questa è la risposta dal codice di esempio: ['123', '456', '789'].

Come trovare le sottostringhe con i panda

Pandas è una popolare libreria di analisi e manipolazione dei dati open source per Python. Fornisce le strutture dati e le funzioni necessarie per manipolare e analizzare i dati strutturati.

Una delle strutture dati primarie fornite da Pandas è il DataFrame. È possibile utilizzare questa versatile struttura dati per verificare la presenza di una stringa all'interno di un'altra.

Il vantaggio di Pandas è che fornisce pacchetti di codice che dovresti scrivere ampiamente in altri linguaggi di programmazione. In particolare, molta potenza è racchiusa all'interno della funzione contiene.

Funzione str.contains() in Panda

Il metodo str.contains() verifica se un modello o un'espressione regolare specificata è contenuta all'interno di una stringa di una colonna DataFrame.

Ecco un esempio che importa la libreria e cerca una stringa all'interno di un elenco di stringhe:

import pandas as pd

# Creating a sample DataFrame 
data = {'fruits': ['apple', 'banana', 'cherry', 'watermelon', 'orange']} 
df = pd.DataFrame(data) 

# Searching for substrings in the 'fruits' column 
has_an = df['fruits'].str.contains(pat='an', regex=False)

# Filtering the DataFrame based on the search results 
filtered_df = df[has_an] 
print(filtered_df)

In questo esempio, cerchiamo la sottostringa 'an' nella colonna 'fruits' e filtriamo il DataFrame di conseguenza. L'output sarebbe:

• 1 banana

• 4 arancione

Se stai cercando altri esempi di cosa possono fare i panda, guarda questo video:

Suggerimenti per la scelta di un metodo specifico in Python

La scelta del metodo dipende in gran parte dai requisiti specifici della tua attività.

Ecco quattro motivi per scegliere uno dei metodi che hai imparato da questo articolo, più un metodo bonus che imparerai altrove su questo blog:

1. Velocità di elaborazione

2. Devi conoscere la posizione della sottostringa

3. Devi conoscere il numero di occorrenze della sottostringa

4. Vuoi abbinare modelli complessi

5. Esecuzione di analisi del testo

1. Velocità di elaborazione

L'operatore 'in' è la scelta migliore se vuoi semplicemente sapere se esiste una sottostringa all'interno di una stringa.

È semplice, intuitivo e veloce per questo scopo. Tuttavia, non fornisce informazioni sulla posizione o sul conteggio della sottostringa.

2. Posizione della sottostringa

Utilizzare i metodi .find() o .index() se è necessario conoscere la posizione della prima occorrenza di una sottostringa all'interno di una stringa.

Entrambi restituiscono l'indice della prima occorrenza della sottostringa.

3. Conteggio della sottostringa

Utilizzare il metodo .count() quando si desidera sapere quante volte si verifica una sottostringa in una stringa.

4. Schemi complessi

Se devi abbinare modelli complessi o eseguire ricerche senza distinzione tra maiuscole e minuscole, le espressioni regolari sono le più flessibili. La funzione re.search() può gestire pattern oltre le semplici sottostringhe e può eseguire facilmente ricerche senza distinzione tra maiuscole e minuscole.

Tuttavia, le espressioni regolari possono essere eccessive per semplici controlli di sottostringa e possono anche essere più lente e complesse da utilizzare e mantenere.

5. Esecuzione dell'analisi del testo

Dai un'occhiata al nostro articolo sull'analisi del testo in Python , che mostra come lavorare con la libreria textblob.

È possibile utilizzare la funzione .tags per controllare le parti del discorso o la funzione .ngram per trovare le parole che compaiono frequentemente insieme in un documento.

Pensieri finali

Hai imparato sette metodi per verificare se una parola o un oggetto stringa è contenuto in un altro. Questi includevano operatori di appartenenza, funzioni integrate, regex e funzioni Panda.

Ogni metodo è corretto per alcune situazioni ma non per tutte. Usa questo articolo come cheat sheet mentre impari a padroneggiare il linguaggio di programmazione Python e usa la soluzione migliore per il tuo compito di analisi delle stringhe.

Ricorda, non esiste un metodo valido per tutti. Ogni approccio ha i suoi vantaggi e stranezze, quindi sentiti libero di scegliere quello che si adatta al tuo stile o al problema particolare che stai cercando di risolvere. Alla fine della giornata, Python si occupa di semplificarti la vita, quindi abbraccia la sua flessibilità!