I denna genomgång kommer du att utveckla Python-program för att hantera vanliga utmaningar relaterade till stränghantering.
Du kommer att utforska hur man avgör om Python-strängar är palindrom, anagram samt hur man kontrollerar om de är i titelformat.
En Snabb Genomgång av Python-Strängar
I Python representerar strängar en robust inbyggd datatyp. De används för att lagra sekvenser av tecken.
Indexering i Python-strängar: Strängar är, precis som andra iterabla objekt i Python, nollindexerade. Det innebär att giltiga index för en sträng av längd N sträcker sig från 0, 1, 2 ända upp till N – 1.
Python stöder även negativ indexering, vilket gör det möjligt att komma åt element från slutet av strängen. Exempelvis motsvarar -1 det sista tecknet, -2 näst sista tecknet, och så vidare.
Oföränderlighet hos Python-strängar: Strängar i Python är oföränderliga, vilket innebär att de inte kan ändras direkt. Dock kan du använda olika strängmetoder för att skapa nya strängar med de önskade modifieringarna.
Nu när vi har repeterat grunderna kring Python-strängar, kan vi fortsätta med att utforska några enkla men intressanta problem.
Låt oss börja.
Kontrollera om en Python-sträng är ett Palindrom
Problem: Givet en Python-sträng, avgör om det är ett palindrom eller inte.
Om det är ett palindrom, returnera True; annars, returnera False.
Vår första uppgift är att fastställa om en given sträng är ett palindrom eller inte.
Ett palindrom är en sträng som läses likadant både framlänges och baklänges. Exempel på palindrom är: ”racerbil”, ”referera”, ”nivå”, ”fru”, ”radar” och liknande.
Här är stegen för att lösa detta problem:
- Skapa en omvänd kopia av strängen, som kan lagras i en separat variabel.
- Jämför värdena för den ursprungliga strängen med den omvända strängen.
- Om de är identiska, är strängen ett palindrom. Returnera True och avsluta.
- Om originalet och den omvända kopian inte matchar, är strängen inte ett palindrom. Returnera False.
Nyckelmomentet är att generera en omvänd kopia av strängen. I Python finns det ett par sätt att uppnå detta.
Vi kommer att utforska två metoder:
- Användning av strängskivning (slicing).
- Användning av reversed()-funktionen kombinerad med join()-metoden.
Hur man Vänder en Python-Sträng med Hjälp av Slicing
Syntaxen
- Om start utelämnas, börjar skivan från början av strängen.
- Om stoppindexet inte anges, sträcker sig skivan till slutet av strängen.
- Negativa värden på steg kan användas för att extrahera segment från slutet av strängen.
Så
Följande kodavsnitt innehåller definitionen av funktionen is_palindrome().
Funktionen tar en sträng som argument och returnerar True eller False beroende på om strängen är ett palindrom eller inte.
Här använder vi strängskivning för att skapa en omvänd version 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 funktionen är definierad, kan vi anropa den med valfri sträng som argument.
is_palindrome("racecar")
True
I exemplet ovan är ”racecar” ett palindrom. Funktionen is_palindrome() returnerar korrekt True.
Prova nu att anropa funktionen med en sträng som inte är ett palindrom, som till exempel ”flod”.
is_palindrome("river")
False
Och som du ser, returnerar funktionen False, vilket är korrekt. ✅
Hur man Vänder en Python-Sträng med reversed() och join()
I Python kan du kombinera metoden join() med funktionen reversed() för att vända en sträng.
- Funktionen reversed() returnerar en omvänd iterator över tecknen i strängen.
- Metoden join() kan sedan användas för att sammanfoga dessa tecken i omvänd ordning.
Med denna metod kan du skriva om funktionen is_palindrome() enligt följande:
def is_palindrome(this_str):
rev_str="".join(reversed(this_str))
if (this_str == rev_str):
return True
else:
return False
Du kan även använda funktionen is_palindrome() i en listkomprehension för att filtrera ut alla palindromer från en lista av 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:
- Iterera genom str_list och anropa is_palindrome() för varje sträng.
- Om is_palindrome() returnerar True, läggs strängen till i palindrom-listan.
Som utdata visar, så är palindrom en lista som innehåller alla palindromiska strängar från str_list.
Kontrollera om Två Python-Strängar är Anagram
En annan vanlig frågeställning som kan dyka upp i intervjuer är att kontrollera om ett par strängar, str1 och str2, är anagram eller inte.
Två strängar betraktas som anagram om de innehåller samma antal av varje tecken. Det betyder att den ena strängen kan skapas genom att omordna tecknen i den andra strängen.
Exempel på anagram inkluderar ”state-taste”, ”save-vase”, ”armbow-below” och så vidare.
Hur man Söker Anagram med Hjälp av Counter-Objektet i Python
Ett enkelt och intuitivt sätt är att räkna antalet förekomster av varje tecken i de båda strängarna. Därefter kontrollerar man om dessa antal är lika.
Detta kan göras smidigt med hjälp av Counter-objektet från modulen collections. Counter-objektet returnerar en Python-ordbok, där tecknen fungerar som nycklar och deras respektive antal som värden.
Betrakta strängarna ”save” och ”vase”, som visas nedan.
str1 = "save" str2 = "vase"
Här är c1 och c2 Counter-objekt som lagrar 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 True eftersom str1 och str2 är anagram.
Med denna princip kan vi definiera funktionen are_anagrams() med parametrarna word1 och word2. Inuti funktionen jämför vi om Counter(word1) == Counter(word2).
def are_anagrams(word1, word2):
if Counter(word1) == Counter(word2):
return True
else:
return False
▶️ För att bekräfta, anropa are_anagrams() med str1 och str2 som argument. Eftersom str1 och str2 är anagram (”save” och ”vase”), returnerar funktionen True, vilket är rätt.
are_anagrams(str1, str2) True
Hur man Söker Anagram med Hjälp av Sorterade Kopior av Strängar
Det finns ett annat tillvägagångssätt för att lösa detta problem.
Om två strängar är anagram, så kommer deras sorterade kopior att vara lika.
Därför kan vi 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, är de två strängarna anagram; annars är de inte det.
Genom att använda metoden ovan för att jämföra sorterade kopior kan vi skriva om funktionen are_anagrams() enligt nedan.
def are_anagrams(word1, word2):
if sorted(word1) == sorted(word2):
return True
else:
return False
Låt oss nu utföra några funktionsanrop.
- Strängarna ”elbow” och ”below” är anagram, och funktionen are_anagrams() returnerar True.
- ”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 Titelformat
Här är den sista uppgiften för den här handledningen.
Problem: Givet en sträng, exempelvis ett personnamn med för- och efternamn.
Du ska kontrollera om den första bokstaven i både för- och efternamnet är versal.
Denna typ av formatering, där den första bokstaven i varje ord är versal, kallas titelformat (title case).
Du ska kontrollera om namnet är i titelformat:
1. Om så är fallet, ange att formateringen redan är i titelformat.
2. Annars, returnera en kopia av strängen som är formaterad i titelformat.
- Python har en inbyggd strängmetod, istitle(), som kontrollerar om en sträng är i titelformat.
- Pythons strängmetod title() returnerar en kopia av strängen som är formaterad i titelformat.
Nu kan du använda dessa två metoder för att lösa uppgiften.
Definiera en funktion check_titlecase() som tar emot ett namn som argument.
- Anropa istitle()-metoden på den inmatade strängen för att kontrollera om den är i titelformat.
- Om det är sant, skriv ut att strängen redan är i titelformat.
- Annars, anropa title()-metoden och returnera en kopia av strängen i titelformat.
Följande kodavsnitt visar definitionen av funktionen check_titlecase().
def check_titlecase(name):
if name.istitle():
print(f"'{name}' är redan formaterad i titelformat.")
else:
return name.title()
Låt oss anropa metoden check_titlecase() med ett argument.
check_titlecase("jane smith")
# Output
Jane Smith
Som du ser i utdata, så är strängen ”Jane Smith” nu i titelformat.
▶️ Låt oss ta ett annat exempel.
check_titlecase("agatha Christie")
# Output
Agatha Christie
Den här gången, låt oss anropa funktionen med en sträng som redan är i titelformat.
check_titlecase("Grace Hopper")
# Output
'Grace Hopper' är redan formaterad i titelformat.
Vi får ett meddelande som bekräftar att strängen är i titelformat, vilket visar att funktionen fungerar korrekt.
Sammanfattning 👩🏫
Låt oss nu sammanfatta de problem vi har diskuterat.
- För att avgöra om en sträng är ett palindrom, jämför strängen med dess omvända version. 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, jämför deras sorterade kopior. Använd den inbyggda sorted()-funktionen för att sortera strängar.
- För att bekräfta om ett namn är i titelformat, använd .istitle()-metoden för att kontrollera och .title()-metoden för att skapa en kopia av strängen med korrekt formatering.
Jag hoppas att du tyckte om denna handledning om Python-strängar. Som nästa steg kan du utforska hur man använder listkomprehension i Python, eller studera mer om ”inte lika med”-operatorn i Python.
Lycka till med studierna och programmeringen! 🎉