7 måder, hvordan man kontrollerer, om en Python-streng indeholder en understreng

Arbejde med strenge er en almindelig opgave i Python. Du skal ofte finde ud af, om en streng indeholder en anden streng.

De enkleste metoder til at kontrollere, om en Python-streng indeholder en understreng, inkluderer 'in'-operatoren, find()-funktionen og index()-metoden. Mere komplekse scenarier kan løses med regulære udtryk eller et eksternt bibliotek som Pandas.

Denne artikel viser dig:

• fire enkle metoder

• to mere komplekse regex-funktioner

• en metode, der bruger Pandas-biblioteket

Du lærer hver teknik gennem eksempler på deres syntaks og brug. Du får også tips om, hvilken metode der passer bedst til forskellige krav.

Lad os komme igang!

Indholdsfortegnelse

• Grundlæggende om Python Strings
• 4 enkleste måder at tjekke for understrenge på
  • 1. I Operatør
  • 2. Find() metode
  • 3. Indeks() metode
  • 4. Count() metode
• 2 måder at matche strenge med regulære udtryk
  • 1. re.Search()
  • 2. re.Findall()
• Sådan finder du understrenge med pandaer
  • str.contains() Funktion i Pandas
• Tips til at vælge en specifik metode i Python
  • 1. Behandlingshastighed
  • 2. Placering af understreng
  • 3. Optælling af understreng
  • 4. Komplekse mønstre
  • 5. Udførelse af tekstanalyse
• Afsluttende tanker

Grundlæggende om Python Strings

En streng i Python er en sekvens af tegn, der bruges til at repræsentere tekstbaserede data. De kan indeholde bogstaver, cifre, symboler og mellemrum.

Det er en af ​​Pythons indbyggede datatyper og kan oprettes ved hjælp af enten:

• enkelte anførselstegn (' ')

• dobbelte anførselstegn (" ")

• tredobbelte anførselstegn ("' "' eller """ """)

Strenge er indekseret, hvilket betyder, at du kan få adgang til bestemte tegn ved at henvise til deres indeksnummer. Startindekset er 0, hvilket betyder, at det første tegn i en streng har et indeks på 0, det andet har et indeks på 1, og så videre.

Dernæst ser vi på måder at tjekke for understrenge.

4 enkleste måder at tjekke for understrenge på

Python giver mange måder at kontrollere, om en bestemt understreng findes i en større streng. Nogle er mere komplekse end andre. Til de mest grundlæggende kontroller er de enkleste metoder in-operatoren eller en af ​​tre strengmetoder.

1. i operatør

2. find() metode

3. index() metode

4. count() metode

1. I Operatør

'in'-operatoren i Python er en enkel og intuitiv måde at kontrollere, om der findes en streng i en anden streng. Denne operatør tjekker for medlemskab og returnerer en boolesk værdi:

• Sand, hvis understrengen findes i hovedstrengen

• Falsk hvis det ikke er

Her er et eksempel på kode:

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

Operatoren 'in' skelner mellem store og små bogstaver. Det betyder, at den behandler små og store bogstaver som forskellige. Ovenstående kode finder ikke understrengen "hej", så operatoren returnerer falsk.

Hvis du vil udføre et tjek uden forskel på store og små bogstaver, kan du konvertere både hovedstrengen og understrengen til samme sag, før du udfører kontrollen:

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

Ulempen ved in-operatoren er, at den ikke angiver understrengens position i hovedstrengen. Til det har du brug for en anden metode i dette afsnit. Læs videre…

2. Find() metode

Find ()- metoden returnerer det første indeks, hvor understrengen vises, eller -1 , hvis understrengen ikke findes.

Du kalder find()- metoden på en streng s , og sender understrengen under som et argument. Her er et eksempel:

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")

Du kan valgfrit angive et start- eller slutindeks for at begrænse din søgning. Ulempen ved denne metode er, at den stopper ved den første forekomst.

3. Indeks() metode

index ()- metoden ligner meget find()- metoden, bortset fra at den rejser en ValueError , når understrengen ikke findes. Det betyder, at du skal afslutte opkaldet i en Prøv/undtagen sektion.

For at bruge metoden index() skal du kalde den på en streng s , og sende understrengen under som et argument.

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")

Denne metode stopper også ved den første understreng inde i teksten.

4. Count() metode

Metoden .count() tæller, hvor mange gange en understreng forekommer i den originale streng. Det returnerer et heltal, der repræsenterer dette antal. Hvis understrengen ikke findes i hovedstrengen, returnerer den 0.

Her er et simpelt eksempel, der leder efter bogstavet "o" i teksten "Hej verden!":

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

2 måder at matche strenge med regulære udtryk

Brug af (regex) er lidt mere kompleks end metoderne i det foregående afsnit. De giver dig dog flere muligheder for at søge og analysere den tekst, du har med at gøre.

To af de nemmeste måder inden for re- modulet er:

1. Søg()

2. findall()

1. re.Search()

Search () -funktionen i re- modulet søger efter et mønster i en given streng og returnerer et matchobjekt, hvis der findes et match. Ellers returnerer den Ingen .

Som standard skelner funktionen mellem store og små bogstaver. Du kan bruge flaget re.IgnoreCase for at undgå følsomhed over for store og små bogstaver.

Her er et simpelt eksempel, der bruger betingede udsagn baseret på, om strengen er fundet:

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")

Bemærk, at denne metode finder det første match og derefter stopper søgningen. Hvis du vil finde alle matches, så er den næste på denne liste noget for dig.

2. re.Findall()

Denne metode finder alle forekomster af et søgemønster i en given streng og returnerer en liste, der indeholder alle matches.

Dette eksempel bruger et mønster, der matcher et eller flere cifre i en streng. Tekststrengen "123, 456, 789" indeholder tre sekvenser af cifre.

import re 

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

print(numbers)

Dette er svaret fra prøvekoden: ['123', '456', '789'].

Sådan finder du understrenge med pandaer

Pandas er et populært open source-dataanalyse- og manipulationsbibliotek til Python. Det giver datastrukturer og funktioner, der er nødvendige for at manipulere og analysere strukturerede data.

En af de primære datastrukturer leveret af Pandas er DataFrame. Du kan bruge denne alsidige datastruktur til at kontrollere, om der er én streng inde i en anden.

Fordelen ved Pandas er, at den leverer kodepakker, som du skal skrive meget på andre programmeringssprog. Specifikt er en masse strøm pakket inde i indeholder-funktionen.

str.contains() Funktion i Pandas

Metoden str.contains() tester, om et specificeret mønster eller regulært udtryk er indeholdt i en streng i en DataFrame-kolonne.

Her er et eksempel, der importerer biblioteket og søger efter en streng i en liste med strenge:

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)

