# Tips Menggunakan Array [List] dalam Python

*Bismillaah Alhamdulillaah*.

**_List_** merupakan tipe bawaan (_built-in_) dalam bahasa pemrograman Python yang dapat digunakan untuk menampung lebih dari satu buah data dengan tipe yang berbeda-beda. Data dalam _list_ memiliki nomor urut (indeks) dari 0 dan seterusnya hingga sebanyak jumlah data seluruhnya dalam _list_ tersebut.

Struktur data berupa rangkaian data atau larik (_array_) yang mirip dengan list adalah _tuple_. Kalau _list_ isinya dapat diubah, sedangkan data dalam _tuple_ tidak dapat diubah (_immutable_).

Panduan penggunaan tipe data _list_ dapat ditelusuri di website [_Python_](https://docs.python.org/3/tutorial/datastructures.html). Dalam artikel ini saya akan berbagi beberapa tips dan trik penggunaan _list_ yang dapat membantu mempercepat atau memudahkan dalam pemrosesan data lebih lanjut. Penggunaan dasar terkait _list_ lebih lengkap dapat dicek di website lain yang akan saya cantumkan di bagian bawah artikel.

### 1\. Membuat sebuah teks (_string_) dari isi _list_.

Isi _list_ digabung menggunakan fungsi _join string_, dimana _separator_ (pemisah) antar nilai adalah menggunakan _spasi_.
```python
daftar = ['aku', 'cinta', 'indonesia']  
teks = " ".join(daftar)  
print(teks)

#output: "aku cinta indonesia"
```
### 2\. Pemeriksaan _list_ kosong atau tidak.

Untuk memeriksa sebuah _list_ ada isinya atau tidak, biasanya dilakukan dengan cara memeriksa jumlah data dalam _list_.

```len(daftar) == 0```

Pernyataan di atas mengeluarkan nilai _True_, jika panjang atau jumlah data dalam _list daftar_ kosong (atau tidak ada isinya). Sebaliknya, bernilai _False_ jika ada isinya (minimal satu buah data).

Dalam python, sebuah *list* yang ada isinya, akan mengeluarkan nilai *True* jika dilakukan pembandingan dalam sebuah kondisi.
```
# jika ingin memeriksa apakah list daftar ada isinya  
if daftar:  
   ...

# jika ingin memeriksa apakah list daftar tidak ada isinya  
if not daftar:  
   ...
```
Contoh penggunaannya adalah sebagai berikut.
```python
keranjang1 = ["jeruk", "anggur", "manggis"]  
keranjang2 = []

if keranjang1:   
    print("Keranjang 1 ada isinya")  
else:  
    print("Keranjang 1 kosong")

if not keranjang2:   
    print("Keranjang 2 kosong")  
else:  
    print("Keranjang 2 ada isinya")

# output:  
# Keranjang 1 ada isinya  
# Keranjang 2 kosong
```
### 3\. Menggabung isi _list_

Ada dua konsep dalam menggabung isi list, yaitu (1) menggabung dengan model ditumpuk,

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1636796972403/-MuqrI1Xn.png)
```python
listBenda = ["Daun", "Rambut", "Langit"]  
listWarna = ["Hijau", "Hitam", "Biru"]

listGabungan = listBenda + listWarna

print(listGabungan)  
#output = ['Daun', 'Rambut', 'Langit', 'Hijau', 'Hitam', 'Biru']
```
dan cara (2) adalah dengan menggabungkan setiap data di _list_ A dan B secara berdampingan (per item).

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1636796974034/5ZoqbRuCl.png)

