Estimasi Waktu Baca: 7 menit

Pengenalan List

List adalah salah satu anggota tipe data berurut (sequence) selain string dan tuple. List juga bisa dikatakan struktur data, karena tugasnya menampung banyak data sekaligus secara terstruktur. Kemudian untuk membentuk list diperlukan tanda kurung siku dengan setiap nilai di dalamnya dipisahkan menggunakan tanda koma.

[item-1, item-2, item-3, ..... , item-n]
Python

Macam Anggota List

Anggota list dapat terdiri dari semua tipe data dan dalam satu rangkaian bisa terdiri dari tipe yang sama atau bahkan campuran dari berbagai tipe. Untuk mengetahui bagaimana list bekerja dengan data dalam berbagai tipe kita akan ulas satu-satu di bawah ini.

List Beranggotakan Tipe Data Numerik

Terdapat tiga jenis tipe data numerik yaitu integer, float, dan complex. Ketiganya dapat menjadi anggota di dalam list.

>>> # List Beranggotakan bilangan bulat (integer)  
... bulat = [1, 2, 3, 4, 5]
>>> bulat
[1, 2, 3, 4, 5]

>>> # List Beranggotakan bilangan desimal (float)
... desimal = [1.0, 2.0, 3.0, 4.0, 5.0]
>>> desimal
[1.0, 2.0, 3.0, 4.0, 5.0]

>>> # List Beranggotakan bilangan kompleks (complex)
... kompleks = [1j, 2j, 3j, 4j, 5j]
>>> kompleks
[1j, 2j, 3j, 4j, 5j]
Python

Untuk mengetahui jenis tipe data, gunakan fungsi type().

>>> type(bulat), type(desimal), type(kompleks)
(<class 'list'>, <class 'list'>, <class 'list'>)

List Beranggotakan Tipe Data String

Selain tipe data numerik string juga dapat menjadi anggota list.

>>> teks = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> teks
['Ani', 'Budi', 'Cita', 'Dika', 'Ega']
Python

List Beranggotakan Tipe Data Boolean

Begitu juga dengan boolean, meskipun hanya memiliki dua nilai True dan False, boolean masih bisa menjadi anggota list.

>>> boolean = [True, False, True, False]
>>> boolean
[True, False, True, False]
Python

List Bersarang (Nested List)

Selain tiga tipe data di atas, ternyata list juga dapat beranggotakan dirinya sendiri, ini dinamakan nested list atau list bersarang. Penerapan list bersarang ini dapat kita jumpai pada pembuatan matriks di python.

>>> list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
>>> list
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Python

List Beranggotakan Campuran Tipe Data

Banyak yang bilang bahwa list adalah array di python, karena memang pada python tidak ada tipe data array seperti bahasa pemrograman lain, tapi nyatanya baik array dan list memiliki perbedaan. Perbedaannya terletak pada aturan dari kedua jenis tipe data tersebut. Array hanya boleh menampung nilai atau data dengan tipe yang sama dalam satu rangkaian. Sedangkan list lebih fleksibel, ia diperbolehkan menampung data dengan tipe yang berbeda dalam satu rangkaian.

>>> campuran = [1, 1.0, 1j, "satu", True, [1, 1, 1]]
>>> campuran
[1, 1.0, 1j, 'satu', True, [1, 1, 1]]
Python

Mengakses Anggota List

Mengakses di sini merupakan cara kita dalam menampilkan atau mengambil atau juga mendapatkan anggota dari tipe data berurut. Ketika ingin mengakses anggota list, kita diharapkan mengerti tentang pengindeksan. Jika tidak, kita akan kebingungan.

Indeks merupakan angka yang mewakili tiap anggota tipe data berurut. Baik itu string, list, atau tuple, indeks mereka bertiga dimulai dari nol bukan satu. Kemudian ada juga istilah panjang list, hal ini merujuk pada jumlah anggota dalam list.

Kembali lagi untuk cara atau teknik dalam mengakses anggota list, terdapat tiga cara di sini antara lain:

  • Cara manual
  • Teknik Slicing
  • Menggunakan Perulangan

Selanjutnya ketiga cara ini akan kita praktekan satu-satu

Cara Manual

Cara manual di sini maksudnya, kita mengakses anggota list secara individu atau satu persatu secara manual. Untuk menerapkan cara ini, kita memerlukan nama variabel yang bersangkutan diikuti dengan tanda kurung siku. Nah, di dalam kurung siku inilah indeks setiap elemen diletakkan. Lebih jelasnya lihat rumus berikut.

>>> nama_variabel[indeks]

