list_tips_n_tricks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tips dan Trik Menggunakan List dalam Python\n",
    "### Tutorial dibuat oleh [Galih Hermawan](https://galih.eu) di [blog Medium](https://masgalih.medium.com/tips-menggunakan-array-list-dalam-python-6b5add9f2dba)\n",
    "Last updated: 28 Oktober 2021, 16.07\n",
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 1. Membuat string dari isi list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Teks 1:  aku cinta indonesia\n",
      "Teks 2:  aku_cinta_indonesia\n"
     ]
    }
   ],
   "source": [
    "daftar = ['aku', 'cinta', 'indonesia']\n",
    "\n",
    "# digabung dengan separator 'spasi'\n",
    "teks = \" \".join(daftar)\n",
    "print(\"Teks 1: \", teks)\n",
    "\n",
    "# contoh dengan pemisah '_'\n",
    "teks2 = \"_\".join(daftar)\n",
    "print(\"Teks 2: \", teks2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 2. Memeriksa apakah sebuah list ada isinya atau tidak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keranjang 1 ada isinya\n",
      "Keranjang 2 kosong\n"
     ]
    }
   ],
   "source": [
    "keranjang1 = [\"jeruk\", \"anggur\", \"manggis\"]\n",
    "keranjang2 = []\n",
    "\n",
    "# cara lama\n",
    "if len(keranjang1) > 0: \n",
    "    print(\"Keranjang 1 ada isinya\")\n",
    "else:\n",
    "    print(\"Keranjang 1 kosong\")\n",
    "\n",
    "if len(keranjang2) == 0: \n",
    "    print(\"Keranjang 2 kosong\")\n",
    "else:\n",
    "    print(\"Keranjang 2 ada isinya\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keranjang 1 ada isinya\n",
      "Keranjang 2 kosong\n"
     ]
    }
   ],
   "source": [
    "# cara baru\n",
    "if keranjang1: \n",
    "    print(\"Keranjang 1 ada isinya\")\n",
    "else:\n",
    "    print(\"Keranjang 1 kosong\")\n",
    "    \n",
    "if not keranjang2: \n",
    "    print(\"Keranjang 2 kosong\")\n",
    "else:\n",
    "    print(\"Keranjang 2 ada isinya\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tip 3. Menggabung isi list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Daun', 'Rambut', 'Langit', 'Hijau', 'Hitam', 'Biru']\n"
     ]
    }
   ],
   "source": [
    "listBenda = [\"Daun\", \"Rambut\", \"Langit\"]\n",
    "listWarna = [\"Hijau\", \"Hitam\", \"Biru\"]\n",
    "\n",
    "listGabungan = listBenda + listWarna\n",
    "\n",
    "print(listGabungan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Daun Hijau\n",
      "Rambut Hitam\n",
      "Langit Biru\n"
     ]
    }
   ],
   "source": [
    "# mengakses isi list hasil zip dari dua list\n",
    "listGabungan2 = zip(listBenda, listWarna)\n",
    "for benda, warna in listGabungan2:\n",
    "    print(benda,warna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Daun', 'Hijau'), ('Rambut', 'Hitam'), ('Langit', 'Biru')]\n",
      "{'Daun': 'Hijau', 'Rambut': 'Hitam', 'Langit': 'Biru'}\n",
      "['Daun', 'Hijau', 'Rambut', 'Hitam', 'Langit', 'Biru']\n"
     ]
    }
   ],
   "source": [
    "# konversi dari zip ke list\n",
    "listGabungan3 = list(zip(listBenda, listWarna))\n",
    "print(listGabungan3)\n",
    "\n",
    "# koversi dari zip ke dictionary (kamus)\n",
    "kamus = dict(zip(listBenda, listWarna))\n",
    "print(kamus)\n",
    "\n",
    "# menggabung isi list per item secara berdampingan\n",
    "listGabungan4 = []\n",
    "for benda, warna in zip(listBenda, listWarna):\n",
    "    listGabungan4.extend((benda, warna))\n",
    "    \n",
    "print(listGabungan4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 4. Mengembalikan indeks nilai hasil pencarian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "6\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]\n",
    "angkaCari = 2\n",
    "\n",
    "# fungsi index pada list berfungsi mengembalikan indeks dari nilai yang dimasukkan\n",
    "print(angkaAcak.index(angkaCari)) # start dari indeks ke-0\n",
    "#print(angkaAcak.index(10)) # ValueError: 10 is not in list\n",
    "\n",
    "print(angkaAcak.index(angkaCari,1)) # start dari indeks ke-1\n",
    "print(angkaAcak.index(angkaCari,7)) # start dari indeks ke-7\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2\n",
      "1 3\n",
      "2 4\n",
      "3 6\n",
      "4 4\n",
      "5 5\n",
      "6 2\n",
      "7 7\n",
      "8 9\n",
      "9 7\n",
      "10 2\n"
     ]
    }
   ],
   "source": [
    "# menampilkan indeks dan data\n",
    "for idx, angka in enumerate(angkaAcak):\n",
    "    print(idx, angka)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "6\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# pencarian via looping - hanya menampilkan indeks\n",
    "for idx, angka in enumerate(angkaAcak):\n",
    "    if angka == angkaCari:\n",
    "        print(idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 6, 10]\n"
     ]
    }
   ],
   "source": [
    "# looping versi pendek - list comprehension\n",
    "lstCari = [idx for idx,angka in enumerate(angkaAcak) if angka == angkaCari]\n",
    "print(lstCari)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 3], [5, 5], [7, 7], [8, 9], [9, 7]]\n",
      "Angka 3 ada di indeks ke-1\n",
      "Angka 5 ada di indeks ke-5\n",
      "Angka 7 ada di indeks ke-7\n",
      "Angka 9 ada di indeks ke-8\n",
      "Angka 7 ada di indeks ke-9\n"
     ]
    }
   ],
   "source": [
    "# menampilkan indeks dan nilai dari angka ganjil\n",
    "lstCari = [[idx,angka] for idx,angka in enumerate(angkaAcak) if angka % 2 == 1]\n",
    "print(lstCari)\n",
    "\n",
    "# cara akses\n",
    "for isi in lstCari:\n",
    "    print(f\"Angka {isi[1]} ada di indeks ke-{isi[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 5. Menghitung jumlah kemunculan dari suatu nilai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Angka 2 ditemukan sejumlah 3 kali\n",
      "List angka ganjil: [3, 5, 7, 9, 7]\n",
      "Jumlah item: 5\n"
     ]
    }
   ],
   "source": [
    "angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]\n",
    "angkaCari = 2\n",
    "\n",
    "jml = angkaAcak.count(angkaCari)\n",
    "print(f\"Angka {angkaCari} ditemukan sejumlah {jml} kali\")\n",
    "\n",
    "# menemukan bilangan ganjil\n",
    "angkaGanjil = [angka for angka in angkaAcak if angka % 2 == 1]\n",
    "print(f\"List angka ganjil: {angkaGanjil}\")\n",
    "print(f\"Jumlah item: {len(angkaGanjil)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List angka ganjil unik: [3, 5, 7, 9]\n",
      "Jumlah: 4\n"
     ]
    }
   ],
   "source": [
    "# ubah list ke set untuk mendapatkan angka unik \n",
    "angkaGanjilUnik = [angka for angka in set(angkaAcak) if angka % 2 == 1]\n",
    "print(f\"List angka ganjil unik: {angkaGanjilUnik}\")\n",
    "print(f\"Jumlah: {len(angkaGanjilUnik)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Angka 2 muncul 3 kali.\n",
      "Angka 3 muncul 1 kali.\n",
      "Angka 4 muncul 2 kali.\n",
      "Angka 5 muncul 1 kali.\n",
      "Angka 6 muncul 1 kali.\n",
      "Angka 7 muncul 2 kali.\n",
      "Angka 9 muncul 1 kali.\n",
      "\n",
      "List jumlah kemunculan angka: [[2, 3], [3, 1], [4, 2], [5, 1], [6, 1], [7, 2], [9, 1]]\n"
     ]
    }
   ],
   "source": [
    "# menghitung jumlah (kemunculan) setiap item dalam list\n",
    "listPenampung = []\n",
    "setAngkaUnik = set(angkaAcak)\n",
    "for a in setAngkaUnik:\n",
    "    print(f\"Angka {a} muncul {angkaAcak.count(a)} kali.\")\n",
    "    # jika angka dan jumlah kemunculan ingin disimpan dalam sebuah list\n",
    "    listPenampung.append([a, angkaAcak.count(a)])\n",
    "    \n",
    "print(f\"\\nList jumlah kemunculan angka: {listPenampung}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 6. Menampilkan data secara unik"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bentuk set: {2, 3, 4, 5, 6, 7, 9}\n",
      "Bentuk list: [2, 3, 4, 5, 6, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]\n",
    "angkaUnik = set(angkaAcak)\n",
    "\n",
    "# Cara 1 - via set\n",
    "print(f\"Bentuk set: {angkaUnik}\")\n",
    "print(f\"Bentuk list: {list(angkaUnik)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 6, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Cara 2 - menggunakan list murni\n",
    "> menampilkan data list unik tanpa diurutkan\n",
    "> tanpa menggunakan set\n",
    "> secara komputasi membutuhkan waktu lebih lama ketimbang cara pertama\n",
    "'''\n",
    "\n",
    "listTemp = [] # inisialisasi list kosong\n",
    "for angka in angkaAcak:\n",
    "    if angka not in listTemp: # jika angka belum ada di listTemp, daftarkan/masukkan\n",
    "        listTemp.append(angka)\n",
    "\n",
    "print(listTemp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 7. Menampilkan isi list yang ada pada list lain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['buku']\n"
     ]
    }
   ],
   "source": [
    "barang1 = ['buku', 'pensil', 'penggaris']\n",
    "barang2 = ['penghapus', 'kertas', 'buku']\n",
    "\n",
    "# cara 1 - via list comprehension \n",
    "# b1 mewakili setiap item di barang1\n",
    "# b2 mewakili setiap item di barang2\n",
    "barangSama = [b1 for b1 in barang1 for b2 in barang2 if b1==b2]\n",
    "print(barangSama)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['buku']\n"
     ]
    }
   ],
   "source": [
    "# cara 2 - via set intersection\n",
    "set1 = set(barang1)\n",
    "set2 = set(barang2)\n",
    "\n",
    "listBarangSama = list(set1.intersection(set2))\n",
    "print(listBarangSama)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 8. Menampilkan isi dari dua list yang tidak beririsan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['penggaris', 'penghapus', 'pensil', 'kertas']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "barang1 = ['buku', 'pensil', 'penggaris']\n",
    "barang2 = ['penghapus', 'kertas', 'buku']\n",
    "\n",
    "# cara 1 - via set\n",
    "set_barang1 = set(barang1)\n",
    "set_barang2 = set(barang2)\n",
    "\n",
    "listBarang = list(set_barang1.symmetric_difference(set_barang2))\n",
    "print(listBarang)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Barang 1 NOT IN barang 2: ['pensil', 'penggaris']\n",
      "Barang 2 NOT IN barang 1: ['penghapus', 'kertas']\n",
      "Hasil gabungan: ['pensil', 'penggaris', 'penghapus', 'kertas']\n"
     ]
    }
   ],
   "source": [
    "# cara 2 - murni via list\n",
    "\n",
    "# data di barang1 yang tidak ada di barang2\n",
    "b1_beda = [b for b in barang1 if b not in barang2]\n",
    "print(f\"Barang 1 NOT IN barang 2: {b1_beda}\")\n",
    "\n",
    "# data di barang2 yang tidak ada di barang1\n",
    "b2_beda = [b for b in barang2 if b not in barang1]\n",
    "print(f\"Barang 2 NOT IN barang 1: {b2_beda}\")\n",
    "\n",
    "print(f\"Hasil gabungan: {b1_beda+b2_beda}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 9. Mengurutkan data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 2, 3, 4, 4, 5, 6, 7, 7, 9]\n",
      "[9, 7, 7, 6, 5, 4, 4, 3, 2, 2, 2]\n",
      "[2, 3, 4, 6, 4, 5, 2, 7, 9, 7, 2]\n"
     ]
    }
   ],
   "source": [
    "angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]\n",
    "\n",
    "dataUrutAsc = sorted(angkaAcak)\n",
    "dataUrutDesc = sorted(angkaAcak,reverse=True)\n",
    "\n",
    "print(dataUrutAsc)\n",
    "print(dataUrutDesc)\n",
    "print(angkaAcak)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 2, 3, 4, 4, 5, 6, 7, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# modifikasi isi list dengan data berurut\n",
    "angkaAcak.sort()\n",
    "print(angkaAcak)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 6, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# data unik dan urut (otomatis oleh tipe data set)\n",
    "angkaAcakDua = [2,3,4,6,4,5,2,7,9,7,2]\n",
    "dataUrutUnik = list(set(angkaAcakDua))\n",
    "print(dataUrutUnik)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 10. Membongkar elemen list dengan *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 4 6 4 5 2 7 9 7 2\n",
      "2 3 4 5 6 7 9\n"
     ]
    }
   ],
   "source": [
    "angkaAcak = [2,3,4,6,4,5,2,7,9,7,2]\n",
    "\n",
    "# strAngka = \" \".join(angkaAcak) # error\n",
    "print(*angkaAcak)\n",
    "\n",
    "print(*set(angkaAcak))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jeruk\n",
      "mangga nanas apel manggis\n"
     ]
    }
   ],
   "source": [
    "buah = ['jeruk', 'mangga', 'nanas', 'apel', 'manggis']\n",
    "\n",
    "b_satu, *b_sisa = buah\n",
    "print(b_satu)\n",
    "print(*b_sisa)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jeruk\n",
      "mangga nanas apel\n",
      "manggis\n"
     ]
    }
   ],
   "source": [
    "b_satu, *b_tengah, b_akhir = buah\n",
    "print(b_satu)\n",
    "print(*b_tengah)\n",
    "print(b_akhir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips 11. Mengiris (slicing) data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "budi\n",
      "21\n",
      "['budi', 20]\n",
      "['arman', 21]\n",
      "['budi', 'andi', 'indah', 'arman']\n",
      "[20, 21, 19, 21]\n",
      "[21, 'arman', 19, 'indah', 21, 'andi', 20, 'budi']\n"
     ]
    }
   ],
   "source": [
    "data = ['budi', 20, 'andi', 21, 'indah', 19, 'arman', 21]\n",
    "\n",
    "# mengambil data pada indeks ke-0 (atau pertama)\n",
    "print(data[0])\n",
    "\n",
    "# indeks terakhir disimbolkan dengan angka \"-1\"\n",
    "print(data[-1]) \n",
    "\n",
    "# mengambil data pertama hingga sebelum indeks ke-2\n",
    "print(data[:2]) \n",
    "\n",
    "# mengambil data pada indeks -2 hingga terakhir\n",
    "print(data[-2:])\n",
    "\n",
    "# mengambil data dari indeks ke-0 hingga akhir dengan 2 langkah\n",
    "# indeks: 0, 2, 4, 6\n",
    "print(data[::2])\n",
    "\n",
    "# mengambil data dari indeks ke-1 hingga akhir dengan 2 langkah\n",
    "# indeks: 1, 3, 5, 7\n",
    "print(data[1::2]) \n",
    "\n",
    "# mengambil data list secara terbalik\n",
    "print(data[::-1])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}