1_Basic_Python_for_Seismology_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "227e9104",
   "metadata": {},
   "source": [
    "<div style=\"background-color: #28a745 !important; color: white; min-height: 50px; padding: 10px; margin: auto;\">\n",
    "    <p style=\"text-align: right; font-style: italic\">STMKGxHMGI Long Course</p>\n",
    "    <h1>Basic Python for Seismology 1</h1>\n",
    "</div>\n",
    "<div style=\"background-color: whitesmoke; padding: 10px \">\n",
    "    <ul>\n",
    "        <li>Tujuan: Memperkenalkan dasar pemrograman Python</li>\n",
    "        <li>Keluaran: Peserta dapat menjalankan Python dan memahami penggunaannya</li>\n",
    "        <li>Sesi: Materi</li>\n",
    "        <li>Waktu/Tempat: Sabtu, 18 September 2021/ Zoom Meeting</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b084159",
   "metadata": {},
   "source": [
    "# 1 Variabel dan Operasi\n",
    "\n",
    "## 1.1 Variabel\n",
    "Variabel adalah suatu nilai yang kita simpan di memori dan bisa kita panggil saat akan digunakan. Contoh kasus variabel adalah seperti saat kita menyimpan memori di otak kita bahwa nilai $\\pi$ (variabel) adalah 3,14. Saat mengingat atau memanggil $\\pi$ di memori otak kita maka akan muncul angka 3,14. Cara kerja komputer juga demikian sehingga Python sebagai salah satu bahasa pemrograman juga bertindak seperti itu. Dalam implementasinya cara 'menyimpan ingatan' ini dilakukan dengan cara yang mudah:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "3e450281",
   "metadata": {},
   "outputs": [],
   "source": [
    "pi=3.14"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4618f615",
   "metadata": {},
   "source": [
    "Pada contoh di atas kita menyimpan di ingatan komputer bahwa nilai `pi` adalah `3.14`, dengan begitu kita dapat memanggilnya dengan cara:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "3a890a9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c591e8fe",
   "metadata": {},
   "source": [
    "Variabel dalam Python sendiri dibedakan menjadi beberapa jenis seperti:\n",
    "- `Integer`: bilangan bulat\n",
    "- `Float`: *floating point*, bilangan dengan desimal\n",
    "- `String`: teks\n",
    "- `Complex numbers`: bilangan kompleks\n",
    "- `Boolean`: benar (`True`) atau salah (`False`)\n",
    "\n",
    "Python akan menginterpretasikan jenis variabel dari **cara kita menulis** variabel tersebut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "027f85f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "angka=1 #integer\n",
    "Angka=1.0 #float\n",
    "ANGKA=\"1\" #string\n",
    "ANGKA2='1' #string\n",
    "bil_kompleks=5-1j #complex\n",
    "bools=True #boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9f89077",
   "metadata": {},
   "source": [
    "Sama seperti ingatan manusia, jika suatu menyimpan ke memori dengan kata kunci yang sama maka nilai sebelumnya akan dilupakan, contoh:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "f17b288f",
   "metadata": {},
   "outputs": [],
   "source": [
    "angka=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "43ba2b1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angka"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c1f23a0",
   "metadata": {},
   "source": [
    "Saat kita panggil `angka` maka `2` yang akan muncul, bagaimana kalau nilai `angka` kita ganti:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "4a06b635",
   "metadata": {},
   "outputs": [],
   "source": [
    "angka=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "2a59b5a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angka"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bb02248",
   "metadata": {},
   "source": [
    "## 1.2 Operasi\n",
    "\n",
    "Jika kita sudah bisa menyimpan suatu nilai ke dalam ingatan komputer dengan mendefinisikan suatu `variable`, selanjutnya kita akan mengoperasikan variabel-variabel tersebut. Beberapa operasi standar yang dapat kita lakukan adalah:\n",
    "\n",
    "|Simbol Operasi|\tKegunaan\t|\n",
    "|----|-----|\n",
    "|**+**\t|penjumlahan |\n",
    "|**-** | pengurangan |\n",
    "|**\\***|  perkalian|\n",
    "| **/** | pembagian |\n",
    "|  **%** | mengembalikan sisa pembagian (_modulo_).|\n",
    "| **\\*\\*** |pangkat|\n",
    "|**+=** | menambah dan mengganti |\n",
    "| **-=** | mengurangkan dan mengganti |\n",
    "| ==  | mengetes kesamaan |\n",
    "| != | mengetes ketidaksamaan |\n",
    "\n",
    "Contoh implementasi operasi-operasi di atas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "19956727",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "angka1=3\n",
    "angka2=5\n",
    "angka3=angka1+angka2\n",
    "print(angka3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "7b6470c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-5\n"
     ]
    }
   ],
   "source": [
    "angka4=angka1-angka3\n",
    "print(angka4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "972723f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "243\n"
     ]
    }
   ],
   "source": [
    "angka5=angka1**angka2\n",
    "print(angka5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40cf7783",
   "metadata": {},
   "source": [
    "Jenis variabel yang dioperasikan akan berpengaruh terhadap hasil operasinya, misalkan operasi perkalian antar `integer`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "23c1b49d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10*10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e27bab4",
   "metadata": {},
   "source": [
    "Hasil operasi di atas berupa `integer` karena variabel yang dikalikan sama-sama `integer`. Jika salah satu atau kedua data merupakan `float` maka hasil dari operasi akan berjenis `float`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "53b2192a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10*10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9430e6c8",
   "metadata": {},
   "source": [
    "Bagaimana dengan operasi `string`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "defa9c0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'13'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"1\"+\"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "23215995",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_4387/2527148311.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"13\"\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;34m\"3\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "\"13\"-\"3\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b4b0e8",
   "metadata": {},
   "source": [
    "Operasi penjumlahan pada `string` akan 'menumpuk' string tersebut sedangkan operasi pengurangan tidak bisa dijalankan. Operasi perkalian antar `string` juga akan menghasilkan error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27e1306c",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"1\"*\"3\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6425e6e2",
   "metadata": {},
   "source": [
    "`string` bisa dikalikan dengan `integer`, hasil perkalian ini berupa penumpukan string sebanyak angka yang dikalikan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b08cb945",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"1\"*3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ab85d86",
   "metadata": {},
   "source": [
    "operasi dengan `float` akan menghasilkan error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b7ebec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"1\"*3."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cf12b55",
   "metadata": {},
   "source": [
    "# 2 Struktur Data\n",
    "\n",
    "Data dalam geofisika biasanya merupakan kumpulan nilai atau angka yang erat kaitannya dengan pengukuran. Kita akan menggunakan studi kasus pengukuran suhu suatu ruangan setiap 4 jam dalam satu hari, dengan kata lain kita akan memiliki 6 angka hasil pengukuran. Bagaimana mewakili 6 angka tersebut dalam Python?\n",
    "\n",
    "Python menyediakan beberapa jenis struktur data yang bisa digunakan untuk menyimpan data kita yang masing-masing memiliki fungsinya sendiri. Beberapa jenis struktur data yang umum di dalam Python adalah:\n",
    "- `List`\n",
    "- `Tuple`\n",
    "- `Dictionary`\n",
    "- `Sets`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dd9cfd1",
   "metadata": {},
   "source": [
    "## 2.1 List\n",
    "\n",
    "`List` ditulis dalam Python dengan `[]` yang bisa diisi berbagai macam variable yang sama ataupun berbeda dan masing-masing variabel tersebut dipisahkan dengan tanda koma (`,`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "caaf9e0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[34.0, 35.0, 34.3, 32.0, 31.1, 29.0]\n"
     ]
    }
   ],
   "source": [
    "suhu_24h=[34.0, 35.0, 34.3, 32.0, 31.1, 29.0]\n",
    "print(suhu_24h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4753197b",
   "metadata": {},
   "source": [
    "dalam kasus pengukuran suhu ruangan tersebut kita mendapatkan 6 angka pengukuran yang kemudian dituangkan dalam `list` di Python seperti di atas. Setiap element `list` berasosiasi dengan `index` yang dimulai dengan angka 0 pada element pertama dan seterusnya. Contoh apabila kita ingin mengambil pengukuran ketiga maka `index`nya adalah 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "5963709b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34.3\n"
     ]
    }
   ],
   "source": [
    "pengukuran_3=suhu_24h[2]\n",
    "print(pengukuran_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a5d7957",
   "metadata": {},
   "source": [
    "Kita juga dapat memanggil dari belakang dengan `index` -1 untuk element terakhir, -2 untuk element kedua dari akhir, dan seterusnya, seperti contoh:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "3bc34876",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.0\n"
     ]
    }
   ],
   "source": [
    "pengukuran_terakhir=suhu_24h[-1]\n",
    "print(pengukuran_terakhir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc280bf6",
   "metadata": {},
   "source": [
    "Dengan `index` kita juga bisa mengambil lebih dari 1 elemen dengan tambahan simbol `:`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "1644c497",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[34.0, 35.0]\n"
     ]
    }
   ],
   "source": [
    "pengukuran_1dan2=suhu_24h[0:2]\n",
    "print(pengukuran_1dan2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8443d019",
   "metadata": {},
   "source": [
    "Element dalam `list` dapat diganti/*mutable* seperti pada contoh dibawah ini:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "22100eef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[37.0, 35.0, 34.3, 32.0, 31.1, 29.0]\n"
     ]
    }
   ],
   "source": [
    "suhu_24h[0]=37.0\n",
    "print(suhu_24h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decd4cf9",
   "metadata": {},
   "source": [
    "`list` memiliki banyak sekali `method` yang digunakan untuk mengolah `list` tersebut, opsi-opsi atau `method` tersebut dapat kita lihat dengan mengetikkan `help`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "82985ee6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on list object:\n",
      "\n",
      "class list(object)\n",
      " |  list(iterable=(), /)\n",
      " |  \n",
      " |  Built-in mutable sequence.\n",
      " |  \n",
      " |  If no argument is given, the constructor creates a new empty list.\n",
      " |  The argument must be an iterable if specified.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the list.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the list in memory, in bytes.\n",
      " |  \n",
      " |  append(self, object, /)\n",
      " |      Append object to the end of the list.\n",
      " |  \n",
      " |  clear(self, /)\n",
      " |      Remove all items from list.\n",
      " |  \n",
      " |  copy(self, /)\n",
      " |      Return a shallow copy of the list.\n",
      " |  \n",
      " |  count(self, value, /)\n",
      " |      Return number of occurrences of value.\n",
      " |  \n",
      " |  extend(self, iterable, /)\n",
      " |      Extend list by appending elements from the iterable.\n",
      " |  \n",
      " |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      " |      Return first index of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(self, index, object, /)\n",
      " |      Insert object before index.\n",
      " |  \n",
      " |  pop(self, index=-1, /)\n",
      " |      Remove and return item at index (default last).\n",
      " |      \n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(self, value, /)\n",
      " |      Remove first occurrence of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(self, /)\n",
      " |      Reverse *IN PLACE*.\n",
      " |  \n",
      " |  sort(self, /, *, key=None, reverse=False)\n",
      " |      Sort the list in ascending order and return None.\n",
      " |      \n",
      " |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n",
      " |      order of two equal elements is maintained).\n",
      " |      \n",
      " |      If a key function is given, apply it once to each list item and sort them,\n",
      " |      ascending or descending, according to their function values.\n",
      " |      \n",
      " |      The reverse flag can be set to sort in descending order.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  __class_getitem__(...) from builtins.type\n",
      " |      See PEP 585\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(suhu_24h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86bc499",
   "metadata": {},
   "source": [
    "Berdasarkan petunjuk di atas kita akan mencoba 1 `method` yaitu `pop` yang petunjuknya adalah:\n",
    "\n",
    "```\n",
    "pop(self, index=-1, /)\n",
    " |      Remove and return item at index (default last).\n",
    "```\n",
    "\n",
    "berdasarkan petunjuk tersebut maka `pop` akan mengambil elemen list sekaligus menghapusnya dari `list` kita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a34752a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list sebelum pop [37.0, 35.0, 34.3, 32.0, 31.1, 29.0]\n",
      "elemen yang dihapus 29.0\n",
      "list setelah dihapus [37.0, 35.0, 34.3, 32.0, 31.1]\n"
     ]
    }
   ],
   "source": [
    "print(\"list sebelum pop\", suhu_24h)\n",
    "elemen_terhapus=suhu_24h.pop()\n",
    "print(\"elemen yang dihapus\",elemen_terhapus)\n",
    "print(\"list setelah pop\", suhu_24h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb09de16",
   "metadata": {},
   "source": [
    "## 2.2 Tuple\n",
    "\n",
    "`Tuple` sangat mirip dengan `List` hanya saja `Tuple` merupakan *sequence* yang elemennya tidak bisa diganti (*immutable*). Penulisan `Tuple` dalam Python menggunakan tanda `()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "c1286713",
   "metadata": {},
   "outputs": [],
   "source": [
    "suhu_24h_lock=(37.0, 35.0, 34.3, 32.0, 31.1, 29.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a96cdf",
   "metadata": {},
   "source": [
    "Pemanggilan element sama dengan `list` yaitu menggunakan `index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "aaf3ef1a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.0\n"
     ]
    }
   ],
   "source": [
    "pengukuran_1=suhu_24h_lock[0]\n",
    "print(pengukuran_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e1fd6f9",
   "metadata": {},
   "source": [
    "Jika kita coba mengedit element dalam `tuple` maka akan muncul error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "5cbb618b",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_4387/2770928713.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msuhu_24h_lock\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m29.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "suhu_24h_lock[0]=29.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23203363",
   "metadata": {},
   "source": [
    "## 2.3 Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f42a9570",
   "metadata": {},
   "source": [
    "`Sets` adalah data dalam bentuk koleksi unik yang tak berurutan dan sifatnya *immutable* seperti `tuple`. Secara sederhana `sets` bisa kita artikan sebagai himpunan dalam bahasa Indonesia. Kegunaannya juga mirip seperti himpunan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "ddd18b31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bayam', 'seledri', 'tomat'}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sayur={\"seledri\", \"tomat\", \"bayam\"}\n",
    "Sayur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88d010e1",
   "metadata": {},
   "source": [
    "elemen `sets` harus unik dan tidak ada yang duplikat:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "62cb1936",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bayam', 'seledri', 'tomat'}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sayur={\"seledri\", \"tomat\", \"bayam\", \"tomat\"}\n",
    "Sayur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb263e92",
   "metadata": {},
   "source": [
    "Walaupun bersifat *immutable* tapi `sets` dapat ditambah elemennya:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "887930f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bayam', 'kol', 'seledri', 'tomat'}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sayur.add(\"kol\")\n",
    "Sayur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58eb0351",
   "metadata": {},
   "source": [
    "`sets` juga dapat dioperasikan dengan `sets` yang lain:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "8a781372",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apel', 'jeruk', 'tomat'}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Buah={\"tomat\",\"apel\",\"jeruk\"}\n",
    "Buah"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd80174a",
   "metadata": {},
   "source": [
    "dalam contoh pertama kita akan melihat elemen dari dua `sets` yang sama dengan method `intersection`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "82db5305",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'tomat'}"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sayur.intersection(Buah)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd59402d",
   "metadata": {},
   "source": [
    "Dari contoh di atas kita seperti mencari irisan dari dua buah himpunan yaitu Sayur dan Buah, karena tomat masuk keduanya maka tomat adalah irisannya. Contoh selanjutnya adalah dengan metode `difference` dan `union`kira-kira apa yang terjadi?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "c5a1d543",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bayam', 'kol', 'seledri'}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sayur.difference(Buah)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "def089d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apel', 'bayam', 'jeruk', 'kol', 'seledri', 'tomat'}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sayur.union(Buah)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e213b42",
   "metadata": {},
   "source": [
    "## 2.4 Dictionary\n",
    "\n",
    "`Dictionary` menyimpan data di dalam `keys` bersifat alfanumerik, `keys` bisa dianalogikan sebagai sebuah judul kolom yang masing-masing kolom tersebut terdapat data. Penulisan `dictionary` mirip dengan `sets` yaitu menggunakan `{}`. Dalam contoh di bawah ini masih menggunakan studi kasus pengukuran suhu, dengan `dictionary` kita dapat mendefinisikan data lain yaitu waktu pengukuran dalam menit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "5b986dde",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'waktu_menit': [10, 20, 30], 'suhu': [29, 30, 27]}\n"
     ]
    }
   ],
   "source": [
    "pengukuran_suhu={\"waktu_menit\":[10,20,30], \"suhu\":[29,30,27]}\n",
    "print(pengukuran_suhu)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f9c46c8",
   "metadata": {},
   "source": [
    "Jika dalam `list` dan dalam `tuple` kita bisa mengambil elemen dengan menggunakan indeks, dalam `dictionary` kita menggunakan `keys` dari data yang akan kita ambil. Apabila kita ingin mengambil data waktu pengukuran maka kita menggunakan `keys` `waktu_menit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "9bfde658",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "waktu_pengukuran=pengukuran_suhu['waktu_menit']\n",
    "waktu_pengukuran"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45e10d29",
   "metadata": {},
   "source": [
    "Dengan memanggil `waktu_pengukuran` kita mendapatkan isi dari `key` tersebut yang berupa `list`, seperti yang kita definisikan di atas."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a9a648a",
   "metadata": {},
   "source": [
    "# 3 Conditional (Pembuatan Keputusan)\n",
    "\n",
    "Pada pembuatan suatu aplikasi pasti akan sampai dalam sebuah titik dimana kita harus mengambil keputusan dan harus memilih satu dari beberapa pilihan tergantung kondisi. Dalam implementasinya kita akan mengenal `if`, `elif`, dan `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "90fcbaf6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pengukuran lebih dari 1 jam\n"
     ]
    }
   ],
   "source": [
    "waktu_menit=70\n",
    "\n",
    "if waktu_menit > 60:\n",
    "    print(\"pengukuran lebih dari 1 jam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f975abd",
   "metadata": {},
   "source": [
    "Pada contoh di atas kita membuat variabel `waktu_menit`, apabila nilai dalam variabel tersebut melebihi 60 menit (`if waktu_menit > 60`) maka akan dicetak tulisan: `pengukuran lebih dari 1 jam`. Jika waktu kurang dari 60 maka tidak akan terjadi apa-apa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "b90ff036",
   "metadata": {},
   "outputs": [],
   "source": [
    "waktu_menit=10\n",
    "\n",
    "if waktu_menit > 60:\n",
    "    print(\"pengukuran lebih dari 1 jam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ccfcab8",
   "metadata": {},
   "source": [
    "Kita bisa menambah percabangan lagi dengan `else` apabila `waktu_menit` tidak lebih besar dari 60:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "90c6fa26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pengukuran kurang dari 1 jam\n"
     ]
    }
   ],
   "source": [
    "waktu_menit=10\n",
    "\n",
    "if waktu_menit > 60:\n",
    "    print(\"pengukuran lebih dari 1 jam\")\n",
    "else:\n",
    "    print(\"pengukuran kurang dari 1 jam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a84c21a2",
   "metadata": {},
   "source": [
    "Untuk percabangan yang lebih dari 2 maka kita perlu menggunakan `elif` atau else-if:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "f0b264b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pengukuran tepat 1 jam\n"
     ]
    }
   ],
   "source": [
    "waktu_menit=60\n",
    "\n",
    "if waktu_menit > 60:\n",
    "    print(\"pengukuran lebih dari 1 jam\")\n",
    "elif waktu_menit == 60:\n",
    "    print(\"pengukuran tepat 1 jam\")\n",
    "else:\n",
    "    print(\"pengukuran kurang dari 1 jam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5c90937",
   "metadata": {},
   "source": [
    "`Conditional` ini dapat bertingkat (`nested`), contoh apabila pengukuran selesai setelah 120 menit atau 2 jam:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "0065a8e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pengukuran selesai karena sudah 2 jam\n"
     ]
    }
   ],
   "source": [
    "waktu_menit=130\n",
    "timer_off=120\n",
    "\n",
    "if waktu_menit > 60:\n",
    "    if waktu_menit < timer_off:\n",
    "        print(\"pengukuran lebih dari 1 jam\")\n",
    "    else:\n",
    "        print(\"pengukuran selesai karena sudah 2 jam\")\n",
    "elif waktu_menit == 60:\n",
    "    print(\"pengukuran tepat 1 jam\")\n",
    "else:\n",
    "    print(\"pengukuran kurang dari 1 jam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9dfddb8",
   "metadata": {},
   "source": [
    "# 4 Loop (perulangan)\n",
    "\n",
    "`Loop` digunakan untuk melakukan perulangan proses pada setiap elemen pada data *sequence* seperti `list` dan `tuple`. Ada dua macam perulangan di Python yaitu `for` dan `while`. Misalkan kita akan mencetak hasil pengukuran suhu dengan `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "7c5a45bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suhu sekarang adalah: 37.0\n",
      "Suhu sekarang adalah: 35.0\n",
      "Suhu sekarang adalah: 34.3\n",
      "Suhu sekarang adalah: 32.0\n",
      "Suhu sekarang adalah: 31.1\n"
     ]
    }
   ],
   "source": [
    "for elemen in suhu_24h:\n",
    "    print(\"Suhu sekarang adalah:\", elemen)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5509ad41",
   "metadata": {},
   "source": [
    "Setiap elemen akan dari `suhu_24h` akan dicetak secara bergantian dan berurutan. Untuk mempermudah intuisi kita bisa berikan delay 1 detik untuk setiap perintah `print` agar terlihat bahwa fungsi print ini dilakukan satu per satu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "d6ef7c60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suhu sekarang adalah: 37.0\n",
      "Suhu sekarang adalah: 35.0\n",
      "Suhu sekarang adalah: 34.3\n",
      "Suhu sekarang adalah: 32.0\n",
      "Suhu sekarang adalah: 31.1\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "for elemen in suhu_24h:\n",
    "    print(\"Suhu sekarang adalah:\", elemen)\n",
    "    time.sleep(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "7af985c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suhu sekarang adalah: 310.0\n",
      "Suhu sekarang adalah: 308.0\n",
      "Suhu sekarang adalah: 307.3\n",
      "Suhu sekarang adalah: 305.0\n",
      "Suhu sekarang adalah: 304.1\n"
     ]
    }
   ],
   "source": [
    "for elemen in suhu_24h:\n",
    "    suhu_kelvin=elemen+273\n",
    "    print(\"Suhu sekarang adalah:\", suhu_kelvin)\n",
    "    time.sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21fde272",
   "metadata": {},
   "source": [
    "Sama seperti pada `conditional`, `loop` juga dapat kita buat bertingkat (*nested*), contoh apabila ingin mencetak waktu dengan perulangan jam dan menit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "a984d547",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pukul:  1 lebih:  0  menit\n",
      "Pukul:  1 lebih:  10  menit\n",
      "Pukul:  1 lebih:  20  menit\n",
      "Pukul:  1 lebih:  30  menit\n",
      "Pukul:  1 lebih:  40  menit\n",
      "Pukul:  1 lebih:  50  menit\n",
      "Pukul:  2 lebih:  0  menit\n",
      "Pukul:  2 lebih:  10  menit\n",
      "Pukul:  2 lebih:  20  menit\n",
      "Pukul:  2 lebih:  30  menit\n",
      "Pukul:  2 lebih:  40  menit\n",
      "Pukul:  2 lebih:  50  menit\n",
      "Pukul:  3 lebih:  0  menit\n",
      "Pukul:  3 lebih:  10  menit\n",
      "Pukul:  3 lebih:  20  menit\n",
      "Pukul:  3 lebih:  30  menit\n",
      "Pukul:  3 lebih:  40  menit\n",
      "Pukul:  3 lebih:  50  menit\n"
     ]
    }
   ],
   "source": [
    "menit=[0,10,20,30,40,50]\n",
    "jam=[1,2,3]\n",
    "\n",
    "for j in jam:\n",
    "    for m in menit:\n",
    "        print(\"Pukul: \",j,\"lebih: \",m,\" menit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f47dcb1",
   "metadata": {},
   "source": [
    "# 5 Fungsi dan Modul\n",
    "\n",
    "Sebelum melangkah ke penjelasan fungsi kita akan coba mengonversi pengukuran suhu kita dari celcius ke dalam derajat Fahrenheit dengan rumus:\n",
    "\n",
    "$$T_F=(\\frac{9}{5} *T_c)+32$$\n",
    "\n",
    "dengan pengetahuan kita tentang operasi kita bisa menerapkannya dalam Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "d863f4ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suhu pertama dalam C:  37.0\n",
      "Suhu pertama dalam F:  98.60000000000001\n"
     ]
    }
   ],
   "source": [
    "suhu_pertama_c=suhu_24h[0]\n",
    "\n",
    "suhu_pertama_F=(9/5*suhu_pertama_c)+32\n",
    "\n",
    "print(\"Suhu pertama dalam C: \", suhu_pertama_c)\n",
    "print(\"Suhu pertama dalam F: \", suhu_pertama_F)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c598c56",
   "metadata": {},
   "source": [
    "Kita juga bisa melakukan hal yang sama pada pengukuran yang kedua:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "1f500708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suhu kedua dalam C:  37.0\n",
      "Suhu kedua dalam F:  98.60000000000001\n"
     ]
    }
   ],
   "source": [
    "suhu_kedua_c=suhu_24h[0]\n",
    "\n",
    "suhu_kedua_F=(9/5*suhu_kedua_c)+32\n",
    "\n",
    "print(\"Suhu kedua dalam C: \", suhu_kedua_c)\n",
    "print(\"Suhu kedua dalam F: \", suhu_kedua_F)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d26a7425",
   "metadata": {},
   "source": [
    "## 5.1 Fungsi\n",
    "\n",
    "Dalam konversi suhu seperti kasus di atas kita perlu menuliskan rumus lengkap dari konversi setiap akan melakukannya. Hal seperti demikian tidak efektif, rawan terjadi error, dan susah saat akan *maintenance*. Suatu operasi yang akan dilakukan berkali-kali dapat kita definisikan sebagai sebuah fungsi agar bisa kita panggil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "ea26c958",
   "metadata": {},
   "outputs": [],
   "source": [
    "def celcius_to_fahrenheit(suhu_celcius):\n",
    "    suhu_fahrenheit=(9/5*suhu_celcius)+32\n",
    "    return suhu_fahrenheit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30241694",
   "metadata": {},
   "source": [
    "Dalam kode di atas dapat kita lihat bahwa sebuah fungsi di awali dengan `def` diikuti nama fungsi, nama fungsi kita adalah `celcius_to_fahrenheit`. Setelah nama fungsi diikuti parameter dalam tanda kurung `(suhu_celcius)`,i baris selanjutnya adalah *body* dari fungsi tersebut. Di bagian akhir kita mengembalikan variabel yang menjadi hasil dari fungsi kita.\n",
    "\n",
    "Setelah mendefinisikan fungsi `celcius_to_fahrenheit` seperti di atas kita bisa memanggilnya:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "1d6f4db9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50.0\n"
     ]
    }
   ],
   "source": [
    "suhu_celcius=10\n",
    "suhu_fahrenheit=celcius_to_fahrenheit(suhu_celcius)\n",
    "print(suhu_fahrenheit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "d71981ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59.0"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "celcius_to_fahrenheit(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6812e64b",
   "metadata": {},
   "source": [
    "Dalam penulisan sebuah fungsi disarankan kita memberikan petunjuk tentang bagaimana cara menggunakan fungsi tersebut atau sering disebut sebagai `docstring`. Petunjuk ini biasanya ditulis di bawah baris pendefinisian fungsi (yang di awali `def`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "d1f13ee4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def celcius_to_fahrenheit(suhu_celcius):\n",
    "    \"\"\"Fungsi konversi suhu Celcius ke Fahrenheit\n",
    "    Argument:\n",
    "        suhu_celcius (float/int): Suhu dalam celcius yang akan dikonversi\n",
    "    Return:\n",
    "        suhu_fahrenheit (float): Hasil konversi berupa suhu dalam Fahrenheit\n",
    "    \"\"\"\n",
    "    suhu_fahrenheit=(9/5*suhu_celcius)+32\n",
    "    return suhu_fahrenheit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3166db98",
   "metadata": {},
   "source": [
    "Petunjuk tersebut dapat kita akses dengan `?` atau dengan fungsi `help`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "78d13adc",
   "metadata": {},
   "outputs": [],
   "source": [
    "celcius_to_fahrenheit?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "615140ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function celcius_to_fahrenheit in module __main__:\n",
      "\n",
      "celcius_to_fahrenheit(suhu_celcius)\n",
      "    Fungsi konversi suhu Celcius ke Fahrenheit\n",
      "    Argument:\n",
      "        suhu_celcius (float/int): Suhu dalam celcius yang akan dikonversi\n",
      "    Return:\n",
      "        suhu_fahrenheit (float): Hasil konversi berupa suhu dalam Fahrenheit\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(celcius_to_fahrenheit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2d122af",
   "metadata": {},
   "source": [
    "## 5.2 Modul\n",
    "\n",
    "Modul secara sederhananya adalah kumpulan dari fungsi-fungsi yang bisa kita panggil. Fungsi `celcius_to_fahrenheit` di atas bisa kita masukkan ke dalam modul `temperature_conversion`. Cara membuat modul adalah dengan membuat file dengan ekstensi `.py` dengan diberi nama seperti nama modul kita. Jika modul akan kita namai `temperature_conversion` maka nama file kita adalah `temperature_conversion.py` dan akan kita simpan pada folder `utilities`, buat file `__init__.py` juga dalam folder tersebut dengan isi kosong. Selanjutkan masukkan fungsi kita ke dalam modul tersebut:\n",
    "\n",
    "![modul](figures/simple_module.png)\n",
    "\n",
    "Kita bisa panggil modul tersebut dengan perintah `import`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "70905d85",
   "metadata": {},
   "outputs": [],
   "source": [
    "import utilities.temperature_conversion as temperature_conversion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4b8dca1",
   "metadata": {},
   "source": [
    "Selanjutnya kita bisa mencoba memanggil fungsi `celcius_to_fahrenheit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "0f85d2c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.0"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperature_conversion.celcius_to_fahrenheit(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c40ba09",
   "metadata": {},
   "source": [
    "Modul `temperature_conversion` bisa kita perkaya lagi misalkan kita tambah fungsi untuk mengonversi sebaliknya yaitu dari suhu derajat Celcius ke derajat Fahrenheit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "9eda6d9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fahrenheit_to_celcius(suhu_celcius):\n",
    "    \"\"\"Fungsi konversi suhu Fahrenheit ke Celcius\n",
    "    Argument:\n",
    "        suhu_fahrenheit (float/int): Suhu dalam Fahrenheit yang akan dikonversi\n",
    "    Return:\n",
    "        suhu_celcius (float): Hasil konversi berupa suhu dalam Fahrenheit\n",
    "    \"\"\"\n",
    "    suhu_celcius=(suhu_fahrenheit-32)*5/9\n",
    "    return suhu_celcius"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc62b980",
   "metadata": {},
   "source": [
    "![temperature_conversion](figures/double_module.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6bf4014",
   "metadata": {},
   "source": [
    "Modul sebelumnya sudah kita impor dengan `import temperature_conversion`, jika isi modul tersebut berubah maka kita harus reload dengan memanfaatkan fungsi `reload` dari modul `imporlib`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "8a76eb78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'utilities.temperature_conversion' from '/media/anangsahroni/localdiskD/job/hmgi_course/material/utilities/temperature_conversion.py'>"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from importlib import reload\n",
    "\n",
    "reload(temperature_conversion)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a574afa",
   "metadata": {},
   "source": [
    "Selanjutnya kita bisa mencoba fungsi yang baru saja ditambahkan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "a25f7135",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperature_conversion.fahrenheit_to_celcius(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0020973e",
   "metadata": {},
   "source": [
    "### Modul Built-in (bawaan) Python\n",
    "\n",
    "Python memiliki beberapa modul bawaan seperti `math`, `cmath`, `os`, atau secara lebih lengkap: [Built-in modules](https://docs.python.org/3/py-modindex.html). Seperti modul buatan kita sendiri tadi, kita bisa panggil modul bawaan Python dengan perintah `import`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "fd579511",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "DESCRIPTION\n",
      "    This module provides access to the mathematical functions\n",
      "    defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(x, /)\n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "        \n",
      "        The result is between 0 and pi.\n",
      "    \n",
      "    acosh(x, /)\n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "    \n",
      "    asin(x, /)\n",
      "        Return the arc sine (measured in radians) of x.\n",
      "        \n",
      "        The result is between -pi/2 and pi/2.\n",
      "    \n",
      "    asinh(x, /)\n",
      "        Return the inverse hyperbolic sine of x.\n",
      "    \n",
      "    atan(x, /)\n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "        \n",
      "        The result is between -pi/2 and pi/2.\n",
      "    \n",
      "    atan2(y, x, /)\n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "        \n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "    \n",
      "    atanh(x, /)\n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "    \n",
      "    ceil(x, /)\n",
      "        Return the ceiling of x as an Integral.\n",
      "        \n",
      "        This is the smallest integer >= x.\n",
      "    \n",
      "    comb(n, k, /)\n",
      "        Number of ways to choose k items from n items without repetition and without order.\n",
      "        \n",
      "        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "        \n",
      "        Also called the binomial coefficient because it is equivalent\n",
      "        to the coefficient of k-th term in polynomial expansion of the\n",
      "        expression (1 + x)**n.\n",
      "        \n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "    \n",
      "    copysign(x, y, /)\n",
      "        Return a float with the magnitude (absolute value) of x but the sign of y.\n",
      "        \n",
      "        On platforms that support signed zeros, copysign(1.0, -0.0)\n",
      "        returns -1.0.\n",
      "    \n",
      "    cos(x, /)\n",
      "        Return the cosine of x (measured in radians).\n",
      "    \n",
      "    cosh(x, /)\n",
      "        Return the hyperbolic cosine of x.\n",
      "    \n",
      "    degrees(x, /)\n",
      "        Convert angle x from radians to degrees.\n",
      "    \n",
      "    dist(p, q, /)\n",
      "        Return the Euclidean distance between two points p and q.\n",
      "        \n",
      "        The points should be specified as sequences (or iterables) of\n",
      "        coordinates.  Both inputs must have the same dimension.\n",
      "        \n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))\n",
      "    \n",
      "    erf(x, /)\n",
      "        Error function at x.\n",
      "    \n",
      "    erfc(x, /)\n",
      "        Complementary error function at x.\n",
      "    \n",
      "    exp(x, /)\n",
      "        Return e raised to the power of x.\n",
      "    \n",
      "    expm1(x, /)\n",
      "        Return exp(x)-1.\n",
      "        \n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "    \n",
      "    fabs(x, /)\n",
      "        Return the absolute value of the float x.\n",
      "    \n",
      "    factorial(x, /)\n",
      "        Find x!.\n",
      "        \n",
      "        Raise a ValueError if x is negative or non-integral.\n",
      "    \n",
      "    floor(x, /)\n",
      "        Return the floor of x as an Integral.\n",
      "        \n",
      "        This is the largest integer <= x.\n",
      "    \n",
      "    fmod(x, y, /)\n",
      "        Return fmod(x, y), according to platform C.\n",
      "        \n",
      "        x % y may differ.\n",
      "    \n",
      "    frexp(x, /)\n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "        \n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "    \n",
      "    fsum(seq, /)\n",
      "        Return an accurate floating point sum of values in the iterable seq.\n",
      "        \n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "    \n",
      "    gamma(x, /)\n",
      "        Gamma function at x.\n",
      "    \n",
      "    gcd(*integers)\n",
      "        Greatest Common Divisor.\n",
      "    \n",
      "    hypot(...)\n",
      "        hypot(*coordinates) -> value\n",
      "        \n",
      "        Multidimensional Euclidean distance from the origin to a point.\n",
      "        \n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum(x**2 for x in coordinates))\n",
      "        \n",
      "        For a two dimensional point (x, y), gives the hypotenuse\n",
      "        using the Pythagorean theorem:  sqrt(x*x + y*y).\n",
      "        \n",
      "        For example, the hypotenuse of a 3/4/5 right triangle is:\n",
      "        \n",
      "            >>> hypot(3.0, 4.0)\n",
      "            5.0\n",
      "    \n",
      "    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
      "        Determine whether two floating point numbers are close in value.\n",
      "        \n",
      "          rel_tol\n",
      "            maximum difference for being considered \"close\", relative to the\n",
      "            magnitude of the input values\n",
      "          abs_tol\n",
      "            maximum difference for being considered \"close\", regardless of the\n",
      "            magnitude of the input values\n",
      "        \n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "        \n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "        \n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "    \n",
      "    isfinite(x, /)\n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "    \n",
      "    isinf(x, /)\n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "    \n",
      "    isnan(x, /)\n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "    \n",
      "    isqrt(n, /)\n",
      "        Return the integer part of the square root of the input.\n",
      "    \n",
      "    lcm(*integers)\n",
      "        Least Common Multiple.\n",
      "    \n",
      "    ldexp(x, i, /)\n",
      "        Return x * (2**i).\n",
      "        \n",
      "        This is essentially the inverse of frexp().\n",
      "    \n",
      "    lgamma(x, /)\n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "    \n",
      "    log(...)\n",
      "        log(x, [base=math.e])\n",
      "        Return the logarithm of x to the given base.\n",
      "        \n",
      "        If the base not specified, returns the natural logarithm (base e) of x.\n",
      "    \n",
      "    log10(x, /)\n",
      "        Return the base 10 logarithm of x.\n",
      "    \n",
      "    log1p(x, /)\n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "        \n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "    \n",
      "    log2(x, /)\n",
      "        Return the base 2 logarithm of x.\n",
      "    \n",
      "    modf(x, /)\n",
      "        Return the fractional and integer parts of x.\n",
      "        \n",
      "        Both results carry the sign of x and are floats.\n",
      "    \n",
      "    nextafter(x, y, /)\n",
      "        Return the next floating-point value after x towards y.\n",
      "    \n",
      "    perm(n, k=None, /)\n",
      "        Number of ways to choose k items from n items without repetition and with order.\n",
      "        \n",
      "        Evaluates to n! / (n - k)! when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "        \n",
      "        If k is not specified or is None, then k defaults to n\n",
      "        and the function returns n!.\n",
      "        \n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "    \n",
      "    pow(x, y, /)\n",
      "        Return x**y (x to the power of y).\n",
      "    \n",
      "    prod(iterable, /, *, start=1)\n",
      "        Calculate the product of all the elements in the input iterable.\n",
      "        \n",
      "        The default start value for the product is 1.\n",
      "        \n",
      "        When the iterable is empty, return the start value.  This function is\n",
      "        intended specifically for use with numeric values and may reject\n",
      "        non-numeric types.\n",
      "    \n",
      "    radians(x, /)\n",
      "        Convert angle x from degrees to radians.\n",
      "    \n",
      "    remainder(x, y, /)\n",
      "        Difference between x and the closest integer multiple of y.\n",
      "        \n",
      "        Return x - n*y where n*y is the closest integer multiple of y.\n",
      "        In the case where x is exactly halfway between two multiples of\n",
      "        y, the nearest even value of n is used. The result is always exact.\n",
      "    \n",
      "    sin(x, /)\n",
      "        Return the sine of x (measured in radians).\n",
      "    \n",
      "    sinh(x, /)\n",
      "        Return the hyperbolic sine of x.\n",
      "    \n",
      "    sqrt(x, /)\n",
      "        Return the square root of x.\n",
      "    \n",
      "    tan(x, /)\n",
      "        Return the tangent of x (measured in radians).\n",
      "    \n",
      "    tanh(x, /)\n",
      "        Return the hyperbolic tangent of x.\n",
      "    \n",
      "    trunc(x, /)\n",
      "        Truncates the Real x to the nearest Integral toward 0.\n",
      "        \n",
      "        Uses the __trunc__ magic method.\n",
      "    \n",
      "    ulp(x, /)\n",
      "        Return the value of the least significant bit of the float x.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "62b46979",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "397b7c9d",
   "metadata": {},
   "source": [
    "Modul dapat diberikan nama alias, misalkan kita ganti `math` dengan `matematika`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "04a092cb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math as matematika\n",
    "\n",
    "matematika.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "a1c4bf13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matematika.log10(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46257c2a",
   "metadata": {},
   "source": [
    "Jika sebelumnya kita langsung mengimpor modul, pada contoh dibawah kita hanya mengimpor fungsi-fungsi yang kita butuhkan saja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "01d68491",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8660254037844386\n"
     ]
    }
   ],
   "source": [
    "from math import radians, sin, cos, tan\n",
    "\n",
    "sudut=60\n",
    "sudut_radian=radians(sudut)\n",
    "sin_sudut=sin(sudut_radian)\n",
    "print(sin_sudut)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27b2da05",
   "metadata": {},
   "source": [
    "### Modul External\n",
    "\n",
    "Modul eksternal adalah modul yang dikembangkan diluar pengembang asli Python. Modul eksternal memiliki kegunaan yang spesifik dan berisi kumpulan fungsi-fungsi yang mendukung kegunaan tersebut. Modul-modul eksternal umum yang akan sering kita gunakan seperti `numpy` untuk data-data numerik, `scipy` untuk pengolahan data saintifik, `matplotlib` untuk plotting data, dan `pandas` untuk pengelolaan data. Dalam bidang yang lebih spesifik seperti pada seismologi kita mengenal modul `obspy`.\n",
    "\n",
    "Modul eksternal dapat diinstall menggunakan bantuan *package manager*, jika kita menggunakan Anaconda/Miniconda kita dapat menginstall modul dengan perintah standar di dalam Anaconda Prompt:\n",
    "\n",
    "```\n",
    "conda install [nama modul]\n",
    "```\n",
    "\n",
    "seperti:\n",
    "\n",
    "```\n",
    "conda install numpy\n",
    "```\n",
    "\n",
    "Beberapa modul perlu parameter lain seperti lokasi kanal pengunduhan (`-c`), seperti saat teman-teman menginstall Jupyter Notebook ini kemarin melalui kanal `conda-forge`:\n",
    "\n",
    "```\n",
    "conda install -c conda-forge notebook\n",
    "```\n",
    "\n",
    "Contoh penggunaan modul Numpy dan Matplotlib untuk mengolah data array dan mengeplot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "62116ecb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,  10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110, 120,\n",
       "       130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250,\n",
       "       260, 270, 280, 290, 300, 310, 320, 330, 340, 350])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "sudut=np.arange(0,360,10)\n",
    "sudut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "c7e6ab92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.17453293, 0.34906585, 0.52359878, 0.6981317 ,\n",
       "       0.87266463, 1.04719755, 1.22173048, 1.3962634 , 1.57079633,\n",
       "       1.74532925, 1.91986218, 2.0943951 , 2.26892803, 2.44346095,\n",
       "       2.61799388, 2.7925268 , 2.96705973, 3.14159265, 3.31612558,\n",
       "       3.4906585 , 3.66519143, 3.83972435, 4.01425728, 4.1887902 ,\n",
       "       4.36332313, 4.53785606, 4.71238898, 4.88692191, 5.06145483,\n",
       "       5.23598776, 5.41052068, 5.58505361, 5.75958653, 5.93411946,\n",
       "       6.10865238])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sudut_radian=np.radians(sudut)\n",
    "sudut_radian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "d099d78f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.00000000e+00,  1.73648178e-01,  3.42020143e-01,  5.00000000e-01,\n",
       "        6.42787610e-01,  7.66044443e-01,  8.66025404e-01,  9.39692621e-01,\n",
       "        9.84807753e-01,  1.00000000e+00,  9.84807753e-01,  9.39692621e-01,\n",
       "        8.66025404e-01,  7.66044443e-01,  6.42787610e-01,  5.00000000e-01,\n",
       "        3.42020143e-01,  1.73648178e-01,  1.22464680e-16, -1.73648178e-01,\n",
       "       -3.42020143e-01, -5.00000000e-01, -6.42787610e-01, -7.66044443e-01,\n",
       "       -8.66025404e-01, -9.39692621e-01, -9.84807753e-01, -1.00000000e+00,\n",
       "       -9.84807753e-01, -9.39692621e-01, -8.66025404e-01, -7.66044443e-01,\n",
       "       -6.42787610e-01, -5.00000000e-01, -3.42020143e-01, -1.73648178e-01])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sinus=np.sin(sudut_radian)\n",
    "sinus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "e20df41d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fcc62532220>]"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(sudut, sinus)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}