# Hvordan konvertere strenger til lister i Python

I Python er lister foranderlige objekter, mens strenger er uforanderlige. Ved **å konvertere en streng til en liste** kan du endre, legge til eller fjerne enkelttegn eller deler av strengen.

## Hvilke forskjellige måter finnes det for å konvertere Python-strenger til lister?

Når du konverterer en streng til en liste, endrer du datastrukturen slik at den kan støtte **listeoperasjoner**. Dette utvider igjen utvalget av datamanipuleringsalternativer som er tilgjengelige for deg.

Her er noen av de vanligste metodene for å konvertere en streng til en liste:

### `split()`

Python -metoden split deler en streng opp i en **liste med delstrenger** basert på et bestemt skilletegn eller mønster. Den generelle syntaksen for denne metoden er:

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

- `string`: Dette er den opprinnelige strengen.
- `sep` (valgfritt): Dette er skilletegnet der strengen skal deles. Hvis det ikke angis noe skilletegn, deler metoden strengen ved standard på tomme mellomrom.
- `maxsplit` (valgfritt): `maxsplit` definerer maksimalt antall delinger som skal gjøres. Hvis du vil at Python skal utføre alle mulige delinger, kan du enten sette parameteren til -1 eller la den være tom.

Et eksempel:

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

fører til følgende utdata:

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

f-strenger er et Python-strengformat som aksepterer alle uttrykk som plassholdere i krøllparenteser. Ved å bruke dette formatet kan vi kombinere resultatet av funksjonen `split()` med strengen `"List of colors = "`.

### `list()`

Python-funksjonen list() brukes til å konvertere ulike datastrukturer, inkludert strenger, til lister. Hvis du sender en streng som argument til `list()`, **lagres hver bokstav eller hvert tegn i strengen som et eget element** i den resulterende listen.

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

### Listeforståelse

Listeforståelse er en kompakt måte å lage lister på ved å kombinere **løkker 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 eksemplet starter vi med strengen `"Hello World"` og oppretter en liste som lagres i `char_list`. Listeforståelsen gjentar hver bokstav (`char`) i strengen `text` og legger den til som et enkelt element i listen `char_list`.

### Strengskjæring

Strengskjæring er en annen metode for å konvertere Python-strenger til lister. Den trekker ut **deler av en streng** (delstrenger) og lagrer dem som elementer i en liste.

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

- `start`: Dette er indeksen der oppdelingen begynner. Delstrengen begynner med tegnet på denne posisjonen.
- `stop`: Dette er indeksen der oppdelingen slutter. Sekvensen inkluderer alle tegn opp til, men ikke inkludert tegnet på denne posisjonen.
- `step` (valgfritt): Dette er avstanden mellom hvert valgt tegn når oppdelingen utføres. Det angir hvor mange tegn som skal hoppes over mellom hvert valgt tegn.

`convert(string)` er en **brukerdefinert funksjon** som konverterer en streng til en liste med tegn. Når uttrykket `list1[:0] = string` utføres, blir de enkelte tegnene i strengen satt inn i den tomme listen `list1`.

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

### `re.findall()`

Du kan bruke funksjonen `re.findall()` til å konvertere Python-strenger til lister ved å finne **alle forekomster av et regulært uttrykk** 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 uttrykket `r'\d+'` søker etter ett eller flere påfølgende tall i en tekst og returnerer dem som separate elementer i en liste.

### `enumerate()`

Funksjonen `enumerate()` i Python henter både indeksen og verdien til hvert element i en iterabel datastruktur. Hvis du vil at listen bare skal inneholde verdiene (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 som brukes til å lese og skrive JSON-data og konvertere Python-datastrukturer til JSON-format og omvendt. Hvis du vil konvertere Python-strenger til lister ved hjelp av JSON-modulen, kan du gjøre dette ved å analysere 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]
```

Funksjonen `json.loads()` analyserer JSON-strengen og konverterer den til et tilsvarende Python-objekt, i dette tilfellet en liste.

### `ast.literal`

Modulen `ast` (Abstract Syntax Trees) lar deg evaluere en streng til en Python-datastruktur, hvor strengen tolkes som en Python-litteral. Hvis strengen din er i et gyldig Python-litteralformat (som en liste, ordbok, tall osv.), kan du trygt konvertere den til det tilsvarende Python-objektet ved hjelp av `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]
```

Finn ut mer om hvordan [konvertering av en streng til dato og klokkeslett fungerer i Python](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/konverter-strenger-til-dato-og-klokkeslett-i-python/) i vår digitale guide.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/konvertere-python-strenger-til-lister/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/konvertere-python-strenger-til-lister/) for AI/LLM consumption.