Dasar-Dasar Python untuk Data Science

Disusun oleh Tim Datasans

@[Link]
Peringatan

Materi dalam ebook cheatsheet ini telah divalidasi, namun bagaimanapun juga, ebook ini
tidak luput dari kesalahan baik definisi, konten secara umum, maupun syntax. Segala
masukkan dari pengguna sangat terbuka. DM kami di instagram @[Link]

Himbauan

1.​ Tidak menjadikan ebook ini satu-satunya sumber pegangan, cross check dan validasi
segala informasi dari sumber lain.
2.​ Tidak membagikan atau mencetaknya untuk diperbanyak, kecuali untuk pribadi.
3.​ Disarankan untuk merekomendasikan langsung ke instagram @[Link] jika
temanmu berminat agar ilmu yang bermanfaat bisa tersebar semakin luas.
Daftar Isi

BAB 1 – PENDAHULUAN.................................................................................................. 8
1.1 Apa itu Python?.....................................................................................................8
1.1.1 Sejarah Singkat Python..................................................................................8
1.1.2 Kelebihan Python untuk Data Science............................................................ 8
1.1.3 Perbedaan Python 2 vs Python 3.................................................................... 9
1.2 Persiapan Lingkungan Belajar................................................................................9
1.2.1 Instalasi Python (Windows, macOS, Linux).....................................................9
1.2.2 Manajemen Versi Python (pyenv, Anaconda).................................................11
1.2.3 IDE/Editor yang Direkomendasikan (VSCode, PyCharm, Jupyter Notebook)....12
1.2.4 Google Colab...............................................................................................13
1.3 Memulai Python..................................................................................................14
1.3.1 Menjalankan Python di Terminal/Command Prompt..................................... 14
1.3.2 Menjalankan Python di Jupyter Notebook..................................................... 15
1.3.3 Menjalankan Python di Google Colab........................................................... 16
1.3.4 Menjalankan Skrip .py................................................................................. 17
BAB 2 – DASAR-DASAR PYTHON.................................................................................... 17
2.1 Variabel dan Tipe Data.........................................................................................18
2.1.1 Penamaan Variabel......................................................................................18
2.1.2 Tipe Data Primitif........................................................................................19
2.1.3 Mengecek Tipe Data (type()).........................................................................20
2.2 Struktur Data Built-in...........................................................................................21
2.2.1 List.............................................................................................................21
2.2.2 Tuple.......................................................................................................... 23
2.2.3 Set..............................................................................................................24
2.2.4 Dictionary...................................................................................................25
2.3 Operator dan Ekspresi......................................................................................... 27
2.3.1 Operator Aritmatika.................................................................................... 27
2.3.2 Operator Perbandingan............................................................................... 29
2.3.3 Operator Logika (and, or, not)...................................................................... 30
2.3.4 Operator Penugasan (+=, -=, =, /=, dll.).......................................................... 32
2.3.5 Operator Bitwise (|, &, ^, ~, <<, >>)................................................................32
BAB 3 – KONTROL ALUR (CONTROL FLOW)................................................................... 35
3.1 Pernyataan Kondisional....................................................................................... 35
3.1.1 if, elif,else................................................................................................... 35
3.1.2 Nested if..................................................................................................... 36
3.2 Perulangan......................................................................................................... 37
3.2.1 for Loop......................................................................................................37
3.2.2 while Loop..................................................................................................39
 3.2.3 Pernyataan break, continue, dan pass...........................................................40
BAB 4 – FUNGSI (FUNCTIONS).......................................................................................43
4.1 Definisi Fungsi.................................................................................................... 43
4.2 Parameter dan Argumen (Positional, Default, *args, kwargs)..................................45
4.3 Return Statement................................................................................................ 48
4.4 Fungsi Lambda (Anonymous Function).................................................................49
4.5 Scope Variabel dan Namespace............................................................................ 50
BAB 5 – MODULARISASI DAN MANAJEMEN PAKET........................................................ 53
5.1 Modul................................................................................................................. 53
5.2 Paket (Packages)..................................................................................................55
5.3 Mengelola Paket dengan pip dan Virtual Environment...........................................57
BAB 6 – STRING MANIPULATION.................................................................................. 60
6.1 String Dasar........................................................................................................ 60
6.1.1 Metode String Umum.................................................................................. 62
6.2 String Formatting................................................................................................ 65
6.2.1 format()...................................................................................................... 65
6.2.2 f-String (Formatted String Literal)................................................................ 66
6.2.3 Format Spesifik (Alignment, Precision).........................................................67
6.3 Regular Expressions (Regex) Singkat.................................................................... 68
BAB 7 – PENANGANAN ERROR DAN LOGGING................................................................70
7.1 Error dan Exception............................................................................................ 70
7.2 Membuat Exception Sendiri................................................................................. 72
7.3 Logging.............................................................................................................. 73
BAB 8 – PEMROGRAMAN BERORIENTASI OBJEK (OOP) DASAR...................................... 77
8.1 Kelas dan Objek...................................................................................................77
8.2 Konsep OOP Dasar...............................................................................................79
8.2.1 Enkapsulasi................................................................................................ 79
8.2.2 Inheritance (Pewarisan)...............................................................................81
8.2.3 Polimorfisme.............................................................................................. 82
8.2.4 Abstraksi (Singkat)...................................................................................... 83
8.3 Metode Khusus (Special Methods)........................................................................ 84
8.3.1 __str__() dan __repr__()............................................................................... 84
8.3.2 Operator Overloading (__add__, __len__, dsb.)..............................................85
BAB 9 – MEMULAI DATA SCIENCE DENGAN PYTHON..................................................... 87
9.1 Pengenalan Data Science..................................................................................... 87
9.2 Lingkungan Data Science..................................................................................... 88
9.2.1 Anaconda Distribution.................................................................................88
9.2.2 Jupyter Notebook vs JupyterLab................................................................... 89
9.2.3 Perbandingan Tools Lain............................................................................. 89
BAB 10 – NUMPY: DASAR MANIPULASI ARRAY.............................................................. 92
10.1 Pengenalan NumPy............................................................................................92
 10.2 Membuat Array................................................................................................. 92
10.2.1 [Link]()..................................................................................................93
10.2.2 [Link]()............................................................................................... 93
10.2.3 [Link]()............................................................................................. 94
10.2.4 Array Khusus ([Link](), [Link](), [Link](), [Link]())......................... 94
10.3 Operasi Dasar pada Numpy Array....................................................................... 96
10.3.1 Aritmatika Dasar....................................................................................... 96
10.3.2 Akses Elemen (Indexing, Slicing)................................................................97
10.3.3 Manipulasi Bentuk (reshape, ravel, transpose).............................................98
10.3.4 Broadcasting............................................................................................. 99
10.4 Fungsi-Fungsi Statistik..................................................................................... 100
10.5 Teknik Lanjutan Numpy................................................................................... 101
10.5.1 Fancy Indexing........................................................................................ 101
10.5.2 Boolean Masking......................................................................................101
10.5.3 Concatenate dan Split Array......................................................................102
BAB 11 – PANDAS: PENGOLAHAN DATA TABEL.............................................................104
11.1 Pengenalan Pandas.......................................................................................... 104
11.2 Series.............................................................................................................. 104
11.2.1 Membuat Series (Dari List, Numpy Array, Dictionary)................................ 104
11.2.2 Atribut dan Metode Series........................................................................ 106
11.3 DataFrame.......................................................................................................106
11.3.1 Membuat DataFrame (Dari Dictionary, CSV, Excel, SQL, dll.).......................107
11.3.2 Akses Baris dan Kolom (Indexing, loc, iloc)............................................... 108
11.3.3 Menambah/Menghapus Kolom dan Baris.................................................. 110
11.3.4 Grouping (groupby())................................................................................111
11.3.5 Merge, Join, dan Concat DataFrame.......................................................... 112
11.4 Pembersihan dan Manipulasi Data.................................................................... 114
11.4.1 Menangani Data Hilang (dropna(), fillna())................................................ 114
11.4.2 Deteksi dan Perbaikan Outlier (Singkat).................................................... 116
11.4.3 Konversi Tipe Data, Memformat Tanggal................................................... 117
11.5 Metode Statistik dan Analisis............................................................................ 118
11.5.1 Descriptive Statistics (describe())...............................................................118
11.5.2 Korelasi (corr())........................................................................................119
11.5.3 Agregasi (sum, mean, count).................................................................... 120
BAB 12 – VISUALISASI DATA........................................................................................ 122
12.1 Matplotlib........................................................................................................122
12.1.1 Instalasi dan Import (import [Link] as plt)................................ 122
12.1.2 Plot Dasar (Line Plot, Scatter Plot, Bar Plot, Histogram)..............................122
Line Plot......................................................................................................122
Scatter Plot.................................................................................................. 123
Bar Plot....................................................................................................... 125
 Histogram................................................................................................... 126
12.1.3 Kustomisasi Plot (Label, Title, Legend, Grid)............................................. 127
12.1.4 Multi Subplot........................................................................................... 128
12.2 Seaborn........................................................................................................... 129
12.2.1 Instalasi dan Import (import seaborn as sns)............................................. 129
12.2.2 Plotting Tingkat Lanjut (Boxplot, Violinplot, Pairplot, Heatmap)................. 129
Boxplot........................................................................................................129
Violinplot.................................................................................................... 130
Pairplot....................................................................................................... 131
Heatmap..................................................................................................... 132
12.2.3 Palet Warna dan Gaya Visual.....................................................................133
12.3 Plotly/Altair (Opsional)..................................................................................... 134
BAB 13 – DASAR-DASAR STATISTIKA DAN PROBABILITAS UNTUK DATA SCIENCE........ 136
13.1 Statistika Deskriptif.......................................................................................... 136
13.1.1 Ukuran Pusat (Mean, Median, Mode)........................................................ 136
13.1.2 Ukuran Penyebaran (Variance, Standard Deviation, Range)........................ 137
13.2 Probabilitas..................................................................................................... 138
13.2.1 Konsep Dasar Probabilitas........................................................................ 138
13.2.2 Distribusi Umum (Normal, Uniform, Binomial, Poisson)............................ 138
13.3 Sampling dan Interval Kepercayaan (Singkat).................................................... 141
13.3.1 Sampling................................................................................................. 141
13.3.2 Confidence Interval................................................................................. 142
BAB 14 – PENGENALAN MACHINE LEARNING DI PYTHON........................................... 144
14.1 Konsep Dasar Machine Learning.......................................................................144
14.2 Scikit-Learn..................................................................................................... 144
14.2.1 Instalasi dan Import.................................................................................145
14.2.2 Alur Dasar fit, predict, dan evaluate.......................................................... 145
14.2.3 Train-Test Split.........................................................................................146
14.3 Model Dasar Supervised Learning..................................................................... 147
14.3.1 Regresi Linear (Simple dan Multiple).........................................................147
14.3.2 Klasifikasi (Logistic Regression, KNN, Decision Tree, Random Forest)........ 148
Contoh (Logistic Regression)........................................................................ 148
Contoh (KNN – K Nearest Neighbors)............................................................ 149
Decision Tree dan Random Forest.................................................................150
14.4 Model Unsupervised Learning.......................................................................... 151
14.4.1 Clustering (K-Means)................................................................................151
14.4.2 Dimensionality Reduction (PCA)............................................................... 152
BAB 15 – TIPS DAN TRIK PYTHON UNTUK DATA SCIENCE............................................154
15.1 Itertools...........................................................................................................154
15.1.1 Fungsi Penting: count(), cycle(), chain(), combinations(), permutations().... 154
15.2 Koleksi Tipe Data Khusus (collections).............................................................. 156
 15.2.1 Counter................................................................................................... 157
15.2.2 defaultdict............................................................................................... 157
15.2.3 namedtuple............................................................................................. 158
15.2.4 deque...................................................................................................... 159
15.3 Fungsi Bawaan Python yang Berguna................................................................ 159
15.3.1 map(), filter(), zip()...................................................................................160
15.4 Time dan Date................................................................................................. 160
15.4.1 datetime Module......................................................................................161
15.5 Penggunaan timeit dan Profiling Kode...............................................................162
15.5.1 timeit Module.......................................................................................... 162
15.5.2 Profiling Sederhana (cProfile)................................................................... 163
BAB 16 – PENGEMBANGAN PROYEK DATA SCIENCE SEDERHANA.................................165
16.1 Studi Kasus 1: Analisis Dataset (Exploratory Data Analysis – EDA)....................... 165
Langkah-Langkah EDA (Loading, Cleaning, Visualisasi).......................................165
Contoh script (EDA pada dataset Iris)..................................................................165
16.2 Studi Kasus 2: Model Prediksi............................................................................167
Langkah-Langkah (Train, Test, Evaluasi).............................................................167
Contoh script (Model Klasifikasi pada Iris).......................................................... 168
BAB 17 – BEST PRACTICES DAN SARAN LANJUT.......................................................... 170
17.1 Struktur Folder Proyek..................................................................................... 170
Penjelasan Struktur:.......................................................................................... 171
17.2 Kode yang Rapi dan Terbaca............................................................................. 171
Dokumentasi dan Komentar...............................................................................171
Contoh penulisan fungsi rapi:............................................................................ 172
17.3 Versi Kontrol (Git, GitHub)................................................................................172
Alur Git Dasar................................................................................................... 172
Mengelola Repositori Data Science..................................................................... 173
17.4 Pemanfaatan Lanjutan..................................................................................... 173
17.4.1 Docker untuk Proyek Data Science............................................................ 173
17.4.2 Penyebaran Model (Flask, FastAPI, Streamlit) – Singkat..............................174
BAB 18 – REFERENSI TAMBAHAN................................................................................176
18.1 Dokumentasi Resmi......................................................................................... 176
18.1.1 Dokumentasi Python................................................................................176
18.1.2 Dokumentasi NumPy, Pandas, Matplotlib, Seaborn, Scikit-Learn................ 177
18.2 Sumber Belajar Online..................................................................................... 179
18.2.1 Tutorial Resmi......................................................................................... 179
18.2.2 Kursus dan Komunitas............................................................................. 179
18.2.3 Buku Rekomendasi Lain........................................................................... 180
18.3 Glosarium Istilah............................................................................................. 180
BAB 1 – PENDAHULUAN
Bab awal ini dirancang untuk memperkenalkan kamu pada pemrograman Python, terutama
bila kamu sama sekali belum pernah belajar bahasa pemrograman. Python akan menjadi
pondasi utama untuk mempelajari data science dalam buku ini. Di sini, kita akan melihat
apa itu Python, mengapa bahasa ini populer untuk data science, dan bagaimana cara
menyiapkan lingkungan pemrograman sehingga kamu dapat mulai bereksperimen secara
langsung.

1.1 Apa itu Python?

Python adalah bahasa pemrograman tingkat tinggi yang dirancang dengan tujuan agar
sintaksnya mudah dibaca, ringkas, dan efisien. Jika kamu benar-benar pemula yang belum
pernah menyentuh kode apa pun, jangan khawatir. Python banyak sekali dipakai oleh
pemula karena sintaksnya yang “mirip” bahasa manusia.

Kamu dapat menggunakan Python untuk berbagai keperluan:

●​ Membuat skrip otomatisasi tugas (misalnya: mengunduh file secara otomatis,

mengubah format teks, dsb.).​

●​ Membangun aplikasi web sederhana (dengan framework seperti Flask atau Django).​

●​ Menganalisis data besar, membuat grafik, dan membangun model machine learning
(inilah yang disebut data science).​

Python juga sering dipakai oleh peneliti, insinyur, maupun orang-orang non-teknis yang
ingin mengolah data. Intinya, Python itu serba bisa.

1.1.1 Sejarah Singkat Python

Guido van Rossum menciptakan Python pada awal 1990-an. Nama “Python” bukan diambil
dari nama hewan ular, tapi dari grup komedi Inggris, Monty Python—jadi, kadang banyak
lelucon di dokumentasi resminya. Sejak awal, Python sengaja didesain agar mudah dibaca
dan “menyenangkan.”

Dalam perkembangannya, Python menjadi sangat populer di bidang sains dan data. Sekitar
tahun 2010-an, perpustakaan (library) Python untuk data science berkembang pesat,
misalnya NumPy, Pandas, Matplotlib, dan lain-lain. Hal itulah yang membuat Python
akhirnya menjadi bahasa yang paling sering digunakan di dunia data science saat ini.

1.1.2 Kelebihan Python untuk Data Science

 1.​ Sintaks Mudah: Bahasa pemrograman ini memiliki sintaks yang sederhana, kamu
tidak perlu menuliskan banyak tanda kurung kurawal {} atau titik koma ;. Ini
memudahkan pemula untuk belajar.​

2.​ Komunitas Besar: Python memiliki komunitas global yang aktif. Kamu akan mudah
menemukan tutorial, forum, dan jawaban ketika menemui masalah.​

3.​ Ekosistem Library: Buat data science, Python punya NumPy (untuk perhitungan
numerik), Pandas (untuk data berbentuk tabel), Matplotlib/Seaborn (untuk
visualisasi), scikit-learn (untuk machine learning), dan banyak lagi.​

4.​ Multi-platform: Python dapat dijalankan di Windows, macOS, dan Linux tanpa
perubahan berarti.​

Karena kelebihan di atas, Python menjadi “senjata utama” bagi banyak data scientist, analis
data, peneliti AI, dan bahkan startup rintisan yang butuh prototyping cepat.

1.1.3 Perbedaan Python 2 vs Python 3

Barangkali kamu akan melihat referensi “Python 2” di internet. Namun Python 2 sudah
tidak lagi didukung secara resmi sejak 2020. Python 3 adalah versi yang disarankan saat ini.
Memang ada sedikit perbedaan sintaks, tetapi hampir semua library modern kini fokus
pada Python 3.

Jadi, untuk belajar data science, pakailah Python 3 agar kamu mendapatkan semua fitur
terbaru dan dukungan komunitas.

1.2 Persiapan Lingkungan Belajar

Sebelum mulai menulis kode Python, ada baiknya kamu menyiapkan lingkungan
(environment) di komputer kamu. Tujuannya agar semua library yang dibutuhkan dapat
dijalankan dengan lancar. Ada beberapa cara untuk mengatur lingkungan Python,
tergantung sistem operasi dan preferensi kamu.

1.2.1 Instalasi Python (Windows, macOS, Linux)

1.​ Windows:​

○​ Kunjungi [Link] dan unduh installer Python

3.x.​

○​ Jalankan installer, centang “Add Python to PATH” agar kamu bisa

menjalankan Python di Command Prompt.​
 ○​ Ikuti wizard sampai selesai. Setelah itu, bukalah Command Prompt (CMD)
dan ketik python --version untuk memastikan Python sudah terpasang.​

2.​ macOS:​

○​ Beberapa macOS versi lama punya Python bawaan tapi biasanya Python 2.​

○​ Instalasi termudah adalah menggunakan installer resmi

