W niniejszym poradniku przeanalizujemy różnorodne techniki modyfikacji ciągów tekstowych w Pythonie, w tym wykorzystanie wbudowanych funkcji, wyrażeń regularnych oraz innych metod.
W Pythonie łańcuchy znaków stanowią integralną część struktury danych, przechowując sekwencje symboli Unicode. W odróżnieniu od innych typów danych, takich jak listy czy słowniki, łańcuchy są niezmienne. To oznacza, że raz utworzony łańcuch nie może być bezpośrednio zmodyfikowany.
Niemniej jednak, praca z łańcuchami często wymaga ich modyfikacji – usunięcia białych znaków na początku i końcu, zmiany wielkości liter, zastępowania znaków oraz wielu innych operacji.
Jak zatem można efektywnie manipulować łańcuchami w Pythonie? I jak zastąpić konkretny znak w łańcuchu? Na te pytania odpowiemy w tym samouczku, koncentrując się na następujących aspektach:
- Niezmienność łańcuchów znaków w Pythonie
- Dostępne w Pythonie metody do operacji na łańcuchach
- Różne metody zastępowania znaków w łańcuchach
Zacznijmy więc…
Niezmienność łańcuchów w Pythonie
Jak już wspomniano, łańcuchy w Pythonie charakteryzują się niezmiennością. Nie ma możliwości modyfikacji istniejącego łańcucha w miejscu. Zmiana ta wymaga utworzenia nowego łańcucha.
Weźmy na przykład łańcuch „Programowanie w Pythonie!”.
Dostęp do poszczególnych elementów łańcucha uzyskujemy poprzez indeksy, a fragmenty łańcucha (podłańcuchy) poprzez określenie zakresu indeksów:
>>> my_str = "Programowanie w Pythonie!" >>> my_str[0] 'P' >>> my_str[4] 'r' >>> my_str[1:9] 'rogramow' >>> my_str[9] 'a'
Załóżmy, że chcemy zastąpić literę „o” cyfrą „0”.
Wiemy, że „o” występuje w łańcuchu na indeksach 4 i 9 (jak widać w powyższym kodzie). Próba bezpośredniej zmiany znaku pod danym indeksem spowoduje jednak błąd:
>>> my_str[4] = '0' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment
Python dostarcza zestaw funkcji do operacji na łańcuchach. Funkcje te działają na istniejącym łańcuchu, a rezultatem jest nowy łańcuch z naniesionymi zmianami.
Przeczytaj również: Przykłady operacji na łańcuchach w Pythonie.
Zatem, aby modyfikować łańcuchy, możemy używać metod łańcuchowych w połączeniu z listami, pętlami i wyrażeniami regularnymi. W tym samouczku pokażemy różnorodne sposoby zamiany znaków w łańcuchu w Pythonie.
Zastępowanie znaku w łańcuchach Pythona
Istnieje wiele sytuacji, w których potrzebujemy zamienić znaki lub podłańcuchy w łańcuchu Pythona. Poniżej kilka z nich:
- Czyszczenie tekstu: Podczas pracy z tekstem często konieczne jest jego oczyszczenie, na przykład poprzez usunięcie znaków specjalnych, dodatkowych spacji lub niepożądanych symboli.
- Formatowanie: Możemy zmieniać formatowanie tekstu, np. zmieniając wielkość liter na duże lub małe, aby ujednolicić styl np. w tytułach.
- Maskowanie danych: W celu ochrony wrażliwych danych, takich jak numery identyfikacyjne lub karty kredytowe, często maskuje się dane, zachowując jednocześnie ich format.
- Obsługa URL i ścieżek: W pracy z adresami URL lub ścieżkami plików, konieczna może być zamiana niektórych znaków w celu zapewnienia ich prawidłowego formatu i kompatybilności z przeglądarkami internetowymi i systemami plików.
Rozważmy prosty przykład zastąpienia znaku w łańcuchu.
Zaczniemy od metody wykorzystującej pętle i instrukcje warunkowe, a następnie przedstawimy inne, efektywniejsze sposoby na osiągnięcie tego samego rezultatu.
Ponownie posłużmy się przykładem zastąpienia litery „o” cyfrą „0” w łańcuchu „Programowanie w Pythonie!”.
Oto jak możemy użyć pętli for do przeglądania łańcucha i zastępowania konkretnych znaków:
original_string = "Programowanie w Pythonie!"
new_string = ""
for char in original_string:
if char == "o":
new_string += "0"
else:
new_string += char
print(new_string)
W tej metodzie iterujemy po każdym znaku oryginalnego łańcucha. Jeżeli znakiem jest „o”, dodajemy do nowego łańcucha „0”, w przeciwnym wypadku dodajemy ten sam znak. W ten sposób dokonujemy zamiany znaków i tworzymy nowy łańcuch.
# Output Pr0gram0wanie w Pyth0nie!
Używanie pętli for oraz instrukcji if może być trudne do utrzymania, szczególnie przy potrzebie zastąpienia podłańcucha lub wielu znaków.
Istnieją lepsze sposoby na zastępowanie znaków i podłańcuchów, które omówimy w kolejnych rozdziałach.
#1. Użycie metody str.replace()
Do zastąpienia znaku lub podłańcucha innym łańcuchem znaków możemy użyć metody replace(). Wywołanie str.replace(old, new) zamienia wszystkie wystąpienia starego znaku lub podłańcucha nowym znakiem lub podłańcuchem.
W tym przykładzie używamy metody replace() do zastąpienia litery „o” cyfrą „0” w oryginalnym łańcuchu.
original_string = "Programowanie w Pythonie!"
new_string = original_string.replace("o", "0")
print(new_string)
Wynikowy ciąg znaków zostanie zapisany w new_string.
# Output Pr0gram0wanie w Pyth0nie!
#2. Użycie list składanych (ang. list comprehension) i metody join().
Do zamiany znaku w łańcuchu Pythona możemy również wykorzystać listę składaną w połączeniu z metodą join().
Zobaczmy, jak możemy zmodyfikować nasz przykład:
- Lista składana pozwala iterować po każdym znaku oryginalnego łańcucha. Jeśli dany znak to „o”, zastępujemy go „0”, w przeciwnym wypadku zachowujemy ten sam znak.
- Następnie używamy metody str.join(), aby połączyć te znaki w pojedynczy łańcuch, zapisując wynik w new_string. Jest to bardziej zwięzła alternatywa dla pętli i instrukcji warunkowych, zwłaszcza gdy zastępujemy pojedynczy znak w łańcuchu.
original_string = "Programowanie w Pythonie!" new_string = ''.join(['0' if char == 'o' else char for char in original_string]) print(new_string)
Otrzymujemy oczekiwany rezultat:
# Output Pr0gram0wanie w Pyth0nie!
#3. Użycie wyrażeń regularnych
Kolejną metodą zamiany znaków w łańcuchach Pythona jest zastosowanie wyrażeń regularnych (regex). Python oferuje wbudowany moduł re do operacji dopasowywania wzorców. Za pomocą wyrażenia regularnego możemy zdefiniować wzorzec do znalezienia, łańcuch do przeszukania oraz łańcuch znaków, na który chcemy zamienić znaleziony wzorzec.
Tutaj wykorzystujemy funkcję sub() z modułu re o składni re.sub(wzorzec, zamiana, łańcuch).
import re original_string = "Programowanie w Pythonie!" new_string = re.sub(r'o', '0', original_string) print(new_string)
Wzorzec r’o’ wyszukuje wszystkie wystąpienia litery „o” w oryginalnym łańcuchu i zamienia je na „0”.
# Output Pr0gram0wanie w Pyth0nie!
Za pomocą wyrażeń regularnych można dopasowywać bardziej złożone wzorce. Rozważmy przykład maskowania numerów kart kredytowych. Załóżmy, że chcemy zastąpić wszystkie cyfry (oprócz czterech ostatnich) znakiem „X”. Oto jak możemy to zrealizować:
import re
def mask_credit_card(card_number):
# Użycie wyrażeń regularnych do wyszukiwania i zastępowania znaków
masked_number = re.sub(r'\d(?=\d{4})', 'X', card_number)
return masked_number
# Przykładowe użycie:
credit_card_number = "1234567898765432"
masked_number = mask_credit_card(credit_card_number)
print(masked_number)
Oto wynik:
# Output XXXXXXXXXXXX5432
Dla uproszczenia wyrażenia regularnego, nie dodaliśmy łącznika, ale w razie potrzeby można zmodyfikować przykład.
#4. Wykorzystanie str.maketrans() i str.translate()
Metody str.maketrans() i str.translate() w Pythonie służą do wykonywania translacji i zamiany znaków w łańcuchach znaków.
Jak działa str.maketrans()?
Metoda maketrans() tworzy tabelę translacji, która definiuje sposób zamiany znaków w łańcuchu. Możemy ją użyć ze składnią: str.maketrans(x, y), gdzie:
- x to łańcuch zawierający znaki, które chcemy zamienić.
- y to łańcuch zawierający znaki, na które chcemy zamienić x.
Metoda maketrans() tworzy tabelę translacji na podstawie mapowania od x do y. Następnie tabelę translacji używamy z metodą str.translate() w celu dokonania faktycznej zamiany.
Jak działa str.translate()?
Metoda str.translate() służy do zastosowania tabeli translacji utworzonej przez str.maketrans() do łańcucha. Wykonuje zamianę znak po znaku, zgodnie z mapowaniem zdefiniowanym w tabeli translacji i zwraca nowy łańcuch z zamienionymi znakami.
Metoda translate() przyjmuje następującą składnię:
new_string = original_string.translate(translation_table)
- oryginalny_string: Łańcuch, który chcemy zmodyfikować.
- translation_table: Tabela translacji utworzona za pomocą str.maketrans(), która określa mapowanie znaków.
Łącząc metody maketrans() i translate(), możemy zmodyfikować nasz przykład w następujący sposób:
original_string = "Programowanie w Pythonie!"
translation_table = str.maketrans('o', '0')
new_string = original_string.translate(translation_table)
print(new_string)
Tutaj tworzymy tabelę translacji za pomocą str.maketrans(’o’, '0′), określając, że „o” powinno zostać zastąpione przez „0”. Następnie używamy metody translate() na oryginalnym łańcuchu, aby zastosować translację, a rezultatem jest nowy_łańcuch.
# Output Pr0gram0wanie w Pyth0nie!
Metody te są przydatne w zadaniach takich jak zastępowanie znaków i innych manipulacji na poziomie znaków w łańcuchach.
Podsumowanie
Podsumujmy to, czego się nauczyliśmy.
W Pythonie łańcuchy znaków są niezmienne. Zatem aby zamienić znak w łańcuchu, nie możemy przypisać nowego znaku do konkretnego indeksu. Omówiliśmy następujące sposoby zastępowania jednego lub wielu znaków w łańcuchu Pythona:
- Użyj metody str.replace(old, new), aby zamienić wszystkie wystąpienia starego podłańcucha na nowy.
- Możemy także wykorzystać listy składane i metodę join(). Lista składana umożliwia zmianę znaków, a metoda join() scala listę znaków w jeden łańcuch.
- Do dopasowywania wzorców możemy wykorzystać wyrażenia regularne, aby zastąpić wystąpienia znaku lub wzorca. Służy do tego funkcja sub() z re.sub(wzorzec, zamiana, łańcuch).
- Wykorzystaj str.maketrans(), aby uzyskać tabelę translacji i metodę translate() aby zastosować tablicę do oryginalnego łańcucha.
Zachęcamy do przećwiczenia powyższych przykładów, aby lepiej zrozumieć te techniki. Następnie dowiedz się jak usunąć ostatni znak z łańcucha Pythona.
newsblog.pl