I den här handledningen kommer du att skriva Python-program för att lösa vanliga frågor om strängoperationer.
Du kommer att lära dig hur du kontrollerar om Python-strängar är palindromer, anagram och finns i titelfallet.
Innehållsförteckning
Python Strings: A Quick Review
I Python är strängar kraftfulla inbyggda datatyper. De kan lagra en sekvens av tecken.
Indexering i Python Strings: Liksom alla Python iterables är strängar också nollindexerade. Så de giltiga indexen för en sträng med längden N är 0, 1, 2 upp till N – 1.
Python stöder också negativ indexering för att komma åt element från slutet av strängen. Så -1 är indexet för det sista tecknet i strängen, -2 är indexet för det näst sista tecknet i strängen och så vidare.
Immutability of Python Strings: Dessutom är strängar i Python oföränderliga, så du kan inte ändra dem på plats. Du kan dock anropa flera strängmetoder på dem och få kopior av strängar med önskat resultat.
Nu när vi har granskat grunderna i Python-strängar, låt oss fortsätta för att lösa några enkla men intressanta problem.
Låt oss börja.
Kontrollera om en Python-sträng är en palindrom
Problem: Med tanke på en Python-sträng, kontrollera om det är en palindrom eller inte.
Om ja, returnera True; annars, returnera False.
Så vårt första problem är att kontrollera om en given sträng är ett palindrom eller inte.
Ett palindrom är en sträng som läser likadant från vänster till höger samt från höger till vänster. Låt oss lista några exempel: racerbil, referera, nivå, fru, radar och så vidare.
Här är stegen för att lösa det här problemet:
- Skaffa en omvänd kopia av strängen och lagra den i en annan variabel om det behövs.
- Jämför värdena för den ursprungliga strängen och den omvända strängen.
- Om de är lika är strängen ett palindrom. Så återvänd True och sluta.
- Om originalet och de omvända kopiorna inte är lika, är strängen inte ett palindrom. Så vi bör returnera False.
Nyckeloperationen är att få en omvänd kopia av strängen. I Python finns det några olika sätt du kan göra detta på.
Vi kommer dock att gå över två tillvägagångssätt:
- Med hjälp av skärning av snöre
- Använda reversed()-funktionen och join()-metoden
Hur man vänder en Python-sträng med skärning
Syntaxen
- Om du utelämnar start börjar skivan i början av strängen.
- Om du inte anger stoppindex, sträcker sig segmentet upp till slutet av strängen.
- Och negativa värden på steg kan användas för att returnera segment från slutet av strängen.
Så
Följande kodcell innehåller definitionen av funktionen is_palindrome().
Den tar in en sträng som argument och returnerar True eller False beroende på om det är ett palindrom eller inte.
Här har vi använt strängskivning för att få en omvänd kopia av strängen.
def is_palindrome(this_str):
rev_str = this_str[::-1]
if (this_str == rev_str):
return True
else:
return False
▶️ Nu när vi har definierat funktionen kan vi gå vidare och anropa med valfri giltig sträng som argument.
is_palindrome("racecar")
True
I ovanstående kodcell är racerbil en palindrom. Så funktionen is_palindrome() returnerar True som förväntat.
Försök nu att anropa funktionen med valfri sträng som inte är ett palindrom, till exempel flod.
is_palindrome("river")
False
Och som du kan se returnerar den False, vilket är korrekt. ✅
Hur man vänder en Python-sträng med reversed() och join()
I Python kan du använda metoden join() tillsammans med funktionen reversed() för att vända en sträng.
- Funktionen reversed() returnerar en omvänd iterator genom tecknen i strängen.
- Metoden join() kan sedan användas för att sammanfoga dessa tecken i omvänd ordning.
Med metoden ovan kan du skriva om funktionen is_palindrome() som i kodcellen nedan.
def is_palindrome(this_str):
rev_str="".join(reversed(this_str))
if (this_str == rev_str):
return True
else:
return False
Du kan också använda funktionen is_palindrome() i listförståelse för att samla alla palindromer från en längre lista med strängar.
str_list = ["refer","blue","level","12321","dragon"] palindromes = [string for string in str_list if is_palindrome(string)] print(palindromes) # Output ['refer', 'level', '12321']
Så här fungerar koden ovan:
- Gå igenom str_list, anrop is_palindrome() på varje sträng.
- Om is_palindrome() returnerar True, lägg till strängen i palindromlistan.
Som du kan se i utgången ovan är palindromer en lista över alla palindromiska strängar i str_list.
Kontrollera om Two Python Strings är Anagram
En annan populär fråga som du kan stöta på i intervjuer är att kontrollera om ett par strängar str1 och str2 är anagram eller inte.
Två strängar sägs vara anagram om antalet tecken i de två strängarna är exakt samma. Det betyder att du kan få en av strängarna genom att permutera eller ordna om tecknen i den andra strängen.
Exempel på anagram inkluderar state-taste, save-vase, armbow-below, och så vidare.
Hur man söker efter anagram med hjälp av Counter Object i Python
Ett enkelt och intuitivt sätt är att beräkna antalet förekomster av varje tecken i de två strängarna. Och kontrollera sedan om antalet är lika.
Detta kan göras desto lättare med hjälp av Counter-objektet från itertools-modulen. De Disken objekt returnerar en Python-ordbok: med tecknen som nycklar och motsvarande räknas som värden.
Betrakta strängarna ”spara” och ”vas” som visas nedan.
str1 = "save" str2 = "vase"
Här är c1 och c2 räknareobjekt som innehåller teckenräkningarna för strängarna str1 respektive 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 returnerar Sant eftersom str1 och str2 är anagram.
Med denna logik kan vi nu gå vidare och definiera funktionen are_anagrams() med två parametrar word1 och word2. I funktionskroppen kontrollerar vi om Räknare(ord1) == Räknare(ord2).
def are_anagrams(word1, word2):
if Counter(word1) == Counter(word2):
return True
else:
return False
▶️ För att verifiera, anrop are_anagrams() med str1, str2 som argument. Eftersom str1 och str2 är anagram (”spara” och ”vas”) returnerar funktionen True, vilket är korrekt.
are_anagrams(str1, str2) True
Hur man söker efter anagram med hjälp av sorterade kopior av strängar
Det finns ett annat sätt du kan göra detta.
Om två strängar är anagram, är deras sorterade kopior lika.
Så vi kan skriva om funktionen are_anagrams() för att kontrollera om den sorterade versionen av str1 är densamma som den sorterade kopian av str2. Om de är lika, då är de två strängarna anagram; annars är de inte det.
Genom att använda metoden ovan för att kontrollera likheten mellan sorterade kopior kan vi skriva om funktionen are_anagrams() enligt följande.
def are_anagrams(word1, word2):
if sorted(word1) == sorted(word2):
return True
else:
return False
Låt oss nu göra några funktionsanrop.
- Strängarna ”elbow” och ”below” är anagram och funktionen are_anagrams() returnerar True.
- Och ”state” och ”tasted” är inte anagram, och funktionen returnerar False.
are_anagrams("below","elbow")
True
are_anagrams("state","tasted")
False
Kontrollera om en Python-sträng är i skiftläge
Här är vår sista fråga för denna handledning.
Problem: Givet en sträng: en persons namn—med förnamn och efternamn.
Du måste kontrollera om den första bokstaven i både för- och efternamn är versaler.
Den här typen av skiftläge där den första bokstaven i varje ord är versal kallas skiftläge i rubriken.
Så du måste kontrollera om namnet är i rubriken:
1. Om ja, skicka ett meddelande om att formateringen är i skiftläge.
2. Annars returnerar du en kopia av strängen som är formaterad i rubriken
- Python har en inbyggd strängmetod istitle(), som kontrollerar om en sträng finns i rubriken.
- Och Pythons strängmetod title() returnerar en kopia av strängen som är formaterad i titelns skiftläge.
Så nu kan du använda dessa två metoder för att lösa problemet.
Definiera en funktion check_titlecase() som accepterar namn som argument.
- Du kan anropa metoden istitle() på inmatningssträngen för att kontrollera om den är formaterad med skiftläge i titel.
- Om det är sant kan du skriva ut att strängen redan är i skiftläge.
- Annars kan du anropa title()-metoden och returnera en kopia av strängen i titelns skiftläge.
Följande kodcell visar definitionen av check_titlecase()-funktionen.
def check_titlecase(name):
if name.istitle():
print(f"'{name}' is already formatted in title case.")
else:
return name.title()
Låt oss nu anropa metoden check_titlecase() med ett argument.
check_titlecase("jane smith")
# Output
Jane Smith
I utgången ovan kan du se att strängen ”Jane Smith” nu finns i titelfallet.
▶️ Låt oss ta ett annat exempel.
check_titlecase("agatha Christie")
# Output
Agatha Christie
Den här gången, låt oss kalla funktionen med en sträng med bokstäver.
check_titlecase("Grace Hopper")
# Output
'Grace Hopper' is already formatted in title case.
Vi får ett meddelande om att strängen är formaterad i rubriken och funktionen fungerar som förväntat.
Slutsats 👩🏫
Låt oss nu sammanfatta problemen vi har diskuterat hittills.
- För att kontrollera om en sträng är en palindrom, kontrollera om strängen och dess omvända version är lika. Du kan använda strängskivning eller inbyggda metoder för att vända strängar.
- För att kontrollera om två strängar är anagram, kontrollera om deras sorterade kopior är lika. Och för att sortera en sträng, använd den inbyggda sorted()-funktionen.
- För att verifiera om ett namn är i skiftläge, använd .istitle()-metoden för kontroll och .title()-metoden för att få en kopia av strängen med skiftläge.
Jag hoppas att du gillade den här handledningen om Python-strängar. Som nästa steg kan du lära dig hur du använder listförståelse i Python eller lära dig mer om operatorn inte lika i Python.
Lycka till med lärande och kodning!🎉