02 - Pengenalan Python - List, Tuple, Dictionary, String, Perulangan.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Perulangan / Looping\n",
    "Sintaks yang digunakan untuk menjalankan sebuah kode program secara berulang kali hingga step yang ditentukan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#SINTAKS FOR\n",
    "for j in range(0,10,2):\n",
    "    print(j,j**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#SINTAKS WHILE\n",
    "i = 0\n",
    "while i<10:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. List\n",
    "Tipe data yang digunakan untuk menyimpan beberapa nilai dalam satu variabel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30, 40, 50, 60, 70, 80, 90]\n",
      "['Ani', 'Budi', 'Catra', 'Desi']\n",
      "['Big', 2.5, 90, 'Data']\n"
     ]
    }
   ],
   "source": [
    "# Deklarasi List\n",
    "\n",
    "#Dapat Berisi Angka\n",
    "nilai = [30,40,50,60,70,80,90]\n",
    "print(nilai)\n",
    "\n",
    "#Dapat berisi String\n",
    "peserta = ['Ani','Budi','Catra','Desi']\n",
    "print(peserta)\n",
    "\n",
    "#Dapat juga berisi campuran tipe data\n",
    "campuran = ['Big',2.5, 90, 'Data']\n",
    "print(campuran)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 List Index\n",
    "Untuk mengakses elemen tertentu di dalam list, kita dapat menggunakan list index. Index list dimulai dari 0. Index di dalam python juga dapat dibuat negatif, yang artinya index akan ditelusuri dari belakang\n",
    "\n",
    "| 30 | 40 | 50 | 60 | 70 | 80 | 90 |\n",
    "|----|----|----|----|----|----|----|\n",
    "| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "70\n",
      "90\n",
      "70\n",
      "Catra\n"
     ]
    }
   ],
   "source": [
    "print(nilai[0])\n",
    "print(nilai[4])\n",
    "print(nilai[-1])\n",
    "print(nilai[-3])\n",
    "\n",
    "print(peserta[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Menambah Elemen ke Dalam List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40, 50, 60, 70]\n"
     ]
    }
   ],
   "source": [
    "nilai.append(90)\n",
    "nilai.extend([10,20,30,40])\n",
    "\n",
    "print(nilai)\n",
    "\n",
    "#MENGHAPUS ELEMEN PADA LIST\n",
    "del nilai[0]\n",
    "\n",
    "# List Function in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Slicing List\n",
    "Slicing digunakan untuk memilih beberapa kelompok nilai dari list dengan memanfaatkan range index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(nilai)\n",
    "\n",
    "# elemen ke 3 sampai ke 5\n",
    "print(nilai[2:5])\n",
    "\n",
    "# ...\n",
    "print(nilai[:-2])\n",
    "\n",
    "# ...\n",
    "print(nilai[5:])\n",
    "\n",
    "# ...\n",
    "print(nilai[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Perulangan dalam List\n",
    "Dalam mengakses setiap elemen dalam list, kita dapat menggunakan sintaks perulangan for yang telah kita pelajari sebelumnya"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "900\n",
      "1600\n",
      "2500\n",
      "3600\n",
      "4900\n",
      "6400\n",
      "8100\n",
      "(0, 30)\n",
      "(1, 40)\n",
      "(2, 50)\n",
      "(3, 60)\n",
      "(4, 70)\n",
      "(5, 80)\n",
      "(6, 90)\n"
     ]
    }
   ],
   "source": [
    "for n in nilai:\n",
    "    print(n**2)\n",
    "\n",
    "# Mengikutkan Indeksnya\n",
    "for i,n in enumerate(nilai):\n",
    "    print(i,n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contoh\n",
    "Berapakah rata-rata nilai dari list tersebut?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60.0\n"
     ]
    }
   ],
   "source": [
    "# ALGORITMA RATA-RATA\n",
    "total = 0.0\n",
    "for n in nilai:\n",
    "    total = total + float(n)\n",
    "    \n",
    "rata = total / len(nilai)\n",
    "print(rata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lookup Nilai dalam List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(92, 'tidak ada dalam list')\n"
     ]
    }
   ],
   "source": [
    "n = 92\n",
    "if n in nilai:\n",
    "    print(n, \"ada dalam list\")\n",
    "else:\n",
    "    print(n, \"tidak ada dalam list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Latihan\n",
    "Tampilkan Nilai dari list nilai yang Lebih dari sama dengan (>=) rata-ratanya.\n",
    "\n",
    "tugas = [66,77,88,99,55,54]\n",
    "\n",
    "Tampilkan nilai dari list tugas yang Genap "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66\n",
      "-\n",
      "88\n",
      "-\n",
      "54\n",
      "-\n"
     ]
    }
   ],
   "source": [
    "tugas = [66,77,88,99,55,54]\n",
    "for n in tugas:\n",
    "    if n%2==0:\n",
    "        print(n)\n",
    "        print(\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Tuple\n",
    "Tuple merupakan tipe data yang mirip dengan list, namun berifat immutable atau tidak dapat ditambah dan diubah nilainya. Keuntungan dari penggunaan tuple adalah, pengaksesan datanya lebih cepat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Deklarasi Tuple\n",
    "bulan = (\"Januari\",\"Februari\",\"Maret\",\"April\",\"Mei\",\"Juni\",\"Juli\",\"Agustus\",\"September\",\"Oktober\",\"November\",\"Desember\")\n",
    "print(bulan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Akses Elemen dan Slicing\n",
    "Konsep dalam melakukan akses elemen dan slicing sama persis dengan di list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Januari\n",
      "Mei\n",
      "Desember\n",
      "Oktober\n"
     ]
    }
   ],
   "source": [
    "print(bulan[0])\n",
    "print(bulan[4])\n",
    "print(bulan[-1])\n",
    "print(bulan[-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Maret', 'April', 'Mei')\n",
      "('Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli')\n",
      "('Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember')\n",
      "('Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember')\n"
     ]
    }
   ],
   "source": [
    "print(bulan[2:5])\n",
    "\n",
    "print(bulan[:-5])\n",
    "\n",
    "print(bulan[5:])\n",
    "\n",
    "print(bulan[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Perulangan dalam Tuple\n",
    "Konsep perulangan juga sama dengan list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Januari\n",
      "Februari\n",
      "Maret\n",
      "April\n",
      "Mei\n",
      "Juni\n",
      "Juli\n",
      "Agustus\n",
      "September\n",
      "Oktober\n",
      "November\n",
      "Desember\n"
     ]
    }
   ],
   "source": [
    "for b in bulan:\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Dictionary\n",
    "Dictionary dalam Python berbeda dengan List ataupun Tuple. Karena setiap urutanya berisi key dan value. Setiap key dipisahkan dari value-nya oleh titik dua (:), item dipisahkan oleh koma, dan semuanya tertutup dalam kurung kurawal. Dictionary kosong tanpa barang ditulis hanya dengan dua kurung kurawal, seperti ini: {}."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 Membuat dan Mengakses Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Nama': 'Budi', 'JenisKelamin': 'Laki-Laki', 'Umur': 7}\n",
      "Budi\n",
      "7\n",
      "Laki-Laki\n",
      "[{'Nama': 'Budi', 'JenisKelamin': 'Laki-Laki', 'Umur': 7}, {'Nama': 'Ani', 'JenisKelamin': 'Perempuan', 'Umur': 8}]\n"
     ]
    }
   ],
   "source": [
    "siswa = {'Nama': 'Budi', 'Umur': 7, 'JenisKelamin': 'Laki-Laki'}\n",
    "siswa2 = {'Nama': 'Ani', 'Umur': 8, 'JenisKelamin': 'Perempuan'}\n",
    "print(siswa)\n",
    "print(siswa['Nama'])\n",
    "print(siswa['Umur'])\n",
    "print(siswa['JenisKelamin'])\n",
    "\n",
    "list_siswa = []\n",
    "list_siswa.append(siswa)\n",
    "list_siswa.append(siswa2)\n",
    "print(list_siswa)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Nama', 'Budi')\n",
      "('JenisKelamin', 'Laki-Laki')\n",
      "('Umur', 7)\n"
     ]
    }
   ],
   "source": [
    "for k,v in siswa.items():\n",
    "    print(k,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 Mengubah nilai Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Nama': 'Deni', 'JenisKelamin': 'Laki-Laki', 'Umur': 7}\n"
     ]
    }
   ],
   "source": [
    "siswa['Nama'] = 'Deni'\n",
    "print(siswa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.3 Menambahkan Elemen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Nama': 'Deni', 'JenisKelamin': 'Laki-Laki', 'Alamat': 'Jl. Kaliurang KM 5', 'Umur': 7}\n"
     ]
    }
   ],
   "source": [
    "siswa['Alamat'] = \"Jl. Kaliurang KM 5\"\n",
    "print(siswa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Nama': 'Deni', 'JenisKelamin': 'Laki-Laki', 'Alamat': 'Jl. Kaliurang KM 5', 'Nilai': [30, 40, 50, 60, 70, 80, 90], 'Umur': 7}\n",
      "30\n",
      "40\n",
      "50\n",
      "60\n",
      "70\n",
      "80\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "# List sebagai nilai dari elemen Dictionary\n",
    "siswa[\"Nilai\"] = nilai\n",
    "print(siswa)\n",
    "\n",
    "for n in siswa[\"Nilai\"]:\n",
    "   print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============\n",
      "('Nama', 'Deni')\n",
      "('JenisKelamin', 'Laki-Laki')\n",
      "('Alamat', 'Jl. Kaliurang KM 5')\n",
      "('Nilai', [30, 40, 50, 60, 70, 80, 90])\n",
      "('Umur', 7)\n",
      "============\n",
      "('Nama', 'Ani')\n",
      "('JenisKelamin', 'Perempuan')\n",
      "('Umur', 8)\n"
     ]
    }
   ],
   "source": [
    "for l in list_siswa:\n",
    "    print(\"============\")\n",
    "    for k,v in l.items():\n",
    "        print(k,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Operasi String\n",
    "Pada pertemuan sebelumnya telah dijelaskan mengenai string. Dalam python cukup banyak operasi yang dikenakan pada string, yang akan berguna dalam analisis data.\n",
    "\n",
    "## 5.1 Slicing dan Akses per Karakter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tutori\n",
      "ograman Py\n",
      "Python\n"
     ]
    }
   ],
   "source": [
    "nama = \"Tutorial Bahasa Pemrograman Python\"\n",
    "print(nama[0:6])\n",
    "print(nama[20:30])\n",
    "print(nama[-6:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n",
      "u\n",
      "t\n",
      "o\n",
      "r\n",
      "i\n",
      "a\n",
      "l\n",
      " \n",
      "B\n",
      "a\n",
      "h\n",
      "a\n",
      "s\n",
      "a\n",
      " \n",
      "P\n",
      "e\n",
      "m\n",
      "r\n",
      "o\n",
      "g\n",
      "r\n",
      "a\n",
      "m\n",
      "a\n",
      "n\n",
      " \n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for n in nama:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 Merubah String menjadi list Kata\n",
    "Menggunakan fungsi split. Fungsi split dapat diberikan parameter berupa karakter pemisahnya. Jika tidak diberikan parameter maka secara default, pemisahnya adalah spasi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Pada hari minggu kuturut ayah ke kota', ' Naik Delman istimewa kududuk di muka', ' Duduk disamping pak kusir yang sedang bekerja']\n",
      "['Pada', 'hari', 'minggu', 'kuturut', 'ayah', 'ke', 'kota']\n",
      "['Naik', 'Delman', 'istimewa', 'kududuk', 'di', 'muka']\n",
      "['Duduk', 'disamping', 'pak', 'kusir', 'yang', 'sedang', 'bekerja']\n"
     ]
    }
   ],
   "source": [
    "# kata = nama.split()\n",
    "# print(kata)\n",
    "# print(kata[0])\n",
    "# print(kata[2])\n",
    "\n",
    "paragraf = \"Pada hari minggu kuturut ayah ke kota. Naik Delman istimewa kududuk di muka. Duduk disamping pak kusir yang sedang bekerja\"\n",
    "kalimat = paragraf.split(\".\")\n",
    "print(kalimat)\n",
    "\n",
    "for k in kalimat:\n",
    "    print(k.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.3 Pencarian kata dalam String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Python', 'Found!')\n",
      "('Java', 'Not Found!')\n",
      "('C++', 'Not Found!')\n"
     ]
    }
   ],
   "source": [
    "cari = 'Python'\n",
    "if cari in nama:\n",
    "    print(\"Found!\")\n",
    "else:\n",
    "    print(\"Not Found!\")\n",
    "    \n",
    "cari = ['Python','Java','C++']\n",
    "for c in cari:\n",
    "    if c in nama:\n",
    "        print(c,\"Found!\")\n",
    "    else:\n",
    "        print(c,\"Not Found!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.4 Replace String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pada hari ini saya belajar\n"
     ]
    }
   ],
   "source": [
    "paragraf = \"Pd hr ini saya BljR\"\n",
    "paragraf = paragraf.lower()\n",
    "paragraf = paragraf.replace('pd','pada')\n",
    "paragraf = paragraf.replace('hr','hari')\n",
    "paragraf = paragraf.replace('bljr','belajar')\n",
    "print(paragraf)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.5 Panjang String, Lowercase, Uppercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n",
      "TUTORIAL BAHASA PEMROGRAMAN PYTHON\n",
      "tutorial bahasa pemrograman python\n"
     ]
    }
   ],
   "source": [
    "print(len(nama))\n",
    "print(nama.upper())\n",
    "print(nama.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LATIHAN 2 - Tugas List Nilai\n",
    "\n",
    "Diberikan sekumpulan Nilai Random antara 0 sampai dengan 100 sebanyak 250 nilai. Buatlah program untuk melakukan hal berikut:\n",
    "1. Tampilkan Angka Ganjil dari ke 250 nilai tersebut\n",
    "2. Tampilkan berapa banyak yang mendapatkan nilai lebih dari 70\n",
    "3. Tampilkan standar deviasi dari sekumpulan nilai tersebut\n",
    "4. Tampilkan nilai maksimum dan minimum\n",
    "5. Tampilkan modus dari sekumpulan nilai tersebut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[77, 98, 60, 16, 54, 69, 10, 55, 65, 80, 84, 83, 3, 25, 47, 52, 67, 18, 14, 10, 27, 42, 53, 23, 64, 44, 17, 72, 68, 28, 69, 64, 53, 4, 36, 28, 13, 38, 4, 94, 68, 98, 40, 97, 90, 70, 76, 50, 35, 42, 15, 18, 57, 55, 45, 44, 88, 45, 50, 83, 62, 74, 73, 69, 33, 53, 24, 5, 51, 5, 1, 90, 95, 28, 46, 27, 16, 67, 33, 58, 16, 5, 23, 93, 43, 70, 86, 90, 36, 86, 6, 72, 65, 31, 27, 13, 9, 62, 4, 99, 23, 28, 43, 52, 45, 18, 94, 7, 57, 63, 39, 58, 99, 8, 78, 8, 92, 21, 74, 55, 58, 42, 95, 95, 64, 14, 50, 7, 89, 78, 78, 91, 73, 29, 58, 63, 96, 87, 17, 94, 51, 35, 66, 76, 39, 9, 84, 22, 79, 52, 17, 81, 68, 39, 49, 23, 88, 48, 93, 93, 51, 53, 85, 21, 68, 18, 87, 87, 36, 37, 57, 55, 42, 15, 5, 51, 45, 38, 4, 28, 92, 70, 86, 76, 94, 79, 36, 8, 94, 86, 32, 59, 37, 46, 3, 33, 96, 16, 86, 10, 23, 20, 6, 23, 83, 30, 8, 25, 43, 88, 42, 82, 81, 85, 53, 25, 5, 91, 64, 77, 14, 3, 66, 94, 42, 50, 99, 25, 96, 65, 71, 41, 92, 68, 41, 1, 44, 73, 6, 25, 62, 44, 62, 52, 50, 78, 99, 30, 25, 56]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# GENERATE RANDOM\n",
    "nilaiTugas = []\n",
    "for i in range(250):\n",
    "    nilaiTugas.append(random.randrange(1,100,1))\n",
    "\n",
    "print(nilaiTugas)\n",
    "\n",
    "# TAMPILKAN:\n",
    "# ganjil\n",
    "# nilai > 70\n",
    "# standar deviasi\n",
    "# maksimum\n",
    "# minimum\n",
    "# modus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LATIHAN 3 - Word Count\n",
    "Diberikan sebuah paragraf, hitunglah banyak kemunculan masing-masing kata.\n",
    "Contoh : \"Presiden pagi ini melakukan kunjungan ke Jogja\"\n",
    "\n",
    "- presiden: 1\n",
    "- pagi: 1\n",
    "- ini: 1\n",
    "- melakukan: 1\n",
    "- kunjungan: 1\n",
    "- ke: 1\n",
    "- jogja: 1\n",
    "\n",
    "hints: Gunakan Dictionary dalam menyimpan word count. Gunakan kata sebagai key, dan jumlah kemunculan sebagai value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Barcelona', 'berhasil', 'merebut', 'posisi', 'puncak', 'klasemen', 'La', 'Liga', 'Spanyol', 'seusai', 'menang', '4', '2', 'atas', 'Sevilla', 'pada', 'pertandingan', 'pekan', 'kesembilan', 'di', 'Stadion', 'Camp', 'Nou,', 'Sabtu', '20', '10', '2018', 'atau', 'Minggu', 'dini', 'hari', 'WIB.', 'Barcelona', 'membuka', 'keunggulan', 'pada', 'menit', 'ke', '2', 'melalui', 'gol', 'yang', 'dicetak', 'oleh', 'Philippe', 'Coutinho.', 'Lionel', 'Messi', 'menggandakan', 'keunggulan', 'Barcelona,', '10', 'menit', 'berselang.', 'Namun,', 'nahas', 'bagi', 'Barcelona,', 'karena', 'Messi', 'harus', 'ditarik', 'keluar', 'pada', 'menit', 'ke', '26', 'setelah', 'mengalami', 'cedera.', 'Tanpa', 'Messi,', 'skor', '2', '0', 'bertahan', 'hingga', 'babak', 'pertama', 'berakhir.']\n"
     ]
    }
   ],
   "source": [
    "paragraf = \"Barcelona berhasil merebut posisi puncak klasemen La Liga Spanyol seusai menang 4-2 atas Sevilla pada pertandingan pekan kesembilan di Stadion Camp Nou, Sabtu (20/10/2018) atau Minggu dini hari WIB. Barcelona membuka keunggulan pada menit ke-2 melalui gol yang dicetak oleh Philippe Coutinho. Lionel Messi menggandakan keunggulan Barcelona, 10 menit berselang.  Namun, nahas bagi Barcelona, karena Messi harus ditarik keluar pada menit ke-26 setelah mengalami cedera. Tanpa Messi, skor 2-0 bertahan hingga babak pertama berakhir.\"\n",
    "paragraf = paragraf.replace(\"/\",\" \")\n",
    "paragraf = paragraf.replace(\"(\",\" \")\n",
    "paragraf = paragraf.replace(\")\",\" \")\n",
    "paragraf = paragraf.replace(\"-\",\" \")\n",
    "print(paragraf.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}