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

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.

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

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.