# Kaip konvertuoti eilutes į sąrašus Python kalboje

Python kalboje sąrašai yra keičiami objektai, o eilutės yra nekintamos. **Paverčiant eilutę sąrašu**, galima keisti, pridėti arba pašalinti atskirus simbolius arba eilutės dalis.

## Kokiais būdais galima konvertuoti Python stygas į sąrašus?

Kai konvertuojate eilutę į sąrašą, pakeičiate duomenų struktūrą taip, kad ji galėtų palaikyti **sąrašo operacijas**. Tai savo ruožtu išplečia jums prieinamas duomenų tvarkymo galimybes.

Čia pateikiami keli dažniausiai naudojami būdai, kaip konvertuoti eilutę į sąrašą:

### `split()`

Python split metodas padalina eilutę į **dalinių eilutės sąrašą** pagal konkretų skyriklį arba šabloną. Bendras šio metodo sintaksas yra toks:

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

- `string`: Tai yra originalusis stygos tekstas.
- `sep` (neprivaloma): tai yra skyriklis, kuriuo eilutė turi būti padalyta. Jei skyriklis nenurodytas, metodas pagal numatytuosius nustatymus eilutę padalys pagal tarpus.
- `maxsplit` (neprivaloma): `maxsplit` apibrėžia maksimalų galimų padalijimų skaičių. Jei norite, kad Python atliktų visus galimus padalijimus, galite nustatyti parametrą -1 arba palikti jį tuščią.

Pavyzdys:

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

rezultatas:

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

f-stringai yra Python stygos formatas, kuris priima bet kokį išraišką kaip vietos laikiklį skliaustuose. Naudodami šį formatą, galime sujungti `split()` funkcijos rezultatą su stygos `"List of colors = "`.

### `list()`

Python funkcija list() naudojama įvairioms duomenų struktūroms, įskaitant eilutes, konvertuoti į sąrašus. Jei kaip argumentą `list()` perduodate eilutę, **kiekviena eilutės raidė ar simbolis išsaugomas kaip atskiras elementas** galutiniame sąraše.

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

### Sąrašo supratimas

Sąrašų supratimas yra kompaktiškas būdas kurti sąrašus, derinant **ciklus ir sąlygas** vienoje eilutėje.

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

Šiame pavyzdyje pradedame nuo eilutės `"Hello World"` ir sukuriame sąrašą, išsaugotą `char_list`. Sąrašo supratimas kartojasi per kiekvieną raidę (`char`) eilutėje `text` ir prideda ją kaip vieną elementą į sąrašą `char_list`.

### Stringų pjaustymas

String slicing yra dar vienas būdas konvertuoti Python stygas į sąrašus. Jis išskiria **stygos dalis** (substrygas) ir išsaugo jas kaip sąrašo elementus.

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

- `start`: Tai indeksas, nuo kurio prasideda skaidymas. Dalinė eilutė prasideda nuo šioje pozicijoje esančio simbolio.
- `stop`: tai indeksas, kuriame pjaustymas baigiasi. Seka apima visus simbolius iki šioje pozicijoje esančio simbolio, bet jo neįskaitant.
- `step` (neprivaloma): tai atstumas tarp kiekvieno pasirinktos simbolio, kai atliekamas pjaustymas. Jis nurodo, kiek simbolių reikia praleisti tarp kiekvieno pasirinktos simbolio.

`convert(string)` yra **vartotojo apibrėžta funkcija**, kuri konvertuoja eilutę į simbolių sąrašą. Kai išreiškimas `list1[:0] = string` yra vykdomas, atskiri eilutės simboliai yra įterpiami į tuščią sąrašą `list1`.

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

### `re.findall()`

Naudodami funkciją `re.findall()` galite konvertuoti Python eilutes į sąrašus, surandant **visus reguliariosios išraiškos modelio pasikartojimus** eilutėje ir išgaudami juos kaip sąrašą.

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

Reguliari išraiška `r'\d+'` ieško vieno ar daugiau iš eilės einančių skaitmenų tekste ir grąžina juos kaip atskirus elementus sąraše.

### `enumerate()`

Python kalbos funkcija `enumerate()` išgauna kiekvieno elemento indeksą ir vertę iteruojamoje duomenų struktūroje. Jei norite, kad sąrašas apimtų tik vertes (t. y. stygos simbolius), galite derinti `enumerate()` su sąrašo supratimu:

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

### JSON

JSON yra modulis, naudojamas JSON duomenims skaityti ir rašyti bei Python duomenų struktūroms konvertuoti į JSON formatą ir atvirkščiai. Jei norite konvertuoti Python eilutes į sąrašus naudodami JSON modulį, galite tai padaryti išskaidydami **eilutę į 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]
```

`json.loads()` funkcija analizuoja JSON eilutę ir konvertuoja ją į atitinkamą Python objektą, šiuo atveju – sąrašą.

### `ast.literal`

`ast` (abstrakčių sintaksės medžių) modulis leidžia įvertinti eilutę į Python duomenų struktūrą, kurioje eilutė interpretuojama kaip Python literatas. Jei jūsų eilutė yra tinkamo Python literato formato (pavyzdžiui, sąrašas, žodynas, skaičius ir pan.), galite ją saugiai konvertuoti į atitinkamą Python objektą naudodami `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]
```

Daugiau informacijos apie tai, [kaip Python kalboje konvertuoti eilutę į datetime,](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/konvertuoti-eilutes-i-datetime-python-kalba/) rasite mūsų skaitmeniniame vadove.


This is a markdown version of: [https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/python-stygu-konvertavimas-i-sarasus/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/python-stygu-konvertavimas-i-sarasus/) for AI/LLM consumption.