Python BuildQuest (E-Book)

Cara Kuasai Python & Bangun 100 Proyek Nyata Tanpa

Ikut Bootcamp Mahal Dalam 100 Hari

Introduction :
Kamu mungkin sudah berkali-kali mencoba belajar Python dari YouTube, tutorial, atau kelas
online, tapi tetap mentok. Setiap kali buka proyek baru, kamu bingung mulai dari mana.
Sementara teman-teman lain sudah bisa bikin bot, API, atau aplikasi web, kamu masih sibuk
membaca dokumentasi tanpa hasil nyata.

Masalahnya bukan di otak kamu. Masalahnya ada pada cara belajar.

Sebagian besar orang belajar Python dengan cara pasif — nonton, catat, tapi tidak
membangun apa-apa. Akibatnya, otak tidak pernah mengaitkan konsep dengan pengalaman
nyata. Padahal, kemampuan coding itu seperti otot: kalau tidak dipakai, tidak akan tumbuh.

E-book “Python BuildQuest” ini dibuat dengan pendekatan berbeda.

Alih-alih teori, kamu akan membangun 100 proyek nyata dalam 100 hari, satu proyek per
hari — dari yang paling sederhana (otomatisasi tugas kecil) sampai kompleks (web app, AI
mini, API, dan tools pribadi). Setiap proyek dirancang untuk:

● Menambah pemahaman logika Python secara alami, tanpa hafalan.

● Menghasilkan portofolio nyata yang bisa kamu pamerkan di GitHub atau LinkedIn.

● Melatih kebiasaan berpikir dan menyelesaikan masalah seperti developer

sungguhan.

Janji Hasil (Promise)

Dalam 100 hari, kamu akan:

● Menguasai dasar dan lanjutan Python tanpa ikut bootcamp mahal.

● Membangun 100 proyek fungsional dari berbagai bidang (otomatisasi, web, data,
AI, API).
 ● Punya portofolio publik lengkap yang siap dilihat HR atau klien freelance.

● Mampu membuat proyek dari ide sendiri tanpa tutorial tambahan.

Kerangka Besar (Big Picture)

E-book ini dibagi jadi 5 fase utama:

1. Fase 1 – Setup & Dasar Praktis (Hari 1–10)

Instalasi, sintaks dasar, dan 10 proyek mini untuk memanaskan otak.

2. Fase 2 – Logika, Struktur Data, & Otomatisasi (Hari 11–30)

20 proyek otomatisasi dunia nyata: rename file, kirim email otomatis, olah data CSV,
dll.

3. Fase 3 – Web & API (Hari 31–50)

Bangun 20 proyek berbasis API dan web sederhana: quote generator, weather app,
REST API mini.

4. Fase 4 – Data & AI Mini Project (Hari 51–80)

Mulai main dengan data dan AI: analisis dataset, chatbot sederhana, model prediksi.

5. Fase 5 – Final Quest: Build Your Own Product (Hari 81–100)

Buat produk nyata dari nol — gabungkan semua kemampuan Python kamu ke satu
proyek besar.

Aksi Kecil Hari Ini (Small Win)

Untuk memulai perjalanan ini, kamu tidak butuh kursus, hanya butuh:

1. Instal Python 3.12+ di komputer kamu.

2. Buka VS Code (atau editor apa pun yang kamu suka).

3. Buat folder baru bernama BuildQuest100.

Tulis file pertama:

print("Hello, BuildQuest!")
 4. Jalankan. Kalau muncul teks itu — kamu sudah resmi memulai hari pertama.

E-book ini bukan teori kosong. Ini quest praktis — setiap halaman menggerakkan kamu satu
langkah lebih dekat ke janji utama: menguasai Python lewat 100 proyek nyata.

Outline :
Bab 1 — Bangun Fondasi Python dari Nol

Hasil: Kamu bisa menulis, menjalankan, dan memahami kode Python

sederhana tanpa takut error.

Isi utama:

● Instalasi Python & VS Code

● Struktur dasar program

● Variabel, input, output

● Latihan: buat 3 skrip pertama (“Hello BuildQuest”, kalkulator mini, konversi suhu)

● Checklist: bisa jalankan file .py tanpa panduan

Bab 2 — Logika, Loop, & Fungsi yang Bekerja

Hasil: Kamu memahami alur logika dan mampu membuat fungsi sendiri.

Isi utama:

● Kondisional if, else, elif

● Loop for, while

● Fungsi buatan sendiri (def & return)

● 10 proyek latihan logika (tebak angka, kuis otomatis, pengolah teks)

● Checklist: bisa menulis fungsi reusable

 Bab 3 — Struktur Data Python dalam Dunia Nyata

Hasil: Kamu bisa mengelola data dengan list, dict, tuple, dan set.

Isi utama:

● Menyimpan & memanipulasi data

● Studi kasus: data pelanggan, stok barang, transaksi

● 10 proyek praktis (daftar belanja otomatis, pencatat keuangan harian, reminder list)

● Checklist: mampu menggabungkan struktur data untuk tugas praktis

Bab 4 — File Handling & Otomatisasi Harian

Hasil: Kamu mampu memanipulasi file (CSV, TXT, JSON) dan otomatisasi tugas
berulang.

Isi utama:

● Baca & tulis file

● Path & os module

● Otomatisasi rename file, log harian, dan backup sederhana

● 10 proyek nyata: email auto-send, laporan harian, file organizer

● Checklist: bisa otomatisasi minimal 3 pekerjaan rutin di laptop sendiri

Bab 5 — Koneksi Internet & API

Hasil: Kamu bisa mengambil data dari internet dan memanfaatkannya dalam
proyek.

Isi utama:

● HTTP request & JSON response

● Menggunakan API publik (weather, quote, crypto)

 ● 10 proyek API: chatbot quote, app harga kripto, translator mini

● Checklist: bisa ambil & tampilkan data API dengan requests

Bab 6 — Web Project dengan Flask

Hasil: Kamu bisa membuat web app sederhana dengan Python.

Isi utama:

● Dasar Flask & routing

● Template HTML & integrasi form

● 10 proyek web mini (guestbook, kalkulator online, blog mini)

● Checklist: bisa deploy web sederhana ke Render/Heroku

Bab 7 — Data Science Mini Journey

Hasil: Kamu bisa menganalisis data sederhana menggunakan pandas dan

matplotlib.

Isi utama:

● Baca dataset (CSV/Excel)

● Analisis statistik dasar

● Visualisasi data

● 10 proyek: laporan penjualan, analisis tren, grafik keuangan

● Checklist: bisa menampilkan grafik dari dataset sendiri

Bab 8 — AI & Machine Learning Dasar

Hasil: Kamu mengenal konsep ML dan bisa membuat model sederhana.

Isi utama:
 ● Dasar ML dengan scikit-learn

● Model regresi, klasifikasi, clustering

● 10 proyek: prediksi harga, klasifikasi teks, chatbot dasar

● Checklist: bisa membuat model & menyimpan hasil prediksi

Bab 9 — Full Integration Projects

Hasil: Kamu menggabungkan semua kemampuan jadi proyek kompleks.

Isi utama:

● Integrasi web + database + API

● Proyek besar 3 in 1: “Dashboard Data Otomatis”

● Otomatisasi + visualisasi real-time

● Checklist: satu proyek utuh dari nol yang bisa dijalankan

Bab 10 — Final Quest: Bangun Produk Sendiri dalam 20 Hari

Hasil: Kamu punya produk Python nyata (dengan dokumentasi & repo publik).

Isi utama:

● Pemilihan ide produk final

● Perencanaan fitur dan arsitektur

● Implementasi dan debugging

● Dokumentasi & publikasi di GitHub

● Checklist: 1 produk final dengan minimal 3 fitur aktif

Bonus Bab — Strategi Pamer & Monetisasi Portofolio

 Hasil: Kamu bisa menjadikan hasil 100 proyek ini sebagai alat karier.

Isi utama:

● Cara upload proyek ke GitHub & tulis README profesional

● Membangun LinkedIn dev profile

● Menawarkan jasa freelance berbasis Python

● Checklist: profil publik siap ditampilkan ke HR atau klien

Struktur 100 Hari (Pemetaan Progress)

Fas Hari Fokus Jumlah Proyek Hasil Akhir
e

1 1–10 Dasar & sintaks 10 Pahami Python

2 11–30 Logika & Otomatisasi 20 Skill coding praktis

3 31–50 Web & API 20 Web mini-app

4 51–80 Data & AI 30 Analisis & AI mini

5 81–100 Produk Final 20 Produk siap publikasi

Dengan struktur ini, pembaca tidak hanya belajar, tapi juga punya hasil nyata setiap hari.
Tujuan akhir: portofolio 100 proyek Python yang bisa jadi tiket kerja atau freelance.

Bab 1 — Bangun Fondasi Python dari Nol

Tujuan Bab

Setelah menyelesaikan bab ini, kamu bisa menulis, menjalankan, dan memahami kode
Python dasar tanpa takut error. Kamu akan tahu cara kerja variabel, input, output, serta
struktur file Python, dan menyiapkan lingkungan kerja agar siap untuk 100 proyek
berikutnya.

Strategi

1. Bangun lingkungan coding yang siap pakai — instal Python dan editor kode
modern.
 2. Pahami anatomi program Python sederhana — bagaimana perintah dieksekusi.
3. Latihan tiga proyek mini untuk membiasakan diri dengan sintaks dan logika.
4. Gunakan error sebagai teman belajar, bukan musuh.
5. Checklist hasil belajar untuk memastikan kamu benar-benar siap ke tahap
berikutnya.

Praktek Step-by-Step

Langkah 1 — Instalasi Python

1. Buka situs resmi: [Link]

2. Unduh versi Python 3.12+ sesuai sistem operasi kamu.
3. Centang opsi “Add Python to PATH” sebelum klik “Install Now”.

Setelah selesai, buka terminal dan ketik:

python --version

4. Jika muncul seperti Python 3.12.1, berarti instalasi sukses.

Langkah 2 — Instal VS Code

1. Kunjungi [Link]
2. Unduh dan instal.
3. Setelah terbuka, tekan Ctrl+Shift+X lalu cari dan instal ekstensi Python dari
Microsoft.
4. Buat folder baru bernama BuildQuest100.
5. Di dalamnya, buat file pertama: day1_hello.py.

Langkah 3 — Jalankan Program Pertama

Buka day1_hello.py dan tulis:

print("Hello, BuildQuest!")

Simpan, lalu jalankan dengan menekan tombol di pojok kanan atas atau ketik di terminal:

python day1_hello.py

Jika muncul teks Hello, BuildQuest!, artinya kamu resmi memulai perjalanan Python
kamu.

Langkah 4 — Pahami Variabel dan Input

Python menyimpan data dalam variabel. Coba ubah program kamu:

nama = input("Masukkan nama kamu: ")
print("Selamat datang di BuildQuest,", nama)

Jalankan. Ketik nama kamu dan lihat bagaimana program merespons.

Variabel nama menyimpan input pengguna, dan fungsi print() menampilkannya kembali.

Langkah 5 — Eksperimen dengan Operasi Dasar

Buat file baru day2_kalkulator.py:

a = int(input("Masukkan angka pertama: "))

b = int(input("Masukkan angka kedua: "))
hasil = a + b
print("Hasil penjumlahan:", hasil)

Uji dengan beberapa angka. Jika hasilnya benar, tambahkan operasi lain:

print("Hasil pengurangan:", a - b)
print("Hasil perkalian:", a * b)
print("Hasil pembagian:", a / b)

