# List di Python: metode, slice, pengurutan, append, tuple dan set

URL: https://skillaria.top/id/guides/python/list-python

List di Python (list) adalah kumpulan berurutan yang bisa diubah dan ditulis dalam tanda kurung siku, misalnya [250, 1200, 99]: elemen bisa ditambahkan dengan append, disisipkan, dihapus, diambil dengan slice, dan diurutkan. Metode sort mengurutkan list di tempat dan mengembalikan None, sedangkan fungsi sorted mengembalikan list baru yang sudah terurut.

List di Python (`list`) adalah kumpulan berurutan dari nilai apa pun yang ditulis dalam tanda kurung siku dan bisa diubah: elemen bisa ditambahkan di akhir, disisipkan di tengah, dihapus, atau diurutkan. Ini kumpulan yang paling sering dipakai di Python: baris berkas, pengeluaran sebulan, jawaban API — hampir semuanya dimulai dari list. Berikut list di Python dibahas dari awal: membuat, metode, slice, pengurutan, list comprehension, menyalin, dan di akhir tuple serta set.

## Apa itu list di Python

List menyimpan elemen sesuai urutan saat Anda menuliskannya, dan elemennya diakses lewat indeks yang dimulai dari nol. Dalam satu list boleh ada nilai bertipe berbeda, meskipun dalam praktik data yang disimpan biasanya sejenis.

```
amounts = [250, 1200, 99]
print(amounts[0])     # 250 — elemen pertama
print(amounts[-1])    # 99 — elemen terakhir
amounts[1] = 1300     # list bisa diubah
print(len(amounts))   # 3 — panjang list
```

Ukuran list dikembalikan oleh fungsi `len()`. Mengakses indeks yang tidak ada akan menghasilkan `IndexError: list index out of range`.

## Membuat list

```
empty = []                       # list kosong
also_empty = list()              # sama, lewat fungsi 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]
```

Fungsi `list()` mengubah objek apa pun yang bisa diiterasi menjadi list: string, `range`, set, atau kunci dict.

## append dan metode list lainnya

Metode `append` menambahkan satu elemen di akhir list — ini metode yang paling sering dipakai di Python. Ia mengubah list di tempat dan mengembalikan `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)         # hapus nilai 1200 yang pertama
last = amounts.pop()         # 20 — hapus dan kembalikan elemen terakhir
```

Kesalahan umum: `a.append([10, 20])` menambahkan satu elemen, yaitu list bersarang, bukan dua angka. Untuk menambahkan beberapa elemen sekaligus, gunakan `extend`.

| Metode | Fungsi |
| --- | --- |

| `append(x)` | tambahkan x di akhir |

| `extend(iter)` | tambahkan semua elemen dari urutan |

| `insert(i, x)` | sisipkan x sebelum indeks i |

| `remove(x)` | hapus kemunculan x yang pertama (ValueError jika tidak ada) |

| `pop(i=-1)` | hapus dan kembalikan elemen pada indeks i |

| `index(x)` | indeks kemunculan pertama |

| `count(x)` | berapa kali x muncul |

| `sort()` | urutkan di tempat |

| `reverse()` | balik urutan di tempat |

| `copy()` | salinan dangkal |

| `clear()` | kosongkan list |

Elemen pada indeks tertentu atau rentang juga bisa dihapus dengan operator `del`: `del a[0]`, `del a[1:3]`. Fungsi bawaan yang berguna untuk list: `len`, `sum`, `min`, `max`, `sorted`, `reversed`, `enumerate`, `zip`.

## Slice di Python

Slice mengambil sebagian list dengan pola `a[start:stop:step]`: dari `start` (termasuk) sampai `stop` (tidak termasuk) dengan langkah `step`. Bagian mana pun boleh dihilangkan. Slice selalu menghasilkan list baru.

```
a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — dua elemen pertama
print(a[-2:])     # [4, 5] — dua elemen terakhir
print(a[::2])     # [0, 2, 4] — setiap elemen kedua
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — dibalik
print(a[:])       # salinan seluruh list
```

