6-func-tuple-dict-excep.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dekomposisi\n",
    "\n",
    "seringkali terjadi problem yang besar dan komplek tidak dapat di-assign hanya ke 1 develeoper,tetapi 1 unit team devl\n",
    "Masalah harus di split menjadi beberapa bagian kepada beberapa dev utk memastikan efisiensi dan kooperasi.\n",
    "tidak hanya berbagi pekerjaan tetapi juga tentang sharing tanggung jawab"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tentang FUngsi\n",
    "\n",
    "secara umum, fungsi berasal paling sedikit  dari tempat berikut:\n",
    "\n",
    "- dari Python sendiri, beberapa func seperti print() adalah bagian integral dari Python. funct ini selalu tersedia tanpa effort tambahan dari programernya. fungsi ini disebut fungsi built-in\n",
    "selengkapnya tentang built-in function : https://docs.python.org/3/library/functions.html.\n",
    "\n",
    "- modules terinstal, banyak fungsi dan sangat berguna, namun digunakan tidak lebih banyak dibandingkan yang built-in. fungsi ini membutuhkan langkah tambahan dari programer untuk membuatnya terakses secara penuh.\n",
    "- langsung dari kode-mu. \n",
    "\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fungsi pertamamu\n",
    "\n",
    "kamu harus mendefinisikannya terlebih dahulu menggunakan kata \"define\"\n",
    "ini adalah fungsi paling sederhana:\n",
    "\n",
    "def function_name():\n",
    "function_body\n",
    "\n",
    "nb:\n",
    "- dimulai dg keyword \"def\"\n",
    "- diikuti nama fungsinya\n",
    "- setelah nama fungsi lalu diikuti tanda kurung\n",
    "- diakhiri dg titik dua \":\"\n",
    "- baris selanjutnya adalah body function\n",
    "\n",
    "contoh:\n",
    "\n",
    "def message():\n",
    "    print(\"masukkan nilai:\")\n",
    "\n",
    "untuk memanggil function, ckup panggil nama fungsinya\n",
    "\n",
    "message()\n",
    "\n",
    "berikut contoh penggunaan def pada kode yg simple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we start here\n",
      "masukkan nilai\n",
      "we end here.\n"
     ]
    }
   ],
   "source": [
    "def pesan():\n",
    "    print(\"masukkan nilai\")\n",
    "print(\"we start here\")\n",
    "pesan()\n",
    "print(\"we end here.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fungsi Parameter\n",
    "\n",
    "function mengeluarkan kekuatan penuhnya saat dilengkapi interface yang dapat menangkap data yang diberikan oleh pengguna.\n",
    "\n",
    "parameter dapat juga disebut sebagai variabel, namun ada 2 faktor yang mmbuat parameter berbeda dan spesial\n",
    "\n",
    "- parameter hanya ada di dialam fungsi yang didefinisikan terlebih dahulu, dan tempatnya ada di dalam tanda kurung statement \"def\"\n",
    "- memasukkan nilai pada parameter dilakukan dengan menentukan argumen yg sesuai\n",
    "\n",
    "nb:\n",
    "- parameter ada di dalam fungsi\n",
    "- argumen ada di luar fungsi\n",
    "\n",
    "contoh sederhana fungsi ber parameter:\n",
    "\n",
    "def pesan(nomor):\n",
    "    print(\"masukkan nomor:\", nomor)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- boleh :\n",
    "nama parameter boleh sama dg nama variabel diluar blok funct\n",
    "contoh:\n",
    "def pesan(angka):\n",
    "    print(\"masukkan angka\", angka)\n",
    "angka=2\n",
    "\n",
    "\n",
    "- tidak boleh :\n",
    "nama function tidak boleh sama dengan nama variabel( di luar blok function)\n",
    "contoh:\n",
    "def pesan():\n",
    "    print(\"enter a value: \")\n",
    "pesan=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "masukkan angka 100\n"
     ]
    }
   ],
   "source": [
    "#contoh boleh\n",
    "\n",
    "def pesan(angka):\n",
    "    print(\"masukkan angka\", angka)\n",
    "angka=300\n",
    "pesan(100)\n",
    "# output: masukkan angka 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter halo number 33434\n"
     ]
    }
   ],
   "source": [
    "# contoh function 2 parameter\n",
    "\n",
    "def pesan(what, number):\n",
    "    print(\"enter\", what, \"number\",number)\n",
    "    \n",
    "pesan(\"halo\", 33434)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Melewati parameter positional\n",
    "\n",
    "adalah teknik yang menetapkan argumen ke berapa ke parameter ke berapa yang disebut \"positional parameter passing\" ketika argumen menggunakan cara ini. hal ini yang membuatnya disebut argumen posisional\n",
    "\n",
    "misal:\n",
    "\n",
    "def halo(a,b,c):\n",
    "    print(a,b,c)\n",
    "\n",
    "halo(1,1,2)\n",
    "\n",
    "Python menawarkan cara lain utk passing argumen ditentukan oleh nama bukan dari posisi, yang dinamakan \"keyword argument passing\"\n",
    "\n",
    "contoh passing:\n",
    "\n",
    "def introduction(first_name, last_name):\n",
    "    print(\"Hello, my name is\", first_name, last_name)\n",
    "\n",
    "introduction(first_name = \"James\", last_name = \"Bond\")\n",
    "introduction(last_name = \"Skywalker\", first_name = \"Luke\")\n",
    "\n",
    "output:\n",
    "\n",
    "Hello, my name is James Bond\n",
    "Hello, my name is Luke Skywalker\n",
    "\n",
    "cara ini dengan menetapkan parameter thd valuenya dg tanda\"=\" tanpa memerhatikan posisinya."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameterized function\n",
    "\n",
    "biasanya, sebagian parameter digunakan lebih sering drpd sebagian yang lain. argumen tsb dapat dikatakan memiliki nilai default/predefined.\n",
    "\n",
    "contoh men-set default parameter :\n",
    "\n",
    "def introduction(first_name, last_name=\"Smith\"):\n",
    "    print(\"Hello, my name is\", first_name, last_name)\n",
    "\n",
    "default parameter akan diberikan jika parameter tsb tidak diisi shg otomatis diberikan oleh sistem.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nama saya joko susanto\n",
      "nama saya andres smithh\n"
     ]
    }
   ],
   "source": [
    "# assign default parameter\n",
    "def kenal(nama_depan, nama_belakang=\"smithh\"):\n",
    "    print(\"nama saya\", nama_depan, nama_belakang)\n",
    "    \n",
    "kenal(\"joko\", \"susanto\") # tidak menggunakan default\n",
    "kenal(\"andres\") # nama belakang tidak diisi, otomatis diberikan oleh sistem"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Return\n",
    "\n",
    "utk mendapatkan fungsi yang mengembalikan nilai, gunakan keyword \"return\"\n",
    "Keyword \"return\" punya 2 varian berbeda\n",
    "yaitu:\n",
    "\n",
    "- return tanpa ekspresi\n",
    "terdiri hanya keyword return itu sendiri. ketika digunakan di dalam fungsi, menyebabkan penghentian seketika dari eksekusi fungsi dan mengembalikan ke poin pemanggilan.\n",
    "nb: jika suatu fungsi tidak dimaksudkan utk menghasilkan hasil, \"return\" tidak wajib digunakan. \"return\" dapat digunakan utk menghentikan fungsi sblm mencapai baris akhir fungsi.\n",
    "\n",
    "contoh dibawah :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three...\n",
      "Two...\n",
      "One...\n",
      "Happy New Year!\n",
      "Three...\n",
      "Two...\n",
      "One...\n"
     ]
    }
   ],
   "source": [
    "def happy_new_year(wishes = True):\n",
    "    print(\"Three...\")\n",
    "    print(\"Two...\")\n",
    "    print(\"One...\")\n",
    "    if not wishes:\n",
    "        return\n",
    "    \n",
    "    print(\"Happy New Year!\")\n",
    "    \n",
    "happy_new_year() #True\n",
    "happy_new_year(False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- return dengan expression\n",
    "\n",
    "varian return kedua adalah dg penambahan ekspresi\n",
    "contoh :\n",
    "def function():\n",
    "    return expression\n",
    "\n",
    "konsekuensi dari menggunakan ini sbb:\n",
    "\n",
    "1. menyebabkan eksekusi fungsi terhenti\n",
    "2. fungsi akan mengevaluasi nilai value dan mengembalikannya\n",
    "\n",
    "contoh :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fungsi boring mengembalikan nilai yaitu:  123\n"
     ]
    }
   ],
   "source": [
    "def boring_function():\n",
    "    return 123\n",
    "x= boring_function()\n",
    "print(\"fungsi boring mengembalikan nilai yaitu: \", x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kerugian nya adalah sbb:\n",
    "\n",
    "- kamu selalu diijinkan mengabaikan hasil fungsi\n",
    "- jika fungsi dimaksudkan mengembalikan suatu nilai, itu adalah penggunaan return jenis kedua"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "None\n",
    "\n",
    "mari berkenalan dengan nilai yg sangat curious(non value) bernama \"none\"\n",
    "datanya, tidak mempresentasikan nilai apapun. untuk mengecek nilainya, silahkan cek dg snipet berikut:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'NoneType' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[7], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mNone\u001b[39;49;00m \u001b[39m+\u001b[39;49m \u001b[39m2\u001b[39;49m) \u001b[39m# menghasilkan error TypeError\u001b[39;00m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'NoneType' and 'int'"
     ]
    }
   ],
   "source": [
    "print(None + 2) # menghasilkan error TypeError"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hanya ada 2 keadaan ketika \"None\" dapat digunakan secara aman:\n",
    "- ketika meng-assign None ke variabel/ mereturn nya sebagai hasil fungsi\n",
    "- ketika kamu membandingkan nya dengan variabel utk mengecek keadaan internal\n",
    "\n",
    "seperti berikut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sorry u dont carry any value\n"
     ]
    }
   ],
   "source": [
    "value = None\n",
    "if value is None:\n",
    "    print(\"sorry u dont carry any value\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- melihat perilaku None\n",
    "- gunakan def bernama strange function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def strange_funct(n):\n",
    "    if(n%2==0):\n",
    "        return True\n",
    "    \n",
    "print(strange_funct(2))\n",
    "print(strange_funct(1))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fungsi diatas sangat mengejutkan, mungkin merupakan kesalahan dalam fungsi"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Efek dan Hasil : list dan fungsi\n",
    "\n",
    "terdapat 2 pertanyaan tambahan utk dijawab\n",
    "1. bolehkah sebuah list dikirim ke fungsi sbg argumen\n",
    "\n",
    "tentu saja boleh!  contohnya seperti ini:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "def list_sum(lst):\n",
    "    s=0\n",
    "    \n",
    "    for elem in lst:\n",
    "        s+=elem\n",
    "        \n",
    "    return s\n",
    "\n",
    "print(list_sum([5,4,3]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. bolehkah list menjadi hasil sebuah fungsi ? tentu bisa! \n",
    "coba perhatikan snippet berikut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "def strange_list_fun(n):\n",
    "    strange_list = []\n",
    "    \n",
    "    for i in range(0, n):\n",
    "        strange_list.insert(0, i)\n",
    "    \n",
    "    return strange_list\n",
    "\n",
    "print(strange_list_fun(5))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fungsi dan scopes\n",
    "\n",
    "adalah bagian dari code yang dikenali\n",
    "\n",
    "sebagai contoh, scope fungsi parameter adalah fungsi itu sendiri. parameter tidak dapat diakses di luar fungsi\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do I know that variable? 3\n",
      "99\n"
     ]
    }
   ],
   "source": [
    "def my_function():\n",
    "    var=3\n",
    "    print(\"Do I know that variable?\", var)\n",
    "\n",
    "var=99\n",
    "my_function() # var = 3\n",
    "print(var) # var = 99"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fungsi dan scopes: keyword \"global\"\n",
    "\n",
    "apakah fungsi tdk bs memodify sebuah var. diluar blok? jawabanny adalah tidak.\n",
    "namun python punya spesial metod yang dapat extend scope variabel yang memasukkan tubuh fungsi. efek tsb dikarenakan keyword bernama \"global\"\n",
    "\n",
    "global name\n",
    "global name1, name2, ...\n",
    "\n",
    "menggunakan keyword tsb di dalam sebuah fungsi, memaksa python utk membuat variabel tsb dpt diakses dr luar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do I know that variable? 2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "def my_function():\n",
    "    global var # efek keyword global\n",
    "    var = 2\n",
    "    print(\"Do I know that variable?\", var)\n",
    "\n",
    "\n",
    "var = 1\n",
    "my_function() # mengakses var=2\n",
    "print(var) # mengakses var=2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interaksi Fungsi dan Argumen\n",
    "\n",
    "perhatikan kode dibawah ini :\n",
    "\n",
    "def my_function(n):\n",
    "    print(\"I got\", n) # nilai param blm berubah\n",
    "    n += 1\n",
    "    print(\"I have\", n) # nilai param berubah\n",
    "\n",
    "\n",
    "var = 1\n",
    "my_function(var) # argumen 1,2\n",
    "print(var) # argumen 3\n",
    "\n",
    "output :\n",
    "I got 1\n",
    "I have 2\n",
    "1\n",
    "\n",
    "terlihat bahwa fungsi merubah nilai parameter berubah, apakah merubah argumen juga ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fungsi menghitung BMI\n",
    "\n",
    "def bmi(weight, height):\n",
    "    if height < 1.0 or height > 2.5 or \\\n",
    "    weight < 20 or weight > 200:\n",
    "        return None\n",
    "\n",
    "    return weight / height ** 2\n",
    "\n",
    "\n",
    "print(bmi(352.5, 1.65))\n",
    "\n",
    "# -------------\n",
    "# fungsi mengecek segitiga\n",
    "def is_a_triangle(a, b, c):\n",
    "    if a + b <= c:\n",
    "        return False\n",
    "    if b + c <= a:\n",
    "        return False\n",
    "    if c + a <= b:\n",
    "        return False\n",
    "    return True\n",
    "\n",
    "\n",
    "print(is_a_triangle(1, 1, 1))\n",
    "print(is_a_triangle(1, 1, 3))\n",
    "\n",
    "# --------------\n",
    "# fungsi fibbonaci\n",
    "#notes:\n",
    "#fib1 =1, fib2 =1, fib3=fib1+fib2, fib4= fib3+fib2,and so on\n",
    "\n",
    "def fib(n):\n",
    "    if n < 1:\n",
    "        return None\n",
    "    if n < 3:\n",
    "        return 1\n",
    "\n",
    "    elem_1 = elem_2 = 1\n",
    "    the_sum = 0\n",
    "    for i in range(3, n + 1):\n",
    "        the_sum = elem_1 + elem_2\n",
    "        elem_1, elem_2 = elem_2, the_sum\n",
    "    return the_sum\n",
    "\n",
    "\n",
    "for n in range(1, 10):  # testing\n",
    "    print(n, \"->\", fib(n))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sequence Types n Mutability\n",
    "\n",
    "sequence/ sikuense  adalah tipe data di python yang dapat simpan lebih dari 1 nilai( bahkan nilai kosong) dan nilai ini dapat dijelajahi secara berurutan elemen demi elemen. \"for\" loop adalah tools yang didesain secara khusus utk mengulang berurutan. sehingga sikuense adalah data yang dapat discan oleh \"for\" loop.\n",
    "sejauh ini, list adalah salah satu contoh sikuense yang ada di python. List adalah contoh sikuen klasik, dari sekian sikuense yang akan dipejari\n",
    "\n",
    "\n",
    "Mutability adalah salah satu properti data python yang datanya dapat diubah selama program dieksekusi. ada 2 macam data python, immutable dan mutable\n",
    "data mutable dapat diganti secara bebas dan kapan saja. \n",
    "\n",
    "immutable : data gbs diubah\n",
    "tipe data yang tidak bs diubah adalah tuple. sifatnya mirip list tetapi tdk bs diubah\n",
    "\n",
    "tuples : pake \"( )\" dan kadang cm dipisahkan pake koma per isi datanya\n",
    "list   : pake \"[ ]\"\n",
    "\n",
    "contoh:\n",
    "tupel_1 = (1,2,3,4,5,6)\n",
    "tupel2_ = 1,2,3,4,5,6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ngekoding swap\n",
    "\n",
    "var=123\n",
    "t1=(1,)\n",
    "t2=(2,)\n",
    "t3=(3,var)\n",
    "\n",
    "t1,t2,t3=t2,t3,t1"
   ]
  }
 ],
 "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
}