Sekarang kamu punya kalkulator mini.

Langkah 6 — Gunakan Komentar

Komentar penting untuk menjelaskan kode. Python mengabaikan teks yang diawali #.

# Ini adalah komentar

# Program ini menjumlahkan dua angka

Biasakan menulis komentar setiap kali kamu membuat proyek baru. Nanti, saat proyekmu
makin banyak, komentar akan menyelamatkan waktu kamu.

Langkah 7 — Tangani Error

Coba ubah satu baris menjadi salah, misalnya:

print("Halo"

Python akan menampilkan error seperti:

SyntaxError: unexpected EOF while parsing

Jangan panik. Ini sinyal dari interpreter bahwa kamu lupa menutup tanda kurung.
Kamu baru saja belajar satu hal penting: error adalah guru paling jujur.

Langkah 8 — Buat Proyek Mini 3-in-1

Sekarang gabungkan semua konsep ke dalam satu file: day3_combo.py.

print("=== Program Serbaguna BuildQuest ===")

nama = input("Masukkan nama kamu: ")

print(f"Halo {nama}, selamat datang!")

a = int(input("Masukkan angka pertama: "))

b = int(input("Masukkan angka kedua: "))

print(f"Jumlah: {a + b}")
print(f"Selisih: {a - b}")
print(f"Perkalian: {a * b}")
print(f"Rata-rata: {(a + b) / 2}")

umur = int(input("Masukkan umur kamu: "))

if umur >= 18:
print("Kamu sudah dewasa, siap belajar Python lebih dalam.")
else:
print("Kamu masih muda, tapi sudah keren mau belajar Python!")

Kamu baru menyatukan variabel, input, output, logika, dan kondisi. Ini pondasi dari
semua proyek berikutnya.

Contoh

Kasus nyata:
Bayangkan kamu ingin menghitung pengeluaran harian. Kamu bisa buat file [Link]:

pengeluaran = int(input("Masukkan total pengeluaran hari ini (Rp): "))

target = 100000 # batas harian

if pengeluaran > target:

print("Kamu melebihi batas! Kurangi pengeluaran besok.")
else:
print("Bagus! Kamu masih dalam batas wajar.")

Contoh kecil ini memperkenalkan pola real-life automation — kamu memberi logika ke
angka.
 Tugas / Checklist Bab 1

Sebelum lanjut ke Bab 2, pastikan semua poin berikut sudah kamu capai:

● Python 3.12+ sudah terinstal dan bisa dijalankan dari terminal.

● VS Code sudah disiapkan dengan ekstensi Python.
● Kamu sudah membuat dan menjalankan file .py pertama.
● Kamu memahami konsep variabel dan input/output.
● Kamu sudah menyelesaikan 3 proyek mini (Hello, Kalkulator, Program Serbaguna).
● Kamu tidak takut lagi menghadapi error.

Kalau semua sudah dicentang, kamu sudah siap melangkah ke tahap berikutnya — logika
dan fungsi.

Bridge ke Bab 2

Kamu kini tahu cara berbicara dengan Python dan membuat program sederhana yang
benar-benar jalan.
Langkah selanjutnya adalah mengajarkan Python untuk berpikir dan mengambil
keputusan.
Di Bab 2 — Logika, Loop, & Fungsi yang Bekerja, kamu akan belajar bagaimana
membuat program yang bisa berpikir otomatis dan mengulang tugas tanpa campur tangan
manusia.

Bab 2 — Logika, Loop, & Fungsi yang Bekerja

Tujuan Bab

Setelah menyelesaikan bab ini, kamu akan mampu membuat program Python yang bisa
berpikir dan bertindak otomatis — mengambil keputusan dengan logika, mengulang tugas
berkali-kali tanpa disuruh, dan membungkus blok kode jadi fungsi reusable.
Hasil akhirnya: kamu bisa membuat skrip yang menyelesaikan pekerjaan rutin tanpa
mengetik ulang perintah berkali-kali.

Strategi

1. Pahami logika keputusan (if–else) agar program bisa bereaksi sesuai kondisi.
2. Gunakan perulangan (loop) untuk mengulang tugas otomatis.
3. Buat fungsi sendiri (def) agar kode kamu ringkas dan bisa dipakai ulang.
4. Latihan dengan proyek nyata: mulai dari auto-grader sederhana sampai
loop-driven simulator.
 5. Gunakan checklist untuk memastikan semua kemampuan dasar logika sudah
terkuasai.

Praktek Step-by-Step

Langkah 1 — Logika Dasar (if–elif–else)

Program tanpa logika = mesin buta.

Tambahkan percabangan agar kode bisa berpikir.

Contoh file day4_keputusan.py:

nilai = int(input("Masukkan nilai ujian: "))

if nilai >= 90:

print("Nilai kamu A. Hebat!")

elif nilai >= 75:

print("Nilai kamu B. Cukup baik.")

elif nilai >= 60:

print("Nilai kamu C. Perlu latihan lagi.")

else:

print("Nilai kamu D. Ayo ulangi belajarnya.")

Sekarang program bisa membuat keputusan sendiri berdasarkan input.

Tambahkan variasi:

if nilai == 100:

print("Nilai sempurna! Kamu jenius.")

Gunakan ==, !=, >, <, >=, <= untuk semua bentuk logika.

Langkah 2 — Loop for

Loop membuat kamu bisa mengulang sesuatu tanpa menulis ulang kode.
Contoh file day5_loop.py:

for i in range(1, 6):

print("Hari ke-", i)

Output:

Hari ke- 1

Hari ke- 2

Hari ke- 3

Hari ke- 4

Hari ke- 5

Sekarang ubah jadi lebih berguna:

nama = ["Andi", "Budi", "Citra"]

for orang in nama:

print("Selamat belajar,", orang)

Kamu baru membuat loop dinamis yang bisa membaca data dari list.

Langkah 3 — Loop while

Gunakan while untuk mengulang sampai kondisi tertentu berhenti.

Contoh day6_counter.py:

angka = 0

while angka < 5:

print("Angka:", angka)

angka += 1
Program akan berhenti otomatis saat angka mencapai 5.
Loop ini cocok untuk kasus di mana kamu tidak tahu batas akhir secara pasti.

Langkah 4 — Fungsi (def)

Tanpa fungsi, kode kamu akan berantakan dan sulit dibaca.

Fungsi menyimpan logika dalam satu tempat agar bisa dipakai berulang kali.

Contoh day7_fungsi.py:

def salam(nama):

print(f"Halo {nama}, selamat datang di BuildQuest!")

salam("Andi")

salam("Sinta")

Output:

Halo Andi, selamat datang di BuildQuest!

Halo Sinta, selamat datang di BuildQuest!

Coba fungsi dengan parameter dan return value:

def hitung_diskon(harga, persen):

potongan = harga * persen / 100

return harga - potongan

total = hitung_diskon(200000, 10)

print("Harga setelah diskon:", total)

Sekarang fungsi kamu mengembalikan nilai yang bisa digunakan di bagian lain program.
Langkah 5 — Nested Logic: Loop + If + Fungsi

Gabungkan semua konsep menjadi satu program mini yang “berpikir dan bertindak”.

File day8_autograder.py:

def konversi(nilai):

if nilai >= 90:

return "A"

elif nilai >= 75:

return "B"

elif nilai >= 60:

return "C"

else:

return "D"

daftar_nilai = [95, 80, 72, 60, 40]

for n in daftar_nilai:

print(f"Nilai {n} → Grade {konversi(n)}")

Program ini menilai 5 siswa sekaligus tanpa input manual.

Kamu baru saja membuat auto-grader sederhana — logika, loop, dan fungsi bekerja sama.

Langkah 6 — Tantangan Praktis

Buat program yang membaca data daftar belanja dan menghitung total otomatis.
File day9_belanja.py:

belanja = {

"beras": 12000,

"telur": 20000,

"ayam": 35000,
 "sayur": 5000

total = 0

for item, harga in [Link]():

print(f"{[Link]()} - Rp{harga}")

total += harga

if total > 50000:

print("Kamu belanja lumayan banyak!")

else:

print("Belanja kamu masih ringan.")

print("Total belanja:", total)

Kamu sudah belajar cara menggabungkan loop, logika, dan data structure.

Langkah 7 — Buat Fungsi Sendiri (Reusable Utility)

Sekarang buat satu fungsi kecil yang bisa dipakai di proyek mana pun.

def cek_genap(angka):

return angka % 2 == 0

for i in range(1, 11):

if cek_genap(i):

print(i, "adalah genap")

else:

print(i, "adalah ganjil")

Ini akan sering kamu gunakan di proyek berikutnya, terutama untuk validasi data dan logika
algoritmik.

Contoh Nyata

Kamu bekerja di toko online kecil dan ingin menghitung diskon otomatis setiap kali
pelanggan belanja.

File diskon_otomatis.py:

def hitung_total(harga, jumlah, diskon=0):

subtotal = harga * jumlah

potongan = subtotal * (diskon / 100)

total = subtotal - potongan

return total

produk = [

("Kaos", 100000, 2, 10),

("Celana", 150000, 1, 0),

("Jaket", 250000, 1, 20)

for nama, harga, jumlah, diskon in produk:

total = hitung_total(harga, jumlah, diskon)

print(f"{nama}: Rp{total:,}")

Output:

Kaos: Rp180,000

Celana: Rp150,000
Jaket: Rp200,000

Kamu baru membuat sistem kasir otomatis berbasis fungsi.

Tugas / Checklist Bab 2

Pastikan kamu sudah menguasai semua sebelum lanjut:

● Menggunakan if–elif–else untuk keputusan otomatis.

● Membuat for dan while loop dengan benar.
● Membuat minimal 3 fungsi yang bisa dipakai ulang.
● Menyelesaikan proyek auto-grader, cek belanja, dan diskon otomatis.
● Memahami bagaimana loop, logika, dan fungsi bekerja bersama.

Jika semua sudah kamu capai, kamu siap beralih ke fase berikutnya: manipulasi data
dalam dunia nyata.

Bridge ke Bab 3

Kamu sudah bisa membuat program yang berpikir dan mengulang pekerjaan tanpa kamu
awasi.
Langkah berikutnya: belajar bagaimana menyimpan, memproses, dan mengelola data
dalam skala kecil maupun besar.
Di Bab 3 — Struktur Data Python dalam Dunia Nyata, kamu akan mengubah data mentah
menjadi sesuatu yang bisa diolah, dicari, dan digunakan untuk proyek-proyek otomatisasi
berikutnya.

Bab 3 — Struktur Data Python dalam Dunia Nyata

Tujuan Bab

Setelah menyelesaikan bab ini, kamu bisa menyimpan, memproses, dan memanipulasi
data dengan Python secara efisien menggunakan struktur data bawaan: list, tuple,
set, dan dictionary.
Hasil akhirnya: kamu bisa membuat program yang mengelola data pelanggan, stok barang,
transaksi, hingga laporan keuangan — pondasi dari hampir semua aplikasi nyata.

Strategi
 1. Pahami peran empat struktur data utama di Python: list, tuple, set, dan
dict.
2. Gunakan struktur yang tepat untuk masalah yang tepat.
3. Bangun proyek data nyata: seperti pencatat keuangan, inventori, dan daftar
pelanggan.
4. Gabungkan dengan logika dan loop dari bab sebelumnya agar data bisa hidup
dan dinamis.
5. Validasi hasil lewat checklist proyek untuk memastikan kamu siap ke tahap
otomatisasi file dan API.

Praktek Step-by-Step

Langkah 1 — Kenalan dengan List

List = kumpulan data berurutan yang bisa diubah.

produk = ["Beras", "Telur", "Gula", "Minyak"]

print(produk[0]) # Beras

[Link]("Kopi") # tambah item

[Link]("Gula") # hapus item

print(produk)

List cocok untuk data dinamis: daftar nama, tugas harian, atau log aktivitas.

Latihan cepat:

todo = []

for i in range(3):

tugas = input("Masukkan tugas ke-" + str(i+1) + ": ")

[Link](tugas)

print("\nDaftar tugas kamu hari ini:")

for t in todo:

print("-", t)
Kamu baru saja membuat to-do list interaktif sederhana.

Langkah 2 — Tuple: Data yang Tidak Boleh Diubah

Tuple mirip list, tapi datanya tetap (immutable).

koordinat = (12.4, -7.3)

print("Latitude:", koordinat[0])

print("Longitude:", koordinat[1])

Tuple ideal untuk data yang tidak berubah, misalnya posisi GPS, versi software, atau
konfigurasi sistem.

Contoh kasus:

versi = ("Python", 3, 12)

print(f"Saat ini kamu pakai {versi[0]} versi {versi[1]}.{versi[2]}")

Langkah 3 — Set: Data Unik Tanpa Duplikasi

Set menghapus elemen duplikat otomatis.

email = {"a@[Link]", "b@[Link]", "a@[Link]"}

print(email) # hasil: {'a@[Link]', 'b@[Link]'}

Contoh penggunaan nyata:

data = ["a", "b", "a", "c", "c", "d"]

unik = set(data)

print("Data unik:", unik)

Set cocok untuk validasi dan penghapusan data ganda — misalnya daftar pelanggan unik.
Langkah 4 — Dictionary: Data dengan Label (Key–Value)

Dictionary (dict) menyimpan data dengan pasangan kunci–nilai.

pelanggan = {

"nama": "Andi",

"umur": 25,

"email": "andi@[Link]"

print(pelanggan["nama"])

pelanggan["status"] = "aktif"

print(pelanggan)

Dictionary adalah bentuk data paling fleksibel — kamu akan memakainya di hampir semua
proyek nyata.

Langkah 5 — Nested Structure: Data dalam Data

Kamu bisa menggabungkan struktur data untuk membuat model kompleks.

Contoh day10_pelanggan.py:

daftar_pelanggan = [

{"nama": "Andi", "umur": 25, "saldo": 150000},

{"nama": "Budi", "umur": 30, "saldo": 250000},

{"nama": "Citra", "umur": 22, "saldo": 180000}

for p in daftar_pelanggan:

print(f"{p['nama']} - Saldo: Rp{p['saldo']}")

Output:

Andi - Saldo: Rp150000

Budi - Saldo: Rp250000

Citra - Saldo: Rp180000

Kamu baru membuat data pelanggan seperti yang dipakai di sistem kasir atau CRM.

Langkah 6 — Simulasi Data Transaksi

Gunakan dictionary untuk mencatat penjualan.

transaksi = [

{"produk": "Beras", "harga": 12000, "jumlah": 5},

{"produk": "Telur", "harga": 20000, "jumlah": 2},

{"produk": "Kopi", "harga": 15000, "jumlah": 1}

total = 0

for t in transaksi:

subtotal = t["harga"] * t["jumlah"]

total += subtotal

print(f"{t['produk']} x {t['jumlah']} = Rp{subtotal}")

print("Total pembelian:", total)

Hasilnya:

Beras x 5 = Rp60000

Telur x 2 = Rp40000
Kopi x 1 = Rp15000

Total pembelian: 115000

Kamu sudah membuat sistem kasir sederhana berbasis data dictionary.

Langkah 7 — Gabungkan Semua: Data + Logika + Loop

Buat proyek pencatat saldo dengan validasi otomatis.

akun = {"nama": "Sinta", "saldo": 100000}

while True:

print(f"\nSaldo saat ini: Rp{akun['saldo']}")

aksi = input("Pilih [tambah/kurang/keluar]: ")

if aksi == "tambah":

jumlah = int(input("Masukkan jumlah: "))

akun["saldo"] += jumlah

elif aksi == "kurang":

jumlah = int(input("Masukkan jumlah: "))

if jumlah <= akun["saldo"]:

akun["saldo"] -= jumlah

else:

print("Saldo tidak cukup!")

elif aksi == "keluar":

break

else:

print("Perintah tidak dikenal.")

print("Program selesai.")

Sekarang program kamu sudah bisa menyimpan, memproses, dan memperbarui data
real-time.

Contoh Proyek Nyata

1. Pencatat Keuangan Harian

catatan = []

while True:

deskripsi = input("Masukkan deskripsi (atau 'stop' untuk berhenti): ")

if deskripsi == "stop":

break

nominal = int(input("Masukkan jumlah: "))

tipe = input("Tipe [masuk/keluar]: ")

[Link]({"deskripsi": deskripsi, "nominal": nominal, "tipe": tipe})

total = 0

for c in catatan:

if c["tipe"] == "masuk":

total += c["nominal"]

else:

total -= c["nominal"]

print("Saldo akhir:", total)

Kamu baru membuat aplikasi keuangan sederhana berbasis dictionary dan loop.
2. Sistem Inventori Barang

gudang = {

"laptop": 5,

"keyboard": 10,

"mouse": 8

barang = input("Masukkan nama barang: ").lower()

jumlah = int(input("Jumlah keluar: "))

if barang in gudang:

if gudang[barang] >= jumlah:

gudang[barang] -= jumlah

print(f"Sisa stok {barang}: {gudang[barang]}")

else:

print("Stok tidak cukup!")

else:

print("Barang tidak ditemukan!")

Kamu sudah bisa membuat sistem inventori mini — dasar aplikasi manajemen stok modern.

3. Analisis Data Penjualan

penjualan = [

{"produk": "A", "terjual": 120},

{"produk": "B", "terjual": 85},

 {"produk": "C", "terjual": 150}

total = sum([p["terjual"] for p in penjualan])

rata = total / len(penjualan)

terlaris = max(penjualan, key=lambda x: x["terjual"])

print("Total unit terjual:", total)

print("Rata-rata:", rata)

print("Produk terlaris:", terlaris["produk"])

Hasilnya memberi kamu insight sederhana — seperti laporan toko online mini.

Tugas / Checklist Bab 3

Pastikan kamu sudah menguasai poin berikut sebelum lanjut:

● Bisa menggunakan list, tuple, set, dan dict.

● Bisa menyimpan dan membaca data dari struktur kompleks.
● Menyelesaikan minimal 3 proyek: keuangan, inventori, penjualan.
● Bisa memproses data dengan logika dan loop tanpa error.
● Paham kapan harus memilih struktur data tertentu (mutable vs immutable).

Jika semua sudah terpenuhi, berarti kamu siap melangkah ke dunia nyata berikutnya:
otomatisasi file dan pekerjaan harian dengan Python.

Bridge ke Bab 4

Kamu sudah bisa menyimpan dan memproses data di memori. Tapi semua data itu akan
hilang saat program berhenti.
Langkah berikutnya: belajar membaca, menulis, dan memanipulasi file di komputer
secara otomatis.
Di Bab 4 — File Handling & Otomatisasi Harian, kamu akan membuat program yang bisa
bekerja untukmu: menata file, membuat laporan, dan mengirim data tanpa harus kamu buka
satu per satu.
Bab 4 — File Handling & Otomatisasi Harian
Tujuan Bab

Setelah menyelesaikan bab ini, kamu akan bisa membaca, menulis, dan mengelola file di
komputer secara otomatis menggunakan Python.
Kamu akan belajar bagaimana membuat skrip yang bisa memindahkan file, mengolah data
CSV, membuat laporan otomatis, dan bahkan mengirim hasil lewat email — semua tanpa
klik manual.
Hasil akhirnya: kamu punya asisten digital pribadi yang bisa menghemat 1–2 jam kerja
setiap hari.

Strategi

1. Pahami dasar file handling (buka, baca, tulis, ubah, hapus).

2. Gunakan modul os, shutil, dan pathlib untuk mengelola file & folder.
3. Baca & tulis file data (CSV, TXT, JSON).
4. Bangun otomatisasi nyata seperti backup, laporan harian, atau pengelola file.
5. Checklist & validasi hasil agar proyekmu benar-benar jalan otomatis tanpa campur
tangan manual.

Praktek Step-by-Step

Langkah 1 — Dasar File Handling

Setiap file bisa dibuka dengan fungsi open(). Format umumnya:

file = open("[Link]", "w") # mode w = write

[Link]("Halo BuildQuest!\n")

[Link]("Belajar Python setiap hari.\n")

[Link]()

Sekarang buka kembali file-nya untuk dibaca:

file = open("[Link]", "r")

isi = [Link]()

[Link]()
print(isi)

Kamu baru saja membuat dan membaca file teks di Python.

Gunakan mode:

● "r" → read
● "w" → write (hapus isi lama)
● "a" → append (tambah di akhir file)

Langkah 2 — Gunakan Context Manager (with)

Supaya lebih aman dan otomatis menutup file:

with open("[Link]", "a") as f:

[Link]("Hari ini belajar Python.\n")

with open("[Link]", "r") as f:

print([Link]())

Context manager (with) memastikan file selalu tertutup meskipun terjadi error.

Langkah 3 — Bekerja dengan Modul OS

Modul os mengizinkan kamu menjelajahi dan mengatur file/folder di sistem.

import os

print("Lokasi kerja saat ini:", [Link]())

[Link]("laporan") # buat folder baru

[Link]("[Link]", "laporan/laporan_harian.txt")
Sekarang file kamu otomatis berpindah ke folder baru.
Inilah dasar untuk membangun sistem backup dan penataan otomatis.

Langkah 4 — Menghapus & Memindahkan File

Gunakan [Link]() dan [Link]():

import os, shutil

# pindahkan file

[Link]("laporan/laporan_harian.txt", "laporan_arsip.txt")

# hapus file lama

if [Link]("[Link]"):

[Link]("[Link]")

Setelah latihan ini, kamu sudah bisa mengatur folder kerja seperti robot.

Langkah 5 — Baca File CSV

CSV (Comma-Separated Values) adalah format umum untuk data tabel (Excel, Google
Sheet, laporan keuangan, dll).

import csv

with open("[Link]", "r") as file:

reader = [Link](file)

for baris in reader:

print(baris["produk"], "-", baris["jumlah"])

Contoh isi file [Link]:

produk,jumlah,harga

Beras,5,12000

Telur,2,20000

Kopi,1,15000

Kamu bisa hitung total otomatis:

total = 0

with open("[Link]", "r") as file:

reader = [Link](file)

for baris in reader:

subtotal = int(baris["jumlah"]) * int(baris["harga"])

total += subtotal

print("Total:", total)

Sekarang Python kamu sudah bisa membaca data penjualan layaknya Excel otomatis.

Langkah 6 — Tulis File CSV Baru

import csv

data = [

{"nama": "Andi", "nilai": 90},

{"nama": "Budi", "nilai": 75},

{"nama": "Citra", "nilai": 82}

with open("[Link]", "w", newline="") as file:

 fieldnames = ["nama", "nilai"]

writer = [Link](file, fieldnames=fieldnames)

[Link]()

[Link](data)

Kamu baru saja membuat file CSV dari Python — seperti ekspor Excel otomatis.

Langkah 7 — Bekerja dengan JSON

JSON (JavaScript Object Notation) sering digunakan untuk menyimpan konfigurasi atau
data API.

import json

profil = {"nama": "Andi", "umur": 25, "hobi": ["coding", "makan"]}

with open("[Link]", "w") as f:

[Link](profil, f)

with open("[Link]", "r") as f:

data = [Link](f)

print(data["hobi"])

JSON ini sangat penting karena kamu akan menggunakannya di bab tentang API dan web
app nanti.

Langkah 8 — Proyek: Backup Otomatis Harian

Buat skrip [Link] yang membuat salinan otomatis file penting.

import os, shutil

from datetime import datetime

sumber = "laporan_arsip.txt"

tujuan_folder = "backup"

if not [Link](tujuan_folder):

[Link](tujuan_folder)

timestamp = [Link]().strftime("%Y%m%d_%H%M%S")

tujuan_file = f"{tujuan_folder}/backup_{timestamp}.txt"

[Link](sumber, tujuan_file)

print("Backup berhasil:", tujuan_file)

Sekarang setiap kali kamu jalankan file ini, Python akan membuat salinan otomatis
dengan cap waktu unik.

Langkah 9 — Proyek: Laporan Harian Otomatis

Gabungkan penulisan dan pembacaan file untuk membuat log aktivitas otomatis.

from datetime import datetime

log = f"{[Link]().strftime('%d-%m-%Y %H:%M:%S')} - Belajar Python BuildQuest\n"

with open("log_harian.txt", "a") as f:

[Link](log)

print("Log harian tercatat!")

Buka file log_harian.txt dan kamu akan melihat riwayat belajar kamu tersimpan
otomatis setiap kali menjalankan program.

Langkah 10 — Tantangan Nyata: Email Otomatis (Opsional)

Jika kamu ingin lebih maju, gunakan smtplib untuk mengirim file laporan via email.

import smtplib

from [Link] import MIMEText

pesan = MIMEText("Laporan BuildQuest hari ini sudah selesai.")

pesan["Subject"] = "Laporan Harian Otomatis"

pesan["From"] = "emailkamu@[Link]"

pesan["To"] = "emailtujuan@[Link]"

server = smtplib.SMTP_SSL("[Link]", 465)

[Link]("emailkamu@[Link]", "password_aplikasi")

server.send_message(pesan)

[Link]()

print("Email terkirim!")

Sekarang Python kamu bukan cuma membaca dan menulis file — tapi berkomunikasi
seperti manusia.

Contoh Kasus Nyata

1. Organizer File

Pisahkan file otomatis berdasarkan ekstensi.

import os, shutil

folder = "Downloads"

for file in [Link](folder):

if [Link](".jpg") or [Link](".png"):

[Link](f"{folder}/{file}", f"{folder}/Gambar/{file}")

elif [Link](".pdf"):

[Link](f"{folder}/{file}", f"{folder}/Dokumen/{file}")

print("File berhasil ditata.")

Kamu baru menciptakan sistem manajemen folder otomatis.

2. Pembuatan Laporan CSV Mingguan

import csv

from datetime import datetime

data = [

{"hari": "Senin", "penjualan": 5},

{"hari": "Selasa", "penjualan": 8},

{"hari": "Rabu", "penjualan": 4}

tanggal = [Link]().strftime("%Y%m%d")

with open(f"laporan_{tanggal}.csv", "w", newline="") as f:

writer = [Link](f, fieldnames=["hari", "penjualan"])

[Link]()

[Link](data)
print("Laporan mingguan tersimpan.")

Python kini menjadi asisten administrasi otomatis.

3. Monitoring Folder (Konsep Lanjutan)

Kamu bisa pakai pustaka seperti watchdog (nanti di bab lanjutan) untuk mendeteksi
perubahan file secara real-time — dasar dari sistem otomatis seperti Google Drive Sync.

Tugas / Checklist Bab 4

Sebelum lanjut ke bab berikutnya, pastikan kamu sudah:

● Bisa membuat, membaca, menulis, dan menghapus file.

● Bisa membuat folder otomatis dengan os atau pathlib.
● Bisa membaca dan menulis file CSV & JSON.
● Membuat minimal 2 proyek: backup otomatis dan laporan harian otomatis.
● (Opsional) Mengirim file laporan lewat email.

Jika semua sudah kamu lakukan, kamu resmi naik level: Python kamu bukan cuma cerdas
— tapi juga bekerja tanpa disuruh.

Bridge ke Bab 5

Sekarang Python kamu sudah bisa mengelola file di komputer sendiri.

Langkah berikutnya: buat Python kamu terhubung ke dunia luar — internet, API, dan
data global.
Di Bab 5 — Koneksi Internet & API, kamu akan belajar mengambil data dari web, seperti
harga saham, cuaca, atau berita terbaru, lalu mengolahnya jadi aplikasi interaktif.

Bab 5 — Koneksi Internet & API

Tujuan Bab

Setelah menyelesaikan bab ini, kamu akan bisa mengambil, mengolah, dan menampilkan
data dari internet menggunakan API (Application Programming Interface).
Kamu akan belajar cara Python berkomunikasi dengan layanan eksternal — mulai dari
cuaca, kripto, berita, hingga AI — lalu menampilkannya dalam format yang bisa digunakan
untuk aplikasi web atau otomatisasi laporan.
Hasil akhirnya: kamu bisa membangun program Python yang selalu up-to-date dengan
data nyata dari internet.

Strategi

1. Pahami cara kerja API dan HTTP request.

2. Gunakan modul requests untuk mengambil data dari web.
3. Pelajari cara membaca data JSON dan menampilkannya.
4. Bangun proyek nyata: aplikasi cuaca, harga kripto, dan translator mini.
5. Siapkan data hasil API untuk digunakan di proyek web (Bab 6).

Praktek Step-by-Step

Langkah 1 — Apa Itu API?

API adalah jembatan komunikasi antar aplikasi.

Contoh: kamu bisa “bertanya” ke situs cuaca lewat Python, dan API akan mengembalikan
jawaban dalam format data (biasanya JSON).

Contoh URL API:

[Link]

Buka di browser, kamu akan melihat data dalam format JSON — seperti kamus besar
digital.

Langkah 2 — Mengambil Data API

Instal library requests jika belum ada:

pip install requests

Kemudian jalankan:

import requests

url = "[Link]
respon = [Link](url)

print("Kode Status:", respon.status_code)

data = [Link]()

print(data["rates"]["IDR"])

Output:

Kode Status: 200

16234.12

Artinya 1 USD ≈ 16.234 IDR. Kamu baru saja mengambil data real-time dari internet.

Langkah 3 — Menampilkan Data API dengan Format Rapi

mata_uang = ["USD", "SGD", "JPY"]

for m in mata_uang:

url = f"[Link]

r = [Link](url).json()

print(f"1 {m} = {r['rates']['IDR']} Rupiah")

Sekarang program kamu bisa menampilkan kurs real-time dari berbagai negara.

Langkah 4 — Akses API Cuaca

Buka situs: [Link]

Buat akun gratis dan dapatkan API key. Gunakan contoh berikut:

import requests
api_key = "MASUKKAN_API_KEY_KAMU"

kota = input("Masukkan nama kota: ")

url =
f"[Link]

data = [Link](url).json()

print("Cuaca di", kota)

print("Suhu:", data["main"]["temp"], "°C")

print("Deskripsi:", data["weather"][0]["description"])

Output:

Cuaca di Bandung

Suhu: 26 °C

Deskripsi: scattered clouds

Kamu baru saja membuat aplikasi cuaca real-time dengan Python.

Langkah 5 — API Berita

Kamu bisa menarik berita terbaru menggunakan API seperti [Link]:

import requests

api_key = "MASUKKAN_API_KEY_KAMU"

url = f"[Link]

res = [Link](url)

data = [Link]()
for i, artikel in enumerate(data["articles"][:5]):

print(f"{i+1}. {artikel['title']}")

Output:

1. Harga BBM Naik, Pemerintah Jelaskan Alasan

2. Rupiah Menguat Terhadap Dolar

3. AI Digunakan Dalam Pendidikan Indonesia

...

Python kamu kini terhubung langsung ke portal berita dunia.

Langkah 6 — Translator Mini dengan API Gratis

Gunakan API LibreTranslate (tanpa API key untuk testing).

import requests

text = input("Masukkan teks (Inggris): ")

url = "[Link]

data = {

"q": text,

"source": "en",

"target": "id"

response = [Link](url, data=data).json()

print("Terjemahan:", response["translatedText"])
Contoh:

Input: "Good morning, Python developer!"

Output: "Selamat pagi, pengembang Python!"

Python kamu kini bisa menerjemahkan bahasa otomatis.

Langkah 7 — Gabungkan API + File Handling

Ambil data API dan simpan ke CSV otomatis.

import requests, csv

url = "[Link]

data = [Link](url).json()

with open("[Link]", "w", newline="") as f:

writer = [Link](f)

[Link](["Mata Uang", "Nilai terhadap IDR"])

for k, v in data["rates"].items():

[Link]([k, v])

print("Data kurs tersimpan ke [Link]")

Kamu baru membuat otomatisasi laporan ekonomi real-time.

Langkah 8 — API Error Handling

Pastikan program tetap berjalan walau API error.

import requests
try:

res = [Link]("[Link]

res.raise_for_status()

except [Link] as e:

print("Terjadi error:", e)

Python akan menampilkan pesan error yang mudah dipahami tanpa crash total.

Langkah 9 — Proyek Nyata: Dashboard Informasi Real-Time

Gabungkan semua data API jadi satu laporan.

import requests

from datetime import datetime

# Data cuaca

weather = [Link]("[Link]

# Data kurs

rate = [Link]("[Link]

idr = rate["rates"]["IDR"]

# Data crypto

crypto = [Link]("[Link]

btc = crypto["bpi"]["IDR"]["rate"]

print(f"\n=== DASHBOARD HARIAN ===")

print("Tanggal:", [Link]().strftime("%d-%m-%Y %H:%M"))

print("Cuaca Jakarta:", weather)

print("1 USD =", idr, "IDR")

print("Harga Bitcoin:", btc, "IDR")

Hasil:

=== DASHBOARD HARIAN ===

Tanggal: 15-12-2025 19:45

Cuaca Jakarta: 30°C Partly cloudy

1 USD = 16234.12 IDR

Harga Bitcoin: 1,074,523,900 IDR

Kamu baru saja membuat dashboard real-time data ekonomi dan cuaca.

Contoh Kasus Nyata

1. Bot Telegram atau Discord: kirim data API langsung ke chat.

2. Sistem monitoring harga: alert otomatis kalau harga saham/kripto turun.
3. Aplikasi perjalanan: tampilkan cuaca dan kurs lokal otomatis.

Dengan API, Python kamu bisa menjadi jembatan digital antara dunia nyata dan dunia kode.

Tugas / Checklist Bab 5

Pastikan semua ini sudah kamu kuasai sebelum lanjut:

● Bisa menggunakan requests untuk mengambil data dari API.

● Bisa membaca dan menulis hasil ke file CSV/JSON.
● Sudah membuat minimal 3 proyek: cuaca, kurs, dan translator.
● Mengerti cara menangani error API.
● Sudah membuat dashboard real-time data sederhana.

Jika semua sudah terpenuhi, kamu siap menuju level berikutnya: membuat aplikasi web
nyata dengan Python.
 Bridge ke Bab 6

Kamu sekarang bisa mengambil dan mengolah data dari internet.

Langkah berikutnya: menampilkan data itu di halaman web buatan kamu sendiri.
Di Bab 6 — Web Project dengan Flask, kamu akan membangun web app Python
sederhana yang bisa menampilkan data API dan berinteraksi dengan pengguna langsung
lewat browser.

Bab 6 — Web Project dengan Flask

Tujuan Bab

Setelah menyelesaikan bab ini, kamu akan bisa membangun aplikasi web sederhana
menggunakan Flask, framework Python yang ringan dan populer untuk backend.
Kamu akan membuat website yang bisa menampilkan data, menerima input pengguna,
memproses hasilnya, dan bahkan menampilkan data API di halaman web.
Hasil akhirnya: kamu akan punya web app Python pertama kamu — bisa diakses lewat
browser, dikustomisasi, dan siap di-deploy ke internet.

Strategi

1. Pahami dasar Flask — cara membuat server dan halaman pertama.

2. Gunakan route (@[Link]) untuk mengatur halaman dan logika.
3. Kirim data ke halaman HTML dengan render_template().
4. Bangun proyek nyata: kalkulator web, form input, dan aplikasi API web.
5. Deploy aplikasi ke internet agar bisa diakses publik.

Praktek Step-by-Step

Langkah 1 — Instalasi Flask

Pastikan kamu punya Flask di sistem:

pip install flask

Buat folder proyek:

mkdir webquest

cd webquest
Buat file [Link]:

from flask import Flask

app = Flask(__name__)

@[Link]("/")

def home():

return "Halo, BuildQuest Web!"

if __name__ == "__main__":

[Link](debug=True)

Jalankan di terminal:

python [Link]

Buka browser dan ketik:

[Link]

Jika muncul tulisan “Halo, BuildQuest Web!”, artinya web server kamu sudah hidup!

Langkah 2 — Tambah Halaman HTML

Buat folder baru templates di dalam webquest.

Tambahkan file [Link]:

<!DOCTYPE html>

<html>

<head>
 <title>BuildQuest Home</title>

</head>

<body>

<h1>Selamat Datang di Python BuildQuest Web</h1>

<p>Proyek Flask pertama kamu berhasil dijalankan!</p>

</body>

</html>

Lalu ubah [Link]:

from flask import Flask, render_template

app = Flask(__name__)

@[Link]("/")

def home():

return render_template("[Link]")

if __name__ == "__main__":

[Link](debug=True)

Sekarang web kamu sudah menampilkan halaman HTML dari template — bukan lagi teks
biasa.

Langkah 3 — Tambah Route Baru

Tambahkan halaman lain, misalnya “Tentang”:

@[Link]("/tentang")

def tentang():
 return "<h2>Python BuildQuest — Belajar lewat 100 proyek nyata.</h2>"

Coba buka:

[Link]

Kamu sudah membuat multi-page web app.

Langkah 4 — Form Input dan Output

Buat form sederhana untuk menerima input pengguna.

templates/[Link]

<!DOCTYPE html>

<html>

<head><title>Hitung Diskon</title></head>

<body>

<h2>Hitung Diskon Produk</h2>

<form action="/hasil" method="POST">

<label>Harga Awal (Rp):</label><br>

<input type="number" name="harga"><br><br>

<label>Diskon (%):</label><br>

<input type="number" name="diskon"><br><br>

<button type="submit">Hitung</button>

</form>

</body>

</html>

Lalu ubah [Link]:

from flask import Flask, render_template, request

app = Flask(__name__)

@[Link]("/")

def home():

return render_template("[Link]")

@[Link]("/hasil", methods=["POST"])

def hasil():

harga = int([Link]["harga"])

diskon = int([Link]["diskon"])

total = harga - (harga * diskon / 100)

return f"<h3>Harga setelah diskon: Rp{int(total):,}</h3>"

if __name__ == "__main__":

[Link](debug=True)

Sekarang kamu punya kalkulator diskon berbasis web yang memproses input pengguna!

Langkah 5 — Tampilkan Data API di Halaman Web

Gabungkan Flask + API seperti di bab sebelumnya.

import requests

from flask import Flask, render_template

app = Flask(__name__)
@[Link]("/")

def kurs():

data = [Link]("[Link]

return render_template("[Link]", rates=data["rates"])

templates/[Link]

<!DOCTYPE html>

<html>

<head><title>Kurs Harian</title></head>

<body>

<h2>Kurs Mata Uang (1 USD = ?)</h2>

<ul>

{% for mata, nilai in [Link]() %}

<li>{{ mata }} : {{ "%.2f"|format(nilai) }}</li>

{% endfor %}

</ul>

</body>

</html>

Jalankan [Link] dan buka di browser — kamu baru saja membuat aplikasi kurs real-time
dengan Python!

Langkah 6 — Menyimpan Data ke File

Tambahkan fitur untuk mencatat hasil input ke file.

@[Link]("/simpan", methods=["POST"])

def simpan():
 nama = [Link]["nama"]

with open("data_pengunjung.txt", "a") as f:

[Link](nama + "\n")

return f"<p>Terima kasih, {nama}, datamu tersimpan!</p>"

Buat form baru di [Link]:

<form action="/simpan" method="POST">

<input type="text" name="nama" placeholder="Masukkan nama kamu">

<button type="submit">Kirim</button>

</form>

Setiap kali seseorang mengisi nama, datanya otomatis tersimpan di file .txt di server.

Langkah 7 — Gunakan Template Variabel

Gunakan render_template() untuk menampilkan hasil yang dinamis.

@[Link]("/halo/<nama>")

def halo(nama):

return render_template("[Link]", nama=nama)

templates/[Link]

<h1>Halo, {{ nama }}!</h1>

<p>Selamat datang di BuildQuest Flask Web</p>

Buka di browser:

[Link]
Hasil:
Halo, Sinta!
Kamu baru memahami dasar dynamic web rendering.

Langkah 8 — Proyek Nyata: Mini Dashboard Cuaca

Gabungkan API, form, dan tampilan dinamis.

[Link]

import requests

from flask import Flask, render_template, request

app = Flask(__name__)

@[Link]("/", methods=["GET", "POST"])

def cuaca():

if [Link] == "POST":

kota = [Link]["kota"]

api_key = "MASUKKAN_API_KEY_KAMU"

url =
f"[Link]

data = [Link](url).json()

suhu = data["main"]["temp"]

deskripsi = data["weather"][0]["description"]

return render_template("[Link]", kota=kota, suhu=suhu, deskripsi=deskripsi)

return render_template("[Link]")

templates/[Link]

<!DOCTYPE html>
<html>

<head><title>Cuaca</title></head>

<body>

<h2>Cek Cuaca</h2>

<form method="POST">

<input type="text" name="kota" placeholder="Masukkan nama kota">

<button type="submit">Cek</button>

</form>

{% if kota %}

<h3>Cuaca di {{ kota }}</h3>

<p>Suhu: {{ suhu }} °C</p>

<p>Deskripsi: {{ deskripsi }}</p>

{% endif %}

</body>

</html>

Kamu baru saja membuat dashboard cuaca web interaktif berbasis API.

Langkah 9 — Deploy ke Internet

1. Buat akun di [Link] (gratis).

2. Upload proyek kamu ke GitHub.
3. Hubungkan repository kamu di Render dan pilih runtime: Python → Flask.
4. Tunggu proses build selesai.

Web kamu bisa diakses di URL publik seperti:

[Link]

5.

Selamat! Kamu baru saja mempublikasikan aplikasi web Python pertamamu ke dunia.
 Contoh Kasus Nyata

● Form feedback pelanggan otomatis.

● Dashboard kurs real-time.
● Aplikasi cuaca global dengan peta interaktif.
● Web personal project showcase (portfolio).

Flask ringan, fleksibel, dan bisa dikombinasikan dengan API, file handling, dan database
untuk aplikasi yang lebih besar nanti.

Tugas / Checklist Bab 6

Pastikan kamu sudah menyelesaikan:

● Bisa menjalankan server Flask lokal.

● Bisa membuat minimal 3 route berbeda.
● Sudah menampilkan data dari API di halaman HTML.
● Sudah membangun form input → output hasil.
● Sudah membuat dan meng-deploy aplikasi sederhana (opsional).

Jika semua checklist sudah terisi, kamu sudah resmi menjadi developer Python web
pemula yang produktif.

Bridge ke Bab 7

Kamu kini bisa menampilkan data di web.

Langkah berikutnya: belajar bagaimana menganalisis dan memvisualisasikan data di
Python menggunakan pustaka pandas dan matplotlib.
Di Bab 7 — Data Science Mini Journey, kamu akan belajar bagaimana Python mengubah
data mentah menjadi insight visual — laporan yang berbicara sendiri.

Bab 7 — Data Science Mini Journey

Tujuan Bab

Setelah menyelesaikan bab ini, kamu akan bisa mengolah, menganalisis, dan
memvisualisasikan data menggunakan Python.
Kamu akan belajar membaca file dataset (CSV/Excel), membersihkan data, membuat
ringkasan statistik, dan menampilkan grafik visual yang informatif.
Hasil akhirnya: kamu bisa membuat laporan data otomatis dan visualisasi profesional
tanpa perlu software tambahan seperti Excel atau Power BI.
 Strategi

1. Pelajari dasar pustaka data: pandas, matplotlib, dan numpy.

2. Gunakan dataset nyata untuk latihan (penjualan, keuangan, suhu, dsb).
3. Bersihkan, analisis, dan visualisasikan data.
4. Bangun proyek mini: laporan penjualan, tren pengeluaran, analisis data pelanggan.
5. Simpan hasil visual ke file otomatis.

Praktek Step-by-Step

Langkah 1 — Instalasi Pustaka Data

Ketik di terminal:

pip install pandas matplotlib numpy

Pandas digunakan untuk membaca dan mengolah data.

Matplotlib untuk membuat grafik.
Numpy untuk perhitungan numerik.

Langkah 2 — Membaca Dataset

Misal kamu punya file [Link] seperti ini:

tanggal,produk,jumlah,harga

2025-12-01,beras,5,12000

2025-12-02,gula,2,15000

2025-12-02,beras,3,12000

2025-12-03,minyak,4,18000

Gunakan kode:

import pandas as pd

df = pd.read_csv("[Link]")
print([Link]())

Output:

tanggal produk jumlah harga

0 2025-12-01 beras 5 12000

1 2025-12-02 gula 2 15000

2 2025-12-02 beras 3 12000

3 2025-12-03 minyak 4 18000

Sekarang kamu punya dataframe — format tabel yang bisa diolah seperti Excel, tapi
dengan kode.

Langkah 3 — Menambah Kolom dan Menghitung Total

df["total"] = df["jumlah"] * df["harga"]

print(df)

Output:

tanggal produk jumlah harga total

0 2025-12-01 beras 5 12000 60000

1 2025-12-02 gula 2 15000 30000

2 2025-12-02 beras 3 12000 36000

3 2025-12-03 minyak 4 18000 72000

Kamu sudah membuat kolom baru hasil perhitungan otomatis.

Langkah 4 — Analisis Dasar

Hitung total penjualan dan rata-rata:

print("Total keseluruhan:", df["total"].sum())

print("Rata-rata per transaksi:", df["total"].mean())

Hitung total per produk:

print([Link]("produk")["total"].sum())

Output:

beras 96000

gula 30000

minyak 72000

Python kini bisa mengelompokkan data secara otomatis.

Langkah 5 — Analisis Berdasarkan Tanggal

penjualan_harian = [Link]("tanggal")["total"].sum()

print(penjualan_harian)

Output:

2025-12-01 60000

2025-12-02 66000

2025-12-03 72000

Ini mirip laporan harian toko, hanya dengan 3 baris kode.

Langkah 6 — Visualisasi Data

Tambahkan grafik agar laporan lebih mudah dibaca.

import [Link] as plt

penjualan_harian.plot(kind="bar", title="Total Penjualan Harian")

[Link]("Tanggal")

[Link]("Total Penjualan (Rp)")

plt.tight_layout()

[Link]()

Hasilnya: grafik batang total penjualan per hari.

Langkah 7 — Visualisasi Produk Terlaris

produk_terlaris = [Link]("produk")["total"].sum()

produk_terlaris.plot(kind="pie", autopct="%1.1f%%", title="Proporsi Penjualan per Produk")

[Link]("")

[Link]()

Kamu baru membuat grafik pie chart interaktif untuk proporsi penjualan per produk.

Langkah 8 — Menyimpan Laporan

penjualan_harian.to_csv("laporan_harian.csv")

[Link]("grafik_penjualan.png")

print("Laporan dan grafik tersimpan.")

Sekarang kamu bisa menghasilkan laporan otomatis setiap hari tanpa buka Excel sama
sekali.

Langkah 9 — Proyek Nyata: Analisis Keuangan Harian

import pandas as pd

import [Link] as plt

data = {

"hari": ["Senin", "Selasa", "Rabu", "Kamis", "Jumat"],

"pemasukan": [500000, 600000, 550000, 700000, 800000],

"pengeluaran": [300000, 400000, 350000, 450000, 500000]

df = [Link](data)

df["saldo"] = df["pemasukan"] - df["pengeluaran"]

print(df)

[Link](df["hari"], df["saldo"], marker="o")

[Link]("Laporan Saldo Harian")

[Link]("Hari")

[Link]("Saldo (Rp)")

[Link](True)

[Link]()

Kamu baru saja membuat grafik saldo mingguan otomatis.

Langkah 10 — Analisis Pelanggan

Gunakan data dummy pelanggan:

data = {
 "nama": ["Andi", "Budi", "Citra", "Dewi", "Eko"],

"transaksi": [5, 3, 8, 2, 10],

"rata_pembelian": [120000, 90000, 150000, 70000, 180000]

df = [Link](data)

df["total_spent"] = df["transaksi"] * df["rata_pembelian"]

print(df.sort_values(by="total_spent", ascending=False))

Output:

nama transaksi rata_pembelian total_spent

4 Eko 10 180000 1800000

2 Citra 8 150000 1200000

0 Andi 5 120000 600000

...

Sekarang kamu tahu siapa pelanggan terbaik (top spender).

Kamu bisa gunakan hasil ini untuk strategi promosi atau personalisasi produk.

Contoh Kasus Nyata

1. Toko online: analisis produk terlaris dan tren penjualan mingguan.

2. Freelancer: laporan penghasilan otomatis per klien.
3. Perusahaan kecil: analisis pengeluaran bulanan untuk efisiensi.
4. Investor: melacak tren harga saham dan return harian.

Python bisa menggantikan seluruh proses manual Excel, dan bahkan jauh lebih cepat.

Tugas / Checklist Bab 7

Pastikan kamu sudah menguasai semua ini:

 ● Bisa membaca file CSV dengan pandas.
● Bisa membuat kolom baru hasil perhitungan.
● Bisa melakukan agregasi data dengan groupby().
● Sudah membuat minimal 2 grafik (bar dan pie).
● Bisa mengekspor hasil analisis ke file CSV dan gambar.
● Sudah menyelesaikan proyek analisis keuangan sederhana.

Jika semua sudah kamu capai, kamu siap masuk ke dunia Machine Learning — tahap di
mana Python mulai berpikir sendiri.

Bridge ke Bab 8

Kamu sekarang sudah bisa membaca, menganalisis, dan menampilkan data dengan
Python.
Langkah berikutnya: ajarkan Python untuk mengenali pola dan membuat prediksi.
Di Bab 8 — AI & Machine Learning Dasar, kamu akan belajar membuat model sederhana
yang bisa memprediksi harga, mengklasifikasi teks, dan memahami data seperti manusia.

Bab 8 — AI & Machine Learning Dasar

Tujuan Bab

Setelah menyelesaikan bab ini, kamu akan mampu membuat model Machine Learning
(ML) sederhana di Python untuk melakukan prediksi, klasifikasi, dan analisis pola data.
Kamu akan belajar bagaimana Python “berpikir” melalui data: mengenali pola, belajar dari
contoh, lalu memberikan hasil prediksi baru secara otomatis.
Hasil akhirnya: kamu bisa membuat proyek AI mini seperti prediksi harga, klasifikasi teks,
dan chatbot sederhana — dasar sebelum masuk ke AI tingkat lanjut seperti deep learning.

Strategi

1. Pahami konsep inti ML: supervised learning, training, testing, dan evaluasi.
2. Gunakan pustaka scikit-learn untuk membangun model cepat dan ringan.
3. Gunakan dataset nyata dan bagi jadi data latih (train) dan uji (test).
4. Bangun 3 proyek nyata: regresi, klasifikasi, dan clustering.
5. Simpan model untuk digunakan kembali di aplikasi lain.

Praktek Step-by-Step

Langkah 1 — Instalasi Pustaka ML

Jalankan di terminal:

pip install scikit-learn pandas numpy matplotlib

Langkah 2 — Konsep Inti Machine Learning

Machine Learning bekerja dengan langkah sederhana:

1. Kumpulkan data.
2. Pisahkan data jadi dua bagian: training (belajar) dan testing (uji hasil).
3. Latih model agar mengenali pola dari data training.
4. Uji model untuk melihat seberapa akurat prediksi.
5. Gunakan model untuk memprediksi data baru.

Langkah 3 — Proyek 1: Prediksi Harga (Regresi Linear)

Gunakan dataset sederhana.

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

import [Link] as plt

# Dataset

data = {

"luas": [30, 50, 70, 100, 120, 150],

"harga": [500, 800, 1100, 1500, 1800, 2200]

df = [Link](data)

# Pisahkan fitur dan target

X = df[["luas"]] # fitur
y = df["harga"] # target

# Bagi data jadi training dan testing

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Latih model

model = LinearRegression()

[Link](X_train, y_train)

# Prediksi harga baru

prediksi = [Link]([[90]])

print("Prediksi harga rumah (90m²):", int(prediksi[0]), "juta")

# Visualisasi

[Link](X, y, color="blue")

[Link](X, [Link](X), color="red")

[Link]("Prediksi Harga Rumah vs Luas Tanah")

[Link]("Luas (m²)")

[Link]("Harga (juta)")

[Link]()

Python akan menggambar garis merah — representasi hubungan antara luas dan harga
rumah.
Model ini bisa digunakan untuk prediksi harga otomatis.

Langkah 4 — Proyek 2: Klasifikasi Teks (Spam Filter)

Buat model sederhana untuk mendeteksi email spam.

from sklearn.feature_extraction.text import CountVectorizer

from sklearn.naive_bayes import MultinomialNB

# Dataset

pesan = [

"Selamat Anda menang hadiah!",

"Diskon besar hanya hari ini!",

"Rapat besok jam 10 pagi",

"Laporan proyek sudah dikirim",

"Menangkan iPhone gratis sekarang!"

label = ["spam", "spam", "biasa", "biasa", "spam"]

# Ubah teks ke bentuk numerik

vectorizer = CountVectorizer()

X = vectorizer.fit_transform(pesan)

# Latih model

model = MultinomialNB()

[Link](X, label)

# Tes model

uji = ["Dapatkan hadiah besar sekarang!"]

hasil = [Link]([Link](uji))

print("Pesan:", uji[0])

print("Klasifikasi:", hasil[0])
Output:

Pesan: Dapatkan hadiah besar sekarang!

Klasifikasi: spam

Kamu baru saja membuat detektor spam sederhana hanya dengan beberapa baris kode.

Langkah 5 — Proyek 3: Clustering (Pengelompokan Data)

Clustering = mengelompokkan data otomatis tanpa label (unsupervised learning).

from [Link] import KMeans

import numpy as np

import [Link] as plt

# Data acak pelanggan

X = [Link]([

[25, 5000000],

[30, 7000000],

[22, 4000000],

[40, 12000000],

[35, 10000000],

[23, 4500000],

])

# Buat model clustering

kmeans = KMeans(n_clusters=2)

[Link](X)
labels = kmeans.labels_

[Link](X[:, 0], X[:, 1], c=labels, cmap='rainbow')

[Link]("Segmentasi Pelanggan Berdasarkan Umur dan Penghasilan")

[Link]("Umur")

[Link]("Pendapatan")

[Link]()

Hasilnya: dua kelompok warna berbeda yang mewakili segmen pelanggan kaya dan
menengah.

Langkah 6 — Menyimpan dan Menggunakan Ulang Model

Simpan model ke file agar bisa dipakai di proyek lain.

import joblib

[Link](model, "model_prediksi.pkl")

Untuk menggunakannya lagi:

model_baru = [Link]("model_prediksi.pkl")

print(model_baru.predict([[100]]))

Sekarang kamu punya model cerdas permanen yang bisa kamu pakai di aplikasi lain
(seperti web app Flask).

Langkah 7 — Evaluasi Akurasi Model

Pastikan model kamu benar-benar belajar dengan baik.

from [Link] import r2_score, accuracy_score

pred_y = [Link](X_test)

print("Akurasi regresi:", r2_score(y_test, pred_y))

Jika nilainya mendekati 1, berarti model kamu sangat akurat.

Langkah 8 — Mini Project: Chatbot AI Dasar

Gunakan if dan pola teks untuk simulasi chatbot sederhana (tanpa ML kompleks dulu):

while True:

tanya = input("Kamu: ").lower()

if "halo" in tanya:

print("Bot: Halo juga! Apa kabar?")

elif "harga" in tanya:

print("Bot: Harga tergantung jenis produk. Mau lihat daftarnya?")

elif "keluar" in tanya:

print("Bot: Sampai jumpa!")

break

else:

print("Bot: Aku belum paham maksudmu.")

Sekarang kamu punya AI sederhana yang bisa merespons percakapan.

Contoh Kasus Nyata

1. Prediksi penjualan berdasarkan data historis.

2. Klasifikasi pelanggan berdasarkan perilaku transaksi.
3. Deteksi anomali (fraud atau spam).
4. Model rekomendasi sederhana (produk atau konten).

Machine Learning bukan sihir — hanya matematika yang diajarkan untuk berpikir logis.
Dan Python membuat prosesnya menjadi sangat praktis.
 Tugas / Checklist Bab 8

Pastikan kamu sudah menyelesaikan hal-hal berikut:

● Mengerti konsep supervised dan unsupervised learning.

● Membuat model regresi linear (prediksi harga).
● Membuat model klasifikasi teks (spam filter).
● Membuat model clustering (segmentasi pelanggan).
● Menyimpan dan memuat model dengan joblib.
● Menjalankan evaluasi akurasi model.

Jika semua checklist sudah tercentang, kamu telah resmi memasuki dunia AI Python
praktis.

Bridge ke Bab 9

Kamu sekarang bisa membuat Python berpikir sendiri — mengenali pola dan memprediksi
hasil.
Langkah berikutnya: gabungkan semua kemampuanmu (file, web, API, data, dan AI) ke
dalam proyek utuh yang bisa digunakan sehari-hari.
Di Bab 9 — Full Integration Projects, kamu akan membangun sistem nyata yang
menggabungkan semua skill Python yang sudah kamu pelajari — satu proyek besar yang
terasa seperti produk profesional.

Bab 9 — Full Integration Projects

Tujuan Bab

Di bab ini, kamu akan menggabungkan semua kemampuan Python yang sudah kamu
pelajari menjadi satu sistem utuh — mulai dari pengambilan data (API & file), analisis,
visualisasi, hingga tampilan web.
Kamu tidak lagi belajar potongan skill; kamu akan membangun proyek yang terasa
seperti aplikasi profesional sungguhan.

Hasil akhirnya: kamu memiliki 1 proyek kompleks yang mengintegrasikan logika, data, API,
AI, dan web — bisa dijadikan portofolio developer di GitHub atau LinkedIn.

Strategi

1. Tentukan ide proyek terpadu yang memanfaatkan minimal 3 kemampuan dari bab
sebelumnya.
2. Bangun struktur folder rapi agar proyek bisa dijalankan siapa pun.
 3. Gunakan API atau file eksternal sebagai sumber data.
4. Gunakan Flask untuk tampilan web hasil.
5. Tambahkan elemen otomatisasi (laporan, notifikasi, atau prediksi AI).

Praktek Step-by-Step

Kita akan membangun proyek utama:

Project: Smart Dashboard — Sistem Monitoring

Penjualan Otomatis
Proyek ini akan:

● Membaca data transaksi dari file CSV.

● Mengambil kurs USD–IDR real-time dari API.
● Menganalisis performa produk & membuat grafik otomatis.
● Menampilkan hasil di halaman web Flask.
● Menggunakan model AI sederhana untuk memprediksi penjualan minggu depan.

Langkah 1 — Struktur Folder

Buat folder proyek:

smart_dashboard/

├── [Link]

├── data/

│ └── [Link]

├── static/

│ └── [Link]

└── templates/

├── [Link]

└── [Link]
Langkah 2 — Siapkan Data Penjualan

File: data/[Link]

tanggal,produk,jumlah,harga

2025-12-01,beras,5,12000

2025-12-02,gula,2,15000

2025-12-03,beras,7,12000

2025-12-03,minyak,3,18000

2025-12-04,beras,4,12000

2025-12-04,gula,6,15000

Langkah 3 — App Flask (Dasar)

File: [Link]

from flask import Flask, render_template

import pandas as pd

import [Link] as plt

import requests

app = Flask(__name__)

@[Link]("/")

def home():

# 1⃣ Ambil data CSV

df = pd.read_csv("data/[Link]")

df["total"] = df["jumlah"] * df["harga"]

 # 2⃣ Ambil kurs USD–IDR real-time

url = "[Link]

kurs = [Link](url).json()["rates"]["IDR"]

# 3⃣ Analisis data

per_produk = [Link]("produk")["total"].sum()

# 4⃣ Buat grafik

[Link](figsize=(6,4))

per_produk.plot(kind="bar", color="orange")

[Link]("Total Penjualan per Produk")

[Link]("Produk")

[Link]("Total Penjualan (Rp)")

plt.tight_layout()

[Link]("static/[Link]")

# 5⃣ Kirim data ke web

total_semua = df["total"].sum()

return render_template("[Link]",

total=total_semua,

kurs=kurs,

produk=per_produk.to_dict())

Langkah 4 — Template Web

File: templates/[Link]

<!DOCTYPE html>

<html>

<head>

<title>Smart Dashboard Penjualan</title>

</head>

<body>

<h1>Smart Dashboard Penjualan</h1>

<p><b>Total Penjualan:</b> Rp{{ "{:,}".format(total) }}</p>

<p><b>Kurs USD-IDR (Real-time):</b> {{ "{:,.2f}".format(kurs) }}</p>

<h3>Data Penjualan per Produk</h3>

<ul>

{% for p, t in [Link]() %}

<li>{{ p }}: Rp{{ "{:,}".format(t) }}</li>

{% endfor %}

</ul>

<img src="/static/[Link]" alt="Grafik Penjualan">

<hr>

<a href="/prediksi">Lihat Prediksi Penjualan Minggu Depan</a>

</body>

</html>
Langkah 5 — Tambahkan Prediksi AI Sederhana

Tambahkan route baru di [Link]:

from sklearn.linear_model import LinearRegression

import numpy as np

@[Link]("/prediksi")

def prediksi():

df = pd.read_csv("data/[Link]")

df["total"] = df["jumlah"] * df["harga"]

# Hitung total harian

harian = [Link]("tanggal")["total"].sum().reset_index()

harian["hari_ke"] = range(1, len(harian) + 1)

# Latih model

X = harian[["hari_ke"]]

y = harian["total"]

model = LinearRegression().fit(X, y)

pred = [Link]([[len(harian) + 1]])[0]

return render_template("[Link]",

pred=int(pred),

data=harian.to_dict(orient="records"))
Langkah 6 — Halaman Prediksi

File: templates/[Link]

<!DOCTYPE html>

<html>

<head>

<title>Prediksi Penjualan</title>

</head>

<body>

<h2>Prediksi Penjualan Minggu Depan</h2>

<p>Prediksi total penjualan besok: <b>Rp{{ "{:,}".format(pred) }}</b></p>

<h3>Data Historis</h3>

<table border="1" cellpadding="5">

<tr><th>Tanggal</th><th>Total Penjualan</th></tr>

{% for row in data %}

<tr>

<td>{{ row["tanggal"] }}</td>

<td>Rp{{ "{:,}".format(row["total"]) }}</td>

</tr>

{% endfor %}

</table>

<br>

<a href="/"> Kembali ke Dashboard</a>

</body>

</html>
Sekarang kamu bisa membuka:

[Link]

untuk melihat dashboard penjualan real-time, dan klik “Lihat Prediksi Penjualan Minggu
Depan” untuk melihat hasil AI.

Langkah 7 — Tambahkan Laporan Otomatis

Tambahkan kode di bawah route / untuk menyimpan laporan otomatis:

df.to_csv("data/laporan_terakhir.csv", index=False)

print("Laporan tersimpan otomatis.")

Setiap kali aplikasi dijalankan, data terbaru akan disimpan sebagai file laporan.

Langkah 8 — Opsional: Kirim Laporan via Email

Tambahkan di bawah proyek kamu:

import smtplib

from [Link] import MIMEText

def kirim_email():

pesan = MIMEText("Laporan penjualan BuildQuest terbaru sudah diupdate.")

pesan["Subject"] = "Laporan Harian Otomatis"

pesan["From"] = "emailkamu@[Link]"

pesan["To"] = "emailtujuan@[Link]"

server = smtplib.SMTP_SSL("[Link]", 465)

 [Link]("emailkamu@[Link]", "password_aplikasi")

server.send_message(pesan)

[Link]()

Panggil kirim_email() setelah laporan tersimpan.

Langkah 9 — Jalankan dan Tes

Jalankan aplikasi:
python [Link]

1.
2. Buka browser → [Link]
3. Lihat dashboard, pastikan grafik tampil.
4. Klik Prediksi Penjualan Minggu Depan → tampilkan hasil AI.
5. Periksa folder data/ → file laporan terbaru otomatis dibuat.

Hasil Akhir

Kamu kini punya produk Python nyata yang terintegrasi penuh:

● Mengambil data dari file (Bab 4).

● Menyambung API real-time (Bab 5).
● Menampilkan lewat web Flask (Bab 6).
● Menganalisis & menggambar grafik (Bab 7).
● Memprediksi dengan AI sederhana (Bab 8).
● Menyimpan & mengirim laporan otomatis.

Inilah contoh nyata automated business intelligence system — dibangun dari nol dengan
Python!

Tugas / Checklist Bab 9

Pastikan kamu sudah:

● Membuat folder proyek lengkap (data, templates, static).

● Menggabungkan API, file, Flask, dan AI dalam satu proyek.
● Bisa menampilkan dashboard di browser.
● Grafik penjualan tampil otomatis.
 ● Prediksi AI berjalan dan akurat.
● Laporan disimpan otomatis setiap update.
● (Opsional) Email laporan berhasil terkirim.

Kalau semua sudah berfungsi, kamu sudah naik level ke integrator sejati — Python kamu
bukan sekadar alat belajar, tapi sistem nyata yang bisa bekerja untuk bisnis dan data
real-time.

Bridge ke Bab 10

Kamu sudah membuktikan bahwa semua skill-mu bisa digabung jadi sistem utuh.
Langkah berikutnya: waktunya membuat produk final buatanmu sendiri.
Di Bab 10 — Final Quest: Bangun Produk Sendiri dalam 20 Hari, kamu akan
menciptakan satu produk Python orisinal — mulai dari ide, rancangan, implementasi, sampai
dipublikasikan di GitHub atau web.

Bab 10 — Final Quest: Bangun Produk Sendiri dalam

20 Hari
Tujuan Bab

Ini adalah bab penentu. Setelah menyelesaikannya, kamu akan memiliki satu produk
Python utuh buatanmu sendiri — hasil nyata dari seluruh perjalanan BuildQuest.
Bukan proyek tutorial, bukan latihan pendek, tapi produk orisinal yang kamu rancang,
bangun, uji, dan rilis sendiri.
Tujuan akhirnya sederhana: kamu punya portofolio nyata yang bisa dilihat HR, klien, atau
calon investor.

Strategi

1. Pilih satu ide produk nyata yang bisa diselesaikan dalam 20 hari.
2. Bagi pengerjaan ke 4 fase: riset, desain, bangun, dan rilis.
3. Gunakan semua kemampuan Python yang kamu kuasai: logika, data, API, web,
otomatisasi, AI.
4. Gunakan sistem tracking (harian atau mingguan) agar proyek tetap berjalan.
5. Publikasikan hasil ke GitHub atau platform online.

Langkah 1 — Pilih Ide Produk Final (Hari 1–2)

Gunakan 3 kriteria berikut untuk memilih ide:

 1. Punya nilai guna nyata. Produk harus menyelesaikan masalah sederhana, bukan
sekadar keren.
2. Bisa selesai dalam ≤ 20 hari. Hindari ide besar seperti “buat game 3D” atau “AI
sosial media penuh”.
3. Bisa didemokan. Harus punya output visual atau laporan yang bisa dilihat orang.

Contoh Ide Produk Final:

● Smart Expense Tracker — aplikasi keuangan otomatis (pembacaan CSV +

laporan + grafik + reminder).
● Weather Dashboard — web app dengan API cuaca, prediksi suhu, dan laporan
PDF otomatis.
● AI Job Assistant — analisis lowongan kerja dan rekomendasi posisi terbaik
berdasarkan skill pengguna.
● Chatbot Customer Service — bot berbasis Flask yang menjawab pertanyaan
pelanggan dari FAQ CSV.
● Crypto Portfolio Tracker — ambil data API real-time, simpan transaksi, tampilkan
grafik profit.

Tugas Hari 1–2:

Tulis ide kamu di file ide_final.txt dengan format:

Nama Produk:

Deskripsi Singkat:

Masalah yang Diselesaikan:

Teknologi yang Dipakai:

Langkah 2 — Desain Struktur & Fitur (Hari 3–5)

Buat folder proyek dengan struktur berikut:

produk_final/

├── [Link]

├── core/

│ ├── data_handler.py

│ ├── api_connector.py
│ ├── ai_model.py

├── templates/

│ └── [Link]

├── static/

│ └── [Link]

└── data/

└── [Link]

Langkah:

● Tentukan alur data (dari input → proses → output).

● Buat diagram sederhana di kertas atau Notion.
● Tentukan fitur utama maksimal 3 fitur inti.
● Jangan kejar banyak fitur; kejar fungsionalitas yang benar-benar bekerja.

Contoh Fitur untuk Smart Expense Tracker:

1. Upload file CSV pengeluaran.

2. Sistem hitung total otomatis per kategori.
3. Visualisasi grafik + ekspor laporan ke PDF.

Langkah 3 — Mulai Bangun Proyek (Hari 6–15)

Gunakan metode Build–Test–Fix:

1. Bangun fitur satu per satu.

Jangan lanjut ke fitur baru sebelum fitur lama stabil.
2. Uji setiap bagian secara terpisah.
Jalankan dari terminal dan lihat output.

Gunakan Git untuk tracking perubahan.

git init

git add .

git commit -m "Versi awal produk"

3.

Tips Teknis:
 ● Gunakan Flask jika produk kamu berbasis web.
● Gunakan pandas untuk data analisis.
● Gunakan matplotlib atau plotly untuk grafik.
● Gunakan joblib untuk menyimpan model AI.
● Gunakan schedule atau cron untuk otomatisasi tugas harian.

Contoh Implementasi: Smart Expense Tracker

Berikut gambaran modul utama:

data_handler.py

import pandas as pd

def baca_data(file_path):

df = pd.read_csv(file_path)

df["total"] = df["jumlah"] * df["harga"]

return df

def total_per_kategori(df):

return [Link]("kategori")["total"].sum().to_dict()

api_connector.py

import requests

def ambil_kurs():

url = "[Link]

return [Link](url).json()["rates"]["IDR"]

ai_model.py

from sklearn.linear_model import LinearRegression

import pandas as pd

def prediksi_tren(df):

df["hari_ke"] = range(1, len(df)+1)

model = LinearRegression()

[Link](df[["hari_ke"]], df["total"])

return int([Link]([[len(df)+1]])[0])

[Link]

from flask import Flask, render_template, request

from core.data_handler import baca_data, total_per_kategori

from core.api_connector import ambil_kurs

from core.ai_model import prediksi_tren

app = Flask(__name__)

@[Link]("/", methods=["GET", "POST"])

def index():

if [Link] == "POST":

file = [Link]["file"]

df = baca_data(file)

kategori = total_per_kategori(df)

kurs = ambil_kurs()

prediksi = prediksi_tren(df)

return render_template("[Link]",

kategori=kategori,
 kurs=kurs,

pred=prediksi)

return render_template("[Link]")

if __name__ == "__main__":

[Link](debug=True)

templates/[Link]

<h2>Smart Expense Tracker</h2>

<form method="POST" enctype="multipart/form-data">

<input type="file" name="file">

<button type="submit">Upload</button>

</form>

{% if kategori %}

<h3>Rangkuman Pengeluaran</h3>

<ul>

{% for k, v in [Link]() %}

<li>{{ k }}: Rp{{ "{:,}".format(v) }}</li>

{% endfor %}

</ul>

<p>Kurs USD: {{ "{:,.2f}".format(kurs) }}</p>

<p>Prediksi Pengeluaran Besok: Rp{{ "{:,}".format(pred) }}</p>

{% endif %}

Dengan struktur ini, produk kamu benar-benar modular — mudah diperluas dan dibaca.
 Langkah 4 — Testing, Dokumentasi, dan Debugging (Hari 16–18)

1. Jalankan uji coba end-to-end.

○ Upload data → tampilkan hasil → uji grafik/prediksi.
2. Tangani error dan input tak valid (gunakan try/except).
3. Tambahkan dokumentasi singkat:
○ [Link] → menjelaskan fitur, cara pakai, dependensi, dan contoh
output.

Upload ke GitHub:
git add .

git commit -m "Rilis versi 1.0"

git push origin main

4.

Langkah 5 — Rilis Publik (Hari 19–20)

Pilih satu bentuk rilis:

● Web Deploy: gunakan Render atau Railway (gratis).

● Desktop App: bungkus dengan tkinter atau PyInstaller.
● CLI Tool: jalankan dari terminal dan ekspor laporan otomatis.

Tambahkan dokumentasi singkat di README:

# Smart Expense Tracker

Aplikasi Python untuk melacak pengeluaran otomatis dengan prediksi AI.

Setelah rilis, bagikan ke:

● GitHub (public repo)

● LinkedIn (post: “Saya baru menyelesaikan proyek Python 100 Hari”)
● Medium/Substack (artikel: “Bagaimana saya membangun aplikasi AI tanpa bootcamp
mahal”)

Hasil Akhir
Selamat — kamu kini sudah:
Membuat produk Python fungsional dari nol.
Menguasai semua aspek — dari logika, data, web, API, hingga AI.
Mempunyai portofolio profesional yang bisa kamu tunjukkan ke dunia.

Tugas / Checklist Bab 10

● Ide produk final sudah ditulis dan disetujui.

● Struktur proyek sudah dibuat dengan folder rapi.
● Semua modul utama sudah bekerja.
● UI (web/CLI) sudah bisa menampilkan hasil.
● Dokumentasi ([Link]) sudah lengkap.
● Produk sudah dirilis ke GitHub / Render.

Jika semua checklist sudah selesai → BuildQuest kamu resmi dituntaskan!

Penutup & Next Step

Kamu sudah menempuh 100 hari perjalanan dari nol hingga membangun produk Python
orisinal.
Tapi ini bukan akhir.
Ini awal karier developer yang bisa terus tumbuh — karena kamu sudah punya pola belajar
dan kemampuan membuat solusi nyata.

Langkah berikutnya:

● Pilih 1 proyek kamu → jadikan open-source.

● Tambahkan fitur baru setiap minggu.
● Kolaborasi dengan developer lain di GitHub.
● Dokumentasikan perjalananmu (jadi konten LinkedIn atau blog).

Kamu tidak lagi “belajar Python.”

Kamu membangun hidup dengan Python.

Epilog — Dari Pembelajar Menjadi Pembangun

100 hari sudah kamu jalani.
Mulai dari print("Hello, BuildQuest!") sederhana, hingga menulis aplikasi berbasis
web dan AI yang bisa memproses data nyata, kamu telah melakukan perjalanan yang tidak
semua orang bisa selesaikan.
Kamu bukan lagi “orang yang belajar Python.”
Kamu kini adalah pembangun — seseorang yang bisa memecah ide menjadi proyek, dan
proyek menjadi hasil nyata.

Refleksi 100 Hari

Coba mundur sedikit. Ingat hari pertama kamu mengetik kode Python?
Barangkali waktu itu kamu ragu:

“Apakah saya bisa benar-benar menguasai ini tanpa ikut bootcamp mahal?”

Sekarang jawabannya ada di depanmu.

Kamu bukan cuma menguasai sintaks, tapi sudah menjalankan 100 proyek nyata yang bisa
berbicara sendiri:

● Kamu tahu bagaimana membuat sistem bekerja otomatis.

● Kamu tahu bagaimana mengubah data menjadi insight.
● Kamu tahu bagaimana menghubungkan Python dengan dunia luar (API, web,
AI).
● Dan yang paling penting: kamu tahu bagaimana membangun sesuatu dari nol.

Dari Ilmu ke Aset

Keterampilan Python-mu sekarang bukan sekadar skill — tapi aset digital pribadi.
Setiap proyek yang kamu buat bisa:

● Dipajang di GitHub sebagai portofolio developer profesional.

● Dipresentasikan ke calon klien atau HR untuk menunjukkan kemampuan teknis dan
konsistensi.
● Dikonversi jadi produk atau jasa digital:
○ Otomatisasi laporan keuangan
○ Aplikasi prediksi sederhana untuk bisnis lokal
○ Tool internal untuk UMKM atau startup

Tidak ada lagi kata “belum siap”.

Karena kamu sudah punya bukti nyata.

Langkah Berikutnya: “Build, Don’t Browse”

Banyak orang berhenti belajar setelah e-book seperti ini.

Mereka kembali menonton tutorial baru, mencoba framework baru, tapi tidak membangun
apa pun.
Kamu jangan jadi salah satunya.
Mulai dari besok — jangan belajar Python lagi.
Gunakan Python.

Gunakan 1 jam sehari untuk:

● Mengembangkan fitur baru di produk finalmu.

● Memperbaiki bug kecil.
● Menulis README lebih rapi.
● Mengunggah hasil eksperimen baru ke GitHub.

Karena semakin sering kamu build, semakin kuat skill kamu.

Rencana 30 Hari Lanjutan (Post-BuildQuest)

Mingg Fokus Target Hasil

u

1 Refactor Produk Final Struktur kode modular, dokumentasi rapi

2 Tambah 1 Fitur Baru Misalnya integrasi API tambahan

3 Tulis Artikel atau Video Demo Ceritakan bagaimana kamu membangun

produkmu

4 Publikasi ke Publik / Open Upload ke GitHub, share ke LinkedIn

Source

Gunakan pola Learn → Build → Publish → Repeat.

Setiap publikasi memperkuat kredibilitas kamu sebagai developer.

Promise Awal vs Hasil Akhir

Sub Judul: “Cara Kuasai Python & Bangun 100 Proyek Nyata Tanpa Ikut
Bootcamp Mahal Dalam 100 Hari.”
Sekarang lihat: kamu benar-benar sudah melakukan itu.
Tanpa mentor mahal, tanpa biaya bootcamp jutaan rupiah, hanya dengan komitmen dan
struktur BuildQuest 100 Hari.

Kamu telah membuktikan bahwa hasil besar datang bukan dari “banyak belajar”, tapi dari
disiplin membangun setiap hari.

Pesan Penutup

Jangan berhenti di sini.

Gunakan Python sebagai alat pengungkit kariermu:

● Jadikan portofolio-mu senjata untuk apply kerja developer.

● Jadikan skill otomasi-mu alat bantu untuk bisnis pribadi.
● Jadikan proyek AI-mu sebagai bukti kreativitasmu di dunia kerja digital.

Python bukan hanya bahasa pemrograman.

Python adalah bahasa pembangun masa depan.

Dan kamu sekarang sudah berbicara lancar dalam bahasa itu.

Challenge Akhir — “Promise to Build”

Tulis janji pribadi kamu di file terakhir e-book ini:

Saya berjanji akan membangun minimal 1 proyek Python baru setiap bulan,

menguji ide saya sendiri, dan membagikannya ke dunia.

Simpan di file [Link] di folder BuildQuest100/.

Jangan biarkan e-book ini berakhir sebagai arsip.

Buat dia jadi buku kerja hidupmu.

Penutup

“Kamu tidak perlu menjadi jenius untuk menjadi builder.

Kamu hanya perlu terus membangun, setiap hari, tanpa berhenti.”

Selamat.
Kamu baru saja menyelesaikan Python BuildQuest — perjalanan 100 proyek nyata.
Sekarang waktunya dunia tahu apa yang bisa kamu bangun.
 Next Step yang Direkomendasikan:

1. Publikasikan produk final kamu ke GitHub.

2. Buat video demo 1 menit — tampilkan hasil kerja kamu di YouTube atau LinkedIn.
3. Tulis artikel pendek: “Apa yang Saya Pelajari dari 100 Hari Membangun Python
Project.”
4. Mulai proyek open-source pertama kamu.
5. Bergabung di komunitas developer (Reddit, Discord, Kaggle, GitHub).

Akhir Buku: Python BuildQuest

Karya: [Nama Kamu]
Slogan: Belajar bukan untuk tahu, tapi untuk membangun.