{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Bab 1: Dasar Pemrograman Python & Algoritma\n",
        "\n",
        "**Awd Course - Buku Modul Praktik Komprehensif**\n",
        "\n",
        "Notebook kompilasi lengkap untuk Bab 1 yang mencakup Komentar, Tipe Data & Variabel, Operator, Percabangan, Perulangan, Fungsi, serta Studi Kasus Praktik Kalkulator Interaktif.\n",
        "\n",
        "---\n"
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Komentar & Format Penulisan Kode Python\n",
        "\n",
        "Dalam pemrograman Python, **komentar** adalah baris teks yang tidak akan dieksekusi oleh interpreter Python. Komentar berfungsi penting untuk:\n",
        "1. Memberikan penjelasan dokumentasi logika kode kepada rekan pengembang.\n",
        "2. Memudahkan pemeliharaan (*maintenance*) kode di masa mendatang.\n",
        "3. Menonaktifkan sementara baris kode tertentu saat proses *debugging*."
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Komentar Satu Baris (Single-Line Comment)\n",
        "Komentar satu baris diawali dengan tanda pagar (`#`). Semua teks setelah tanda `#` hingga akhir baris akan diabaikan oleh Python."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Ini adalah contoh komentar satu baris\n",
        "print(\"Halo, selamat datang di kursus Python & Sains Data!\")  # Komentar di samping kode"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Komentar Multi Baris (Multi-Line Comment)\n",
        "Untuk menuliskan penjelasan yang panjang atau berupa paragraf, kita dapat menggunakan beberapa tanda `#` berturut-turut atau menggunakan *triple quotes* (`'''` atau `\"\"\"`)."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Ini adalah komentar multi-baris\n",
        "# yang menggunakan beberapa baris tanda pagar\n",
        "# untuk menjelaskan alur algoritma yang kompleks.\n",
        "\n",
        "\"\"\"\n",
        "Ini adalah string multi-baris yang sering digunakan sebagai\n",
        "docstring untuk mendokumentasikan fungsi, modul, atau kelas.\n",
        "\"\"\"\n",
        "print(\"Dokumentasi kode yang baik membuat program mudah dipahami.\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Best Practice Penulisan Komentar\n",
        "- Tulis komentar yang menjelaskan **MENGAPA** kode tersebut ditulis, bukan hanya sekadar mengulang apa yang sudah jelas dari kode.\n",
        "- Gunakan bahasa yang ringkas, jelas, dan mudah dipahami.\n",
        "- Perbarui komentar jika ada perubahan logika pada kode."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Menghitung diskon 15% untuk anggota premium\n",
        "total_belanja = 500000\n",
        "persen_diskon = 0.15\n",
        "total_akhir = total_belanja * (1 - persen_diskon)\n",
        "\n",
        "print(f\"Total bayar setelah diskon: Rp {total_akhir:,.0f}\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "---\n",
        "\n"
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Tipe Data dan Variabel Python\n",
        "\n",
        "**Variabel** adalah lokasi memori yang diberi nama untuk menyimpan data. Python bersifat *dynamically typed*, yang artinya Anda tidak perlu mendeklarasikan tipe data secara eksplisit saat membuat variabel."
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Tipe Data Primitif Dasar\n",
        "Python memiliki 4 tipe data primitif utama:\n",
        "- **Integer (`int`)**: Bilangan bulat positif atau negatif tanpa desimal.\n",
        "- **Float (`float`)**: Bilangan riil dengan pecahan desimal.\n",
        "- **String (`str`)**: Teks atau deretan karakter yang diapit tanda kutip.\n",
        "- **Boolean (`bool`)**: Nilai kebenaran logika (`True` atau `False`)."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Deklarasi berbagai tipe data dasar\n",
        "umur = 25                   # int\n",
        "tinggi_badan = 175.5        # float\n",
        "nama_lengkap = \"Budi Santoso\" # str\n",
        "is_active = True            # bool\n",
        "\n",
        "# Memeriksa tipe data dengan fungsi type()\n",
        "print(\"Tipe umur:\", type(umur))\n",
        "print(\"Tipe tinggi_badan:\", type(tinggi_badan))\n",
        "print(\"Tipe nama_lengkap:\", type(nama_lengkap))\n",
        "print(\"Tipe is_active:\", type(is_active))"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Struktur Data Koleksi (Collections)\n",
        "Python menyediakan struktur data koleksi bawaan yang sangat fleksibel:\n",
        "1. **List**: Terurut (*ordered*), dapat diubah (*mutable*), mengizinkan duplikasi. Ditulis dengan `[ ]`.\n",
        "2. **Tuple**: Terurut (*ordered*), tidak dapat diubah (*immutable*). Ditulis dengan `( )`.\n",
        "3. **Dictionary**: Pasangan kunci-nilai (*key-value pairs*), kunci harus unik. Ditulis dengan `{ }`.\n",
        "4. **Set**: Kumpulan elemen unik tanpa urutan (*unordered*). Ditulis dengan `{ }`."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# 1. List (Daftar)\n",
        "hobi = [\"Membaca\", \"Koding\", \"Berenang\"]\n",
        "hobi.append(\"Musik\")\n",
        "print(\"List Hobi:\", hobi)\n",
        "\n",
        "# 2. Tuple (Pasangan data koordinat/tetap)\n",
        "koordinat = (-7.250445, 112.768845)  # Latitude, Longitude Surabaya\n",
        "print(\"Koordinat:\", koordinat)\n",
        "\n",
        "# 3. Dictionary (Struktur Data Objek/Profil)\n",
        "profil_pengguna = {\n",
        "    \"id\": 101,\n",
        "    \"nama\": \"Siti Rahma\",\n",
        "    \"pekerjaan\": \"Data Analyst\",\n",
        "    \"keahlian\": [\"Python\", \"SQL\", \"Tableau\"]\n",
        "}\n",
        "print(\"Profil Pengguna:\", profil_pengguna[\"nama\"], \"-\", profil_pengguna[\"pekerjaan\"])\n",
        "\n",
        "# 4. Set (Himpunan Unik)\n",
        "angka_unik = {1, 2, 2, 3, 4, 4, 5}\n",
        "print(\"Set angka unik:\", angka_unik)"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Konversi Tipe Data (Type Casting)\n",
        "Anda dapat mengubah satu tipe data ke tipe data lain menggunakan fungsi bawaan seperti `int()`, `float()`, dan `str()`."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Konversi dari string ke numerik\n",
        "string_angka = \"150\"\n",
        "angka_integer = int(string_angka)\n",
        "angka_float = float(string_angka)\n",
        "\n",
        "print(\"Hasil int:\", angka_integer + 50)\n",
        "print(\"Hasil float:\", angka_float)"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "---\n",
        "\n"
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Operator Aritmatika, Perbandingan, & Logika\n",
        "\n",
        "Operator adalah simbol khusus dalam Python yang digunakan untuk melakukan operasi pada nilai (*operand*)."
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Operator Aritmatika\n",
        "Digunakan untuk operasi perhitungan matematika standar:\n",
        "- Penjumlahan (`+`), Pengurangan (`-`), Perkalian (`*`), Pembagian (`/`)\n",
        "- Pembagian Bulat (`//`), Modulo / Sisa Bagi (`%`), Pemangkatan (`**`)"
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "a = 15\n",
        "b = 4\n",
        "\n",
        "print(\"Penjumlahan (a + b)     =\", a + b)\n",
        "print(\"Pengurangan (a - b)     =\", a - b)\n",
        "print(\"Perkalian (a * b)       =\", a * b)\n",
        "print(\"Pembagian (a / b)       =\", a / b)\n",
        "print(\"Pembagian Bulat (a // b) =\", a // b)\n",
        "print(\"Sisa Bagi / Modulo (a % b)=\", a % b)\n",
        "print(\"Pemangkatan (a ** b)    =\", a ** b)"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Operator Perbandingan (Relasional)\n",
        "Menghasilkan nilai Boolean (`True` atau `False`) untuk membandingkan dua nilai:\n",
        "- Sama dengan (`==`), Tidak sama dengan (`!=`)\n",
        "- Lebih besar (`>`), Lebih kecil (`<`), Lebih besar sama dengan (`>=`), Lebih kecil sama dengan (`<=`)"
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "x = 20\n",
        "y = 35\n",
        "\n",
        "print(\"x == y :\", x == y)\n",
        "print(\"x != y :\", x != y)\n",
        "print(\"x < y  :\", x < y)\n",
        "print(\"x >= y :\", x >= y)"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Operator Logika\n",
        "Digunakan untuk menggabungkan kondisi kondisional:\n",
        "- `and`: Bernilai `True` jika **kedua kondisi** benar.\n",
        "- `or`: Bernilai `True` jika **salah satu kondisi** benar.\n",
        "- `not`: Membalikkan nilai logika (`True` menjadi `False`, dan sebaliknya)."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "nilai_ujian = 85\n",
        "kehadiran = 90\n",
        "\n",
        "lulus_syarat = (nilai_ujian >= 75) and (kehadiran >= 80)\n",
        "print(\"Apakah mahasiswa lulus?\", lulus_syarat)"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "---\n",
        "\n"
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Percabangan Kondisional (If, Elif, Else, Match-Case)\n",
        "\n",
        "Percabangan memungkinkan program membuat keputusan dan mengeksekusi blok kode tertentu berdasarkan kondisi Boolean."
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Pernyataan `if`, `elif`, dan `else`\n",
        "- **`if`**: Blok kode pertama yang dievaluasi.\n",
        "- **`elif`**: Kondisi alternatif berikutnya jika kondisi sebelumnya tidak terpenuhi.\n",
        "- **`else`**: Blok kode penutup yang dieksekusi jika seluruh kondisi di atas tidak terpenuhi."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "nilai = 82\n",
        "\n",
        "if nilai >= 85:\n",
        "    grade = \"A (Sangat Baik)\"\n",
        "elif nilai >= 75:\n",
        "    grade = \"B (Baik)\"\n",
        "elif nilai >= 60:\n",
        "    grade = \"C (Cukup)\"\n",
        "else:\n",
        "    grade = \"D (Perlu Perbaikan)\"\n",
        "\n",
        "print(f\"Nilai: {nilai} -> Predikat: {grade}\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Percabangan Bersarang (Nested If)\n",
        "Anda dapat menempatkan struktur `if` di dalam blok `if` lainnya untuk mengevaluasi kondisi bertingkat."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "member = True\n",
        "total_belanja = 600000\n",
        "\n",
        "if member:\n",
        "    if total_belanja >= 500000:\n",
        "        diskon = 0.20  # Diskon 20%\n",
        "    else:\n",
        "        diskon = 0.10  # Diskon 10%\n",
        "else:\n",
        "    diskon = 0.05      # Diskon 5%\n",
        "\n",
        "total_bayar = total_belanja * (1 - diskon)\n",
        "print(f\"Diskon: {diskon*100}% | Total Bayar: Rp {total_bayar:,.0f}\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Fitur Modern: `match-case` (Python 3.10+)\n",
        "Mirip dengan struktur *switch-case* pada bahasa pemrograman lain, `match-case` mempermudah pencocokan pola nilai secara elegan."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "kode_status = 200\n",
        "\n",
        "match kode_status:\n",
        "    case 200:\n",
        "        pesan = \"200 OK - Permintaan berhasil diproses.\"\n",
        "    case 404:\n",
        "        pesan = \"404 Not Found - Sumber data tidak ditemukan.\"\n",
        "    case 500:\n",
        "        pesan = \"500 Internal Server Error - Terjadi kesalahan server.\"\n",
        "    case _:\n",
        "        pesan = \"Kode status tidak dikenali.\"\n",
        "\n",
        "print(pesan)"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "---\n",
        "\n"
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Struktur Perulangan (For & While Loop)\n",
        "\n",
        "Perulangan (*looping*) digunakan untuk mengeksekusi blok kode berulang kali selama kondisi terpenuhi atau melintasi elemen-elemen dalam sebuah koleksi (*iterasi*)."
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Perulangan `for` dengan Fungsi `range()`\n",
        "Fungsi `range(start, stop, step)` menghasilkan deret angka urut."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Melakukan perulangan 5 kali (dari 1 hingga 5)\n",
        "print(\"Deret angka kuadrat:\")\n",
        "for i in range(1, 6):\n",
        "    print(f\"{i} kuadrat = {i**2}\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Iterasi pada Elemen Koleksi (List & Dictionary)"
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "bahasa_pemrograman = [\"Python\", \"SQL\", \"JavaScript\", \"R\", \"Go\"]\n",
        "\n",
        "print(\"Daftar Bahasa:\")\n",
        "for idx, bahasa in enumerate(bahasa_pemrograman, start=1):\n",
        "    print(f\"{idx}. {bahasa}\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Perulangan `while`\n",
        "Perulangan `while` akan terus berjalan selama kondisi logika bernilai `True`. Pastikan selalu memperbarui variabel penghitung (*counter*) agar tidak terjadi perulangan tanpa henti (*infinite loop*)."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "hitung_mundur = 5\n",
        "\n",
        "print(\"Memulai hitung mundur:\")\n",
        "while hitung_mundur > 0:\n",
        "    print(f\"{hitung_mundur}...\")\n",
        "    hitung_mundur -= 1\n",
        "\n",
        "print(\"Peluncuran Sukses!\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. Kontrol Perulangan: `break`, `continue`, dan `pass`\n",
        "- **`break`**: Menghentikan perulangan secara paksa.\n",
        "- **`continue`**: Melewati iterasi saat ini dan langsung melanjutkan ke iterasi berikutnya.\n",
        "- **`pass`**: Pernyataan kosong sebagai penampung (*placeholder*)."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Contoh continue: Hanya mencetak bilangan ganjil\n",
        "print(\"Bilangan ganjil antara 1 s.d. 10:\")\n",
        "for num in range(1, 11):\n",
        "    if num % 2 == 0:\n",
        "        continue  # Lewati bilangan genap\n",
        "    print(num, end=\" \")\n",
        "print()"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "---\n",
        "\n"
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Pembuatan & Pemanggilan Fungsi (Function)\n",
        "\n",
        "**Fungsi** adalah blok kode terorganisir dan dapat digunakan kembali (*reusable*) untuk melakukan satu tugas spesifik."
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Fungsi Bawaan (Built-in Functions)\n",
        "Python menyediakan banyak fungsi siap pakai seperti `len()`, `max()`, `min()`, `sum()`, `abs()`, dan `round()`."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "angka_list = [14, 28, 5, 92, 47, 63]\n",
        "\n",
        "print(\"Jumlah Elemen :\", len(angka_list))\n",
        "print(\"Nilai Maksimum:\", max(angka_list))\n",
        "print(\"Nilai Minimum :\", min(angka_list))\n",
        "print(\"Total Jumlah  :\", sum(angka_list))\n",
        "print(\"Rata-rata     :\", round(sum(angka_list) / len(angka_list), 2))"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Membuat Fungsi Kustom (User-Defined Functions)\n",
        "Fungsi didefinisikan menggunakan kata kunci `def`, diikuti nama fungsi dan tanda kurung parameter."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "def sapa_pengguna(nama, peran=\"Pelajar\"):\n",
        "    \"\"\"Fungsi untuk menampilkan salam sambutan.\"\"\"\n",
        "    return f\"Halo {nama}, selamat belajar sebagai {peran} di Awd Course!\"\n",
        "\n",
        "# Memanggil fungsi\n",
        "pesan_1 = sapa_pengguna(\"Agus\", \"Data Engineer\")\n",
        "pesan_2 = sapa_pengguna(\"Budi\")  # Menggunakan default parameter\n",
        "\n",
        "print(pesan_1)\n",
        "print(pesan_2)"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Fungsi dengan Nilai Balik Multi (Multiple Return Values)"
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "def hitung_statistik_sederhana(data):\n",
        "    \"\"\"Menghitung total, rata-rata, dan jangkauan (range).\"\"\"\n",
        "    total = sum(data)\n",
        "    rata_rata = total / len(data)\n",
        "    jangkauan = max(data) - min(data)\n",
        "    return total, rata_rata, jangkauan\n",
        "\n",
        "# Mengambil beberapa nilai balik sekaligus\n",
        "data_nilai = [80, 85, 90, 75, 95]\n",
        "tot, avg, rng = hitung_statistik_sederhana(data_nilai)\n",
        "\n",
        "print(f\"Total: {tot} | Rata-rata: {avg:.2f} | Jangkauan: {rng}\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "---\n",
        "\n"
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Tugas Praktik: Program Kalkulator Interaktif\n",
        "\n",
        "### Deskripsi Tugas:\n",
        "Terapkan seluruh konsep yang telah Anda pelajari pada Bab 1 (Variabel, Tipe Data, Operator, Percabangan, dan Fungsi) untuk membuat program kalkulator fungsional."
      ],
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Spesifikasi Program yang Diharapkan:\n",
        "1. Memiliki fungsi matematika: `tambah(a, b)`, `kurang(a, b)`, `kali(a, b)`, dan `bagi(a, b)`.\n",
        "2. Menangani pembagian dengan angka nol (*zero division error handling*).\n",
        "3. Mengembalikan hasil komputasi yang rapi."
      ],
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# Implementasi Program Kalkulator Modular\n",
        "def tambah(a, b):\n",
        "    return a + b\n",
        "\n",
        "def kurang(a, b):\n",
        "    return a - b\n",
        "\n",
        "def kali(a, b):\n",
        "    return a * b\n",
        "\n",
        "def bagi(a, b):\n",
        "    if b == 0:\n",
        "        return \"Error: Pembagian dengan nol tidak diizinkan!\"\n",
        "    return a / b\n",
        "\n",
        "# Uji Coba Fungsi Kalkulator\n",
        "angka1 = 48\n",
        "angka2 = 12\n",
        "\n",
        "print(f\"{angka1} + {angka2} = {tambah(angka1, angka2)}\")\n",
        "print(f\"{angka1} - {angka2} = {kurang(angka1, angka2)}\")\n",
        "print(f\"{angka1} * {angka2} = {kali(angka1, angka2)}\")\n",
        "print(f\"{angka1} / {angka2} = {bagi(angka1, angka2)}\")\n",
        "print(f\"{angka1} / 0  = {bagi(angka1, 0)}\")"
      ],
      "outputs": [],
      "execution_count": null
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "---\n",
        "\n"
      ],
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.11.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}