I denne veiledningen skal vi utforske hvordan du kan konstruere Python-programmer for å håndtere typiske utfordringer knyttet til strengmanipulasjon.
Du vil bli kjent med teknikker for å avgjøre om en Python-streng er et palindrom, et anagram, eller om den følger konvensjonen med stor forbokstav i hvert ord (tittelcase).
Python-strenger: En rask innføring
Strenger er en sentral og kraftfull datatype i Python. De brukes til å lagre sekvenser av tegn.
Indeksering i Python-strenger: Strenger, i likhet med andre iterable objekter i Python, er nullindeksert. Dette betyr at for en streng med lengde N, er de gyldige indeksene 0, 1, 2, og så videre opp til N – 1.
Python tillater også bruk av negativ indeksering for å hente tegn fra slutten av strengen. For eksempel, -1 refererer til det siste tegnet, -2 til det nest siste, og så videre.
Uforanderlige Python-strenger: En viktig egenskap ved Python-strenger er at de er uforanderlige. Dette betyr at du ikke kan modifisere dem direkte. Du kan imidlertid anvende ulike strengmetoder som returnerer nye strengkopier med ønskede endringer.
Med dette grunnlaget på plass, la oss gå videre til å løse noen enkle, men interessante strengrelaterte problemstillinger.
La oss komme i gang.
Sjekk om en Python-streng er et palindrom
Oppgave: Gitt en Python-streng, avgjør om den er et palindrom eller ikke.
Returner `True` hvis den er et palindrom, og `False` ellers.
Det første problemet vi skal ta for oss, er altså å identifisere om en gitt streng er et palindrom.
Et palindrom er definert som en streng som leses likt fra begge sider. Eksempler inkluderer «racecar», «refer», «level», «madam», «radar», osv.
Følgende er stegene for å løse dette problemet:
- Lag en omvendt kopi av strengen og lagre den i en ny variabel.
- Sammenlign den opprinnelige strengen med den omvendte kopien.
- Hvis de er identiske, er strengen et palindrom. Returner `True` og avslutt.
- Hvis originalen og den omvendte kopien ikke stemmer overens, er strengen ikke et palindrom. Returner `False`.
Den sentrale operasjonen her er å generere den omvendte kopien. Python tilbyr flere metoder for å oppnå dette.
Vi skal se på to metoder:
- Ved å bruke strengskjæring (slicing)
- Ved bruk av `reversed()`-funksjonen i kombinasjon med `join()`-metoden
Hvordan snu en Python-streng ved bruk av skjæring
Syntaksen `
- Hvis start utelates, starter utsnittet fra begynnelsen av strengen.
- Hvis stoppindeksen utelates, strekker utsnittet seg til slutten av strengen.
- Negative verdier for trinn kan benyttes til å generere utsnitt som går baklengs gjennom strengen.
Dermed vil `
Nedenfor finner du en kodecelle som definerer funksjonen `is_palindrome()`.
Denne funksjonen tar inn en streng som argument og returnerer `True` eller `False`, avhengig av om strengen er et palindrom eller ikke.
Her benytter vi oss av strengskjæring for å skape en omvendt kopi av strengen.
def is_palindrome(this_str):
rev_str = this_str[::-1]
if (this_str == rev_str):
return True
else:
return False
▶️ Nå som funksjonen er definert, kan vi teste den med en rekke gyldige strenger som argument.
is_palindrome("racecar")
True
I eksemplet ovenfor er «racecar» et palindrom, og funksjonen `is_palindrome()` returnerer `True` som forventet.
La oss nå teste funksjonen med en streng som ikke er et palindrom, for eksempel «elv».
is_palindrome("river")
False
Og som du ser, returnerer den `False`, som er korrekt. ✅
Hvordan snu en Python-streng ved bruk av `reversed()` og `join()`
I Python kan man benytte `join()`-metoden i kombinasjon med `reversed()`-funksjonen for å snu en streng.
- `reversed()`-funksjonen returnerer en omvendt iterator over tegnene i strengen.
- `join()`-metoden kan deretter brukes til å sette sammen disse tegnene i motsatt rekkefølge.
Ved å bruke denne metoden, kan vi omformulere funksjonen `is_palindrome()` som vist nedenfor.
def is_palindrome(this_str):
rev_str="".join(reversed(this_str))
if (this_str == rev_str):
return True
else:
return False
Du kan også bruke funksjonen `is_palindrome()` i en list comprehension for å samle alle palindromer fra en lengre liste med strenger.
str_list = ["refer","blue","level","12321","dragon"] palindromes = [string for string in str_list if is_palindrome(string)] print(palindromes) # Output ['refer', 'level', '12321']
Slik fungerer koden ovenfor:
- Gå gjennom `str_list` og kall `is_palindrome()` på hver streng.
- Hvis `is_palindrome()` returnerer `True`, legg til strengen i `palindromes`-listen.
Som du kan se i utdataene, er `palindromes` en liste med alle palindromiske strenger fra `str_list`.
Sjekk om to Python-strenger er anagrammer
Et annet populært spørsmål som ofte dukker opp i jobbintervjuer, er å sjekke om et par strenger, `str1` og `str2`, er anagrammer.
To strenger defineres som anagrammer hvis antall forekomster av hvert tegn i de to strengene er identisk. Dette betyr at den ene strengen kan oppnås ved å permutere eller omorganisere tegnene i den andre strengen.
Eksempler på anagrammer inkluderer «state-taste», «save-vase», «elbow-below», osv.
Hvordan sjekke for anagrammer ved bruk av `Counter` i Python
En enkel og intuitiv metode er å telle antall forekomster av hvert tegn i begge strengene, og deretter undersøke om tellingene er like.
Dette kan forenkles ved bruk av `Counter`-objektet fra `collections`-modulen. Dette objektet returnerer en Python-ordbok der tegnene er nøkler og deres telling er de tilhørende verdiene.
La oss se på strengene «lagre» og «vase» som eksempler:
str1 = "save" str2 = "vase"
Her er `c1` og `c2` `Counter`-objekter som lagrer tellingene av tegn for henholdsvis `str1` og `str2`.
from collections import Counter
c1 = Counter(str1)
c2 = Counter(str2)
print(c1)
print(c2)
c1 == c2
# Output
Counter({'s': 1, 'a': 1, 'v': 1, 'e': 1})
Counter({'v': 1, 'a': 1, 's': 1, 'e': 1})
True
`c1 == c2` returnerer `True` fordi `str1` og `str2` er anagrammer.
Ved å bruke denne logikken kan vi nå definere funksjonen `are_anagrams()` med to parametere, `word1` og `word2`. I funksjonskroppen sjekker vi om `Counter(word1)` er lik `Counter(word2)`.
def are_anagrams(word1, word2):
if Counter(word1) == Counter(word2):
return True
else:
return False
▶️ La oss bekrefte dette ved å kalle `are_anagrams()` med `str1` og `str2` som argumenter. Ettersom `str1` og `str2` er anagrammer («lagre» og «vase»), returnerer funksjonen `True`, som er forventet.
are_anagrams(str1, str2) True
Hvordan sjekke for anagrammer ved bruk av sorterte kopier av strenger
Det finnes en annen tilnærming for å løse dette problemet.
Hvis to strenger er anagrammer, vil deres sorterte kopier være identiske.
Vi kan derfor omformulere funksjonen `are_anagrams()` for å sjekke om den sorterte versjonen av `str1` er lik den sorterte kopien av `str2`. Hvis de er like, er strengene anagrammer, ellers ikke.
Med utgangspunkt i likhetsprinsippet for sorterte kopier, kan vi omstrukturere `are_anagrams()`-funksjonen som følger:
def are_anagrams(word1, word2):
if sorted(word1) == sorted(word2):
return True
else:
return False
La oss nå gjennomføre noen funksjonskall.
- Strengene «elbow» og «below» er anagrammer, og funksjonen `are_anagrams()` returnerer `True`.
- Strengene «state» og «tasted» er ikke anagrammer, og funksjonen returnerer `False`.
are_anagrams("below","elbow")
True
are_anagrams("state","tasted")
False
Sjekk om en Python-streng følger tittelcase
Her er det siste problemet vi skal se på i denne veiledningen.
Oppgave: Gitt en streng som representerer et personnavn med fornavn og etternavn.
Du skal sjekke om den første bokstaven i både fornavnet og etternavnet er stor.
Denne typen skrivemåte, hvor første bokstav i hvert ord er stor, kalles tittelcase.
Oppgaven er altså å verifisere om navnet følger tittelcase:
1. Hvis navnet allerede følger tittelcase, skal en melding om dette skrives ut.
2. Ellers skal en kopi av strengen formateres til tittelcase og returneres.
- Python har en innebygd strengmetode, `istitle()`, som kontrollerer om en streng følger tittelcase.
`
- Pythons strengmetode `title()` returnerer en kopi av strengen formatert i tittelcase.
Med utgangspunkt i disse to metodene, kan vi nå løse oppgaven.
Definer funksjonen `check_titlecase()` som tar inn et navn som argument.
- Kall `istitle()`-metoden på inndatastrengen for å se om den følger tittelcase.
- Hvis resultatet er `True`, skriv ut en melding om at strengen allerede er i tittelcase.
- Ellers, kall `title()`-metoden og returner en kopi av strengen i tittelcase.
Følgende kodecelle viser definisjonen av funksjonen `check_titlecase()`.
def check_titlecase(name):
if name.istitle():
print(f"'{name}' is already formatted in title case.")
else:
return name.title()
La oss nå kalle `check_titlecase()`-metoden med et argument.
check_titlecase("jane smith")
# Output
Jane Smith
I utdataene ser vi at strengen «Jane Smith» nå følger tittelcase.
▶️ La oss se på et annet eksempel.
check_titlecase("agatha Christie")
# Output
Agatha Christie
Denne gangen kaller vi funksjonen med en streng som allerede følger tittelcase.
check_titlecase("Grace Hopper")
# Output
'Grace Hopper' is already formatted in title case.
Vi får beskjed om at strengen allerede er formatert i tittelcase, og funksjonen fungerer som forventet.
Oppsummering 👩🏫
La oss nå oppsummere problemene vi har gjennomgått.
- For å sjekke om en streng er et palindrom, verifiser om strengen er lik sin omvendte versjon. Du kan benytte strengskjæring eller innebygde metoder for å snu strenger.
- For å avgjøre om to strenger er anagrammer, sjekk om deres sorterte kopier er identiske. For å sortere en streng, bruk den innebygde `sorted()`-funksjonen.
- For å kontrollere om et navn følger tittelcase, bruk `.istitle()`-metoden for å verifisere og `.title()`-metoden for å returnere en kopi av strengen med tittelcase.
Jeg håper du har hatt nytte av denne veiledningen om Python-strenger. Som et neste steg kan du utforske list comprehensions i Python, eller lære mer om ulikhetsoperatoren i Python.
Lykke til med læring og koding!🎉