I dette eksempel søger vi efter understrengen 'an' i kolonnen 'frugter' og filtrerer DataFrame i overensstemmelse hermed. Outputtet ville være:

• 1 banan

• 4 orange

Hvis du leder efter flere eksempler på, hvad Pandas kan, så tjek denne video:

Tips til at vælge en specifik metode i Python

Valget af metode afhænger i høj grad af de specifikke krav til din opgave.

Her er fire grunde til at vælge en af ​​de metoder, du har lært fra denne artikel, plus en bonusmetode, du vil lære andetsteds på denne blog:

1. Bearbejdningshastighed

2. Du skal kende placeringen af ​​understrengen

3. Du skal kende antallet af forekomster af understrengen

4. Du ønsker at matche komplekse mønstre

5. Udførelse af tekstanalyse

1. Behandlingshastighed

'in' 0peratoren er det bedste valg, hvis du blot vil vide, om der findes en understreng i en streng.

Det er enkelt, intuitivt og hurtigt til dette formål. Det giver dog ikke oplysninger om placeringen eller antallet af understrengen.

2. Placering af understreng

Brug metoderne .find() eller .index() , hvis du har brug for at kende positionen af ​​den første forekomst af en understreng i en streng.

De returnerer begge indekset for den første forekomst af understrengen.

3. Optælling af understreng

Brug metoden .count() når du vil vide, hvor mange gange en understreng forekommer i en streng.

4. Komplekse mønstre

Hvis du har brug for at matche komplekse mønstre eller udføre søgninger, der ikke skiller mellem store og små bogstaver, er regulære udtryk de mest fleksible. Re.search () -funktionen kan håndtere mønstre ud over simple understrenge og kan nemt udføre søgninger uden forskel på store og små bogstaver.

Men regulære udtryk kan være overkill til simple understrengskontrol og kan også være langsommere og mere komplekse at bruge og vedligeholde.

5. Udførelse af tekstanalyse

Tjek vores artikel om , som viser dig, hvordan du arbejder med textblob-biblioteket.

Du kan bruge .tags- funktionen til at søge efter dele af tale eller .ngram- funktionen til at finde ord, der ofte optræder sammen i et dokument.

Afsluttende tanker

Du har lært syv metoder til at kontrollere, om et ord eller strengobjekt er indeholdt i et andet. Disse omfattede medlemskabsoperatører, indbyggede funktioner, regex og Pandas-funktioner.

Hver metode er korrekt for nogle situationer, men ikke for alle. Brug denne artikel, når du mestrer Python-programmeringssproget og brug den bedste løsning til din strenganalyseopgave.

Husk, der er ingen ensartet metode. Hver tilgang har sine egne fordele og særheder, så du er velkommen til at vælge den, der passer til din stil eller det særlige problem, du prøver at løse. I slutningen af ​​dagen handler Python om at gøre dit liv lettere, så omfavn dets fleksibilitet!