W tym samouczku omówiono różne sposoby zastępowania znaku w ciągu znaków w języku Python: przy użyciu wbudowanych metod ciągów, wyrażeń regularnych i nie tylko.
Ciągi znaków w Pythonie to wbudowane struktury danych przechowujące sekwencję znaków Unicode. W przeciwieństwie do niektórych struktur danych w języku Python, takich jak listy i słowniki, ciągi znaków są niezmienne. Oznacza to, że nie można modyfikować istniejącego ciągu.
Jednak podczas pracy z nimi możesz chcieć manipulować ciągami — usuwać początkowe i końcowe białe spacje, zmieniać wielkie litery, zastępować znak innym i wykonywać wiele innych czynności.
Jak zatem manipulować ciągami znaków w Pythonie? A jak zastąpić znak w ciągu Pythona? Odpowiemy na te pytania w tym samouczku, skupiając się na:
- Niezmienność ciągów znaków w Pythonie
- Metody łańcuchowe Pythona do manipulacji ciągami
- Różne sposoby zastępowania znaku w ciągu
Zacznijmy…
Spis treści:
Niezmienność ciągów znaków w Pythonie
Jak wspomniano, ciągi znaków w Pythonie są niezmienne. Nie można więc modyfikować istniejącego ciągu w miejscu. nie można modyfikować istniejącego ciągu w miejscu
Rozważmy na przykład ciąg „Programowanie w Pythonie!”.
Dostęp do pojedynczego elementu ciągu można uzyskać za pomocą indeksu i podciągu, określając wycinek z początkiem i końcem, jak pokazano:
>>> my_str = "Python programming!" >>> my_str[0] 'P' >>> my_str[4] 'o' >>> my_str[1:9] 'ython pr' >>> my_str[9] 'o'
Załóżmy, że chcesz zastąpić literę „o” cyfrą „0”.
Wiesz, że masz o w indeksach 4 i 9 (zobacz fragment kodu powyżej). Jeśli jednak spróbujesz bezpośrednio ustawić znak – pod określonym indeksem – na „0”, pojawi się następujący 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 udostępnia zestaw metod łańcuchowych, które działają na istniejącym ciągu i zwracają nowy ciąg z wymaganymi zmianami.
Przeczytaj także: Programy w Pythonie dotyczące operacji na łańcuchach.
Można więc używać metod ciągów w połączeniu ze znakami listowymi, pętlami i wyrażeniami regularnymi do wykonywania zadań manipulacji ciągami. W tym samouczku przyjrzymy się różnym sposobom zamiany znaku w ciągu znaków w języku Python.
Zastępowanie znaku w ciągach znaków Pythona
Istnieje wiele przypadków użycia, w których możesz chcieć zamienić znaki lub podciągi w ciągu Pythona. Tutaj jest kilka z nich:
- Czyszczenie tekstu: Podczas pracy z danymi tekstowymi może zaistnieć potrzeba wyczyszczenia tekstu poprzez zamianę niektórych znaków. Na przykład usunięcie lub zastąpienie znaków specjalnych, dodatkowego odstępu lub niechcianych symboli.
- Formatowanie: możesz zmienić formatowanie tekstu, na przykład pisanie wielkimi literami lub konwertowanie tekstu na małe litery. Na przykład zapewnienie spójnej wielkości liter w tytułach lub nagłówkach.
- Maskowanie danych: często będziesz musiał maskować poufne informacje, takie jak osobiste numery identyfikacyjne lub numery kart kredytowych, aby chronić wrażliwe dane przy jednoczesnym zachowaniu formatu.
- Adresy URL i obsługa ścieżek: Podczas pracy z adresami URL lub ścieżkami plików może zaistnieć potrzeba zamiany niektórych znaków, aby upewnić się, że są one prawidłowo sformatowane i zgodne z przeglądarkami internetowymi lub systemami plików.
Weźmy prosty przykład zamiany znaku w ciągu znaków.
Zaczniemy od podejścia wykorzystującego pętle i instrukcje warunkowe, a następnie przejdziemy do omówienia innych lepszych metod osiągnięcia tego samego.
Weźmy ten sam przykład zastąpienia „o” przez „0” w ciągu „Programowanie w Pythonie!”.
Oto jak możemy wykonać pętlę po ciągu za pomocą pętli for i zastąpić określony znak:
original_string = "Python programming!"
new_string = ""
for char in original_string:
if char == "o":
new_string += "0"
else:
new_string += char
print(new_string)
W tym podejściu ręcznie przeglądamy każdy znak w oryginalnym_ciągu. Jeśli znakiem jest „o”, do nowego ciągu dołączamy „0”; w przeciwnym razie dołączymy ten sam znak. W ten sposób dokonujemy zamiany znaków i budujemy new_string.
# Output Pyth0n pr0gramming!
Używanie pętli for i rozgałęzień warunkowych z instrukcjami if jest trudne w utrzymaniu. Zwłaszcza gdy trzeba zastąpić podciąg lub wiele znaków.
Istnieją lepsze podejścia do zastępowania znaków lub podciągów i przyjrzymy się im w kolejnych sekcjach.
#1. Używanie str.replace()
Możemy użyć metody łańcuchowej zamiany(), aby zastąpić znak lub podciąg innym ciągiem. Użycie str.replace(old, new) zastępuje wszystkie wystąpienia starego znaku lub podciągu nowym znakiem lub podciągiem.
Tutaj używamy litery „o” metody zamiany() z cyfrą „0” w oryginalnym_ciągu.
original_string = "Python programming!"
new_string = original_string.replace("o", "0")
print(new_string)
Wynikowy ciąg znaków znajduje się w new_string.
# Output Pyth0n pr0gramming!
#2. Używanie rozumienia list i metody Join().
Aby zastąpić znak w ciągu Pythona, możemy użyć rozumienia list w połączeniu z metodą łańcuchową Join().
Zobaczmy, jak możemy przepisać nasz przykład:
- Możemy użyć rozumienia listy, aby iterować po każdym znaku w oryginalnym_ciągu. Jeśli znak to „o”, zastępujemy go „0” i w przeciwnym razie zachowujemy ten sam znak.
- Następnie używamy str.join() do połączenia tych znaków w jeden ciąg, w wyniku czego otrzymujemy new_string. Należy pamiętać, że jest to bardziej zwięzła alternatywa dla pętli i rozgałęzień warunkowych, gdy trzeba zastąpić pojedynczy znak w ciągu.
original_string = "Python programming!" new_string = ''.join(['0' if char == 'o' else char for char in original_string]) print(new_string)
Otrzymujemy oczekiwany wynik:
# Output Pyth0n pr0gramming!
#3. Używanie wyrażeń regularnych
Inną metodą zastępowania znaków w ciągach znaków Pythona jest użycie wyrażeń regularnych (regex). Python ma wbudowany moduł moduł ponownie dla operacji dopasowywania wyrażeń regularnych. Za pomocą wyrażenia regularnego możesz określić wzorzec do wyszukania, ciąg do przeszukania i ciąg znaków, na który chcesz zastąpić dopasowany wzorzec.
Tutaj używamy funkcji sub() z modułu re o składni re.sub(wzór, zamiana, ciąg).
import re original_string = "Python programming!" new_string = re.sub(r'o', '0', original_string) print(new_string)
Wzorzec r’o’ dopasowuje wszystkie wystąpienia litery 'o’ w oryginalnym_ciągu i zastępuje je wartością '0′.
# Output Pyth0n pr0gramming!
Do dopasowania bardziej złożonych wzorców można używać wyrażeń regularnych. Weźmy przykład maskowania numerów kart kredytowych. Załóżmy, że chcemy zastąpić wszystkie liczby — z wyjątkiem czterech ostatnich cyfr — znakiem „X”. Oto jak możemy to zrobić:
import re
def mask_credit_card(card_number):
# Use regular expressions to match and replace characters
masked_number = re.sub(r'\d(?=\d{4})', 'X', card_number)
return masked_number
# Example usage:
credit_card_number = "1234567898765432"
masked_number = mask_credit_card(credit_card_number)
print(masked_number)
A oto wynik:
# Output XXXXXXXXXXXX5432
Aby zachować prostotę wyrażenia regularnego, nie dodaliśmy łącznika, ale jeśli chcesz, możesz zmodyfikować przykład w razie potrzeby.
#4. Korzystanie ze str.maketrans() i str.translate()
Metody str.maketrans() i str.translate() w Pythonie służą do wykonywania translacji i zamiany na poziomie znaków w ciągach znaków.
Jak działa str.maketrans().
Metoda maketrans() służy do tworzenia tabeli tłumaczeń, która określa, w jaki sposób znaki powinny być zastępowane w ciągu znaków. Można go używać ze składnią: str.maketrans(x, y). Tutaj:
- x to ciąg zawierający znaki, które chcesz zastąpić.
- y to ciąg zawierający znaki, którymi chcesz zastąpić x.
Metoda maketrans() generuje tabelę translacji w oparciu o odwzorowania od x do y. Następnie możesz użyć tej tabeli tłumaczeń z metodą str.translate(), aby dokonać faktycznej zamiany.
Jak działa str.translate().
Możesz użyć metody str.translate(), aby zastosować tabelę translacji utworzoną przez str.maketrans() do łańcucha. Wykonuje zamianę znak po znaku w oparciu o odwzorowania zdefiniowane w tabeli tłumaczeń. I zwraca nowy ciąg znaków z zastosowanymi określonymi zamianami znaków.
Oto jak możesz użyć metody tłumacz():
new_string = original_string.translate(translation_table)
- oryginalny_string: Ciąg wejściowy, który chcesz zmodyfikować.
- Translation_table: Tabela tłumaczeń utworzona za pomocą str.maketrans(), która definiuje mapowania znaków.
Łącząc metody maketrans() i str.translate(), przepiszmy nasz przykład w następujący sposób:
original_string = "Python programming!"
translation_table = str.maketrans('o', '0')
new_string = original_string.translate(translation_table)
print(new_string)
Tutaj tworzymy tabelę tłumaczeń za pomocą str.maketrans(’o’, '0′) w celu określenia, że „o” powinno zostać zastąpione przez „0”. Następnie używamy metody tłumaczenia() na oryginalnym_ciągu, aby zastosować to tłumaczenie, w wyniku czego powstaje nowy_ciąg.
# Output Pyth0n pr0gramming!
Metody te są przydatne do zadań takich jak zastępowanie znaku i inne manipulacje na poziomie znaku w ciągach.
Wniosek
Przeanalizujmy, czego się nauczyliśmy.
Ciągi Pythona są niezmienne. Jeśli więc chcesz zamienić znak w ciągu Pythona, nie możesz po prostu ponownie przypisać znaku do określonego indeksu. Omówiliśmy następujące sposoby zamiany znaku lub wielu znaków w ciągu Pythona:
- Użyj str.replace(old, new), aby zastąpić wszystkie wystąpienia starego nowym podciągiem.
- Można także użyć rozumienia list i metody Join(). Użyj funkcji rozumienia listy, aby zastąpić znaki, oraz metody Join(), aby połączyć listę znaków w ciąg znaków.
- Dopasowywania wzorców można używać z wyrażeniami regularnymi, aby zastąpić wystąpienia znaku lub wzorca. Użyj funkcji sub() z re.sub(wzorzec, zamiana, ciąg znaków).
- Użyj str.maketrans(), aby uzyskać tabelę tłumaczeń, i metody translacji(), aby zastosować tabelę tłumaczeń do oryginalnego ciągu.
Pamiętaj, aby zakodować kilka przykładów, aby lepiej zrozumieć te techniki. Następnie dowiedz się, jak usunąć ostatni znak z ciągu Pythona.