5-list.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIST\n",
    "\n",
    "untuk menyimpan, memproses dan membaca ratusan bilangan, apakah kita harus membuat masing-masing variabel terpisah ? sangat tidak efisien\n",
    "\n",
    "var1= int(input())\n",
    "var2 = int(input())\n",
    ".\n",
    ".\n",
    ".\n",
    "varn = int(input())\n",
    "\n",
    "kita sudah belajar bahwa mendeklar variable hanya dapat simpan 1 nilai saja pada satu waktu. Variabel tersebut disebut scalars secara matematika. Semua variabel yang sejauh ini kita pakai sebenarnya berbentuk scalars.\n",
    "\n",
    "maka dari itu diperkenalkan list. list adalah sekumpulan elemen dan tiap elemen adalah scalars. \n",
    "nb : urutan elemen pada List selalu dimulai dari 0. item pertama yang tersimpan pada list diberi urutan 0"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing List\n",
    "\n",
    "gimana cara mengganti nilai pada elemen di dalam list?\n",
    "\n",
    "coba kita assign nilai 111 sebagai 1st element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original list konten [10, 5, 7, 2, 1]\n",
      "list konten terbaru [111, 5, 7, 2, 1]\n",
      "list berubah menjadi [111, 1, 7, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "nomor = [10,5,7,2,1] # list blm dirubah\n",
    "print(\"original list konten\", nomor)\n",
    "nomor[0]=111\n",
    "print(\"list konten terbaru\", nomor) #list pertama berubah dari 10 ke 111\n",
    "nomor[1]=nomor[4] # elemen kedua meng-copy elemen kelima menjadi 111,1,7,2,1\n",
    "print(\"list berubah menjadi\", nomor)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nilai yang ada dalam bracket [] disebut index. sejauh ini, indeks masih berupa literal atau angka, namun bisa juga diisi ekspresi atau formula"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mengakses isi list\n",
    "\n",
    "tiap elemen pada list bs diakses terpisah, caranya dg mencetaknya\n",
    "\n",
    "print(nomor[0]) # mencetak elemen ke-1\n",
    "output : 111\n",
    "\n",
    " Fungsi len()\n",
    "\n",
    " berguna utk cek panjang (lenght) sebuah list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "list sekarang adalah:  [111, 1, 7, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "print(len(nomor))\n",
    "print(\"list sekarang adalah: \",nomor)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Menghapus elemen dalam list\n",
    "\n",
    "menghapus isi list elemen tertentu menggunakan instruksi bernama del. ini adalah instruksi dan bukan sebuah fungsi\n",
    "\n",
    "nb: kita tidak bs mengakses elemen yang tidak ada di dalam list\n",
    "misal panjang list adalah 4, maka kita tidak bs akses index ke-4 dan lebih dari itu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "panjang list sekarang :  4 dan list sekarang yaitu : [1, 7, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "del nomor[0]\n",
    "print(\"panjang list sekarang : \", len(nomor), \"dan list sekarang yaitu :\",nomor)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negatif Index\n",
    "\n",
    "elemen terakhir (0 di ujung) dari sebuah list adalah -1\n",
    "elemen pertama sebelum terakhir (1 dari ujung) dari sebuah list adalah -2\n",
    "dst."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4321\n",
      "567\n"
     ]
    }
   ],
   "source": [
    "nomber = [1,44,567,4321]\n",
    "print(nomber[-1]) # paling ujung yaitu 4321\n",
    "print(nomber[-2]) # elemen ke-1 sblm paling ujung yaitu 567"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fungsi vs Metod\n",
    "\n",
    "- metod : jenis spesifik dari fungsi. sangat mirip fungsi tetapi beda cara kerja dan cara memanggilnya.\n",
    "metod bs melakukan pekerjaan apapun, tetapi juga dapat mengubah status entitas yang dipilihnya. metod dimiliki oleh data yang bekerja padanya.\n",
    "\n",
    "- fungsi : tidak merupakan milik data apapun. tetapi dimiliki oleh keseluruhan kode\n",
    "\n",
    "secara umum, pemanggilan fungsi yang khusus dg cara berikut:\n",
    "\n",
    "result = function(args)\n",
    "\n",
    "fungsi mengambil suatu argumen, melakukan sesuatu dan mengembalikan hasil tertentu\n",
    "\n",
    "sedangkan tipikal metod,pemanggilannya seperti ini:\n",
    "\n",
    "result = data.method(arg)\n",
    "\n",
    "nb: pemanggilan metod didahului dg nama data(karena metode dimiliki oleh data yang bekerja padanya), ditambahkan titik (dot) lalu diikuti nama metod, disambung dengan tanda kurung berisi argumen didalamnya.\n",
    "metod akan berkelakuan seperti fungsi, tetapi dapat melakukan sesuatu yang lebih, seperti mengganti keadaan data tsb\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Menambah element ke list dengan metod append() dan insert()\n",
    "\n",
    "- append()\n",
    "sebuah elemen baru dapat ditambahkan ke akhir elemen dari suatu list\n",
    "\n",
    "list.append(value)\n",
    "\n",
    "append ambil nilai argumen dan meletakkannya ke akhir elemen pada list tsb. kemudian panjang list akan bertambah\n",
    "\n",
    "\n",
    "- insert()\n",
    "metod ini lebih pinter lagi,  dapat menambahkan elemen baru pada tempat tertentu di dalam list\n",
    "\n",
    "list.insert(lokasi, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 999]\n",
      "[111, 1, 3, 5, 7, 999]\n"
     ]
    }
   ],
   "source": [
    "aa = [1,3,5,7]\n",
    "aa.append(999) # menambah 999 di akhir baris dg append()\n",
    "print(aa) # output: 1,3,5,7,999\n",
    "\n",
    "aa.insert(0,111) # menambah 111 pada index ke-0 atau elemen pertama\n",
    "print(aa) # output: 111,1,3,5,7,999\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Menambah elemen pada list (lanjutan)\n",
    "\n",
    "kita juga bs membuat list yang bisa disesuaikan dg kebutuhan menggunakan list kosong lalu menambahkan elemen baru ke dalamnya\n",
    "contoh:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "my_list = [] # list kosong\n",
    "for i in range(10): # i adalah index, sehingga dimulai dr 0 diakhir n-1\n",
    "    my_list.append(i)\n",
    "    \n",
    "print(my_list)\n",
    "\n",
    "# atau modifikasi dg insert()\n",
    "\n",
    "mynew_list = []\n",
    "for a in range(11):\n",
    "    mynew_list.insert(0,a) # karena penambahan selalu diletakkan di index-0\n",
    "print(mynew_list) # elemen nya akan terdesak ke kanan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "# mari coba snippet yang lain\n",
    "\n",
    "list_a = [10, 1, 8, 3, 5]\n",
    "total = 0 # inisiasi awal var total\n",
    "\n",
    "for b in range(len(list_a)):\n",
    "    total += list_a[b]\n",
    "\n",
    "print(total)\n",
    "\n",
    "# coba snippet yang lain lagi\n",
    "# snippet ini dimodifikasi shg tidak perlu menggunakan len()\n",
    "\n",
    "list_b = [10, 1, 8, 3, 5]\n",
    "totol = 0\n",
    "\n",
    "for j in list_b:\n",
    "    totol += j\n",
    "\n",
    "print(totol)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mengurutkan list sederhana\n",
    "\n",
    "coba pelajari algo ini :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "my_list = [8, 10, 6, 2, 4]  # list to sort\n",
    "swapped = True  # It's a little fake, we need it to enter the while loop.\n",
    "\n",
    "while swapped:\n",
    "    swapped = False  # no swaps so far\n",
    "    for i in range(len(my_list) - 1):\n",
    "        if my_list[i] > my_list[i + 1]:\n",
    "            swapped = True  # a swap occurred!\n",
    "            my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]\n",
    "\n",
    "print(my_list)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python memiliki mekanisme tersendiri dalam melakukan sort. sehingga kita tidak perlu lagi menulis sendiri sintak sorting (seperti contoh diatas).\n",
    "\n",
    "kita akan menggunakan metod sort(). contoh penggunaan sbb:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[32, 33, 35, 57, 67]\n"
     ]
    }
   ],
   "source": [
    "isi = [57,35,33,67,32]\n",
    "isi.sort() #metod sort bawaan python\n",
    "print(isi) # output : 32,33,35,57,67"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ada juga metod reverse() utk membalik urutan list.\n",
    "\n",
    "misal 2,3,4,5 menjadi terbalik 5,4,3,2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Powerful Slices\n",
    "\n",
    "slice adalah elemen dari sintak python yang membuatmu bisa membuat copy-an sebuah full-list atau sebagian copy-an sebuah list\n",
    "\n",
    "polanya yaitu\n",
    "\n",
    "list[start:end]\n",
    "start : index termulai\n",
    "end : elemen tepat sebelum elemen ke-end\n",
    "\n",
    "contoh:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n"
     ]
    }
   ],
   "source": [
    "list_1 = [1]\n",
    "list_2 = list_1[:]\n",
    "list_1[0] = 2\n",
    "print(list_2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "atau contoh lain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 6]\n"
     ]
    }
   ],
   "source": [
    "list_lagi = [10, 8, 6, 4, 2]\n",
    "new_list = list_lagi[1:3] # start nya dimulai dari index 1 yaitu 8 , dan kurang dari 3 element( atau sama dengan 2 elemen dimulai dr elemen start)\n",
    "# maka yang akan dicopy adalah 8 (index-1 sbg elemen pertama) lalu 6(elemen kedua  sblm elemen ketiga)\n",
    "print(new_list)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slices-negatif\n",
    "\n",
    "lihat snippet berikut :\n",
    "\n",
    "my_list[start:end]\n",
    "\n",
    "start : adalah indeks pada elemen pertama yang included pada slice target.\n",
    "end : indeks elemen pertama yang tidak termasuk dalam slice\n",
    "\n",
    "coba potong indeks berikut list_saya = [10,8,6,4,2]\n",
    "dengan start : 1 dan end : -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 6, 4]\n"
     ]
    }
   ],
   "source": [
    "list_saya = [10,8,6,4,2]\n",
    "newlist_saya = list_saya[1:-1] # potongan pertama adalah indeks ke-1 yaitu 8 dan indeks ke minus 1(tidak termasuk) maka yang terambil\n",
    "# adalah 6 dan 4\n",
    "print(newlist_saya) # output : 8,6,4"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slices (sambungan)\n",
    "\n",
    "jika kita menghilangkn start dalam proses slice, diasumsikan startnya adalah berasal dari 0\n",
    "\n",
    "contoh snippet:\n",
    "\n",
    "list_saya[:end] sama hasilnya dengan list_saya[0:end]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "list_d = [1,3,4,5]\n",
    "mylist_d = list_d[:3] # start dr 0 ke index ke-3 ( tidak termasuk)\n",
    "print(mylist_d) # output: 1,3,4"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sedangkan bentuk lain dg snipet berikut:\n",
    "my_list[start:] sama hasilnya dengan my_list[start:panjang(my_list)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 2]\n"
     ]
    }
   ],
   "source": [
    "list_ku = [10,8,6,4,2]\n",
    "\n",
    "newlist_ku = list_ku[3:] dimulai dr index ke-3 (included)sampai terakhir (tidak included)\n",
    "print(newlist_ku)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "del method dapat menghapus elemen list sekaligus slice\n",
    "\n",
    "contoh berikut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 7, 6]\n",
      "[10, 7, 6]\n"
     ]
    }
   ],
   "source": [
    "list_del = [10,9,8,7,6]\n",
    "del list_del[1:3] # menghapus element 9,8\n",
    "print(list_del)\n",
    "\n",
    "newlist_del = list_del\n",
    "print(newlist_del) # mengcopy list\n",
    "del newlist_del\n",
    "# print(newlist_del) nb: output error karna mendelet list, bukan hanya mendelet konten saja"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operator \"in\" dan \"not in\"\n",
    "\n",
    "Python menawarkan 2 powerful operator, dapat melihat list untuk mengecek adakah nilai yang spesifik yang tersimpan atau tidak  didalam list.\n",
    "\n",
    "cek snipet berikut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "cek_list = [10,3,12,8,2]\n",
    "\n",
    "print(5 in cek_list) # salah\n",
    "print(5 not in cek_list) # benar\n",
    "print(12 in cek_list) # salah"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n"
     ]
    }
   ],
   "source": [
    "# berikut contoh kode program simpel mengecek elemen dg nilai terbesar\n",
    "\n",
    "my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]\n",
    "largest = my_list[0]\n",
    "\n",
    "for i in range(1, len(my_list)):\n",
    "    if my_list[i] > largest:\n",
    "        largest = my_list[i]\n",
    "\n",
    "print(largest)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List lanjutan- array 2 dimensi\n",
    "\n",
    "contoh penggunaan array 2 dimensi tedapat pada papan catur atau juga bisa disebut matrix.\n",
    "\n",
    "contoh penggunaan matrix/ 2 dimensi array\n",
    "board = [[EMPTY for i in range(8)]for j in range(8)]\n",
    "\n",
    "berikut contoh penggunaan 2 dimensi "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [17, 3, 11, 5, 1, 9, 7, 15, 13]\n",
    "largest = my_list[0]\n",
    "\n",
    "for i in range(1, len(my_list)):\n",
    "    if my_list[i] > largest:\n",
    "        largest = my_list[i]\n",
    "\n",
    "print(largest)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List lanjutan- array 3 dimensi\n",
    "\n",
    "contoh penggunaan 3 dimensi \n",
    "rooms = [[[False for r in range(20)] for f in range(15)] for t in range(3)]\n",
    "\n",
    "contoh matrix 3 dimensi\n",
    "\n",
    "rooms[1][2][4]\n",
    "\n",
    "vacancy = 0\n",
    "\n",
    "for room_number in range(20):\n",
    "    if not rooms[2][14][room_number]:\n",
    "        vacancy += 1"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}