Data Types, For, If-Else-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DATA TYPE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DATA TYPE\n",
    "\n",
    "# 1. int 10 15 2000 \n",
    "# Data dengan nilai angka biasa \n",
    "# contoh  a = 15\n",
    "\n",
    "# 2. float 3.4 5.6 \n",
    "# Data dengan nilai angka desimal\n",
    "# contoh a = 37.5\n",
    "\n",
    "# 3. str 'Rahul' \"Muliana\" \"\"\"SMBPRO12\"\"\"\n",
    "# Data dengan nilai huruf/kata/kalimat\n",
    "# contoh a = 'Rahul'\n",
    "\n",
    "# 4. list [60,89,38,58]\n",
    "# Sekumpulan Data dengan nilai dengan khas []\n",
    "# contoh a = [60,89,38,58]\n",
    "\n",
    "# 5. tuple (60,89,38,58)\n",
    "# Sekumpulan Data dengan nilai dengan khas ()\n",
    "# contoh a = (60,89,38,58)\n",
    "\n",
    "# 6. dict {\"name\":\"rahul\",\"Kelas\":\"SMBPRO12\"} -> {key1:value1, key2:value\n",
    "# Sekumpulan Data dengan nilai dengan khas terdapat key dan value pada setiap nilainya\n",
    "# contoh a = {\"name\":\"rahul\",\"Kelas\":\"SMBPRO12\"}\n",
    "\n",
    "# 7. set {10,20,30,40}\n",
    "# Sekumpulan Data dengan nilai dengan khas {} dan nilai yang ada tidak boleh sama\n",
    "# contoh a = {10,20,30,40}\n",
    "\n",
    "# 8. Bool True false\n",
    "# Data dengan nilai True atau False\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> 4381761200 [10, 20, 30, 40]\n",
      "<class 'tuple'> 4381761200 (50, 55, 60, 65, 70, 75)\n",
      "<class 'set'> 4381761200 {1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "# cara mengecek type data dari variable  menggunakan type()\n",
    "# cara mengecek lokasi memori data dari variable  menggunakan id()\n",
    "# contoh\n",
    "\n",
    "a = list(range(10,50, 10))\n",
    "b = tuple(range(50,80,5))\n",
    "c = set(range(1,10,2))\n",
    "\n",
    "print(type(a), id(a), a)\n",
    "print(type(b), id(a), b)\n",
    "print(type(c), id(a), c) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Type - Immutable / Mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMMUTABLE / MUTABLE\n",
    "\n",
    "# Immutable = Jika saya dapat merubah nilai di lokasi memori yang sama \n",
    "# Mutable = Jika saya tidak dapat merubah nilai di lokasi yang sama\n",
    "\n",
    "# Immutable :\n",
    "#     1. int\n",
    "#     2. float\n",
    "#     3. tuple\n",
    "#     4. str\n",
    "#     5. bool\n",
    "    \n",
    "# Mutable : \n",
    "#     1. list\n",
    "#     2. dict\n",
    "#     3. set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 11, 12, 13, 14] dengan lokasi memori di 4549321584\n",
      "[10, 11, 12, 13, 14, 20] dengan lokasi memori di 4549321584\n",
      "(10, 11, 12, 13, 14, 15, 16, 17, 18, 19) dengan lokasi memori di 4539180528\n",
      "13 dengan lokasi memori di 4498765312\n",
      "(10, 11, 12, 13, 14, 15, 16, 17, 18) dengan lokasi memori di 4538691152\n",
      "14 dengan lokasi memori di 4498765344\n"
     ]
    }
   ],
   "source": [
    "# contoh perbedaan mutable dan immutable\n",
    "\n",
    "# 1. list(mutable) dan tuple,int(immutable)\n",
    "\n",
    "a = list(range(10,15))\n",
    "\n",
    "print(a, \"dengan lokasi memori di\",id(a))\n",
    "\n",
    "# Menambahkan nilai 20 pada variable a menggunakan name_variable.append()\n",
    "\n",
    "a.append(20)\n",
    "print(a, \"dengan lokasi memori di\",id(a))\n",
    "\n",
    "# KESIMPULAN \n",
    "# Dengan menambahkan angka 20 pada list varirable a, lokasi variable a lokasinya masih sama\n",
    "\n",
    "#sedangkan untuk tuple dan int\n",
    "\n",
    "b = tuple(range(10,20))\n",
    "c = 13\n",
    "\n",
    "print(b, \"dengan lokasi memori di\", id(b))\n",
    "print(c, \"dengan lokasi memori di\", id(c))\n",
    "\n",
    "# Menambahkan nilai 20 menggunakan name_variable.append() akan error karena data type immutable tidak dapat \n",
    "# digunakan untuk Add, Update dan Delete \n",
    "# Bila kita menambah nilai variable b dan c dengan fungsi a = ..... maka memori tidak sama\n",
    "\n",
    "b = tuple(range(10,19))\n",
    "c = 14\n",
    "\n",
    "print(b, \"dengan lokasi memori di\", id(b))\n",
    "print(c, \"dengan lokasi memori di\", id(c))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4418466016 4418466016 4418471008 4418471008 4458801520 4458801936\n"
     ]
    }
   ],
   "source": [
    "# OBJECT INTERING CONCEPT\n",
    "\n",
    "num1 = 100\n",
    "num2 = 100\n",
    "num3 = 256\n",
    "num4 = 256\n",
    "num5 = 257\n",
    "num6 = 257\n",
    "\n",
    "print(id(num1), id(num2), id(num3), id(num4), id(num5), id(num6))\n",
    "\n",
    "# KESIMPULAN\n",
    "# Bila menyimpan nilai angka yang sama pada variable yang berbeda maka akan tersimpan di lokasi memori yang sama\n",
    "# Namun, bila nilai angka > 256 maka tidak akan tersimpan di lokasi memori yang sama"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterable data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ITERABLE DATA\n",
    "\n",
    "# 1. list[]\n",
    "# 2. tuple()\n",
    "# 3. set{}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OPERATORS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "True\n",
      "True\n",
      "True\n",
      "15\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# OPERATORS\n",
    "\n",
    "# 1. Arith Oeprators : +, -, *, /, //, **, %\n",
    "# ** = pangkat, % = modulus, // = division\n",
    "a = 9 % 3\n",
    "print(a)\n",
    "\n",
    "\n",
    "# 2. Comparison Operators : ==, !=, <, >, <=, >= \n",
    "# True/False\n",
    "b = 30\n",
    "c = 50\n",
    "print(b < c)\n",
    "\n",
    "# 3. Membership Operators : in, not in \n",
    "# After in / not in  it harus nilai koleksi atau iterable data\n",
    "# True/False\n",
    "d = list(range(1,11))\n",
    "e = 8\n",
    "print(e in d)\n",
    "\n",
    "# 4. Identity Operators : is, is not\n",
    "# is sama dengan ==, is not sama dengan != \n",
    "# True/False\n",
    "f = 15\n",
    "g = 15\n",
    "print(f is g)\n",
    "\n",
    "# 5. Assignment Operatos : =, +=, -=, *=, /=\n",
    "h = 10\n",
    "h += 5 # h = h + 3\n",
    "print(h)\n",
    "\n",
    "# 6. Logical Operators : and, or, not\n",
    "# True/False\n",
    "i = 40\n",
    "j = 50\n",
    "k = 30\n",
    "\n",
    "# AND\n",
    "# expected outputnya True,bila kedua operand harus dalam posisi True.\n",
    "print(i < j and j > k )\n",
    "\n",
    "# OR\n",
    "# expected outputnya True,bila kedua operand harus dalam posisi True dan salah satu operand dalam posisi True\n",
    "print(i < j or j < k)\n",
    "\n",
    "# NOT\n",
    "# Expected outputnya bisa True bisa False, tergantung logika yang dibangun pada code\n",
    "l = 80\n",
    "m = 50\n",
    "\n",
    "print(not(m > l))\n",
    "\n",
    "# 7. Bitwise Operators : & | >> <<"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Andi tua!\n",
      "bimo paling tua\n"
     ]
    }
   ],
   "source": [
    "# CONDITIONAL STATEMENT\n",
    "\n",
    "# 1. if\n",
    "# 2. elif\n",
    "# 3. else\n",
    "\n",
    "# 1. Kombinasi if-else\n",
    "# if [conditional]:\n",
    "#     statement/print/return -> Posisi True\n",
    "# else:\n",
    "#     statement/print/return -> Posisi False\n",
    "\n",
    "umur_andi = 30\n",
    "umur_saya = 25\n",
    "umur_bimo = 35\n",
    "\n",
    "if umur_andi > umur_saya:\n",
    "    print(\"Andi tua!\")\n",
    "else:\n",
    "    print(\"Andi masih muda\")\n",
    "\n",
    "# 2. Kombinasi if-elif-else\n",
    "# if [conditional 1]:\n",
    "#     statement/print/return -> Posisi True\n",
    "# elif [conditional ]:\n",
    "#     statement/print/return -> Posisi True/False\n",
    "# else:\n",
    "#     statement/print/return -> Posisi False\n",
    "\n",
    "if (umur_bimo < umur_andi) and (umur_bimo > umur_saya):\n",
    "    print(\"saya paling muda\")\n",
    "elif (umur_saya < umur_bimo):\n",
    "    print(\"bimo paling tua\")\n",
    "else:\n",
    "    print(\"salah semua\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  For & While (Looping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "65\n",
      "105\n",
      "150\n",
      "200\n",
      "255\n",
      "315\n",
      "380\n",
      "remedial\n",
      "remedial\n",
      "tidak remedial\n",
      "tidak remedial\n",
      "tidak remedial\n",
      "remedial\n",
      "Huruf vokal = 30 dan huruf konsonan = 34\n"
     ]
    }
   ],
   "source": [
    "# LOOPING\n",
    "\n",
    "# 1. For\n",
    "# for variable_additinal in variable itarable:\n",
    "#     statements\n",
    "\n",
    "# for\n",
    "umur = list(range(30,70,5))\n",
    "total = 0\n",
    "for kumpulan_umur in umur:\n",
    "    total = total + kumpulan_umur\n",
    "    print(total)\n",
    "\n",
    "# Kombinasi for looping + if-else + Data Integer\n",
    "nilai_ujian = list(range(60,110,10))\n",
    "nilai_ujian.append(70)\n",
    "nilai_kkm = 75\n",
    "# Bila ada nilai diatas 70 maka tidak ada ujian ulang \n",
    "for nilai_ujian_lulus in nilai_ujian:\n",
    "#     print(nilai_ujian_lulus) #Bisa di print/tidak untuk check iterasi\n",
    "    if nilai_ujian_lulus < nilai_kkm:\n",
    "        print(\"remedial\")\n",
    "    else:\n",
    "        print(\"tidak remedial\")\n",
    "        \n",
    "# Kombinasi for looping + if-else + Data String\n",
    "kalimat = \"apeladalahjenisbuahbuahanataubuahyangdihasilkandaripohonbuahapel\"\n",
    "vokal = [\"a\",\"i\",\"u\",\"e\",\"o\"]\n",
    "huruf_vokal = 0\n",
    "huruf_konsonan = 0\n",
    "for huruf in kalimat:\n",
    "    if huruf in vokal:\n",
    "        huruf_vokal += 1\n",
    "    else:\n",
    "        huruf_konsonan += 1\n",
    "print(\"Huruf vokal = {0} dan huruf konsonan = {1}\".format(huruf_vokal,huruf_konsonan))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3628800\n",
      "Saat ini i bernilai 0\n",
      "Saat ini i bernilai 1\n",
      "Saat ini i bernilai 2\n",
      "Saat ini i bernilai 3\n",
      "Saat ini i bernilai 4\n",
      "Saat ini i bernilai 5\n",
      "Saat ini i bernilai 6\n",
      "Saat ini i bernilai 7\n",
      "Saat ini i bernilai 8\n",
      "Saat ini i bernilai 9\n"
     ]
    }
   ],
   "source": [
    "# 2. While\n",
    "# While [condition]:\n",
    "#     statements\n",
    "\n",
    "num = 10\n",
    "start = 1\n",
    "\n",
    "while num > 1:\n",
    "    start = start * num\n",
    "    num = num - 1\n",
    "print(start)\n",
    "\n",
    "i = 0\n",
    "while True:\n",
    "    if i < 10:\n",
    "        print(\"Saat ini i bernilai {}\".format(i))\n",
    "        i = i + 1\n",
    "    elif i == 10:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nilai andi tidak ada\n"
     ]
    }
   ],
   "source": [
    "# BREAK AND CONTINUE - FOR AND WHILE\n",
    "\n",
    "# 1. For - Break\n",
    "nilai = [50,60,60,70,80,90,100]\n",
    "nilai_andi = 101\n",
    "\n",
    "for nilai_ujian in nilai:\n",
    "    if nilai_ujian == nilai_andi:\n",
    "        print(\"ada nilai andi\")\n",
    "        break\n",
    "else:\n",
    "    print(\"Nilai andi tidak ada\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ada angka 1\n",
      "2\n",
      "3\n",
      "Ada angka 1\n",
      "2\n",
      "8\n",
      "9\n",
      "Ada angka 1\n",
      "Ada angka 1\n"
     ]
    }
   ],
   "source": [
    "# 2. For - Continue\n",
    "b = [1,2,3,1,2,8,9,1,1]\n",
    "for a in b:\n",
    "    if a == 1:\n",
    "        print(\"Ada angka 1\")\n",
    "        continue\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# RANGE\n",
    "\n",
    "# tipe of range ;\n",
    "\n",
    "#  1. range(10): 0 1 2 3 4 5 6 7 8 9 \n",
    "#  2. range(0,5): 0 1 2 3 4 \n",
    "#  3. range(0,10,2): 0 2 4 6 8\n",
    "\n",
    "a = list(range(10))\n",
    "b = list(range(0,5))\n",
    "c = list(range(0,10,2))\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Str : \n",
    "    - '' , \" \", \"\"\" \"\"\"\n",
    "    - immutable (no add update & delete)\n",
    "    - Iterable\n",
    "    - Indexing (only 1 char)\n",
    "    - Slicing (start:end:stride)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String - Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n",
      "e\n",
      "Learning\n",
      "Learning\n",
      "Learning_python is easy\n",
      "python is easy\n",
      "python is eas\n",
      "Lann_\n",
      "ysae si nohtyp_gninraeL\n",
      "_gninraeL\n"
     ]
    }
   ],
   "source": [
    "# Mencari karakter yang ada pada kalimat menggunakan nomor index\n",
    "s = \"Learning_python is easy\"\n",
    "print(s[0]) #From left to right\n",
    "print(s[-4]) #From right to left\n",
    "print(s[0:8]) #start:end\n",
    "print(s[:8]) #start of the string\n",
    "print(s[0:]) #Full of string\n",
    "print(s[9:]) #end of the string\n",
    "print(s[9:-1])\n",
    "print(s[0:9:2])\n",
    "print(s[::-1])\n",
    "print(s[8::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String - Split and Join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Learning', 'python', 'is', 'easy', 'funny', 'lovely']\n",
      "['Learning', 'python', 'is', 'easy', 'funny', 'lovely']\n",
      "['Learninng', 'python', 'is', 'easy', 'funny', 'lovely']\n"
     ]
    }
   ],
   "source": [
    "# Memecah 1 nilai string berdasarkan spasi,koma,titik\n",
    "\n",
    "a = \"Learning python is easy funny lovely\"\n",
    "b = \"Learning,python,is,easy,funny,lovely\"\n",
    "c = \"Learninng.python.is.easy.funny.lovely\"\n",
    "\n",
    "d = a.split(\" \")\n",
    "e = b.split(\",\")\n",
    "f = c.split(\".\")\n",
    "\n",
    "print(d)\n",
    "print(e)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "a,b,c,d,e,f\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# Menggabungkan beberapa string pada list menjadi 1 nilai string\n",
    "g = ['a','b','c','d','e','f']\n",
    "print(type(g))\n",
    "h = (\",\").join(g)\n",
    "print(h)\n",
    "print(type(h))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['pohon', 'yang', 'buahnya', 'bundar,', 'berdaging', 'tebal', 'dan', 'mengandung', 'air', 'serta', 'berkulit', 'lunak', 'yang', 'warnanya', 'merah', '(kemerah-merahan)', 'atau', 'kuning', '(kekuning-kuningan),', 'jika', 'matang', 'rasanya', 'manis', 'kemasam-masaman']\n"
     ]
    }
   ],
   "source": [
    "# Contoh mengubah 1 kalimat menjadi beberapa string kata dalam 1 list\n",
    "a = \"pohon yang buahnya bundar, berdaging tebal dan mengandung air serta berkulit lunak yang warnanya merah (kemerah-merahan) atau kuning (kekuning-kuningan), jika matang rasanya manis kemasam-masaman\"\n",
    "a_kata = a.split(\" \")\n",
    "print(a_kata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String - Print .format()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anda telah menerima tata cara pendaftaran melalui email anda yaitu mulianaraul@gmail.com dengan No.Hp 081212894409\n"
     ]
    }
   ],
   "source": [
    "# Cara untuk melakukan print() sesuai variable\n",
    "\n",
    "s = \"Anda telah menerima tata cara pendaftaran melalui email anda yaitu {email} dengan No.Hp {nohp}\"\n",
    "print(s.format(email = \"mulianaraul@gmail.com\", nohp = \"081212894409\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nama saya adalah Rahul Muliana dan umur saya saat ini 24 tahun. Saya adalah seorang Data scientist di perusahaan swasta.\n"
     ]
    }
   ],
   "source": [
    "# Cara untuk melakukan print() sesuai variable diurutkan dengan index yang sesuai urutan dengan .format()\n",
    "\n",
    "nama_saya = \"Rahul Muliana\"\n",
    "umur_saya = \"24\"\n",
    "pekerjaan = \"Data scientist\"\n",
    "\n",
    "print(\"nama saya adalah {0} dan umur saya saat ini {1} tahun. Saya adalah seorang {2} di perusahaan swasta.\".format(nama_saya,umur_saya,pekerjaan))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String - upper() / lower() / title() / capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apakah nilai pada var_profile huruf besar semua? jawabannya adalah False\n",
      "NAMA SAYA ADALAH RAHUL MULIANA, SAYA LAHIR DI KEDIRI TANGGAL 31 OKTOBER 1997\n"
     ]
    }
   ],
   "source": [
    "# Mengubah karakter string menjadi huruf kecil semua dengan .upper()\n",
    "\n",
    "var_profile = \"Nama saya adalah Rahul Muliana, saya lahir di Kediri tanggal 31 Oktober 1997\"\n",
    "\n",
    "#Mengecek apakah variable var_profile memiliki nilai string yang hurufnya besar semua?\n",
    "pertanyaan = \"apakah nilai pada var_profile huruf besar semua? jawabannya adalah {tidak}\" \n",
    "print(pertanyaan.format(tidak = var_profile.isupper()))\n",
    "\n",
    "#Mengubah nilai pada var_profile menjadi huruf kecil semua\n",
    "var_profile_upper = var_profile.upper()\n",
    "print(var_profile_upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apakah nilai pada var_profile huruf kecil semua? jawabannya adalah False\n",
      "nama saya adalah rahul muliana, saya lahir di kediri tanggal 31 oktober 1997\n"
     ]
    }
   ],
   "source": [
    "# Mengubah karakter string menjadi huruf kecil semua dengan .lower()\n",
    "\n",
    "var_profile = \"Nama saya adalah Rahul Muliana, saya lahir di Kediri tanggal 31 Oktober 1997\"\n",
    "\n",
    "#Mengecek apakah variable var_profile memiliki nilai string yang hurufnya kecil semua?\n",
    "pertanyaan = \"apakah nilai pada var_profile huruf kecil semua? jawabannya adalah {tidak}\" \n",
    "print(pertanyaan.format(tidak = var_profile.islower()))\n",
    "\n",
    "#Mengubah nilai pada var_profile menjadi huruf kecil semua\n",
    "var_profile_lower = var_profile.lower()\n",
    "print(var_profile_lower)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apakah nilai pada var_profile huruf dengan konsep title? jawabannya adalah False\n",
      "Nama Saya Adalah Rahul Muliana, Saya Lahir Di Kediri Tanggal 31 Oktober 1997\n"
     ]
    }
   ],
   "source": [
    "# Mengubah karakter string menjadi huruf kecil semua dengan .title()\n",
    "\n",
    "var_profile = \"Nama saya adalah Rahul Muliana, saya lahir di Kediri tanggal 31 Oktober 1997\"\n",
    "\n",
    "#Mengecek apakah variable var_profile memiliki nilai string yang hurufnya dengan konsep title?\n",
    "pertanyaan = \"apakah nilai pada var_profile huruf dengan konsep title? jawabannya adalah {tidak}\" \n",
    "print(pertanyaan.format(tidak = var_profile.istitle()))\n",
    "\n",
    "#Mengubah nilai pada var_profile menjadi huruf dengan konsep title\n",
    "var_profile_title = var_profile.title()\n",
    "print(var_profile_title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nama saya adalah rahul muliana, saya lahir di kediri tanggal 31 oktober 1997\n"
     ]
    }
   ],
   "source": [
    "# Mengubah karakter string menjadi huruf kecil semua dengan .capitalize()\n",
    "\n",
    "var_profile = \"Nama saya adalah Rahul Muliana, saya lahir di Kediri tanggal 31 Oktober 1997\"\n",
    "\n",
    "#Mengubah nilai pada var_profile menjadi huruf dengan konsep kapital\n",
    "var_profile_capitalize = var_profile.capitalize()\n",
    "print(var_profile_capitalize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String - .find() / .replace() / .count() / .strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### .find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# Mencari satu kata dalam satu kalimat string, apabila kata tersebut ada maka outputnya posisi index\n",
    "# Apabila kata yang dicari tidak ada maka outputnya yaitu -1\n",
    "\n",
    "nama = \"rahul aggil risma waliji mutyawati\"\n",
    "print(nama.find(\"aggil\"))\n",
    "print(nama.find(\"radin\")) # kata yang dicari tidak ada dalam string kalimat di variable nama"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ada kata tersebut\n"
     ]
    }
   ],
   "source": [
    "# Bila kalimat pada variable string panjang dapat menggunakan conditional statement\n",
    "# Untuk mencari apakah ada kata yang dicari dalam kalimat tersebut\n",
    "\n",
    "nama = \"rahul maurica aggil zhifa risma nasya radin ayah ibu\"\n",
    "result_nama = nama.find(\"radin\")\n",
    "\n",
    "if result_nama != -1:\n",
    "    print(\"Ada kata tersebut\")\n",
    "else:\n",
    "    print(\"Tidak ada kata tersebut\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### .replace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ada nama ibu\n",
      "rahul maurica aggil mutyawati ayah zhifa risma nasya radin ayah mutyawati\n",
      "rahul maurica aggil mutyawati ayah zhifa risma nasya radin ayah ibu\n"
     ]
    }
   ],
   "source": [
    "# Melakukan check apakah dalam variable kalimat tersebut ada kata ibu?\n",
    "nama = \"rahul maurica aggil ibu ayah zhifa risma nasya radin ayah ibu\"\n",
    "nama_split = nama.split()\n",
    "# print(nama_split)\n",
    "if \"ibu\" in nama_split:\n",
    "    print(\"ada nama ibu\")\n",
    "else:\n",
    "    print(\"tidak ada nama ibu\")\n",
    "\n",
    "# Mengganti semua kata ibu dengan mutyawati\n",
    "nama_ibu_change_mutya = nama.replace(\"ibu\",\"mutyawati\")\n",
    "print(nama_ibu_change_mutya)\n",
    "\n",
    "# Mengganti 1 kata ibu dengan mutyawati\n",
    "nama_ibu_change_mutya = nama.replace(\"ibu\",\"mutyawati\",1)\n",
    "print(nama_ibu_change_mutya)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### .count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Untuk nama maurica terdapat 4 buah nama\n"
     ]
    }
   ],
   "source": [
    "# mencari jumlah kata yang terduplikasi dalam 1 kalimat string\n",
    "nama = \"rahul maurica aggil ibu maurica ayah zhifa  mauricarisma nasya radin ayah ibu maurica\"\n",
    "nama_duplikasi_maurica = nama.count(\"maurica\")\n",
    "print(\"Untuk nama maurica terdapat {duplikasi} buah nama\".format(duplikasi = nama_duplikasi_maurica))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    }
   ],
   "source": [
    "# Mencari jumlah huruf yang terduplikasi dalam 1 kalimat string\n",
    "huruf_acak = \"askdjhaksdhausdiahsduaisdhiahdishiaudakhskdahkdhsakdshakhdkaskjdhakhksakkaakjahkahkahkahkaha\"\n",
    "a_jumlah = 0\n",
    "m_jumlah = 0\n",
    "for huruf in huruf_acak:\n",
    "    if huruf in \"abcdefghijklmnopqrstuvwxyz\" and huruf == \"a\":\n",
    "        a_jumlah += 1\n",
    "print(a_jumlah)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 14\n"
     ]
    }
   ],
   "source": [
    "# Mencari jumlah huruf yang terduplikasi paling banyak dalam 1 kalimat string\n",
    "huruf_acak = \"kajhgjagdasdgfdsfkhkdshghgiuuhahsihasdhiddishfahiudhiaugsigfsifaoahsaohfjagdjagsjgajsha\"\n",
    "max_huruf = \"\"\n",
    "max_jumlah = 0\n",
    "\n",
    "for huruf in huruf_acak:\n",
    "    huruf_jumlah = huruf_acak.count(huruf)\n",
    "    if huruf_jumlah > max_jumlah:\n",
    "        max_huruf,max_jumlah = huruf,huruf_jumlah\n",
    "print(max_huruf,max_jumlah)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### .strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul Muliana\n"
     ]
    }
   ],
   "source": [
    "# Menghilangkan spasi yang banyak serta karakter lain pada awal kata atau akhir kata \n",
    "\n",
    "nama = \"                                Rahul Muliana________________________\"\n",
    "nama_change_1 = nama.strip(\" \")\n",
    "nama_change_2 = nama_change_1.strip(\"_\")\n",
    "print(nama_change_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String - Computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foobar\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Mencari kata pada hasil komputasi string\n",
    "\n",
    "s = \"foo\"\n",
    "t = \"bar\"\n",
    "print(s+t)\n",
    "\n",
    "print(\"rfoo\" in 2 * (s+t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String - ord() and chr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nilai angka dari huruf a adalah 97\n",
      "nilai angka dari huruf z adalah 122\n"
     ]
    }
   ],
   "source": [
    "# ord() digunakan untuk mencari tahu nilai dari huruf a-z\n",
    "print(\"nilai angka dari huruf a adalah {a}\".format(a = ord(\"a\")))\n",
    "print(\"nilai angka dari huruf z adalah {z}\".format(z = ord(\"z\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "huruf dari nilai angka 115 adalah s\n"
     ]
    }
   ],
   "source": [
    "# chr() digunakan untuk mencari tahu hururf dari nilai 97-122\n",
    "print(\"huruf dari nilai angka 115 adalah {huruf}\".format(huruf = chr(115)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List\n",
    "    - [10,20,30,\"Python,{1:1,2:2},[1,2,3,4,5]] Di dalam list boleh ada data tipe macam-macam\n",
    "    - mutable (bisa di Add, update dan dihapus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "[100, 200, 300, 400]\n",
      "[100, 200, 300]\n"
     ]
    }
   ],
   "source": [
    "# Mendapatkan nilai dari data list menggunakan indexing\n",
    "l = [\"Python\",\"java\",10,20,30,[100,200,300,400]]\n",
    "print(l[0])\n",
    "print(l[-1])\n",
    "print(l[-1][0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List - Add - .append() / .extend() / .insert()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Add .append()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50, 60, 70, 80, 'nilai remedial']\n"
     ]
    }
   ],
   "source": [
    "# Menambah 1 nilai pada data list\n",
    "# Untuk menambah banyak nilai harus dilakukan dengan berkali kali secara manual dengan .append()\n",
    "nilai_uts = [50,60,70]\n",
    "nilai_uts.append(80)\n",
    "nilai_uts.append(\"nilai remedial\")\n",
    "print(nilai_uts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Add .extend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50, 60, 50, 60, 70, 80, 90, 90, 90, 80, 90]\n",
      "[50, 60, 50, 60, 70, 'c', 'c', 'b', 'c', 'a', 'b', 'c']\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Menambahkan beberapa nilai menggunakan data list pada data list dengan metode iterasi\n",
    "nilai_ujian = [50,60,50,60,70]\n",
    "nilai_latihan = [80,90,90,90,80,90]\n",
    "nilai_ujian.extend(nilai_latihan)\n",
    "print(nilai_ujian)\n",
    "\n",
    "# Menambahkan beberapa nilai menggunakan data string pada data list dengan metode iterasi\n",
    "nilai_ujian = [50,60,50,60,70]\n",
    "nilai_alphabet = 'ccbcabc'\n",
    "nilai_ujian.extend(nilai_alphabet)\n",
    "print(nilai_ujian)\n",
    "\n",
    "# Contoh\n",
    "# Output yang diminta => l2 = [1,2,3,4,5,6,7,8,9]\n",
    "l = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "\n",
    "l2 = []\n",
    "for value in l:\n",
    "    l2.extend(value)\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Add .insert()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50, 60, 50, 60, 70, 'a', 100]\n"
     ]
    }
   ],
   "source": [
    "# Menambahkan nilai int/string pada data list sesuai dengan posisi index yang diingignkan\n",
    "nilai_ujian = [50,60,50,60,70]\n",
    "nilai_ujian.insert(5,\"a\")\n",
    "nilai_ujian.insert(6,100)\n",
    "print(nilai_ujian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List - Iterasi for dengan zip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(70, 'A', 'rahul')\n",
      "(70, 'B', 'aggil')\n",
      "(80, 'C', 'radin')\n",
      "(80, 'B', 'risma')\n"
     ]
    }
   ],
   "source": [
    "# Penggabungan nilai pada iterable data berdasarkan indexnya\n",
    "nilai_ujian = [70,70,80,80,90]\n",
    "nilai_alphabet = \"ABCBA\"\n",
    "nama = [\"rahul\", \"aggil\",\"radin\",\"risma\"]\n",
    "for value in zip(nilai_ujian,nilai_alphabet,nama):\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([70, 80, 90], [1, 2, 3])\n",
      "([50, 60, 70], [1, 2, 3])\n",
      "([60, 70, 80], [1, 2, 3])\n",
      "Outputnya adalah [[71, 82, 93], [51, 62, 73], [61, 72, 83]]\n"
     ]
    }
   ],
   "source": [
    "# Contoh iterasi kompleks menggunakan zip\n",
    "# Output yang dihasilkan l3 = [[71,82,93],[51,62,73],[61,72,83]]\n",
    "\n",
    "nilai_ujian = [[70,80,90,],[50,60,70],[60,70,80]]\n",
    "point_harian = [[1,2,3],[1,2,3],[1,2,3]]\n",
    "nilai_total = []\n",
    "# 1. melakukan check bila 2 variable dilakukan zip\n",
    "for a in zip(nilai_ujian,point_harian):\n",
    "    print(a)\n",
    "\n",
    "# 2. Melakukan iterasi\n",
    "for list_1,list_2 in zip(nilai_ujian,point_harian):\n",
    "    variable_temporary = []\n",
    "    for var_1,var_2 in zip(list_1,list_2):\n",
    "#         print(var_1,var_2)\n",
    "        variable_temporary.append(var_1 + var_2)\n",
    "#         print(variable_temporary)\n",
    "    nilai_total.append(variable_temporary)\n",
    "print(\"Outputnya adalah {output}\".format(output = nilai_total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List - Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[70, 80, 100, 90]\n"
     ]
    }
   ],
   "source": [
    "# Melakukan update nilai pada data list\n",
    "nilai_ujian = [70,80,50,90]\n",
    "nilai_ujian[2] = 100\n",
    "print(nilai_ujian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List - Delete - .pop() / .remove() / .clear() / .del()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List - Delete - .pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[80, 80, 70, 80, 100]\n",
      "nilai yang dihapus adalah 90\n"
     ]
    }
   ],
   "source": [
    "# Melakukan penghapusan nilai berdasarkan index dan nilai yang dihapus dapat disimpan dalam 1 variable (cut system)\n",
    "nilai_ujian = [80,80,70,80,90,100]\n",
    "nilai_dihapus = nilai_ujian.pop(-2)\n",
    "print(nilai_ujian)\n",
    "print(\"nilai yang dihapus adalah {nilai}\".format(nilai = nilai_dihapus))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List - Delete - .remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[80, 80, 80, 90, 100]\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Melakukan penghapusan nilai pada data list berdasarkan nilai tersebut\n",
    "nilai_ujian = [80,80,70,80,90,100]\n",
    "nilai_dihapus = nilai_ujian.remove(70)\n",
    "print(nilai_ujian)\n",
    "print(nilai_dihapus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[60, 60, 70, 80, 70, 80, 90]\n"
     ]
    }
   ],
   "source": [
    "# Melakukan penghapusan nilai pada data list dengan iterasi berdasarkan nilai tersebut\n",
    "nilai_ujian = [50,60,50,60,70,80,70,80,50,90]\n",
    "for nilai_lulus in nilai_ujian:\n",
    "    if nilai_lulus == 50:\n",
    "        nilai_ujian.remove(50)\n",
    "print(nilai_ujian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List - Delete - .clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Melakukan penghapusan semua nilai dalam data list\n",
    "nilai_ujian = [80,80,70,80,90,100]\n",
    "nilai_ujian.clear()\n",
    "print(nilai_ujian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List - Delete - del"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'nilai_harian' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-256-e942e1196e9d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mnilai_harian\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m70\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m70\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m70\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m80\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m90\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mnilai_harian\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnilai_harian\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'nilai_harian' is not defined"
     ]
    }
   ],
   "source": [
    "# Melakukan penghapusan variable sehingga variable tidak dapat dipanggil kembali\n",
    "nilai_harian = [70,70,70,80,90]\n",
    "del nilai_harian\n",
    "print(nilai_harian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List - .count() / .sort() / len()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List - .count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jumlah nama rahul pada variable name_member adalah 4\n"
     ]
    }
   ],
   "source": [
    "# Mendapatkan jumlah nilai yang sama pada data list\n",
    "name_member = [\"rahul\",\"rahul\",\"aggil\",\"radin\",\"mutyawati\",\"rahul\",\"rahul\"]\n",
    "jumlah_name = name_member.count(\"rahul\")\n",
    "print(\"jumlah nama rahul pada variable name_member adalah {jumlah}\".format(jumlah = jumlah_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List - .sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['aggil', 'mutyawati', 'radin', 'rahul', 'rahul', 'rahul', 'rahul']\n",
      "[23, 23, 23, 23, 25, 31, 50]\n"
     ]
    }
   ],
   "source": [
    "# Mendapatkan data yang berurutan dari awalan kata huruf A - Z\n",
    "name_member = [\"rahul\",\"rahul\",\"aggil\",\"radin\",\"mutyawati\",\"rahul\",\"rahul\"]\n",
    "name_member.sort()\n",
    "print(name_member)\n",
    "\n",
    "# Mendapatkan data yang berurutan dari yang paling kecil hingga paling besar\n",
    "age_member = [23,23,25,31,50,23,23]\n",
    "age_member.sort()\n",
    "print(age_member)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List - len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jumlah nilai pada data list name_member adalah 15 nilai dan tipe variable nya adalah <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Mendapatkan jumlah data yang ada pada data list\n",
    "name_member = [\"rahul\",\"rahul\",\"aggil\",\"radin\",\"mutyawati\",\"rahul\",\"rahul\",23,23,25,31,50,23,23,[2,3]]\n",
    "a = len(name_member)\n",
    "print(\"jumlah nilai pada data list name_member adalah {jumlah_nilai} nilai dan tipe variable nya adalah {tipe}\".format(jumlah_nilai = a, tipe = type(a)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple\n",
    "    - ()\n",
    "    - immutable (tidak bisa di Add, update dan dihapus)\n",
    "    - t = (\"Python\",10,20,30,40,50,[100,200,300],(10,20),{'name':'raul'}) Di dalam tuple boleh ada data tipe macam-macam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "3\n",
      "(10, 20, 30, [40, 4, 20, 30], 4005)\n",
      "[40, 4]\n"
     ]
    }
   ],
   "source": [
    "# Mendapatkan nilai dari data list menggunakan indexing\n",
    "var_tuple = (10,20,30,[40,4,20,30],4005,0,3)\n",
    "print(var_tuple[1])\n",
    "print(var_tuple[-1])\n",
    "print(var_tuple[0:5])\n",
    "print(var_tuple[-4][0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dict\n",
    "    - pola data dict yaitu selalu ada \"key\" dan \"value\" {\"key1\":\"value1\",\"key2\":\"value2\"}\n",
    "    - semua \"key\" bersifat unik atau tidak boleh sama\n",
    "    - semua nilai dari \"key\" adalah immutable (str,int,tuple,float)\n",
    "    - mutable (bisa di Add, update dan dihapus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rahul\n"
     ]
    }
   ],
   "source": [
    "# Melakukan pencarian nilai pada data dict berdasarkan key dengan menggunakan cara manual\n",
    "form = {\"name\":\"rahul\",\"email\":\"mulianaraul@gmail.com\",\"nohp\":\"081212894409\",\"age\":\"23\"}\n",
    "print(form['name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'salary'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-327-b6faf445d4ab>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mform\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"name\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\"rahul\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"email\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\"mulianaraul@gmail.com\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"nohp\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\"081212894409\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"age\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\"23\"\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mform\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'salary'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'salary'"
     ]
    }
   ],
   "source": [
    "# Melakukan pencarian nilai pada data dict berdasarkan key dengan menggunakan cara manual\n",
    "# Jika key tidak disesuai dengan key yang ada pada data dict tsb maka akan  error\n",
    "\n",
    "form = {\"name\":\"rahul\",\"email\":\"mulianaraul@gmail.com\",\"nohp\":\"081212894409\",\"age\":\"23\"}\n",
    "print(form['salary'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict - .get()\n",
    "Untuk melakukan check apakah terdapat nama key yang dicari dalam data dict tersebut. Bila tidak ada maka outputnya yaitu \"None\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nilai pada key name adalah rahul\n",
      "Pendidikan terakhir rahul yaitu None\n"
     ]
    }
   ],
   "source": [
    "# Melakukan pencarian nilai pada data dict berdasarkan key dengan menggunakan .get(\"key_names\")\n",
    "\n",
    "form = {\"name\":\"rahul\",\"email\":\"mulianaraul@gmail.com\",\"nohp\":\"081212894409\",\"age\":\"23\"}\n",
    "var_name = form.get(\"name\")\n",
    "var_pendidikan = form.get(\"pendidikan\")\n",
    "print(\"Nilai pada key name adalah {name}\".format(name = var_name))\n",
    "print(\"Pendidikan terakhir rahul yaitu {pendidikan}\".format(pendidikan = var_pendidikan))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict - .setdefault(key,value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "sma\n",
      "{'name': 'rahul', 'email': 'mulianaraul@gmail.com', 'nohp': '081212894409', 'age': '23', 'jenis_kelamin': None, 'pendidikan_akhir': 'sma'}\n"
     ]
    }
   ],
   "source": [
    "# Melakukan pencarian nilai pada data dict berdasarkan key dengan menggunakan .setdefaut()\n",
    "# Apabila key yang dicari tidak ada dalam daftar key pada data dict, maka kkey tersebut secara otomatis ter input\n",
    "# Oleh karena itu, .setdefault() dapat digunakan juga untuk menambahkan key dan value pada data dict\n",
    "\n",
    "form = {\"name\":\"rahul\",\"email\":\"mulianaraul@gmail.com\",\"nohp\":\"081212894409\",\"age\":\"23\"}\n",
    "print(form.setdefault(\"jenis_kelamin\"))\n",
    "print(form.setdefault(\"pendidikan_akhir\",\"sma\"))\n",
    "print(form)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101, 'f': 102, 'g': 103, 'h': 104, 'i': 105, 'j': 106, 'k': 107, 'l': 108, 'm': 109, 'n': 110, 'o': 111, 'p': 112, 'q': 113, 'r': 114, 's': 115, 't': 116, 'u': 117, 'v': 118, 'w': 119, 'x': 120, 'y': 121, 'z': 122} {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}\n"
     ]
    }
   ],
   "source": [
    "# Melakukan input key dan value kedalam variable data dict yang masih kosong dengan iterasi\n",
    "\n",
    "alpha_num = {}\n",
    "for value in range(ord('a'),ord('z')+1):\n",
    "    alpha_num.setdefault(chr(value),value)\n",
    "\n",
    "num_numsquare = {}\n",
    "for value in range(1,10+1):\n",
    "    num_numsquare.setdefault(value,value**2)\n",
    "    \n",
    "    \n",
    "print(alpha_num,num_numsquare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(1, 10): 0, (11, 20): 0, (21, 30): 0, (31, 40): 0, (41, 50): 0, (51, 60): 0, (61, 70): 0, (71, 80): 0, (81, 90): 0, (91, 100): 0}\n",
      "{(1, 10): 0, (11, 20): 0, (21, 30): 0, (31, 40): 0, (41, 50): 1, (51, 60): 0, (61, 70): 0, (71, 80): 0, (81, 90): 0, (91, 100): 0}\n"
     ]
    }
   ],
   "source": [
    "# Contoh advanced .setdefault()\n",
    "\n",
    "data_dict = {}\n",
    "for key in zip(range(1,92,10),range(10,101,10)):\n",
    "    data_dict.setdefault(key,0)\n",
    "print(data_dict)\n",
    "    \n",
    "num = 44\n",
    "for data in data_dict:\n",
    "    if num >= data[0] and num <= data[1]:\n",
    "        data_dict[data] = data_dict.get(data) +1\n",
    "        break\n",
    "print(data_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict - .keys() / .values() / .items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n",
      "g\n",
      "h\n",
      "i\n",
      "j\n",
      "k\n",
      "l\n",
      "m\n",
      "n\n",
      "o\n",
      "p\n",
      "q\n",
      "r\n",
      "s\n",
      "t\n",
      "u\n",
      "v\n",
      "w\n",
      "x\n",
      "y\n",
      "z\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# Untuk mengetahui jumlah dan nama key yang ada pada data dict dengan .keys()\n",
    "for data_key in alpha_num.keys():\n",
    "    print(data_key)\n",
    "print(type(data_key)) # Bila ingin mengambil key pada data dict lalu menjadikannya ke string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122])\n"
     ]
    }
   ],
   "source": [
    "# Untuk mengetahui jumlah dan values yang ada pada data dict dengan .values()\n",
    "print(alpha_num.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('a', 97), ('b', 98), ('c', 99), ('d', 100), ('e', 101), ('f', 102), ('g', 103), ('h', 104), ('i', 105), ('j', 106), ('k', 107), ('l', 108), ('m', 109), ('n', 110), ('o', 111), ('p', 112), ('q', 113), ('r', 114), ('s', 115), ('t', 116), ('u', 117), ('v', 118), ('w', 119), ('x', 120), ('y', 121), ('z', 122)])\n"
     ]
    }
   ],
   "source": [
    "# Untuk menampilkan key dan value pada data dict dengan .items()\n",
    "print(alpha_num.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict - Delete - .pop() / .popitem() / .clear() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict - .pop() | Menghapus key dan value pada data dict berdasarkan key nya"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nama': 'rahul', 'usia': '23', 'status': 'Belum Menikah'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'usia': '23', 'status': 'Belum Menikah'}"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_formulir = {\"nama\":\"rahul\",\"usia\":\"23\",\"status\":\"Belum Menikah\"}\n",
    "print(data_formulir)\n",
    "data_formulir.keys() #Mengetahu isi apa saja key pada data dict\n",
    "data_formulir.pop(\"nama\")\n",
    "data_formulir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dict - .popitem() | Menghapus key dan value yang terakhir pada data dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('pekerjaan', 'karyawan') {'usia': '23', 'status': 'Belum Menikah', 'nama': 'rahul'}\n"
     ]
    }
   ],
   "source": [
    "data_formulir\n",
    "data_formulir.setdefault(\"nama\",\"rahul\") # Menambah key and value nama rahul\n",
    "data_formulir\n",
    "data_formulir.setdefault(\"pekerjaan\",\"karyawan\") # Menambah key and value pekerjaan karyawan\n",
    "data_formulir\n",
    "data_pekerjaan = data_formulir.popitem()\n",
    "data_pekerjaan\n",
    "\n",
    "\n",
    "print(data_pekerjaan,data_formulir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict - .update() | Menambah data key dan value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'usia': '23',\n",
       " 'status': 'Belum Menikah',\n",
       " 'nama': 'rahul',\n",
       " 'pekerjaan': 'karyawan',\n",
       " 'pendidikan': 'S1'}"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_formulir_baru = {\"pekerjaan\":\"karyawan\",\"pendidikan\":\"S1\"}\n",
    "data_formulir.update(data_formulir_baru) # Menambah key dan value \n",
    "data_formulir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set\n",
    "    - {10,20,30,40,50} semua elemen harus unik tidak boleh ada yang sama\n",
    "    - tidak bisa indexing ataupun slicing\n",
    "    - mutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set - .union() / .intersection() / .difference() / .symetric_difference() / .subset() / .superset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = {10,20,30,40,50,60,}\n",
    "s2 = {40,50,60,70,80,90}\n",
    "\n",
    "# s1 union s2 = {10,20,30,40,50,60,70,80,90}\n",
    "# s1 intersection s2 = {40,50,60}\n",
    "# s1 difference s2 = {10,20,30}\n",
    "# s1 symmetric difference = {10,20,30,70,80,90}\n",
    "\n",
    "s3 = {10,20}\n",
    "\n",
    "# s3 issubset of s1 = answer will True or False\n",
    "# s1 issuperset of s3 = answer will True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{70, 40, 10, 80, 50, 20, 90, 60, 30}\n"
     ]
    }
   ],
   "source": [
    "s3 = s1.union(s2)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{40, 50, 60}\n"
     ]
    }
   ],
   "source": [
    "s3 = s1.intersection(s2)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{10, 20, 30}\n"
     ]
    }
   ],
   "source": [
    "s3 = s1.difference(s2)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{70, 10, 80, 20, 90, 30}\n"
     ]
    }
   ],
   "source": [
    "s3 = s1.symmetric_difference(s2)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "s3 = {10,20}\n",
    "\n",
    "print(s3.issubset(s1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "s3 = {10,20}\n",
    "\n",
    "print(s1.issuperset(s3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set - sorted() | Mengurutkan value dari terkecil hingga terbesar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50, 60, 70, 80, 90]\n"
     ]
    }
   ],
   "source": [
    "var_score = {70,40,10,80,50,20,90,60,30}\n",
    "var_newscore = sorted(var_score)\n",
    "print(var_newscore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set - Delete - .remove() / .discard() / .pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "100",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-140-4a386b8fa72c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvar_score\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 100"
     ]
    }
   ],
   "source": [
    "var_score.remove(100) # Error karena nilai 100 tidak ada dalam variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{70, 40, 10, 80, 50, 20, 90, 60, 30}\n"
     ]
    }
   ],
   "source": [
    "var_score.discard(100) # Ada/Tidak nilai yang akan dihapus tidak akan mengeluarkan error\n",
    "print(var_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{20, 90, 60, 30} 50\n"
     ]
    }
   ],
   "source": [
    "var_pop = var_score.pop() # Menghapus nilai dengan secara random / acak\n",
    "print(var_score,var_pop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set - .add() | Menambah value satu-satu pada variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{20, 30, 50, 60, 90}"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_score.add(50)\n",
    "var_score"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}