Behandla strängar

Strängoperationer

Strängar kan kombineras med +-operatorn:

start = "exe"
slut = "mpel"
ord = start+slut
print(ord)

Operatorn * kan också användas med strängar då den andra operanden är ett heltal. Strängoperanden kommer då att upprepas det antal gånger som specificeras av heltalet. Till exempel så här:

ord = "pegas"
print(ord*3)

Genom att kombinera strängoperationer med en loop kan vi skriva ett program som ritar en pyramid:

n = 10 # våningar i pyramiden
rad = "*"

while n > 0:
    print(" " * n + rad)
    rad += "**"
    n -= 1

Så här ser utskriften ut:

          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************

Instruktionen print inom loopen skriver ut en rad som börjar med n mellanslag följt av värdet som är lagrat i variabeln rad. Sedan läggs två stjärnor till i slutet av variabeln rad och variabeln n:s värde minskas med ett.

Längden på en sträng och dess index

Funktionen len returnerar antalet tecken i en sträng som ett heltal. Till exempel returnerar len("hej") 3 eftersom det finns tre tecken i strängen hej.

Följande program ber användaren att mata in en sträng och skriver sedan ut det "understrykt". Programmet skriver alltså ut en andra rad som innehåller så många streck (-) som det finns tecken i den givna strängen:

strang = input("Ange sträng: ")
print(strang)
print("-"*len(strang))

Hejsan svejsan!
---------------

Strängens längd innehåller alla tecken i strängen – också mellanslag. Till exempel är längden på strängen hej igen 8.

Eftersom strängar i grunden är sekvenser av tecken kan vi också plocka ut enskilda tecken ur en sträng. Vi gör det med hjälp av operatorn [] och ett index.

Indexet hänvisar till en given position i strängen, och indexeringen börjar från 0. Det första tecknet i en sträng har alltså indexet 0, medan nästa tecken har indexet 1 och så vidare.

Det här programmet…

strang = input("Ange sträng: ")
print(strang[0])
print(strang[1])
print(strang[3])

…skulle skriva ut följande:

Eftersom det första tecknet i en sträng har indexet noll, har det sista tecknet indexet längd-1. Följande program skriver ut det första och sista tecknet i en sträng:

strang = input("Ange sträng: ")
print("Första: " + strang[0])
print("Sista: " + strang[len(strang) - 1])

Det här programmet går igenom varje tecken i en sträng – från det första till det sista:

strang = input("Ange sträng: ")
plats = 0
while plats < len(strang):
    print(strang[plats])
    plats += 1

Man kan också använda negativa index för att komma åt tecknen i en sträng i motsatt ordning, dvs. från slutet av strängen.

Det sista tecknet i en sträng har då indexet -1, det näst sista indexet -2 och så vidare. Du kan tänka att str[-1] är en genväg för str[len(str) – 1].

Det föregående exemplet kan därmed förenklas med negativ indexering.

strang = input("Ange sträng: ")
print("Första: " + strang[0])
print("Sista: " + strang[-1])

IndexError: string index out of range

Om du har testat exemplen ovan har du kanske stött på felmeddelandet IndexError. Det här felet uppstår då du försöker använda ett index som inte finns i en sträng.

strang = input("Ange sträng: ")
print("Tionde tecknet: " + strang[9])

Ibland orsakas indexeringsfel av en bugg i koden. Det är till exempel relativt vanligt att man försöker komma åt ett index som inte finns när man försöker komma åt det sista tecknet i en sträng:

strang = input("Ange sträng: ")
print("Sista tecknet: " + strang[len(strang)])

Eftersom strängindexeringen börjar med noll kommer det sista tecknet att ha indexet len(str) - 1.

Det finns situationer där programmet borde förbereda sig för fel orsakade av indata från användaren:

strang = input("Ange sträng: ")
if len(strang) > 0:
    print("Första tecknet: " + strang[0])
else:
    print("Strängen är tom, alltså finns det inget första tecken")

I exemplet ovan skulle en sträng med längden noll ha orsakat problem om programmeraren inte skulle ha lagt till en längdkontroll i koden. En sträng med längden noll är en tom sträng. En inmatning blir en tom sträng om användaren inte skriver in något utan direkt trycker Enter.

###

########

Hejsan svejsan!
---------------

Clara steg upp på en tremetersstege
-----------------------------------

a
-

**************python

****ganskalångsträng

*sssuperlångstränggg

******************************
*            aj!             *
******************************

******************************
*           python           *
******************************

Delsträngar

En delsträng är en sekvens av tecken som utgör en del av den ursprungliga strängen. Till exempel innehåller strängen exempel delsträngarna exem, mpe, el med flera. Att i Python ta ut en delsträng ur en sträng kallas för slicing.

Om du vet vad det inledande och avslutande indexet för en delsträng är, kan du extrahera (slice) delsträngen med notationen [a:b]. Då kommer delsträngen att börja vid index a och ta slut vid det sista tecknet före indexet b – det vill säga inklusive den första bokstaven men exklusive den sista. Du kan tänka att indexen är streck ritade på den vänstra sidan av det indexerade tecknet – som vi illustrerar nedan:

Låt oss kika lite mer på extraherade (sliced) strängar:

strang = "glassbil"

print(strang[0:3])
print(strang[4:7])

# om inledande index fattas, är det 0
print(strang[:3])

# om avslutande index fattas, är det lika med strängens längd
print(strang[4:])

Söka efter delsträngar

Operatorn in berättar om en sträng innehåller en specifik delsträng. Boolean-uttrycket a in b är sant om b innehåller delsträngen a.

Till exempel skriver den här kodsnutten…

strang = "test"

print("t" in strang)
print("x" in strang)
print("est" in strang)
print("ets" in strang)

… ut följande:

Programmet nedan låter användaren söka efter delsträngar i en sträng som är hårdkodad i programmet:

strang = "eu-val"

while True:
    delstrang = input("Vad söker du efter? ")
    if delstrang in strang:
        print("Hittades")
    else:
        print("Hittades inte")

Operatorn in returnerar ett Boolean-värde. Det berättar alltså bara att en delsträng existerar i en sträng, men baserat på den informationen vet vi inte var delsträngen befinner sig. Däremot kan metoden find hos strängar användas för det här syftet. Som argument ger man delsträngen som söks efter. Tillbaka får vi ett värde som anger det första indexet där delsträngen hittades – eller -1 om delsträngen inte hittas i strängen.

Så här fungerar det:

Några exempel där vi använder find:

strang = "test"

print(strang.find("t"))
print(strang.find("x"))
print(strang.find("est"))
print(strang.find("ets"))

Ovanstående delsträngsexempel gjort med find:

strang = "led-lampa"

while True:
    delstrang = input("Vad söker du efter? ")
    plats = strang.find(delstrang)
    if plats >= 0:
        print(f"Hittades på platsen {plats}")
    else:
        print("Hittades inte")

ord = input("Ord: ")
while True:
    if len(ord) == 0:
        break
    print(ord)
    ord = ord[2:]

Se dina poäng genom att klicka på cirkeln nere till höger av sidan.