# List sa Python: mga method, slice, sorting, append, tuple, at set

URL: https://skillaria.top/tl/guides/python/list-python-halimbawa

Ang list sa Python ay maayos at mababagong koleksiyon ng anumang halaga sa loob ng mga square bracket, halimbawa [250, 1200, 99]: maaaring idagdag ang mga elemento gamit ang append, ipasok, tanggalin, kunin gamit ang slice, at ayusin. Inaayos ng sort ang listahan sa mismong lugar at nagbabalik ng None, samantalang ang sorted ay nagbabalik ng bagong nakaayos na listahan.

Ang list sa Python (`list`) ay maayos na koleksiyon ng anumang halaga sa loob ng mga square bracket, at maaari itong baguhin: magdagdag ng elemento sa dulo, magpasok sa gitna, magtanggal, mag-ayos. Ito ang pinakagamiting koleksiyon ng wika: mga linya ng file, mga gastos sa buong buwan, mga sagot ng API — halos lahat ay nagsisimula sa list. Tatalakayin natin ang python list nang buo: paggawa, mga method, slice, sorting, list comprehension, pagkopya, at sa dulo, tuple at set.

## Ano ang list sa Python

Iniimbak ng list ang mga elemento ayon sa pagkakasunod na itinakda mo, at naaabot ang mga ito sa pamamagitan ng index na nagsisimula sa zero. Maaaring magkakaiba ang uri ng mga halaga sa iisang list, bagaman sa praktika ay karaniwang magkakapareho ang datos.

```
amounts = [250, 1200, 99]
print(amounts[0])     # 250 — unang elemento
print(amounts[-1])    # 99 — huling elemento
amounts[1] = 1300     # nababago ang list
print(len(amounts))   # 3 — haba ng list
```

Ibinabalik ng function na `len()` ang laki ng list. Kapag tinangka mong i-access ang index na wala, makakakuha ka ng `IndexError: list index out of range`.

## Paggawa ng list

```
empty = []                       # walang laman na list
also_empty = list()              # pareho, gamit ang function na list
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]
```

Ginagawang list ng function na `list()` ang anumang iterable object: string, `range`, set, o mga key ng dictionary.

## append at iba pang method ng list

Idinadagdag ng method na `append` ang isang elemento sa dulo ng list — ito ang pinakamadalas gamiting method sa Python. Binabago nito ang list sa mismong lugar at nagbabalik ng `None`.

```
amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # tanggalin ang unang halagang 1200
last = amounts.pop()         # 20 — tanggalin at ibalik ang huli
```

Karaniwang pagkakamali: ang `a.append([10, 20])` ay nagdaragdag ng isang elemento — isang nakapaloob na list, hindi dalawang numero. Para sa maraming elemento, gamitin ang `extend`.

| Method | Ginagawa |
| --- | --- |

| `append(x)` | idagdag ang x sa dulo |

| `extend(iter)` | idagdag ang lahat ng elemento ng sunod-sunod na datos |

| `insert(i, x)` | ipasok ang x bago ang index na i |

| `remove(x)` | tanggalin ang unang pagkakataon ng x (ValueError kung wala) |

| `pop(i=-1)` | tanggalin at ibalik ang elemento sa index |

| `index(x)` | index ng unang pagkakataon |

| `count(x)` | ilang beses lumitaw ang x |

| `sort()` | ayusin sa mismong lugar |

| `reverse()` | baligtarin sa mismong lugar |

| `copy()` | shallow copy |

| `clear()` | linisin ang list |

Maaari ring magtanggal ng elemento sa index o ng buong saklaw gamit ang `del` na operator: `del a[0]`, `del a[1:3]`. Kapaki-pakinabang na built-in na function para sa list: `len`, `sum`, `min`, `max`, `sorted`, `reversed`, `enumerate`, `zip`.

## Mga slice sa Python

Kumukuha ng bahagi ng list ang slice ayon sa anyong `a[start:stop:step]`: mula sa `start` na kasama, hanggang sa `stop` na hindi kasama, na may hakbang na `step`. Maaaring alisin ang alinmang bahagi. Laging nagbabalik ng bagong list ang slice.

```
a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — unang dalawa
print(a[-2:])     # [4, 5] — huling dalawa
print(a[::2])     # [0, 2, 4] — bawat ikalawa
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — baligtad
print(a[:])       # kopya ng buong list
```

Hindi tulad ng index, hindi nagbibigay ng error ang slice na lumalampas sa list: ang `a[10:20]` ay magbabalik lang ng `[]`. Maaari ring bigyan ng halaga ang slice at palitan ang bahagi ng list: `a[1:3] = ["x", "y", "z"]`.