Berbeda dengan indeks, slice di luar batas tidak menimbulkan error: `a[10:20]` hanya mengembalikan `[]`. Slice juga bisa diberi nilai untuk mengganti sebagian list: `a[1:3] = ["x", "y", "z"]`.

### Slice string

Slice bekerja sama untuk semua urutan, termasuk string dan tuple:

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

String tidak bisa diubah dengan slice — string bersifat tetap, dan slice membuat string baru.

## Mengurutkan list: sort dan sorted

Di sinilah pemula paling sering bingung. Metode `sort` menata ulang elemen di dalam list itu sendiri dan mengembalikan `None`. Fungsi `sorted` tidak menyentuh list asal dan mengembalikan list baru yang sudah terurut.

```
amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — salinan baru
print(amounts)             # [250, 1200, 99, 450] — list asal utuh

result = amounts.sort()    # urutkan di tempat
print(result, amounts)     # None [99, 250, 450, 1200]
```

Dari sini muncul kesalahan klasik «kenapa hasilnya None»: `a = a.sort()` menimpa list dengan nilai `None`. Tulis salah satu saja: `a.sort()` atau `a = sorted(a)`.

### Kunci dan urutan terbalik

Kedua cara itu menerima parameter `key` dan `reverse`. `key` adalah fungsi yang hasilnya dipakai untuk membandingkan elemen.

```
words = ["kopi", "Taksi", "langganan"]
print(sorted(words, key=len))               # ['kopi', 'Taksi', 'langganan']
print(sorted(words, key=str.lower))         # tanpa memedulikan huruf besar-kecil
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Makan", 650), ("Bioskop", 120), ("Taksi", 300)]
expenses.sort(key=lambda e: e[1])           # berdasarkan jumlah
```

Pengurutan di Python bersifat stabil: elemen dengan kunci yang sama mempertahankan urutan awalnya. Perbedaan lainnya ada pada cakupan pemakaian: `sorted` menerima urutan apa pun (string, dict, set), sedangkan `sort` hanya dimiliki list.

## Membalik list

Ada tiga cara dengan perilaku berbeda:

- `a.reverse()` — membalik di tempat, mengembalikan `None`;
- `a[::-1]` — list baru yang sudah dibalik;
- `reversed(a)` — iterator malas, nyaman di dalam perulangan: `for x in reversed(a):`.

## Menelusuri list

```
items = ["kopi", "kereta", "bioskop"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 kopi, 2 kereta, 3 bioskop

print("bioskop" in items)   # True — cek keberadaan
```

Jangan menghapus elemen dari list yang sedang diulang — sebagian elemen akan terlewat. Bangun list baru dengan comprehension atau ulangi salinannya `a[:]`.

## List comprehension

List comprehension membangun list baru dalam satu baris: ekspresi, perulangan, dan kondisi opsional.

```
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 [" rina ", "budi"]]
```

List comprehension biasanya lebih cepat dan lebih mudah dibaca daripada perulangan dengan `append`. Namun jika logikanya tidak muat dalam satu baris yang jelas, perulangan biasa lebih baik.

## Menggabungkan, menjumlahkan, dan mengurangi list

```
a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — list baru
a += b             # sama seperti a.extend(b)
print([*a, *b])    # pembongkaran ke list baru
```

Tidak ada operator `-` untuk mengurangi list. Untuk membuang dari satu list elemen yang ada di list lain, gunakan comprehension: `[x for x in a if x not in set(b)]`. Irisan dua list paling mudah dicari dengan set: `set(a) & set(b)` (urutan dan duplikat ikut hilang).

## List bersarang dan dua dimensi

List di dalam list adalah cara sederhana untuk menyimpan tabel atau matriks:

```
matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # benar
bad = [[0] * 3] * 2                  # jebakan: dua referensi ke satu list
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]
```

