04. Basic Python - Part 3/04. Basic Python - Part 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Python - Part 3\n",
    "\n",
    "- If , elif, & else \n",
    "- while loops \n",
    "- for loops \n",
    "- function & lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Percabangan (If, elif, else)\n",
    "\n",
    "struktur percabangan pada python :\n",
    "\n",
    "```\n",
    "if statement_1 :\n",
    "    tugas_1\n",
    "elif statement_2 :\n",
    "    tugas_2\n",
    "else :\n",
    "    tugas_3\n",
    "    \n",
    "if (statement){\n",
    "    task1\n",
    "    task2\n",
    "}\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Struktur If "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Apakah kamu lulus? [ya/tidak]:  tidak\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kamu harus ikut ujian\n",
      "ini task 2\n"
     ]
    }
   ],
   "source": [
    "lulus = input(\"Apakah kamu lulus? [ya/tidak]: \")\n",
    "\n",
    "if lulus == \"tidak\":\n",
    "    print(\"Kamu harus ikut ujian\")\n",
    "\n",
    "print(\"ini task 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Input nilai:  65\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nilai dibawah KKM : 65\n"
     ]
    }
   ],
   "source": [
    "nilai = int(input(\"Input nilai: \"))\n",
    "\n",
    "if nilai < 70:\n",
    "    print(\"Nilai dibawah KKM : %d\" % nilai)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek kriteria lamaran kerja\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Umur :  27\n",
      "Tinggi badan :  267\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Umur 27 dan tinggi badan 267, memenuhi kriteria.\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek kriteria lamaran kerja\")\n",
    "\n",
    "umur = int(input(\"Umur : \"))\n",
    "tinggi = int(input(\"Tinggi badan : \"))\n",
    "\n",
    "if umur < 30 and tinggi > 165:\n",
    "    print(\"Umur %d dan tinggi badan %d, memenuhi kriteria.\" % (umur, tinggi))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check Password\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "password :  admin\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Password minimal 8 karakter!\n",
      "Password tidak boleh terlalu mudah\n"
     ]
    }
   ],
   "source": [
    "print(\"Check Password\")\n",
    "\n",
    "password = input(\"password : \")\n",
    "\n",
    "if len(password) <= 8:\n",
    "    print(\"Password minimal 8 karakter!\")\n",
    "if password == 'admin':\n",
    "    print(\"Password tidak boleh terlalu mudah\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Struktur if & else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Berapa umur kamu:  17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kamu belum boleh membuat SIM\n"
     ]
    }
   ],
   "source": [
    "umur = int(input(\"Berapa umur kamu: \"))\n",
    "if umur >= 18:\n",
    "    print(\"Kamu boleh membuat SIM\")\n",
    "else:\n",
    "    print(\"Kamu belum boleh membuat SIM\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek kriteria lamaran kerja\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Berapa umur kamu:  30\n",
      "Tinggi badan :  170\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Umur 30 dan tinggi badan 170, tidak memenuhi kriteria.\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek kriteria lamaran kerja\")\n",
    "\n",
    "umur = int(input(\"Berapa umur kamu: \"))\n",
    "tinggi = int(input(\"Tinggi badan : \"))\n",
    "\n",
    "if umur < 30 and tinggi > 165:\n",
    "    print(\"Umur %d dan tinggi badan %d, memenuhi kriteria.\" % (umur, tinggi))\n",
    "else :\n",
    "    print(\"Umur %d dan tinggi badan %d, tidak memenuhi kriteria.\" % (umur, tinggi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Struktur if , elif & else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Kualitas Suhu\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "suhu sekarang :  31\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "suhu panas\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek Kualitas Suhu\")\n",
    "\n",
    "suhu = int(input(\"suhu sekarang : \"))\n",
    "\n",
    "if suhu < 25 :\n",
    "    print(\"suhu dingin\")\n",
    "elif suhu < 30 :\n",
    "    print(\"suhu hangat\")\n",
    "else :\n",
    "    print(\"suhu panas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- tanpa menggunakan elif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Kualitas Suhu\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "suhu sekarang :  17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "suhu dingin\n",
      "suhu hangat\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek Kualitas Suhu\")\n",
    "\n",
    "suhu = int(input(\"suhu sekarang : \"))\n",
    "\n",
    "if suhu < 25 :\n",
    "    print(\"suhu dingin\")\n",
    "if suhu < 30 :\n",
    "    print(\"suhu hangat\")\n",
    "else :\n",
    "    print(\"suhu panas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Mengunakan operator pembanding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Kualitas Suhu\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "suhu sekarang :  27\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "suhu hangat\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek Kualitas Suhu\")\n",
    "\n",
    "suhu = int(input(\"suhu sekarang : \"))\n",
    "\n",
    "if suhu < 25 :\n",
    "    print(\"suhu dingin\")\n",
    "if suhu >= 25 and suhu < 30 :\n",
    "    print(\"suhu hangat\")\n",
    "if suhu >= 30 :\n",
    "    print(\"suhu panas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task\n",
    "# Buat program untuk menghitung nilai siswa\n",
    "# 90 - 100 = A\n",
    "# 80 - 89 = B+\n",
    "# 70 - 79 = B\n",
    "# 60 - 69 = C+\n",
    "# 50 - 59 = C\n",
    "# 40 - 49 = D\n",
    "# 0 - 39 = E "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "- Jawaban soal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Nilai Kualitatif\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inputkan nilaimu:  -10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nilai negative invalid\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek Nilai Kualitatif\")\n",
    "\n",
    "nilai = int(input(\"Inputkan nilaimu: \"))\n",
    "\n",
    "if nilai > 100:\n",
    "    print(\"nilai invalid\")\n",
    "elif nilai >= 90:\n",
    "    grade = \"A\"\n",
    "    print(\"Grade: %s\" % grade)\n",
    "elif nilai >= 80:\n",
    "    grade = \"B+\"\n",
    "    print(\"Grade: %s\" % grade)\n",
    "elif nilai >= 70:\n",
    "    grade = \"B\"\n",
    "    print(\"Grade: %s\" % grade)\n",
    "elif nilai >= 60:\n",
    "    grade = \"C+\"\n",
    "    print(\"Grade: %s\" % grade)\n",
    "elif nilai >= 50:\n",
    "    grade = \"C\"\n",
    "    print(\"Grade: %s\" % grade)\n",
    "elif nilai >= 40:\n",
    "    grade = \"D\"\n",
    "    print(\"Grade: %s\" % grade)\n",
    "elif nilai >= 0:\n",
    "    grade = \"E\"\n",
    "    print(\"Grade: %s\" % grade)\n",
    "else :\n",
    "    print(\"nilai negative invalid\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Nilai Kualitatif\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inputkan nilaimu:  75\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade: D\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek Nilai Kualitatif\")\n",
    "\n",
    "nilai = int(input(\"Inputkan nilaimu: \"))\n",
    "\n",
    "if nilai >= 90:\n",
    "    grade = \"A\"\n",
    "if nilai >= 80:\n",
    "    grade = \"B+\"\n",
    "if nilai >= 70:\n",
    "    grade = \"B\"\n",
    "if nilai >= 60:\n",
    "    grade = \"C+\"\n",
    "if nilai >= 50:\n",
    "    grade = \"C\"\n",
    "if nilai >= 40:\n",
    "    grade = \"D\"\n",
    "else:\n",
    "    grade = \"E\"\n",
    "\n",
    "print(\"Grade: %s\" % grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perbedaan multiple if statement dan elif statement\n",
    "\n",
    "- jika multiple `if` statment maka program akan cek **semua if statement** (tidak ada yang terlewatkan) dan bisa jadi semua instruksi bisa dilakukan jika memang memnuhi kondisi semua multiple if statement. \n",
    "\n",
    "\n",
    "- Namun jika `elif` statement **tidak semua dicek** (bisa semua/bisa tidak), program akan cek semua kondisi jika program masih belum menemukan yang sesuai, namun **jika ada yang sesuai** maka program akan langsung **keluar dari statement pecabangan**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Menggunakan operator membership pada statement if"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek mata kuliah IT\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "nama mata kuliah : kimia\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kimia bukan mata kuliah IT\n"
     ]
    }
   ],
   "source": [
    "print (\"Cek mata kuliah IT\")\n",
    "\n",
    "nama = input(\"nama mata kuliah :\")\n",
    "\n",
    "list_matkul = ['database', 'algoritma', 'sistem pakar', 'pemrograma web']\n",
    "\n",
    "if nama in list_matkul :\n",
    "    print(\"%s merupakan mata kuliah IT\" % nama)\n",
    "else :\n",
    "    print(\"%s bukan mata kuliah IT\" % nama)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if nama == 'database' or nama == 'algoritma' ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Makanan sehat\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "nama makanan :  jeruk\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jeruk merupakan makanan sehat\n"
     ]
    }
   ],
   "source": [
    "print(\"Cek Makanan sehat\")\n",
    "\n",
    "nama = input(\"nama makanan : \")\n",
    "\n",
    "list_makanan_tidak_sehat = ['soda', 'burger', 'gorengan', 'permen']\n",
    "\n",
    "if nama not in list_makanan_tidak_sehat :\n",
    "    print(\"%s merupakan makanan sehat\" % nama)\n",
    "else :\n",
    "    print(\"%s merupakan makanan tidak sehat\" % nama)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- nested if\n",
    "\n",
    "```\n",
    "if statement :\n",
    "    task\n",
    "    if statement :\n",
    "        task\n",
    "     else :\n",
    "        task\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Nama : yuni\n",
      "Jenis kelamin [L/P] :  P\n",
      "Hobby :  Cooking\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yuni anda memiliki hobi yang banyak disukai perempuan\n"
     ]
    }
   ],
   "source": [
    "nama = input(\"Nama :\")\n",
    "gender = input(\"Jenis kelamin [L/P] : \")\n",
    "\n",
    "if gender == 'L':\n",
    "    hobby = input(\"Hobby : \")\n",
    "    if hobby in ['Game', 'Futsal', 'Design', 'Musik']:\n",
    "        print(\"%s anda memiliki hobi yang banyak disukai laki-laki\" % nama)\n",
    "    else :\n",
    "        print(\"%s anda memiliki hobi yang unik\" % nama)\n",
    "else :\n",
    "    hobby = input(\"Hobby : \")\n",
    "    if hobby in ['Fashion', 'Cooking', 'Photography']:\n",
    "        print(\"%s anda memiliki hobi yang banyak disukai perempuan\" % nama)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perulangan mengunakan for\n",
    "\n",
    "- perulangan pada pemrograman python hanya mengimplementasikan *collection-based iteration*, \n",
    "- sehingga sebuah perulangan bisa dilakukan jika kita memiliki **iterable** object di python\n",
    "\n",
    "```\n",
    "for <var> in <iterable>:\n",
    "    <task(s)>\n",
    "\n",
    "```\n",
    "\n",
    "- Iterable pada python adalah object dalam bentuk `string`, `list`, `tuple`, `dictionary`, `set`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- contoh bentuk perulangan dari iterator `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "item 3\n",
      "item 4\n",
      "item 5\n",
      "item 6\n",
      "item 7\n",
      "item 8\n",
      "item 9\n",
      "item 10\n"
     ]
    }
   ],
   "source": [
    "myList = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "\n",
    "print(type(myList))\n",
    "\n",
    "for i in myList :\n",
    "    print (\"item\", i+2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- contoh bentuk perulangan dari iterator `tuple`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "item satu\n",
      "item dua\n",
      "item tiga\n",
      "item empat\n",
      "item lima\n"
     ]
    }
   ],
   "source": [
    "myTuple = ('satu', 'dua', 'tiga', 'empat', 'lima')\n",
    "\n",
    "print(type(myTuple))\n",
    "\n",
    "for item in myTuple :\n",
    "    print (\"item\", item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- contoh bentuk perulangan dari iterator `set`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "item dua\n",
      "item satu\n",
      "item tiga\n"
     ]
    }
   ],
   "source": [
    "mySet = {'satu', 'dua', 'tiga'}\n",
    "\n",
    "print(type(mySet))\n",
    "\n",
    "for item in mySet :\n",
    "    print (\"item\", item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- contoh bentuk perulangan dari iterator `dictionary`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "item key 1\n",
      "item key 2\n",
      "item key 3\n"
     ]
    }
   ],
   "source": [
    "myDict = {'key 1': \"value 1\", \n",
    "          'key 2': \"value 2\", \n",
    "          'key 3': \"value 3\"}\n",
    "\n",
    "print(type(myDict))\n",
    "\n",
    "for item in myDict :\n",
    "    print (\"item\", item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDict = {'satu': 1, 'dua': 2, 'tiga': 3}\n",
    "myDict.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "item 1\n",
      "item 2\n",
      "item 3\n"
     ]
    }
   ],
   "source": [
    "myDict = {'satu': 1, 'dua': 2, 'tiga': 3}\n",
    "\n",
    "print(type(myDict))\n",
    "\n",
    "for item in myDict.values() :\n",
    "    print (\"item\", item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "satu 1\n",
      "dua 2\n",
      "tiga 3\n"
     ]
    }
   ],
   "source": [
    "myDict = {'satu': 1, 'dua': 2, 'tiga': 3}\n",
    "\n",
    "print(type(myDict))\n",
    "\n",
    "for key in myDict :\n",
    "    print (key, myDict[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 2 + 4  = 6\n",
      "2 * 2 + 4  = 8\n",
      "3 * 2 + 4  = 10\n",
      "4 * 2 + 4  = 12\n",
      "5 * 2 + 4  = 14\n",
      "6 * 2 + 4  = 16\n",
      "7 * 2 + 4  = 18\n",
      "8 * 2 + 4  = 20\n"
     ]
    }
   ],
   "source": [
    "angka = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "\n",
    "for item in angka :\n",
    "    hasil = item*2 + 4\n",
    "    print (\"%d * 2 + 4  = %d\" %(item, hasil))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' *  *  * '"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * \" * \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n",
      "******\n",
      "*******\n",
      "********\n",
      "*********\n"
     ]
    }
   ],
   "source": [
    "angka = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "for i in angka :\n",
    "    print(\"*\" * i )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**********\n",
      "*********\n",
      "********\n",
      "*******\n",
      "******\n",
      "*****\n",
      "****\n",
      "***\n",
      "**\n",
      "*\n"
     ]
    }
   ],
   "source": [
    "angka = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "for i in angka :\n",
    "    print(\"*\" * (len(angka) - i ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          \n",
      "         *\n",
      "        **\n",
      "       ***\n",
      "      ****\n",
      "     *****\n",
      "    ******\n",
      "   *******\n",
      "  ********\n",
      " *********\n"
     ]
    }
   ],
   "source": [
    "angka = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "for i in angka :\n",
    "    print(\" \"* (len(angka) - i) + \"*\" *i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# task 2\n",
    "#buat perulangan for agar hasilnya sebagai berikut\n",
    "\n",
    "#**********\n",
    "# *********\n",
    "#  ********\n",
    "#   *******\n",
    "#    ******\n",
    "#     *****\n",
    "#      ****\n",
    "#       ***\n",
    "#        **\n",
    "#         *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**********\n",
      " *********\n",
      "  ********\n",
      "   *******\n",
      "    ******\n",
      "     *****\n",
      "      ****\n",
      "       ***\n",
      "        **\n",
      "         *\n"
     ]
    }
   ],
   "source": [
    "angka = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "for i in angka:\n",
    "    print(\" \" * i + \"*\" * ( len(angka) - i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- menggunakan if dalam for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 adalah ganjil\n",
      "2 adalah genap\n",
      "3 adalah ganjil\n",
      "4 adalah genap\n",
      "5 adalah ganjil\n",
      "6 adalah genap\n",
      "7 adalah ganjil\n",
      "8 adalah genap\n"
     ]
    }
   ],
   "source": [
    "angka = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "\n",
    "for item in angka :\n",
    "    if item % 2 == 0:\n",
    "        print (\"%d adalah genap\" % item)\n",
    "    else :\n",
    "        print (\"%d adalah ganjil\" % item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- for didalam for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n",
      "1 2\n",
      "1 3\n",
      "2 1\n",
      "2 2\n",
      "2 3\n",
      "3 1\n",
      "3 2\n",
      "3 3\n"
     ]
    }
   ],
   "source": [
    "angka = [1, 2, 3]\n",
    "\n",
    "for i in angka :\n",
    "    for j in angka :\n",
    "        print(i, j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "list2D = [[1, 2, 3],\n",
    "          [4, 5, 6],\n",
    "          [7, 8, 9]]\n",
    "\n",
    "for row in list2D :\n",
    "    for item in row :\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 adalah ganjil\n",
      "2 adalah genap\n",
      "3 adalah ganjil\n",
      "4 adalah genap\n",
      "5 adalah ganjil\n",
      "6 adalah genap\n",
      "7 adalah ganjil\n",
      "8 adalah genap\n",
      "9 adalah ganjil\n"
     ]
    }
   ],
   "source": [
    "list2D = [[1, 2, 3],\n",
    "          [4, 5, 6],\n",
    "          [7, 8, 9]]\n",
    "\n",
    "for row in list2D :\n",
    "    for item in row :\n",
    "        if item%2 == 0:\n",
    "            print (\"%d adalah genap\" % item)\n",
    "        else :\n",
    "            print (\"%d adalah ganjil\" % item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "users = [\n",
    "    {\n",
    "        'name' : 'john',\n",
    "        'age'  : 27,\n",
    "        'job'  : 'engineer'\n",
    "    },\n",
    "    {\n",
    "        'name' : 'budi',\n",
    "        'age'  : 30,\n",
    "        'job'  : 'guru'\n",
    "    },\n",
    "    {\n",
    "        'name' : 'sasa',\n",
    "        'age'  : 24,\n",
    "        'job'  : 'mahasiswi'\n",
    "    }\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'john', 'age': 27, 'job': 'engineer'}\n",
      "{'name': 'budi', 'age': 30, 'job': 'guru'}\n",
      "{'name': 'sasa', 'age': 24, 'job': 'mahasiswi'}\n"
     ]
    }
   ],
   "source": [
    "for user in users :\n",
    "    print(user)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name \t : john\n",
      "age \t : 27\n",
      "job \t : engineer\n",
      "--------------\n",
      "name \t : budi\n",
      "age \t : 30\n",
      "job \t : guru\n",
      "--------------\n",
      "name \t : sasa\n",
      "age \t : 24\n",
      "job \t : mahasiswi\n",
      "--------------\n"
     ]
    }
   ],
   "source": [
    "for user in users :\n",
    "    for key in user :\n",
    "        print(\"%s \\t : %s\" % (key, user[key]))\n",
    "    print(\"--------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perulangan menggunakan while\n",
    "\n",
    "- struktur dasar,\n",
    "\n",
    "```\n",
    "while <condition>:\n",
    "    <do something..>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loop ke- 0\n",
      "loop ke- 1\n",
      "loop ke- 2\n",
      "loop ke- 3\n",
      "loop ke- 4\n",
      "loop ke- 5\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i <= 5 :\n",
    "    print(\"loop ke-\", i)\n",
    "    i +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak ya\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ya\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak ya\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ya\n",
      "ya\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak ya\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ya\n",
      "ya\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak tidak\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tidak\n"
     ]
    }
   ],
   "source": [
    "data = input(\"ya/tidak\")\n",
    "\n",
    "while data == 'ya':\n",
    "    print(data)\n",
    "    data = input(\"ya/tidak\")\n",
    "    print(data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loop ke- 0\n",
      "loop ke- 1\n",
      "loop ke- 2\n",
      "loop ke- 3\n",
      "loop ke- 4\n",
      "loop ke- 5\n",
      "loop selesai\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i <= 5 :\n",
    "    print(\"loop ke-\", i)\n",
    "    i +=1\n",
    "else :\n",
    "    print(\"loop selesai\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak ya\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ya\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak ya\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ya\n",
      "ya\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak ya\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ya\n",
      "ya\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ya/tidak tidak\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tidak\n",
      "loop dihentikan karena bernilai `tidak`\n"
     ]
    }
   ],
   "source": [
    "data = input(\"ya/tidak\")\n",
    "\n",
    "while data == 'ya':\n",
    "    print(data)\n",
    "    data = input(\"ya/tidak\")\n",
    "    print(data)\n",
    "else :\n",
    "    print(\"loop dihentikan karena bernilai `tidak`\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : budi\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "budi ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : vica\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vica ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : rudi\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rudi ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : roni\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "roni tidak ada pada list nama\n"
     ]
    }
   ],
   "source": [
    "nama = input(\"input nama :\")\n",
    "\n",
    "while nama in [\"budi\", \"yuni\", \"vica\", \"rudi\"]:\n",
    "    print (\"%s ada pada list nama\" % nama)\n",
    "    \n",
    "    nama = input(\"input nama :\")\n",
    "else :\n",
    "    print (\"%s tidak ada pada list nama\" % nama)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : hany\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hany tidak ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : rudi\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rudi ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : vica\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vica ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : yuni\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yuni ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : budi\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "budi ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : hasbi\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasbi tidak ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : aska\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aska tidak ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : yunus\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yunus tidak ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : tono\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tono tidak ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : kartika\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kartika tidak ada pada list nama\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nama : yanti\n"
     ]
    }
   ],
   "source": [
    "nama = input(\"input nama :\")\n",
    "\n",
    "list_nama = [\"budi\", \"yuni\", \"vica\", \"rudi\"]\n",
    "\n",
    "i = 0\n",
    "while i < 10:\n",
    "    if nama in list_nama :\n",
    "        print (\"%s ada pada list nama\" % nama)\n",
    "    else :\n",
    "        print (\"%s tidak ada pada list nama\" % nama)\n",
    "    \n",
    "    nama = input(\"input nama :\")\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### fungsi range() \n",
    "- fungsi `range` digunakan untuk menghasilkan *sequence* angka"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n"
     ]
    }
   ],
   "source": [
    "A = range(20)\n",
    "\n",
    "print(type(A))\n",
    "print(list(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kita dapat gunakan :\n",
    "\n",
    "\n",
    "+ fungsi `list()` untuk convert object `range` menjadi list\n",
    "+ fungsi `set()` untuk convert object `range` menjadi set\n",
    "+ fungsi `tuple()` untuk convert object `range` menjadi tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "B = list(A)\n",
    "\n",
    "print(B, type(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19} <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "B = set(A)\n",
    "\n",
    "print(B, type(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "B = tuple(A)\n",
    "\n",
    "print(B, type(B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### mengunakan range() pada perulangan for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iterasi ke- 0\n",
      "iterasi ke- 1\n",
      "iterasi ke- 2\n",
      "iterasi ke- 3\n",
      "iterasi ke- 4\n",
      "iterasi ke- 5\n",
      "iterasi ke- 6\n",
      "iterasi ke- 7\n",
      "iterasi ke- 8\n",
      "iterasi ke- 9\n",
      "iterasi ke- 10\n",
      "iterasi ke- 11\n",
      "iterasi ke- 12\n",
      "iterasi ke- 13\n",
      "iterasi ke- 14\n"
     ]
    }
   ],
   "source": [
    "for i in range(15):\n",
    "    print (\"iterasi ke-\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list( range(2, 15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iterasi ke- 2\n",
      "iterasi ke- 3\n",
      "iterasi ke- 4\n",
      "iterasi ke- 5\n",
      "iterasi ke- 6\n",
      "iterasi ke- 7\n",
      "iterasi ke- 8\n",
      "iterasi ke- 9\n",
      "iterasi ke- 10\n",
      "iterasi ke- 11\n",
      "iterasi ke- 12\n",
      "iterasi ke- 13\n",
      "iterasi ke- 14\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 15):\n",
    "    print (\"iterasi ke-\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iterasi ke- 2\n",
      "iterasi ke- 6\n",
      "iterasi ke- 10\n",
      "iterasi ke- 14\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 15, 4):\n",
    "    print (\"iterasi ke-\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function pada Python\n",
    "\n",
    "```\n",
    "def function_name():\n",
    "    task1\n",
    "    task2\n",
    "    \n",
    "def function_name()\n",
    "    task1\n",
    "    task2\n",
    "    return data\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hitung(a, b):\n",
    "    c = a + b\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hasilnya adalah 9\n"
     ]
    }
   ],
   "source": [
    "hasil = hitung(5,4)\n",
    "\n",
    "print(\"hasilnya adalah %d\" % hasil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Nilai Kualitatif\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inputkan nilaimu:  76\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade: B\n"
     ]
    }
   ],
   "source": [
    "def cek_nilai(nilai):\n",
    "    if nilai >= 90:\n",
    "        grade = \"A\"\n",
    "    elif nilai >= 80:\n",
    "        grade = \"B+\"\n",
    "    elif nilai >= 70:\n",
    "        grade = \"B\"\n",
    "    elif nilai >= 60:\n",
    "        grade = \"C+\"\n",
    "    elif nilai >= 50:\n",
    "        grade = \"C\"\n",
    "    elif nilai >= 40:\n",
    "        grade = \"D\"\n",
    "    else:\n",
    "        grade = \"E\"\n",
    "\n",
    "    print(\"Grade: %s\" % grade)\n",
    "    \n",
    "    \n",
    "print(\"Cek Nilai Kualitatif\")\n",
    "\n",
    "nilai = int(input(\"Inputkan nilaimu: \"))\n",
    "\n",
    "cek_nilai(nilai)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cek Nilai Kualitatif\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Inputkan nilaimu:  97\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade: A\n"
     ]
    }
   ],
   "source": [
    "    \n",
    "print(\"Cek Nilai Kualitatif\")\n",
    "\n",
    "nilai = int(input(\"Inputkan nilaimu: \"))\n",
    "\n",
    "cek_nilai(nilai)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- default value pada function & multiple return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hitung(a, b, operasi='tambah'):\n",
    "    if operasi == 'tambah':\n",
    "        return a + b\n",
    "    elif operasi == 'kali' :\n",
    "        return a * b\n",
    "    elif operasi == 'kurang' :\n",
    "        return a - b\n",
    "\n",
    "hitung(2, 5, 'kali')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hitung(2, 5, 'kurang')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hitung(2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hitung(2, 5, 'tambah')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda function (define function anonymouse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "x = lambda a : a + 10\n",
    "print(x(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "x = lambda a, b : a * b\n",
    "print(x(5, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "x = lambda a, b, c : a + b + c\n",
    "print(x(5, 6, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = lambda a : a in [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "input nilai : 31\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31 tidak ada pada list nilai\n"
     ]
    }
   ],
   "source": [
    "data = int(input(\"input nilai :\"))\n",
    "if output(data) :\n",
    "    print(\"%d ada pada list nilai\" % data)\n",
    "else :\n",
    "    print(\"%d tidak ada pada list nilai\" % data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList = [1, 2, 3, 4]\n",
    "myFunction = lambda a, b: a in myList and b in myList "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myFunction(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myFunction(21, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}