# Kuinka muuntaa merkkijonot listoiksi Pythonissa

Pythonissa listat ovat muokattavia objekteja, kun taas merkkijonot ovat muuttumattomia. **Muuntamalla merkkijonon listaksi** voit muokata, lisätä tai poistaa yksittäisiä merkkejä tai merkkijonon osia.

## Mitä erilaisia tapoja on muuntaa Python-merkkijonot listoiksi?

Kun muunnat merkkijonon luetteloksi, muutat tietorakennetta niin, että se tukee **luettelotoimintoja**. Tämä puolestaan laajentaa käytettävissä olevien tietojen käsittelyvaihtoehtojen valikoimaa.

Tässä on joitakin yleisimpiä tapoja muuntaa merkkijono listaksi:

### `split()`

Pythonin split-metodi jakaa merkkijonon **alimerkkijonojen luetteloksi** tietyn erottimen tai mallin perusteella. Tämän metodin yleinen syntaksi on:

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

- `string`: Tämä on alkuperäinen merkkijono.
- `sep` (valinnainen): Tämä on erottimena käytettävä merkki, jonka kohdalta merkkijono jaetaan. Jos erottinta ei anneta, menetelmä jakaa merkkijonon oletusarvoisesti välilyönneillä.
- `maxsplit` (valinnainen): `maxsplit` määrittää tehtävien jakojen enimmäismäärän. Jos haluat, että Python suorittaa kaikki mahdolliset jaot, voit joko asettaa parametrin arvoksi -1 tai jättää sen tyhjäksi.

Esimerkki:

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

johtaa tulokseen:

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

f-merkkijonot ovat Python-merkkijonoformaatti, joka hyväksyy minkä tahansa lausekkeen paikkamerkkinä aaltosulkeissa. Tätä formaattia käyttämällä voimme yhdistää `split()` tuloksen merkkijonoon `"List of colors = "`.

### `list()`

Pythonin list()-funktiota käytetään muuntamaan erilaisia tietorakenteita, kuten merkkijonoja, listoiksi. Jos annat merkkijonon argumenttina `list()`, **merkkijonon jokainen kirjain tai merkki tallennetaan erillisenä elementtinä** tuloksena olevaan listaan.

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

### Luettelon ymmärtäminen

List comprehension on kompakti tapa luoda luetteloita yhdistämällä **silmukat ja ehdot** yhdelle riville.

```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']
```

Tässä esimerkissä aloitamme merkkijonolla `"Hello World"` ja luomme luettelon, joka tallennetaan `char_list`. Luettelon ymmärtäminen toistaa jokaisen merkin (`char`) merkkijonossa `text` ja lisää sen yhtenä elementtinä luetteloon `char_list`.

### Merkkijonon leikkaaminen

Merkkijonojen leikkaaminen on toinen tapa muuntaa Python-merkkijonot listoiksi. Se poimii **merkkijonon osia** (osamerkkijonoja) ja tallentaa ne listan elementteinä.

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

- `start`: Tämä on indeksi, josta leikkaus alkaa. Alimerkkijono alkaa tällä sijainnilla olevalla merkillä.
- `stop`: Tämä on indeksi, jossa leikkaus päättyy. Jono sisältää kaikki merkit tähän kohtaan asti, mutta ei itse merkkiä tässä kohdassa.
- `step` (valinnainen): Tämä on etäisyys kunkin valitun merkin välillä, kun leikkaus suoritetaan. Se määrittää, kuinka monta merkkiä kunkin valitun merkin välillä on ohitettava.

`convert(string)` on **käyttäjän määrittämä funktio**, joka muuntaa merkkijonon merkkien luetteloksi. Kun lauseke `list1[:0] = string` suoritetaan, merkkijonon yksittäiset merkit lisätään tyhjään luetteloon `list1`.

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

### `re.findall()`

Voit käyttää `re.findall()` muuntamaan Python-merkkijonot listoiksi etsimällä merkkijonosta **kaikki säännöllisen lausekkeen esiintymät** ja hakemalla ne listana.

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

Säännöllinen lauseke `r'\d+'` etsii tekstistä yhden tai useamman peräkkäisen numeron ja palauttaa ne erillisinä elementteinä luettelossa.

### `enumerate()`

Pythonin `enumerate()` hakee sekä indeksin että arvon jokaisesta elementistä toistettavassa tietorakenteessa. Jos haluat, että luettelo sisältää vain arvot (eli merkkijonon merkit), voit yhdistää `enumerate()` luettelon ymmärtämiseen:

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

### JSON

JSON on moduuli, jota käytetään JSON-tietojen lukemiseen ja kirjoittamiseen sekä Python-tietorakenteiden muuntamiseen JSON-muotoon ja päinvastoin. Jos haluat muuntaa Python-merkkijonot listoiksi JSON-moduulin avulla, voit tehdä sen jäsentämällä **merkkijonon Python-objektiksi.**

```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]
```

`json.loads()` -funktio analysoi JSON-merkkijonon ja muuntaa sen vastaavaksi Python-objektiksi, tässä tapauksessa listaksi.

### `ast.literal`

`ast` (Abstract Syntax Trees) -moduulin avulla voit arvioida merkkijonon Python-tietorakenteeksi, jossa merkkijono tulkitaan Python-literaaliksi. Jos merkkijono on kelvollisessa Python-literaalimuodossa (kuten luettelo, sanakirja, numero jne.), voit muuntaa sen turvallisesti vastaavaksi Python-objektiksi käyttämällä `ast.literal_eval()`.

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

Lue lisää [merkkijonon muuntamisesta päivämäärä- ja aikamuotoon Pythonissa](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/muunna-merkkijonot-paeivaemaeaerae-ja-aikamuotoon-pythonissa/) digitaalisesta oppaastamme.


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/python-merkkijonojen-muuntaminen-listoiksi/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/python-merkkijonojen-muuntaminen-listoiksi/) for AI/LLM consumption.