# Python: come rimuovere o sostituire i caratteri da una stringa

Le stringhe in Python sono **immutabili**. Tuttavia, è possibile rimuovere dei caratteri utilizzando appositi metodi per creare una nuova sequenza di caratteri che contenga soltanto le parti desiderate dell’originale.

## Una spiegazione sull’immutabilità delle stringhe

Per immutabilità si intende il fatto che un oggetto, una volta creato, non può più essere modificato. Con le stringhe in Python, **ogni sequenza di caratteri è immutabile**. Se scegli di rimuovere dei caratteri da una stringa con i metodi di Python, in realtà stai creando una nuova sequenza di caratteri che contiene soltanto determinati elementi di quella originale. La stringa di partenza rimane invariata. L’immutabilità delle stringhe contribuisce a rendere efficiente la gestione della memoria in Python e aiuta a evitare effetti imprevisti quando si lavora con le sequenze di caratteri.

## Rimozione di determinati caratteri da una stringa

Per rimuovere determinati caratteri da una stringa, puoi utilizzare ad esempio `str.replace()` oppure `re.sub()` con un’**espressione regolare** che rappresenta i caratteri o il modello da rimuovere.

### `str.replace()`

La funzione `str.replace()` serve a rimuovere parti di un testo o sostituirle con una sottostringa.

```Python
original_string = "Hello, Python#"
modified_string = original_string.replace('#', '!')
print(original_string)  # Output: Hello, Python#
print(modified_string)  # Output: Hello, Python!
```

Nell’esempio qui sopra il metodo `replace()` sostituisce tutti i caratteri della forma “#” in `original_string` con un punto esclamativo “!”.

### `re.sub()`

La funzione `re.sub()` fa parte del **modulo re** in Python. Esso ti permette di cercare e sostituire espressioni regolari in sequenze di caratteri.

```Python
import re
original_string = "Hello, World! @#$%^&*"
modified_string = re.sub(r'[@#$%^&*]', '', original_string)
print(original_string)  # Output: Hello, World! @#$%^&*
print(modified_string)  # Output: Hello, World!
```

Il modello `[@#$%^&*]` è un’espressione regolare che cerca i caratteri speciali `@, #, $, %, ^, &,*`. La funzione `re.sub()` va alla ricerca di **tutte le corrispondenze del modello** nella stringa originale `original_string` e le sostituisce con una sequenza di caratteri vuota `''`. Il risultato viene memorizzato nella variabile `modified_string` e quindi emesso.

## Rimozione di tutti i caratteri tranne le lettere

Tra i vari metodi a tua disposizione per rimuovere tutte le lettere da una stringa trovi `isalpha()`, `filter()` e `re.sub()`.

### `re.sub()`

```Python
import re
original_string = "Hello, 123 World! @#$%^&*"
modified_string = re.sub(r'[^a-zA-Z]', '', original_string)
print(original_string)  # Output: Hello, 123 World! @#$%^&*
print(modified_string)  # Output: HelloWorld
```

L’espressione regolare `[^a-zA-Z]` corrisponde a ogni carattere che non sia una lettera maiuscola o minuscola. Come risultato, la stringa `modified_string` contiene solo le lettere della stringa originale. Anche gli spazi vuoti sono stati rimossi.

### `isalpha()`

```Python
original_string = "Hello, 123 World! @#$%^&*"
modified_string = ''.join(char for char in original_string if char.isalpha())
print(original_string)  # Output: Hello, 123 World! @#$%^&*
print(modified_string)  # Output: HelloWorld
```

In questo esempio utilizziamo le **comprensioni di lista** per eseguire un’iterazione con ogni lettera di `original_string`. Il metodo `isalpha()` controlla se un carattere è una lettera. Solo le lettere vengono inserite in una nuova sequenza di caratteri `modified_string`, mentre tutti gli altri caratteri vengono ignorati.

### `filter()`