## Pembongkaran 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 elemen list tanpa tanda kurung
```

Jika jumlah variabel tidak sama dengan panjang list, akan muncul `ValueError` — tanda bintang bisa menyelamatkan situasi ini.

## Menyalin list

`b = a` tidak menyalin list; ia hanya memberi label kedua pada objek yang sama, sehingga perubahan lewat `b` terlihat di `a`. Salinan yang independen dibuat secara eksplisit: `a.copy()`, `list(a)`, atau `a[:]`. Untuk data bersarang ini belum cukup — list di dalamnya tetap dipakai bersama, jadi perlu `copy.deepcopy(a)`.

```
import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — list bersarang masih dipakai bersama
c = copy.deepcopy(a)     # salinan yang sepenuhnya independen
```

## Tuple: list yang tidak bisa diubah

Tuple (`tuple`) mirip list, tetapi setelah dibuat tidak bisa diubah. Ini sinyal jelas bagi pembaca kode: di sini ada satu catatan dengan bidang tetap, bukan kumpulan yang terus bertambah. Tuple mudah dibongkar, dan fungsi sering memakainya untuk mengembalikan beberapa nilai sekaligus.

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

Tuple yang berisi nilai tidak bisa diubah bisa di-hash, sehingga boleh dipakai sebagai kunci dict. Tuple dengan satu elemen ditulis dengan koma: `(5,)`.

## Set: hanya nilai unik

Set (`set`) hanya menyimpan nilai unik dan tidak menjaga urutan. Ini cara tercepat menghapus duplikat dan mengecek «apakah elemen ini ada», dan set juga bisa irisan, gabungan, serta selisih.

```
jan = {"Makan", "Taksi", "Bioskop"}
feb = {"Makan", "Langganan"}
print(jan & feb)    # {'Makan'}
print(feb - jan)    # {'Langganan'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — tanpa duplikat, urutan terjaga
empty = set()       # {} di sini akan menjadi dict kosong!
```

## Memilih koleksi yang tepat

| Tugas | Koleksi |
| --- | --- |

| Urutan dan perubahan | `list` |

| Catatan dengan bidang tetap | `tuple` |

| Pencarian berdasarkan kunci | `dict` |

| Keunikan, cek «apakah ada» | `set` |

| Pengaturan yang tidak boleh diubah | `frozendict` (Python 3.15) |

Pengecekan `x in list` menelusuri elemen satu per satu, sedangkan `x in set` hampir seketika. Jika di dalam perulangan Anda berkali-kali mengecek keberadaan sesuatu di list yang besar, ubahlah list itu menjadi set.

## Ringkasan

List di Python adalah kumpulan berurutan yang bisa diubah: `append` dan `extend` menambah elemen, `pop` dan `remove` menghapus, slice `a[start:stop:step]` mengambil bagian, `sort` mengurutkan di tempat dan mengembalikan `None`, sedangkan `sorted` memberi list baru. Salin secara eksplisit, untuk catatan dengan bidang tetap pakai tuple, dan untuk nilai unik pakai set. List, tuple, dict dan set dipraktikkan dengan contoh pada kursus Python.

## FAQ

**Apa bedanya list dan array di Python?**

Array dalam arti bahasa lain tidak ada sebagai tipe bawaan; perannya diambil oleh list, yang bisa menyimpan nilai bertipe campuran. Untuk array angka yang padat tersedia modul array dan pustaka NumPy.

**Bagaimana mencari indeks elemen di dalam list?**

Metode a.index(x) mengembalikan indeks kemunculan pertama dan melempar ValueError jika elemen tidak ada. Karena itu, periksa dulu dengan x in a.

**Bagaimana menghapus duplikat dari list sambil menjaga urutan?**

Gunakan list(dict.fromkeys(a)): dict menyimpan kunci secara unik dan sesuai urutan penyisipan. list(set(a)) juga menghapus duplikat, tetapi urutannya tidak terjaga.

**Bagaimana menggabungkan list string menjadi satu string?**

Dengan metode join pada string: ", ".join(["a", "b", "c"]) menghasilkan "a, b, c". Semua elemen harus berupa string; angka diubah dulu dengan map(str, a).

**Bolehkah list berisi tipe data yang berbeda?**

Boleh: list bisa berisi angka, string, list lain, dan objek apa pun sekaligus. Namun mengurutkan list seperti itu tanpa parameter key biasanya tidak bisa, karena membandingkan angka dengan string menghasilkan TypeError.


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