# Esempi per la conversione da stringa a lista in Python

Le liste sono oggetti modificabili, mentre le stringhe in Python sono immutabili. Grazie alla **conversione di una stringa in una lista** è possibile modificare, aggiungere o rimuovere singoli caratteri o sottosezioni della stringa.

## Da stringa a lista in Python: i metodi di conversione

Per convertire una stringa in una lista in Python è necessario trasformare la stringa in una struttura di dati che deve **supportare le operazioni sulle liste** e quindi consentire una manipolazione avanzata dei dati.

Nelle parti seguenti ti mostriamo i metodi più diffusi per convertire una stringa in una lista.

### split()

Il metodo [split in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/split-in-python/) scompone una stringa in una **lista di sottostringhe** basandosi su un determinato separatore o modello. La sintassi generale è la seguente:

```python
string.split(sep=None, maxsplit=-1)
```

- `string`: questa è la stringa originale.
- `sep` (opzionale): questo è il separatore in corrispondenza del quale dividere la stringa. Se non si indica nessun separatore, il metodo divide la stringa in corrispondenza degli spazi.
- `maxsplit` (opzionale): `maxsplit` definisce il numero massimo di divisioni da eseguire. Se non indicato o se l’impostazione è -1, vengono eseguite tutte le divisioni possibili.

Esempio:

```python
text = "blue,green,yellow,red"
print(f"List of colors = {text.split(',')}")
```

Il risultato è il seguente:

```python
List of colors = ['blue', 'green', 'yellow', 'red']
```

Le f-string sono un metodo di [formattazione delle stringhe in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/formattazione-delle-stringhe-in-python/) che accetta un’espressione a piacere come segnaposto fra le parentesi graffe. Pertanto possiamo collegare il risultato della funzione `split()` con la stringa `”List of colors = “`.

### list()

La funzione [list in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/liste-in-python/) serve a convertire diverse strutture di dati, comprese le stringhe, in liste. Assegnando una stringa come argomento alla funzione `list()`, **ogni lettera oppure ogni carattere della stringa viene memorizzato come elemento separato** nella lista risultante.

```python
text = "Hello"
char_list = list(text)
print(char_list)
# Output: ['H', 'e', 'l', 'l', 'o']
```

### List comprehension

Il metodo list comprehension è un modo per creare liste combinando **cicli e condizioni** in un’unica riga.

```python
text = "Hello World"
char_list = [char for char in text]
print(char_list)
# Output: ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
```

In questo esempio utilizziamo la stringa `"Hello World"` per creare una lista e memorizzarla in `char_list`. Il metodo list comprehension prende in esame ogni lettera `char` nella stringa `text` e la aggiunge come singolo elemento alla lista `char_list`.

### String slicing

Lo string slicing è un altro metodo per convertire una stringa in una lista in Python che **estrae sottosequenze di una stringa** e le memorizza in una lista sotto forma di elementi.

```python
substring_list = string[start:stop:step]
```

- `start`: l’indice da cui ha inizio lo slicing. La parte di stringa inizia dal carattere che si trova in questa posizione.
- `stop`: l’indice dove termina lo slicing. La sequenza termina prima del carattere che si trova in questa posizione.
- `step` (opzionale): il passo con cui si esegue lo slicing. Indica quanti caratteri lasciare fra ciascun carattere selezionato.

```python
def convert(string):
    list1 = []
    list1[:0] = string
    return list1
str1 = "xyz"
print(convert(str1))
# Output: ['x', 'y', 'z']
```

Il metodo `convert(string)` è una **funzione definita dall’utente** che converte una stringa in una lista di caratteri. Se si esegue l’espressione `list1[:0] = string`, i singoli caratteri della stringa vengono inseriti nella lista vuota `list1`.

### re.findall()

La funzione `re.findall()` è utilizzabile come metodo in Python per eseguire la conversione da stringa a lista e permette di trovare **tutte le corrispondenze di un’espressione regolare** in una stringa restituendole sotto forma di lista.

```python
import re
text = "123 and 456 are numbers."
numbers_list = re.findall(r'\d+', text)
print(numbers_list)
# Output: ['123', '456']
```

L’espressione regolare `r'\d+'` cerca una o più cifre consecutive nel testo e le restituisce come elementi separati in una lista.

### enumerate()

La funzione `enumerate()` è integrata in Python e serve a ottenere l’indice e il valore di ciascun elemento di una struttura di dati iterabile. Se desideri che la lista contenga solo i valori (ossia i caratteri della stringa), puoi utilizzare `enumerate()` in combinazione con il metodo list comprehension:

```python
text = "Python"
char_list = [char for index, char in enumerate(text)]
print(char_list)
# Output: ['P', 'y', 't', 'h', 'o', 'n']
```

### JSON

JSON è un modulo che puoi utilizzare per la lettura e la scrittura di dati JSON e per la conversione da strutture di dati Python al formato JSON e viceversa. Per la funzione di conversione da stringa a lista in Python il modulo JSON offre la possibilità di **eseguire il parsing di una stringa per ottenere un oggetto Python corrispondente**.

```python
import json
json_string = '[1, 2, 3, 4, 5]'
list_from_json = json.loads(json_string)
print(list_from_json)
# Output: [1, 2, 3, 4, 5]
```

La funzione `json.loads()` analizza la stringa JSON e la converte in un oggetto Python corrispondente: in questo caso, in una lista.

### ast.literal

Il modulo `ast` (Abstract Syntax Trees) ti permette di valutare una stringa in una struttura di dati Python. A tal fine la stringa viene interpretata come un literal di Python. Se hai una stringa in un formato literal di Python valido (ad esempio una lista, un dizionario, un numero, ecc.), puoi utilizzare `ast.literal_eval()` per trasformarla in modo sicuro nell’oggetto Python corrispondente.

```python
import ast
string = "[1, 2, 3, 4, 5]"
my_list = ast.literal_eval(string)
print(my_list)
# Output: [1, 2, 3, 4, 5]
```

Nella nostra guida troverai inoltre spiegazioni sul funzionamento della [conversione da stringa al modulo datetime in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/python-conversione-da-stringa-a-datetime/).


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/da-stringa-a-lista-in-python/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/da-stringa-a-lista-in-python/) for AI/LLM consumption.