```Python
original_string = "Hello, 123 World! @#$%^&*"
filtered_chars = filter(str.isalpha, original_string)
modified_string = ''.join(filtered_chars)
print(original_string)  # Output: Hello, 123 World! @#$%^&*
print(modified_string)  # Output: HelloWorld
```

Il metodo `str.isalpha()` restituisce il valore `True` se il carattere è una lettera; in caso contrario, restituisce `False`. La funzione `filter()` crea un **oggetto filter** che contiene solo i caratteri per i quali la condizione `str.isalpha()` è vera. In questo modo possiamo estrarre tutti i caratteri in `original_string` che non sono lettere.

## Rimozione di tutti i caratteri tranne i numeri

È possibile separare i numeri in modo simile agli esempi precedenti con `re.sub()`, `filter()` e con la funzione `isdecimal()` analoga a `isalpha()`.

### `re.sub()`

```Python
import re
original_string = "Hello, 123 World! @#$%^&*"
modified_string = re.sub('[^0-9]', '', original_string)
print(original_string)   # Output: Hello, 123 World! @#$%^&*
print(modified_string)    # Output: 123
```

Con `0-9` definiamo un intervallo che include tutte le cifre da 0 a 9. Il trattino di separazione `-` fra 0 e 9 funge da operatore di intervallo. Il segno `^` davanti si riferisce a tutti i caratteri che non sono compresi nell’intervallo indicato tra 0 e 9. Essi sono sostituiti con spazi vuoti da `re.sub`.

### `filter()`

```Python
original_string = "Hello, 123 World! @#$%^&*"
filtered_chars = filter(str.isdecimal, original_string)
modified_string = ''.join(filtered_chars)
print(original_string)   # Output: Hello, 123 World! @#$%^&*
print(modified_string)    # Output: 123
```

La funzione `filter()`, in combinazione con `isdecimal()`, permette di filtrare i numeri in una stringa e rimuovere i restanti caratteri. La nuova stringa mostra di conseguenza solo le cifre `123`.

### `isdecimal()`

```Python
original_string = "Hello, 123 World"
modified_string = ''.join('*' if not char.isdecimal() else char for char in original_string)
print(original_string)   # Output: Hello, 123 World
print(modified_string)    # Output: *******123******
```

È anche possibile utilizzare il metodo `isdecimal()` in una comprensione di lista per eseguire un’iterazione su ogni `char` in `original_string`. Se il carattere non è una cifra decimale (`not char.isdecimal()` è vera), viene sostituito da un asterisco `*`, altrimenti resta invariato.

## Rimozione di caratteri con `translate()`

Il metodo `translate()` è una funzione integrata in Python, utilizzata per la sostituzione e la traduzione avanzate di caratteri in sequenze di caratteri. Il metodo offre una soluzione efficiente per sostituire caratteri sulla base di una tabella di traduzione.

```Python
original_string = "Hello, World! Remove vowels."
translation_table = str.maketrans(dict.fromkeys('aeiouAEIOU', '*'))
modified_string = original_string.translate(translation_table)
print(original_string)   # Output: Hello, World! Remove vowels.
print(modified_string)    # Output: H*ll*, W*rld! R*m*v* v*w*ls.
```

Utilizziamo il costruttore `str.maketrans()` e `dict.fromkeys()` per creare la **tabella di traduzione**. Quest’ultima prevede che tutte le vocali debbano essere sostituite con `*`. La tabella viene quindi applicata sulla stringa originale per ottenere la stringa `modified_string`.

Consiglio Per filtrare le stringhe è anche possibile considerare il metodo [string index in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/metodo-index-per-stringhe-python/), così da filtrare i caratteri in determinate posizioni. Se come output desideri ottenere le sequenze di caratteri in un formato specifico, ti consigliamo di dare un’occhiata all’articolo dedicato alla [formattazione delle stringhe in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/formattazione-delle-stringhe-in-python/) nella nostra guida.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-remove-character-from-string/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-remove-character-from-string/) for AI/LLM consumption.