Untuk penerapan kodenya sebagai berikut.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[0]
'Ani'
>>> siswa[4]
'Ega'

Gunakan angka negatif untuk mendapatkan anggota list dari urutan belakang.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[-1]
'Ega'

Teknik Slicing

Kedua dengan cara atau teknik slicing. Dengan cara ini memungkinkan kita untuk mendapatkan lebih dari satu anggota secara berurut dengan rentang yang kita tentukan sendiri. Nantinya kita akan membutuhkan dua parameter berupa indeks awal yang berarti dari indeks ke berapa data tersebut didapatkan dan indeks akhir yang berarti sampai indeks ke berapa data tersebut didapatkan.

>>> nama_variabel[indeks_awal : indeks_akhir]

Lalu, dalam penerapan kodenya sama seperti cara manual, kita akan membutuhkan tanda kurung siku, yang membedakan adalah di dalam kurung siku nanti akan ada tanda titik dua yang digunakan sebagai pemisah kedua parameter (indeks awal dan akhir) tersebut atau dapat juga diartikan sebagai rentang dari indeks awal sampai indeks akhir.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[1:3]
['Budi', 'Cita']

Yang perlu diperhatikan di sini, meskipun kita tetapkan indeks akhir atau batas dalam pengambilan data adalah indeks ketiga pada kenyataannya data yang didapatkan hanya sampai indeks kedua. Jadi indeks ketiga tidak termasuk.

Selanjutnya kita juga dapat mengosongi parameter indeks awal, bila anggota yang ingin didapatkan dimulai dari indeks 0.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[:4]
['Ani', 'Budi', 'Cita', 'Dika']

Sedangkan bila parameter indeks akhir yang kosong, berarti indeks yang akan kita ambil dimulai dari indeks awal yang kita tentukan sampai indeks akhir dari list itu sendiri.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[1:]
['Budi', 'Cita', 'Dika', 'Ega']

Jika keduanya kosong? Ya tentu akan menampilkan seluruh anggota list tersebut dari indeks ke-0 sampai indeks ke-n.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[:]
['Ani', 'Budi', 'Cita', 'Dika', 'Ega']

Menggunakan Perulangan

Karena setiap anggota memiliki indeks, maka penggunaan perulangan juga bisa diandalkan di sini.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> for i in siswa:
...  print(i)
... 
Ani
Budi
Cita
Dika
Ega

List Bersifat Mutable

Mutable artinya bahwa data di dalamnya dapat diubah.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[2] = "Fani"
>>> siswa
['Ani', 'Budi', 'Fani', 'Dika', 'Ega']

Lawannya adalah immutable (tidak bisa diubah) seperti string dan tuple contohnya.

>>> # Immutable pada Tuple 
... siswa = ("Ani", "Budi", "Cita", "Dika", "Ega")
>>> siswa[2] = "Fani"
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> # Immutable pada String
... angka = "012345"
>>> angka[2] = "9"
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'str' object does not support item assignment
Python

Berbagai Fungsi Dalam List

Python menyediakan berbagai metode atau fungsi bawaan (built-in) untuk tipe data list. Fungsi-fungsi ini memungkinkan kita untuk memanipulasi atau merubah susunan dalam sebuah list. Manipulasi di sini mencakup seperti mengurutkan anggota, menambahkan, menyisipkan, menghapus, dan lain-lain.

Mengurutkan Anggota

Salah satu cara untuk mengurutkan anggota list dapat dengan menggunakan perulangan, namun pada python hal ini lebih menjadi pilihan opsional, dikarenakan pada python sudah tersedia metode atau fungsi untuk melakukan hal ini. Fungsi tersebut dinamakan sort().

>>> angka = [5, 0, 6, 1, 3, 2, 4, 9, 7, 8] 
>>> angka.sort()
>>> print(angka)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Fungsi sort() akan mengurutkan data atau nilai berdasarkan besar kecilnya nilai tersebut, bisa secara ascending (kecil ke besar) atau descending (besar ke kecil). Defaultnya ascending.

