Questo articolo come sostituire le stringhe in Python.
- Sostituisci le sottostringhe:
replace()- Specificare il numero massimo di sostituzioni:
count - Sostituisci più sottostringhe diverse
- Sostituisci il carattere di nuova riga
- Specificare il numero massimo di sostituzioni:
- Sostituisci più caratteri diversi:
translate() - Sostituisci con regex:
re.sub(), re.subn()- Sostituisci più sottostringhe con la stessa stringa
- Sostituisci usando la parte abbinata
- Ottieni il conteggio delle parti sostituite
- Sostituisci con posizione: affettare
Puoi anche rimuovere la sottostringa sostituendola con una stringa vuota ”.
Se si desidera estrarre una sottostringa da una stringa invece di sostituirla, vedere l’articolo seguente.
Sostituisci le sottostringhe:replace()
Usa replace() per sostituire le sottostringhe.
Specificare la vecchia stringa vecchia per il primo argomento e la nuova stringa nuova per il secondo argomento.
s = 'one two one two one'
print(s.replace(' ', '-'))
# one-two-one-two-one
Specificando la stringa vuota ” come nuova eliminerà la vecchia.
print(s.replace(' ', ''))
# onetwoonetwoone
Specificare il numero massimo di sostituzioni:count
È possibile specificare il numero massimo di sostituzioni nel terzo parametro, conte. Se viene fornito il conteggio, vengono sostituite solo le prime occorrenze di conteggio.
print(s.replace('one', 'XXX'))
# XXX two XXX two XXX
print(s.replace('one', 'XXX', 2))
# XXX two XXX two one
Sostituisci più sottostringhe diverse
Quando si sostituiscono stringhe diverse con la stessa più stringa, utilizzare l’espressione regolare descritta più avanti.
Non esiste un metodo per sostituire più stringhe diverse con stringhe diverse, ma puoi applicare sostituisci().
print(s.replace('one', 'XXX').replace('two', 'YYY'))
# XXX YYY XXX YYY XXX
Chiama semplicemente replace() in ordine, quindi se il primo nuovo contiene il seguente vecchio, anche il primo nuovo viene sostituito. Devi stare attento in ordine.
print(s.replace('one', 'XtwoX').replace('two', 'YYY'))
# XYYYX YYY XYYYX YYY XYYYX
print(s.replace('two', 'YYY').replace('one', 'XtwoX'))
# XtwoX YYY XtwoX YYY XtwoX
Quando si sostituiscono più caratteri (una stringa di lunghezza 1), è possibile utilizzare il metodo translate() di seguito.
Sostituisci il carattere di nuova riga
Se c’è un solo tipo di carattere di nuova riga, puoi specificarlo come primo argomento di sostituire().
s_lines = 'onentwonthree'
print(s_lines)
# one
# two
# three
print(s_lines.replace('n', '-'))
# one-two-three
Fare attenzione se n (LF, utilizzatore nel sistema operativo Unix incluso Mac) e rn (CR + LF, utilizzatore nel sistema operativo Windows) sono mischiati.
Poiché n è incluso in rn, non è possibile ottenere il risultato desiderato a seconda dell’ordine. L’esempio seguente mostra anche il risultato di repr() che contiene ner come una stringa.
s_lines_multi = 'onentwornthree'
print(s_lines_multi)
# one
# two
# three
print(repr(s_lines_multi))
# 'onentwornthree'
print(s_lines_multi.replace('rn', '-').replace('n', '-'))
# one-two-three
print(repr(s_lines_multi.replace('rn', '-').replace('n', '-')))
# 'one-two-three'
print(s_lines_multi.replace('n', '-').replace('rn', '-'))
# -threeo
print(repr(s_lines_multi.replace('n', '-').replace('rn', '-')))
# 'one-twor-three'
Puoi usare splitlines(), che aggiunge una lista divisa con vari caratteri di nuova riga, e join(), che combina liste con stringhe.
In questo modo è sicuro e consigliato, soprattutto se non sai quali caratteri di nuova riga sono inclusi.
print(s_lines_multi.splitlines())
# ['one', 'two', 'three']
print('-'.join(s_lines_multi.splitlines()))
# one-two-three
Vedere gli articoli seguenti per altre operazioni relative alla divisione delle stringhe e alle interruzioni di riga.
Sostituisci più caratteri diversi:translate()
Usa il metodo translate() per sostituire più caratteri.
Puoi creare la tabella di traduzione specificata in translate() da str.maketrans().
Specificare un dizionario la cui chiave è il vecchio carattere e il cui valore è la nuova stringa in str.maketrans().
Il vecchio carattere deve essere un carattere (una stringa di lunghezza 1). La nuova stringa è una stringa o None, dove None rimuove i vecchi caratteri.
s = 'one two one two one'
print(s.translate(str.maketrans({'o': 'O', 't': 'T'})))
# One TwO One TwO One
print(s.translate(str.maketrans({'o': 'XXX', 't': None})))
# XXXne wXXX XXXne wXXX XXXne
str.maketrans() può anche prendere tre stringhe come argomenti invece di un dizionario.
Il primo argomento è una stringa in cui vengono concatenati i vecchi caratteri, secondo il è una stringa in cui vengono concatenati i nuovi caratteri e il terzo è una stringa in cui vengono concatenati i caratteri da.
print(s.translate(str.maketrans('ow', 'XY', 'n')))
# Xe tYX Xe tYX Xe
In questo caso, le lunghezze del primo e del secondo argomento devono corrispondere.
# print(s.translate(str.maketrans('ow', 'XXY', 'n')))
# ValueError: the first two maketrans arguments must have equal length
Sostituisci con regex:re.sub(), re.subn()
Se vuoi una stringa che corrisponde a un’espressione regolare (regex) invece di una corrispondenza perfetta, usa sub() del modulo re.
In re.sub(), specifica un modello regex nel primo argomento, una nuova stringa nel secondo e una stringa da elaborare nel terzo.
import re
s = 'aaa@xxx.com bbb@yyy.com ccc@zzz.com'
print(re.sub('[a-z]*@', 'ABC@', s))
# ABC@xxx.com ABC@yyy.com ABC@zzz.com
Come con replace(), puoi specificare il numero massimo di sostituzioni nel quarto parametro, count.
print(re.sub('[a-z]*@', 'ABC@', s, 2))
# ABC@xxx.com ABC@yyy.com ccc@zzz.com
Sostituisci più sottostringhe con la stessa stringa
I due seguenti sono utili da ricordare anche se non hai familiarità con la regex.
Racchiudi una stringa con [] in qualsiasi modo che corrisponda a singolo carattere in esso contenuto. Puoi sostituire più caratteri con la stessa stringa.
print(re.sub('[xyz]', '1', s))
# aaa@111.com bbb@111.com ccc@111.com
Se i modelli sono delimitati da |, corrispondono a qualsiasi modello. Naturalmente, è possibile utilizzare caratteri speciali di regolare per ogni modello, ma va bene anche se la stringa normale è specificata così com’è. È possibile più stringhe diverse con la stessa stringa.
print(re.sub('aaa|bbb|ccc', 'ABC', s))
# ABC@xxx.com ABC@yyy.com ABC@zzz.com
Sostituisci usando la parte abbinata
Se parte del motivo è racchiusa tra (), puoi utilizzare una stringa che corrisponda alla parte racchiusa tra () nella nuova stringa.
print(re.sub('([a-z]*)@', '\1-123@', s))
# aaa-123@xxx.com bbb-123@yyy.com ccc-123@zzz.com
print(re.sub('([a-z]*)@', r'1-123@', s))
# aaa-123@xxx.com bbb-123@yyy.com ccc-123@zzz.com
1 corrisponde alla parte che corrisponde a (). Se ce ne sono più (), usali come 2, 3 … .
È necessario eseguire l’escape come \1 in una stringa normale (” o “”), ma puoi scrivere 1 in una stringa grezza (r” o r””).
Ottieni il conteggio delle parti sostituite
re.subn() restituisce una tupla della stringa sostituita e il numero di parti sostituite.
t = re.subn('[a-z]*@', 'ABC@', s)
print(t)
# ('ABC@xxx.com ABC@yyy.com ABC@zzz.com', 3)
print(type(t))
# <class 'tuple'>
print(t[0])
# ABC@xxx.com ABC@yyy.com ABC@zzz.com
print(t[1])
# 3
Sostituisci con posizione: affettare
Non esiste un metodo per sostituire la stringa nella posizione specificata.
Dividendo la stringa con una fetta e concatenandola con un’altra stringa, puoi una nuova stringa con la creazione posizione specificata sostituita.
s = 'abcdefghij'
print(s[:4] + 'XXX' + s[7:])
# abcdXXXhij
La lunghezza della stringa (numero di caratteri) può essere ottenuto con len(), quindi può essere scritta come segue:
s_replace = 'XXX'
i = 4
print(s[:i] + s_replace + s[i + len(s_replace):])
# abcdXXXhij
Il numero di caratteri non deve corrispondere, poiché concatena semplicemente stringhe diverse tra le stringhe divise.
print(s[:4] + '-' + s[7:])
# abcd-hij
È anche possibile creare una nuova stringa inserendo un’altra stringa in un punto della stringa.
print(s[:4] + '+++++' + s[4:])
# abcd+++++efghij
Vedere il seguente articolo per i dettagli sull’affettatura.