Förstå delsträngar i Python med exempel

Denna artikel har som mål att öka elevens förståelse för delsträngar inom programmeringsspråket Python.

Här kommer du att lära dig hur man konstruerar en delsträng, plockar ut olika segment av en sträng och hur delsträngar fungerar i Python genom att granska flera praktiska exempel. Vi kommer även att undersöka hur man avgör om en viss delsträng är en del av en större sträng.

Innan vi går vidare är det nödvändigt att klargöra vad som menas med en sträng respektive en delsträng. En sträng definieras som en följd av Unicode-tecken, bestående av både alfanumeriska symboler och specialtecken. En delsträng kan betraktas som en sektion av denna teckenföljd.

Vi kommer att fokusera på följande områden:

• Hur man skapar en delsträng.
• Tekniker för att extrahera delsträngar.
• Att räkna antalet gånger en delsträng uppträder.
• Att identifiera förekomsten av en delsträng i en sträng.

Låt oss sätta igång!

Skapa en delsträng

Konstruktionen av en delsträng åstadkoms primärt genom så kallad slicing, eller segmentering. Denna metod möjliggör att extrahera en delsträng genom att specificera gränser för startindex, slutindex och steglängd. Dessa parametrar ger möjligheten att med precision ange index för de tecken som ska utvinnas.

Syntaxen för detta ser ut på följande vis:

string[startindex:slutindex:steg]

Viktigt att notera är att indexeringen i en sträng börjar från noll.

Parametern startindex definierar startpunkten för delsträngen. Om denna parameter utelämnas, tolkar Python automatiskt att indexet är noll.

Slutindex markerar sista tecknet som inkluderas i delsträngen. Om slutindex inte anges, antar slicing att delsträngen fortsätter till slutet av strängen.

Steg anger vilket tecken som ska plockas ut efter det aktuella tecknet. Värdet på denna parameter är ofta ett. Om steg inte anges, är standardvärdet ett.

Metoder för att extrahera delsträngar

Det finns flera tillvägagångssätt för att erhålla en delsträng från en större sträng. Här följer några av dessa:

#1. Segmentering med start- och slutindex.

String = string[startindex : slutindex]

Om vi vill extrahera en persons förnamn från deras fullständiga namn, görs det på detta sätt:

string = 'Michael Doe'

print(string[0:7])

Resultatet blir:

Michael

#2. Segmentering med endast startindex.

String= string[startindex:]

I detta fall anger vi endast var extraktionen av delsträngen ska starta. Segmenteringen fortsätter sedan till slutet av den fullständiga strängen, vilket vanligtvis motsvarar index -1.

Exempel:

string = 'Detta exempel visar hur man segmenterar en sträng med endast startindex'

print(string[5:])

Output:

exempel visar hur man segmenterar en sträng med endast startindex

#3. Segmentering med endast slutindex.

String = string[:slutindex]

Här definierar vi det sista tecknet som ska inkluderas i delsträngen. Segmenteringen börjar då från index noll av den ursprungliga strängen.

Exempel:

string = 'Detta exempel visar hur man segmenterar en sträng med endast slutindex'

print(string[:12])

Output:

Detta exempel

#4. Segmentering av hela strängen.

String = string[ : ]

När varken start- eller slutindex specificeras, returneras hela den ursprungliga strängen.

Exempel:

string = 'Detta är ett exempel på segmentering av hela strängen'

print(string[:])

Output:

Detta är ett exempel på segmentering av hela strängen

#5. Segmentering av ett enskilt tecken.

String = string[index]

Här anger vi ett specifikt index för ett tecken i strängen.

Exempel:

string = 'Detta exempel visar hur man segmenterar ett enskilt tecken'

print(string[8])

Tecknet ’e’ i ordet ’exempel’ skrivs ut eftersom dess index är 8.

#6. Segmentering med startindex, slutindex och steglängd.

Exempel:

string = 'Detta är ett exempel på hur man använder startindex, steg och slutindex'

print(string[11:24:1])

När steglängden är 1 sker normal segmentering och resultatet blir:

exempel på hur

Med samma exempel, men med steglängd 2:

string = 'Detta är ett exempel på hur man använder startindex, steg och slutindex'

print(string[11:24:2])

Segmenteringen kommer att ske i steg om 2, vilket ger:

eepåh

Segmenteringen extraherar alltså varannat tecken, vilket resulterar i outputen ’eepåh’.

#7. Vända en sträng med negativ steglängd.

Här visas hela strängen i omvänd ordning, från sista tecknet till det första.

string = 'Detta är ett exempel på att vända strängen med negativ steglängd'

print(string[::-1])

Output:

dgnälledgets vitagen med ngnärtsa ändve att på lepmaxe ett rä attT

Den negativa steglängden fungerar enligt följande:

V
Ä
N
D
A
-6
-5
-4
-3
-2
-1

Startindexet för den omvända strängen börjar som standard från 0 och slutar på 6. Den negativa steglängden vänder indexvärdet för det sista tecknet och applicerar det på det första tecknet, och så vidare.

Ytterligare exempel på segmentering

Hämta de fyra första tecknen i en sträng.

string = 'teckenföljd'

print(string[0:4])

Kommer att returnera:

teck

Hitta förekomsten av en delsträng i en sträng

Python använder antingen funktionen `find()` eller operatorn `in` för att kontrollera om en viss delsträng finns i en större sträng.

Exempel med operatorn `in`:

string = 'Detta är för att visa att en viss delsträng hittas i en sträng'
if 'hitta' in string:
    print('Delsträngen hittades')
else:
    print('Delsträngen kunde inte hittas')

Output:

Delsträngen kunde inte hittas

Ovanstående exempel undersöker om delsträngen ’hitta’ finns i den definierade strängen. Eftersom delsträngen inte återfinns i strängen, blir resultatet ’Delsträngen kunde inte hittas’.

Om vi skulle byta ut delsträngen ’hitta’ mot ’visa’, och göra samma kontroll, skulle outputen istället bli ’Delsträngen hittades’ eftersom ’visa’ faktiskt finns i strängen.

Exempel med funktionen `find()`:

string = 'använder string för att hitta om en delsträng finns i en sträng'

if string.find('finns') != -1:
    print("Delsträngen 'finns' existerar")
else:
    print("Delsträngen 'finns' existerar inte")

Output:

Delsträngen 'finns' existerar

I det här exemplet sökte vi efter en delsträng som faktiskt fanns i vår sträng. Funktionen `find()` letar genom hela strängen och returnerar det angivna resultatet.

Räkna antalet förekomster av en delsträng

Python använder funktionen `count()` för att räkna antalet förekomster av en specifik delsträng, vilket visas i exemplet nedan.

string = " Räknar antalet förekomster av 'a' i denna sträng "

print("Antalet 'a' i strängen är: ",string.count('a'));

Output:

Antalet 'a' i strängen är: 2

Sammanfattning

Denna artikel har för avsikt att ge en ökad förståelse för vad en delsträng är i Python, hur man skapar den, och att förklara begreppet segmentering, samt hur man använder det. Använd exemplen ovan som vägledning och öva på fler liknande fall för att ytterligare befästa konceptet.

Du kan även lära dig hur man skapar ett gissningsspel i Python, eller hur man hanterar JSON-data i Python.

Lycka till med kodningen!