([Link] atau menggunakan Homebrew (brew
install python).​

○​ Setelah selesai, jalankan Terminal dan ketik python3 --version untuk

memastikan instalasi berhasil.​

3.​ Linux:​

○​ Kebanyakan distro Linux modern sudah menyertakan Python 3. Coba ketik

python3 --version di Terminal.​

○​ Jika belum ada atau versinya terlalu lama, kamu bisa gunakan manajer paket
distro (misalnya apt di Ubuntu/Debian: sudo apt-get install
python3 python3-pip).​

Contoh script (cek versi Python, di terminal):

python --version

python3 --version

Output:

Python 3.10.5

Penjelasan output:

●​ Di Windows, jika python --version menampilkan Python 3.10.5, berarti

instalasi sukses.​

●​ Di macOS/Linux, biasanya perlu ketik python3 --version di terminal.​

1.2.2 Manajemen Versi Python (pyenv, Anaconda)

Ketika kamu mulai mendalami data science, mungkin kamu ingin mengelola beberapa versi
Python di komputer, misalnya Python 3.8, 3.9, 3.10. Hal ini bisa dilakukan dengan:

1.​ pyenv (terutama di Linux/Mac): Sebuah tool untuk menginstal banyak versi Python
lalu beralih satu sama lain.​

2.​ Anaconda Distribution: Sebuah paket yang menyertakan Python, conda (package
manager), serta library data science seperti NumPy, Pandas, dan lain-lain secara
default.

Banyak pemula suka memakai Anaconda karena semuanya “sudah dibundel,” sehingga tak
perlu instal library satu per satu di awal.

Contoh script (conda create environment, di terminal):

# Jika kamu pakai Anaconda, buka Anaconda Prompt atau Terminal

conda create --name dsenv python=3.9

# Lalu aktifkan environment

conda activate dsenv

# Setelah aktif, kamu bisa install library

conda install numpy pandas matplotlib

Output:

Preparing transaction: done

Verifying transaction: done

Executing transaction: done

# To activate this environment, use

# conda activate dsenv

Penjelasan output:

●​ conda create --name dsenv python=3.9 membuat environment bernama

“dsenv” yang memakai Python 3.9.​

●​ Saat environment aktif, library yang diinstal hanya berlaku di dsenv, sehingga tidak
mengganggu sistem global.

1.2.3 IDE/Editor yang Direkomendasikan (VSCode, PyCharm, Jupyter Notebook)

Ada banyak alat untuk menulis kode Python. Pilihlah yang paling nyaman bagi kamu:

1.​ Jupyter Notebook: Sering digunakan untuk data science, karena memudahkan
mengeksekusi kode per sel, lalu langsung menampilkan hasil (termasuk grafik).​

2.​ VSCode (Visual Studio Code): Editor serbaguna dari Microsoft, gratis dan mudah
diatur, termasuk untuk Python.​

3.​ PyCharm: IDE khusus Python dengan fitur lengkap, cocok untuk proyek lebih besar.​

4.​ Spyder: IDE mirip MATLAB, terkadang disertakan di Anaconda.

Buat pemula, Jupyter Notebook sangat disarankan karena kamu bisa menulis beberapa
baris kode, mengeksekusinya, lalu langsung melihat output. Ini sangat interaktif dan ideal
untuk eksplorasi data.

Contoh script (Menjalankan Jupyter Notebook setelah instal Anaconda):

# Buka Anaconda Prompt atau Terminal

conda activate dsenv

jupyter notebook

Output (dalam browser):

Jendela browser akan terbuka menampilkan halaman Jupyter dengan daftar folder di lokasi
kamu menjalankan perintah. Kamu bisa klik “New” -> “Python 3 (ipykernel)” untuk
membuat notebook baru.

Penjelasan output:

●​ Jupyter Notebook akan memunculkan interface web. Di sana kamu dapat membuat
sel kode Python lalu jalankan dengan menekan Shift+Enter.​
1.2.4 Google Colab

Google Colab ([Link] adalah layanan gratis dari Google yang

memungkinkan kamu menjalankan Python di cloud tanpa perlu menginstal apa pun di
komputer. Kamu hanya butuh akun Google (misalnya Gmail).

1.​ Cara Menggunakan:​

○​ Buka link Colab, pilih “New Notebook” atau buka notebook contoh.​

○​ Kamu akan melihat tampilan mirip Jupyter Notebook. Di setiap sel, kamu
bisa menulis kode Python dan mengeksekusinya.​

○​ Semua proses terjadi di server Google, jadi komputer kamu tidak perlu
spesifikasi tinggi.​

2.​ Kelebihan:​

○​ Tidak perlu instal Python dan library, karena Colab sudah menyertakan
banyak library data science seperti NumPy, Pandas, TensorFlow, dsb.​

○​ Akses GPU gratis (dengan batas tertentu), cocok untuk percobaan machine
learning atau deep learning sederhana.​

○​ Mudah berbagi dengan orang lain—cukup bagikan link notebook.​

3.​ Kekurangan:​

○​ Perlu koneksi internet yang stabil.​

○​ Session Colab akan reset setelah beberapa jam tidak aktif, jadi kamu perlu
menyimpan data atau notebook di Google Drive.​

Contoh script (kode sederhana di Google Colab):

import numpy as np​

​
arr = [Link](5)​
print("Array random:", arr)​
print("Rata-rata:", [Link](arr))

Output (contoh):
Array random: [0.48461373 0.97367287 0.20371304 0.6418225
0.56403912]

Rata-rata: 0.573172251

Penjelasan output:

●​ Kode ini di eksekusi pada sel Colab. Hasilnya akan tampil tepat di bawah sel.​

●​ [Link](5) menghasilkan array acak berisi 5 nilai float di rentang [0,1).​

●​ [Link](arr) menghitung rata-rata semua nilai di arr.​

Google Colab sangat berguna bila spesifikasi komputer kamu terbatas, atau jika kamu ingin
berkolaborasi dengan rekan lain secara online.

1.3 Memulai Python

Setelah Python terinstal (atau kamu memilih menggunakan Google Colab), langkah
selanjutnya adalah memahami bagaimana cara menjalankannya. Ada beberapa cara:

1.​ Menggunakan Terminal/Command Prompt: Mengetik python di CMD/Terminal.​

2.​ Menggunakan Jupyter Notebook atau Google Colab: Membuat sel (cell), menulis
kode Python, lalu mengeksekusinya.​

3.​ Menjalankan Skrip .py: Menulis kode di file teks berekstensi .py, lalu
menjalankannya.

1.3.1 Menjalankan Python di Terminal/Command Prompt

Contoh script (Interaktif di terminal):

python

Output (contoh):

Python 3.10.5 (tags/whatever)

Type "help", "copyright", ...

>>>
Penjelasan output:

●​ Tanda >>> berarti kamu masuk ke mode interaktif Python.​

●​ Kamu bisa mengetik perintah seperti print("Halo Python") dan menekan

Enter. Python akan segera mengeksekusi perintah itu.​

Contoh kode di shell Python:

>>> print("Halo Python")

Halo Python

>>> 2 + 3

1.3.2 Menjalankan Python di Jupyter Notebook

1.​ Buka Terminal atau Anaconda Prompt, lalu ketik jupyter notebook.​

2.​ Browser akan menampilkan halaman Jupyter.​

3.​ Klik “New” -> “Python 3 (ipykernel)” untuk membuat notebook baru.​

4.​ Muncul halaman dengan sel kosong, ketik kode di sel.​

5.​ Tekan Shift+Enter untuk mengeksekusi.​

Contoh script di Jupyter Notebook (dalam satu sel):

print("Halo, Jupyter!")​
x = 10​
y = 5​
print("x + y =", x + y)

Output:

Halo, Jupyter!
x + y = 15

Penjelasan output:

●​ Jupyter Notebook akan menampilkan hasil print langsung di bawah sel yang
dieksekusi, sehingga kamu bisa melihat hasil tanpa perlu membuka jendela CMD.​

●​ Notebook sangat membantu untuk menulis “catatan” (markdown) dan kode Python
berdampingan, sehingga cocok untuk data science.

1.3.3 Menjalankan Python di Google Colab

1.​ Buka [Link] pastikan sudah login dengan akun Google.​

2.​ Klik “New Notebook” atau buka salah satu “Examples.”​

3.​ Kamu akan melihat sel yang mirip Jupyter Notebook.​

4.​ Tulis kode Python di sel dan tekan tombol ▶ atau Ctrl+Enter untuk mengeksekusi.​

Contoh script (di Colab):

import math​
​
print("Contoh di Google Colab")​
print("Hasil sin(90 derajat):", [Link]([Link](90)))

Output:

Contoh di Google Colab

Hasil sin(90 derajat): 1.0

Penjelasan:

●​ import math memanggil modul matematika bawaan Python.​

●​ [Link](90) mengkonversi 90 derajat ke radian, lalu [Link](...)

menghitung nilai sin, yang hasilnya 1.0 (90° = π/2 rad, sin(π/2)=1).
1.3.4 Menjalankan Skrip .py

Kadang, kamu mau menyimpan kode Python ke dalam file .py lalu menjalankannya seperti
program biasa. Ini berguna kalau kamu ingin membuat proyek yang lebih besar atau
otomatis tanpa harus membuka notebook atau Colab.

Contoh script ([Link]):

# [Link]​
print("Ini adalah skrip Python pertama kamu!")

Setelah kamu membuat file [Link], jalankan perintah ini di terminal:

python [Link]

Output:

Ini adalah skrip Python pertama kamu!

Penjelasan:

●​ Program mengeksekusi seluruh isi file [Link] mulai dari baris pertama hingga
terakhir.​

●​ Jika kamu punya lebih banyak baris di [Link], semua akan dijalankan secara
berurutan.

BAB 2 – DASAR-DASAR PYTHON

Bab ini akan membahas pondasi utama dalam pemrograman Python. Kamu akan
mempelajari bagaimana cara memberikan nama pada variabel, mengenali berbagai tipe
data, menggunakan struktur data bawaan (list, tuple, set, dictionary), hingga memahami
berbagai operator untuk melakukan operasi matematis, perbandingan, logika, serta
penugasan. Meski tampak banyak, inilah dasar yang sangat penting agar kamu dapat
melangkah lebih jauh ke pengolahan data dan data science.

2.1 Variabel dan Tipe Data

2.1.1 Penamaan Variabel

Dalam Python, variabel adalah “wadah” yang dapat menyimpan berbagai nilai. Kita bisa
menyimpan angka, teks, list, dan lain-lain ke dalam variabel. Pemilihan nama variabel
harus mengikuti aturan tertentu:

●​ Hanya boleh mengandung huruf (a–z, A–Z), angka (0–9), dan underscore (_).​

●​ Tidak boleh diawali dengan angka.​

●​ Tidak boleh menggunakan kata kunci (keyword) yang sudah dipesan Python seperti
if, while, for, True, False, dll.​

●​ Sebisa mungkin gunakan nama yang deskriptif agar kode mudah dibaca (misal:
jumlah_data, nama_pengguna, dll.).​

Contoh script:

# Penamaan variabel yang benar​

nama = "Budi"​
usia = 25​
jumlah_barang = 10​
​
# Penamaan variabel yang salah (akan error)​
# 1stValue = 100 # Tidak boleh diawali angka​
# for = 10 # 'for' adalah keyword Python​
​
print(nama, usia, jumlah_barang)

Output:

Budi 25 10
Penjelasan output:

●​ Program mencetak isi variabel nama, usia, dan jumlah_barang secara berurutan.
Variabel dapat menyimpan data dengan tipe berbeda, misalnya nama (string), usia
(integer), dan jumlah_barang (integer).

Dalam konteks data science, pemberian nama variabel yang deskriptif penting agar
memudahkan kolaborasi dan penelusuran data.

2.1.2 Tipe Data Primitif

Tipe data adalah bentuk data yang disimpan di dalam variabel. Python memiliki beberapa
tipe data primitif, di antaranya:

1.​ Integer: Bilangan bulat (contoh: 1, -5, 100).​

2.​ Float: Bilangan pecahan/desimal (contoh: 3.14, -0.001).​

3.​ Boolean: Tipe data yang hanya bernilai True atau False.​

4.​ String: Kumpulan karakter atau teks (contoh: "Hello", "123").​

5.​ Complex Number: Bilangan kompleks (contoh: 3+5j).​

Contoh script:

# Contoh berbagai tipe data primitif​

bilangan_bulat = 10 # integer​
bilangan_pecahan = 3.14 # float​
nilai_boolean = True # boolean​
teks = "Belajar Python" # string​
bilangan_kompleks = 2 + 3j # complex​
​
print("bilangan_bulat:", bilangan_bulat, "->", type(bilangan_bulat))​
print("bilangan_pecahan:", bilangan_pecahan, "->",
type(bilangan_pecahan))​
print("nilai_boolean:", nilai_boolean, "->", type(nilai_boolean))​
print("teks:", teks, "->", type(teks))​
print("bilangan_kompleks:", bilangan_kompleks, "->",
type(bilangan_kompleks))

Output:
bilangan_bulat: 10 -> <class 'int'>

bilangan_pecahan: 3.14 -> <class 'float'>

nilai_boolean: True -> <class 'bool'>

teks: Belajar Python -> <class 'str'>

bilangan_kompleks: (2+3j) -> <class 'complex'>

Penjelasan output:

●​ type() menunjukkan bahwa variabel bilangan_bulat termasuk int,

bilangan_pecahan termasuk float, dan seterusnya.​

●​ Python secara otomatis mengenali tipe data berdasarkan nilai yang kita berikan.

2.1.3 Mengecek Tipe Data (type())

Untuk mengetahui tipe data suatu variabel, kamu dapat menggunakan fungsi bawaan
type(). Ini berguna terutama saat kamu belum yakin apakah data kamu berbentuk
integer, float, string, atau tipe lain. Dalam dunia data science, terkadang data yang diimpor
dari file CSV atau sumber eksternal memiliki tipe yang tidak sesuai perkiraan, sehingga
type() dapat membantu pengecekan awal.

Contoh script:

angka = 42​
kata = "Empat puluh dua"​
​
print(type(angka))​
print(type(kata))

Output:

<class 'int'>

<class 'str'>

Penjelasan output:

●​ print(type(angka)) menampilkan <class 'int'> yang berarti variabel

angka adalah integer.​
 ●​ print(type(kata)) menampilkan <class 'str'> yang berarti variabel kata
adalah string.

2.2 Struktur Data Built-in

Struktur data built-in adalah tipe data kompleks yang sudah disediakan oleh Python. Kamu
dapat menggunakan struktur data ini untuk mengatur, mengelompokkan, dan mengolah
data lebih efisien.

2.2.1 List

List adalah struktur data Python yang paling umum digunakan. List bersifat mutable,
artinya kamu bisa mengubah isinya setelah membuat list. List didefinisikan menggunakan
kurung siku [].

●​ Dapat menyimpan tipe data campuran (misal: integer, string, boolean dalam satu
list).​

●​ Dapat ditambah, dihapus, atau diubah elemennya.​

Contoh script dasar:

# Membuat list​
buah = ["apel", "mangga", "jeruk"]​
angka_campur = [1, 2.5, "tiga", True]​
​
print(buah)​
print(angka_campur)​
​
# Mengakses elemen list​
print("Elemen pertama buah:", buah[0])​
print("Elemen kedua buah:", buah[1])

Output:

['apel', 'mangga', 'jeruk']

[1, 2.5, 'tiga', True]

Elemen pertama buah: apel

Elemen kedua buah: mangga

Penjelasan output:

●​ buah menampilkan list berisi tiga string.​

●​ angka_campur menampilkan list yang memiliki berbagai tipe data.​

●​ buah[0] berarti akses elemen indeks ke-0 (indeks dimulai dari 0).​

Operasi Slicing dan Metode List

Slicing adalah teknik untuk mengambil sebagian elemen list berdasarkan indeks awal dan
akhir. Beberapa metode umum list antara lain append(), insert(), remove(), dan
pop().

Contoh script lebih lanjut:

buah = ["apel", "mangga", "jeruk", "pisang", "anggur"]​

print("List asli:", buah)​
​
# Slicing: mengambil elemen dari indeks 1 sampai 3 (tidak termasuk 4)​
sub_list = buah[1:4]​
print("Slicing 1:4 ->", sub_list)​
​
# Menambah elemen dengan append()​
[Link]("kelapa")​
print("Setelah append:", buah)​
​
# Menyisipkan elemen pada posisi tertentu dengan insert()​
[Link](2, "durian")​
print("Setelah insert di indeks 2:", buah)​
​
# Menghapus elemen dengan remove() (berdasarkan nilai)​
[Link]("jeruk")​
print("Setelah remove 'jeruk':", buah)​
​
# Menghapus elemen dengan pop() (berdasarkan indeks; default yang
terakhir)​
elemen_terakhir = [Link]()​
print("Elemen terakhir yang terhapus:", elemen_terakhir)​
print("List setelah pop:", buah)

Output:
List asli: ['apel', 'mangga', 'jeruk', 'pisang', 'anggur']

Slicing 1:4 -> ['mangga', 'jeruk', 'pisang']

Setelah append: ['apel', 'mangga', 'jeruk', 'pisang', 'anggur',

'kelapa']

Setelah insert di indeks 2: ['apel', 'mangga', 'durian', 'jeruk',

'pisang', 'anggur', 'kelapa']

Setelah remove 'jeruk': ['apel', 'mangga', 'durian', 'pisang',

'anggur', 'kelapa']

Elemen terakhir yang terhapus: kelapa

List setelah pop: ['apel', 'mangga', 'durian', 'pisang', 'anggur']

Penjelasan output:

●​ sub_list = buah[1:4] mengambil elemen dengan indeks 1, 2, dan 3 saja, yaitu

["mangga", "jeruk", "pisang"].​

●​ [Link]("kelapa") menambahkan "kelapa" di posisi paling akhir list.​

●​ [Link](2, "durian") menyisipkan "durian" di indeks ke-2.​

●​ [Link]("jeruk") mencari elemen "jeruk" dan menghapusnya.​

●​ [Link]() menghapus elemen terakhir di list dan mengembalikannya ke variabel

elemen_terakhir.​

Dalam data science, list kerap dipakai untuk menyimpan daftar objek, misalnya daftar file,
daftar kolom, atau kumpulan data yang sederhana.

2.2.2 Tuple

Tuple mirip dengan list, namun immutable (tidak dapat diubah elemennya setelah
didefinisikan). Biasanya tuple digunakan untuk data yang bersifat tetap atau sebagai
pengaman agar data tidak sengaja terubah.

Contoh script dasar:

# Membuat tuple​
koordinat = (10, 20)​
 print("Tuple koordinat:", koordinat)​
​
# Mengakses elemen tuple​
print("Elemen pertama:", koordinat[0])​
print("Elemen kedua:", koordinat[1])​
​
# Mengubah elemen tuple (akan error)​
# koordinat[0] = 15

Output:

Tuple koordinat: (10, 20)

Elemen pertama: 10

Elemen kedua: 20

Jika kamu mencoba mengubah nilai koordinat (misal koordinat[0] = 15), Python akan
menampilkan error karena tuple bersifat immutable. Penggunaannya di data science,
misalnya untuk menyimpan parameter yang seharusnya tidak berubah, atau hasil fungsi
yang return-nya lebih dari satu nilai tetapi tidak ingin dimodifikasi.

2.2.3 Set

Set adalah kumpulan elemen yang bersifat unik (tidak ada duplikasi) dan tidak berurutan.
Set berguna untuk operasi himpunan (seperti union, intersection, difference).

Contoh script dasar:

# Membuat set​
angka_set = {1, 2, 3, 3, 2, 4, 5}​
print("Set angka:", angka_set)​
​
# Menambahkan elemen​
angka_set.add(6)​
print("Setelah menambah 6:", angka_set)​
​
# Menghapus elemen​
angka_set.discard(3)​
print("Setelah menghapus 3:", angka_set)​
​
# Operasi himpunan​
 set_a = {1, 2, 3}​
set_b = {3, 4, 5}​
​
print("Union A & B:", set_a.union(set_b))​
print("Intersection A & B:", set_a.intersection(set_b))​
print("Difference A - B:", set_a.difference(set_b))

Output:

Set angka: {1, 2, 3, 4, 5}

Setelah menambah 6: {1, 2, 3, 4, 5, 6}

Setelah menghapus 3: {1, 2, 4, 5, 6}

Union A & B: {1, 2, 3, 4, 5}

Intersection A & B: {3}

Difference A - B: {1, 2}

Penjelasan output:

●​ Set menghilangkan duplikasi, sehingga meskipun kita menuliskan 3 dan 2 dua kali,
yang disimpan hanya satu elemen 3 dan satu elemen 2.​

●​ angka_set.add(6) menambah elemen 6 ke set.​

●​ angka_set.discard(3) menghapus elemen 3 dari set. Jika elemen tidak ada,

discard tidak error (berbeda dengan remove pada list yang akan error jika elemen
tidak ada).​

●​ union(), intersection(), dan difference() merupakan operasi himpunan

yang sering dipakai saat kita perlu membandingkan kumpulan data tertentu.​

Dalam data science, set terkadang dipakai untuk melenyapkan duplikasi data, atau ketika
kita hanya tertarik pada keunikan sebuah kumpulan.

2.2.4 Dictionary

Dictionary adalah struktur data yang menyimpan pasangan key-value. Setiap nilai (value)
diakses dengan menggunakan kunci (key) yang unik. Digunakan untuk data yang memiliki
asosiasi atau pengaitan antar informasi.
Contoh script dasar:

# Membuat dictionary​
data_mahasiswa = {​
"nama": "Andi",​
"nim": "12345",​
"jurusan": "Informatika",​
"ipk": 3.75​
}​
​
print("Dictionary data_mahasiswa:", data_mahasiswa)​
​
# Mengakses value berdasarkan key​
print("Nama:", data_mahasiswa["nama"])​
print("NIM:", data_mahasiswa["nim"])​
​
# Menambah atau mengubah nilai​
data_mahasiswa["semester"] = 6 # menambahkan key baru​
data_mahasiswa["ipk"] = 3.90 # mengubah IPK​
​
print("Dictionary setelah perubahan:", data_mahasiswa)​
​
# Metode dictionary​
keys_list = data_mahasiswa.keys()​
values_list = data_mahasiswa.values()​
items_list = data_mahasiswa.items()​
​
print("Keys:", keys_list)​
print("Values:", values_list)​
print("Items:", items_list)

Output:

Dictionary data_mahasiswa: {'nama': 'Andi', 'nim': '12345',

'jurusan': 'Informatika', 'ipk': 3.75}

Nama: Andi

NIM: 12345

Dictionary setelah perubahan: {'nama': 'Andi', 'nim': '12345',

'jurusan': 'Informatika', 'ipk': 3.9, 'semester': 6}

Keys: dict_keys(['nama', 'nim', 'jurusan', 'ipk', 'semester'])

Values: dict_values(['Andi', '12345', 'Informatika', 3.9, 6])

Items: dict_items([('nama', 'Andi'), ('nim', '12345'), ('jurusan',

'Informatika'), ('ipk', 3.9), ('semester', 6)])

Penjelasan output:

●​ data_mahasiswa["nama"] mengembalikan nilai "Andi".​

●​ Anda dapat menambah key baru, misalnya "semester", dan juga mengubah value
yang sudah ada, contohnya ipk.​

●​ keys(), values(), dan items() memudahkan kamu melihat susunan key, value,
dan pasangan (key-value).​

Dictionary sangat penting di data science, misalnya saat kamu menyimpan konfigurasi
model, mapping label, atau metadata.

2.3 Operator dan Ekspresi

2.3.1 Operator Aritmatika

Operator aritmatika digunakan untuk operasi matematika dasar:

1.​ + (Penjumlahan)​

2.​ - (Pengurangan)​

3.​ * (Perkalian)​

4.​ / (Pembagian)​

5.​ // (Pembagian bulat)​

6.​ % (Modulus / Sisa bagi)​

7.​ ** (Pangkat)​

Contoh script:

a = 10​
 b = 3​
​
hasil_tambah = a + b​
hasil_kurang = a - b​
hasil_kali = a * b​
hasil_bagi = a / b​
hasil_bagi_bulat = a // b​
hasil_modulus = a % b​
hasil_pangkat = a ** b​
​
print("Penjumlahan (10 + 3) =", hasil_tambah)​
print("Pengurangan (10 - 3) =", hasil_kurang)​
print("Perkalian (10 * 3) =", hasil_kali)​
print("Pembagian (10 / 3) =", hasil_bagi)​
print("Pembagian Bulat (10 // 3) =", hasil_bagi_bulat)​
print("Modulus (10 % 3) =", hasil_modulus)​
print("Pangkat (10 ** 3) =", hasil_pangkat)

Output:

Penjumlahan (10 + 3) = 13

Pengurangan (10 - 3) = 7

Perkalian (10 * 3) = 30

Pembagian (10 / 3) = 3.3333333333333335

Pembagian Bulat (10 // 3) = 3

Modulus (10 % 3) = 1

Pangkat (10 ** 3) = 1000

Penjelasan output:

●​ a / b menghasilkan nilai float.​

●​ a // b membuang sisa pecahan, sehingga hasilnya 3.​

●​ a % b memberikan sisa pembagian, yaitu 1.​

●​ a ** b berarti 10 pangkat 3 = 1000.​

2.3.2 Operator Perbandingan

Digunakan untuk membandingkan dua nilai. Hasil dari operator ini adalah tipe boolean
(True atau False).

1.​ == : Sama dengan​

2.​ != : Tidak sama dengan​

3.​ > : Lebih besar​

4.​ < : Lebih kecil​

5.​ >=: Lebih besar atau sama dengan​

6.​ <=: Lebih kecil atau sama dengan​

Contoh script:

x = 5​
y = 8​
​
print("x == y ->", x == y)​
print("x != y ->", x != y)​
print("x > y ->", x > y)​
print("x < y ->", x < y)​
print("x >= 5 ->", x >= 5)​
print("y <= 8 ->", y <= 8)

Output:

x == y -> False

x != y -> True

x > y -> False

x < y -> True

x >= 5 -> True

y <= 8 -> True

Penjelasan output:

●​ x == y bernilai False karena 5 tidak sama dengan 8.​

●​ x < y bernilai True karena 5 memang kurang dari 8.​

●​ x >= 5 bernilai True karena x sama dengan 5.​

2.3.3 Operator Logika (and, or, not)

Operator logika dipakai untuk menggabungkan atau memodifikasi ekspresi boolean.

●​ and: Bernilai True jika semua ekspresi True.​

●​ or: Bernilai True jika setidaknya satu ekspresi True.​

●​ not: Membalik nilai boolean (True → False, False → True).​

Contoh script:

a = True​
b = False​
​
print("a and b ->", a and b)​
print("a or b ->", a or b)​
print("not a ->", not a)​
​
# Aplikasi operator logika pada perbandingan​
x = 10​
print("x > 5 and x < 15 ->", x > 5 and x < 15)​
print("x < 5 or x > 8 ->", x < 5 or x > 8)

Output:

a and b -> False

a or b -> True

not a -> False

x > 5 and x < 15 -> True

x < 5 or x > 8 -> True

Penjelasan output:

●​ a and b = True and False = False.​

●​ a or b = True or False = True.​

●​ not a = not True = False.​

●​ x > 5 and x < 15 = True and True = True.​

●​ x < 5 or x > 8 = False or True = True.

2.3.4 Operator Penugasan (+=, -=, =, /=, dll.)

Operator ini memudahkan kamu menggabungkan operasi aritmatika dan penugasan dalam
satu ekspresi.

Contoh script:

a = 5​
print("Nilai awal a:", a)​
​
a += 3 # sama dengan a = a + 3​
print("Setelah a += 3:", a)​
​
a *= 2 # sama dengan a = a * 2​
print("Setelah a *= 2:", a)​
​
a -= 4 # sama dengan a = a - 4​
print("Setelah a -= 4:", a)​
​
a /= 2 # sama dengan a = a / 2​
print("Setelah a /= 2:", a)

Output:

Nilai awal a: 5

Setelah a += 3: 8

Setelah a *= 2: 16

Setelah a -= 4: 12

Setelah a /= 2: 6.0

Penjelasan output:

●​ a += 3 membuat a bertambah 3, dari 5 menjadi 8.​

●​ a *= 2 membuat a dikali 2, dari 8 menjadi 16.​

●​ a /= 2 membuat a dibagi 2. Hasilnya menjadi tipe float, yaitu 6.0.​

2.3.5 Operator Bitwise (|, &, ^, ~, <<, >>)

Operator bitwise bekerja pada level bit. Walau jarang digunakan di level data science
pemula, kadang operator ini berguna untuk optimasi tertentu atau manipulasi bit pada
data.

●​ | (OR bitwise)​

●​ & (AND bitwise)​

●​ ^ (XOR bitwise)​

●​ ~ (NOT bitwise)​

●​ << (left shift)​

●​ >> (right shift)​

Contoh script singkat:

x = 6 # biner: 0110​
y = 3 # biner: 0011​
​
print("x | y ->", x | y, " (biner: ", bin(x | y), ")")​
print("x & y ->", x & y, " (biner: ", bin(x & y), ")")​
print("x ^ y ->", x ^ y, " (biner: ", bin(x ^ y), ")")​
print("~x ->", ~x, " (biner: ", bin(~x), ")")​
print("x << 1 ->", x << 1, "(biner: ", bin(x << 1), ")")​
print("x >> 1 ->", x >> 1, "(biner: ", bin(x >> 1), ")")

Output:

x | y -> 7 (biner: 0b111 )

x & y -> 2 (biner: 0b10 )

x ^ y -> 5 (biner: 0b101 )

~x -> -7 (biner: -0b111 )

x << 1 -> 12 (biner: 0b1100 )

x >> 1 -> 3 (biner: 0b11 )

Penjelasan output (secara ringkas):

●​ 6 dalam biner = 0110, 3 dalam biner = 0011.​

●​ 6 | 3 = 0111 (7 dalam desimal).​

●​ 6 & 3 = 0010 (2 dalam desimal).​

●​ ~6 = komplement bit dari 0110, yaitu ...1001 (dalam representasi dua

komplemen, hasilnya -7).​

●​ 6 << 1 menggeser bit ke kiri 1 kali, 0110 menjadi 1100 (12 desimal).​

●​ 6 >> 1 menggeser bit ke kanan 1 kali, 0110 menjadi 0011 (3 desimal).​

BAB 3 – KONTROL ALUR (CONTROL
FLOW)
Kontrol alur atau control flow adalah cara kita mengatur bagaimana program dieksekusi
secara berurutan. Kadang kita ingin mengeksekusi blok kode tertentu jika suatu kondisi
terpenuhi, atau mengulang suatu proses beberapa kali.

3.1 Pernyataan Kondisional

3.1.1 if, elif,else

if digunakan untuk mengeksekusi sebuah blok kode jika suatu kondisi bernilai True. Jika
kondisi if tidak terpenuhi, kamu dapat menggunakan elif untuk memeriksa kondisi lain.
else akan dieksekusi jika semua kondisi if dan elif sebelumnya tidak terpenuhi.

Contoh script dasar:

nilai = 80​
​
if nilai >= 85:​
print("Luar biasa! Nilai A")​
elif nilai >= 70:​
print("Bagus! Nilai B")​
elif nilai >= 60:​
print("Cukup. Nilai C")​
else:​
print("Nilai kurang, perlu belajar lebih giat.")

Output:

Bagus! Nilai B

Penjelasan output:

●​ Karena nilai = 80, maka kondisi nilai >= 85 adalah False, sehingga
melewati blok pertama. Kondisi nilai >= 70 adalah True, maka langsung
mencetak "Bagus! Nilai B".​
 ●​ Blok elif dan else berikutnya tidak dieksekusi karena Python sudah menemukan
kondisi yang True.​

Contoh penggunaan yang lebih kompleks (memeriksa banyak kondisi):

suhu = 35​
cuaca = "hujan"​
​
if suhu > 30 and cuaca == "cerah":​
print("Mungkin ini waktu yang tepat untuk pergi ke pantai.")​
elif suhu <= 30 and cuaca == "cerah":​
print("Cuaca cerah tapi tidak terlalu panas, cocok untuk
jalan-jalan.")​
elif cuaca == "hujan":​
print("Sebaiknya bawa payung atau tunda rencana ke luar.")​
else:​
print("Informasi cuaca tidak pasti.")

Penjelasan:

●​ Program mengecek kondisi suhu dan cuaca secara berurutan.​

●​ Karena suhu > 30 adalah True tapi cuaca == "cerah" adalah False (karena
cuaca = "hujan"), maka blok if dilewati.​

●​ Blok elif kedua (suhu <= 30 and cuaca == "cerah") juga False.​

●​ Blok elif ketiga cuaca == "hujan" bernilai True, sehingga mencetak pesan
sesuai kondisi hujan.​

3.1.2 Nested if

Kamu bisa menulis if di dalam if lainnya. Ini berguna jika kamu perlu memeriksa
beberapa level kondisi.

Contoh script:

nilai = 90​
absensi = 85 # persentase kehadiran​
​
if nilai >= 75:​
if absensi >= 80:​
 print("Selamat! Nilai dan absensi memuaskan.")​
else:​
print("Nilai memenuhi, tapi absensi kurang.")​
else:​
print("Nilai belum memenuhi.")

Output:

Selamat! Nilai dan absensi memuaskan.

Penjelasan output:

●​ Program pertama-tama memeriksa apakah nilai >= 75. Karena 90 >= 75

bernilai True, blok dalam if dijalankan.​

●​ Di dalamnya, ada if absensi >= 80. Karena absensi = 85 juga True, maka
pesan “Selamat! …” dicetak.​

●​ Jika nilai < 75, maka Python langsung melewati nested if dan mengeksekusi
blok else paling luar.​

3.2 Perulangan

3.2.1 for Loop

Digunakan untuk mengeksekusi blok kode berulang kali, biasanya saat kita tahu berapa
banyak elemen yang akan diiterasi.

Contoh script dasar:

buah = ["apel", "mangga", "jeruk"]​

​
for item in buah:​
print("Saya suka", item)

Output:

Saya suka apel

Saya suka mangga

Saya suka jeruk

Penjelasan output:

●​ Perulangan for item in buah akan mengeksekusi blok kode sebanyak jumlah
elemen di dalam list buah.​

●​ Masing-masing elemen disimpan dalam variabel item secara bergantian.​

range() dan enumerate()

●​ range(n) memberikan deret 0 sampai n-1. Berguna untuk perulangan dengan

jumlah tertentu.​

●​ enumerate(iterable) memberikan pasangan indeks dan nilai.​

Contoh script dengan range():

for i in range(5):​
print("i =", i)

Output:

i = 0

i = 1

i = 2

i = 3

i = 4

Penjelasan:

●​ range(5) menghasilkan urutan 0, 1, 2, 3, 4.​

Contoh script dengan enumerate():

buah = ["apel", "mangga", "jeruk"]​

 ​
for index, item in enumerate(buah):​
print(index, item)

Output:

0 apel

1 mangga

2 jeruk

Penjelasan:

●​ enumerate(buah) mengembalikan tuple (index, nilai_element).​

●​ Sangat berguna jika kamu perlu menyertakan indeks saat melakukan iterasi.​

Kasus penggunaan for​

Sering digunakan dalam data science untuk memproses setiap baris data, setiap kolom, atau
setiap elemen array. Misalnya, menghitung rata-rata manual dengan menambahkan semua
elemen lalu membaginya dengan jumlah elemen.

3.2.2 while Loop

Digunakan untuk mengeksekusi blok kode selama suatu kondisi bernilai True. Biasanya
dipakai jika jumlah perulangan belum pasti tetapi bergantung pada kondisi tertentu.

Contoh script dasar:

counter = 0​
​
while counter < 5:​
print("Counter =", counter)​
counter += 1

Output:

Counter = 0

Counter = 1
Counter = 2

Counter = 3

Counter = 4

Penjelasan output:

●​ Selama counter < 5, perulangan terus berjalan.​

●​ Setiap iterasi, counter bertambah 1. Ketika counter menjadi 5, kondisi counter

< 5 menjadi False, dan perulangan berhenti.​

Contoh penerapan di kasus while:

import random​
​
# Game tebak angka sederhana​
angka_rahasia = [Link](1, 10)​
tebakan = 0​
​
print("Saya telah memilih angka antara 1 sampai 10. Coba tebak!")​
​
while tebakan != angka_rahasia:​
tebakan = int(input("Masukkan tebakan Anda: "))​
if tebakan < angka_rahasia:​
print("Terlalu rendah!")​
elif tebakan > angka_rahasia:​
print("Terlalu tinggi!")​
else:​
print("Benar! kamu menebak angka", angka_rahasia)

Penjelasan:

●​ Program akan terus meminta input dari user selama tebakan !=

angka_rahasia.​

●​ Jika tebakan lebih rendah atau lebih tinggi, program memberi petunjuk. Ketika
tebakan tepat, perulangan berhenti.

3.2.3 Pernyataan break, continue, dan pass

●​ break: Menghentikan perulangan seluruhnya.​

 ●​ continue: Melewati iterasi saat ini dan langsung melompat ke iterasi berikutnya.​

●​ pass: Tidak melakukan apa-apa, biasanya placeholder untuk blok kosong.​

Contoh script penggunaan break:

for i in range(10):​
if i == 5:​
break​
print(i)

Output:

Penjelasan output:

●​ Saat i bernilai 5, pernyataan break dipanggil dan loop berhenti.​

●​ Sehingga tidak ada output untuk i = 5 dan seterusnya.​

Contoh script penggunaan continue:

for i in range(5):​
if i == 2:​
continue​
print(i)

Output:

0
1

Penjelasan output:

●​ Ketika i == 2, pernyataan continue men-skip pencetakan dan langsung

melanjutkan ke iterasi berikutnya. Jadi 2 tidak pernah dicetak.​

Contoh script penggunaan pass:

for i in range(3):​
if i == 1:​
pass ​
print("Iterasi ke-", i)

Output:

Iterasi ke- 0

Iterasi ke- 1

Iterasi ke- 2

Penjelasan:

●​ pass di dalam if i == 1 tidak memberikan efek, tapi kadang diperlukan untuk

struktur kode yang belum diisi atau sebagai template agar tidak terjadi error sintaks
“IndentationError” atau “SyntaxError”.​

Dalam konteks data science, break dan continue mungkin digunakan saat kamu ingin
menghentikan pemrosesan data di kondisi tertentu atau melewati data yang tidak valid.
pass berguna untuk menyiapkan blok kode yang akan diisi nanti.
BAB 4 – FUNGSI (FUNCTIONS)
Fungsi adalah blok kode terorganisir yang dapat dipanggil berulang kali untuk menjalankan
suatu tugas tertentu. Penggunaan fungsi memungkinkan kamu menstrukturkan program
dengan lebih rapi, mempermudah pemeliharaan, dan menghindari pengulangan kode yang
tidak perlu. Bagi kamu yang ingin terjun ke data science, pemahaman fungsi sangat krusial
karena sering kali kita membuat potongan kode (fungsi) yang dapat digunakan untuk
membersihkan data, memproses data, atau menguji berbagai model secara efisien.

4.1 Definisi Fungsi

Fungsi didefinisikan menggunakan kata kunci def, diikuti dengan nama fungsi dan tanda
kurung (). Di dalam tanda kurung, kita dapat menuliskan parameter-parameter yang
dibutuhkan. Blok kode fungsi harus diindentasi.

Langkah mendefinisikan fungsi:

1.​ Menulis def nama_fungsi(parameter):​

2.​ Menuliskan serangkaian perintah di dalam blok fungsi yang terindentasi.​

3.​ (Opsional) Mengembalikan nilai menggunakan return.​

Contoh script (Dasar):

def sapa():​
print("Halo, selamat datang di Python!")​
​
# Memanggil fungsi sapa​
sapa()

Output (Dasar):

Halo, selamat datang di Python!

Penjelasan output:​
Fungsi sapa() tidak memiliki parameter. Setiap kali dipanggil, ia akan mengeksekusi kode
di dalamnya, yaitu mencetak teks “Halo, selamat datang di Python!” ke layar.

Contoh script (Fungsi dengan Parameter dan Return):

def tambah(angka1, angka2):​

 hasil = angka1 + angka2​
return hasil​
​
# Memanggil fungsi tambah dan menyimpan hasilnya​
x = 10​
y = 5​
jumlah = tambah(x, y)​
print("Hasil penjumlahan:", jumlah)

Output (Fungsi dengan Parameter dan Return):

Hasil penjumlahan: 15

Penjelasan output:

●​ Parameter angka1 dan angka2 menerima nilai 10 dan 5 ketika kita memanggil
tambah(x, y).​

●​ Kode di dalam fungsi menghitung angka1 + angka2 yang hasilnya 15, kemudian
mengembalikannya (return).​

●​ Variabel jumlah di luar fungsi menerima nilai pengembalian 15, dan program
menampilkannya dengan print.​

Contoh script (Penerapan kasus: Fungsi menghitung luas segitiga):

def luas_segitiga(alas, tinggi):​

"""​
Menghitung luas segitiga dengan formula:​
luas = 1/2 * alas * tinggi​
"""​
return 0.5 * alas * tinggi​
​
a = 10​
t = 5​
luas = luas_segitiga(a, t)​
print(f"Luas segitiga dengan alas {a} dan tinggi {t} adalah: {luas}")

Output (Penerapan kasus: Fungsi menghitung luas segitiga):

Luas segitiga dengan alas 10 dan tinggi 5 adalah: 25.0

Penjelasan output:

●​ Fungsi luas_segitiga menerima dua parameter, alas dan tinggi.​

●​ Perhitungan luas dilakukan dengan rumus 0.5 * alas * tinggi.​

●​ Hasil akhirnya 25.0 karena 0.5 * 10 * 5 = 25.0.​

●​ Fungsi memudahkan kita memanggilnya berulang kali dengan parameter berbeda,

tanpa menulis ulang logika perhitungan.​

4.2 Parameter dan Argumen (Positional, Default, *args,

kwargs)
Dalam Python, fungsi dapat memiliki bermacam-macam jenis parameter. Hal ini
memudahkan penulisan fungsi yang fleksibel dan dapat digunakan di banyak situasi.

1.​ Positional Arguments: Argumen yang urutannya harus sesuai dengan parameter di
definisi fungsi.​

2.​ Default Arguments: Parameter yang memiliki nilai default, sehingga kalau argumen
tidak diberikan, Python akan menggunakan nilai default.​

3.​ *args (Positional Arguments tak terbatas): Digunakan saat kita ingin menerima
sejumlah argumen berapa pun, dalam bentuk tuple.​

4.​ **kwargs (Keyword Arguments tak terbatas): Digunakan saat kita ingin menerima
sejumlah argumen berapa pun, dalam bentuk dictionary.​

Contoh script (Positional dan Default Arguments):

def info_mahasiswa(nama, nim, jurusan="Informatika"):​

print(f"Nama: {nama}")​
print(f"NIM: {nim}")​
print(f"Jurusan: {jurusan}")​
​
# Memanggil fungsi dengan argumen positional​
info_mahasiswa("Andi", "12345")​
​
print("----")​
 ​
# Memanggil fungsi dengan mengganti default jurusan​
info_mahasiswa("Budi", "67890", "Sistem Informasi")

Output (Positional dan Default Arguments):

Nama: Andi

NIM: 12345

Jurusan: Informatika

----

Nama: Budi

NIM: 67890

Jurusan: Sistem Informasi

Penjelasan output:

●​ Pada pemanggilan pertama, kita hanya memberikan 2 argumen: "Andi" dan

"12345". Karena parameter jurusan memiliki nilai default "Informatika",
maka akan otomatis tertulis.​

●​ Pada pemanggilan kedua, kita menimpa nilai default jurusan menjadi "Sistem
Informasi".​

Contoh script (args - menangani banyak argumen positional):

def rata_rata(*angka):​
if len(angka) == 0:​
return 0​
total = 0​
for a in angka:​
total += a​
return total / len(angka)​
​
hasil1 = rata_rata(10, 20, 30)​
hasil2 = rata_rata(5, 15)​
hasil3 = rata_rata() # tanpa argumen​
​
 print("Rata-rata (10, 20, 30):", hasil1)​
print("Rata-rata (5, 15):", hasil2)​
print("Rata-rata tanpa argumen:", hasil3)

Output (args - menangani banyak argumen positional):

Rata-rata (10, 20, 30): 20.0

Rata-rata (5, 15): 10.0

Rata-rata tanpa argumen: 0

Penjelasan output:

●​ Fungsi rata_rata(*angka) dapat menerima berapa pun jumlah argumen karena

kita menggunakan *angka.​

●​ Semua argumen akan disimpan dalam bentuk tuple di variabel angka.​

●​ Kita melakukan penjumlahan dan membagi dengan jumlah argumen. Jika tidak ada
argumen sama sekali, nilai kembalian diset 0.​

Contoh script (kwargs - menangani banyak argumen keyword):

def cetak_info(**data):​
for key, value in [Link]():​
print(f"{key} : {value}")​
​
# Memanggil fungsi dengan berbagai keyword argument​
cetak_info(nama="Citra", usia=21, kota="Bandung")​
​
print("---")​
​
# Menambahkan argumen lain​
cetak_info(produk="Laptop", merek="ABC", harga=15000000, garansi="2
tahun")

Output (kwargs - menangani banyak argumen keyword):

nama : Citra
usia : 21

kota : Bandung

---

produk : Laptop

merek : ABC

harga : 15000000

garansi : 2 tahun

Penjelasan output:

●​ **data menampung keyword arguments dalam bentuk dictionary, di mana key

adalah nama argumen (nama, usia, kota) dan value adalah nilai masing-masing
argumen.​

●​ Kita kemudian melakukan iterasi for key, value in [Link](): untuk

mencetak semua pasangan key-value.​

●​ Cara ini sangat fleksibel ketika kita tidak tahu berapa banyak informasi yang akan
dikirim ke fungsi atau jika kita ingin parameter lebih “dinamis.”

4.3 Return Statement

Setiap fungsi dapat mengembalikan nilai dengan menggunakan kata kunci return. Begitu
return dieksekusi, fungsi akan langsung berhenti (tidak melanjutkan baris kode
setelahnya).

Contoh script (Efek menghentikan eksekusi setelah return):

def cek_nilai(angka):​
if angka > 0:​
return "Positif"​
print("Bagian ini tidak akan dieksekusi jika angka > 0")​
return "Tidak Positif"​
​
print(cek_nilai(10))​
print(cek_nilai(-5))

Output (Efek menghentikan eksekusi setelah return):

Positif

Tidak Positif

Penjelasan output:

●​ Ketika angka bernilai 10, kondisi angka > 0 terpenuhi, maka fungsi return
"Positif". Baris print("Bagian ini...") tidak pernah dijalankan.​

●​ Ketika angka bernilai -5, kondisi angka > 0 adalah False, sehingga melewati if
dan mengeksekusi print("Bagian ini tidak akan dieksekusi...") lalu
return "Tidak Positif".​

4.4 Fungsi Lambda (Anonymous Function)

Fungsi lambda adalah fungsi kecil tanpa nama yang hanya terdiri dari satu ekspresi.
Biasanya digunakan untuk keperluan sederhana seperti argumen dalam map(), filter(),
atau sekadar membuat fungsi singkat tanpa mendefinisikannya secara eksplisit dengan
def.

Contoh script (Dasar Fungsi Lambda):

# Fungsi lambda untuk menambah 5 pada sebuah angka​

tambah_5 = lambda x: x + 5​
​
print(tambah_5(10))​
print(tambah_5(-2))

Output (Dasar Fungsi Lambda):

15

Penjelasan output:

●​ lambda x: x + 5 mendefinisikan fungsi singkat yang menerima satu parameter x

dan mengembalikan x + 5.​

●​ Saat kita panggil tambah_5(10), hasilnya 15. Saat tambah_5(-2), hasilnya 3.​

Contoh script (Lambda dalam map, filter, reduce):

 from functools import reduce​
​
daftar_angka = [1, 2, 3, 4, 5]​
​
# Map - menerapkan fungsi lambda ke setiap elemen​
hasil_map = list(map(lambda x: x * 2, daftar_angka))​
print("Map (x * 2):", hasil_map)​
​
# Filter - menyaring elemen yang memenuhi kondisi​
hasil_filter = list(filter(lambda x: x % 2 == 1, daftar_angka))​
print("Filter (ganjil):", hasil_filter)​
​
# Reduce - menerapkan fungsi secara berurutan untuk menghasilkan satu
nilai​
hasil_reduce = reduce(lambda a, b: a + b, daftar_angka)​
print("Reduce (penjumlahan semua elemen):", hasil_reduce)

Output (Lambda dalam map, filter, reduce):

Map (x * 2): [2, 4, 6, 8, 10]

Filter (ganjil): [1, 3, 5]

Reduce (penjumlahan semua elemen): 15

Penjelasan output:

●​ map(lambda x: x * 2, daftar_angka) menghasilkan list baru dengan setiap

elemen dikali 2.​

●​ filter(lambda x: x % 2 == 1, daftar_angka) hanya mengambil elemen

yang bernilai ganjil (x % 2 == 1).​

●​ reduce(lambda a, b: a + b, daftar_angka) menerapkan operasi

penjumlahan secara berurutan, akhirnya menjumlahkan semua elemen dalam list.​

4.5 Scope Variabel dan Namespace

Scope variabel adalah wilayah di mana variabel tersebut dapat diakses. Secara umum,
Python mengenal:
 ●​ Global Scope: Variabel yang didefinisikan di level teratas (tidak berada di dalam
fungsi apa pun). Dapat diakses di mana saja dalam modul yang sama.​

●​ Local Scope: Variabel yang didefinisikan di dalam fungsi, hanya dapat diakses di
dalam fungsi tersebut.​

Contoh script (Global vs Local):

x = 10 # global variable​
​
def tampilkan_x():​
x = 5 # local variable di dalam fungsi​
print("x di dalam fungsi:", x)​
​
tampilkan_x()​
print("x di luar fungsi:", x)

Output (Global vs Local):

x di dalam fungsi: 5

x di luar fungsi: 10

Penjelasan output:

●​ Variabel x = 10 didefinisikan di luar fungsi.​

●​ Di dalam tampilkan_x(), kita membuat x = 5 yang hanya berlaku di fungsi itu

(local scope).​

●​ Saat mencetak di dalam fungsi, nilainya 5. Setelah keluar dari fungsi, nilai x global
tetap 10.​

Contoh script (Mengakses variabel global di dalam fungsi dengan global):

y = 10​
​
def ubah_y():​
global y​
y = 20​
print("y di dalam fungsi:", y)​
​
 print("y sebelum diubah:", y)​
ubah_y()​
print("y setelah diubah:", y)

Output (Mengakses variabel global di dalam fungsi dengan global):

y sebelum diubah: 10

y di dalam fungsi: 20

y setelah diubah: 20

Penjelasan output:

●​ Dengan kata kunci global, kita memberitahu Python bahwa kita ingin memakai
(dan mengubah) variabel y yang ada di global scope, bukan membuat y baru di local
scope.​

●​ Akibatnya, ketika fungsi ubah_y() dipanggil, nilai y global berubah dari 10 menjadi
20.​
BAB 5 – MODULARISASI DAN
MANAJEMEN PAKET
Modularisasi adalah proses memecah kode menjadi bagian-bagian yang lebih kecil dan
terpisah (modul), sehingga lebih mudah dirawat, diuji, dan digunakan kembali. Dalam
praktik pengembangan Python, kita sering membuat modul dan paket untuk mengatur
fungsi-fungsi yang saling berkaitan. Selain itu, manajemen paket (dengan pip atau conda)
sangatlah penting, terutama dalam data science yang bergantung pada banyak library
eksternal seperti NumPy, Pandas, dan scikit-learn.

5.1 Modul
Modul adalah berkas Python dengan ekstensi .py yang berisi definisi fungsi, kelas, atau
variabel. Dengan modul, kamu dapat memisahkan logika program menjadi beberapa
berkas sesuai fungsinya, kemudian mengimpornya di berkas lain saat dibutuhkan.

Contoh script (Membuat modul sendiri)

Misalkan kita membuat sebuah berkas bernama [Link] dengan isi:

# [Link]​
​
def tambah(a, b):​
return a + b​
​
def kali(a, b):​
return a * b​
​
def pangkat(a, b):​
return a ** b

Kemudian, di berkas utama kita (misal [Link]), kita bisa mengimpor modul tersebut:

# dalam [Link]​
​
import matematika​
​
hasil_tambah = [Link](3, 5)​
hasil_kali = [Link](4, 6)​
hasil_pangkat = [Link](2, 3)​
 ​
print("Hasil tambah:", hasil_tambah)​
print("Hasil kali:", hasil_kali)​
print("Hasil pangkat:", hasil_pangkat)

Output (Penggunaan modul matematika di [Link]):

Hasil tambah: 8

Hasil kali: 24

Hasil pangkat: 8

Penjelasan output:

●​ [Link](3, 5) memanggil fungsi tambah yang kita definisikan di

[Link], hasilnya 8.​

●​ [Link](4, 6) memanggil fungsi kali, hasilnya 24.​

●​ [Link](2, 3) memanggil fungsi pangkat, hasilnya 2 ** 3 =

8.​

Contoh script (Mengimpor secara spesifik):

# dalam [Link]​
​
from matematika import tambah, kali​
​
print("10 + 2 =", tambah(10, 2))​
print("7 * 8 =", kali(7, 8))​
​
# Jika kita coba panggil pangkat, akan error karena tidak diimpor​
# print(pangkat(2, 3)) # NameError

Di sini, kita hanya mengimpor tambah dan kali saja. Fungsi pangkat tidak ikut diimpor.
5.2 Paket (Packages)
Paket adalah kumpulan modul yang disusun dalam sebuah direktori yang memiliki berkas
__init__.py. Keberadaan __init__.py menandakan bahwa direktori tersebut adalah
paket Python. Hal ini memudahkan kita mengelompokkan modul-modul yang saling
berkaitan.

Struktur direktori paket:

projek_ku/

├── [Link]

└── paket_ku/

├── __init__.py

├── modul_a.py

└── modul_b.py

Misal, di dalam modul_a.py kita punya:

# modul_a.py​
​
def sapa(nama):​
print(f"Halo, {nama}! Ini dari modul_a.")

Di dalam modul_b.py kita punya:

# modul_b.py​
​
def salam_pagi(nama):​
print(f"Selamat pagi, {nama}!")

Dan __init__.py boleh kosong atau berisi inisialisasi:

# __init__.py (dapat dikosongkan atau isi inisialisasi)

Contoh script (Mengimpor dari paket di [Link]):

# [Link]​
​
from paket_ku import modul_a, modul_b​
​
modul_a.sapa("Andi")​
modul_b.salam_pagi("Budi")

Output (Mengimpor dari paket):

Halo, Andi! Ini dari modul_a.

Selamat pagi, Budi!

Penjelasan output:

●​ from paket_ku import modul_a, modul_b berarti kita mengimpor kedua

modul tersebut dari direktori paket_ku.​

●​ Kita kemudian memanggil fungsi sapa() yang ada di modul_a dan salam_pagi()
yang ada di modul_b.​

●​ Hasilnya adalah dua baris teks yang mencerminkan fungsi masing-masing.​

Contoh script (Mengimpor fungsi tertentu dari modul dalam paket):

# [Link]​
​
from paket_ku.modul_a import sapa​
from paket_ku.modul_b import salam_pagi​
​
sapa("Citra")​
salam_pagi("Dewi")

Ini lebih spesifik; kita langsung mengimpor fungsi yang dibutuhkan. Struktur paket seperti
ini memudahkanmu menata banyak modul agar tidak tercampur aduk di satu folder.
5.3 Mengelola Paket dengan pip dan Virtual Environment
Dalam data science, kita bergantung pada banyak pustaka eksternal seperti NumPy, Pandas,
Matplotlib, dan scikit-learn. Agar proyek tetap berjalan mulus tanpa konflik versi, kita
biasanya menggunakan virtual environment.

1.​ pip adalah tool bawaan Python untuk menginstal paket-paket dari repositori PyPI
(Python Package Index).​

2.​ Virtual Environment membantu kita membuat lingkungan Python terpisah,

sehingga paket-paket yang diinstal tidak bentrok dengan paket di sistem global.​

Instalasi paket dengan pip:

pip install numpy

pip install pandas

pip install matplotlib

Setelah diinstal, kita dapat langsung mengimpor di skrip Python:

import numpy as np​

import pandas as pd​
import [Link] as plt

Membuat Virtual Environment:

Pada Python versi 3.3 ke atas, kita dapat menggunakan modul venv untuk membuat virtual
environment.

# Membuat virtual environment baru bernama venv

python -m venv venv

# Mengaktifkan virtual environment (Windows)

.\venv\Scripts\activate
# Mengaktifkan virtual environment (Linux/Mac)

source venv/bin/activate

# Setelah aktif, kita bisa install package

pip install numpy pandas

Jika environment sudah aktif, perintah pip install akan menginstal paket ke dalam
folder venv, bukan ke sistem global.

Contoh script (Menggunakan paket eksternal di dalam environment):

import numpy as np​

import pandas as pd​
​
array_data = [Link]([1, 2, 3, 4, 5])​
print("Numpy array:", array_data)​
​
df = [Link]({'angka': [10, 20, 30], 'huruf': ['A', 'B', 'C']})​
print("DataFrame:\n", df)

Output (Menggunakan paket eksternal):

Numpy array: [1 2 3 4 5]

DataFrame:

angka huruf

0 10 A

1 20 B

2 30 C

Penjelasan output:

●​ Numpy array [1 2 3 4 5] terbentuk dari list [1, 2, 3, 4, 5].​

 ●​ DataFrame dari Pandas menampilkan dua kolom (angka dan huruf). Kolom angka
berisi [10, 20, 30] dan kolom huruf berisi [A, B, C]. Terdapat indeks baris 0,
1, 2.​

Dengan manajemen paket yang tepat dan modularisasi, kamu akan terhindar dari konflik
versi perpustakaan, serta memiliki struktur proyek yang rapi dan terorganisir. Ini sangat
krusial di dunia data science di mana kita sering bekerja dengan aneka library dalam satu
proyek.
BAB 6 – STRING MANIPULATION
String adalah kumpulan karakter yang merepresentasikan teks. Dalam pemrograman
Python, string dikelilingi oleh tanda kutip tunggal ('...') atau tanda kutip ganda ("...").
Kita sering berurusan dengan string untuk memproses data teks, termasuk pembersihan
data, transformasi, serta pencarian pola. Bab ini akan membahas berbagai teknik
manipulasi string secara mendasar hingga beberapa penerapan yang berguna, terutama
untuk persiapan dalam data science.

6.1 String Dasar

String dapat diakses seperti halnya list, menggunakan indeks dan teknik slicing, karena
string pun merupakan urutan (sequence) karakter.

Deklarasi, Index, Slicing

Tidak ada perbedaan sintaks signifikan antara string dengan satu atau dua tanda kutip, yang
penting adalah konsistensi. Kita juga bisa menggunakan tanda kutip tiga (''' atau """)
untuk membuat string multi-baris.

Contoh script (Dasar deklarasi, index, slicing):

teks1 = "Hello"​
teks2 = 'World'​
teks3 = """Ini adalah ​
string multi-baris ​
di Python."""​
​
# Mengakses karakter​
huruf_pertama = teks1[0]​
huruf_terakhir = teks1[-1]​
​
# Slicing​
sub_string = teks1[1:4] # Mengambil karakter indeks 1 sampai 3 (4 tidak
ikut)​
​
print("teks1:", teks1)​
print("teks2:", teks2)​
print("teks3 (multi-baris):", teks3)​
print("Huruf pertama teks1:", huruf_pertama)​
print("Huruf terakhir teks1:", huruf_terakhir)​
print("Slicing teks1[1:4]:", sub_string)
Output (Dasar deklarasi, index, slicing):

teks1: Hello

teks2: World

teks3 (multi-baris): Ini adalah

string multi-baris

di Python.

Huruf pertama teks1: H

Huruf terakhir teks1: o

Slicing teks1[1:4]: ell

Penjelasan output:

●​ teks1[0] mengembalikan karakter pertama dari "Hello", yaitu 'H'.​

●​ teks1[-1] mengembalikan karakter terakhir, yaitu 'o'.​

●​ teks1[1:4] adalah karakter pada indeks 1, 2, dan 3 (indeks 4 tidak diikutkan),

sehingga "ell".​

●​ teks3 menggunakan tanda kutip tiga, sehingga bisa berisi baris teks lebih dari satu
baris.​

Escape Sequences

Escape sequence digunakan jika kita ingin memunculkan karakter spesial di dalam string.
Misalnya \n untuk baris baru, \t untuk tab, \" atau \' untuk menampilkan tanda kutip
secara literal.

Contoh script (Escape sequences):

teks = "Baris pertama\nBaris kedua\t(Teks dengan tab)\n\"Kutipan di

dalam string\""​
print(teks)

Output (Escape sequences):

Baris pertama

Baris kedua (Teks dengan tab)

"Kutipan di dalam string"

Penjelasan output:

●​ \n membuat baris baru. Setelah “Baris pertama”, maka teks dilanjutkan di baris
kedua.​

●​ \t membuat spasi tab, sehingga teks menjadi agak menjorok ke kanan.​

●​ \" menampilkan tanda kutip ganda di dalam string tanpa mengakhiri string itu
sendiri.

6.1.1 Metode String Umum

Python menyediakan banyak metode bawaan (built-in) untuk memanipulasi string, seperti
lower(), upper(), strip(), split(), replace(), dan join(). Metode-metode ini
sering dipakai dalam membersihkan data teks, normalisasi format, dan lain sebagainya.

lower() dan upper()

Mengubah seluruh karakter dalam string menjadi huruf kecil atau huruf besar.

teks = "PyThOn"​
​
print("lower():", [Link]())​
print("upper():", [Link]())

Output:

lower(): python

upper(): PYTHON

Penjelasan:

●​ lower() berguna saat kita ingin menyamakan format input teks (misalnya untuk
pencocokan data).​

●​ upper() pun berguna dalam kasus yang sama, hanya saja kebalikan.​
strip(), lstrip(), rstrip()

Menghapus karakter (spasi atau karakter lain yang ditentukan) di awal dan akhir
string.teks_spasi = " Data Science "​
print("Asli:", repr(teks_spasi))​
print("strip():", repr(teks_spasi.strip()))​
print("lstrip():", repr(teks_spasi.lstrip()))​
print("rstrip():", repr(teks_spasi.rstrip()))

Output:

Asli: ' Data Science '

strip(): 'Data Science'

lstrip(): 'Data Science '

rstrip(): ' Data Science'

Penjelasan output:

●​ strip() menghapus semua spasi di depan dan belakang.​

●​ lstrip() hanya menghapus spasi di depan (kiri).​

●​ rstrip() hanya menghapus spasi di belakang (kanan).​

●​ repr() digunakan agar spasi terlihat jelas di konsol, menampilkan string dengan
tanda kutip.​

split()

Memotong string menjadi list berdasarkan pemisah tertentu (defaultnya spasi).

kalimat = "Belajar Python untuk Data Science"​

list_kata = [Link]()​
print(list_kata)

Output:
['Belajar', 'Python', 'untuk', 'Data', 'Science']

Penjelasan:

●​ split() tanpa argumen akan memisahkan string berdasarkan satu atau lebih
spasi.​

●​ Kita bisa memberikan argumen pemisah kustom, misal split(',') untuk

memisah berdasarkan tanda koma.​

replace()

Mengganti semua kemunculan substring tertentu dengan substring baru.

teks = "Saya suka Python. Python sangat mudah dipelajari."​

teks_baru = [Link]("Python", "JavaScript")​
print(teks_baru)

Output:

Saya suka JavaScript. JavaScript sangat mudah dipelajari.

Penjelasan:

●​ replace("Python", "JavaScript") mencari semua substring "Python" dan

menggantinya dengan "JavaScript".​

join()

Menggabungkan elemen-elemen dalam list menjadi satu string dengan pemisah tertentu.

list_kata = ["Data", "Science", "dengan", "Python"]​

kalimat = " ".join(list_kata)​
print(kalimat)

Output:
Data Science dengan Python

Penjelasan:

●​ " ".join(list_kata) akan menggabungkan setiap elemen list ["Data",

"Science", "dengan", "Python"] menjadi satu string dengan pemisah spasi
(" ").​

6.2 String Formatting

String formatting memudahkan kita memasukkan nilai variabel ke dalam string dengan
cara yang rapih dan mudah dibaca. Python memiliki beberapa cara untuk melakukan ini,
antara lain metode format(), f-String, dan % formatting (gaya lama).

6.2.1 format()

Kita bisa menggunakan kurung kurawal {} sebagai placeholder dan memanggil fungsi
format() untuk mengisi placeholder tersebut.

Contoh script (Dasar format()):

nama = "Andi"​
umur = 25​
teks = "Nama saya adalah {} dan saya berumur {} tahun.".format(nama,
umur)​
print(teks)

Output (Dasar format()):

Nama saya adalah Andi dan saya berumur 25 tahun.

Penjelasan output:

●​ {}.format(nama, umur) akan menempatkan nilai nama ke placeholder {}

pertama, dan umur ke placeholder {} kedua.​

●​ Teks menjadi lebih dinamis ketimbang menulis print("Nama saya adalah",

nama, "dan...").​
Positional dan Named Placeholders dengan format()

Kita dapat mengatur urutan atau memberikan nama khusus di dalam placeholder.

teks_positional = "Angka pertama: {0}, Angka kedua: {1}".format(10, 20)​

teks_named = "Produk: {produk}, Harga: {harga}".format(produk="Laptop",
harga=15000000)​
​
print(teks_positional)​
print(teks_named)

Output:

Angka pertama: 10, Angka kedua: 20

Produk: Laptop, Harga: 15000000

Penjelasan:

●​ {0} merujuk pada argumen pertama, {1} merujuk pada argumen kedua.​

●​ produk="Laptop", harga=15000000 bisa langsung dikaitkan dengan

{produk} dan {harga} di dalam string format.​

6.2.2 f-String (Formatted String Literal)

Sejak Python 3.6, f-String menjadi cara yang lebih ringkas dan mudah dibaca. Kita cukup
menuliskan f"..." lalu memasukkan variabel di dalam curly braces {}.

nama = "Budi"​
usia = 30​
teks = f"Nama: {nama}, Usia: {usia}"​
print(teks)

Output:

Nama: Budi, Usia: 30

Penjelasan:

●​ Kita langsung menggunakan f sebelum tanda kutip.​

●​ Variabel nama dan usia bisa disisipkan ke dalam string dengan {nama} dan
{usia}.​

●​ Dapat juga melakukan operasi langsung, misal f"{usia + 5}" akan menampilkan
hasil penambahan.​

6.2.3 Format Spesifik (Alignment, Precision)

Kita bisa menambahkan format untuk alignment (perataan) dan precision ( jumlah digit
setelah koma).

nilai_pi = 3.1415926535​
teks_format = f"Nilai pi sekitar {nilai_pi:.2f}"​
print(teks_format)​
​
angka = 123​
print(f"Angka {angka:5d} dengan lebar 5 karakter, rata kanan.")​
print(f"Angka {angka:<5d} dengan lebar 5 karakter, rata kiri.")

Output:

Nilai pi sekitar 3.14

Angka 123 dengan lebar 5 karakter, rata kanan.

Angka 123 dengan lebar 5 karakter, rata kiri.

Penjelasan output:

●​ {nilai_pi:.2f} menampilkan nilai nilai_pi dengan 2 digit desimal dan tipe

float.​

●​ {angka:5d} menampilkan angka dalam format integer (d), dengan lebar 5

karakter, dan defaultnya rata kanan.​

●​ {angka:<5d} artinya rata kiri (left align).​

6.3 Regular Expressions (Regex) Singkat
Regex adalah sekumpulan pola yang digunakan untuk mencocokkan teks. Di Python, kita
menggunakan modul re untuk menerapkan regex. Regex sangat berguna dalam
membersihkan data, validasi input, atau memproses teks secara terstruktur.

Fungsi utama re module

1.​ [Link](pattern, string): Mencari pola di mana saja di dalam string;

jika cocok, mengembalikan objek match pertama, jika tidak, None.​

2.​ [Link](pattern, string): Mencari kecocokan di awal string saja.​

3.​ [Link](pattern, string): Mengembalikan semua substring yang cocok

dengan pola dalam bentuk list.​

4.​ [Link](pattern, repl, string): Mengganti semua kecocokan pattern di

dalam string dengan repl.​

Contoh script (search, findall, sub):

import re​
​
teks = "Email saya adalah user@[Link]. Alternatif lainnya:
user2@[Link]"​
​
pattern_email = r"[a-zA-Z0-9_.]+@[a-zA-Z0-9_.]+\.[a-zA-Z0-9]+"​
​
# search​
hasil_search = [Link](pattern_email, teks)​
if hasil_search:​
print("Hasil search:", hasil_search.group())​
​
# findall​
hasil_findall = [Link](pattern_email, teks)​
print("Hasil findall:", hasil_findall)​
​
# sub​
teks_disamarkan = [Link](pattern_email, "[email-dihilangkan]", teks)​
print("Teks disamarkan:", teks_disamarkan)

Output:
Hasil search: user@[Link]

Hasil findall: ['user@[Link]', 'user2@[Link]']

Teks disamarkan: Email saya adalah [email-dihilangkan]. Alternatif

lainnya: [email-dihilangkan]

Penjelasan output:

●​ [Link](pattern_email, teks) menemukan kecocokan pertama yaitu

user@[Link].​

●​ [Link](pattern_email, teks) mengembalikan semua email dalam list,

yaitu ['user@[Link]', 'user2@[Link]'].​

●​ [Link](pattern_email, "[email-dihilangkan]", teks) mengganti

setiap email yang ditemukan dengan teks "[email-dihilangkan]".​

Penggunaan regex sangat luas dalam data science, misalnya membersihkan data teks
(menghapus karakter aneh, mengekstrak informasi spesifik, dsb.).
BAB 7 – PENANGANAN ERROR DAN
LOGGING
Tidak jarang saat menulis kode Python, kita menjumpai error atau exception. Ketika kode
kita melakukan operasi yang tidak valid, misalnya membagi dengan nol, mengakses indeks
di luar jangkauan, atau membuka berkas yang tidak ada, Python akan melempar exception.
Bab ini akan memandu cara penanganan error (exception handling) dengan try-except,
cara membuat exception kustom, serta teknik logging untuk mencatat jalannya program.

7.1 Error dan Exception

Error di Python biasanya terangkat (raise) sebagai exception. Beberapa jenis exception
umum:

●​ ZeroDivisionError (membagi dengan nol)​

●​ ValueError (tipe nilai tidak sesuai)​

●​ TypeError (operasi tidak sesuai dengan tipe data)​

●​ IndexError (indeks di luar jangkauan list/tuple/string)​

●​ KeyError (key tidak ditemukan di dictionary)​

Try-Except Block

try-except digunakan untuk mencegah program berhenti ketika terjadi exception. Kita
dapat menambahkan blok else yang dieksekusi jika tidak ada exception, dan blok
finally yang dieksekusi selalu, entah terjadi error atau tidak.

Contoh script (Dasar try-except):

try:​
angka1 = int(input("Masukkan angka pertama: "))​
angka2 = int(input("Masukkan angka kedua: "))​
hasil = angka1 / angka2​
print("Hasil pembagian:", hasil)​
except ZeroDivisionError:​
print("Error: Tidak bisa membagi dengan nol.")
Output (Contoh dasar):

●​ Jika user memasukkan angka2 = 0, maka akan mencetak "Error: Tidak bisa
membagi dengan nol.".​

●​ Jika user memasukkan angka biasa, misal 10 dan 2, maka akan mencetak "Hasil
pembagian: 5.0".​

Penjelasan output:

●​ Jika terjadi ZeroDivisionError, blok except dijalankan dan program tidak

berhenti.​

●​ Jika tidak ada error, perintah di except tidak dieksekusi.​

Contoh script (else dan finally):

try:​
angka1 = int(input("Masukkan angka pertama: "))​
angka2 = int(input("Masukkan angka kedua: "))​
hasil = angka1 / angka2​
except ValueError:​
print("Input harus berupa angka.")​
except ZeroDivisionError:​
print("Tidak bisa membagi dengan nol.")​
else:​
print("Hasil pembagian:", hasil)​
finally:​
print("Terima kasih telah menggunakan program ini.")

Output (Variasi 1, user memasukkan 5 dan 2):

Masukkan angka pertama: 5

Masukkan angka kedua: 2

Hasil pembagian: 2.5

Terima kasih telah menggunakan program ini.

Output (Variasi 2, user memasukkan 5 dan 0):

Masukkan angka pertama: 5

Masukkan angka kedua: 0

Tidak bisa membagi dengan nol.

Terima kasih telah menggunakan program ini.

Output (Variasi 3, user memasukkan a dan b):

Masukkan angka pertama: a

Input harus berupa angka.

Terima kasih telah menggunakan program ini.

Penjelasan output:

●​ Pada Variasi 1, tidak ada error, sehingga blok else dijalankan (Hasil pembagian:
2.5). Blok finally selalu dijalankan mencetak “Terima kasih…”.​

●​ Pada Variasi 2, terjadi ZeroDivisionError, sehingga blok except

ZeroDivisionError menampilkan “Tidak bisa membagi dengan nol.” Blok else
dilewati, namun finally tetap jalan.​

●​ Pada Variasi 3, terjadi ValueError karena input tidak bisa dikonversi menjadi
integer. Blok except ValueError dijalankan, lalu finally.

7.2 Membuat Exception Sendiri

Kita bisa membuat exception kustom dengan menurunkan kelas dari Exception. Ini
berguna jika kita ingin menandai kesalahan spesifik yang hanya relevan di program kita.

Contoh script (Exception kustom):

class NilaiNegatifError(Exception):​
"""Exception untuk menandakan bahwa nilai negatif tidak
diizinkan."""​
pass​
​
def hitung_akar_pangkat2(x):​
if x < 0:​
raise NilaiNegatifError("Tidak bisa menghitung akar dari nilai
negatif.")​
 return x ** 0.5​
​
try:​
angka = float(input("Masukkan bilangan: "))​
hasil = hitung_akar_pangkat2(angka)​
print(f"Akar dari {angka} adalah {hasil}")​
except NilaiNegatifError as e:​
print("Terjadi error:", e)​
except ValueError:​
print("Input harus berupa angka.")

Output (Jika user memasukkan -9):

Masukkan bilangan: -9

Terjadi error: Tidak bisa menghitung akar dari nilai negatif.

Output (Jika user memasukkan 16):

Masukkan bilangan: 16

Akar dari 16.0 adalah 4.0

Penjelasan output:

●​ Kita mendefinisikan kelas exception NilaiNegatifError(Exception). Jika x <

0, kita raise NilaiNegatifError("Tidak bisa menghitung akar…").​

●​ Ketika user memasukkan -9, program langsung melempar NilaiNegatifError

dan masuk ke blok except NilaiNegatifError as e.​

●​ Jika user memasukkan 16 (positif), blok try sukses, dan menampilkan akar 16, yaitu
4.0.​

Dengan exception kustom, kita bisa lebih spesifik dalam menandai error terkait domain
permasalahan kita.

7.3 Logging
Logging adalah proses mencatat informasi tentang jalannya program ke console atau ke file,
sehingga kita bisa memantau apa yang terjadi. Dalam data science, logging membantu kita
mengecek proses training, debugging, dan performa model. Python menyediakan modul
logging untuk mengatur level pesan (DEBUG, INFO, WARNING, ERROR, CRITICAL).

Konfigurasi Dasar logging Module

import logging​
​
# Set level logging. Misal, level=DEBUG maka semua pesan log dari DEBUG
ke atas akan tampil​
[Link](level=[Link],
format='%(levelname)s:%(message)s')​
​
[Link]("Ini debug - rincian detail untuk diagnosis.")​
[Link]("Ini info - pesan informasi umum.")​
[Link]("Ini warning - peringatan adanya potensi masalah.")​
[Link]("Ini error - ada kesalahan.")​
[Link]("Ini critical - error serius.")

Output (Di console, jika level=DEBUG):

DEBUG:Ini debug - rincian detail untuk diagnosis.

INFO:Ini info - pesan informasi umum.

WARNING:Ini warning - peringatan adanya potensi masalah.

ERROR:Ini error - ada kesalahan.

CRITICAL:Ini critical - error serius.

Penjelasan output:

●​ [Link]() menampilkan pesan level DEBUG. Kita bisa mengatur level log
minimal yang ingin ditampilkan. Jika level minimal adalah WARNING, maka pesan
INFO dan DEBUG tidak tampil.​

●​ format='%(levelname)s:%(message)s' menentukan format output log, yaitu

menampilkan level log dan pesan.​

Menulis Log ke File

Kita dapat mengatur logging supaya dicatat ke file, sehingga bisa ditinjau ulang. Ini
membantu saat proses data yang panjang atau saat kita ingin menyimpan log di server.
 import logging​
​
[Link](​
filename='[Link]', ​
level=[Link], ​
format='%(asctime)s - %(levelname)s - %(message)s'​
)​
​
[Link]("Program dimulai.")​
[Link]("Pastikan data terisi sebelum dijalankan.")​
[Link]("Terjadi error ketika mengakses berkas.")​
[Link]("Program berakhir.")

Penjelasan:

●​ filename='[Link]' menyimpan semua pesan log ke dalam file [Link].​

●​ format='%(asctime)s - %(levelname)s - %(message)s' menambahkan

timestamp (asctime) ke setiap pesan log.​

●​ Level log yang diatur adalah INFO, sehingga pesan INFO, WARNING, ERROR,
CRITICAL akan ditulis, sedangkan DEBUG tidak.​

Penerapan Logging dalam Kasus Data Loading

Berikut contoh penerapan logging saat kita memuat data dari file CSV, di mana kita ingin
tahu apakah file sukses diakses atau tidak.

import logging​
import os​
​
[Link](level=[Link], format='%(asctime)s -
%(levelname)s - %(message)s')​
​
def load_data_csv(filename):​
if not [Link](filename):​
[Link](f"File {filename} tidak ditemukan.")​
return None​
else:​
[Link](f"Membuka file {filename}...")​
with open(filename, 'r', encoding='utf-8') as f:​
data = [Link]()​
 [Link](f"Berhasil membaca {len(data)} baris dari file
{filename}.")​
return data​
​
data = load_data_csv("data_salah.csv") # Misalnya file ini tidak ada​
if data is None:​
print("Tidak bisa melanjutkan karena file tidak ditemukan.")​
else:​
print("Data berhasil dimuat.")

Output (Jika file data_salah.csv tidak ada):

2025-04-03 10:00:00,123 - ERROR - File data_salah.csv tidak

ditemukan.

Tidak bisa melanjutkan karena file tidak ditemukan.

Penjelasan output:

●​ [Link](filename) mengecek apakah file ada. Jika tidak ada, logging

akan mencatat pesan ERROR.​

●​ Karena data bernilai None, program menampilkan pesan “Tidak bisa

melanjutkan…”.​

●​ Jika file ada, logging menampilkan pesan INFO bahwa file dibuka dan berapa baris
yang dibaca.​

Dengan logging, kita dapat mudah menelusuri alur eksekusi program tanpa
mencampuradukkan dengan output untuk user. Ini sangat penting untuk aplikasi data
science yang biasanya memproses data besar dan membutuhkan pemantauan ketat.

Dengan demikian, Bab 6 dan Bab 7 telah membahas manipulasi string (mulai dari metode
built-in hingga regex) serta penanganan error (try-except, membuat exception sendiri) dan
logging (untuk mencatat jalannya program). Pemahaman menyeluruh akan topik ini
membantu kamu menangani teks dengan lebih baik dalam persiapan analisis data, serta
merancang program yang lebih tangguh terhadap kesalahan dan mudah dilacak saat terjadi
masalah.
BAB 8 – PEMROGRAMAN
BERORIENTASI OBJEK (OOP) DASAR
Pemrograman berorientasi objek (Object-Oriented Programming, OOP) adalah paradigma
pemrograman yang berfokus pada pembuatan “objek” yang memiliki atribut (data/properti)
dan metode (fungsi/perilaku). Python mendukung OOP dengan sintaks yang relatif mudah
dibaca. Dalam data science, mungkin kamu akan menemui berbagai library atau framework
yang dikemas dalam bentuk kelas dan objek, sehingga memahami OOP penting agar kamu
bisa memanfaatkannya dengan optimal.

8.1 Kelas dan Objek

Dalam Python, kelas didefinisikan menggunakan kata kunci class. Kelas adalah template
atau cetakan yang mendeskripsikan perilaku dan atribut suatu entitas. Ketika kamu
membuat “instance” dari kelas tersebut, maka kamu mendapatkan sebuah objek yang
memiliki data dan fungsi sesuai definisi kelasnya.

Membuat Kelas dan Objek

Kita dapat membuat kelas sederhana dengan menuliskan class NamaKelas:. Di

dalamnya, kita dapat menulis metode yang minimal sebuah metode konstruktor
__init__() jika kita perlu menginisialisasi atribut.

class Mahasiswa:​
# __init__ disebut konstruktor, dijalankan saat objek diciptakan​
def __init__(self, nama, nim):​
[Link] = nama # [Link] adalah atribut milik objek​
[Link] = nim​
​
def perkenalan(self):​
print(f"Perkenalkan, nama saya {[Link]} dan NIM saya
{[Link]}.")​
​
# Membuat objek / instance dari kelas Mahasiswa​
m1 = Mahasiswa("Andi", "12345")​
m2 = Mahasiswa("Budi", "67890")​
​
# Memanggil metode perkenalan​
[Link]()​
[Link]()
Output:

Perkenalkan, nama saya Andi dan NIM saya 12345.

Perkenalkan, nama saya Budi dan NIM saya 67890.

Penjelasan output:

●​ class Mahasiswa: adalah definisi kelas.​

●​ __init__(self, nama, nim) adalah konstruktor yang otomatis dipanggil saat

kita membuat objek. Parameter self selalu merujuk ke objek yang sedang dibuat.​

●​ [Link] dan [Link] menjadi atribut yang berbeda untuk setiap objek.​

●​ Ketika kita memanggil Mahasiswa("Andi", "12345"), Python menjalankan

__init__, mengisi [Link] = "Andi" dan [Link] = "12345" untuk
objek m1. Hal serupa terjadi untuk m2.​

●​ Memanggil [Link]() membuat program mengeksekusi

print(f"Perkenalkan...") dengan format nama dan NIM objek m1.​

Atribut dan Metode Kelas

Di dalam kelas, kita dapat membedakan antara “atribut instance” (yang unik untuk setiap
objek) dan “atribut kelas” (yang sama untuk semua objek). Kita juga dapat membuat
“metode kelas” (class method) atau “metode statik” (static method) selain metode instance
biasa.

class Mobil:​
jumlah_mobil = 0 # Atribut kelas, dimiliki oleh semua objek​
​
def __init__(self, merek, model):​
[Link] = merek # Atribut instance​
[Link] = model # Atribut instance​
Mobil.jumlah_mobil += 1​
​
def info(self):​
print(f"Mobil merek {[Link]} dengan model {[Link]}.")​
​
@classmethod​
def total_mobil(cls):​
return cls.jumlah_mobil​
​
 ​
# Contoh penggunaan​
avanza = Mobil("Toyota", "Avanza")​
xenia = Mobil("Daihatsu", "Xenia")​
​
[Link]()​
[Link]()​
​
print("Total mobil yang dibuat:", Mobil.total_mobil())

Output:

Mobil merek Toyota dengan model Avanza.

Mobil merek Daihatsu dengan model Xenia.

Total mobil yang dibuat: 2

Penjelasan output:

●​ jumlah_mobil = 0 adalah atribut kelas; nilainya akan sama dan diakses oleh
semua instance. Setiap kali __init__ dipanggil, kita menambah
Mobil.jumlah_mobil += 1.​

●​ @classmethod menandakan bahwa total_mobil(cls) adalah metode kelas.

Alih-alih menerima parameter self, ia menerima parameter cls yang merujuk ke
kelas (Mobil).​

●​ Saat kita panggil Mobil.total_mobil(), ia mengembalikan

cls.jumlah_mobil, yakni total mobil yang telah dibuat.

8.2 Konsep OOP Dasar

Ada empat pilar utama OOP: Enkapsulasi, Inheritance, Polimorfisme, dan Abstraksi.
Meskipun beberapa konsep ini mungkin jarang dipakai secara mendalam di data science,
penting untuk memahaminya, karena banyak library besar Python memanfaatkan
fitur-fitur OOP.

8.2.1 Enkapsulasi

Enkapsulasi adalah konsep “membungkus” data (atribut) dan metode (fungsi) menjadi satu
kesatuan dalam kelas, sehingga kita dapat melindungi data tersebut dan memanfaatkan
metode tertentu untuk mengakses atau memodifikasi data. Python tidak memiliki kata
kunci “private” seperti bahasa lain, tetapi kita bisa menandai atribut dengan tanda garis
bawah _ atau __ (double underscore) sebagai kesepakatan bahwa atribut tersebut “internal”.

class AkunBank:​
def __init__(self, pemilik, saldo):​
[Link] = pemilik​
self.__saldo = saldo # atribut ini dianggap 'private' secara
konvensi​
​
def deposit(self, jumlah):​
self.__saldo += jumlah​
print(f"{jumlah} berhasil dideposit. Saldo sekarang:
{self.__saldo}")​
​
def tarik(self, jumlah):​
if jumlah > self.__saldo:​
print("Saldo tidak cukup!")​
else:​
self.__saldo -= jumlah​
print(f"Penarikan {jumlah} berhasil. Saldo sekarang:
{self.__saldo}")​
​
def cek_saldo(self):​
print(f"Saldo {[Link]} adalah {self.__saldo}")​
​
# Contoh penggunaan​
akun_andi = AkunBank("Andi", 1000)​
akun_andi.deposit(500)​
akun_andi.tarik(2000)​
akun_andi.cek_saldo()​
​
# Mencoba akses langsung saldo: akun_andi.__saldo -> ini tidak
direkomendasikan

Output:

500 berhasil dideposit. Saldo sekarang: 1500

Saldo tidak cukup!

Saldo Andi adalah 1500

Penjelasan output:
 ●​ __saldo menandakan bahwa kita tidak ingin atribut ini diakses langsung dari luar
kelas. Walau Python secara teknis memungkinkan akses “menerobos” dengan nama
khusus (_AkunBank__saldo), konvensi __saldo menandakan agar developer lain
berhati-hati.​

●​ deposit(500) menambah saldo dari 1000 menjadi 1500. Lalu kita coba tarik 2000,
yang melebihi saldo 1500, sehingga mencetak “Saldo tidak cukup!” dan saldo tetap
1500.

8.2.2 Inheritance (Pewarisan)

Inheritance memungkinkan kita membuat kelas baru dengan mewarisi atribut dan metode
dari kelas yang sudah ada, agar tidak menulis ulang hal yang sama. Kelas yang mewarisi
disebut “subclass” atau “child class”, sedangkan kelas yang diwarisi disebut “superclass” atau
“parent class”.

class Person:​
def __init__(self, nama, usia):​
[Link] = nama​
[Link] = usia​
​
def info(self):​
print(f"Nama: {[Link]}, Usia: {[Link]}")​
​
​
class Pelajar(Person):​
def __init__(self, nama, usia, sekolah):​
super().__init__(nama, usia) # Memanggil konstruktor Person​
[Link] = sekolah​
​
def info(self):​
super().info() # Memanggil method info() di kelas induk​
print(f"Sekolah: {[Link]}")​
​
​
# Contoh penggunaan​
p = Person("Dewi", 20)​
[Link]()​
print("--------")​
pelajar = Pelajar("Rina", 16, "SMA 1 Jakarta")​
[Link]()

Output:
Nama: Dewi, Usia: 20

--------

Nama: Rina, Usia: 16

Sekolah: SMA 1 Jakarta

Penjelasan output:

●​ class Pelajar(Person) berarti Pelajar adalah subclass dari Person.​

●​ Di __init__ milik Pelajar, kita memanggil super().__init__(nama, usia)

agar atribut nama dan usia diinisialisasi oleh kelas Person.​

●​ Saat kita memanggil info() pada pelajar, kita memanggil super().info()

agar mencetak “Nama” dan “Usia” kemudian menambahkan “Sekolah” dari subclass.

8.2.3 Polimorfisme

Polimorfisme berarti “banyak bentuk”, di mana suatu metode atau fungsi bisa memiliki
perilaku berbeda tergantung objek yang memanggilnya. Pada Python, polimorfisme sering
muncul saat kita menimpa (override) metode di subclass, atau ketika kita memanggil fungsi
umum dengan objek dari kelas berbeda.

class Hewan:​
def suara(self):​
print("Hewan ini bersuara dengan cara tertentu.")​
​
class Kucing(Hewan):​
def suara(self):​
print("Meong...")​
​
class Anjing(Hewan):​
def suara(self):​
print("Guk guk...")​
​
def tes_suara(hewan):​
[Link]()​
​
k = Kucing()​
a = Anjing()​
tes_suara(k) # Meong...​
tes_suara(a) # Guk guk...
Output:

Meong...

Guk guk...

Penjelasan output:

●​ Meskipun k dan a diperlakukan sama oleh tes_suara(hewan), pemanggilan

[Link]() akan berbeda karena Kucing menimpa metode suara() dengan
versinya sendiri, dan Anjing juga menimpa dengan versinya sendiri.

8.2.4 Abstraksi (Singkat)

Abstraksi memungkinkan kita mendefinisikan “konsep umum” dengan antarmuka tertentu,

sementara implementasi spesifik diserahkan ke subclass. Di Python, kita dapat
menggunakan modul abc (Abstract Base Class). Abstraksi dapat berguna jika kita ingin
memaksa subclass untuk mengimplementasikan metode-metode tertentu.

from abc import ABC, abstractmethod​

​
class Bentuk(ABC):​
@abstractmethod​
def luas(self):​
pass​
​
class Persegi(Bentuk):​
def __init__(self, sisi):​
[Link] = sisi​
​
def luas(self):​
return [Link] * [Link]​
​
# p = Bentuk() # Error, karena Bentuk adalah kelas abstrak​
persegi = Persegi(5)​
print("Luas persegi:", [Link]())

Output:

Luas persegi: 25

Penjelasan output:
 ●​ class Bentuk(ABC) menunjukkan kita membuat kelas abstrak dengan mewarisi
dari ABC.​

●​ @abstractmethod menandakan luas() harus diimplementasikan oleh subclass.​

●​ Jika kita coba instansiasi Bentuk() langsung, kita akan mendapat error karena
Bentuk adalah kelas abstrak dan belum memiliki implementasi luas().

8.3 Metode Khusus (Special Methods)

Python memiliki metode khusus (dunder methods – double underscore) seperti
__str__(), __repr__(), __add__(), __len__(), dsb., yang memungkinkan kita
menyesuaikan perilaku objek saat berinteraksi dengan fungsi atau operator bawaan.

8.3.1 __str__() dan __repr__()

class Buku:​
def __init__(self, judul, penulis):​
[Link] = judul​
[Link] = penulis​
​
def __str__(self):​
return f"'{[Link]}' oleh {[Link]}"​
​
def __repr__(self):​
return f"Buku('{[Link]}', '{[Link]}')"​
​
b1 = Buku("Belajar Python", "Andi")​
print(str(b1))​
print(repr(b1))

Output:

'Belajar Python' oleh Andi

Buku('Belajar Python', 'Andi')

Penjelasan output:
 ●​ __str__() adalah representasi string yang dibaca oleh manusia saat kita
memanggil print(objek).​

●​ __repr__() adalah representasi resmi (unambiguous) yang berguna saat

debugging. Bila memungkinkan, __repr__() sebaiknya menampilkan detail yang
memudahkan kita merekonstruksi objek.

8.3.2 Operator Overloading (__add__, __len__, dsb.)

Kita dapat menimpa perilaku operator matematika. Misalnya __add__ untuk +, __sub__
untuk -, __mul__ untuk *, dsb.

class Vector2D:​
def __init__(self, x, y):​
self.x = x​
self.y = y​
​
def __add__(self, other):​
return Vector2D(self.x + other.x, self.y + other.y)​
​
def __len__(self):​
# Asumsikan 'panjang' adalah jarak dari titik (0,0)​
return int((self.x**2 + self.y**2)**0.5)​
​
def __str__(self):​
return f"({self.x}, {self.y})"​
​
v1 = Vector2D(3, 4)​
v2 = Vector2D(1, 2)​
v3 = v1 + v2 # memanggil __add__​
​
print("v3 =", v3)​
print("len(v1) =", len(v1))

Output:

v3 = (4, 6)

len(v1) = 5

Penjelasan output:
 ●​ v1 + v2 memanggil v1.__add__(v2), membuat Vector2D baru dengan
x=3+1=4, y=4+2=6.​

●​ len(v1) memanggil __len__() yang kita definisikan untuk menghitung jarak

(3,4) dari (0,0), yaitu 5 (karena segitiga 3-4-5).​

●​ __str__() menampilkan string “(4, 6)” ketika v3 diprint.​

Objek-objek di library data science seperti NumPy array, Pandas Series, dsb. juga
memanfaatkan OOP, sehingga memahami konsep OOP di atas akan memudahkan kamu
memanipulasi dan memahami perilaku objek-objek tersebut.
BAB 9 – MEMULAI DATA SCIENCE
DENGAN PYTHON
Data science adalah disiplin yang bertujuan mengekstraksi wawasan (insight) dan
pengetahuan dari data. Python menjadi salah satu bahasa paling populer untuk data science
karena memiliki ekosistem library yang sangat kaya (NumPy, Pandas, Matplotlib,
Scikit-learn, dan banyak lagi). Bab ini memperkenalkan gambaran awal mengenai apa itu
data science dan bagaimana Python digunakan dalam alur kerjanya.

9.1 Pengenalan Data Science

Data science mencakup proses berikut:

1.​ Mengumpulkan data (data collection)​

2.​ Membersihkan data (data cleaning)​

3.​ Eksplorasi dan analisis data (data exploration & analysis)​

4.​ Pemodelan (modeling)​

5.​ Evaluasi dan interpretasi (evaluation & interpretation)​

6.​ Deployment (opsional, jika ingin hasil model diimplementasikan)​

Dalam setiap tahapan, Python menawarkan library yang bisa membantu Anda:

●​ Mengumpulkan data: Requests, BeautifulSoup (web scraping), API library​

●​ Membersihkan data: Pandas (merapikan data, menangani missing values, dll.)​

●​ Eksplorasi dan visualisasi: Pandas, NumPy, Matplotlib, Seaborn​

●​ Pemodelan: scikit-learn, TensorFlow, PyTorch (untuk deep learning)​

●​ Evaluasi: scikit-learn (metrik evaluasi), statsmodels (statistika), dll.​

Peran Python dalam Data Science

Python mudah dibaca, kaya library, dan komunitasnya besar. Ini menjadikannya pilihan
utama bagi data scientist. Kita bisa bekerja secara interaktif menggunakan Jupyter
Notebook, yang memungkinkan kita menulis code dan melihat hasilnya (termasuk
visualisasi) di tempat yang sama.

9.2 Lingkungan Data Science

Terdapat beberapa opsi utama untuk menyiapkan lingkungan (environment) data science di
Python:

1.​ Anaconda Distribution: Salah satu distribusi Python yang sudah menyertakan
paket-paket data science penting seperti NumPy, Pandas, Matplotlib, scikit-learn,
dan Jupyter. Cocok untuk pemula karena instalasinya relatif sederhana.​

2.​ Jupyter Notebook & JupyterLab: Interface interaktif yang populer di kalangan data
scientist. Kita bisa menulis code dalam sel, mengeksekusinya, menampilkan grafik,
dan menambahkan catatan (markdown).​

3.​ Google Colab: Layanan notebook berbasis cloud dari Google. Tidak perlu instal
apapun, hanya memerlukan akun Google. Sering dipakai untuk kolaborasi atau jika
kita tidak ingin repot menyiapkan environment lokal.​

4.​ Editor lain: Bisa juga menggunakan VSCode, PyCharm, Spyder, dll., tergantung
preferensi.​

9.2.1 Anaconda Distribution

Anaconda adalah paket bundle yang berisi Python, conda (package manager), dan banyak
library siap pakai.

●​ Setelah instalasi, kita mendapatkan perintah conda yang dapat digunakan seperti
pip untuk mengatur paket.​

●​ Kita juga bisa membuat environment terpisah dengan conda create --name
env_baru python=3.9.​

●​ Di dalam environment, kita bisa menginstal library dengan conda install

numpy pandas matplotlib scikit-learn.​

Contoh script (Menjalankan Jupyter Notebook dari Anaconda Prompt):

# Pastikan berada di environment yang sudah diaktifkan

jupyter notebook

Output:​
Akan membuka tab di browser, menampilkan interface Jupyter Notebook di mana kamu
bisa membuat file .ipynb dan mulai menulis kode Python interaktif.

Penjelasan output:

●​ Jupyter Notebook menampilkan daftar berkas di direktori kerja kamu. Kamu bisa
membuat notebook baru, menulis code di sel, dan mengeksekusinya.​

●​ Hasil print atau plot akan muncul langsung di bawah sel yang dijalankan.

9.2.2 Jupyter Notebook vs JupyterLab

●​ Jupyter Notebook: Interface klasik, sel code terpisah, sel markdown untuk catatan.​

●​ JupyterLab: Versi lebih modern dan fleksibel, tampilan tab, panel, integrasi
terminal, editor teks, dsb.​

●​ Keduanya sama-sama berguna, tetapi JupyterLab lebih disukai banyak pengguna

karena kemudahan navigasinya.

9.2.3 Perbandingan Tools Lain

●​ Spyder: IDE mirip MATLAB, sering disertakan dalam instalasi Anaconda. Memiliki
jendela variable explorer, console, dll.​

●​ VSCode: Editor yang populer dengan plugin Python. Dapat membuka notebook,
debugging, manajemen environment, dsb.​

●​ PyCharm: IDE Python yang powerful, bagus untuk project skala menengah-besar,
meski setup untuk data science perlu sedikit konfigurasi plugin.​

●​ Google Colab: Alternatif gratis berbasis cloud, cocok untuk kolaborasi, khususnya
bagi yang tidak mau repot memasang environment lokal.​

Contoh Sederhana Penerapan Data Science

Untuk memberi gambaran tentang penggunaan Python di data science, berikut contoh
singkat tentang bagaimana kita melakukan pengolahan data sederhana dengan Pandas dan
NumPy, serta membuat visualisasi dengan Matplotlib. (Detail lebih lanjut akan dibahas di
bab khusus Numpy, Pandas, dan Visualisasi.)

import numpy as np​

import pandas as pd​
import [Link] as plt​
​
# Membuat data sederhana​
data = {​
"Name": ["Alice", "Bob", "Charlie", "Diana", "Ethan"],​
"Age": [24, 30, 18, 22, 29],​
"Score": [90, 85, 75, 90, 80]​
}​
​
df = [Link](data)​
print("DataFrame:\n", df)​
​
# Analisis sederhana: mencari rata-rata Age dan Score​
mean_age = df["Age"].mean()​
mean_score = df["Score"].mean()​
print(f"\nRata-rata Age: {mean_age}")​
print(f"Rata-rata Score: {mean_score}")​
​
# Visualisasi sederhana​
[Link](df["Name"], df["Score"])​
[Link]("Bar Plot Score")​
[Link]("Name")​
[Link]("Score")​
[Link]()

Output (DataFrame dan analisis):

DataFrame:

Name Age Score

0 Alice 24 90

1 Bob 30 85

2 Charlie 18 75

3 Diana 22 90

4 Ethan 29 80
Rata-rata Age: 24.6

Rata-rata Score: 84.0

Setelah itu, akan muncul jendela plot menampilkan bar chart dengan sumbu x =
["Alice", "Bob", "Charlie", "Diana", "Ethan"] dan tinggi batang sesuai nilai
Score.

Penjelasan output:

●​ Kita mendefinisikan data sebagai dictionary, lalu membuat DataFrame df dengan

[Link](data).​

●​ df["Age"].mean() dan df["Score"].mean() mengembalikan nilai rata-rata

kolom Age dan Score.​

●​ [Link](...) membuat diagram batang, menampilkan nama di sumbu X dan

nilai skor di sumbu Y.​

●​ [Link]() menampilkan grafik pada layar. Di Jupyter Notebook, grafik langsung

muncul di bawah sel, sedangkan di editor lain mungkin muncul jendela pop-up.​

Melalui contoh tersebut, kamu dapat melihat betapa Python memudahkan kita dalam
memanipulasi data (melalui Pandas) serta membuat visualisasi (melalui Matplotlib). Ini
hanya permulaan. Di bab-bab berikutnya kamu akan mengenal NumPy, Pandas, dan tools
visualisasi yang lebih mendalam, termasuk teknik analisis dan machine learning dasar
menggunakan scikit-learn.
BAB 10 – NUMPY: DASAR MANIPULASI
ARRAY
NumPy (Numeric Python) adalah salah satu library fundamental dalam ekosistem data
science Python. NumPy menyediakan struktur data array multidimensi yang sangat efisien
dan berbagai fungsi untuk melakukan komputasi numerik dengan cepat. Berbeda dengan
list bawaan Python, array NumPy memiliki tipe data yang seragam dan ukuran yang tetap,
sehingga operasi matematis dapat dijalankan jauh lebih cepat, terutama bila kamu
berurusan dengan data berukuran besar.

10.1 Pengenalan NumPy

NumPy biasanya diimpor dengan alias np:

import numpy as np

Banyak library data science lain (seperti Pandas dan scikit-learn) dibangun di atas NumPy
atau mengandalkan struktur array NumPy. Oleh karena itu, pemahaman dasar NumPy
penting sebelum melangkah ke tahap analisis dan pemodelan data yang lebih lanjut.

Keuntungan menggunakan NumPy Array:

1.​ Kecepatan: Operasi vektor dan matriks di NumPy ditulis dalam bahasa C, sehingga
lebih cepat dibanding list Python.​

2.​ Penggunaan Memori Efisien: Array NumPy hanya menyimpan satu tipe data,
sehingga memori dapat diatur dengan efisien.​

3.​ Fungsi Matematis Siap Pakai: Terdapat banyak fungsi untuk operasi linear algebra,
transformasi Fourier, statistik, dll.

10.2 Membuat Array

Berikut beberapa cara umum untuk membuat array NumPy:

1.​ [Link](): Mengkonversi list (atau struktur data lain) menjadi array NumPy.​

2.​ [Link](): Membuat array berurutan dari suatu rentang.​

 3.​ [Link](): Membuat array berisi nilai yang terdistribusi sama rata dalam
suatu interval.​

4.​ Array khusus: [Link](), [Link](), [Link](), serta [Link] untuk

membuat array acak.

10.2.1 [Link]()
import numpy as np​
​
list_awal = [1, 2, 3, 4, 5]​
arr = [Link](list_awal)​
​
print("Tipe:", type(arr))​
print("Isi array:", arr)​
print("Tipe data array:", [Link])

Output:

Tipe: <class '[Link]'>

Isi array: [1 2 3 4 5]

Tipe data array: int64

Penjelasan output:

●​ [Link](list_awal) mengubah Python list menjadi [Link] (struktur

data array milik NumPy).​

●​ [Link] menunjukkan tipe data elemen array; di environment tertentu,

mungkin muncul int32 atau int64 tergantung platform.

10.2.2 [Link]()

arange(start, stop, step) berfungsi mirip range() pada Python, namun

mengembalikan array NumPy.

arr_arange = [Link](0, 10, 2)​

print("[Link](0, 10, 2) ->", arr_arange)

Output:
 [Link](0, 10, 2) -> [0 2 4 6 8]

Penjelasan:

●​ Membuat array dari 0 hingga 8 (karena 10 tidak termasuk) dengan step 2,

menghasilkan [0, 2, 4, 6, 8].​

10.2.3 [Link]()

linspace(start, stop, num) membuat array yang terdiri dari num titik yang
terdistribusi merata di interval [start, stop].

arr_linspace = [Link](0, 1, 5)​

print("[Link](0, 1, 5) ->", arr_linspace)

Output:

[Link](0, 1, 5) -> [0. 0.25 0.5 0.75 1. ]

Penjelasan:

●​ Python membagi jarak dari 0 sampai 1 menjadi 4 segmen, menghasilkan 5 titik (0,
0.25, 0.5, 0.75, 1.0).​

10.2.4 Array Khusus ([Link](), [Link](), [Link](), [Link]())

●​ [Link](shape) membuat array dengan nilai 0.​

●​ [Link](shape) membuat array dengan nilai 1.​

●​ [Link](n) membuat matriks identitas berukuran n x n.​

●​ [Link]() membuat array acak dengan distribusi uniform di interval [0,

1).​

●​ [Link]() membuat array acak dengan distribusi normal (mean=0,

std=1).​
zeros_arr = [Link]((2, 3))​
ones_arr = [Link]((3, 2))​
eye_arr = [Link](3)​
rand_arr = [Link](2,2) # matriks 2x2 random [0,1)​
​
print("[Link]((2,3)):\n", zeros_arr)​
print("[Link]((3,2)):\n", ones_arr)​
print("[Link](3):\n", eye_arr)​
print("[Link](2,2):\n", rand_arr)

Output (contoh acak):

[Link]((2,3)):

[[0. 0. 0.]

[0. 0. 0.]]

[Link]((3,2)):

[[1. 1.]

[1. 1.]

[1. 1.]]

[Link](3):

[[1. 0. 0.]

[0. 1. 0.]

[0. 0. 1.]]

[Link](2,2):

[[0.45032172 0.98006717]

[0.29157038 0.22253041]]
Penjelasan output:

●​ zeros_arr adalah array 2 baris, 3 kolom berisi nol semua.​

●​ ones_arr adalah array 3 baris, 2 kolom berisi satu semua.​

●​ eye_arr matriks identitas 3x3 (diagonal utama = 1, sisanya 0).​

●​ rand_arr adalah 2x2 dengan nilai acak di antara 0 dan 1.

10.3 Operasi Dasar pada Numpy Array

Setelah kita memiliki array, kita sering kali perlu melakukan operasi seperti aritmatika,
indexing, slicing, reshaping, dan broadcasting.

10.3.1 Aritmatika Dasar

Operasi penjumlahan, pengurangan, perkalian, pembagian, dan berbagai fungsi

matematika seperti akar, logaritma, dapat dilakukan secara element-wise.

arr_a = [Link]([1, 2, 3])​

arr_b = [Link]([4, 5, 6])​
​
print("arr_a + arr_b:", arr_a + arr_b)​
print("arr_a * arr_b:", arr_a * arr_b)​
print("arr_a ** 2:", arr_a ** 2)​
print("[Link](arr_b):", [Link](arr_b))

Output:

arr_a + arr_b: [5 7 9]

arr_a * arr_b: [ 4 10 18]

arr_a ** 2: [1 4 9]

[Link](arr_b): [2. 2.23606798 2.44948974]

Penjelasan output:

●​ arr_a + arr_b menambahkan elemen per elemen: [1+4, 2+5, 3+6] = [5,
7, 9].​
 ●​ arr_a * arr_b mengalikan elemen per elemen: [1*4, 2*5, 3*6] = [4, 10,
18].​

●​ arr_a ** 2 mempangkatkan setiap elemen di arr_a dengan 2, jadilah [1, 4, 9].​

●​ [Link](arr_b) mengambil akar tiap elemen di arr_b.

10.3.2 Akses Elemen (Indexing, Slicing)

NumPy array dapat diakses mirip dengan list, namun mendukung indexing multi-dimensi.

mat = [Link]([[1, 2, 3],​

[4, 5, 6],​
[7, 8, 9]])​
​
# Akses elemen tunggal​
elem_22 = mat[2, 2] # baris ke-2, kolom ke-2 (indeks dimulai 0)​
print("mat[2,2]:", elem_22)​
​
# Slicing​
row_slice = mat[1, :] # baris ke-1, semua kolom​
col_slice = mat[:, 1] # semua baris, kolom ke-1​
​
print("Slicing baris ke-1:", row_slice)​
print("Slicing kolom ke-1:", col_slice)​
​
# Slicing sub-matriks​
sub_mat = mat[0:2, 1:3] # ambil baris 0 s.d <2, kolom 1 s.d <3​
print("Sub matrix:\n", sub_mat)

Output:

mat[2,2]: 9

Slicing baris ke-1: [4 5 6]

Slicing kolom ke-1: [2 5 8]

Sub matrix:

[[2 3]

[5 6]]
Penjelasan output:

●​ mat[2,2] artinya baris ke-3 kolom ke-3 (karena indeks mulai dari 0), nilainya 9.​

●​ mat[1, :] mengambil seluruh kolom di baris kedua (indeks 1), menghasilkan [4,
5, 6].​

●​ mat[:, 1] mengambil seluruh baris di kolom kedua (indeks 1), menghasilkan [2,
5, 8].​

●​ mat[0:2, 1:3] mengambil baris 0 sampai 1, dan kolom 1 sampai 2, membentuk

sub-matriks [[2,3],[5,6]].

10.3.3 Manipulasi Bentuk (reshape, ravel, transpose)

●​ reshape(new_shape): Mengubah bentuk array tanpa mengubah data.​

●​ **ravel() atau flatten(): Mengubah array multidimensi menjadi array 1

dimensi.​

●​ transpose(): Menukar baris dan kolom pada matriks.​

arr_1d = [Link](6) # [0 1 2 3 4 5]​

arr_2d = arr_1d.reshape((2, 3))​
​
print("arr_1d:", arr_1d)​
print("arr_2d (2x3):\n", arr_2d)​
print("arr_2d ravel:", arr_2d.ravel())​
print("arr_2d transpose:\n", arr_2d.T)

Output:

arr_1d: [0 1 2 3 4 5]

arr_2d (2x3):

[[0 1 2]

[3 4 5]]

arr_2d ravel: [0 1 2 3 4 5]
arr_2d transpose:

[[0 3]

[1 4]

[2 5]]

Penjelasan output:

●​ reshape((2,3)) membentuk array berukuran 2 baris dan 3 kolom dari [0, 1,

2, 3, 4, 5].​

●​ ravel() meratakan array 2D kembali menjadi 1D.​

●​ arr_2d.T (transpose) menukar baris menjadi kolom.

10.3.4 Broadcasting

Broadcasting memungkinkan operasi antara dua array dengan dimensi berbeda. NumPy
akan “memperluas” array yang lebih kecil agar memiliki dimensi yang cocok.

arr_x = [Link]([10, 20, 30])

mat_y = [Link]([[1],

[2],

[3]])

# arr_x berukuran (3,), mat_y berukuran (3,1)

# Broadcasting memungkinkan arr_x + mat_y -> (3,3)

hasil = arr_x + mat_y

print("arr_x + mat_y:\n", hasil)

Output:

arr_x + mat_y:
 [[11 21 31]

[12 22 32]

[13 23 33]]

Penjelasan output:

●​ arr_x adalah [10, 20, 30] (bentuk (3,)).​

●​ mat_y adalah [[1],[2],[3]] (bentuk (3,1)).​

●​ NumPy melakukan broadcasting, menyalin arr_x di sepanjang baris dan mat_y di

sepanjang kolom, sehingga kita mendapat hasil array (3,3).

10.4 Fungsi-Fungsi Statistik

NumPy memiliki banyak fungsi statistik built-in untuk menghitung rata-rata, median,
standar deviasi, varian, jumlah total, nilai maksimal, minimal, dsb. Semua operasi ini
dilakukan secara cepat dengan memanfaatkan array NumPy.

data = [Link]([1, 2, 3, 4, 5])​

​
print("Sum:", [Link](data))​
print("Mean:", [Link](data))​
print("Median:", [Link](data))​
print("Std Dev:", [Link](data))​
print("Variance:", [Link](data))​
print("Min:", [Link](data))​
print("Max:", [Link](data))

Output:

Sum: 15

Mean: 3.0

Median: 3.0

Std Dev: 1.4142135623730951

Variance: 2.0

Min: 1
Max: 5

Penjelasan output:

●​ [Link](data) menambahkan seluruh elemen, dapat dilakukan juga dengan

[Link]().​

●​ [Link](data), [Link](data), [Link](data), [Link](data) memberi

nilai rata-rata, median, standar deviasi, dan varian.​

●​ [Link](data) dan [Link](data) mencari nilai minimal dan maksimal.

10.5 Teknik Lanjutan Numpy

10.5.1 Fancy Indexing

Fancy indexing adalah teknik memilih elemen tertentu di dalam array menggunakan list
atau array indeks.

arr_sample = [Link]([10, 20, 30, 40, 50])​

index_list = [0, 2, 4]​
selected = arr_sample[index_list]​
print("Fancy indexing:", selected

Output:

Fancy indexing: [10 30 50]

Penjelasan:

●​ arr_sample[index_list] mengekstrak elemen di indeks 0, 2, dan 4, hasilnya

[10, 30, 50].

10.5.2 Boolean Masking

Boolean masking memfilter elemen array berdasarkan kondisi yang mengembalikan

boolean True/False.

data_mask = [Link]([1, 3, 5, 7, 9, 10, 12])​

mask = data_mask > 5 # menghasilkan array boolean​
filtered_data = data_mask[mask]​
 print("Mask:", mask)​
print("Filtered data:", filtered_data)

Output:

Mask: [False False False True True True True]

Filtered data: [ 7 9 10 12]

Penjelasan output:

●​ data_mask > 5 menghasilkan [False, False, False, True, True,

True, True].​

●​ data_mask[mask] memilih elemen yang True, yaitu [7, 9, 10, 12].

10.5.3 Concatenate dan Split Array

●​ [Link]((arr1, arr2), axis=...) menggabungkan dua atau lebih

array di sepanjang sumbu tertentu.​

●​ [Link](arr, indices_or_sections, axis=...) membagi array menjadi

beberapa bagian di sepanjang sumbu yang ditentukan.​

arr1 = [Link]([1, 2, 3])​

arr2 = [Link]([4, 5, 6])​
combined = [Link]((arr1, arr2))​
print("Combined:", combined)​
​
# Split array​
arr_big = [Link]([10, 20, 30, 40, 50, 60])​
split1, split2, split3 = [Link](arr_big, [2, 4]) # Memotong di indeks
2 dan 4​
print("split1:", split1)​
print("split2:", split2)​
print("split3:", split3)

Output:

Combined: [1 2 3 4 5 6]
split1: [10 20]

split2: [30 40]

split3: [50 60]

Penjelasan:

●​ [Link]((arr1, arr2)) menghasilkan [1, 2, 3, 4, 5, 6].​

●​ [Link](arr_big, [2, 4]) memotong array di indeks 2 (antara elemen ke-2

dan ke-3) serta indeks 4 (antara elemen ke-4 dan ke-5).​

Dengan menguasai NumPy, kamu dapat melakukan manipulasi array yang kompleks secara
efisien. Konsep array akan menjadi dasar bagi library seperti Pandas (untuk data tabular)
dan scikit-learn (untuk machine learning).
BAB 11 – PANDAS: PENGOLAHAN DATA
TABEL
Pandas adalah library Python yang sangat populer untuk mengolah data terstruktur
(tabular), seperti data dari file CSV, Excel, SQL, dan sebagainya. Pandas menyediakan dua
struktur data utama: Series (1D) dan DataFrame (2D). Dengan Pandas, kamu dapat
membaca data dari berbagai format, membersihkan data, menggabungkan tabel, dan
melakukan eksplorasi dengan mudah sebelum melanjutkan ke tahap pemodelan dalam data
science.

11.1 Pengenalan Pandas

Biasanya, Pandas diimpor dengan alias pd:

import pandas as pd

Pandas memudahkan kamu menangani data yang berisi label kolom (column names) dan
label baris (index). Fitur ini menjadikannya mirip spreadsheet, namun dengan performa
dan fleksibilitas bahasa pemrograman.

Beberapa kelebihan Pandas:

1.​ DataFrame yang intuitif, mirip tabel, dengan label kolom dan baris.​

2.​ Fleksibilitas dalam manipulasi data: filtering, grouping, pivoting, merging, dsb.​

3.​ Integrasi yang baik dengan NumPy, Matplotlib, dan library lain.

11.2 Series
Series adalah struktur data satu dimensi dengan label pada setiap elemennya. Kamu bisa
menganggapnya sebagai kolom tunggal pada tabel.

11.2.1 Membuat Series (Dari List, Numpy Array, Dictionary)

import pandas as pd​
​
# Dari list​
data_list = [10, 20, 30]​
series_list = [Link](data_list)​
print("Series dari list:")​
print(series_list)​
​
# Dari array NumPy​
import numpy as np​
data_array = [Link]([0.5, 1.5, 2.5])​
series_array = [Link](data_array)​
print("\nSeries dari array:")​
print(series_array)​
​
# Dari dictionary​
data_dict = {"a": 100, "b": 200, "c": 300}​
series_dict = [Link](data_dict)​
print("\nSeries dari dictionary:")​
print(series_dict)

Output:

Series dari list:

0 10

1 20

2 30

dtype: int64

Series dari array:

0 0.5

1 1.5

2 2.5

dtype: float64

Series dari dictionary:

a 100

b 200
c 300

dtype: int64

Penjelasan output:

●​ Series dari list: Indeks default adalah integer mulai dari 0, 1, 2.​

●​ Series dari array: Sama, indeks default 0, 1, 2. Tipe data float64 sesuai isi array.​

●​ Series dari dictionary: Label indeks ditentukan oleh key dictionary ("a", "b", "c").​

11.2.2 Atribut dan Metode Series

Series memiliki berbagai atribut dan metode, seperti index, values, dtype, head(),
describe(), dsb.

print("Index:", series_dict.index)​
print("Values:", series_dict.values)​
print("Dtype:", series_dict.dtype)

Output:

Index: Index(['a', 'b', 'c'], dtype='object')

Values: [100 200 300]

Dtype: int64

Penjelasan:

●​ series_dict.index menampilkan objek Index dengan label ['a', 'b', 'c'].​

●​ series_dict.values adalah array NumPy [100, 200, 300].​

Series bisa diakses mirip array NumPy atau list, tetapi kita dapat memanfaatkan label
indeksnya juga.

11.3 DataFrame
DataFrame adalah struktur dua dimensi, mirip tabel, dengan label baris (index) dan label
kolom (columns). Inilah objek yang paling sering digunakan dalam analisis data dengan
Pandas.

11.3.1 Membuat DataFrame (Dari Dictionary, CSV, Excel, SQL, dll.)

Dari Dictionary: Key menjadi nama kolom, value berupa list/array akan menjadi data
kolom tersebut.

data = {​
"Nama": ["Andi", "Budi", "Citra"],​
"Usia": [25, 30, 22],​
"Kota": ["Jakarta", "Bandung", "Surabaya"]​
}​
​
df = [Link](data)​
print("DataFrame dari dictionary:")​
print(df)

Output:

DataFrame dari dictionary:

Nama Usia Kota

0 Andi 25 Jakarta

1 Budi 30 Bandung

2 Citra 22 Surabaya

Penjelasan output:

●​ Terdapat 3 baris (indeks 0, 1, 2) dan 3 kolom (Nama, Usia, Kota).​

●​ DataFrame ini terbentuk dari dict {"Nama": [...], "Usia": [...],

"Kota": [...]}.​

Dari CSV: Menggunakan pd.read_csv("nama_file.csv").

# df_csv = pd.read_csv("[Link]")​
# print(df_csv.head())
Jika kita memiliki file [Link], baris di atas akan membaca isi file tersebut ke dalam
DataFrame df_csv. head() menampilkan 5 baris pertama untuk inspeksi awal.

Dari Excel: Menggunakan pd.read_excel("nama_file.xlsx").

df_excel = pd.read_excel("[Link]", sheet_name="Sheet1")​

print(df_excel.head())

Dari SQL: Kita dapat memakai pd.read_sql(query, connection) bila kita terkoneksi
ke database. Contohnya:

import sqlite3​
conn = [Link]("[Link]")​
df_sql = pd.read_sql("SELECT * FROM table_name", conn)

11.3.2 Akses Baris dan Kolom (Indexing, loc, iloc)

●​ df["Nama_Kolom"] atau df.Nama_Kolom ( jika namanya tanpa spasi) untuk akses

kolom.​

●​ loc[] akses berdasarkan label index dan nama kolom.​

●​ iloc[] akses berdasarkan posisi integer (mirip indexing NumPy).​

Contoh script (akses kolom dan baris):

print("Kolom 'Nama':")​
print(df["Nama"])​
​
print("\nMenggunakan [Link]:")​
print([Link])​
​
print("\nAkses baris dengan loc (label):")​
print([Link][1]) # baris dengan indeks label 1​
​
print("\nAkses baris dengan iloc (posisi integer):")​
print([Link][2]) # baris ke-2 (urut 0-based)

Output:
Kolom 'Nama':

0 Andi

1 Budi

2 Citra

Name: Nama, dtype: object

Menggunakan [Link]:

0 Andi

1 Budi

2 Citra

Name: Nama, dtype: object

Akses baris dengan loc (label):

Nama Budi

Usia 30

Kota Bandung

Name: 1, dtype: object

Akses baris dengan iloc (posisi integer):

Nama Citra

Usia 22

Kota Surabaya

Name: 2, dtype: object

Penjelasan output:

●​ df["Nama"] menampilkan Series kolom Nama.​

●​ [Link] melakukan hal yang sama, tapi hanya berfungsi jika nama kolom tidak
mengandung spasi atau karakter khusus.​

●​ [Link][1] menampilkan baris dengan index=1 (Andi=0, Budi=1, Citra=2).​

●​ [Link][2] menampilkan baris secara positional, yakni baris ketiga (posisi 2).

11.3.3 Menambah/Menghapus Kolom dan Baris

Pandas memudahkan kita menambah kolom baru dengan assignment langsung. Kita juga
bisa menghapus kolom/baris dengan drop().

df["Gender"] = ["M", "M", "F"] # menambah kolom baru​

print("Setelah menambah kolom 'Gender':")​
print(df)​
​
df = [Link]("Usia", axis=1) # menghapus kolom 'Usia'​
print("\nSetelah menghapus kolom 'Usia':")​
print(df)​
​
df = [Link](2, axis=0) # menghapus baris dengan indeks 2​
print("\nSetelah menghapus baris dengan indeks 2:")​
print(df)

Output:

Setelah menambah kolom 'Gender':

Nama Usia Kota Gender

0 Andi 25 Jakarta M

1 Budi 30 Bandung M

2 Citra 22 Surabaya F

Setelah menghapus kolom 'Usia':

 Nama Kota Gender

0 Andi Jakarta M

1 Budi Bandung M

2 Citra Surabaya F

Setelah menghapus baris dengan indeks 2:

Nama Kota Gender

0 Andi Jakarta M

1 Budi Bandung M

Penjelasan output:

●​ df["Gender"] = ... menambahkan kolom “Gender”.​

●​ [Link]("Usia", axis=1) menghapus kolom “Usia” dari DataFrame. axis=1

menandakan kolom.​

●​ [Link](2, axis=0) menghapus baris dengan indeks 2 (Citra). axis=0

menandakan baris.

11.3.4 Grouping (groupby())

groupby() memungkinkan kita mengelompokkan baris berdasarkan satu atau beberapa

kolom, lalu menerapkan fungsi agregasi seperti mean(), sum(), count(), dll. Ini berguna
untuk analisis data yang butuh ringkasan per grup.

data_group = {​
"Departemen": ["IT", "IT", "HR", "HR", "HR", "Finance", "Finance"],​
"Nama": ["Andi", "Budi", "Citra", "Dewi", "Eka", "Fajar", "Gita"],​
"Gaji": [7, 8, 6, 6, 7, 8, 9]​
}​
df_group = [Link](data_group)​
​
# Mengelompokkan berdasarkan Departemen dan menghitung rata-rata gaji​
df_grouped = df_group.groupby("Departemen")["Gaji"].mean()​
print(df_group)​
print("\nRata-rata Gaji per Departemen:")​
print(df_grouped)
Output:

Departemen Nama Gaji

0 IT Andi 7

1 IT Budi 8

2 HR Citra 6

3 HR Dewi 6

4 HR Eka 7

5 Finance Fajar 8

6 Finance Gita 9

Rata-rata Gaji per Departemen:

Departemen

Finance 8.5

HR 6.3

IT 7.5

Name: Gaji, dtype: float64

Penjelasan output:

●​ DataFrame df_group terdiri dari 3 departemen: IT, HR, Finance. Masing-masing

memiliki beberapa karyawan dengan gaji tertentu.​

●​ df_group.groupby("Departemen")["Gaji"].mean() mengelompokkan
baris berdasarkan kolom “Departemen”, lalu mengambil kolom “Gaji” dan
menghitung mean untuk setiap grup.​

●​ Hasilnya Finance memiliki rata-rata gaji 8.5, HR 6.3, IT 7.5.​

11.3.5 Merge, Join, dan Concat DataFrame

Penggabungan DataFrame menjadi satu sering dibutuhkan. Misalnya, data karyawan di satu
tabel dan data gaji di tabel lain. Dengan Pandas, kita dapat melakukan:

●​ [Link]() untuk menggabungkan 2 DataFrame berdasarkan satu atau beberapa

kolom kunci.​

●​ [Link]() untuk menumpuk DataFrame secara vertikal (baris) atau horizontal

(kolom).​

●​ [Link]() untuk join berdasar index (atau col tertentu) antara 2 DataFrame.​

Contoh script (merge):

df_left = [Link]({​
"key": [1, 2, 3],​
"Nama": ["Andi", "Budi", "Citra"]​
})​
​
df_right = [Link]({​
"key": [2, 3, 4],​
"Kota": ["Bandung", "Surabaya", "Medan"]​
})​
​
merged = [Link](df_left, df_right, on="key", how="inner")​
print("df_left:")​
print(df_left)​
print("\ndf_right:")​
print(df_right)​
print("\nHasil merge (inner):")​
print(merged)

Output:

df_left:

key Nama

0 1 Andi

1 2 Budi

2 3 Citra
df_right:

key Kota

0 2 Bandung

1 3 Surabaya

2 4 Medan

Hasil merge (inner):

key Nama Kota

0 2 Budi Bandung

1 3 Citra Surabaya

Penjelasan output:

●​ df_left berisi baris key 1, 2, 3. df_right berisi baris key 2, 3, 4.​

●​ [Link](df_left, df_right, on="key", how="inner") mencari baris

yang sama “key”-nya di kedua DataFrame, yakni key=2 dan key=3. Key=1 hanya ada
di df_left, key=4 hanya di df_right, keduanya tidak muncul di hasil “inner” merge.​

●​ Kolom “Nama” dan “Kota” bergabung berdasarkan key yang sama.

11.4 Pembersihan dan Manipulasi Data

Sebagian besar waktu dalam data science dihabiskan untuk membersihkan dan menata
data. Pandas punya fungsi bawaan seperti dropna(), fillna(), konversi tipe, dan
sebagainya.

11.4.1 Menangani Data Hilang (dropna(), fillna())

data_missing = {​
"A": [1, None, 3, 4],​
"B": [None, 2, None, 4]​
}​
df_missing = [Link](data_missing)​
print("Data dengan missing values:")​
print(df_missing)​
​
df_drop = df_missing.dropna() # menghapus baris yang memiliki NaN​
print("\nHapus baris yang memiliki NaN:")​
print(df_drop)​
​
df_fill = df_missing.fillna(0) # mengganti NaN dengan 0​
print("\nGanti NaN dengan 0:")​
print(df_fill)

Output:

Data dengan missing values:

A B

0 1.0 NaN

1 NaN 2.0

2 3.0 NaN

3 4.0 4.0

Hapus baris yang memiliki NaN:

A B

3 4.0 4.0

Ganti NaN dengan 0:

A B

0 1.0 0.0

1 0.0 2.0

2 3.0 0.0
3 4.0 4.0

Penjelasan output:

●​ df_missing memiliki missing values (None/NaN) di beberapa baris.​

●​ dropna() menghapus baris yang mengandung NaN, menyisakan hanya baris 3

(4.0, 4.0).​

●​ fillna(0) mengganti semua NaN dengan 0.

11.4.2 Deteksi dan Perbaikan Outlier (Singkat)

Outlier dapat dideteksi melalui analisis statistik (misalnya z-score) atau visualisasi (misalnya
boxplot). Sebagai contoh singkat, kita bisa memfilter data yang berada di luar rentang
tertentu.

data_outlier = {​
"Nilai": [50, 52, 1000, 55, 58, 60]​
}​
df_outlier = [Link](data_outlier)​
​
# Misal kita anggap data valid jika 0 < Nilai < 100​
df_no_outlier = df_outlier[(df_outlier["Nilai"] > 0) &
(df_outlier["Nilai"] < 100)]​
print("Data asli:")​
print(df_outlier)​
print("\nData tanpa outlier:")​
print(df_no_outlier)

Output:

Data asli:

Nilai

0 50

1 52

2 1000

3 55
4 58

5 60

Data tanpa outlier:

Nilai

0 50

1 52

3 55

4 58

5 60

Penjelasan:

●​ Kita membuat filter (df_outlier["Nilai"] > 0) & (df_outlier["Nilai"]

< 100), sehingga nilai 1000 dianggap outlier dan dihilangkan.

11.4.3 Konversi Tipe Data, Memformat Tanggal

Jika kolom data berisi string yang merepresentasikan tanggal, kita dapat mengkonversinya
menjadi tipe datetime agar lebih mudah diolah.

date_data = {​
"Tanggal": ["2023-01-01", "2023/02/15", "01-Mar-2023"]​
}​
df_date = [Link](date_data)​
df_date["Tanggal"] = pd.to_datetime(df_date["Tanggal"])​
print(df_date)​
print(df_date.dtypes)

Output:

Tanggal

0 2023-01-01

1 2023-02-15
2 2023-03-01

Tanggal datetime64[ns]

dtype: object

Penjelasan output:

●​ pd.to_datetime() secara otomatis mengenali format tanggal yang berbeda

("2023-01-01", "2023/02/15", "01-Mar-2023") dan mengonversinya menjadi
datetime64[ns].​

●​ Setelah dikonversi, kita bisa dengan mudah melakukan filtering berdasarkan waktu,
menghitung selisih hari, dsb.​

11.5 Metode Statistik dan Analisis

11.5.1 Descriptive Statistics (describe())

[Link]() memberikan ringkasan statistik cepat untuk kolom numerik: count,

mean, std, min, quartiles, max.

data_stats = {​
"Kolom1": [10, 20, 30, 40, 50],​
"Kolom2": [5, 7, 9, 4, 2]​
}​
df_stats = [Link](data_stats)​
print(df_stats)​
print("\nRingkasan statistik:")​
print(df_stats.describe())

Output:

Kolom1 Kolom2

0 10 5

1 20 7

2 30 9
3 40 4

4 50 2

Ringkasan statistik:

Kolom1 Kolom2

count 5.000000 5.000000

mean 30.000000 5.400000

std 15.811388 2.301511

min 10.000000 2.000000

25% 20.000000 4.000000

50% 30.000000 5.000000

75% 40.000000 7.000000

max 50.000000 9.000000

Penjelasan output:

●​ Terdapat 5 baris data pada Kolom1 dan Kolom2.​

●​ Rata-rata (mean) Kolom1 = 30, Kolom2 = 5.4.​

●​ Standar deviasi (std) Kolom1 = 15.81, Kolom2 = 2.30.​

●​ Tersedia juga nilai minimal, 25th percentile, median (50%), 75th percentile, dan
maksimal.

11.5.2 Korelasi (corr())

[Link]() menghitung koefisien korelasi antar kolom numerik.

print("Korelasi antar kolom:")​

print(df_stats.corr())
Output:

Korelasi antar kolom:

Kolom1 Kolom2

Kolom1 1.000000 -0.543328

Kolom2 -0.543328 1.000000

Penjelasan:

●​ Kolom1 dan Kolom2 memiliki korelasi negatif sekitar -0.5433. Artinya, secara linear,
saat Kolom1 meningkat, Kolom2 cenderung menurun.

11.5.3 Agregasi (sum, mean, count)

Kita bisa melakukan agregasi di seluruh kolom atau per kolom tertentu.

print("Sum per kolom:")​

print(df_stats.sum())​
​
print("\nMean per kolom:")​
print(df_stats.mean())​
​
print("\nCount per kolom:")​
print(df_stats.count())

Output:

Sum per kolom:

Kolom1 150

Kolom2 27

dtype: int64

Mean per kolom:

Kolom1 30.0
Kolom2 5.4

dtype: float64

Count per kolom:

Kolom1 5

Kolom2 5

dtype: int64

Penjelasan output:

●​ sum() menambahkan seluruh nilai di Kolom1 dan Kolom2. Kolom1 total 150,
Kolom2 total 27.​

●​ mean() menghitung rata-rata Kolom1 = 30, Kolom2 = 5.4.​

●​ count() menghitung jumlah nilai non-null di masing-masing kolom. Terdapat 5

nilai di kedua kolom.
BAB 12 – VISUALISASI DATA
Visualisasi data sangat penting dalam data science karena memberikan cara intuitif untuk
memahami dan menjelaskan pola, tren, serta outlier dalam dataset. Python menyediakan
beberapa library populer untuk keperluan ini, di antaranya Matplotlib, Seaborn, dan Plotly
(serta beberapa library lain seperti Bokeh, Altair, dll.). Bab ini akan membahas penggunaan
Matplotlib dan Seaborn karena keduanya cukup umum digunakan di proyek data science.
Matplotlib adalah library dasar untuk plot di Python, sedangkan Seaborn dibangun di atas
Matplotlib dan menawarkan style default yang lebih menarik serta fungsi khusus untuk data
statistik.

12.1 Matplotlib
Matplotlib adalah library paling dasar yang hampir selalu menjadi fondasi bagi library
visualisasi lain di Python. Biasanya diimpor sebagai import [Link] as
plt.

12.1.1 Instalasi dan Import (import [Link] as plt)

Matplotlib sering kali sudah terinstal secara default di Anaconda Distribution. Jika belum,
kamu bisa menginstal dengan:

pip install matplotlib

Kemudian di script Python atau Jupyter Notebook:

import [Link] as plt

12.1.2 Plot Dasar (Line Plot, Scatter Plot, Bar Plot, Histogram)

Matplotlib sangat fleksibel. Kita dapat membuat berbagai plot dengan fungsi berbeda.
Berikut beberapa plot paling dasar:

Line Plot

Line plot umumnya digunakan untuk menampilkan tren atau hubungan yang
berkelanjutan.

import [Link] as plt​

​
x = [1, 2, 3, 4, 5]​
y = [2, 4, 6, 3, 5]​
​
 [Link](x, y, marker='o') # marker='o' memberi tanda lingkaran di tiap
titik​
[Link]("Contoh Line Plot")​
[Link]("Sumbu X")​
[Link]("Sumbu Y")​
[Link]()

Output:

Penjelasan output:

●​ [Link](x, y) menghasilkan garis yang menghubungkan titik (1,2), (2,4),

(3,6), (4,3), dan (5,5).​

●​ [Link]("Contoh Line Plot") memberi judul.​

●​ [Link]("Sumbu X") dan [Link]("Sumbu Y") memberi label pada

sumbu.​

●​ [Link]() menampilkan plot ke layar (atau inline di Jupyter Notebook).​

Scatter Plot
Scatter plot bagus untuk memperlihatkan hubungan antara dua variabel numerik, melihat
pola distribusi atau korelasi di antara mereka.

import [Link] as plt​

​
x = [1, 2, 3, 4, 5]​
y = [5, 3, 6, 2, 7]​
​
[Link](x, y, color='red')​
[Link]("Contoh Scatter Plot")​
[Link]("Variabel X")​
[Link]("Variabel Y")​
[Link]()

Output:

Penjelasan output:

●​ [Link](x, y, color='red') menampilkan titik-titik di lokasi (x_i,

y_i) dengan warna merah. Tidak ada garis penghubung seperti pada line plot.​

●​ Judul dan label sumbu sudah ditambahkan.​

Bar Plot

Bar plot berguna untuk menampilkan data kategorik (sering kali pada sumbu X) dan nilai
(pada sumbu Y).

import [Link] as plt​

​
kategori = ["A", "B", "C", "D"]​
nilai = [10, 15, 7, 12]​
​
[Link](kategori, nilai, color='green')​
[Link]("Contoh Bar Plot")​
[Link]("Kategori")​
[Link]("Nilai")​
[Link]()

Output:

Penjelasan output:

●​ [Link](kategori, nilai, color='green') membuat empat batang.

Masing-masing batang mewakili A=10, B=15, C=7, D=12.​

●​ Label sumbu dan judul disesuaikan.

Histogram

Histogram menampilkan distribusi frekuensi data numerik dengan membaginya ke dalam

bin (interval).

import [Link] as plt​

import numpy as np​
​
data = [Link](1000) # 1000 data acak terdistribusi normal​
[Link](data, bins=30, color='blue', edgecolor='black')​
[Link]("Contoh Histogram")​
[Link]("Nilai")​
[Link]("Frekuensi")​
[Link]()

Output:

Penjelasan output:

●​ [Link](1000) menghasilkan 1000 angka acak berdistribusi normal

(mean=0, std=1).​

●​ [Link](data, bins=30, ...) membagi data menjadi 30 interval, lalu

menghitung berapa banyak data yang jatuh ke setiap interval.​
 ●​ edgecolor='black' menambahkan garis hitam di tepi batang, sehingga
histogram lebih jelas.

12.1.3 Kustomisasi Plot (Label, Title, Legend, Grid)

Matplotlib mengizinkan beragam kustomisasi seperti menambahkan legend, menyesuaikan

warna, marker, garis, menambahkan grid, dsb.

import [Link] as plt​

​
x = [1, 2, 3, 4, 5]​
y1 = [2, 4, 6, 8, 10]​
y2 = [1, 3, 5, 7, 9]​
​
[Link](x, y1, label="Data 1", color="blue", linestyle="--",
marker="o")​
[Link](x, y2, label="Data 2", color="red", linestyle="-.", marker="s")​
​
[Link]("Kustomisasi Plot")​
[Link]("X")​
[Link]("Y")​
[Link](loc="upper left")​
[Link](True)​
[Link]()

Output:
Penjelasan output:

●​ label="Data 1" dan [Link](...) memunculkan legend di plot.​

●​ color="blue", linestyle="--", marker="o" mengubah gaya visual.​

●​ [Link](True) menampilkan garis bantu horizontal dan vertikal.

12.1.4 Multi Subplot

Kadang kita ingin menampilkan beberapa plot berdampingan. Kita bisa menggunakan
[Link]() atau [Link]().

import [Link] as plt​

​
fig, axes = [Link](nrows=1, ncols=2, figsize=(10,4))​
​
# Subplot kiri​
x = [1, 2, 3, 4, 5]​
y = [2, 4, 6, 3, 5]​
axes[0].plot(x, y, marker='o')​
axes[0].set_title("Line Plot")​
​
# Subplot kanan​
kategori = ["A", "B", "C", "D"]​
nilai = [10, 15, 7, 12]​
axes[1].bar(kategori, nilai, color='green')​
axes[1].set_title("Bar Plot")​
​
plt.tight_layout()​
[Link]()

Output:
Penjelasan output:

●​ fig, axes = [Link](nrows=1, ncols=2, figsize=(10,4))

membuat satu baris subplot dengan 2 kolom. axes adalah array [axes_0,
axes_1].​

●​ axes[0] merujuk ke subplot pertama, axes[1] ke subplot kedua.​

●​ plt.tight_layout() memastikan agar layout tidak saling tumpang tindih.

12.2 Seaborn
Seaborn menawarkan visualisasi statistik dan styling yang lebih menarik secara default.
Seaborn diimpor sebagai import seaborn as sns. Ia mengandalkan Matplotlib di
belakang layar.

12.2.1 Instalasi dan Import (import seaborn as sns)

pip install seaborn

Di dalam Python/Jupyter:

import seaborn as sns​

import [Link] as plt

12.2.2 Plotting Tingkat Lanjut (Boxplot, Violinplot, Pairplot, Heatmap)

Seaborn menyediakan fungsi-fungsi yang memudahkan kita mem-plot data kategorik,

distribusi, serta hubungan antar variabel.

Boxplot
Boxplot (box and whisker plot) menampilkan ringkasan statistika (median, kuartil, outlier).
Bagus untuk membandingkan distribusi beberapa kategori.

import seaborn as sns​

import [Link] as plt​
​
tips = sns.load_dataset("tips") # dataset contoh bawaan seaborn​
[Link](x="day", y="total_bill", data=tips)​
[Link]("Boxplot total_bill berdasarkan day")​
[Link]()

Output:

Penjelasan output:

●​ tips adalah dataset bawaan Seaborn yang berisi data tagihan restoran.​

●​ [Link](x="day", y="total_bill", data=tips) menempatkan “day”

di sumbu X dan “total_bill” di sumbu Y. Seaborn secara otomatis menghitung
median dan kuartil.

Violinplot
Violinplot mirip boxplot, tetapi juga menambahkan estimasi distribusi kernel (menyerupai
bentuk biola).

[Link](x="day", y="total_bill", data=tips, palette="muted")​

[Link]("Violinplot total_bill berdasarkan day")​
[Link]()

Output:

Pairplot

Pairplot menampilkan pairwise relationship antar kolom numerik di dataset, termasuk

scatter plot antar kolom dan histogram/ KDE di diagonal. Sangat cocok untuk eksplorasi
awal dataset.

[Link](tips, vars=["total_bill", "tip", "size"], hue="day")​

[Link]()

Output:
Penjelasan output:

●​ vars=["total_bill", "tip", "size"] menandakan tiga kolom numerik

yang ingin kita plot.​

●​ hue="day" mewarnai setiap titik berdasarkan hari, memudahkan kita melihat

perbedaan tiap kategori hari.​

Heatmap

Heatmap sering kali digunakan untuk menampilkan korelasi antar variabel atau matriks
confusi (confusion matrix) di machine learning.

import numpy as np​

​
# Select only numeric columns for correlation calculation​
 numeric_tips = tips.select_dtypes(include=[Link])​
​
corr = numeric_tips.corr()​
[Link](corr, annot=True, cmap="Blues")​
[Link]("Heatmap Korelasi")​
[Link]()

Output:

Penjelasan output:

●​ [Link]() menghitung korelasi antar kolom numerik.​

●​ [Link](corr, annot=True, cmap="Blues") menampilkan matriks

korelasi dalam bentuk heatmap, menuliskan nilai korelasi di setiap sel
(annot=True), dan menggunakan skema warna biru ("Blues").

12.2.3 Palet Warna dan Gaya Visual

Seaborn memiliki tema default yang menarik, tetapi kita dapat mengubah palet warna atau
style:

import seaborn as sns​

​
# Mengubah tema​
sns.set_style("whitegrid")​
 sns.set_palette("pastel")​
​
# Plot misal barplot​
[Link](x="day", y="total_bill", data=tips)​
[Link]("Barplot dengan Style Whitegrid & Palet Pastel")​
[Link]()

Output:

Penjelasan output:

●​ sns.set_style("whitegrid") menambahkan grid halus di latar belakang

dengan background berwarna putih.​

●​ sns.set_palette("pastel") memilih rangkaian warna pastel.​

●​ Seaborn menambahkan error bar default (confidence interval) di barplot.

12.3 Plotly/Altair (Opsional)

Plotly dan Altair adalah library visualisasi interaktif. Jika kita butuh plot yang bisa di-zoom,
di-hover, atau disorot, kita dapat menggunakan Plotly. Altair juga populer karena
pendekatan deklaratif.

Contoh Sederhana Plot Interaktif (Plotly)

pip install plotly

import [Link] as px​

import pandas as pd​
​
df_plotly = [Link]() # dataset bawaan plotly​
fig = [Link](​
df_plotly,​
x="sepal_width",​
y="sepal_length",​
color="species",​
title="Plotly Scatter Iris"​
)​
[Link]()

Output:

Penjelasan output:

●​ [Link]() memuat dataset Iris (150 baris data, 4 kolom dimensi sepal/petal,
1 kolom species).​

●​ [Link](...) membuat grafik interaktif. Hover pada titik menampilkan nilai

detail.​
BAB 13 – DASAR-DASAR STATISTIKA
DAN PROBABILITAS UNTUK DATA
SCIENCE
Data science tidak hanya soal pemrograman, tetapi juga tentang pemahaman konsep
statistika dan probabilitas. Konsep ini membantu kita memahami cara menafsirkan data,
mengambil keputusan, dan membangun model machine learning secara benar. Bab ini
akan membahas fondasi statistika deskriptif dan konsep probabilitas yang umum dipakai
dalam data science.

13.1 Statistika Deskriptif

Statistika deskriptif berfokus pada ringkasan dan penyajian data, biasanya meliputi ukuran
pemusatan (mean, median, mode) dan ukuran penyebaran (variance, standard deviation,
range, quartiles). Tujuannya agar kita bisa menangkap karakteristik data secara sekilas.

13.1.1 Ukuran Pusat (Mean, Median, Mode)

1.​ Mean (Rata-rata): Jumlah semua nilai dibagi jumlah data.​

2.​ Median (Nilai tengah): Nilai yang membagi data menjadi dua bagian sama besar
setelah data diurutkan.​

3.​ Mode (Nilai terbanyak): Nilai yang paling sering muncul.​

Contoh script (Menghitung mean, median, mode dengan Python):

import numpy as np​

from statistics import mode​
​
data = [1, 2, 2, 3, 4, 4, 4, 5, 6]​
​
mean_val = [Link](data)​
median_val = [Link](data)​
mode_val = mode(data)​
​
print("Data:", data)​
print("Mean:", mean_val)​
print("Median:", median_val)​
print("Mode:", mode_val)
Output:

Data: [1, 2, 2, 3, 4, 4, 4, 5, 6]

Mean: 3.4444444444444446

Median: 4.0

Mode: 4

Penjelasan output:

●​ Mean adalah 3.444..., yaitu (1+2+2+3+4+4+4+5+6)/9 = 31/9.​

●​ Median adalah 4 karena setelah diurutkan, data [1, 2, 2, 3, 4, 4, 4, 5, 6]

memiliki posisi tengah di index ke-4 (0-based), yang nilainya 4.​

●​ Mode adalah 4 karena 4 muncul paling sering (tiga kali).

13.1.2 Ukuran Penyebaran (Variance, Standard Deviation, Range)

Ukuran penyebaran menggambarkan seberapa “tersebar” data kita. Variance dan standard
deviation cukup populer. Semakin besar nilainya, berarti data semakin bervariasi.

Contoh script (Var, Std, Range):

import numpy as np​

​
data = [10, 12, 15, 20, 25]​
variance_val = [Link](data)​
std_val = [Link](data)​
range_val = [Link](data) - [Link](data)​
​
print("Variance:", variance_val)​
print("Standard Deviation:", std_val)​
print("Range:", range_val)

Output:

Variance: 30.16

Standard Deviation: 5.494318

Range: 15

Nilai di atas mungkin sedikit berbeda tergantung pembulatan.

Penjelasan output:

●​ [Link](data) menghitung varians sample/populasi (defaultnya interpretable

sebagai populasi di NumPy, kecuali ditentukan ddof=1 untuk sample).​

●​ [Link](data) adalah akar varians, 5.4943....​

●​ range_val = 25 - 10 = 15.

13.2 Probabilitas
Probabilitas membahas “peluang suatu kejadian terjadi.” Dalam data science, konsep
probabilitas membantu kita menangani ketidakpastian, mengambil sampling, serta
membangun model statistika.

13.2.1 Konsep Dasar Probabilitas

Probabilitas sebuah kejadian A adalah perkiraan seberapa sering A akan terjadi jika kita
melakukan percobaan berkali-kali, yakni P(A)=Jumlah kejadian AJumlah
percobaan\mathrm{P}(A) = \frac{\text{Jumlah kejadian A}}{\text{Jumlah
percobaan}}P(A)=Jumlah percobaanJumlah kejadian A​.

Peluang dapat digeneralisasi untuk berbagai kejadian dan peristiwa, misalnya:

●​ Peluang gabungan dua kejadian (A dan B).​

●​ Peluang bersyarat P(A∣B)\mathrm{P}(A|B)P(A∣B).​

●​ Peluang saling lepas, dsb.

Dalam Python, kita sering mengaplikasikan konsep probabilitas ketika bekerja dengan
random sampling (misalnya [Link]) atau ketika kita membangun model machine
learning yang melibatkan distribusi probabilitas tertentu.

13.2.2 Distribusi Umum (Normal, Uniform, Binomial, Poisson)

Distribusi probabilitas menggambarkan bagaimana nilai acak didistribusikan. Beberapa

distribusi yang sering dipakai di data science:
 1.​ Normal (Gaussian) Distribution: Distribusi lonceng, ditentukan oleh mean (μ) dan
standard deviation (σ).​

2.​ Uniform Distribution: Semua nilai dalam interval [a, b] memiliki kemungkinan
sama.​

3.​ Binomial Distribution: Memodelkan jumlah “sukses” dalam sejumlah percobaan

Bernoulli yang independen.​

4.​ Poisson Distribution: Memodelkan banyaknya kejadian dalam interval waktu/ruang

tertentu dengan laju kejadian λ (lambda).​

Contoh script (Membuat data acak dari distribusi berbeda):

import numpy as np​

import [Link] as plt​
​
# Normal Distribution (mean=0, std=1)​
data_normal = [Link](1000)​
​
# Uniform Distribution (interval 0 hingga 1)​
data_uniform = [Link](1000)​
​
# Binomial Distribution (n=10, p=0.5)​
data_binomial = [Link](n=10, p=0.5, size=1000)​
​
# Plot histogram keempatnya​
fig, axes = [Link](2, 2, figsize=(10, 6))​
​
axes[0,0].hist(data_normal, bins=30, color='blue')​
axes[0,0].set_title("Normal (mean=0, std=1)")​
​
axes[0,1].hist(data_uniform, bins=30, color='green')​
axes[0,1].set_title("Uniform (0-1)")​
​
axes[1,0].hist(data_binomial, bins=range(0,12), color='red',
edgecolor='black')​
axes[1,0].set_title("Binomial (n=10, p=0.5)")​
​
# Kita contohkan Poisson (lambda=3)​
data_poisson = [Link](lam=3, size=1000)​
axes[1,1].hist(data_poisson, bins=range(0,12), color='orange',
edgecolor='black')​
axes[1,1].set_title("Poisson (lambda=3)")​
 ​
plt.tight_layout()​
[Link]()

Output:

Penjelasan output:

Empat histogram di satu figure (2x2), masing-masing menampilkan distribusi:

●​ Normal: berbentuk lonceng.​

●​ Uniform: lebih merata di sumbu X.​

●​ Binomial (n=10, p=0.5): cenderung berbentuk distribusi sekitar 5.​

●​ Poisson (lambda=3): puncak sekitar 2-4, menurun ke kanan.

●​ data_normal di-generate dengan [Link](1000), yang berarti
mean=0 dan std=1.​

●​ data_uniform di-generate dengan [Link](1000), dalam interval [0,

1).​
 ●​ data_binomial memodelkan 1000 percobaan, tiap percobaan memiliki 10 ulangan
dengan p=0.5. Kita lihat di histogram, rata-rata jumlah “sukses” sekitar 5.​

●​ data_poisson memodelkan laju kejadian 3, sehingga histogram paling banyak di

sekitar 2-3-4 kejadian.

13.3 Sampling dan Interval Kepercayaan (Singkat)

Dalam data science, kita sering melakukan sampling karena data bisa berukuran terlalu
besar, atau kita ingin menguji model pada subset data. Kita juga sering menggunakan
interval kepercayaan (confidence interval) untuk mengukur ketidakpastian estimasi.

13.3.1 Sampling

Sampling berarti memilih subset data untuk mewakili populasi. Python menyediakan fungsi
sample() pada Pandas DataFrame, atau kita bisa memakai [Link] untuk
array.

import pandas as pd​

​
df_large = [Link]({"Nilai": range(1, 101)}) # Contoh data 100
baris​
df_sample = df_large.sample(n=10, random_state=42) # Ambil 10 baris​
print("Hasil sampling 10 baris acak:")​
print(df_sample)

Output (Contoh acak):

Menampilkan 10 baris acak dari total 100 baris. Contoh:

Hasil sampling 10 baris acak:

Nilai

83 84

53 54

70 71

45 46

44 45
39 40

22 23

80 81

10 11

0 1

Penjelasan output:

●​ df_large berisi kolom “Nilai” dari 1 sampai 100.​

●​ df_large.sample(n=10, random_state=42) mengambil 10 baris secara acak,

tetapi random_state=42 membuat pengacakan bersifat deterministik (akan sama
setiap kali skrip dijalankan).

13.3.2 Confidence Interval

Confidence interval, misalnya 95% CI, adalah rentang nilai di mana kita cukup percaya
(95%) bahwa parameter populasi sesungguhnya (misal mean) berada dalam rentang
tersebut. Perhitungannya biasanya menggunakan mean ± z ×\times× SE (Standard Error)
untuk data berdistribusi normal, atau pendekatan lain tergantung distribusi dan jumlah
data.

Contoh sederhana (metode frequentis dengan asumsi normal):

import numpy as np​

from scipy import stats​
​
data_ci = [Link](30) + 5 # mean sekitar 5, std 1, n=30​
mean_ci = [Link](data_ci)​
std_ci = [Link](data_ci, ddof=1) # sample standard deviation​
n = len(data_ci)​
​
confidence = 0.95​
alpha = 1 - confidence​
z_critical = [Link](1 - alpha/2) # z-score untuk 95% confidence​
​
se = std_ci / [Link](n) # standard error​
margin_of_error = z_critical * se​
lower_bound = mean_ci - margin_of_error​
upper_bound = mean_ci + margin_of_error​
​
print(f"Mean sampel: {mean_ci:.2f}")​
 print(f"95% CI: [{lower_bound:.2f}, {upper_bound:.2f}]")

Output (Contoh):

Mean sampel: 4.92

95% CI: [4.56, 5.28]

Penjelasan output:

●​ data_ci adalah data acak berdistribusi normal, berukuran 30, dengan mean sekitar
5.​

●​ mean_ci adalah rata-rata sampel, misal 4.92.​

●​ std_ci adalah standar deviasi sampel, menghitung ragam sampel (ddof=1).​

●​ [Link](1 - alpha/2) mencari z-score untuk 95% confidence (sekitar

1.96).​

●​ Interval kepercayaan = mean_ci ± (z_critical * se).​

●​ Hasilnya menunjukkan kita 95% percaya bahwa mean populasi (sesungguhnya)

berada dalam rentang [4.56, 5.28] (angka bergantung pada data acak yang
dihasilkan).

Dengan memahami statistika deskriptif (mean, median, mode, variance, std, dsb.),
probabilitas (konsep distribusi, sampling), dan confidence interval, kita memiliki landasan
kuat untuk menginterpretasi data secara benar. Konsep ini akan sering muncul saat kita
menerapkan machine learning dan mengevaluasi model.

Pada bab-bab selanjutnya, kita akan memanfaatkan pengetahuan ini untuk melangkah ke
modeling dan evaluasi model di data science, termasuk pembahasan dasar machine
learning yang sering memanfaatkan konsep probabilitas dan statistika untuk membuat
prediksi maupun klasifikasi.
BAB 14 – PENGENALAN MACHINE
LEARNING DI PYTHON
Machine learning (ML) adalah cabang kecerdasan buatan yang berfokus pada
pengembangan algoritma yang belajar dari data dan membuat prediksi atau keputusan
tanpa diprogram secara eksplisit untuk setiap kemungkinan. Python menjadi salah satu
bahasa yang sangat populer untuk ML karena ekosistem library-nya yang kaya, seperti
scikit-learn, TensorFlow, PyTorch, dan lain-lain. Pada bab ini, kita akan membahas
dasar-dasar ML, terutama penerapan supervised learning dan unsupervised learning
menggunakan scikit-learn, agar kamu dapat memahami bagaimana memulai membangun
model prediksi dan klasterisasi sederhana.

14.1 Konsep Dasar Machine Learning

ML dibagi menjadi beberapa kategori:

1.​ Supervised Learning: Terdapat data input (fitur) dan data output (label/target) yang
sudah diketahui. Tujuan model adalah mempelajari hubungan antara input dan
output, sehingga bisa memprediksi output untuk data baru. Contohnya adalah
regression (output kontinu) dan classification (output kategori).​

2.​ Unsupervised Learning: Hanya terdapat data input tanpa label/target yang
diketahui. Tujuan model adalah menemukan pola tersembunyi atau struktur dalam
data, seperti pengelompokan (clustering) atau reduksi dimensi (dimensionality
reduction).

Machine learning pada dasarnya mengikuti alur:

1.​ Mempersiapkan data (membersihkan, memisahkan fitur dan label, mengatasi data
hilang, dsb.).​

2.​ Memilih model (misal Linear Regression, Decision Tree, K-Means, dsb.).​

3.​ Melakukan training (model fit data).​

4.​ Evaluasi model (cek performa dengan metrik tertentu).​

5.​ Prediksi (menggunakan model terlatih pada data baru).

14.2 Scikit-Learn
Scikit-learn (sklearn) adalah library Python paling populer untuk ML tradisional (regresi,
klasifikasi, klasterisasi, dsb.). Biasanya diimpor sebagai:

import sklearn

atau secara spesifik:

from sklearn.model_selection import train_test_split​

from sklearn.linear_model import LinearRegression​
# dan seterusnya

14.2.1 Instalasi dan Import

Jika scikit-learn belum terinstal, kita dapat memasangnya dengan pip install
scikit-learn atau menggunakan conda conda install scikit-learn pada
environment Anaconda. Setelah itu, kamu dapat mengimpor modul-modul yang
diperlukan.

14.2.2 Alur Dasar fit, predict, dan evaluate

Setiap model di scikit-learn memiliki antarmuka yang seragam:

1.​ Membuat objek model, misal model = LinearRegression().​

2.​ Memanggil [Link](X, y) untuk melatih model dengan data fitur X dan target
y.​

3.​ Memanggil [Link](X_new) untuk membuat prediksi.​

Misalnya:

import numpy as np​

from sklearn.linear_model import LinearRegression​
​
# Contoh data sederhana​
X = [Link]([[1], [2], [3], [4], [5]]) # Fitur (harus 2D array)​
y = [Link]([2, 4, 5, 4, 5]) # Target (1D array)​
​
model = LinearRegression()​
[Link](X, y)​
​
X_new = [Link]([[6], [7]]) # Prediksi di input baru​
predictions = [Link](X_new)​
 ​
print("Koefisien (m):", model.coef_)​
print("Intercept (b):", model.intercept_)​
print("Prediksi untuk X_new:", predictions)

Output (contoh):

Koefisien (m): [0.6]

Intercept (b): 2.2

Prediksi untuk X_new: [5.8 6.4]

Penjelasan output:

●​ Koefisien (m) adalah slope dari garis regresi, di sini sekitar 0.6.​

●​ Intercept (b) adalah titik potong dengan sumbu Y, di sini sekitar 2.2.​

●​ Model memperkirakan bahwa bila X=6, maka Y ~ 5.8, dan bila X=7, maka Y ~ 6.4.

14.2.3 Train-Test Split

Dalam ML, kita perlu mengevaluasi performa model pada data yang tidak digunakan saat
training. Itulah mengapa kita memisahkan data menjadi train set dan test set.

from sklearn.model_selection import train_test_split​

from sklearn.linear_model import LinearRegression​
import numpy as np​
​
X = [Link]([[1], [2], [3], [4], [5], [6], [7], [8]])​
y = [Link]([2, 4, 5, 4, 5, 6, 7, 8])​
​
# Memisahkan data (80% training, 20% testing)​
X_train, X_test, y_train, y_test = train_test_split(​
X, y, test_size=0.2, random_state=42​
)​
​
model = LinearRegression()​
[Link](X_train, y_train)​
​
score = [Link](X_test, y_test) # R^2 score​
print("R^2 test score:", score)
Output (contoh):

R^2 test score: 0.96

Penjelasan output:

●​ train_test_split(...) memecah data menjadi X_train, X_test,

y_train, y_test. Sebanyak 20% data (yakni 2 baris) untuk testing, sisanya untuk
training.​

●​ [Link](X_train, y_train) melatih model pada train set.​

●​ [Link](X_test, y_test) menghitung koefisien determinasi (R^2) pada

test set, misal 0.96 yang berarti model menjelaskan ~96% variasi data pada test set.

14.3 Model Dasar Supervised Learning

Supervised learning terbagi dua jenis utama: regresi (output kontinu) dan klasifikasi
(output kategori). Berikut beberapa algoritma populer yang didukung scikit-learn.

14.3.1 Regresi Linear (Simple dan Multiple)

Regresi linear bertujuan memodelkan hubungan linear antara fitur dan target. Simple linear
regression memiliki satu fitur, sedangkan multiple linear regression memiliki beberapa fitur.

Contoh script (Multiple Linear Regression):

import numpy as np​

import pandas as pd​
from sklearn.linear_model import LinearRegression​
​
# Misal data (bisa dari file CSV, di sini kita pakai data buatan)​
data = {​
"X1": [1, 2, 3, 4, 5],​
"X2": [2, 1, 4, 3, 5],​
"Y": [2, 4, 5, 6, 8]​
}​
df = [Link](data)​
​
X = df[["X1", "X2"]] # dua fitur​
y = df["Y"] # target​
​
model = LinearRegression()​
 [Link](X, y)​
​
print("Koefisien:", model.coef_)​
print("Intercept:", model.intercept_)​
​
# Prediksi​
X_new = [Link]([[2, 3], [5, 5]]) # contoh data baru​
pred = [Link](X_new)​
print("Prediksi:", pred)

Output (contoh):

Koefisien: [0.8 0.4]

Intercept: 0.9999999999999982

Prediksi: [4.2 7. ]

Penjelasan output:

●​ Koefisien: [0.8 0.4] menunjukkan untuk setiap kenaikan 1 unit di X1, Y naik
0.8, dan setiap kenaikan 1 unit di X2, Y naik 0.4 (dengan asumsi variabel lain
konstan).​

●​ Intercept: ~1.0 berarti saat X1=0 dan X2=0, Y diprediksi ~1.0.​

●​ Prediksi [4.2, 7.0] berarti untuk input (2,3), model memprediksi Y=4.2, dan
untuk (5,5), Y=7.0.

14.3.2 Klasifikasi (Logistic Regression, KNN, Decision Tree, Random Forest)

Klasifikasi berarti output adalah kategori diskrit, misalnya “spam” vs “not spam”, “lulus” vs
“tidak lulus,” dsb.

Contoh (Logistic Regression)

from sklearn.linear_model import LogisticRegression​

from sklearn.model_selection import train_test_split​
from [Link] import accuracy_score​
​
# Contoh data buatan (fitur X1, X2 -> label: 0/1)​
X = [[1,2],[2,2],[2,3],[3,2],[4,5],[5,6],[6,5],[7,8]]​
y = [0,0,0,0,1,1,1,1]​
​
 X_train, X_test, y_train, y_test = train_test_split(​
X, y, test_size=0.25, random_state=42​
)​
​
clf = LogisticRegression()​
[Link](X_train, y_train)​
y_pred = [Link](X_test)​
​
acc = accuracy_score(y_test, y_pred)​
print("Prediksi:", y_pred)​
print("Akurasi:", acc)

Output (contoh):

Prediksi: [0 1]

Akurasi: 1.0

Penjelasan output:

●​ Data X berisi 8 baris (masing-masing dua fitur), y adalah label biner (0 atau 1).​

●​ train_test_split(...) memisahkan data menjadi 75% training dan 25%

testing.​

●​ [Link](X_train, y_train) melatih logistic regression.​

●​ y_pred = [Link](X_test) menghasilkan prediksi label. Jika model

menebak dengan benar untuk seluruh data test, akurasinya 1.0 (100%).

Contoh (KNN – K Nearest Neighbors)

from [Link] import KNeighborsClassifier​

from [Link] import classification_report​
​
X = [[1,1], [2,2], [1,2], [2,1], [6,6], [7,7], [6,7], [7,6]]​
y = [0, 0, 0, 0, 1, 1, 1, 1] # 0 = cluster pertama, 1 = cluster kedua​
​
X_train, X_test, y_train, y_test = train_test_split(​
X, y, test_size=0.25, random_state=42​
)​
​
knn = KNeighborsClassifier(n_neighbors=3)​
[Link](X_train, y_train)​
 ​
y_pred = [Link](X_test)​
print("Prediksi:", y_pred)​
print("Laporan Klasifikasi:\n", classification_report(y_test, y_pred))

Output (contoh):

Prediksi: [0 1]

Laporan Klasifikasi:

precision recall f1-score support

0 1.00 1.00 1.00 1

1 1.00 1.00 1.00 1

accuracy 1.00 2

macro avg 1.00 1.00 1.00 2

weighted avg 1.00 1.00 1.00 2

Penjelasan output:

●​ Data X dibagi menjadi dua kelompok jelas: (1,1), (2,2), (1,2), (2,1) untuk label 0 dan
(6,6), (7,7), (6,7), (7,6) untuk label 1.​

●​ KNeighborsClassifier(n_neighbors=3) berarti kita menggunakan 3 tetangga

terdekat untuk memutuskan label.​

●​ Model memprediksi label test set dengan benar (akurasi 100%).

Decision Tree dan Random Forest

Cara penggunaannya mirip: kita impor class DecisionTreeClassifier atau

RandomForestClassifier, inisialisasi, lalu fit(X,y) dan predict(X_new). Hanya
algoritmanya yang berbeda di dalam.
14.4 Model Unsupervised Learning
Unsupervised learning tidak memiliki label, sehingga kita membiarkan algoritma
menemukan pola sendiri. Dua contoh umum: Clustering (K-Means) dan Dimensionality
Reduction (PCA).

14.4.1 Clustering (K-Means)

K-Means membagi data menjadi k cluster berdasarkan jarak. Kita tentukan k terlebih dulu.

import numpy as np​

from [Link] import KMeans​
​
# Contoh data 2D​
data = [Link]([[1,2],[1,3],[2,3],[6,7],[7,8],[8,8],[6,6],[7,6]])​
​
kmeans = KMeans(n_clusters=2, random_state=42)​
[Link](data)​
​
labels = kmeans.labels_​
centroids = kmeans.cluster_centers_​
​
print("Labels cluster:", labels)​
print("Centroids:", centroids)

Output (contoh):

Labels cluster: [1 1 1 0 0 0 0 0]

Centroids: [[7. 6.8 ]

[1.33333333 2.66666667]]

Penjelasan output:

●​ labels menunjukkan cluster mana setiap titik termasuk. Di sini, 0 mungkin

merepresentasikan cluster “atas” (titik sekitar [7,7]), dan 1 mewakili cluster “bawah”
(titik sekitar [1,2]).​

●​ centroids adalah titik tengah (rata-rata) dari tiap cluster.​

●​ Hasilnya menandakan data di sekitar (6,6) sampai (8,8) berada di cluster 0,

sementara (1,2), (1,3), (2,3) berada di cluster 1.​
14.4.2 Dimensionality Reduction (PCA)

Principal Component Analysis (PCA) menurunkan dimensi data sambil mempertahankan

variasi sebanyak mungkin. Sering dipakai untuk visualisasi data berdimensi tinggi.

from [Link] import PCA​

import [Link] as plt​
​
# Contoh data dimensi 3​
X = [Link](100, 3) * 10​
​
# Mengurangi dimensi ke 2 komponen​
pca = PCA(n_components=2)​
X_reduced = pca.fit_transform(X)​
​
print("Shape data asli:", [Link])​
print("Shape data setelah PCA:", X_reduced.shape)​
print("Rasio varian tiap komponen:", pca.explained_variance_ratio_)​
​
[Link](X_reduced[:,0], X_reduced[:,1], color='blue')​
[Link]("Data setelah PCA ke 2D")​
[Link]("Komponen 1")​
[Link]("Komponen 2")​
[Link]()

Output (contoh):

Shape data asli: (100, 3)

Shape data setelah PCA: (100, 2)

Rasio varian tiap komponen: [0.42 0.35]

Penjelasan output:

●​ X berukuran 100x3 (100 sample, 3 fitur).​

●​ Setelah PCA menjadi 2 komponen, ukurannya 100x2.​

●​ explained_variance_ratio_ kira-kira [0.42, 0.35], artinya komponen

pertama menjelaskan 42% variasi data, komponen kedua 35%. Sisa ~23% hilang
karena kita hanya ambil 2 komponen.

Dengan memahami konsep machine learning (supervised/unsupervised), alur scikit-learn

(fit, predict, evaluate), dan contoh model (Linear/Logistic Regression, KNN, K-Means, PCA),
kamu sudah bisa memulai eksperimen ML menggunakan Python. Banyak detail lanjutan
(penyetelan hyperparameter, validasi silang, dsb.) akan kamu temukan saat mendalami
bab-bab khusus machine learning. Namun, fondasi di atas sudah cukup untuk mulai
melakukan projek ML dasar dan mengenali alur kerja pengembangan model data science.
BAB 15 – TIPS DAN TRIK PYTHON
UNTUK DATA SCIENCE
Selain library inti seperti NumPy, Pandas, dan scikit-learn, Python memiliki banyak modul
bermanfaat lainnya yang sering digunakan untuk meningkatkan produktivitas dan efisiensi
dalam proyek data science. Bab ini membahas beberapa di antaranya, seperti itertools,
collections, fungsi-fungsi bawaan Python yang kerap dipakai, pengelolaan waktu
(datetime), serta cara profiling kode dengan timeit dan cProfile.

15.1 Itertools
itertools adalah modul berisi fungsi-fungsi untuk memanipulasi iterasi (daftar,
generator, dll.). Beberapa fungsi penting:

1.​ count(): Membuat iterator yang menghitung bertambah terus.​

2.​ cycle(): Mengulang elemen suatu iterable tanpa henti.​

3.​ chain(): Menggabungkan beberapa iterable secara berurutan.​

4.​ combinations(): Menghasilkan semua kombinasi panjang tertentu.​

5.​ permutations(): Menghasilkan semua permutasi panjang tertentu.​

15.1.1 Fungsi Penting: count(), cycle(), chain(), combinations(), permutations()

Contoh script dan penerapan:

import itertools​
​
# count()​
counter = [Link](start=10, step=2)​
print("Menggunakan [Link]:")​
for i in range(5):​
print(next(counter))​
​
# chain()​
list1 = [1, 2]​
list2 = [3, 4]​
combined = [Link](list1, list2)​
print("\nMenggunakan [Link]:")​
for item in combined:​
print(item)​
​
# combinations()​
print("\nMenggunakan [Link] (r=2) pada [1,2,3]:")​
for combo in [Link]([1,2,3], 2):​
print(combo)​
​
# permutations()​
print("\nMenggunakan [Link] (r=2) pada ['A','B','C']:")​
for perm in [Link](['A','B','C'], 2):​
print(perm)

Output:

Menggunakan [Link]:

10

12

14

16

18

Menggunakan [Link]:

Menggunakan [Link] (r=2) pada [1,2,3]:

(1, 2)
(1, 3)

(2, 3)

Menggunakan [Link] (r=2) pada ['A','B','C']:

('A', 'B')

('A', 'C')

('B', 'A')

('B', 'C')

('C', 'A')

('C', 'B')

Penjelasan output:

●​ count(start=10, step=2) memulai hitungan dari 10 dan bertambah 2 setiap

kali dipanggil next(counter). Hasilnya 10, 12, 14, 16, 18, dan seterusnya.​

●​ chain(list1, list2) menggabungkan [1,2] dan [3,4] menjadi satu iterable

[1,2,3,4].​

●​ combinations([1,2,3], 2) menghasilkan pasangan unik berukuran 2 tanpa

memperhatikan urutan.​

●​ permutations(['A','B','C'], 2) menghasilkan semua urutan 2 huruf, yang

berbeda dengan combinations karena urutan diperhitungkan (A,B) berbeda dengan
(B,A).

15.2 Koleksi Tipe Data Khusus (collections)

Modul collections menyediakan struktur data khusus yang kadang lebih efisien atau
berguna daripada list/dict biasa:

1.​ Counter: Menghitung frekuensi elemen dalam iterable.​

2.​ defaultdict: Seperti dict biasa, tapi jika key belum ada, otomatis membuat value
default (misal list, int, dsb.).​
 3.​ namedtuple: Membuat tuple dengan nama field, sehingga dapat diakses seperti
object.​

4.​ deque: Double-ended queue dengan operasi append dan pop di kedua ujung yang
cepat.​

15.2.1 Counter
from collections import Counter​
​
data = ["apple", "banana", "apple", "orange", "banana", "apple"]​
counter_data = Counter(data)​
print("Counter:", counter_data)​
print("Most common 2:", counter_data.most_common(2))

Output:

Counter: Counter({'apple': 3, 'banana': 2, 'orange': 1})

Most common 2: [('apple', 3), ('banana', 2)]

Penjelasan output:

●​ Counter({'apple': 3, 'banana': 2, 'orange': 1}) menunjukkan apple

muncul 3 kali, banana 2 kali, orange 1 kali.​

●​ most_common(2) mengambil 2 elemen paling sering, di sini apple dan banana.​

15.2.2 defaultdict
from collections import defaultdict​
​
# Otomatis menset value jadi list kosong jika key baru​
list_dict = defaultdict(list)​
list_dict["buah"].append("apel")​
list_dict["buah"].append("jeruk")​
list_dict["sayur"].append("wortel")​
print("defaultdict(list):", list_dict)​
​
# Otomatis menset value jadi 0 (int) jika key baru​
 int_dict = defaultdict(int)​
int_dict["count_a"] += 1​
int_dict["count_b"] += 5​
print("defaultdict(int):", int_dict)

Output:

defaultdict(list): defaultdict(<class 'list'>, {'buah': ['apel',

'jeruk'], 'sayur': ['wortel']})

defaultdict(int): defaultdict(<class 'int'>, {'count_a': 1,

'count_b': 5})

Penjelasan:

●​ defaultdict(list) memudahkan kita untuk memasukkan elemen ke list tanpa

khawatir key belum ada.​

●​ defaultdict(int) memudahkan penambahan integer, karena default value-nya

0.

15.2.3 namedtuple
from collections import namedtuple​
​
Point = namedtuple("Point", ["x", "y"])​
p = Point(10, 20)​
print("p.x =", p.x)​
print("p.y =", p.y)

Output:

p.x = 10

p.y = 20

Penjelasan:
 ●​ Point adalah named tuple dengan field x dan y. Saat membuat Point(10, 20),
kita punya sebuah tuple yang dapat diakses seperti object: p.x, p.y.

15.2.4 deque
from collections import deque​
​
dq = deque([1, 2, 3])​
[Link](4)​
[Link](0)​
print("Setelah append(4) dan appendleft(0):", dq)​
​
[Link]()​
[Link]()​
print("Setelah pop() dan popleft():", dq)

Output:

Setelah append(4) dan appendleft(0): deque([0, 1, 2, 3, 4])

Setelah pop() dan popleft(): deque([1, 2, 3])

Penjelasan output:

●​ dq awalnya [1, 2, 3]. append(4) menambah elemen di ujung kanan -> [1, 2,
3, 4]. appendleft(0) menambah di ujung kiri -> [0, 1, 2, 3, 4].​

●​ pop() menghapus elemen paling kanan (4), popleft() menghapus elemen paling
kiri (0), hasil akhirnya [1, 2, 3].

15.3 Fungsi Bawaan Python yang Berguna

Beberapa fungsi bawaan (built-in) Python yang sering dipakai dalam data science:

1.​ map(): Menerapkan fungsi ke setiap elemen iterable.​

2.​ filter(): Menyaring elemen iterable dengan fungsi kondisi.​

3.​ zip(): Menggabungkan beberapa iterable menjadi satu baris (tuple) per indeks.​

4.​ sorted(): Mengurutkan iterable, dapat memakai kunci custom.​

 5.​ reversed(): Membalik urutan iterable.​

6.​ enumerate(): Membuat pasangan (indeks, elemen) saat iterasi.

15.3.1 map(), filter(), zip()

numbers = [1, 2, 3, 4, 5]​
​
# map​
doubled = list(map(lambda x: x * 2, numbers))​
print("map (x*2):", doubled)​
​
# filter​
even = list(filter(lambda x: x % 2 == 0, numbers))​
print("filter (genap):", even)​
​
# zip​
list_a = [1, 2, 3]​
list_b = ['a', 'b', 'c']​
combined = list(zip(list_a, list_b))​
print("zip:", combined)

Output:

map (x*2): [2, 4, 6, 8, 10]

filter (genap): [2, 4]

zip: [(1, 'a'), (2, 'b'), (3, 'c')]

Penjelasan output:

●​ map(lambda x: x*2, numbers) menerapkan operasi x*2 ke setiap elemen

numbers.​

●​ filter(lambda x: x % 2 == 0, numbers) menyeleksi hanya elemen yang

habis dibagi 2.​

●​ zip(list_a, list_b) menghasilkan pasangan (1,'a'), (2,'b'),

(3,'c').

15.4 Time dan Date

Mengelola waktu dan tanggal sangat umum dalam data science, terutama jika berurusan
dengan data time-series atau penjadwalan. Python punya modul datetime untuk
membuat, memanipulasi, dan memformat objek tanggal/waktu.

15.4.1 datetime Module

from datetime import datetime, timedelta​
​
# Sekarang​
now = [Link]()​
print("Waktu sekarang:", now)​
​
# Membuat datetime spesifik​
dt = datetime(2022, 12, 25, 10, 30, 0)​
print("Datetime spesifik:", dt)​
​
# Menambah 5 hari​
dt_plus_5 = dt + timedelta(days=5)​
print("Ditambah 5 hari:", dt_plus_5)​
​
# Format ke string​
dt_str = [Link]("%d/%m/%Y %H:%M")​
print("Format string:", dt_str)​
​
# Parsing string ke datetime​
parsed_dt = [Link]("01-03-2023", "%d-%m-%Y")​
print("Parsing string ke datetime:", parsed_dt)

Output (contoh):

Waktu sekarang: 2025-04-03 12:34:56.789123

Datetime spesifik: 2022-12-25 10:30:00

Ditambah 5 hari: 2022-12-30 10:30:00

Format string: 25/12/2022 10:30

Parsing string ke datetime: 2023-03-01 00:00:00

Penjelasan output:

●​ [Link]() menampilkan tanggal dan waktu komputer saat ini.​

 ●​ datetime(2022,12,25,10,30,0) merepresentasikan 25 Desember 2022 pukul
10:30:00.​

●​ timedelta(days=5) menambah 5 hari dari objek datetime tersebut.​

●​ [Link]("%d/%m/%Y %H:%M") mengubah datetime menjadi string format

“DD/MM/YYYY HH:MM”.​

●​ [Link]("01-03-2023", "%d-%m-%Y") mem-parse string

“01-03-2023” (format dd-mm-yyyy) menjadi objek datetime 1 Maret 2023.

15.5 Penggunaan timeit dan Profiling Kode

Dalam data science, kita kadang perlu mengukur efisiensi kode, khususnya saat menangani
dataset besar. Python menyediakan modul timeit untuk mengukur waktu eksekusi, serta
cProfile untuk profiling keseluruhan program.

15.5.1 timeit Module

timeit dapat dijalankan di command line atau di dalam script. Fungsinya mengulang
eksekusi sebuah kode kecil berulang kali dan menampilkan waktu rata-rata.

Contoh script (dalam Jupyter Notebook/mode interaktif):

import timeit​
​
code_to_test = """​
import numpy as np​
arr = [Link](100000)​
[Link](arr)​
"""​
execution_time = [Link](code_to_test, number=100)​
print("Waktu eksekusi:", execution_time, "detik (untuk 100 kali run)")

Output (contoh):

Waktu eksekusi: 0.0523475439932345 detik (untuk 100 kali run)

Penjelasan output:
 ●​ [Link](code_to_test, number=100) mengeksekusi code_to_test
sebanyak 100 kali dan mengembalikan total waktu.​

●​ Kita dapat menghitung waktu rata-rata per eksekusi dengan membagi total waktu
oleh 100.

15.5.2 Profiling Sederhana (cProfile)

cProfile dapat menganalisa berapa lama setiap fungsi dipanggil, seberapa sering
dipanggil, dsb. Cocok saat ingin tahu mana bagian kode yang paling lambat.

Contoh script (buat file python bernama profiling_test.py):

def fungsi_pertama(n):​
s = 0​
for i in range(n):​
s += i​
return s​
​
def fungsi_kedua(n):​
import numpy as np​
arr = [Link](n)​
return [Link](arr)​
​
def main():​
hasil1 = fungsi_pertama(10_000_000)​
hasil2 = fungsi_kedua(10_000_000)​
print("Hasil1:", hasil1, "Hasil2:", hasil2)​
​
if __name__ == "__main__":​
import cProfile​
[Link]('main()')

Setelah disimpan, jalankan python profiling_test.py di terminal.

Output (contoh ringkasan):

Hasil1: 49999995000000 Hasil2: 49999995000000

6 function calls in 0.220 seconds

ncalls tottime percall cumtime percall

filename:lineno(function)
 1 0.195 0.195 0.220 0.220
profiling_test.py:1(fungsi_pertama)

1 0.021 0.021 0.021 0.021

profiling_test.py:8(fungsi_kedua)

1 0.000 0.000 0.220 0.220

profiling_test.py:13(main)

1 0.000 0.000 0.220 0.220 {built-in method

[Link]}

1 0.004 0.004 0.004 0.004 {method 'arange' of

'[Link]._multiarray_umath' objects}

1 0.000 0.000 0.000 0.000 {built-in method sum}

Penjelasan output:

●​ Menampilkan total waktu, berapa kali fungsi dipanggil, dan waktu yang dihabiskan
di setiap fungsi.​

●​ fungsi_pertama memakai loop Python dan butuh ~0.195 detik, sedangkan

fungsi_kedua menggunakan NumPy vectorized ~0.021 detik, lebih cepat.​

●​ ncalls menunjukkan berapa kali fungsi dipanggil, tottime adalah waktu total
eksekusi fungsi, cumtime adalah waktu komulatif termasuk fungsi di dalamnya.

Melalui profiling, kita dapat mengidentifikasi bagian kode yang perlu dioptimasi, misalnya
mengganti loop Python dengan operasi NumPy yang lebih efisien.

Dengan mempelajari modul dan fitur tambahan di Python seperti itertools,

collections, fungsi-fungsi built-in (map, filter, zip, dsb.), manajemen waktu
(datetime), dan profiling (dengan timeit dan cProfile), kamu memiliki “peralatan
tambahan” yang sangat membantu dalam berbagai tugas data science. Mulai dari merapikan
perulangan, memanipulasi struktur data khusus, sampai mengoptimalkan kinerja kode
dapat dilakukan lebih efisien dengan trik-trik di atas.
BAB 16 – PENGEMBANGAN PROYEK
DATA SCIENCE SEDERHANA
Bab ini menitikberatkan pada penggabungan konsep yang telah dipelajari sebelumnya:
mulai dari pemrosesan data (menggunakan Python, NumPy, Pandas), visualisasi
(Matplotlib, Seaborn), penerapan statistika dasar, hingga pembuatan model machine
learning sederhana (scikit-learn). Tujuannya adalah memberikan gambaran utuh mengenai
bagaimana sebuah proyek data science dijalankan.

16.1 Studi Kasus 1: Analisis Dataset (Exploratory Data

Analysis – EDA)
Tahapan Exploratory Data Analysis (EDA) sangat krusial untuk memahami struktur, pola,
dan potensi masalah (missing values, outlier) dalam dataset sebelum kita memutuskan
teknik apa yang akan digunakan selanjutnya.

Langkah-Langkah EDA (Loading, Cleaning, Visualisasi)

1.​ Load Data: Membaca file CSV/Excel/SQL ke dalam DataFrame Pandas.​

2.​ Inspeksi Awal: Melihat bentuk data, tipe data, dan ringkasan statistik.​

3.​ Pembersihan Data: Menangani missing values, duplikasi, outlier, dsb.​

4.​ Visualisasi Dasar: Plot histogram, boxplot, scatter plot, heatmap korelasi, dsb.​

5.​ Interpretasi: Menarik kesimpulan awal dari analisis.​

Contoh script (EDA pada dataset Iris)

import pandas as pd​
import numpy as np​
import seaborn as sns​
import [Link] as plt​
​
# 1. Load Data​
iris = sns.load_dataset("iris") # dataset bawaan Seaborn​
# Jika kamu memiliki file CSV sendiri, gunakan:​
# iris = pd.read_csv("[Link]")​
​
# 2. Inspeksi Awal​
 print("5 data teratas:")​
print([Link]())​
​
print("\nInfo dataset:")​
print([Link]())​
​
print("\nStatistik deskriptif:")​
print([Link]())​
​
# 3. Pembersihan Data (cek missing, outlier, dsb.)​
print("\nCek missing values:")​
print([Link]().sum())​
​
# 4. Visualisasi Dasar​
[Link](figsize=(10,4))​
​
[Link](1,2,1)​
[Link](data=iris, x="sepal_length", kde=True, color='blue')​
[Link]("Distribusi Sepal Length")​
​
[Link](1,2,2)​
[Link](data=iris, y="sepal_length", color='green')​
[Link]("Boxplot Sepal Length")​
​
plt.tight_layout()​
[Link]()​
​
# Korelasi Heatmap​
corr = [Link](columns="species").corr()​
[Link](figsize=(5,4))​
[Link](corr, annot=True, cmap="Blues")​
[Link]("Heatmap Korelasi Fitur Iris")​
[Link]()​
​
# 5. Interpretasi EDA​
# Misalnya kita lihat dari histogram sepal_length, distribusinya agak
normal,​
# dan dari boxplot kita bisa cek apakah ada outlier. Selanjutnya kita
amati​
# juga korelasi antar fitur.

Output (Penjelasan detail):

 1.​ [Link]() menampilkan 5 baris pertama dataset, biasanya terlihat kolom
seperti sepal_length, sepal_width, petal_length, petal_width, dan
species.​

2.​ [Link]() menunjukkan tipe data setiap kolom (biasanya float untuk
panjang-panjang kelopak, object atau category untuk species), serta jumlah
non-null.​

3.​ [Link]() menampilkan ringkasan statistik, seperti mean, std, min, max,
Q1, Q2, Q3.​

4.​ [Link]().sum() akan menampilkan jumlah missing value di setiap kolom.

Pada dataset Iris bawaan, biasanya tidak ada nilai yang hilang (semuanya 0).​

5.​ Histogram menampilkan distribusi sepal_length, sedangkan boxplot

memperlihatkan ringkasan statistika sepal_length. Kita dapat memeriksa apakah
ada data yang sangat jauh (outlier).​

6.​ Heatmap korelasi memperlihatkan sejauh mana hubungan linear antar fitur
numerik, misalnya petal_length sering sangat berkorelasi positif dengan
petal_width.​

Dengan EDA, kita dapat menyimpulkan pola awal, misalnya korelasi kuat antara
petal_length dan petal_width, atau melihat apakah ada data aneh/outlier. Informasi
ini akan berguna saat kita lanjut ke pemodelan.

16.2 Studi Kasus 2: Model Prediksi

Tahapan selanjutnya setelah EDA biasanya adalah membangun model prediksi. Kita akan
mencontohkan pembuatan model klasifikasi sederhana untuk memprediksi spesies bunga
iris berdasarkan fitur-fitur kelopak dan mahkota bunganya.

Langkah-Langkah (Train, Test, Evaluasi)

1.​ Pemisahan Data: train_test_split agar kita bisa menguji performa model di
data yang tidak dipakai untuk training.​

2.​ Pembuatan Model: Kita pilih algoritma sederhana, misalnya LogisticRegression

atau RandomForestClassifier.​

3.​ Training: [Link](X_train, y_train).​

 4.​ Evaluasi: Memakai accuracy_score, classification_report, dsb.​

Contoh script (Model Klasifikasi pada Iris)

import pandas as pd​
import seaborn as sns​
from sklearn.model_selection import train_test_split​
from [Link] import RandomForestClassifier​
from [Link] import accuracy_score, classification_report​
​
# 1. Load data iris​
iris = sns.load_dataset("iris")​
​
# 2. Pisahkan fitur dan label​
X = [Link](columns="species") # semua kolom kecuali species​
y = iris["species"] # kolom species adalah target​
​
# 3. Split data (80% train, 20% test)​
X_train, X_test, y_train, y_test = train_test_split(​
X, y, test_size=0.2, random_state=42​
)​
​
# 4. Membuat model (RandomForestClassifier sebagai contoh)​
model = RandomForestClassifier(n_estimators=100, random_state=42)​
[Link](X_train, y_train)​
​
# 5. Prediksi​
y_pred = [Link](X_test)​
​
# 6. Evaluasi​
acc = accuracy_score(y_test, y_pred)​
report = classification_report(y_test, y_pred)​
​
print("Akurasi:", acc)​
print("Classification Report:\n", report)​
​
# Opsional: Mencoba prediksi data baru​
new_data = [[5.0, 3.5, 1.4, 0.2]] # sepal_length, sepal_width,
petal_length, petal_width​
prediction_new = [Link](new_data)​
print("Prediksi spesies untuk data baru:", prediction_new)

Output (Penjelasan detail):

 1.​ Akurasi: Biasanya untuk dataset Iris, model random forest akurasinya sangat tinggi
(di atas 0.9), misalnya Akurasi: 1.0 di data test jika beruntung dengan random
state tertentu.​

2.​ Classification Report: Menampilkan precision, recall, dan f1-score untuk setiap
kelas (setosa, versicolor, virginica). Mungkin semuanya 1.00 jika model
memang sempurna memprediksi data test.​

3.​ Prediksi spesies: Baris terakhir mengevaluasi data baru [5.0, 3.5, 1.4, 0.2].
Model akan mengembalikan array dengan satu label spesies, misalnya
[‘setosa’].

Dengan contoh di atas, kamu telah melihat siklus lengkap: EDA, persiapan data, pemodelan,
evaluasi, dan penerapan prediksi. Meskipun dataset Iris relatif kecil dan sederhana, prinsip
yang sama berlaku untuk dataset lebih besar dan kompleks.
BAB 17 – BEST PRACTICES DAN SARAN
LANJUT
Setelah memahami konsep dasar Python dan data science, kamu mungkin ingin menyusun
proyek dengan cara yang terstruktur, mudah di-maintain, dan siap untuk dikembangkan
lebih lanjut. Bab ini membahas praktik terbaik (best practices) dalam mengorganisir kode,
menjaga kualitas, menggunakan sistem kendali versi, dan beberapa saran untuk tahap
lanjut seperti containerization (Docker) dan deployment model.

17.1 Struktur Folder Proyek

Dalam proyek data science, sering kali kita memiliki banyak file: dataset, notebook, skrip
Python, modul, laporan, dsb. Untuk menjaga kerapian, gunakan struktur folder yang
konsisten. Misalnya:

my_data_science_project/

├── data/

│ ├── raw/

│ │ └── dataset_original.csv

│ └── processed/

│ └── dataset_cleaned.csv

├── notebooks/

│ ├── [Link]

│ └── [Link]

├── scripts/

│ ├── data_preprocessing.py

│ ├── train_model.py

│ └── [Link]

├── models/

│ └── random_forest_model.pkl
├── reports/

│ ├── eda_report.html

│ └── model_evaluation.md

├── [Link] (atau [Link])

└── [Link]

Penjelasan Struktur:

1.​ data/raw/: Menyimpan data mentah (original).​

2.​ data/processed/: Menyimpan data hasil pembersihan atau transformasi.​

3.​ notebooks/: Berisi notebook Jupyter tempat eksplorasi dan dokumentasi

langkah-langkah analisis.​

4.​ scripts/: Berisi skrip Python yang dapat dijalankan, misalnya preprocessing,
training, evaluasi.​

5.​ models/: Menyimpan model yang telah dilatih (misal file .pkl jika pakai joblib
atau pickle).​

6.​ reports/: Tempat menyimpan laporan, hasil visualisasi EDA, dsb.​

7.​ [Link] atau [Link]: Daftar library yang dibutuhkan

untuk memudahkan reproduksi environment.​

8.​ [Link]: Penjelasan singkat tentang proyek dan cara menjalankannya.

Struktur ini memudahkan kolaborasi dan memperjelas di mana setiap komponen proyek
disimpan.

17.2 Kode yang Rapi dan Terbaca

Menulis kode yang bersih sangat membantu kamu dan rekan tim di masa depan. Python
memiliki panduan gaya resmi bernama PEP 8 yang menjelaskan tata cara penulisan kode
(indentasi, penamaan variabel, panjang baris, dsb.).

Dokumentasi dan Komentar

 ●​ Gunakan docstring pada awal fungsi/kelas untuk menjelaskan fungsionalitas dan
parameter.​

●​ Tuliskan komentar singkat jika kamu membuat langkah-langkah kritis yang perlu
penjelasan.​

●​ Hindari komentar berlebihan yang justru membingungkan.​

Contoh penulisan fungsi rapi:

def hitung_luas_segitiga(alas, tinggi):​
"""​
Menghitung luas segitiga.​
​
Parameter:​
- alas (float): panjang alas segitiga​
- tinggi (float): tinggi segitiga​
​
Return:​
- float: luas segitiga​
"""​
return 0.5 * alas * tinggi

Penjelasan:

●​ docstring """...""" di dalam definisi fungsi menjelaskan tujuan fungsi, param,

return.​

●​ Gunakan penamaan variabel yang deskriptif, misalnya alas dan tinggi, bukan a
atau t jika ingin lebih jelas.

17.3 Versi Kontrol (Git, GitHub)

Git adalah sistem pengendali versi (version control system) yang sangat berguna untuk
melacak perubahan kode, berkolaborasi, dan mencegah kehilangan data. GitHub atau
GitLab menawarkan platform hosting repositori Git, sehingga orang lain bisa mengakses
dan kamu bisa mengatur alur kolaborasi.

Alur Git Dasar

1.​ git init: Menginisialisasi repositori di folder proyek.​

 2.​ git add .: Menambahkan file-file ke staging area.​

3.​ git commit -m "Pesan commit": Menyimpan snapshot perubahan.​

4.​ git push: Mengirim perubahan ke remote repository (GitHub, GitLab).​

5.​ git pull: Menarik perubahan terbaru dari remote.

Mengelola Repositori Data Science

●​ Jangan menempatkan dataset besar di repositori Git. Gunakan .gitignore atau

layanan data storage lain.​

●​ Commit secara teratur dengan pesan yang jelas (misal: “Menambahkan EDA untuk
dataset X” atau “Memperbaiki bug pada fungsi train_model”).​

●​ Manfaatkan branching untuk fitur baru atau percobaan model, lalu merge ke branch
utama setelah stabil.

17.4 Pemanfaatan Lanjutan

17.4.1 Docker untuk Proyek Data Science

Docker memungkinkan kamu membuat container yang berisi seluruh environment

(Python, library, OS) sehingga proyek dapat dijalankan di mana saja dengan konfigurasi
yang konsisten.

Contoh Dockerfile sederhana:

FROM python:3.9

WORKDIR /app

COPY [Link] .

RUN pip install --no-cache-dir -r [Link]

COPY . /app

CMD ["python", "scripts/train_model.py"]

Penjelasan:

●​ FROM python:3.9 artinya menggunakan image Python 3.9 sebagai basis.​

●​ WORKDIR /app menetapkan direktori kerja di dalam container.​

●​ COPY [Link] . menyalin file [Link], lalu RUN pip

install... menginstal library.​

●​ COPY . /app menyalin seluruh isi folder proyek ke /app.​

●​ CMD ["python", "scripts/train_model.py"] mengeksekusi skrip

train_model.py saat container dijalankan.

Dengan Docker, orang lain bisa cukup menjalankan docker build -t my-ds-project
. lalu docker run my-ds-project tanpa pusing tentang perbedaan environment.

17.4.2 Penyebaran Model (Flask, FastAPI, Streamlit) – Singkat

Setelah model dibuat, kita sering ingin menjadikannya API atau aplikasi web.

●​ Flask: Microframework Python untuk membuat endpoint API sederhana.​

●​ FastAPI: Mirip Flask, tapi lebih modern dan performa tinggi, dilengkapi
dokumentasi otomatis.​

●​ Streamlit: Memudahkan membuat dashboard interaktif untuk data science tanpa

harus banyak menulis kode HTML.

Contoh (Flask) Sederhana:

from flask import Flask, request, jsonify​

import joblib​
​
app = Flask(__name__)​
​
# Muat model​
model = [Link]("models/random_forest_model.pkl")​
​
@[Link]("/predict", methods=["POST"])​
def predict():​
data_json = [Link]​
# data_json diharapkan format: {"features": [5.0, 3.5, 1.4, 0.2]}​
 features = data_json["features"]​
prediction = [Link]([features])[0]​
return jsonify({"prediction": prediction})​
​
if __name__ == "__main__":​
[Link](port=5000, debug=True)

Penjelasan:

●​ [Link]("models/random_forest_model.pkl") memuat model yang

sudah dilatih.​

●​ Endpoint /predict menerima POST request dengan JSON berisi fitur, lalu
memanggil [Link](...).​

●​ Hasil prediksi dikembalikan sebagai JSON.

Dengan demikian, model bisa diakses melalui permintaan HTTP ke

localhost:5000/predict. Kamu dapat mengintegrasikannya ke frontend web atau
aplikasi lain.
BAB 18 – REFERENSI TAMBAHAN
Bab ini dirancang sebagai rujukan akhir yang berisi kumpulan sumber belajar, dokumentasi
resmi, serta istilah-istilah penting di ranah Python dan data science. Mempelajari Python
dan data science adalah perjalanan berkelanjutan, sehingga memiliki akses ke sumber
dokumentasi dan komunitas yang tepat akan sangat membantu kamu memperdalam
keahlian.

18.1 Dokumentasi Resmi

Dokumentasi resmi sangat penting karena memberikan penjelasan paling lengkap dan
akurat tentang fungsi-fungsi, modul, dan perilaku bahasa/librari. Pengembang atau library
maintainers umumnya memperbarui dokumentasi seiring dengan rilis versi baru. Di sinilah
kamu dapat mempelajari detail parameter, contoh penggunaan, dan batasan-batasan
tertentu.

18.1.1 Dokumentasi Python

Python memiliki dokumentasi resmi yang beralamat di:

●​ [Link] (untuk Python 3)​

Dokumentasi ini mencakup:

1.​ Library Reference: Penjelasan setiap modul bawaan Python, misalnya math, os, re,
datetime, dll.​

2.​ Language Reference: Detail sintaks, struktur bahasa, dan perilaku di level
interpreter.​

3.​ Tutorial: Pengantar resmi untuk pemula.

Contoh script (Cara mengecek docstring di dalam Python, khusus awam):

# kamu bisa memanfaatkan fungsi help() untuk melihat docstring​

help(print)

Output (contoh ringkasan):

Help on built-in function print in module builtins:

print(...)

print(value, ..., sep=' ', end='\n', file=[Link],

flush=False)

Prints the values to a stream, or to [Link] by default.

...

Penjelasan output:

●​ help(print) menampilkan penjelasan bawaan terkait fungsi print: parameter

sep, end, dan sebagainya.​

●​ Hal serupa dapat dilakukan pada modul atau objek lain, contohnya help(str),
help([Link]), dan seterusnya.​

Contoh script (Menggunakan pydoc di terminal):

pydoc re

Output:

Akan memunculkan dokumentasi modul re (regex) di terminal: daftar fungsi seperti

[Link], [Link], [Link], dll.

Penjelasan output:

●​ pydoc re adalah perintah terminal yang membaca docstring modul re dan

menampilkannya dalam format teks.​

●​ Ini praktis bila kamu ingin melihat penjelasan secara offline tanpa membuka
browser.

18.1.2 Dokumentasi NumPy, Pandas, Matplotlib, Seaborn, Scikit-Learn

Proyek data science modern hampir selalu melibatkan library: NumPy, Pandas, Matplotlib,
Seaborn, dan scikit-learn. Masing-masing memiliki situs dokumentasi sendiri:
 1.​ NumPy: [Link]

2.​ Pandas: [Link]

3.​ Matplotlib: [Link]

4.​ Seaborn: [Link]

5.​ Scikit-Learn: [Link]

Setiap dokumentasi menyertakan:

●​ API Reference: Penjelasan setiap fungsi, parameter, dan return.​

●​ Tutorial/Guide: Panduan langkah demi langkah untuk pemula atau pengguna

menengah.​

●​ Contoh Kode: Biasanya disertakan snippet yang dapat dipraktikkan.​

Contoh script (Menggunakan docstring library di sesi Python):

import numpy as np​

​
help([Link])

Output (contoh ringkasan):

Help on built-in function rand:

rand(...)

rand(d0, d1, ..., dn) -> ndarray

Random values in a given shape.

Creates an array of the given shape and populates it with

 random samples from a uniform distribution over [0, 1).

...

Penjelasan output:

●​ Menampilkan penjelasan fungsi rand(...), parameter yang dapat diterima (d0,

d1, ..., dn), serta keterangan singkat bahwa nilainya acak antara [0, 1).​

●​ Ini merupakan contoh docstring ringkas. Dokumentasi resmi di situs akan memuat
lebih banyak detail.

18.2 Sumber Belajar Online

Selain dokumentasi resmi, komunitas Python dan data science menyediakan banyak sekali
materi, tutorial interaktif, forum tanya jawab, kursus gratis maupun berbayar.
Menggabungkan referensi ini dengan dokumentasi resmi akan mempercepat proses belajar
kamu.

18.2.1 Tutorial Resmi

1.​ Python Official Tutorial: [Link]

○​ Cocok untuk pemula yang ingin memahami dasar bahasa Python secara
berurutan.​

2.​ Pandas Tutorial: [Link]

○​ Berisi contoh penggunaan DataFrame, Series, dan fungsi-fungsi dasar.​

3.​ Matplotlib Tutorials: [Link]

○​ Menjelaskan dasar pembuatan plot, konsep figure, axes, subplot, dsb.

18.2.2 Kursus dan Komunitas

1.​ Kursus Online​

○​ Khan Academy, Coursera, edX, Udemy, DataCamp: Menyediakan kursus

data science dengan Python, dari tingkat dasar hingga lanjutan.​

○​ Google’s Python Class: Kursus Python gratis.​

2.​ Komunitas & Forum​

 ○​ Stack Overflow: Tempat tanya jawab masalah teknis pemrograman,
termasuk Python.​

○​ Reddit (r/learnpython): Diskusi, tutorial, dan pembahasan seputar Python.​

○​ Kaggle: Platform kompetisi data science dan forum diskusi, juga

menyediakan dataset publik.

18.2.3 Buku Rekomendasi Lain

Ada banyak buku bagus tentang Python dan data science. Beberapa di antaranya:

1.​ “Automate the Boring Stuff with Python” oleh Al Sweigart, gratis online:
[Link]

2.​ “Python for Data Analysis” oleh Wes McKinney, pendiri Pandas.​

3.​ “Fluent Python” oleh Luciano Ramalho, membahas detail internal Python.​

4.​ “Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow” oleh
Aurélien Géron, untuk penerapan ML modern.

18.3 Glosarium Istilah

Glosarium istilah memuat definisi singkat konsep-konsep penting. Ini berguna ketika kamu
kerap lupa atau ingin menjelaskan pada orang yang benar-benar baru. Berikut beberapa
istilah kunci di ranah Python dan data science:

1.​ Module (Modul): Berkas .py atau library eksternal yang berisi sekumpulan fungsi,
kelas, variabel.​

2.​ Package: Direktori yang berisi banyak modul dan memiliki file __init__.py.​

3.​ Virtual Environment: Lingkungan Python terisolasi yang memiliki versi paket
tersendiri.​

4.​ DataFrame: Struktur data 2D ala tabel di Pandas dengan label baris (index) dan label
kolom (columns).​

5.​ Series: Struktur data 1D di Pandas, mirip kolom tunggal.​

6.​ Array NumPy: Struktur data numerik berdimensi tunggal atau lebih, di mana semua
elemen tipe datanya sama.​
 7.​ EDA (Exploratory Data Analysis): Proses menjelajahi data melalui statistik
deskriptif, visualisasi, dan pembersihan data awal.​

8.​ Supervised Learning: Metode machine learning dengan data berlabel. Terbagi
menjadi klasifikasi (label kategori) dan regresi (label numerik).​

9.​ Unsupervised Learning: Metode machine learning tanpa label, seperti klasterisasi
(k-means) dan reduksi dimensi (PCA).​

10.​Overfitting: Kondisi di mana model sangat cocok dengan data training tetapi kurang
generalisasi ke data baru.​

11.​Underfitting: Kondisi di mana model belum cukup belajar pola dari data (biasanya
performa buruk di training dan testing).​

12.​Hyperparameter: Parameter yang menentukan konfigurasi model (misal jumlah

lapisan, learning rate) dan diatur sebelum training.​

13.​Parameter: Parameter model yang dipelajari dari data (misal bobot dan bias pada
neural network, koefisien pada linear regression).

Bab 18 menutup isi buku dengan memberikan daftar referensi resmi, sumber belajar
online, buku lanjutan, dan glosarium. Dokumentasi resmi, komunitas daring, dan buku
berkualitas akan selalu menjadi penolong ketika kamu menghadapi pertanyaan teknis atau
mencari inspirasi untuk praktik data science yang lebih mendalam. Dengan semua bekal
dari bab-bab sebelumnya, dipadu dengan rujukan di bab ini, kamu diharapkan bisa terus
belajar dan mengembangkan keterampilan Python untuk data science secara berkelanjutan.
TERIMAKASIH