### Slice ng string

Pareho ang paggana ng slice sa lahat ng sunod-sunod na datos, kasama ang string at tuple:

```
s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP
```

Hindi mo mababago ang string gamit ang slice — hindi nababago ang string, at gagawa ang slice ng bagong string.

## Pag-aayos ng list: sort at sorted

Dito kadalasang nalilito ang mga baguhan. Inililipat ng method na `sort` ang mga elemento sa mismong list at nagbabalik ng `None`. Hindi ginagalaw ng function na `sorted` ang orihinal na list at nagbabalik ng bagong nakaayos na list.

```
amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — bagong kopya
print(amounts)             # [250, 1200, 99, 450] — buo pa ang orihinal

result = amounts.sort()    # inaayos sa mismong lugar
print(result, amounts)     # None [99, 250, 450, 1200]
```

Dito nanggagaling ang klasikong tanong na "bakit None ang nakukuha ko": ang `a = a.sort()` ay nagpapalit ng list sa halagang `None`. Isulat alinman sa `a.sort()` o sa `a = sorted(a)`.

### Key at pagkakasunod na pababa

Parehong tumatanggap ang dalawa ng mga parameter na `key` at `reverse`. Ang `key` ay function na ang resulta ang ginagamit sa paghahambing ng mga elemento.

```
words = ["kape", "Taksi", "abonado"]
print(sorted(words, key=len))               # ['kape', 'Taksi', 'abonado']
print(sorted(words, key=str.lower))         # hindi sensitibo sa letra
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Pagkain", 650), ("Sine", 120), ("Taksi", 300)]
expenses.sort(key=lambda e: e[1])           # ayon sa halaga
```

Stable ang sorting sa Python: nananatili ang orihinal na pagkakasunod ng mga elementong may parehong key. Iba rin ang sakop ng dalawa: tinatanggap ng `sorted` ang anumang sunod-sunod na datos (string, dictionary, set), samantalang may `sort` lang ang list.

## Baligtarin ang list

Tatlong paraan na may magkakaibang kilos:

- `a.reverse()` — binabaligtad sa mismong lugar, nagbabalik ng `None`;
- `a[::-1]` — bagong baligtad na list;
- `reversed(a)` — lazy iterator, maginhawa sa loop: `for x in reversed(a):`.

## Pagdaan sa list

```
items = ["kape", "metro", "sine"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 kape, 2 metro, 3 sine

print("sine" in items)      # True — pagsusuri kung nandoon
```

Huwag magtanggal ng elemento sa list na dinadaanan ng loop — may ilang elementong malalaktawan. Bumuo ng bagong list gamit ang comprehension, o dumaan sa kopya na `a[:]`.

## List comprehension

Bumubuo ang list comprehension ng bagong list sa isang linya: ekspresyon, loop, at opsyonal na kondisyon.

```
squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" anna ", "oscar"]]
```

Kadalasang mas mabilis at mas madaling basahin ang list comprehension kaysa sa loop na may `append`. Pero kung hindi kasya sa isang malinaw na linya ang lohika, mas mabuti ang tahasang loop.

## Pagsasama, pagdaragdag, at pagbabawas ng list

```
a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — bagong list
a += b             # katulad ng a.extend(b)
print([*a, *b])    # unpacking sa bagong list
```

Walang operator na `-` para sa pagbabawas ng list. Para alisin sa isang list ang mga elemento ng isa pa, gumamit ng comprehension: `[x for x in a if x not in set(b)]`. Mas madaling hanapin ang intersection ng mga list gamit ang set: `set(a) & set(b)` (nawawala ang pagkakasunod at mga duplicate sa prosesong ito).

## Nested at dalawang-dimensiyong list

Ang list ng mga list ay simpleng paraan para mag-imbak ng talahanayan o matrix:

```
matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # tama
bad = [[0] * 3] * 2                  # bitag: dalawang reference sa iisang list
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]
```

## Unpacking ng list

```
first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — print ng list nang walang bracket
```

Kapag hindi tugma ang bilang ng variable sa haba ng list, magkakaroon ng `ValueError` — dito nakatutulong ang asterisk.

## Pagkopya ng list

Hindi kinokopya ng `b = a` ang list; naglalagay lang ito ng pangalawang label sa iisang object: ang pagbabago sa pamamagitan ng `b` ay makikita sa `a`. Ang hiwalay na kopya ay tahasang ginagawa: `a.copy()`, `list(a)`, o `a[:]`. Para sa nested na datos, hindi sapat ito — mananatiling nakabahagi ang mga panloob na list, kaya kailangan ang `copy.deepcopy(a)`.