Sebelum menerapkan cara kedua, yang perlu diketahui adalah terdapat fungsi bawaan bernama **_zip_** yang dapat digunakan untuk menggabung dua _list_ secara berdampingan (per item), hanya saja bentuknya bukan _list_ murni, melainkan _object_.
```python
# hasil gabungan berupa _object_  
listGabungan2 = zip(listBenda, listWarna)

# cara akses  
for benda, warna in listGabungan2:  
    print(benda,warna)

# output:  
# Daun Hijau  
# Rambut Hitam  
# Langit Biru
```
Atau dengan mengkonversi _object_ tersebut ke bentuk _list_.
```python
listGabungan3 = list(zip(listBenda, listWarna))  
print(listGabungan3)

# output: [('Daun', 'Hijau'), ('Rambut', 'Hitam'), ('Langit', 'Biru')]
```
Biasanya untuk penggabungan model seperti ini lebih sesuai dikonversi ke bentuk kamus (_dictionary_).
```python
kamus = dict(zip(listBenda, listWarna))  
print(kamus)

# output: {'Daun': 'Hijau', 'Rambut': 'Hitam', 'Langit': 'Biru'}
```
Adapun kalau ingin dibentuk dalam format list seperti biasanya, dapat memanfaatkan _list extend_. Fungsi _list.extend_ ini digunakan untuk menambah (atau menggabung) isi _list_ dari _list_ lain.
```python
listGabungan4 = []  
for benda, warna in zip(listBenda, listWarna):  
    listGabungan4.extend((benda, warna))  
      
print(listGabungan4)

# output: ['Daun', 'Hijau', 'Rambut', 'Hitam', 'Langit', 'Biru']
```
### 4\. Mengembalikan nomor indeks dari nilai yang dicari dalam _list_

Dalam contoh ini kita ingin mencari sebuah nilai dalam sebuah _list_, serta ingin mengetahui posisi indeks dari nilai tersebut jika memang ditemukan. Untuk mengembalikan nilai indeks dari suatu nilai dalam _list_ sebenarnya sudah ada fungsinya, yaitu _list index_. Fungsi ini akan mengembalikan pesan kesalahan **_ValueError_** jika nilai yang dicari tidak ditemukan.
```python
angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]  
angkaCari = 2

print(angkaAcak.index(angkaCari)) # output = 0  
print(angkaAcak.index(10)) # output = ValueError: 10 is not in list

# mencari angka 2 mulai dari indeks ke-1  
print(angkaAcak.index(angkaCari,1)) # output = 6

# mencari angka 2 mulai dari indeks ke-7  
print(angkaAcak.index(angkaCari,7)) # output = 10
```
Solusi alternatif untuk menghindari **_ValueError_** adalah dengan melakukan pencarian secara manual melalui perulangan.
```python
for idx,angka in enumerate(angkaAcak):  
    if angka == angkaCari:  
        print(idx)

# output:   
# 0   
# 6   
# 10
```
Adapun solusi yang lebih pendek, dimana sering disebut dengan istilah **_list comprehension_** adalah sebagai berikut.
```python
lstCari = [idx for idx,angka in enumerate(angkaAcak) if angka == angkaCari]  
print(lstCari)

# output: [0, 6, 10]
```
### 5. Menghitung jumlah kemunculan dari suatu nilai

Untuk menghitung kemunculan sebuah nilai dalam sebuah _list_ yang paling sederhana adalah dengan menggunakan fungsi **_list count_**.
```python
angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]  
angkaCari = 2

jml = angkaAcak.count(angkaCari)  
print(f"Angka {angkaCari} ditemukan sejumlah {jml} kali")

# output: Angka 2 ditemukan sejumlah 3 kali
```
Bagaimana jika pencarian nilai berdasarkan kondisi tertentu? Misal mencari nilai ganjil atau menghitung kemunculan angka ganjil. Caranya dapat menggunakan kombinasi _list comprehension_ pada tips 4 sebelumnya.
```python
angkaGanjil = [angka for angka in angkaAcak if angka % 2 == 1]  
print(angkaGanjil) # output: [3, 5, 7, 9, 7]  
print(f"Jumlah: {len(angkaGanjil)}") # output: "Jumlah: 5"
```
### 6\. Menampilkan data secara unik

Dalam sebuah _list_ dapat saja ditemukan sebuah nilai yang muncul lebih dari satu kali atau nilai kembar. Kadang-kadang kita membutuhkan nilai yang benar-benar unik, yaitu dengan cara mengeliminasi data kembarannya tersebut. Salah satu solusinya adalah dengan mengkonversi data _list_ ke data **_set_**. Tipe data **_set_** hanya menerima sekumpulan nilai yang bersifat unik, sehingga jika ada yang kembar akan otomatis dihilangkan.
```python
angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]  
angkaUnik = set(angkaAcak)

# luaran berupa tipe data set 
print(angkaUnik) # output: {2, 3, 4, 5, 6, 7, 9}

# luaran hasil konversi tipe data set ke list
print(list(angkaUnik)) # output: [2, 3, 4, 5, 6, 7, 9]
```
### 7\. Menampilkan isi _list_ yang ada pada _list_ lain