>>> angka = [5, 0, 6, 1, 3, 2, 4, 9, 7, 8]
>>> angka.sort() >>> angka [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Sedangkan jika ingin mengurutkan secara descending (besar ke kecil) maka kita perlu mengganti nilai dari parameter fungsi sort() yaitu reverse menjadi True. Parameter ini defaultnya bernilai False.

>>> angka = [5, 0, 6, 1, 3, 2, 4, 9, 7, 8]
>>> angka.sort(reverse=True)
>>> angka
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Fungsi sort() juga bisa digunakan untuk mengurutkan tipe data String.

>>> huruf = ['C', 'G', 'I', 'D', 'B', 'J', 'C', 'A', 'F', 'E', 'H']
>>> huruf.sort()
>>> huruf
['A', 'B', 'C', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
>>> huruf.sort(reverse=True)
>>> huruf
['J', 'I', 'H', 'G', 'F', 'E', 'D', 'C', 'C', 'B', 'A']

Membalik Urutan Anggota

Python juga menyediakan fungsi untuk membalik posisi atau urutan anggota dengan menggunakan fungsi reverse().

>>> angka = [5, 0, 6, 1, 3, 2, 4, 9, 7, 8]
>>> angka.reverse()
>>> angka
[8, 7, 9, 4, 2, 3, 1, 6, 0, 5]

Menambahkan Anggota

Menambahkan anggota list dapat dilakukan dengan mudah menggunakan fungsi append().

>>> angka
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> angka.append(10)
>>> angka
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Kita juga dapat menambahkan anggota dalam list dengan menggabungkan list lain menggunakan operator plus (+).

>>> angka = [1, 2, 3, 4, 5]
>>> angka2 = [6, 7, 8, 9, 10]
>>> angka3 = [11, 12, 13, 14, 15]
>>> angka + angka2 + angka3
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

Dapat dilakukan pula pada data bertipe string.

>>> huruf = ['A', 'B', 'C', 'D', 'E']
>>> huruf2 = ['F', 'G', 'H', 'I', 'J']
>>> huruf + huruf2
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']

Atau jika ingin melipat gandakan anggota list bisa dengan operator *

>>> angka
[1, 2, 3, 4, 5]
>>> angka*3
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

Pada data bertipe string

>>> huruf
['A', 'B', 'C', 'D', 'E']
>>> huruf*3
['A', 'B', 'C', 'D', 'E', 'A', 'B', 'C', 'D', 'E', 'A', 'B', 'C', 'D', 'E']

Menyisipkan Anggota

Menyisipkan anggota merupakan cara lain dalam menambahkan anggota. Menyisipkan berarti kita dapat menambahkan anggota di segala posisi, entah depan, tengah, atau belakang. Cara ini di python dapat dilakukan dengan fungsi insert(). Fungsi insert() akan menyisipkan anggota baru pada indeks yang sudah kita tentukan.

Ada dua parameter penting yang digunakan dalam fungsi insert().

>>> variabel.insert(indeks, data_baru)

Parameter pertama digunakan untuk menentukan indeks mana yang akan disisipi nilai atau data baru. Sedangkan parameter kedua merupakan datanya itu sendiri.

>>> angka = [1, 3, 5]
>>> angka.insert(2, 4)
>>> angka
[1, 3, 4, 5]
>>> angka.insert(1, 2)
>>> angka
[1, 2, 3, 4, 5]
>>> angka.insert(0, 0)
>>> angka
[0, 1, 2, 3, 4, 5]

Menghapus Anggota

Ada banyak cara untuk menghapus anggota dalam list, terhitung ada 4 cara antara lain:

Mengunakan Kata Kunci del

Cara menggunakannya dengan menerapkan cara pengaksesan manual atau bisa juga dengan teknik slicing.

>>> # Dengan cara manual 
... angka
[0, 1, 2, 3, 4, 5]
>>> del angka[0]
>>> angka
[1, 2, 3, 4, 5]

# Dengan teknik slicing
... angka
[0, 1, 2, 3, 4, 5]
... del angka[:4]
>>> angka
[4, 5]

Loh bang untuk teknik slicing bukannya data yang dihapus sampai indeks keempat ya? tapi itu kok….

Coba baca lagi materi teknik slicing di atas yah.

Menghapus Anggota List dengan Fungsi remove()

Dapat juga menggunakan fungsi remove().

>>> angka = [0, 1, 2, 3, 4, 5]
>>> angka.remove(3)
>>> angka
[0, 1, 2, 4, 5]

Menghapus Anggota List dengan Fungsi pop()

Fungsi pop() akan menghapus data sekaligus mengembalikan indeksnya, jadi sangat berguna ketika kita ingin memanfaatkan indeks dari anggota yang sudah dihapus untuk digunakan kembali.

>>> angka = [0, 1, 2, 3, 4, 5]
>>> angka.pop(2)
2
>>> angka
[0, 1, 3, 4, 5]

Menghapus Anggota List dengan Fungsi clear()

Terakhir dengan fungsi clear(). Fungsi ini akan menghapus atau membersihkan semua anggota yang ada di dalam list.

>>> angka = [0, 1, 2, 3, 4, 5]
>>> angka.clear()
>>> angka
[]