```
import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — nakabahagi ang nested list
c = copy.deepcopy(a)     # ganap na hiwalay na kopya
```

## Tuple: list na hindi nababago

Katulad ng list ang tuple (`tuple`), pero hindi ito mababago pagkatapos gawin. Malinaw itong senyales sa nagbabasa: isang rekord na may nakapirmeng mga field ang nasa harapan mo, hindi lumalaking koleksiyon. Madaling i-unpack ang tuple, at dito karaniwang ibinabalik ng mga function ang maraming halaga.

```
expense = (250, "Kape")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment
```

Ang tuple na may hindi nababagong halaga ay puwedeng i-hash, kaya maaari itong gamiting key ng dictionary. Ang tuple na may isang elemento ay isinusulat na may kuwit: `(5,)`.

## Set: mga natatanging halaga lang

Iniimbak ng set (`set`) ang mga natatanging halaga lang at hindi inaalala ang pagkakasunod. Ito ang pinakamabilis na paraan para alisin ang mga duplicate at tingnan kung may ganoong elemento, at kaya rin nitong gawin ang intersection, union, at difference.

```
jan = {"Pagkain", "Taksi", "Sine"}
feb = {"Pagkain", "Subscription"}
print(jan & feb)    # {'Pagkain'}
print(feb - jan)    # {'Subscription'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — walang duplicate, nananatili ang pagkakasunod
empty = set()       # {} — dictionary ito, hindi set!
```

## Aling koleksiyon ang pipiliin

| Gawain | Koleksiyon |
| --- | --- |

| Pagkakasunod at pagbabago | `list` |

| Nakapirmeng rekord | `tuple` |

| Paghahanap ayon sa key | `dict` |

| Pagiging natatangi, pagsusuri kung mayroon | `set` |

| Mga setting na hindi nababago | `frozendict` (Python 3.15) |

Isa-isang tinitingnan ng `x in list` ang mga elemento, samantalang halos agad ang `x in set`. Kung paulit-ulit kang tumitingin ng halaga sa malaking list sa loob ng loop, gawin muna itong set.

## Buod

Ang python list ay maayos at mababagong koleksiyon: idinadagdag ng `append` at `extend`, tinatanggal ng `pop` at `remove`, kinukuha ng slice na `a[start:stop:step]` ang mga bahagi, inaayos ng `sort` sa mismong lugar at nagbabalik ng `None`, at ang `sorted` ay nagbibigay ng bagong list. Gumawa ng kopya nang tahasan, kumuha ng tuple para sa nakapirmeng rekord, at set para sa mga natatanging halaga. Ang mga list, tuple, dictionary, at set ay tinalakay nang praktikal sa kursong "Python 3.15: mula baguhan hanggang propesyonal".

## FAQ

**Ano ang pagkakaiba ng list at array sa Python?**

Walang built-in na array na tulad sa ibang wika; ang list ang gumaganap nito, at maaari itong maglaman ng magkakaibang uri ng halaga. Para sa siksik na numerikong array, may module na array at ang library na NumPy.

**Paano hanapin ang index ng elemento sa list?**

Ibinabalik ng a.index(x) ang index ng unang pagkakataon, at magbibigay ito ng ValueError kung wala ang elemento. Kaya bago tawagin, suriin muna ang x in a.

**Paano tanggalin ang mga duplicate sa list nang hindi nawawala ang pagkakasunod?**

Gamitin ang list(dict.fromkeys(a)): iniimbak ng dictionary ang mga key na natatangi at ayon sa pagkakapasok. Tinatanggal din ng list(set(a)) ang duplicate, pero hindi nito pinananatili ang pagkakasunod.

**Paano pagsamahin ang list ng string sa iisang string?**

Gamit ang join method ng string: ", ".join(["a", "b", "c"]) ay nagbibigay ng "a, b, c". Dapat string lahat ng elemento; i-convert muna ang mga numero gamit ang map(str, a).

**Puwede bang maglaman ng iba't ibang uri ng halaga ang isang list?**

Oo, maaaring maglaman ang list ng numero, string, iba pang list, at iba't ibang object nang sabay. Pero karaniwang hindi ito maaaring i-sort nang walang parameter na key — magbibigay ng TypeError ang paghahambing ng numero at string.


---
Source: Skillaria.Top (https://skillaria.top)