Kadang kita ingin mengetahui apakah ada isi dari sebuah _list_ yang juga terdapat pada isi _list_ lainnya atau istilahnya beririsan. Dalam hal ini kita manfaatkan lagi **_list comprehension_** dengan cara membandingkan isi dari masing-masing (kedua _list_) dalam sebuah perulangan.
```python
barang1 = ['buku', 'pensil', 'penggaris']  
barang2 = ['penghapus', 'kertas', 'buku']

barangSama = [b for b in barang1 for b2 in barang2 if b==b2]  
print(barangSama) #output: ['buku']
```
### 8\. Menampilkan isi dari dua _list_ yang tidak beririsan

Tips ini kebalikan dari tips no. 7 sebelumnya. Yaitu menemukan data dalam kedua list yang tidak saling beririsan. Solusinya adalah dengan memanfaatkan fungsi **_symmetric difference_** pada tipe data _set_, yang berfungsi untuk mencari perbedaan nilai dari dua _set_ yang dibandingkan.
```python
barang1 = ['buku', 'pensil', 'penggaris']  
barang2 = ['penghapus', 'kertas', 'buku']

set_barang1 = set(barang1)  
set_barang2 = set(barang2)

listBarang = list(set_barang1.symmetric_difference(set_barang2))  
print(listBarang) 

# output: ['kertas', 'penghapus', 'penggaris', 'pensil']
```
### 9\. Mengurutkan data

Pengurutan data dapat dilakukan secara _ascending_ maupun _descending_. Fungsi bawaan yang tersedia adalah **_sorted_**.
```python
angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]

dataUrutAsc = sorted(angkaAcak)  
dataUrutDesc = sorted(angkaAcak,reverse=True)

print(dataUrutAsc) # output: [2, 2, 2, 3, 4, 4, 5, 6, 7, 7, 9]  
print(dataUrutDesc) # output: [9, 7, 7, 6, 5, 4, 4, 3, 2, 2, 2]  
print(angkaAcak) # output: [2, 3, 4, 6, 4, 5, 2, 7, 9, 7, 2]
```
Perhatikan bahwa fungsi _sorted_ tidak memodifikasi isi dari _list_ yang diurutkan, sehingga isi _list angkaAcak_ tidak berubah. Jika ingin sekaligus mengubah isi _list_ yang dituju, maka dapat menggunakan fungsi **_list sort_**.
```python
angkaAcak.sort()  
print(angkaAcak) # output: [2, 2, 2, 3, 4, 4, 5, 6, 7, 7, 9]
```
Sekedar mengingatkan, konversi data _list_ ke tipe data _set_ selain berguna untuk mengeliminasi data kembar juga secara otomatis mengurutkan data di dalamnya.
```python
angkaAcakDua = [2,3,4,6,4,5,2,7,9,7,2]  
dataUrutUnik = list(set(angkaAcakDua))  
print(dataUrutUnik) # output: [2, 3, 4, 5, 6, 7, 9]
```
### 10\. Membongkar elemen _list_ dengan **\***

