# Sådan konverteres strenge til lister i Python

I Python er lister foranderlige objekter, mens strenge er uforanderlige. Ved **at konvertere en streng til en liste** kan du ændre, tilføje eller fjerne enkelte tegn eller underafsnit af strengen.

## Hvilke forskellige måder er der at konvertere Python-strenge til lister?

Når du konverterer en streng til en liste, ændrer du datastrukturen, så den kan understøtte **listeoperationer**. Dette udvider igen de muligheder for databehandling, der er tilgængelige for dig.

Her er nogle af de mest almindelige metoder til at konvertere en streng til en liste:

### `split()`

Python-metoden split opdeler en streng i en **liste over delstrenge** baseret på en bestemt separator eller et bestemt mønster. Den generelle syntaks for denne metode er:

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

- `string`: Dette er den oprindelige streng.
- `sep` (valgfrit): Dette er det tegn, hvor strengen skal opdeles. Hvis der ikke angives noget tegn, opdeler metoden som standard strengen ved mellemrum.
- `maxsplit` (valgfrit): `maxsplit` definerer det maksimale antal opdelinger, der skal foretages. Hvis du ønsker, at Python skal foretage alle mulige opdelinger, kan du enten indstille parameteren til -1 eller lade den være tom.

Et eksempel:

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

fører til følgende output:

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

f-strenge er et Python-strengformat, der accepterer ethvert udtryk som pladsholder i krøllede parenteser. Ved hjælp af dette format kan vi kombinere resultatet af funktionen `split()` med strengen `"List of colors = "`.

### `list()`

Python-funktionen list() bruges til at konvertere forskellige datastrukturer, herunder strenge, til lister. Hvis du overfører en streng som argument til `list()`, **gemmes hvert bogstav eller tegn i strengen som et separat element** i den resulterende liste.

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

### Listeforståelse

List comprehension er en kompakt måde at oprette lister på ved at kombinere **sløjfer og betingelser** i en enkelt linje.

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

I dette eksempel starter vi med strengen `"Hello World"` og opretter en liste, der gemmes i `char_list`. List comprehension gentager hvert bogstav (`char`) i strengen `text` og tilføjer det som et enkelt element til listen `char_list`.

### Strengopdeling

String-slicing er en anden metode til at konvertere Python-strenge til lister. Den udtrækker **dele af en streng** (substrings) og gemmer dem som elementer i en liste.

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

- `start`: Dette er det indeks, hvor opdelingen begynder. Delstrengen begynder med tegnet på denne position.
- `stop`: Dette er det indeks, hvor udskæringen slutter. Sekvensen omfatter alle tegn op til, men ikke inklusive tegnet på denne position.
- `step` (valgfrit): Dette er afstanden mellem hvert valgt tegn, når opdelingen udføres. Det angiver, hvor mange tegn der skal springes over mellem hvert valgt tegn.

`convert(string)` er en **brugerdefineret funktion**, der konverterer en streng til en liste over tegn. Når udtrykket `list1[:0] = string` udføres, indsættes de enkelte tegn i strengen i den tomme liste `list1`.

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

### `re.findall()`

Du kan bruge funktionen `re.findall()` til at konvertere Python-strenge til lister ved at finde **alle forekomster af et regulært udtryk** i en streng og hente dem som en liste.

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

Det regulære udtryk `r'\d+'` søger efter et eller flere på hinanden følgende cifre i en tekst og returnerer dem som separate elementer i en liste.

### `enumerate()`

Funktionen `enumerate()` i Python henter både indekset og værdien for hvert element i en iterabel datastruktur. Hvis du ønsker, at listen kun skal indeholde værdierne (dvs. tegnene i strengen), kan du kombinere `enumerate()` med en listeforståelse:

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

### JSON

JSON er et modul, der bruges til at læse og skrive JSON-data og konvertere Python-datastrukturer til JSON-format og omvendt. Hvis du vil konvertere Python-strenge til lister ved hjælp af JSON-modulet, kan du gøre det ved at parse en **streng til et Python-objekt**.

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

Funktionen `json.loads()` analyserer JSON-strengen og konverterer den til et tilsvarende Python-objekt, i dette tilfælde en liste.

### `ast.literal`

Modulet `ast` (Abstract Syntax Trees) giver dig mulighed for at evaluere en streng til en Python-datastruktur, hvor strengen fortolkes som en Python-literal. Hvis din streng er i et gyldigt Python-literalformat (som en liste, ordbog, tal osv.), kan du sikkert konvertere den til det tilsvarende Python-objekt ved hjælp af `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]
```

Læs mere om, hvordan [konvertering af en streng til datetime fungerer i Python](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/konverter-strenge-til-datetime-i-python/), i vores digitale guide.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/konvertering-af-python-strenge-til-lister/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/konvertering-af-python-strenge-til-lister/) for AI/LLM consumption.