List

List adalah struktur data terurut yang bersifat mutable, yakni isinya dapat berubah setelah dibuat, dan menjadi struktur data yang paling sering digunakan pada program Python sehari-hari. Satu list dapat menampung sejumlah nilai dalam satu variabel, mulai dari daftar belanja sampai kumpulan hasil pengukuran. Topik ini membahas operasi CRUD (create, read, update, delete) pada list, metode bawaan seperti append(), insert(), remove(), pop(), dan sort(), serta perilaku ukurannya yang dinamis. Setiap contoh disertai keluaran asli sehingga perubahan isinya dapat diikuti baris demi baris.

Membuat dan membaca list#

Cara paling umum membuat list adalah menulis elemen-elemen di dalam tanda kurung siku yang dipisahkan tanda koma. Elemen boleh bertipe berbeda pada satu list yang sama, meskipun dalam praktik satu list biasanya diisi tipe yang seragam. Setiap elemen memiliki nomor posisi yang disebut indeks (index) dan dihitung mulai dari 0, sehingga elemen pertama berada pada indeks 0. Indeks negatif dihitung dari akhir, dengan -1 menunjuk elemen terakhir. Fungsi len() mengembalikan jumlah elemen pada list.

Perhatikan contoh berikut beserta keluarannya.

buah = ["mangga", "jeruk", "pisang"]
print(buah[0])
print(buah[-1])
print(len(buah))
campur = ["apel", 3, 12.5, True]
print(campur)

mangga
pisang
3
['apel', 3, 12.5, True]

Pembacaan indeks yang melebihi jumlah elemen tidak mengembalikan nilai kosong, melainkan menimbulkan error IndexError. Contoh berikut menangkap error tersebut dengan try dan except agar program tidak berhenti.

buah = ["mangga", "jeruk", "pisang"]
try:
    print(buah[5])
except IndexError as e:
    print(type(e).__name__, str(e))

IndexError list index out of range

Pola type(e).__name__ dan str(e) digunakan di sepanjang topik ini untuk menampilkan jenis error dan pesannya secara ringkas tanpa traceback penuh. Bagian pertama mengambil nama kelas error, sedangkan bagian kedua mengambil teks pesannya.

Selain literal, list dapat dibangun dari urutan lain menggunakan fungsi list(), misalnya list("abc") yang menghasilkan ['a', 'b', 'c']. Elemen sebuah list juga boleh berupa list lain, sehingga struktur bersarang seperti tabel dua dimensi dapat dibentuk. Pembacaan elemen bersarang dilakukan berlapis, misalnya data[0][1] menunjuk elemen kedua dari baris pertama. Perilaku penyalinan struktur bersarang memiliki aturan tersendiri yang dibahas pada topik slicing dan salinan.

Menambah dan mengubah elemen#

List menyediakan tiga metode penambahan yang berbeda perilakunya. Metode append() menambahkan satu elemen di akhir list, metode insert() menyisipkan satu elemen pada indeks tertentu sambil menggeser elemen setelahnya, dan metode extend() menggabungkan isi list lain ke bagian akhir. Perubahan satu elemen dilakukan dengan penugasan berindeks, misalnya belanja[0] = "beras merah", dan menjadi bentuk paling sederhana dari operasi update. Ketiganya bekerja pada list yang sama tanpa membuat list baru.

belanja = ["beras", "telur"]
belanja.append("gula")            # menambah di akhir
belanja.insert(1, "minyak")       # menyisipkan pada indeks 1
belanja.extend(["susu", "kopi"])  # menggabungkan beberapa nilai
print(belanja)
belanja[0] = "beras merah"        # mengubah satu elemen
print(belanja)

['beras', 'minyak', 'telur', 'gula', 'susu', 'kopi']
['beras merah', 'minyak', 'telur', 'gula', 'susu', 'kopi']

Keluaran di atas memperlihatkan urutan perubahannya. Nilai gula masuk ke akhir, lalu minyak disisipkan pada indeks 1 sehingga telur bergeser dari indeks 1 ke indeks 2. Pemilihan metode bergantung pada posisi yang diinginkan, karena menyisipkan di awal list membuat semua elemen setelahnya bergeser satu langkah. Penugasan berindeks mengganti isi tanpa mengubah jumlah elemen, sedangkan ketiga metode tadi selalu menambah jumlah elemen.

Menghapus elemen#

Empat mekanisme penghapusan tersedia dan masing-masing memilih elemen dengan kriteria berbeda. Metode remove() menghapus kemunculan pertama berdasarkan nilai dan menimbulkan error ValueError bila nilai itu tidak ada. Metode pop() menghapus berdasarkan indeks dan mengembalikan nilai yang dihapus, sedangkan pemanggilan tanpa indeks menghapus elemen terakhir. Pernyataan del menghapus berdasarkan indeks tanpa mengembalikan nilai, sedangkan metode clear() mengosongkan seluruh list.

angka = [10, 20, 30, 20, 40]
angka.remove(20)          # menghapus nilai 20 yang pertama
print(angka)
terakhir = angka.pop()    # menghapus dan mengambil elemen terakhir
print(terakhir)
pertama = angka.pop(0)    # menghapus dan mengambil elemen indeks 0
print(pertama)
print(angka)
del angka[0]              # menghapus tanpa mengembalikan nilai
print(angka)
angka.clear()             # mengosongkan list
print(angka)

[10, 30, 20, 40]
40
10
[30, 20]
[20]
[]