Dalam tips ke-1 di atas, data _list_ yang bisa diubah ke bentuk gabungan dalam sebuah _string_ adalah isi _list_ yang juga berupa _string_. Jika isi list berupa bilangan, misalnya _integer_, akan menyebabkan kesalahan.
```python
angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]

strAngka = " ".join(angkaAcak)  
print(angkaAcak)

# TypeError: sequence item 0: expected str instance, int found
```
Solusinya adalah dengan menempatkan karakter **\*** yang diletakkan sebelum _list_, yang digunakan untuk membongkar elemen _list_.
```python
print(angkaAcak) # output: "2 3 4 6 4 5 2 7 9 7 2"

print(set(angkaAcak)) # output: "2 3 4 5 6 7 9"
```
Kegunaan lain tanda **\*** dalam sebuah _variable_ adalah menampung data list “_sisa_” atau dikenal dengan istilah **_partial assignments_**.
```python
buah = ['jeruk', 'mangga', 'nanas', 'apel', 'manggis']  
print(buah)  
# output: "jeruk mangga nanas apel manggis"

b_satu, *b_sisa = buah

print(b_satu) # output: "jeruk"  
print(b_sisa) # output: ['mangga', 'nanas', 'apel', 'manggis']
```
Perhatikan bahwa pada dasarnya, jika ditemukan tanda \* sebelum nama _variable_, itu bermakna mengambil semua isi data _list_. Contoh pada _variable_ \***b_sisa**, karena didahului dengan _variable_ **b_satu**, maka **b_satu** hanya dialokasikan isi _list_ pada indeks nol, dan sisa isi _list_ dialokasikan pada _variable_ **b_sisa**. Kita coba eksperimen lain sebagai berikut.
```python
b_satu, *b_tengah, b_akhir = buah

print(b_satu) # output: "jeruk"  
print(b_tengah) # output: ['mangga', 'nanas', 'apel']  
print(b_akhir) # output: "manggis"
```
*Variable* **b_satu** dan **b_akhir** mendapat alokasi isi _list_ pertama dan terakhir (satu buah nilai), sisanya diberikan pada **b_tengah**.

**11\. Mengiris (_slicing_) data**

_Slicing_ merupakan fitur bawaan untuk mengambil isi dalam _list_ sesuai nomor indeks dan jumlah data yang telah ditentukan.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1636796975450/fxpm3jOnd.png)

Berikut ini contoh _slicing_ data dalam berbagai cara.
```python
data = ['budi', 20, 'andi', 21, 'indah', 19, 'arman', 21]

# mengambil data pada indeks ke-0 (atau pertama)  
print(data[0]) # output: budi

# indeks terakhir disimbolkan dengan angka "-1"  
print(data[-1]) # output: 21

# mengambil data pertama hingga sebelum indeks ke-2  
print(data[:2]) # output: ['budi', 20]

# mengambil data pada indeks -2 hingga terakhir  
print(data[-2:]) # output: ['arman', 21]

# mengambil data dari indeks ke-0 hingga akhir dengan 2 langkah  
# indeks: 0, 2, 4, 6  
print(data[::2]) # output: ['budi', 'andi', 'indah', 'arman']

# mengambil data dari indeks ke-1 hingga akhir dengan 2 langkah  
# indeks: 1, 3, 5, 7  
print(data[1::2]) # output: [20, 21, 19, 21]

# mengambil data list secara terbalik  
print(data[::-1])  
# output: [21, 'arman', 19, 'indah', 21, 'andi', 20, 'budi']
```
Fungsi bawaan dari tipe data _list_ sebenarnya cukup banyak. Beberapa website yang bisa dijadikan sumber belajar adalah [Python Docs](https://docs.python.org/3/tutorial/datastructures.html), [Belajar Python](https://belajarpython.com/tutorial/list-python), dan [Jago Ngoding](https://jagongoding.com/python/dasar/list/).

Demikian tips dan trik terkait pemanfaatan tipe data _list_ dalam _Python_. 
Semoga bermanfaat. 

Terima kasih.

---

Kode sumber dari tutorial ada di github repo. Cek juga versi notebook statis di [Github](https://github.com/galihboy/python_list/blob/main/list_tips_n_tricks.ipynb) \[_up-to-date_\], [Datalore](https://datalore.jetbrains.com/view/notebook/nQSEKFFpuveXre3AWXeaPU) atau yang versi interaktif di [MyBinder](https://mybinder.org/v2/gh/galihboy/python_list/ac5caee1eaeb8de324bc220b1e13564568c758bb?urlpath=lab%2Ftree%2Flist_tips_n_tricks.ipynb).

%[https://github.com/galihboy/python_list]

[**Website**](https://galih.eu/) **·** [**Github Pages**](https://galihboy.github.io/) **·** [**Demo Mini Projects**](https://galihboy.github.io/mini_projects/)

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1636796976894/HsAZE2YIx.gif)