Urutan keluaran mengikuti urutan perintahnya. Nilai 20 yang pertama dihapus, metode pop() mengembalikan 40, metode pop(0) mengembalikan 10, dan pernyataan del menyisakan [20] sebelum metode clear() mengosongkan list. remove() dan pop() sering tertukar, sebab remove() menerima nilai, sedangkan pop() menerima indeks. Akibatnya, angka.remove(0) mencari nilai 0 dan bukan menghapus elemen pertama.

Mengurutkan dan menghitung#

Metode sort() mengurutkan list pada tempatnya secara menaik, dengan argumen reverse=True untuk urutan menurun. Metode count() menghitung kemunculan sebuah nilai, metode index() mencari indeks kemunculan pertama, dan operator in menguji keanggotaan tanpa menimbulkan error. Fungsi sorted() berperilaku serupa dengan sort(), tetapi mengembalikan list baru dan membiarkan list aslinya tak tersentuh.

nilai = [78, 92, 65, 88, 92]
nilai.sort()
print(nilai)
nilai.sort(reverse=True)
print(nilai)
print(nilai.count(92))
print(nilai.index(88))
salinan_urut = sorted(nilai)   # list baru, aslinya tidak berubah
print(salinan_urut)
print(nilai)
print(65 in nilai)

[65, 78, 88, 92, 92]
[92, 92, 88, 78, 65]
2
2
[65, 78, 88, 92, 92]
[92, 92, 88, 78, 65]
True

Dua pemanggilan sort() mengubah list nilai dua kali, sedangkan sorted(nilai) hanya menyalin isinya ke list baru bernama salinan_urut. Baris terakhir keluaran membuktikan bahwa nilai masih dalam keadaan menurun setelah sorted() dipanggil, sehingga kedua pendekatan pengurutan benar-benar berbeda sifatnya.

Ukuran yang dinamis#

List tumbuh dan menyusut secara otomatis tanpa deklarasi ukuran. Saat append() dipanggil dan kapasitas internal habis, Python mengalokasikan ruang yang lebih besar dari kebutuhan saat itu, sehingga pemanggilan berikutnya tidak perlu menyalin ulang seluruh isi. Strategi yang disebut over-allocation ini menjadikan append() memiliki kompleksitas rata-rata $O(1)$, yaitu biaya yang tetap tanpa memandang panjang list. Sebaliknya, insert() dan remove() menggeser elemen-elemen di sebelahnya, sehingga kompleksitasnya $O(n)$, dan biayanya naik sebanding dengan panjang list. Pada list berisi ribuan nilai, penghapusan di awal jauh lebih mahal daripada di akhir.

Perilaku tumbuh otomatisnya dapat diamati pada contoh pendek berikut.

data = []
for i in range(5):
    data.append(i * 10)
print(data)
print(len(data))

[0, 10, 20, 30, 40]
5

List data dibuat kosong, lalu lima kali pemanggilan append() mengisinya tanpa perlu mengetahui ukuran akhirnya. Fungsi len() selalu mengembalikan jumlah elemen yang nyata, bukan kapasitas internal yang dialokasikan.

Pemahaman ini berdampak langsung pada pilihan kode sehari-hari. Menambahkan elemen di akhir hampir selalu aman dilakukan tanpa pertimbangan ukuran, sedangkan menyisipkan di awal pada list panjang patut diganti dengan pola lain, misalnya menyusun ulang list di akhir proses. Fungsi len() sendiri tidak menelusuri isi, sehingga pemanggilannya tetap cepat berapa pun panjang listnya.

Kesalahan umum#

Kesalahan pertama yang sering muncul adalah menyangka sort() mengembalikan list yang sudah terurut. Metode ini sebenarnya mengembalikan None, sehingga hasil penugasannya tidak berisi list terurut.

nilai = [78, 92, 65]
hasil = nilai.sort()
print(hasil)

None

List nilai sendiri sebenarnya sudah terurut setelah baris kedua dijalankan, tetapi variabel hasil tidak memuat data apa pun. Perbaikannya adalah memanggil nilai.sort() tanpa penugasan, atau menuliskan hasil = sorted(nilai) bila list aslinya perlu dipertahankan. Kesalahan serupa berlaku pada reverse() dan clear(), karena keduanya juga mengembalikan None.

Kesalahan kedua adalah menghapus elemen saat perulangan for sedang menelusuri list yang sama. Penghapusan menggeser elemen di belakangnya, sedangkan posisi perulangan terus maju, sehingga sebagian elemen terlewati.

angka = [1, 2, 2, 3, 2]
for a in angka:
    if a == 2:
        angka.remove(a)
print(angka)

[1, 3, 2]

Keluaran [1, 3, 2] menunjukkan angka 2 masih tersisa padahal setiap posisi telah dikunjungi. Pola yang aman adalah membangun list baru berisi elemen yang ingin dipertahankan, misalnya [a for a in angka if a != 2], atau menelusuri salinan list tersebut sambil mengubah aslinya.

Ringkasan#

• List menyimpan elemen secara terurut dan bersifat mutable, dengan operasi CRUD melalui indeks serta metode append(), insert(), extend(), remove(), pop(), pernyataan del, dan clear().
• sort() dan reverse() mengubah list pada tempatnya dan mengembalikan None, sedangkan sorted() mengembalikan list baru tanpa menyentuh aslinya.
• Ukuran list bersifat dinamis, append() berjalan rata-rata konstan, sedangkan insert() dan remove() memaksa elemen bergeser sehingga lebih mahal pada list panjang.

Referensi#

• Data Structures — Python Software Foundation — Tutorial resmi yang membahas list beserta metode penambahan, penghapusan, dan pengurutannya.
• Built-in Types — Python Software Foundation — Referensi tipe bawaan yang merinci perilaku setiap metode list yang mutable.