Cheatsheet Data Processing dengan Pandas

Disusun oleh Tim Datasans

@datasans.book
 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 @datasans.book

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 @datasans.book jika
temanmu berminat agar ilmu yang bermanfaat bisa tersebar semakin luas.
 Daftar Isi

Bab 1. Pendahuluan........................................................................................................ 4
1.1 Sejarah Pandas......................................................................................................4
1.2 Pentingnya Pandas dalam Data Science.................................................................. 4
1.3 Persiapan Lingkungan Kerja.................................................................................. 4
Bab 2. Dasar-dasar Pandas.............................................................................................. 6
2.1 Mengimpor Library Pandas................................................................................... 6
2.2 Struktur Data di Pandas: Series dan DataFrame.......................................................6
2.3 Pembuatan Series dan DataFrame.......................................................................... 8
2.4 Menampilkan Informasi Dasar DataFrame............................................................14
2.5 Mengakses Data dalam Series dan DataFrame....................................................... 22
2.6 Operasi Dasar pada DataFrame............................................................................ 29
2.7 Indexing dan Slicing............................................................................................ 34
2.8 Menggunakan Fungsi Bawaan Pandas...................................................................40
2.9 Menggabungkan DataFrame................................................................................ 45
2.10 Mengurutkan Data............................................................................................. 52
Bab 3. Pembersihan Data dengan Pandas...................................................................... 60
3.1 Mengidentifikasi Data yang Hilang (Missing Data).................................................60
3.2 Mengisi Data yang Hilang.................................................................................... 64
3.3 Menghapus Data yang Hilang............................................................................... 68
3.4 Transformasi Data............................................................................................... 71
3.5 Mengubah Tipe Data........................................................................................... 75
3.6 Mengatasi Data Duplikat...................................................................................... 78
3.7 Normalisasi Data................................................................................................. 81
3.8 Manipulasi String................................................................................................ 84
3.9 Menggunakan Fungsi Apply dan Map di Pandas.................................................... 90
3.10 Konversi antara DataFrame dan Numpy Array..................................................... 95
Bab 4. Visualisasi Data dengan Pandas.........................................................................100
4.1 Plot Dasar dengan Pandas.................................................................................. 100
4.2 Lebih Dalam tentang Grafik Batang dan Histogram..............................................106
4.3 Lebih Dalam tentang Scatter Plot dan Line Plot................................................... 112
4.4 Ebook Data Visualization....................................................................................116
Bab 5. Operasi Lanjutan dengan Pandas...................................................................... 117
5.1 Grouping dan Aggregasi..................................................................................... 117
5.2 Pivot Table........................................................................................................ 120
5.3 Crosstab............................................................................................................ 122
5.4 Merging, Joining, dan Concatenating.................................................................. 124
5.5 Time Series Analysis dengan Pandas................................................................... 128
5.6 Window Functions dengan Pandas......................................................................131
5.7 Querying DataFrame dengan Pandas.................................................................. 134
Bab 6. IO di Pandas: Memuat dan Menyimpan Data...................................................... 139
6.1 Menyimpan Data dari CSV dengan Pandas...........................................................139
6.2 Membaca Data ke CSV dengan Pandas................................................................ 141
6.3 Menyimpan Data dari Excel dengan Pandas.........................................................143
Penutup................................................................................................................. 144
Bab 1. Pendahuluan
1.1 Sejarah Pandas
Sebelum memulai perjalanan kita dengan Pandas, mari kita melangkah kembali sejenak
dan merenungkan asal-usulnya. Pandas, yang dikenal sebagai salah satu library Python
terbaik untuk analisis data, dimulai sebagai proyek oleh Wes McKinney pada tahun 2008.
Wes, seorang ahli statistik, merasa frustrasi dengan alat analisis data yang ada saat itu dan
memutuskan untuk membuat yang baru. Siapa sangka, frustrasi ini berujung pada
kelahiran sebuah library yang kini menjadi tulang punggung analisis data dengan Python.

Pandas, yang merupakan kependekan dari "PANel DAta System", awalnya dirancang untuk
mengatasi data keuangan kuantitatif. Namun, seiring berjalannya waktu, kemampuannya
untuk mengolah berbagai jenis data membuatnya mendapatkan tempat di hati banyak
analis data.

1.2 Pentingnya Pandas dalam Data Science

Mengapa kamu harus peduli dengan Pandas? Jawabannya sederhana: Pandas membuat
hidupmu jauh lebih mudah! Bayangkan memiliki alat yang dapat dengan cepat mengimpor,
membersihkan, dan menganalisis data dengan hanya beberapa baris kode. Inilah yang
Pandas tawarkan.

Di era informasi ini, data adalah mata uang baru. Setiap hari, triliunan bit data dihasilkan,
dicatat, dan disimpan. Namun, data mentah jarang memberikan wawasan apa pun. Hanya
ketika data ini diolah, dianalisis, dan dipahami, barulah ia memiliki nilai. Inilah di mana
Pandas berperan.

1.3 Persiapan Lingkungan Kerja

Sebelum kita benar-benar menyelami dunia Pandas, ada beberapa persiapan yang harus
kamu lakukan. Memastikan lingkungan kerja kamu siap adalah langkah pertama untuk
memastikan perjalananmu dengan Pandas berjalan lancar.

Pertama-tama, pastikan Python sudah terinstall di komputermu. Jika belum, kunjungi situs
web resmi Python dan ikuti petunjuk instalasinya. Setelah itu, kamu bisa memasang Pandas
dengan menggunakan pip, manajer paket Python:
pip install pandas

Setelah instalasi selesai, kamu sudah siap untuk memulai petualanganmu dengan Pandas!
Sampai di sini, kamu mungkin bertanya-tanya: "Apa yang membuat Pandas begitu spesial?"
Atau mungkin, "Mengapa banyak orang jatuh cinta dengan Pandas?" Jawabannya terletak
pada fungsionalitas dan fleksibilitas yang ditawarkannya.

Dengan Pandas, kamu dapat:

● Mengimpor data dari berbagai sumber dengan mudah.
● Membersihkan data yang berantakan atau tidak lengkap.
● Melakukan analisis statistik dasar tanpa perlu software khusus.
● Membuat visualisasi data yang menarik dan informatif.

Namun, kelebihan Pandas tidak hanya sebatas itu. Kemampuannya untuk berintegrasi
dengan berbagai library lain seperti Numpy, Matplotlib, dan Scikit-learn menjadikannya
pilihan utama bagi para profesional data.

Ketika kamu mulai menggunakan Pandas, kamu akan menyadari bahwa Pandas bukan
hanya tentang mengolah data. Ia adalah tentang bagaimana memahami cerita yang
diceritakan oleh data. Di balik setiap dataset, ada kisah, tren, dan wawasan yang menunggu
untuk ditemukan. Dan Pandas adalah kuncinya.

Jadi, apakah kamu siap untuk memulai perjalananmu dengan Pandas? Apakah kamu siap
untuk menggali lebih dalam dan memahami apa yang sebenarnya diceritakan oleh data?
Jika jawabannya ya, maka mari kita lanjutkan petualangan ini. Bab-bab berikutnya akan
membawa kamu lebih dekat ke inti dari Pandas, mengungkap setiap rahasia dan trik yang
perlu kamu ketahui.
Bab 2. Dasar-dasar Pandas
2.1 Mengimpor Library Pandas
Sebelum kita mulai bermain dengan data, hal pertama yang perlu kamu lakukan adalah
mengimpor library Pandas. Seperti menyalakan mesin sebelum mengemudikan mobil, ini
adalah langkah awal dalam perjalanan Pandas kita. Untuk melakukannya, kamu hanya
perlu menulis kode berikut:
import pandas as pd

Mengapa pd? Ini adalah konvensi yang umumnya diterima oleh komunitas Python. Singkat,
padat, dan mudah diingat. Setelah melakukan ini, segala keajaiban Pandas siap untuk kamu
gunakan dengan panggilan singkat pd.

2.2 Struktur Data di Pandas: Series dan DataFrame

Ketika pertama kali mendengar kata "Pandas", apa yang ada di benakmu? Hewan berbulu
hitam putih yang gemas dan tinggal di China? Eits, di dunia pemrograman, Pandas berarti
sesuatu yang jauh berbeda. Pandas adalah salah satu library Python yang paling powerful
untuk manipulasi dan analisis data. Di jantung library ini ada dua struktur data utama yang
menjadi pilar: Series dan DataFrame.

Series: Kolom Tunggal Penuh Misteri

Bayangkan sebuah daftar. Daftar belanjaan, daftar tugas, atau daftar nama teman-temanmu.
Dalam Pandas, daftar semacam itu disebut Series. Sebuah Series adalah array satu dimensi
yang dapat menyimpan data dari berbagai jenis, mulai dari integer, float, hingga string atau
objek lainnya.

Tapi tunggu, apa bedanya dengan list di Python? Kenapa kita perlu Series?

Nah, inilah keajaiban Pandas. Dibandingkan dengan list, Series memiliki sesuatu yang
spesial: sebuah indeks. Indeks ini memungkinkan kamu untuk mengidentifikasi dan
mengakses data dengan cara yang lebih intuitif. Kamu bisa menganggap indeks ini seperti
label yang ditempelkan pada setiap item di daftar belanjaanmu, memudahkanmu
menemukan apa yang kamu cari.

Mari ciptakan Series pertama kita:

import pandas as pd
 s = pd.Series([10, 20, 30, 40, 50])
print(s)
Output:

Apa yang kamu lihat? Sebuah daftar angka, bukan? Tapi perhatikan lebih dekat. Ada dua
kolom: kolom pertama adalah indeks, dan kolom kedua adalah data. Kamu bisa
membayangkan Series sebagai kolom tunggal dari sebuah tabel. Indeks di sisi kiri, dan data
di sisi kanan.

DataFrame: Bukan Sekadar Tabel Biasa

Jika kamu bisa membayangkan Series sebagai kolom, maka DataFrame adalah tabel lengkap
dengan baris dan kolom. Ini adalah struktur data 2D di mana kamu dapat menyimpan data
dalam format tabel.

Namun, jangan salah paham. Meskipun tampak seperti tabel, DataFrame jauh lebih kuat.
Dengan Pandas, kamu dapat melakukan operasi pada data dengan kecepatan kilat,
memfilter baris, mengubah kolom, dan melakukan analisis mendalam, semuanya dengan
beberapa baris kode.

Mari kita ciptakan DataFrame sederhana:

df = pd.DataFrame({
'Nama': ['Ali', 'Budi', 'Citra', 'Dewi'],
'Usia': [25, 30, 35, 40],
'Kota': ['Jakarta', 'Bandung', 'Surabaya', 'Yogyakarta']
})

df
Output:
Apa yang kamu lihat sekarang adalah tabel dengan baris dan kolom. Kolom Nama, Usia, dan
Kota merupakan Series. Dan ketika kamu menggabungkan beberapa Series, kamu
mendapatkan DataFrame.

Mengapa Struktur Data ini Penting?

Bayangkan Series dan DataFrame sebagai blok bangunan. Mereka adalah dasar dari banyak
operasi yang akan kamu lakukan dengan Pandas. Memahami keduanya sama pentingnya
dengan memahami dasar-dasar bahasa ketika belajar berbicara.

Ketika berhadapan dengan data - apakah itu data penjualan, data cuaca, atau data media
sosial - kamu sering kali perlu memutuskan bagaimana cara terbaik untuk menyimpannya.
Apakah sebuah Series sudah cukup, atau apakah kamu memerlukan DataFrame yang lebih
kompleks? Keputusan ini akan mempengaruhi langkah-langkahmu selanjutnya.

Misalkan kamu memiliki daftar harga saham perusahaan tertentu selama satu bulan.
Sebuah Series mungkin sudah cukup. Tapi bagaimana jika kamu memiliki data saham dari
sepuluh perusahaan berbeda, lengkap dengan tanggal, harga pembukaan, harga
penutupan, volume perdagangan, dan lainnya? Di sinilah DataFrame masuk, memberimu
kekuatan untuk menyimpan, mengakses, dan memanipulasi data dengan cara yang belum
pernah kamu alami sebelumnya.

2.3 Pembuatan Series dan DataFrame

Pandas adalah library Python yang memudahkan kita dalam melakukan manipulasi dan
analisis data. Ada dua struktur data utama yang ditawarkan oleh Pandas, yaitu Series dan
DataFrame. Mari kita pelajari bagaimana cara membuat kedua struktur data ini.

Series

Series adalah array satu dimensi yang dapat menyimpan data dari berbagai tipe seperti
integer, float, string, dll. Series memiliki label pada tiap itemnya, yang dikenal sebagai
index.

Cara Membuat Series:

import pandas as pd

s = pd.Series(data, index=index)

Di mana data bisa berupa list, array, atau dictionary, dan index adalah label untuk tiap item.

Contoh Pembuatan Series:

Mari kita coba membuat Series dari list.
import pandas as pd

# Membuat Series dari list

data_list = [1, 2, 3, 4, 5]
ser_from_list = pd.Series(data_list)

ser_from_list
Output:

Seperti yang kamu lihat di atas, kita telah berhasil membuat Series dari list. Label dari
setiap item dalam Series (disebut juga sebagai index) secara default adalah angka yang
dimulai dari 0. Namun, kita bisa menentukan label sendiri jika kita mau.

Contoh Membuat Series dengan Label Kustom:

Kita akan mencoba membuat Series dengan label kustom.

# Membuat Series dengan label kustom
index_custom = ['a', 'b', 'c', 'd', 'e']
ser_with_custom_index = pd.Series(data_list, index=index_custom)

ser_with_custom_index
Output:

Keren, kan? Dengan menentukan label sendiri, kita bisa membuat Series yang lebih
deskriptif.

Selain dari list, kita juga bisa membuat Series dari dictionary. Ketika membuat Series dari
dictionary, kunci dari dictionary akan menjadi index dari Series.

Contoh Membuat Series dari Dictionary:

# Membuat Series dari dictionary
 data_dict = {
'a': 10,
'b': 20,
'c': 30,
'd': 40,
'e': 50
}
ser_from_dict = pd.Series(data_dict)

ser_from_dict
Output:

Bagaimana? Mudah sekali, bukan? Dengan dictionary, kita bisa dengan mudah menentukan
pasangan nilai dan label untuk Series.

Series dengan Data Tipe yang Berbeda

Walaupun jarang ditemui, kamu bisa membuat Series yang berisi tipe data yang berbeda.
Contohnya, angka dan teks dalam satu Series. Namun, kamu harus berhati-hati saat
melakukannya karena bisa mempengaruhi operasi lain yang kamu lakukan pada Series
tersebut.

Contoh Pembuatan Series dengan Tipe Data yang Berbeda:

# Membuat Series dengan tipe data yang berbeda
mixed_data = [1, 'dua', 3.0, 'empat', 5]
ser_mixed_data = pd.Series(mixed_data)

ser_mixed_data
Output:

Seperti yang kamu lihat, meskipun kita memasukkan data dengan tipe yang berbeda
(integer, float, dan string), tipe data dari Series keseluruhannya menjadi object. Ini
menunjukkan bahwa semua elemen dianggap sebagai objek, yang memungkinkan kita
untuk menyimpan data dengan tipe yang berbeda.

Sekarang, mari beralih ke struktur data yang lebih kompleks di Pandas: DataFrame.

DataFrame

DataFrame adalah struktur data dua dimensi yang mirip dengan tabel. Ia memiliki baris dan
kolom, dan setiap kolom bisa memiliki tipe data yang berbeda. DataFrame sangat berguna
untuk menyimpan dan mengelola data dalam format tabel.

Cara Membuat DataFrame:

df = pd.DataFrame(data, columns=column_names)

Di mana data bisa berupa list dari list, array dari array, atau dictionary, dan column_names
adalah nama kolom untuk DataFrame.

Contoh Pembuatan DataFrame dari List dari List:

# Membuat DataFrame dari list dari list
data_list_of_list = [
[1, 'Ali', 23],
[2, 'Budi', 25],
[3, 'Citra', 22],
[4, 'Dodi', 24],
[5, 'Euis', 23]
]

columns = ['ID', 'Nama', 'Usia']

df_from_list_of_list = pd.DataFrame(data_list_of_list, columns=columns)

df_from_list_of_list
Output:
Seperti yang kamu lihat, DataFrame memungkinkan kita untuk menyimpan data dalam
format tabel dengan baris dan kolom. Dalam contoh di atas, kita membuat DataFrame dari
list dari list.

Namun, sering kali kita juga ingin membuat DataFrame dari dictionary. Ketika kita
membuat DataFrame dari dictionary, kuncinya akan menjadi nama kolom.

Contoh Membuat DataFrame dari Dictionary:

# Membuat DataFrame dari dictionary
data_dict_for_df = {
'ID': [1, 2, 3, 4, 5],
'Nama': ['Ali', 'Budi', 'Citra', 'Dodi', 'Euis'],
'Usia': [23, 25, 22, 24, 23]
}

df_from_dict = pd.DataFrame(data_dict_for_df)

df_from_dict
Output:

Taraa! Kamu telah berhasil membuat DataFrame dari dictionary. Dengan menggunakan
dictionary, kita dapat dengan mudah menentukan kolom dan data yang diinginkan.

DataFrame dengan Kolom Bertipe Data Berbeda

Salah satu kelebihan DataFrame adalah kemampuannya untuk menyimpan kolom dengan
tipe data yang berbeda. Misalnya, kolom pertama bisa berisi integer, kolom kedua berisi
teks, dan kolom ketiga berisi float.

Contoh Pembuatan DataFrame dengan Kolom Bertipe Data Berbeda:

# Membuat DataFrame dengan kolom bertipe data berbeda
data_mixed_columns = {
'ID': [1, 2, 3],
'Nama': ['Ali', 'Budi', 'Citra'],
'Rata-rata Nilai': [85.5, 90.3, 88.8]
}
 df_mixed_columns = pd.DataFrame(data_mixed_columns)

df_mixed_columns
Output:

Kamu bisa melihat bahwa DataFrame kita memiliki tiga kolom dengan tipe data yang
berbeda: integer untuk 'ID', string untuk 'Nama', dan float untuk 'Rata-rata Nilai'.
Membuat DataFrame dari Series
Kadang, kamu mungkin memiliki beberapa Series yang ingin kamu gabungkan menjadi
satu DataFrame. Kamu bisa melakukan ini dengan mudah di Pandas.

Contoh Membuat DataFrame dari Beberapa Series:

# Membuat DataFrame dari beberapa Series
series_1 = pd.Series([1, 2, 3], name="ID")
series_2 = pd.Series(['Ali', 'Budi', 'Citra'], name="Nama")
series_3 = pd.Series([23, 25, 22], name="Usia")

df_from_series = pd.DataFrame([series_1, series_2, series_3]).T #

Menggunakan transpose (.T) untuk mengubah baris menjadi kolom

df_from_series
Output:

Dalam contoh di atas, kita membuat tiga Series yang berbeda dan menggabungkannya
menjadi satu DataFrame. Perhatikan penggunaan .T untuk mengubah baris menjadi kolom.
2.4 Menampilkan Informasi Dasar DataFrame
Setelah kamu berhasil membuat DataFrame, langkah selanjutnya yang sering dilakukan
adalah mengeksplorasi dan memahami informasi dasar dari DataFrame tersebut. Dengan
mengetahui informasi dasar, kamu bisa mendapatkan gambaran awal tentang data yang
kamu miliki dan menentukan langkah analisis selanjutnya.

Menggunakan .head() dan .tail()

Ketika bekerja dengan DataFrame yang besar, kamu mungkin tidak ingin menampilkan
seluruh data sekaligus. Untuk itu, kamu bisa menggunakan .head() untuk menampilkan
beberapa baris pertama dan .tail() untuk menampilkan beberapa baris terakhir.

Contoh:

Mari kita buat DataFrame sintetis untuk demonstrasi.

# Membuat DataFrame sintetis
data = {
'A': np.random.randint(1, 100, 20),
'B': np.random.randint(1, 100, 20),
'C': np.random.randint(1, 100, 20),
'D': np.random.randint(1, 100, 20)
}
df_sample = pd.DataFrame(data)

# Menampilkan 5 baris pertama

df_sample.head()
Output:

Dalam contoh di atas, dengan menggunakan .head(), kita dapat menampilkan 5 baris
pertama dari DataFrame df_sample. Jika kamu ingin menampilkan lebih atau kurang dari 5
baris, kamu bisa memberikan angka spesifik ke dalam fungsi .head(). Misalnya, .head(3)
akan menampilkan 3 baris pertama.

Sekarang, mari kita lihat bagaimana cara menggunakan .tail() untuk menampilkan 5 baris
terakhir dari DataFrame.
# Menampilkan 5 baris terakhir
 df_sample.tail()
Output:

Dengan .tail(), kita bisa melihat 5 baris terakhir dari DataFrame. Sama seperti .head(), kamu
juga bisa memberikan angka spesifik ke dalam .tail() untuk menentukan jumlah baris yang
ingin ditampilkan.

Menggunakan .info()

Ketika kamu ingin mengetahui informasi struktural dari DataFrame, seperti jumlah baris,
jumlah kolom, tipe data dari setiap kolom, dan memori yang digunakan, kamu bisa
menggunakan metode .info().

Contoh Penggunaan .info():

# Menampilkan informasi struktural dari DataFrame
df_sample.info()
Output:

Dari output .info(), kita dapat melihat informasi berikut:

DataFrame memiliki 20 baris, yang diindeks dari 0 hingga 19.

Ada 4 kolom di DataFrame dengan tipe data int64.
Semua kolom memiliki 20 data yang non-null (tidak ada data yang hilang).
Memori yang digunakan oleh DataFrame adalah sekitar 768.0 bytes.
Menggunakan .describe()

Jika kamu ingin mengetahui statistik deskriptif dari kolom numerik di DataFrame, seperti
mean, median, standar deviasi, nilai minimum, dan maksimum, kamu bisa menggunakan
metode .describe().

Contoh Penggunaan .describe():

# Menampilkan statistik deskriptif dari DataFrame
df_sample.describe()
Output:

Dari hasil .describe(), kita mendapatkan statistik deskriptif berikut untuk setiap kolom:

1. count: Jumlah data pada kolom.

2. mean: Rata-rata dari data.
3. std: Standar deviasi (penyebaran data).
4. min: Nilai minimum.
5. 25%: Kuartil pertama (25 persen data berada di bawah nilai ini).
6. 50%: Median atau kuartil kedua.
7. 75%: Kuartil ketiga (75 persen data berada di bawah nilai ini).
8. max: Nilai maksimum.

Mengidentifikasi Data yang Hilang dengan .isna() dan .notna()

Dalam analisis data, seringkali kamu akan menemukan data yang hilang atau yang biasa
disebut dengan missing values. Pandas menyediakan metode untuk mendeteksi data yang
hilang: .isna() untuk mengecek data yang hilang dan .notna() untuk mengecek data yang
tidak hilang.

Contoh Penggunaan .isna() dan .notna():

Pertama, mari kita buat DataFrame dengan beberapa data yang hilang.
 # Membuat DataFrame dengan beberapa data yang hilang
data_missing = {
'A': [1, 2, np.nan, 4, 5],
'B': [np.nan, 2, 3, 4, 5],
'C': [1, 2, 3, 4, np.nan]
}
df_missing = pd.DataFrame(data_missing)

# Menampilkan DataFrame
df_missing
Output:

Kini kita memiliki DataFrame df_missing dengan beberapa data yang hilang. Mari kita
gunakan .isna() untuk mendeteksi data yang hilang dan .notna() untuk mendeteksi data
yang tidak hilang.
# Mendeteksi data yang hilang menggunakan .isna()
is_na = df_missing.isna()

# Mendeteksi data yang tidak hilang menggunakan .notna()

not_na = df_missing.notna()

is_na, not_na
Output:

Dari output di atas, kamu bisa melihat bahwa:

.isna() menghasilkan DataFrame dengan nilai True untuk data yang hilang dan False untuk
data yang tidak hilang.
.notna() menghasilkan DataFrame dengan nilai False untuk data yang hilang dan True
untuk data yang tidak hilang.
Dengan informasi ini, kamu dapat dengan mudah mengidentifikasi dan menghitung jumlah
data yang hilang dalam DataFrame kamu.

Menghitung Data yang Hilang

Untuk menghitung jumlah data yang hilang dalam DataFrame, kamu dapat menggabungkan
.isna() dengan metode .sum().

Contoh Menghitung Jumlah Data yang Hilang:

# Menghitung jumlah data yang hilang untuk setiap kolom
missing_count = df_missing.isna().sum()

missing_count
Output:

Hasil di atas menunjukkan bahwa setiap kolom dalam df_missing memiliki satu data yang
hilang.

Menggunakan .value_counts()

Metode .value_counts() memungkinkan kamu untuk dengan cepat mendapatkan distribusi

frekuensi dari setiap nilai unik dalam Series. Ini sangat berguna untuk memahami
distribusi data kategorikal.

Contoh Penggunaan .value_counts():

# Membuat Series dengan data kategorikal
ser_categorical = pd.Series(['apple', 'banana', 'apple', 'orange',
'banana', 'apple', 'apple', 'orange'])

# Mendapatkan distribusi frekuensi

value_counts = ser_categorical.value_counts()

value_counts
Output:
Dari hasil di atas, kamu bisa melihat distribusi frekuensi dari setiap buah dalam
ser_categorical. Terdapat 4 apple, 2 banana, dan 2 orange.

Menggunakan .nunique() dan .unique()

Ketika kamu bekerja dengan data, terkadang kamu mungkin ingin tahu berapa banyak nilai
unik yang ada dalam sebuah kolom, atau apa saja nilai unik tersebut. Pandas menyediakan
dua metode yang berguna untuk ini: .nunique() untuk menghitung jumlah nilai unik dan
.unique() untuk menampilkan nilai unik tersebut.

Contoh Penggunaan .nunique() dan .unique():

# Menggunakan .nunique() untuk menghitung jumlah nilai unik
unique_count = ser_categorical.nunique()

# Menggunakan .unique() untuk menampilkan nilai unik

unique_values = ser_categorical.unique()

unique_count, unique_values
Output:

Dari hasil di atas, kita dapat melihat bahwa ada 3 jenis buah yang unik dalam
ser_categorical, yaitu apple, banana, dan orange.

Menggunakan .dtypes

Ketika kamu bekerja dengan DataFrame yang memiliki banyak kolom dengan tipe data yang
berbeda, kamu mungkin ingin mengetahui tipe data dari setiap kolom. Kamu bisa
menggunakan atribut .dtypes untuk mendapatkan tipe data dari setiap kolom.

Contoh Penggunaan .dtypes:

# Membuat DataFrame sintetis lagi
data_sample = {
'A': np.random.randint(1, 100, 10),
'B': np.random.random(10),
'C': ['apple', 'banana', 'cherry', 'date', 'fig', 'grape', 'apple',
'banana', 'date', 'fig'],
'D': pd.date_range("20230101", periods=10)
}
df_sample = pd.DataFrame(data_sample)

# Mendapatkan tipe data dari setiap kolom

data_types = df_sample.dtypes
 data_types

Output:

Dari hasil di atas, kita dapat melihat tipe data dari setiap kolom dalam df_sample. Kolom 'A'
memiliki tipe data int64, 'B' adalah float64, 'C' adalah object (yang biasanya berarti string
atau campuran tipe data lainnya), dan 'D' adalah datetime64[ns] yang menunjukkan data
tanggal dan waktu.

Memeriksa Ukuran DataFrame dengan .shape

Kadang kamu mungkin ingin tahu berapa banyak baris dan kolom yang ada dalam
DataFrame. Untuk itu, kamu bisa menggunakan atribut .shape.

Contoh Penggunaan .shape:

# Mendapatkan ukuran df_sample
df_shape = df_sample.shape

df_shape
Output:

Dari hasil di atas, kita dapat melihat bahwa df_sample memiliki 10 baris dan 4 kolom.

Menggunakan .columns dan .index

Ketika bekerja dengan DataFrame, terkadang kamu ingin tahu apa saja nama kolom dan
indeks yang ada. Untuk itu, kamu bisa menggunakan atribut .columns dan .index.

Contoh Penggunaan .columns dan .index:

# Mendapatkan nama kolom dan indeks dari df_sample
df_columns = df_sample.columns
df_index = df_sample.index

df_columns, df_index
Output:
Dari hasil di atas, kita dapat melihat bahwa df_sample memiliki kolom dengan nama 'A', 'B',
'C', dan 'D'. Untuk indeks, DataFrame kita menggunakan RangeIndex yang dimulai dari 0
hingga 9 (total 10 baris).

Menggunakan .memory_usage()

Ketika bekerja dengan dataset yang sangat besar, kamu mungkin ingin tahu berapa banyak
memori yang digunakan oleh DataFrame atau kolom tertentu. Kamu bisa menggunakan
metode .memory_usage() untuk mendapatkan informasi ini.

Contoh Penggunaan .memory_usage():

# Mendapatkan penggunaan memori dari df_sample
memory_usage = df_sample.memory_usage()

memory_usage
Output:

Dari hasil di atas, kita dapat melihat penggunaan memori untuk setiap komponen dalam
df_sample. Kolom 'A', 'B', 'C', dan 'D' masing-masing menggunakan 80 bytes. Sementara itu,
indeks menggunakan 128 bytes.

Menggunakan .transpose() atau .T

Terkadang, terutama saat bekerja dengan DataFrame yang memiliki lebih banyak baris
daripada kolom, kamu mungkin ingin menukar baris dan kolom. Kamu bisa menggunakan
metode .transpose() atau atribut .T yang lebih singkat untuk melakukan ini.

Contoh Penggunaan .T:

# Melakukan transpose pada df_sample
df_transposed = df_sample.head(3).T # Ambil hanya 3 baris pertama untuk
kejelasan

df_transposed
Output:
2.5 Mengakses Data dalam Series dan DataFrame
Setelah kamu memahami dasar-dasar pembuatan dan informasi dari Series dan DataFrame,
langkah selanjutnya adalah bagaimana cara mengakses data yang ada di dalamnya. Dalam
bab ini, kita akan membahas berbagai cara untuk mengakses data, mulai dari pengaksesan
elemen sederhana hingga pengaksesan data yang lebih kompleks.

Mengakses Elemen di Series

Mengakses elemen di Series mirip dengan mengakses elemen di dalam list Python. Kamu
bisa menggunakan indeks untuk mengakses elemen tertentu.

Contoh Pengaksesan Elemen di Series:

# Membuat Series contoh
ser_example = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd',
'e'])

# Mengakses elemen dengan indeks posisi

element_pos = ser_example[2]

# Mengakses elemen dengan indeks label

element_label = ser_example['c']

element_pos, element_label
Output:

Dalam contoh di atas, kita membuat Series ser_example dengan indeks label 'a' hingga 'e'.
Kamu bisa melihat bahwa:
1. Mengakses elemen dengan indeks posisi (dalam hal ini posisi ke-2, dimulai dari 0)
menghasilkan nilai 30.
2. Mengakses elemen dengan indeks label (dalam hal ini label 'c') juga menghasilkan
nilai 30.
3. Mengakses Kolom dan Baris di DataFrame
 4. Mengakses data di DataFrame sedikit lebih kompleks dibandingkan dengan Series
karena memiliki dua dimensi: baris dan kolom.

Mengakses Kolom di DataFrame

Kamu bisa mengakses kolom DataFrame dengan cara yang mirip dengan mengakses key di
dictionary Python.

Contoh Pengaksesan Kolom di DataFrame:

# Membuat DataFrame contoh
data_example = {
'A': [1, 2, 3, 4, 5],
'B': ['apple', 'banana', 'cherry', 'date', 'fig'],
'C': [1.1, 2.2, 3.3, 4.4, 5.5]
}
df_example = pd.DataFrame(data_example)

# Mengakses kolom 'A'

column_A = df_example['A']

# Mengakses kolom 'B'

column_B = df_example['B']

column_A.head(), column_B.head() # Menampilkan beberapa elemen pertama

untuk kejelasan
Output:

Dari contoh di atas, kita dapat melihat bahwa:

Mengakses kolom 'A' dari df_example menghasilkan Series dengan tipe data int64.
Mengakses kolom 'B' menghasilkan Series dengan tipe data object (yang biasanya
menandakan data string).
Mengakses Baris di DataFrame dengan .loc[] dan .iloc[]

Untuk mengakses baris di DataFrame, kamu dapat menggunakan .loc[] untuk pengaksesan
berdasarkan label dan .iloc[] untuk pengaksesan berdasarkan posisi.

Contoh Pengaksesan Baris di DataFrame:

# Mengakses baris ke-2 dengan .iloc[]
row_by_position = df_example.iloc[2]

# Mengakses baris dengan indeks label 2 dengan .loc[]

row_by_label = df_example.loc[2]

row_by_position, row_by_label
Output:

Dari contoh di atas, kita dapat melihat bahwa:

Menggunakan .iloc[2] menghasilkan baris ke-3 dari df_example (ingat indeks dimulai dari
0).
Menggunakan .loc[2] juga menghasilkan baris yang sama karena, dalam contoh ini, label
indeksnya sesuai dengan posisi indeksnya.

Mengakses Subsets dari DataFrame

Terkadang, kamu mungkin ingin mengakses subset dari DataFrame, baik berupa baris dan
kolom tertentu. Kamu bisa melakukan ini dengan kombinasi .loc[] dan .iloc[].

Contoh Pengaksesan Subsets dari DataFrame:

# Mengakses subset berdasarkan baris dan kolom dengan .iloc[]
subset_position = df_example.iloc[1:4, 0:2]

# Mengakses subset berdasarkan label baris dan nama kolom dengan .loc[]
subset_label = df_example.loc[1:3, ['A', 'B']]

subset_position, subset_label
Output:
Dari contoh di atas, kita dapat melihat:

Dengan .iloc[1:4, 0:2], kita mengambil baris ke-2 hingga ke-4 dan kolom pertama hingga
kedua dari df_example.
Dengan .loc[1:3, ['A', 'B']], kita mendapatkan hasil yang sama, tetapi menggunakan label
indeks dan nama kolom sebagai referensi.

Pengaksesan Data Berdasarkan Kondisi

Salah satu keunggulan Pandas adalah kemampuannya untuk memfilter dan mengakses data
berdasarkan kondisi tertentu. Kamu bisa menggunakan operasi pembanding untuk
membuat mask boolean dan kemudian menggunakannya untuk memfilter data.

Contoh Pengaksesan Data Berdasarkan Kondisi:

# Mengakses baris di df_example di mana kolom 'A' lebih besar dari 3
filtered_rows = df_example[df_example['A'] > 3]

filtered_rows
Output:

Menggabungkan Beberapa Kondisi

Kamu juga dapat menggabungkan beberapa kondisi saat memfilter DataFrame. Misalnya,
kamu mungkin ingin menemukan semua baris di mana kolom 'A' lebih besar dari 3 dan
kolom 'C' kurang dari 5.

Contoh Menggabungkan Beberapa Kondisi:

# Mengakses baris di df_example berdasarkan beberapa kondisi
multiple_conditions = df_example[(df_example['A'] > 3) &
(df_example['C'] < 5)]
 multiple_conditions
Output:

Dalam contoh di atas, kita berhasil memfilter baris di df_example di mana nilai pada kolom
'A' lebih besar dari 3 dan kolom 'C' kurang dari 5.

Mengakses dengan Metode .at[] dan .iat[]

Jika kamu tahu posisi atau label baris dan kolom tertentu dan hanya ingin mengakses satu
sel data, kamu dapat menggunakan metode .at[] (berdasarkan label) dan .iat[] (berdasarkan
posisi).

Contoh Penggunaan .at[] dan .iat[]:

# Mengakses data dengan .at[]
data_at = df_example.at[2, 'B']

# Mengakses data dengan .iat[]

data_iat = df_example.iat[2, 1]

data_at, data_iat
Output:

Dalam contoh di atas, kita mengakses elemen di baris ke-3 (indeks 2) dan kolom kedua ('B').
Baik dengan .at[] maupun .iat[], kita mendapatkan hasil yang sama: 'cherry'.

Mengakses dengan Metode .xs()

Metode .xs() memungkinkan kamu untuk mengakses baris tertentu dari DataFrame
multi-indeks. Ini dapat sangat berguna ketika kamu bekerja dengan data yang memiliki
struktur indeks yang kompleks.

Contoh Penggunaan .xs():

Sebelum kita mencoba metode .xs(), mari kita buat DataFrame dengan multi-indeks sebagai
contoh.
# Membuat DataFrame dengan multi-indeks
arrays = [
['A', 'A', 'B', 'B'],
 [1, 2, 1, 2]
]
multi_index = pd.MultiIndex.from_arrays(arrays, names=('letters',
'numbers'))
data_multi = {
'data1': [10, 20, 30, 40],
'data2': [100, 200, 300, 400]
}
df_multi = pd.DataFrame(data_multi, index=multi_index)

# Menampilkan DataFrame dengan multi-indeks

df_multi
Output:

Kita memiliki DataFrame df_multi dengan multi-indeks berdasarkan kolom 'letters' dan
'numbers'. Sekarang, mari kita gunakan metode .xs() untuk mengakses data di dalamnya.

Ketika kamu ingin mengambil semua baris dengan level indeks tertentu, misalnya semua
baris dengan letters 'A', kamu dapat menggunakan metode .xs().
# Menggunakan .xs() untuk mengakses baris dengan letters 'A'
rows_with_A = df_multi.xs(key='A', level='letters')
rows_with_A
Output:

Dengan .xs(key='A', level='letters'), kita berhasil memilih semua baris yang memiliki level
indeks letters dengan nilai 'A'.
Metode .query()

Metode .query() memungkinkan kamu untuk mengakses data dengan menggunakan string
ekspresi yang mudah dibaca. Ini bisa menjadi alternatif yang lebih intuitif daripada operasi
pemfilteran tradisional.

Contoh Penggunaan .query():

df_query = df_multi.query('data1 > 15 & data2 < 350')
df_query
Output:

Dengan .query('data1 > 15 & data2 < 350'), kita berhasil memfilter baris di mana data1 lebih
dari 15 dan data2 kurang dari 350.

Menggunakan .take()

Metode .take() memungkinkan kamu untuk mengambil baris dari DataFrame atau Series
berdasarkan posisi indeks. Ini mirip dengan penggunaan .iloc[], tetapi dapat memberikan
lebih banyak fleksibilitas dalam beberapa skenario.

Contoh Penggunaan .take():

# Menggunakan .take() untuk mengambil baris ke-1 dan ke-3 dari
df_example
taken_rows = df_example.take([1, 3])
taken_rows
Output:

Dengan .take([1, 3]), kita berhasil mengambil baris ke-2 dan ke-4 dari df_example.

Metode .xs() sangat berguna ketika bekerja dengan DataFrame yang memiliki multi-indeks.
Metode .query() memungkinkan kamu untuk mengakses data dengan ekspresi string yang
mudah dibaca.
Metode .take() memberikan cara lain untuk mengakses baris berdasarkan posisi indeks.
2.6 Operasi Dasar pada DataFrame
Mengakses data adalah langkah awal, tetapi seringkali kamu perlu melakukan berbagai
operasi pada data tersebut untuk mendapatkan informasi yang kamu butuhkan. Dalam
subbab ini, kita akan membahas operasi dasar yang bisa kamu lakukan pada DataFrame.

Menambah Kolom Baru

Salah satu operasi yang sering dilakukan adalah menambahkan kolom baru ke DataFrame.
Kamu bisa menambahkan kolom baru dengan operasi aritmatika atau dengan menetapkan
nilai langsung.

Contoh Menambah Kolom Baru:

# Menambahkan kolom baru 'D' ke df_example dengan operasi aritmatika
df_example['D'] = df_example['A'] * 10

# Menambahkan kolom baru 'E' dengan nilai tetap

df_example['E'] = "new_column"

df_example.head()

Output:

Dalam contoh di atas, kita telah menambahkan dua kolom baru ke df_example:
1. Kolom 'D' merupakan hasil dari penggandaan setiap elemen di kolom 'A' dengan 10.
2. Kolom 'E' diisi dengan string "new_column" untuk setiap baris.

Menghapus Kolom dan Baris

Selain menambahkan, terkadang kamu juga perlu menghapus kolom atau baris tertentu
dari DataFrame. Kamu bisa menggunakan metode .drop() untuk melakukan ini.

Contoh Menghapus Kolom dan Baris:

# Menghapus kolom 'E'
df_example_dropped_col = df_example.drop(columns=['E'])
 # Menghapus baris dengan indeks 4
df_example_dropped_row = df_example.drop(index=4)

df_example_dropped_col.head(), df_example_dropped_row.head()
Output:

Dalam contoh di atas:

1. Kolom 'E' telah dihapus dari df_example_dropped_col.
2. Baris dengan indeks 4 (baris kelima) telah dihapus dari df_example_dropped_row.

Melakukan Operasi Aritmatika

DataFrame dan Series mendukung operasi aritmatika dasar. Kamu bisa melakukan operasi
seperti penjumlahan, pengurangan, perkalian, dan lainnya antara kolom, baris, atau
dengan skalar.

Contoh Operasi Aritmatika:

# Mengalikan setiap elemen di kolom 'A' dengan 5
df_example['A_times_five'] = df_example['A'] * 5

# Membagi setiap elemen di kolom 'C' dengan 2

df_example['C_divided_by_two'] = df_example['C'] / 2

df_example.head()
Output:
Dalam contoh di atas:
1. Setiap elemen di kolom 'A' dikalikan dengan 5 dan hasilnya disimpan di kolom baru
'A_times_five'.
2. Setiap elemen di kolom 'C' dibagi dengan 2 dan hasilnya disimpan di kolom baru
'C_divided_by_two'.

Menggunakan Fungsi .apply()

Metode .apply() memungkinkan kamu untuk menerapkan fungsi ke setiap elemen (atau
baris/kolom, tergantung pada pengaturan) dalam DataFrame atau Series. Ini sangat berguna
ketika kamu ingin melakukan transformasi data yang lebih kompleks.

Contoh Penggunaan .apply():

# Menerapkan fungsi lambda untuk mengubah string di kolom 'B' menjadi
kapital
df_example['B_upper'] = df_example['B'].apply(lambda x: x.upper())

df_example[['B', 'B_upper']].head()
Output:

Dalam contoh di atas, kita telah menerapkan fungsi lambda untuk mengubah setiap string
di kolom 'B' menjadi huruf kapital dan menyimpannya di kolom baru 'B_upper'.

Mengubah Indeks dengan .set_index() dan .reset_index()

Dalam banyak kasus, kamu mungkin ingin mengubah kolom tertentu menjadi indeks atau
mengembalikan indeks ke kolom biasa. Untuk melakukan ini, kamu dapat menggunakan
.set_index() dan .reset_index().

Contoh Menggunakan .set_index() dan .reset_index():

# Mengatur kolom 'B' sebagai indeks
df_set_index = df_example.set_index('B')

# Mereset indeks ke default (RangeIndex)

 df_reset_index = df_set_index.reset_index()

df_set_index.head(), df_reset_index.head()
Output:

Dalam contoh di atas:

1. Dengan .set_index('B'), kita mengatur kolom 'B' sebagai indeks untuk df_set_index.
2. Dengan .reset_index(), kita mengembalikan indeks ke default (yaitu, RangeIndex)
untuk df_reset_index dan kolom 'B' menjadi kolom biasa lagi.

Mengganti Nilai dengan .replace()

Kadang-kadang, kamu perlu mengganti nilai tertentu di DataFrame atau Series. Fungsi
.replace() memungkinkan kamu untuk dengan mudah melakukannya.

Contoh Menggunakan .replace():

# Mengganti nilai 'apple' di kolom 'B' dengan 'grape'
df_replaced = df_example.replace({'B': {'apple': 'grape'}})

df_replaced[['B']].head()
Output:

Dalam contoh di atas, kita telah menggantikan nilai 'apple' di kolom 'B' dengan 'grape'
menggunakan metode .replace().
Metode .rename()

Metode .rename() memungkinkan kamu untuk mengubah nama kolom atau indeks tanpa
perlu membuat salinan DataFrame.

Contoh Menggunakan .rename():

# Mengganti nama kolom 'A' menjadi 'X' dan 'B' menjadi 'Y'
df_renamed = df_example.rename(columns={'A': 'X', 'B': 'Y'})

df_renamed.head()
Output:

Dalam contoh di atas, kita telah mengganti nama kolom 'A' menjadi 'X' dan 'B' menjadi 'Y'
dengan metode .rename().

Menghitung Nilai Unik dengan .nunique() dan .value_counts()

Ketika menganalisis data, seringkali kamu ingin mengetahui berapa banyak nilai unik
dalam kolom atau berapa kali setiap nilai muncul. Untuk itu, kamu bisa menggunakan
.nunique() dan .value_counts().

Contoh Menggunakan .nunique() dan .value_counts():

# Menghitung jumlah nilai unik di kolom 'B'
unique_values = df_example['B'].nunique()

# Menghitung frekuensi masing-masing nilai di kolom 'B'

value_counts = df_example['B'].value_counts()

unique_values, value_counts
Output:
Dari contoh di atas:
1. Dengan .nunique(), kita menemukan bahwa kolom 'B' memiliki 5 nilai unik.
2. Dengan .value_counts(), kita melihat frekuensi masing-masing nilai di kolom 'B'.
Dalam hal ini, setiap buah muncul satu kali.

2.7 Indexing dan Slicing

Mengakses data dalam DataFrame atau Series adalah hal yang penting, dan seringkali kamu
hanya ingin mengambil sebagian dari data tersebut. Untuk melakukan hal ini, kamu bisa
menggunakan teknik indexing dan slicing.

Indeks Eksplisit vs Indeks Implisit

Sebelum kita masuk ke contoh, penting untuk memahami perbedaan antara indeks eksplisit
dan implisit.
1. Indeks Eksplisit: Ini adalah label yang kamu lihat, misalnya, sebagai hasil dari
df.index.
2. Indeks Implisit: Ini adalah posisi integer dari baris/kolom, dimulai dari 0. Ini mirip
dengan indeks dalam list di Python.

Slicing dengan .loc[] dan .iloc[]

Kita sudah menyentuh .loc[] dan .iloc[] sedikit di subbab sebelumnya, tetapi mari kita
jelajahi lebih dalam.
1. .loc[]: Digunakan untuk indeks berbasis label.
2. .iloc[]: Digunakan untuk indeks berbasis posisi integer.

Contoh Slicing dengan .loc[] dan .iloc[]:

# Membuat data sintetis
data = {
'A': [i for i in range(1, 11)],
'B': [chr(i) for i in range(65, 75)],
'C': [i*0.5 for i in range(1, 11)]
}
df_slicing = pd.DataFrame(data)

# Mengambil baris ke-2 hingga ke-5 dan kolom 'A' dan 'B' dengan .iloc[]
subset_iloc = df_slicing.iloc[1:5, 0:2]

# Mengambil baris dengan label indeks 1 hingga 4 dan kolom 'A' dan 'B'
dengan .loc[]
subset_loc = df_slicing.loc[1:4, ['A', 'B']]
 subset_iloc, subset_loc
Output:

Dalam contoh di atas:

1. Dengan .iloc[1:5, 0:2], kita mengambil baris ke-2 hingga ke-5 (perhatikan bahwa
indeks 5 tidak termasuk, mirip dengan slicing di Python) dan dua kolom pertama.
2. Dengan .loc[1:4, ['A', 'B']], kita mengambil baris dengan label indeks dari 1 hingga 4
(kali ini, termasuk indeks 4) dan kolom 'A' dan 'B'.

Mengakses Baris dengan Boolean Indexing

Seperti yang kita bahas sebelumnya, kamu juga bisa menggunakan boolean indexing untuk
mengakses baris berdasarkan kondisi tertentu.

Contoh Menggunakan Boolean Indexing:

# Mengambil baris di mana kolom 'A' lebih besar dari 5
rows_greater_than_5 = df_slicing[df_slicing['A'] > 5]

rows_greater_than_5
Output:

Dalam contoh di atas, kita mengambil semua baris di mana nilai di kolom 'A' lebih besar dari
5.
Menggunakan .isin()

Ketika kamu ingin memfilter data berdasarkan daftar nilai tertentu, metode .isin() bisa
sangat berguna.

Contoh Menggunakan .isin():

# Mengambil baris di mana kolom 'B' memiliki nilai 'A', 'C', atau 'E'
rows_selected_values = df_slicing[df_slicing['B'].isin(['A', 'C', 'E'])]

rows_selected_values
Output:

Dalam contoh di atas, kita telah memilih baris di mana kolom 'B' memiliki salah satu dari
nilai 'A', 'C', atau 'E'.

Mengatur Ulang Indeks dengan .reindex()

Ada kalanya kamu mungkin ingin mengatur ulang indeks DataFrame Anda, baik untuk
mengubah urutannya atau untuk menambahkan/menghapus beberapa indeks. Metode
.reindex() memungkinkan kamu untuk melakukan hal ini.

Contoh Menggunakan .reindex():

# Mengatur ulang indeks dengan menambahkan indeks yang tidak ada dan
menghapus beberapa yang ada
new_index = list(range(0, 12))
reindexed_df = df_slicing.reindex(new_index)

reindexed_df
Output:
Dalam contoh di atas:
1. Kita telah mengatur ulang indeks DataFrame df_slicing dengan daftar indeks baru
new_index.
2. Karena new_index mencakup indeks 10 dan 11 yang tidak ada di DataFrame asli,
baris baru dengan nilai NaN ditambahkan untuk indeks tersebut.

Mengakses Kolom dengan Atribut

Selain mengakses kolom dengan notasi kurung siku (df['kolom']), jika nama kolom adalah
string yang valid dan tidak bertabrakan dengan metode atau atribut DataFrame lainnya,
kamu dapat mengaksesnya sebagai atribut.

Contoh Mengakses Kolom dengan Atribut:

# Mengakses kolom 'A' sebagai atribut
column_A = df_slicing.A

column_A.head()
Output:

Dalam contoh di atas, kita mengakses kolom 'A' dari df_slicing sebagai atribut. Ini adalah
cara yang cepat dan ringkas untuk mengakses kolom, tetapi perlu diingat bahwa ini
mungkin tidak selalu berfungsi jika nama kolom bertabrakan dengan nama metode atau
atribut DataFrame lainnya.

Menggunakan .at[] dan .iat[] untuk Akses Cepat

Untuk akses cepat ke elemen tunggal, kamu bisa menggunakan .at[] (untuk label) dan .iat[]
(untuk posisi integer).

Contoh Menggunakan .at[] dan .iat[]:

# Mengakses elemen di baris label 2 dan kolom 'B' dengan .at[]
element_at = df_slicing.at[2, 'B']

# Mengakses elemen di baris posisi 2 dan kolom posisi 1 dengan .iat[]

element_iat = df_slicing.iat[2, 1]

element_at, element_iat
Output:

Dalam contoh di atas:

1. Dengan .at[2, 'B'], kita mengambil elemen di baris dengan label indeks 2 dan kolom
'B'.
2. Dengan .iat[2, 1], kita mendapatkan elemen yang sama berdasarkan posisi integer.

Menggunakan Slicing dengan Rentang Waktu

Jika DataFrame kamu memiliki kolom tanggal, kamu mungkin ingin memilih data
berdasarkan rentang waktu tertentu. Ini bisa dilakukan dengan mudah jika kamu memiliki
DateTimeIndex.

Contoh Slicing dengan Rentang Waktu:

import numpy as np

# Membuat DataFrame dengan DateTimeIndex

date_rng = pd.date_range(start='2020-01-01', end='2020-01-10', freq='D')
df_date = pd.DataFrame(date_rng, columns=['date'])
df_date['data'] = np.random.randint(0, 100, size=(len(date_rng)))

# Mengatur 'date' sebagai indeks

df_date = df_date.set_index('date')

# Mengambil data antara '2020-01-03' dan '2020-01-07'

subset_date = df_date['2020-01-03':'2020-01-07']
 subset_date
Output:

Dalam contoh di atas, kita telah:

1. Membuat DataFrame dengan DateTimeIndex dari '2020-01-01' hingga '2020-01-10'.
2. Mengatur kolom 'date' sebagai indeks.
3. Mengambil data antara '2020-01-03' dan '2020-01-07' dengan slicing.

Menggunakan .xs() untuk MultiIndex

Ketika kamu bekerja dengan DataFrame yang memiliki MultiIndex, metode .xs() bisa sangat
berguna untuk memilih data pada level indeks tertentu.

Contoh Menggunakan .xs() dengan MultiIndex:

# Membuat DataFrame dengan MultiIndex
arrays = [['A', 'A', 'B', 'B'], [1, 2, 1, 2]]
index = pd.MultiIndex.from_arrays(arrays, names=('letter', 'number'))
df_multi = pd.DataFrame({'data': [10, 20, 30, 40]}, index=index)

# Mengambil data dengan indeks 'A'

subset_multi = df_multi.xs('A', level='letter')

subset_multi
Output:

Dalam contoh di atas:

 1. Kita telah membuat DataFrame dengan MultiIndex yang terdiri dari kombinasi
huruf ('A' atau 'B') dan nomor (1 atau 2).
2. Menggunakan .xs('A', level='letter'), kita dapat dengan mudah mengambil semua data
yang memiliki indeks 'A' pada level 'letter'.

Menyaring dengan .where()

Metode .where() memungkinkan kamu untuk mengembalikan DataFrame dengan ukuran

yang sama dengan aslinya, tetapi dengan nilai yang tidak memenuhi kondisi digantikan
dengan NaN (atau nilai lain yang kamu tentukan).

Contoh Menggunakan .where():

# Mengambil data di kolom 'data' yang lebih besar dari 15, sisanya
digantikan dengan NaN
subset_where = df_date['data'].where(df_date['data'] > 15)

subset_where.head()
Output:

Dalam contoh di atas, kita menggunakan metode .where() untuk mengambil data dari
kolom 'data' yang nilainya lebih besar dari 15. Nilai yang tidak memenuhi kondisi tersebut
digantikan dengan NaN.

2.8 Menggunakan Fungsi Bawaan Pandas

Pandas menyediakan berbagai fungsi bawaan yang memungkinkan kamu untuk dengan
mudah memanipulasi dan menganalisis data. Dalam subbab ini, kita akan mempelajari
beberapa fungsi bawaan yang paling sering digunakan.

Statistik Deskriptif

Pandas menyediakan berbagai fungsi untuk mendapatkan statistik deskriptif dari data
kamu. Dengan fungsi-fungsi ini, kamu dapat dengan cepat memahami distribusi dan
tendensi data kamu.

Contoh Menggunakan Statistik Deskriptif:

 # Membuat DataFrame dengan data sintetis
np.random.seed(42) # Menetapkan seed agar hasilnya konsisten
df_stats = pd.DataFrame({
'A': np.random.randn(100),
'B': np.random.randint(1, 10, 100),
'C': np.random.choice(['pencil', 'pen', 'eraser'], 100)
})

# Menggunakan beberapa fungsi statistik deskriptif

mean_A = df_stats['A'].mean()
median_B = df_stats['B'].median()
mode_C = df_stats['C'].mode()

mean_A, median_B, mode_C

Output:

Dalam contoh di atas:

1. Kita menggunakan .mean() untuk menghitung rata-rata dari kolom 'A'.
2. Kita menggunakan .median() untuk menemukan median dari kolom 'B'.
3. Kita menggunakan .mode() untuk menemukan modus dari kolom 'C', yang dalam hal
ini adalah 'pencil'.

Fungsi Agregasi dengan .agg()

Metode .agg() memungkinkan kamu untuk menjalankan beberapa operasi agregasi secara
bersamaan, yang bisa sangat berguna untuk mendapatkan ringkasan cepat dari data kamu.

Contoh Menggunakan .agg():

# Menggunakan .agg() untuk mendapatkan beberapa statistik sekaligus
aggregated = df_stats.agg({
'A': ['mean', 'std', 'min', 'max'],
'B': ['sum', 'median']
})

aggregated
Output:
Dalam contoh di atas:
1. Kita telah menggunakan .agg() untuk mendapatkan beberapa statistik dari kolom 'A'
dan 'B' sekaligus. Untuk kolom 'A', kita mendapatkan rata-rata, deviasi standar, nilai
minimum, dan maksimum. Untuk kolom 'B', kita mendapatkan jumlah total dan
median.

Menggunakan .apply()

Meskipun Pandas menyediakan banyak fungsi bawaan, terkadang kamu mungkin perlu
menerapkan fungsi khusus ke baris atau kolom. Di sinilah .apply() menjadi sangat berguna.

Contoh Menggunakan .apply():

# Menggunakan .apply() untuk menghitung panjang string di kolom 'C'
df_stats['length_C'] = df_stats['C'].apply(len)

df_stats[['C', 'length_C']].head()
Output:

Dalam contoh di atas:

1. Kita telah menggunakan .apply() untuk menerapkan fungsi len ke setiap item di
kolom 'C' untuk menghitung panjang string. Hasilnya disimpan dalam kolom baru,
'length_C'.
Menggunakan .map() untuk Series

Sementara .apply() bekerja pada DataFrame dan Series, metode .map() adalah metode yang
khusus untuk Series dan memungkinkan kamu untuk menggantikan setiap nilai di Series
berdasarkan input mapping.

Contoh Menggunakan .map():

# Menggunakan .map() untuk menggantikan nilai di kolom 'C'
replacement = {
'pencil': 'PCL',
'pen': 'PN',
'eraser': 'ERS'
}
df_stats['short_C'] = df_stats['C'].map(replacement)

df_stats[['C', 'short_C']].head()
Output:

Dalam contoh di atas:

1. Kita telah menggunakan .map() untuk menggantikan setiap nilai di kolom 'C'
berdasarkan kamus replacement. Hasilnya disimpan dalam kolom baru, 'short_C'.

Menghitung Nilai yang Hilang dengan .isna() dan .notna()

Data yang hilang adalah hal yang umum dalam analisis data. Pandas menyediakan metode
untuk dengan mudah mengidentifikasi dan menghitung nilai yang hilang.

Contoh Menggunakan .isna() dan .notna():

# Menambahkan beberapa nilai NaN ke df_stats untuk demonstrasi
df_stats.iloc[2:5, 1] = np.nan

# Mengidentifikasi baris di mana kolom 'B' memiliki nilai NaN

missing_values = df_stats['B'].isna()

# Mengidentifikasi baris di mana kolom 'B' tidak memiliki nilai NaN

not_missing_values = df_stats['B'].notna()
 missing_values.head(), not_missing_values.head()
Output:

Dalam contoh di atas:

1. Kita telah menambahkan beberapa nilai NaN ke kolom 'B' dari df_stats untuk
demonstrasi.
2. Dengan .isna(), kita dapat dengan cepat mengidentifikasi baris di mana kolom 'B'
memiliki nilai NaN.
3. Dengan .notna(), kita mengidentifikasi baris di mana kolom 'B' TIDAK memiliki nilai
NaN.

Menggantikan Nilai dengan .replace()

Kadang-kadang, kamu mungkin ingin menggantikan nilai tertentu di DataFrame atau

Series. Metode .replace() memudahkan penggantian nilai.

Contoh Menggunakan .replace():

# Menggantikan nilai 'PCL' di kolom 'short_C' dengan 'pencil'
df_stats['short_C_replaced'] = df_stats['short_C'].replace('PCL',
'pencil')

df_stats[['short_C', 'short_C_replaced']].head()
Output:

Dalam contoh di atas:

 1. Kita telah menggunakan .replace() untuk menggantikan semua kemunculan 'PCL' di
kolom 'short_C' dengan 'pencil'.

Menggabungkan Metode dengan Method Chaining

Salah satu keunggulan Pandas adalah kemampuannya untuk menggabungkan metode

secara berurutan dalam satu baris kode, yang dikenal sebagai method chaining. Ini
memungkinkan kamu untuk menulis kode yang lebih ringkas dan seringkali lebih mudah
dibaca.

Contoh Menggunakan Method Chaining:

# Menggabungkan metode untuk menghitung rata-rata dari kolom 'A' untuk
baris di mana kolom 'B' tidak NaN
average_A_notna = df_stats[df_stats['B'].notna()]['A'].mean()

average_A_notna
Output:

Dalam contoh di atas:

1. Kita telah menggunakan method chaining untuk memilih baris di mana kolom 'B'
tidak memiliki nilai NaN dan kemudian menghitung rata-rata dari kolom 'A' untuk
baris-baris tersebut.

2.9 Menggabungkan DataFrame

Ketika bekerja dengan data, seringkali kamu akan memiliki informasi yang tersebar di
beberapa sumber atau dataset. Dalam situasi seperti itu, menggabungkan data dari berbagai
sumber menjadi satu DataFrame kohesif adalah salah satu tugas penting yang perlu kamu
lakukan. Pandas menyediakan beberapa metode untuk membantu kamu dalam proses ini.

Menggabungkan dengan .concat()

Metode .concat() memungkinkan kamu untuk menggabungkan DataFrame atau Series

sepanjang sumbu tertentu (baris atau kolom).

Contoh Menggunakan .concat():

# Membuat dua DataFrame sintetis
df1 = pd.DataFrame({
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
 'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']
})

df2 = pd.DataFrame({
'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D4', 'D5', 'D6', 'D7']
})

# Menggabungkan df1 dan df2

concatenated = pd.concat([df1, df2])

concatenated
Output:

Dalam contoh di atas:

1. Kita telah membuat dua DataFrame sintetis, df1 dan df2.
2. Menggunakan pd.concat([df1, df2]), kita menggabungkan kedua DataFrame tersebut
sepanjang sumbu baris (yang merupakan default). Perhatikan bagaimana indeks
dari kedua DataFrame tetap tidak berubah dalam hasilnya.

Menggabungkan dengan .merge()

Metode .merge() memungkinkan kamu untuk menggabungkan data berdasarkan kolom

tertentu, mirip dengan operasi JOIN di SQL.

Contoh Menggunakan .merge():

# Membuat dua DataFrame sintetis untuk demonstrasi .merge()
df_left = pd.DataFrame({
'key': ['K0', 'K1', 'K2', 'K3'],
 'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']
})

df_right = pd.DataFrame({
'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']
})

# Menggabungkan df_left dan df_right berdasarkan kolom 'key'

merged = df_left.merge(df_right, on='key')

merged
Output:

Dalam contoh di atas:

1. Kita telah membuat dua DataFrame sintetis, df_left dan df_right, yang memiliki
kolom 'key' yang sama.
2. Dengan menggunakan df_left.merge(df_right, on='key'), kita menggabungkan kedua
DataFrame berdasarkan kolom 'key'. Hasilnya adalah DataFrame baru di mana setiap
baris dari df_left dan df_right yang memiliki nilai 'key' yang sama digabungkan
menjadi satu baris.

Menggunakan .join()

Metode .join() memungkinkan kamu untuk menggabungkan kolom dari satu atau lebih
DataFrame berdasarkan indeks.

Contoh Menggunakan .join():

# Membuat dua DataFrame sintetis untuk demonstrasi .join()
df_left_join = pd.DataFrame({
'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']
}, index=['K0', 'K1', 'K2'])

df_right_join = pd.DataFrame({
 'C': ['C0', 'C1', 'C2'],
'D': ['D0', 'D1', 'D2']
}, index=['K0', 'K2', 'K3'])

# Menggabungkan df_left_join dan df_right_join berdasarkan indeks

joined = df_left_join.join(df_right_join, how='outer')

joined
Output:

Dalam contoh di atas:

1. Kita telah membuat dua DataFrame sintetis, df_left_join dan df_right_join, yang
memiliki indeks beberapa yang sama dan beberapa yang berbeda.
2. Dengan menggunakan df_left_join.join(df_right_join, how='outer'), kita
menggabungkan kedua DataFrame berdasarkan indeks mereka. Kita menggunakan
argumen how='outer' untuk memastikan bahwa semua indeks dari kedua DataFrame
termasuk dalam hasilnya. Jika ada indeks yang tidak ada di salah satu DataFrame,
nilai kolom untuk indeks tersebut akan menjadi NaN.

Menggabungkan Secara Horizontal dengan .concat()

Sejauh ini, kita telah melihat bagaimana menggabungkan DataFrame secara vertikal dengan
.concat(). Namun, metode ini juga bisa digunakan untuk menggabungkan DataFrame secara
horizontal.

Contoh Menggabungkan Secara Horizontal:

# Menggabungkan df1 dan df2 secara horizontal
horizontal_concat = pd.concat([df1, df2], axis=1)

horizontal_concat.head()
Output:
Dalam contoh di atas:
1. Kita telah menggunakan pd.concat([df1, df2], axis=1) untuk menggabungkan df1 dan
df2 secara horizontal. Argumen axis=1 mengindikasikan bahwa penggabungan
harus dilakukan secara horizontal (sepanjang kolom).

Menggabungkan dengan suffix dan prefix

Ketika menggabungkan DataFrame, kamu mungkin menemui situasi di mana kedua

DataFrame memiliki nama kolom yang sama. Untuk mengatasi masalah ini, kamu dapat
menambahkan suffix atau prefix ke nama kolom.

Contoh Menggunakan suffix saat Penggabungan:

# Menggabungkan df_left dan df_right dengan suffix
merged_suffix = df_left.merge(df_right, on='key', suffixes=('_left',
'_right'))

merged_suffix.head()
Output:

Dalam contoh di atas:

1. Kita telah menggunakan df_left.merge(df_right, on='key', suffixes=('_left', '_right'))
untuk menggabungkan df_left dan df_right berdasarkan kolom 'key'. Karena kedua
DataFrame memiliki nama kolom yang sama ('A', 'B', 'C', dan 'D'), kita menambahkan
suffix ke nama kolom dengan argumen suffixes=('_left', '_right') untuk
membedakannya.

Menggabungkan dengan Indeks

Kadang-kadang, kamu mungkin ingin menggabungkan DataFrame berdasarkan indeksnya,

bukan kolom tertentu. Ini bisa dilakukan dengan .merge() dengan mengatur argumen
left_index dan/atau right_index menjadi True.

Contoh Menggabungkan berdasarkan Indeks:

# Menggabungkan df_left_join dan df_right_join berdasarkan indeks
merged_index = df_left_join.merge(df_right_join, left_index=True,
 right_index=True, suffixes=('_left', '_right'))

merged_index
Output:

Dalam contoh di atas:

1. Kita telah menggunakan df_left_join.merge(df_right_join, left_index=True,
right_index=True, suffixes=('_left', '_right')) untuk menggabungkan df_left_join dan
df_right_join berdasarkan indeks mereka. Kita juga menambahkan suffix untuk
membedakan kolom dengan nama yang sama.

Menggabungkan Menggunakan Beberapa Kolom

Kadang-kadang, kamu mungkin perlu menggabungkan DataFrame berdasarkan lebih dari

satu kolom. Ini dapat dicapai dengan memberikan daftar nama kolom ke argumen on dalam
metode .merge().

Contoh Menggabungkan Berdasarkan Beberapa Kolom:

# Membuat dua DataFrame sintetis untuk demonstrasi
df_left_multi = pd.DataFrame({
'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['L0', 'L1', 'L0', 'L1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']
})

df_right_multi = pd.DataFrame({
'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['L0', 'L0', 'L1', 'L1'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']
})

# Menggabungkan berdasarkan 'key1' dan 'key2'

merged_multi = df_left_multi.merge(df_right_multi, on=['key1', 'key2'])

merged_multi
Output:
Dalam contoh di atas:
1. Kita telah membuat dua DataFrame sintetis, df_left_multi dan df_right_multi, yang
memiliki kolom 'key1' dan 'key2'.

Dengan menggunakan df_left_multi.merge(df_right_multi, on=['key1', 'key2']), kita

menggabungkan kedua DataFrame berdasarkan kolom 'key1' dan 'key2'. Hasilnya adalah
DataFrame baru di mana setiap baris dari df_left_multi dan df_right_multi yang memiliki
nilai 'key1' dan 'key2' yang sama digabungkan menjadi satu baris.

Jenis Gabungan dengan .merge()

Pandas menyediakan berbagai jenis penggabungan yang dapat kamu gunakan sesuai
kebutuhan:
1. inner: Menggunakan irisan kunci dari kedua frame, ini adalah operasi gabungan
default.
2. outer: Menggunakan gabungan kunci dari kedua frame.
3. left: Menggunakan hanya kunci dari frame kiri.
4. right: Menggunakan hanya kunci dari frame kanan.
Contoh Jenis Gabungan:
# Menggabungkan dengan jenis gabungan 'outer'
merged_outer = df_left_multi.merge(df_right_multi, on=['key1', 'key2'],
how='outer')

merged_outer
Output:

Dalam contoh di atas:

1. Kita telah menggunakan df_left_multi.merge(df_right_multi, on=['key1', 'key2'],
how='outer') untuk menggabungkan kedua DataFrame dengan jenis gabungan 'outer'.
Dengan jenis gabungan ini, semua kunci yang ada di kedua DataFrame akan termasuk
dalam hasil gabungan. Jika ada kunci yang hanya ada di salah satu DataFrame, nilai kolom
untuk kunci tersebut akan menjadi NaN di DataFrame yang lain.

2.10 Mengurutkan Data

Mengurutkan data adalah salah satu operasi yang paling sering dilakukan dalam analisis
data. Dengan mengurutkan data, kamu dapat dengan mudah mengidentifikasi pola, tren,
atau anomali yang mungkin tidak segera terlihat dalam tampilan data yang acak. Pandas
menyediakan metode yang memudahkan pengurutan data dalam berbagai cara.

Mengurutkan Berdasarkan Indeks dengan .sort_index()

Jika kamu ingin mengurutkan DataFrame atau Series berdasarkan indeksnya, kamu dapat
menggunakan metode .sort_index().

Contoh Menggunakan .sort_index():

# Membuat DataFrame sintetis
df_unsorted_index = pd.DataFrame({
'A': [3, 1, 2],
'B': [33, 11, 22],
'C': ['C3', 'C1', 'C2']
}, index=['K2', 'K0', 'K1'])

# Mengurutkan berdasarkan indeks

df_sorted_index = df_unsorted_index.sort_index()

df_sorted_index
Output:

Dalam contoh di atas:

1. Kita telah membuat DataFrame sintetis, df_unsorted_index, dengan indeks yang
tidak terurut.
2. Dengan menggunakan df_unsorted_index.sort_index(), kita telah mengurutkan
DataFrame berdasarkan indeksnya.
Mengurutkan Berdasarkan Nilai dengan .sort_values()

Jika kamu ingin mengurutkan DataFrame atau Series berdasarkan nilai dari satu atau lebih
kolom, kamu dapat menggunakan metode .sort_values().

Contoh Menggunakan .sort_values():

# Mengurutkan berdasarkan kolom 'A'
df_sorted_values = df_unsorted_index.sort_values(by='A')

df_sorted_values
Output:

Dalam contoh di atas:

1. Dengan menggunakan df_unsorted_index.sort_values(by='A'), kita telah
mengurutkan DataFrame berdasarkan nilai dari kolom 'A'.

Namun, bagaimana jika kamu ingin mengurutkan berdasarkan lebih dari satu kolom?

Contoh Mengurutkan Berdasarkan Beberapa Kolom:

# Mengurutkan berdasarkan kolom 'B' dan 'A'
df_sorted_multi_values = df_unsorted_index.sort_values(by=['B', 'A'])

df_sorted_multi_values
Output:

Dalam contoh di atas:

1. Dengan menggunakan df_unsorted_index.sort_values(by=['B', 'A']), kita mengurutkan
DataFrame terlebih dahulu berdasarkan kolom 'B' dan kemudian 'A' jika ada
beberapa nilai yang sama di kolom 'B'.
Mengurutkan Dalam Urutan Terbalik

Secara default, Pandas akan mengurutkan data dalam urutan menaik. Namun, jika kamu
ingin mengurutkan data dalam urutan menurun, kamu dapat menggunakan argumen
ascending=False.

Contoh Mengurutkan Dalam Urutan Terbalik:

# Mengurutkan berdasarkan kolom 'A' dalam urutan menurun
df_sorted_descending = df_unsorted_index.sort_values(by='A',
ascending=False)

df_sorted_descending
Output:

Mengurutkan dengan MultiIndex

Jika kamu bekerja dengan DataFrame yang memiliki MultiIndex, kamu mungkin perlu
mengurutkan data berdasarkan salah satu level indeks atau lebih. Pandas memungkinkan
kamu untuk melakukan hal ini dengan mudah.

Contoh Mengurutkan dengan MultiIndex:

# Membuat DataFrame dengan MultiIndex
arrays = [['K0', 'K0', 'K1', 'K2', 'K2', 'K3'],
['L0', 'L1', 'L0', 'L0', 'L1', 'L0']]
index = pd.MultiIndex.from_arrays(arrays, names=('key1', 'key2'))
df_multiindex = pd.DataFrame({
'A': [1, 2, 3, 4, 5, 6],
'B': [6, 5, 4, 3, 2, 1]
}, index=index)

# Mengurutkan berdasarkan level 'key2' dari indeks

df_sorted_multiindex = df_multiindex.sort_index(level='key2')

df_sorted_multiindex
Output:
Dalam contoh di atas:
1. Kita memiliki DataFrame df_multiindex dengan MultiIndex (key1 dan key2).

Dengan menggunakan df_multiindex.sort_index(level='key2'), kita telah mengurutkan

DataFrame berdasarkan level key2 dari indeks.

Mengurutkan dengan Menggunakan Fungsi Kustom

Ada kalanya kamu mungkin ingin mengurutkan data berdasarkan logika khusus yang tidak
dapat diakomodasi oleh metode standar. Dalam kasus seperti itu, kamu bisa menggunakan
fungsi kustom dengan bantuan argumen key pada metode .sort_values().

Contoh Mengurutkan dengan Fungsi Kustom:

# Membuat DataFrame untuk demonstrasi
df_custom_sort = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [25, 30, 35, 40]
})

# Fungsi kustom yang diperbaiki untuk mengurutkan berdasarkan jumlah

karakter dalam nama
def custom_sort(series):
return series.str.len()

# Mengurutkan berdasarkan fungsi kustom yang diperbaiki

df_sorted_custom = df_custom_sort.sort_values(by='Name',
key=custom_sort)

df_sorted_custom
Output:
Dalam contoh di atas:
1. Kita telah memodifikasi fungsi custom_sort agar mengembalikan panjang string
untuk setiap elemen dalam Series.

Dengan menggunakan df_custom_sort.sort_values(by='Name', key=custom_sort), kita

mengurutkan DataFrame berdasarkan panjang nama dalam kolom 'Name'. Hasilnya, Bob
(dengan 3 karakter) berada di posisi pertama, diikuti oleh Alice (5 karakter), David (5
karakter), dan terakhir Charlie (7 karakter).

Urutan Berdasarkan Beberapa Kolom dengan Urutan yang Berbeda

Kadang-kadang, kamu mungkin ingin mengurutkan data berdasarkan beberapa kolom,

tetapi dengan urutan yang berbeda untuk setiap kolom. Ini bisa dilakukan dengan
memberikan daftar boolean ke argumen ascending.

Contoh Mengurutkan dengan Urutan yang Berbeda untuk Setiap Kolom:

# Membuat DataFrame untuk demonstrasi
df_multi_sort = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [25, 25, 35, 30],
'Score': [85, 90, 88, 78]
})

# Mengurutkan berdasarkan 'Age' (ascending) dan 'Score' (descending)

df_sorted_multi_order = df_multi_sort.sort_values(by=['Age', 'Score'],
ascending=[True, False])

df_sorted_multi_order
Output:

Dalam contoh di atas:

 1. Kita telah membuat DataFrame df_multi_sort yang memiliki kolom 'Name', 'Age', dan
'Score'.

Dengan menggunakan df_multi_sort.sort_values(by=['Age', 'Score'], ascending=[True, False]),

kita mengurutkan DataFrame berdasarkan kolom 'Age' dalam urutan menaik dan 'Score'
dalam urutan menurun. Oleh karena itu, meskipun Bob dan Alice memiliki usia yang sama,
Bob muncul sebelum Alice karena skornya lebih tinggi.

Pengurutan dengan Data Kategorikal

Jika kamu bekerja dengan data kategorikal di Pandas, kamu mungkin ingin mengurutkan
data bukan berdasarkan urutan alfanumerik, tetapi berdasarkan urutan kategori. Ini bisa
dilakukan dengan mudah dengan tipe data Categorical di Pandas.

Contoh Mengurutkan Data Kategorikal:

# Membuat DataFrame dengan data kategorikal
df_categorical = pd.DataFrame({
'grade': ['gold', 'silver', 'bronze', 'platinum', 'gold', 'silver']
})

# Mengatur urutan kategori dan mengkonversi kolom 'grade' ke tipe

kategorikal
order = ['bronze', 'silver', 'gold', 'platinum']
df_categorical['grade'] = pd.Categorical(df_categorical['grade'],
categories=order, ordered=True)

# Mengurutkan berdasarkan kolom 'grade'

df_sorted_categorical = df_categorical.sort_values(by='grade')

df_sorted_categorical
Output:

Dalam contoh di atas:

1. Kita telah membuat DataFrame df_categorical dengan kolom 'grade' yang berisi
medali seperti emas, perak, perunggu, dan platinum.
Dengan menggunakan pd.Categorical(...), kita mengonversi kolom 'grade' menjadi tipe data
kategorikal dan menentukan urutan kategori yang diinginkan (perunggu < perak < emas <
platinum).

Dengan menggunakan df_categorical.sort_values(by='grade'), kita mengurutkan DataFrame

berdasarkan urutan kategori yang telah ditentukan sebelumnya.

Pengurutan dengan Mengabaikan Huruf Kapital

Secara default, Pandas akan mengurutkan string dengan mempertimbangkan huruf kapital.
Namun, dalam beberapa kasus, kamu mungkin ingin mengabaikan huruf kapital saat
pengurutan.

Contoh Mengurutkan dengan Mengabaikan Huruf Kapital:

# Membuat DataFrame dengan string campuran huruf besar dan kecil
df_mixed_case = pd.DataFrame({
'name': ['alice', 'Bob', 'CHARLIE', 'David', 'eve', 'FRANK']
})

# Mengurutkan dengan mengabaikan huruf kapital

df_sorted_case_insensitive = df_mixed_case.sort_values(by='name',
key=lambda x: x.str.lower())

df_sorted_case_insensitive
Output:

Dalam contoh di atas:

1. Kita memiliki DataFrame df_mixed_case yang berisi nama-nama dengan kombinasi
huruf besar dan kecil.

Dengan menggunakan df_mixed_case.sort_values(by='name', key=lambda x: x.str.lower()),

kita mengurutkan DataFrame dengan mengabaikan huruf kapital, sehingga 'alice', 'Bob', dan
'CHARLIE' muncul dalam urutan alfanumerik yang benar.
Bab 3. Pembersihan Data dengan
Pandas
3.1 Mengidentifikasi Data yang Hilang (Missing Data)
Bayangkan kamu berada di sebuah labirin. Segala sesuatu tampak sempurna; kamu
mengetahui dari mana memulai dan di mana harus berakhir. Tapi tunggu dulu, ada
beberapa bagian dari peta yang hilang! Bagaimana kamu bisa mencapai tujuan tanpa
informasi yang lengkap?

Di dunia analisis data, "data yang hilang" adalah labirinnya sendiri. Terkadang, dataset yang
kamu punya tidak lengkap. Mungkin ada beberapa sel yang kosong, atau mungkin ada
beberapa baris yang seharusnya ada informasi tetapi malah tidak. Data yang hilang ini bisa
menjadi masalah serius, terutama jika kamu berencana melakukan analisis statistik atau
pelatihan model machine learning.

Jadi, bagaimana caranya mengidentifikasi data yang hilang dengan Pandas? Ayo kita
jelajahi!

1. Kenali Tanda Data yang Hilang

Pandas biasanya menggunakan nilai NaN (Not a Number) untuk menandai data yang hilang.
Namun, dalam beberapa kasus, data yang hilang bisa juga ditandai dengan cara lain,
misalnya dengan string kosong, atau angka tertentu seperti -9999. Jadi, langkah pertama
dalam mengidentifikasi data yang hilang adalah memahami bagaimana data yang hilang
ditandai dalam datasetmu.

2. Gunakan .isna() atau .isnull() untuk Mendeteksi Data yang Hilang

Pandas menyediakan dua metode, yaitu .isna() dan .isnull(), yang keduanya melakukan hal
yang sama: mengidentifikasi data yang hilang. Metode ini akan mengembalikan DataFrame
lain dengan nilai boolean (True atau False) yang menunjukkan apakah elemen tertentu
hilang atau tidak.

Mari kita lihat:

# Membuat data sintetis dengan beberapa nilai yang hilang (NaN)
import pandas as pd
import numpy as np

df_missing = pd.DataFrame({
'A': [1, 2, np.nan, 4, 5],
 'B': [5, np.nan, np.nan, 8, 9],
'C': [1, 2, 3, 4, 5]
})

# Menggunakan .isna() untuk mendeteksi data yang hilang

df_missing_isna = df_missing.isna()
df_missing_isna
Output:

Kolom dan baris yang memiliki nilai True menunjukkan posisi data yang hilang dalam
DataFrame aslinya.

3. Menggunakan .info() untuk Melihat Gambaran Umum

Selain menggunakan .isna(), kamu juga bisa menggunakan metode .info() untuk
mendapatkan gambaran umum dari DataFrame, termasuk jumlah data yang hilang di setiap
kolom. Ini adalah cara cepat untuk mengetahui di mana kamu mungkin perlu
membersihkan data.

Contoh:
df_missing.info()
Output:

Dari output di atas, kita bisa melihat bahwa kolom 'A' memiliki 4 data yang bukan null
(artinya ada 1 data yang hilang), dan kolom 'B' memiliki 3 data yang bukan null (artinya ada
2 data yang hilang).
4. Menggunakan .sum() untuk Menghitung Jumlah Data yang Hilang

Terkadang, kamu mungkin juga ingin tahu jumlah total data yang hilang dalam setiap
kolom. Kamu bisa menggunakan metode .sum() setelah .isna() untuk mendapatkan
informasi ini.

Misalnya, df_missing.isna().sum() akan memberikan output sebagai berikut:

Masing-masing angka menunjukkan jumlah data yang hilang dalam kolom terkait.

5. Visualisasi Data yang Hilang

Tidak semua orang merasa nyaman dengan angka dan tabel. Kadang-kadang, sebuah
gambar bisa menyampaikan pesan lebih cepat daripada seribu angka. Itu sebabnya
visualisasi bisa menjadi alat yang sangat kuat dalam mengidentifikasi data yang hilang.

Salah satu cara paling efektif untuk melihat sejauh mana data yang hilang dari datasetmu
adalah dengan menggunakan pustaka visualisasi seperti Matplotlib atau Seaborn. Kamu
bisa membuat 'heatmap' dari DataFrame yang dihasilkan oleh isna() untuk melihat di mana
sel yang hilang berada.

Contoh:
# Contoh kode
import seaborn as sns
sns.heatmap(df_missing.isna(), cbar=False)
Output:
Dalam heatmap ini, sel yang berwarna menunjukkan data yang hilang. Ini memberikan
gambaran cepat tentang sejauh mana data yang hilang dan di kolom mana mereka banyak
ditemukan.

6. Identifikasi Data yang Hilang dalam Series

Tidak hanya DataFrame, kamu juga dapat menggunakan metode yang sama untuk
mengidentifikasi data yang hilang dalam objek Series. Misalnya, jika kamu memiliki sebuah
Series, kamu bisa menggunakan isna() atau isnull() untuk melihat apakah ada data yang
hilang.
# Contoh kode
series_missing = pd.Series([1, np.nan, 3, 4, np.nan])
series_missing.isna()
Output:

7. Data yang Hilang di Data Kategorikal

Data yang hilang tidak hanya terjadi pada data numerik, tetapi juga pada data kategorikal
atau string. Dalam kasus seperti ini, data yang hilang bisa ditandai dengan string kosong
atau label tertentu seperti "Tidak Diketahui", "N/A", atau bahkan "?".

Mari kita gunakan data sintetis ini:

 # Contoh kode
df_categorical = pd.DataFrame({'A': ['foo', '', 'bar'], 'B': ['baz',
'N/A', '']})
df_categorical
Output:

Dalam contoh ini, kita akan menggantikan string kosong '', 'N/A', dan '?' dengan np.nan
dalam dataframe df_categorical. Kemudian, kita akan menggunakan metode isna() untuk
mengidentifikasi data yang hilang.

Contoh:
# Menggantikan string kosong, 'N/A', dan '?' dengan np.nan
df_categorical.replace(['', 'N/A', '?'], np.nan, inplace=True)

# Identifikasi data yang hilang

print(df_categorical.isna())

Dari output, kita dapat melihat bahwa dalam kolom A baris kedua dan keempat memiliki
data yang hilang (ditandai dengan True), sedangkan dalam kolom B, baris kedua dan ketiga
memiliki data yang hilang.

3.2 Mengisi Data yang Hilang

Kamu sudah berhasil memetakan labirin dari data yang hilang di subbab sebelumnya.
Sekarang, apa yang akan kamu lakukan? Berhenti dan menyerah? Tentu saja tidak! Kamu
akan mencari cara untuk mengisi bagian yang kosong itu, kan? Di dunia analisis data,
mengisi data yang hilang adalah seperti menemukan jalan pintas dalam labirin. Jadi, mari
kita pelajari bagaimana cara mengisinya!

1. Menggunakan .fillna() untuk Mengisi dengan Nilai Tertentu

Anggap saja ada lubang di jalan yang biasa kamu lalui. Salah satu cara paling cepat untuk
mengatasinya adalah dengan menutupinya menggunakan material apa pun yang tersedia.
Di Pandas, metode .fillna() adalah alatmu untuk melakukan ini.

Mari kita lihat contoh dengan data sintetis yang memiliki beberapa nilai NaN.
 # Contoh data sintetis
data = {
'A': [1, np.nan, 3, 4, 5],
'B': [5, 4, np.nan, 2, 1]
}
df = pd.DataFrame(data)
df
Output:

Kamu bisa mengisi semua data yang hilang (NaN) di kolom 'A' dengan angka 0.
# Mengisi data yang hilang di kolom 'A' dengan 0
df['A'].fillna(0)
Output:

2. Mengisi dengan Metode Interpolasi

Namun, apa yang terjadi jika lubang di jalan itu besar dan kamu membutuhkan solusi yang
lebih rapi? Di sinilah metode interpolasi berguna. Metode ini akan mencoba
"menebak-nebak" nilai yang paling masuk akal berdasarkan data di sekitarnya.

Di Pandas, kamu bisa melakukan ini dengan argumen method dalam .fillna().
# Mengisi data yang hilang dengan interpolasi linier
df['B'].fillna(method='ffill')
Output:
Pada contoh di atas, metode 'ffill' (forward fill) akan mengisi data yang hilang dengan nilai
sebelumnya di kolom tersebut.

3. Menggunakan Fungsi Agregasi untuk Mengisi Data

Bagaimana jika kamu berada di sebuah labirin dan tahu bahwa rata-rata jarak antara setiap
belokan adalah 10 langkah? Kamu bisa menggunakan informasi ini untuk memperkirakan
di mana belokan selanjutnya!

Di Pandas, kamu bisa menggunakan metode seperti .mean(), .median(), atau .mode() untuk
mengisi data yang hilang dengan nilai agregat dari kolom tersebut.
# Mengisi data yang hilang dengan rata-rata kolom 'A'
df['A'].fillna(df['A'].mean())
Output:

Dalam contoh ini, semua nilai NaN di kolom 'A' akan diganti dengan rata-rata dari kolom 'A'.

4. Menggunakan inplace=True untuk Modifikasi Langsung

Pada semua contoh di atas, perubahan yang kita lakukan pada DataFrame tidak disimpan
kecuali kamu menugaskan hasilnya kembali ke DataFrame atau kolom. Jika kamu ingin
perubahan terjadi langsung pada DataFrame, kamu bisa menggunakan argumen
inplace=True.

# Contoh
df['A'].fillna(0, inplace=True)
df
Output:

Dengan inplace=True, dataframe asli akan langsung berganti nilainya sesuai dengan
imputasi yang kita lakukan. Bisa dilihat kolom A sudah berisi nilai-nilai dengan imputasi
missing value sesuai yang kita lakukan, sedangkan kolom B, walaupun sedari tadi kita
lakukan percobaan imputasi nilai yang hilang, namun nilai aslinya tidak berubah, tanpa
inplace=True, kita harus secara manual meng-assign-nya seperti ini:
df['B'] = df['B'].fillna(method='ffill')
df
Output:

Barulah nilai pada kolom B di dataframe kita ter-update.

Berikut adalah beberapa kondisi kapan kita harus menggunakan metode tertentu dalam
mengatasi nilai yang hilang.

Jenis Imputasi Syntax (Python - pandas) Kapan Digunakan Keterangan

Menggantikan nilai
Data bersifat kontinu yang hilang dengan
Mean Imputation df.fillna(df.mean()) dan distribusi normal rata-rata kolom.
Data bersifat kontinu Menggantikan nilai
dan distribusi tidak yang hilang dengan
Median Imputation df.fillna(df.median()) normal median kolom.
Menggantikan nilai
Data bersifat yang hilang dengan
Modus Imputation df.fillna(df.mode().iloc[0]) kategorikal modus kolom.
Jumlah data yang Menghapus baris
hilang kecil relatif yang memiliki nilai
Hapus Row df.dropna() terhadap dataset yang hilang.
Anda memiliki nilai
konstan untuk Menggantikan nilai
menggantikan nilai yang hilang dengan
Imputasi Konstan df.fillna(value) hilang nilai konstan.
Mengisi nilai yang
Data bersifat time hilang berdasarkan
Imputasi Interpolasi df.interpolate() series atau urutan interpolasi linier.
3.3 Menghapus Data yang Hilang
Tidak semua missing values bisa atau harus diisi, terutama jika kamu tidak yakin mengenai
apa yang sebenarnya sedang kamu hadapi. Kadang, solusinya adalah menghapus bagian
yang tidak kamu butuhkan atau yang bisa mempengaruhi analisis kamu. Apakah kamu siap
untuk membuang kotoran itu? Mari kita coba!

Pertama kita generate data sintetis sebagai contoh:

# Membuat data sintetis untuk digunakan sebagai contoh
# Data sintetis dengan beberapa nilai NaN
data = {
'A': [1, np.nan, 3, 4, 5],
'B': [5, 4, np.nan, 2, 1],
'Company': ['Apple', 'Microsoft', 'Apple', 'Apple', 'Microsoft']
}
df = pd.DataFrame(data)

# Menampilkan data asli

df
Output:

1. Menggunakan .dropna() untuk Menghapus Baris

Metode paling langsung untuk menghapus data yang hilang adalah dengan menggunakan
.dropna(). Dengan metode ini, setiap baris yang memiliki setidaknya satu nilai NaN akan
dihapus.
# Menghapus semua baris yang memiliki nilai NaN dan menampilkan hasilnya
df_dropped = df.dropna()
df_dropped
Output:
Hasilnya adalah DataFrame baru yang sudah dibersihkan dari baris dengan nilai NaN. Baris
dengan indeks 1 dan 2 telah dihapus karena mereka memiliki setidaknya satu NaN.

2. Menghapus Baris Berdasarkan Kolom Tertentu

Terkadang, kamu mungkin hanya peduli pada nilai yang hilang di kolom tertentu. Misalnya,
kolom 'A' adalah kolom target yang sangat penting untuk model machine learning kamu.
Dalam kasus ini, kamu bisa menentukan kolom target saat menggunakan .dropna().

Mari kita coba.​

# Menghapus baris berdasarkan kolom 'A' dan menampilkan hasilnya
df_dropped_A = df.dropna(subset=['A'])
df_dropped_A
Output:

Hasilnya adalah DataFrame yang hanya menghapus baris dengan nilai NaN pada kolom 'A'.
Baris dengan indeks 1 telah dihapus, tetapi baris dengan indeks 2 tetap ada meskipun
memiliki NaN di kolom 'B'.

3. Menghapus Kolom dengan .dropna(axis=1)

Tidak hanya baris, kamu juga bisa menghapus kolom yang memiliki nilai NaN. Untuk
melakukan ini, kamu bisa menggunakan argumen axis=1.

Mari kita coba.​

# Menghapus kolom yang memiliki nilai NaN dan menampilkan hasilnya
df_dropped_columns = df.dropna(axis=1)
df_dropped_columns
Output:
Sebagai hasilnya, kita hanya menyisakan kolom 'Company' karena kolom 'A' dan 'B' memiliki
setidaknya satu nilai NaN.

4. Menggunakan thresh untuk Mengontrol Jumlah Data yang Dihapus

Terkadang, kamu mungkin tidak ingin menghapus baris atau kolom yang memiliki
setidaknya satu NaN. Mungkin kamu ingin lebih fleksibel, misalnya, hanya menghapus
baris yang memiliki lebih dari satu NaN.

Untuk itu, kamu bisa menggunakan parameter thresh dalam .dropna().

Mari kita coba.​

# Hanya menghapus baris yang memiliki lebih dari satu NaN dan
menampilkan hasilnya
df_dropped_thresh = df.dropna(thresh=2)
df_dropped_thresh
Output:

Hasilnya adalah DataFrame yang hanya menghapus baris jika baris tersebut memiliki lebih
dari satu NaN. Dalam kasus ini, semua baris memenuhi syarat tersebut, jadi tidak ada yang
dihapus.

Melakukan pembersihan data yang tepat adalah seni yang memerlukan praktik dan intuisi.
Menghapus data yang hilang adalah salah satu keputusan paling penting yang bisa
mempengaruhi kualitas analisis kamu. Jadi, pertimbangkan dengan cermat apakah kamu
benar-benar perlu menghapus data tersebut atau apakah ada cara lain untuk
mempertahankan informasi penting.
3.4 Transformasi Data
Mengidentifikasi, mengisi, atau bahkan menghapus data yang hilang hanyalah sebagian
kecil dari perjalanan pembersihan data. Sekarang, saatnya kita beralih ke sesuatu yang
lebih kompleks tetapi juga lebih menarik: Transformasi Data.

Transformasi data adalah seperti seni origami dalam dunia data science. Kamu mengambil
sesuatu yang kasar dan tidak terbentuk, lalu melipat dan memotongnya hingga menjadi
sesuatu yang indah dan fungsional. Tertarik? Ayo mulai!

1. Melakukan Operasi Matematika pada Kolom

Pertama-tama, mari kita mulai dengan sesuatu yang sederhana. Kamu bisa melakukan
operasi matematika pada kolom DataFrame dengan mudah. Misalnya, kamu bisa
menggandakan setiap elemen di kolom 'A' dengan 2.
# Menggandakan setiap elemen di kolom 'A' dengan 2
df['A'] * 2
Output:

2. Menggunakan .apply() untuk Fungsi yang Lebih Kompleks

Jika kamu ingin melakukan sesuatu yang lebih dari sekadar operasi matematika sederhana,
.apply() adalah temanmu. Fungsi ini memungkinkan kamu untuk menerapkan fungsi apa
pun ke setiap elemen dalam kolom atau baris.
# Mengkuadratkan setiap elemen di kolom 'A'
df['A'].apply(lambda x: x**2)
Output:
3. .map() dan .replace() untuk Mengganti Nilai

Kamu juga bisa menggunakan .map() atau .replace() untuk mengganti nilai dalam kolom.
Misalnya, mengganti nama perusahaan dengan kode sahamnya.
# Menggunakan map
df['Company'].map({'Apple': 'AAPL', 'Microsoft': 'MSFT'})

# Menggunakan replace
df['Company'].replace({'Apple': 'AAPL', 'Microsoft': 'MSFT'})
Output:

4. Transformasi dengan Fungsi Statistik

Pandas juga memiliki sejumlah fungsi statistik bawaan yang bisa kamu gunakan untuk
transformasi data, seperti .mean(), .min(), .max(), .sum(), dan lain-lain.
# Menghitung rata-rata kolom 'A' dan menggunakannya untuk transformasi
mean_A = df['A'].mean()
df['A'] - mean_A
Output:

5. Menggunakan .cut() untuk Binning Data

Mengkategorikan data numerik ke dalam 'bin' atau kelompok adalah salah satu cara
transformasi data yang umum. Fungsi .cut() di Pandas membuat ini menjadi mudah.
# Membagi data di kolom 'A' menjadi 3 bin
bins = [0, 2, 4, 6]
labels = ['Low', 'Medium', 'High']
df['A_binned'] = pd.cut(df['A'], bins=bins, labels=labels)
Output:
6. Normalisasi Data dengan .min() dan .max()

Normalisasi adalah teknik untuk mengubah rentang data numerik sehingga semuanya ada
dalam skala yang sama, biasanya antara 0 dan 1. Ini adalah langkah yang sering diperlukan
jika kamu bekerja dengan algoritma machine learning yang sensitif terhadap skala.

Kamu bisa menggunakan .min() dan .max() untuk melakukan normalisasi.

Mari kita coba.​

# Normalizing column 'A' using min-max normalization
df['A_normalized'] = (df['A'] - df['A'].min()) / (df['A'].max() -
df['A'].min())
df
Output:

Seperti yang kamu lihat, kolom 'A' telah dinormalisasi sehingga nilainya sekarang berada di
antara 0 dan 1.

7. Log Transformasi

Transformasi logaritmik adalah teknik yang umum digunakan untuk meredam efek outlier
atau mendekatkan distribusi data ke distribusi normal. Di Pandas, kamu bisa melakukan ini
dengan np.log().
Mari kita coba.​
import numpy as np

# Applying log transformation to column 'A'

df['A_log'] = np.log(df['A'])
df
Output:

Voila! Kolom 'A_log' menunjukkan hasil dari transformasi logaritmik kolom 'A'. Teknik ini
sangat berguna untuk memanipulasi skala dan distribusi data.

8. One-Hot Encoding untuk Variabel Kategorikal

Jika kamu memiliki kolom dengan variabel kategorikal, kamu mungkin ingin mengubahnya
menjadi bentuk yang lebih "mesin-baca". One-hot encoding adalah salah satu cara untuk
melakukan ini.
# One-hot encoding the 'Company' column
pd.get_dummies(df, columns=['Company'])
Output:

Tadaa! Kolom 'Company' telah dikonversi menjadi dua kolom baru: 'Company_Apple' dan
'Company_Microsoft', yang menunjukkan keanggotaan kategorikal melalui one-hot
encoding.
9. Menggunakan .astype() untuk Mengubah Tipe Data

Terkadang, kamu mungkin perlu mengubah tipe data kolom. Pandas membuat ini menjadi
mudah dengan .astype().
# Mengubah tipe data kolom 'A' menjadi float
df['A'].astype(float)
Output:

Berhasil! Tipe data kolom 'A' sekarang telah berubah menjadi float64.

10. Menggunakan .query() untuk Filter Berdasarkan Kondisi

Bagaimana jika kamu ingin melakukan transformasi hanya pada sebagian data yang
memenuhi kondisi tertentu? .query() adalah solusinya.
# Menyeleksi baris dimana kolom 'A' lebih dari 2 dan menggandakan
nilainya
df.query('A > 2')['A'] * 2
Output:

Transformasi data adalah sebuah proses yang penuh dengan kekayaan dan kompleksitas.
Setiap teknik mempunyai kegunaan dan implikasinya sendiri.

3.5 Mengubah Tipe Data

Kamu pernah merasa seperti memasukkan kunci mobil ke dalam lubang kunci rumah?
Atau mencoba memasukkan sepatu kiri ke kaki kanan? Tidak cocok, bukan? Nah, dalam
dunia pemrograman data, hal serupa bisa terjadi. Terkadang, kita memiliki data dalam satu
tipe, namun kita membutuhkannya dalam tipe lain. Di sinilah mengubah tipe data menjadi
relevan.

Mengapa Penting Mengubah Tipe Data?

Bayangkan kamu memiliki kolom berisi tanggal dalam bentuk teks (string). Namun, untuk
melakukan analisis berdasarkan tahun, bulan, atau hari, kamu perlu mengubahnya menjadi
tipe data tanggal (datetime). Atau mungkin kamu memiliki kolom harga dalam bentuk teks,
dan ingin menjumlahkannya. Nah, kamu harus mengubahnya menjadi tipe data numerik.

Mengubah tipe data bukan hanya soal kebutuhan analisis. Dengan mengatur tipe data
dengan benar, kamu bisa mengoptimalkan penyimpanan memori dan mempercepat
operasi komputasi. Jadi, siap untuk menyelam lebih dalam?

Bagaimana Mengubah Tipe Data dengan Pandas?

Pandas, pustaka Python yang luar biasa untuk analisis data, memiliki alat yang kuat untuk
mengubah tipe data. Mari kita jelajahi!

Menggunakan astype():

Fungsi ini memungkinkan kamu untuk mengubah tipe data kolom DataFrame.
Contoh:
import pandas as pd

# Membuat data sintetis

df = pd.DataFrame({
'harga': ['1000', '2000', '3000'],
'tanggal': ['2021-01-01', '2021-01-02', '2021-01-03']
})

# Mengubah tipe data kolom harga menjadi integer

df['harga'] = df['harga'].astype(int)

print(df.dtypes)
Output:

Menggunakan pd.to_datetime():

Fungsi ini spesifik untuk mengubah kolom menjadi tipe data datetime.
Contoh:
# Mengubah tipe data kolom tanggal menjadi datetime
df['tanggal'] = pd.to_datetime(df['tanggal'])

print(df.dtypes)
Output:
Menggunakan pd.to_numeric():

Jika kamu memiliki data yang mungkin mengandung non-numeric values dan ingin
mengubahnya menjadi numerik (menggantikan non-numeric dengan NaN), gunakan fungsi
ini.
# Membuat data sintetis dengan non-numeric values
df['harga'] = ['1000', 'dua ribu', '3000']

# Mengubah tipe data kolom harga menjadi numerik

df['harga'] = pd.to_numeric(df['harga'], errors='coerce')

print(df)
Output:

Menggunakan infer_objects():

Jika kamu ingin Pandas menebak tipe data terbaik untuk kolommu, gunakan metode ini.
Contoh:
df = df.infer_objects()
print(df.dtypes)
Output:

Apa yang Harus Diperhatikan?

1. Pastikan kamu tahu tipe data asli dan tipe data tujuan. Mengubah sembarangan
dapat menyebabkan kehilangan informasi.
2. Jika mengubah menjadi tipe data numerik, pastikan tidak ada karakter non-numerik
yang tidak diinginkan (mis. ',' atau '$').
3. Jangan lupa untuk menangani data yang hilang saat mengubah tipe data. Sebagai
contoh, jika kamu memiliki NaN dalam kolom yang ingin diubah menjadi integer,
kamu harus mengatasinya terlebih dahulu.

3.6 Mengatasi Data Duplikat

Data duplikat—kejutan yang tidak pernah diinginkan dalam analisis data. Bayangkan saja,
kamu telah menghabiskan jam-jam mempersiapkan analisis data yang cemerlang, dan
saatnya tiba untuk mempresentasikannya. Dan kaboom! Hasilnya terdistorsi karena ada
baris data yang terduplikasi. Aduh, bisa-bisa kamu langsung dianggap kurang kompeten!

Tapi jangan khawatir! Di sini kita akan membahas beberapa teknik untuk mengidentifikasi
dan menghapus data duplikat menggunakan library Pandas.

Pertama kita generate data sintetis untuk playground kita:

# Importing the pandas library
import pandas as pd

# Creating synthetic data with duplicate rows

data_dup = {
'Name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'David'],
'Age': [25, 30, 35, 25, 30, 40],
'Occupation': ['Engineer', 'Doctor', 'Artist', 'Engineer', 'Doctor',
'Writer']
}
df_dup = pd.DataFrame(data_dup)

# Displaying the original DataFrame with duplicate rows

df_dup
Output:

Mengidentifikasi Data Duplikat dengan .duplicated()

Metode pertama untuk mengidentifikasi baris yang terduplikasi adalah dengan

menggunakan metode .duplicated(). Metode ini akan mengembalikan sebuah Series yang
menunjukkan apakah setiap baris adalah duplikat dari baris yang sudah ada sebelumnya
atau tidak.
# Identifying duplicate rows
df_dup.duplicated()
Output:
Nah, lihat itu? Baris dengan indeks 3 dan 4 ditandai sebagai True, yang berarti mereka
adalah duplikat dari baris yang sudah ada sebelumnya dalam DataFrame. Ini adalah cara
cepat untuk melakukan pemeriksaan awal dan melihat apakah data kamu memiliki duplikat
atau tidak.

Menghapus Data Duplikat dengan .drop_duplicates()

Setelah mengidentifikasi baris yang terduplikasi, langkah selanjutnya adalah

menghapusnya. Untuk ini, Pandas menyediakan metode .drop_duplicates().
# Dropping duplicate rows
df_dup.drop_duplicates(inplace=True)

# Displaying the DataFrame after dropping duplicates

df_dup
Output:

Dan voilà! Baris yang terduplikasi sudah dihapus dari DataFrame kita. Sekarang, kita
memiliki DataFrame yang lebih "bersih."

Spesifikasi Kolom saat Menghapus Duplikat

Kadang, kamu mungkin hanya ingin menghapus baris yang memiliki nilai yang sama pada
kolom tertentu, bukan di seluruh kolom.

# Creating synthetic data with duplicate 'Name' but different 'Age' and
'Occupation'
data_name_dup = {
'Name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'David'],
'Age': [25, 30, 35, 40, 45, 40],
'Occupation': ['Engineer', 'Doctor', 'Artist', 'Writer', 'Dancer',
 'Writer']
}
df_name_dup = pd.DataFrame(data_name_dup)
df_name_dup
Output:

Dalam hal ini, kamu bisa memberikan nama kolom sebagai argumen ke .drop_duplicates().
# Dropping rows that have the same 'Name'
df_name_dup.drop_duplicates(subset=['Name'], inplace=True)

# Displaying the DataFrame after dropping duplicates in the 'Name'

column
df_name_dup
Output:

Seperti yang kamu lihat, meskipun baris dengan indeks 3 dan 4 memiliki 'Age' dan
'Occupation' yang berbeda dari baris pertama yang memiliki nama yang sama (indeks 0 dan
1), mereka tetap dihapus karena kita mengatur untuk menghapus duplikat berdasarkan
kolom 'Name' saja.

Menghapus Duplikat dengan Pertimbangan Urutan

Secara default, .drop_duplicates() akan mempertahankan baris pertama dari setiap set baris
yang terduplikasi. Namun, kamu juga bisa memilih untuk mempertahankan baris terakhir
dari setiap set dengan menggunakan argumen keep='last'.
df.drop_duplicates(keep='last', inplace=True)
3.7 Normalisasi Data
Kita semua tahu betapa pentingnya data yang "bersih" untuk analisis atau pelatihan model
machine learning. Tapi apa yang dimaksud dengan "bersih"? Ya, selain dari tidak adanya
data yang hilang atau duplikat, "bersih" juga berarti data tersebut berada dalam skala atau
rentang yang serupa. Inilah yang disebut "normalisasi data."

Apa Itu Normalisasi?

Normalisasi adalah proses mengubah nilai dalam dataset untuk membuatnya berada dalam
skala yang serupa. Ini sangat penting dalam teknik machine learning seperti k-NN, PCA,
atau metode gradien turun, di mana perbedaan skala antar variabel bisa menjadi masalah.

Teknik Normalisasi
Ada beberapa teknik untuk melakukan normalisasi, di antaranya:

Min-Max Scaling: Mengubah skala fitur ke rentang [0, 1] atau [a, b].

Z-Score Normalization (Standardization): Mengubah skala fitur sehingga memiliki mean (µ)
0 dan standard deviation (σ) 1.

Log Transformation: Menggunakan transformasi logaritmik.

Pertama mari kita generate data sintetis sebagai terlebih dahulu:

# Importing required libraries
import numpy as np

# Generating synthetic data for normalization

np.random.seed(0)
data_norm = {
'Salary': np.random.randint(4000, 9000, 10),
'Age': np.random.randint(20, 60, 10),
'Experience': np.random.randint(1, 20, 10)
 }
df_norm = pd.DataFrame(data_norm)

# Displaying the original DataFrame

df_norm

Mari kita mulai dengan Min-Max Scaling.​

# Min-Max Scaling
def minmax_scaling(series):
return (series - series.min()) / (series.max() - series.min())

# Applying Min-Max Scaling to the DataFrame

df_norm_minmax = df_norm.apply(minmax_scaling)

# Displaying the DataFrame after Min-Max Scaling

df_norm_minmax
Output:

Taraaa! Data kita sekarang telah dinormalisasi ke rentang [0, 1] menggunakan Min-Max
Scaling. Jika kamu perhatikan, nilai minimum untuk setiap kolom sekarang adalah 0, dan
nilai maksimum adalah 1.

Z-Score Normalization (Standardization)

Sekarang, mari kita coba Z-Score Normalization. Ini adalah salah satu teknik normalisasi
yang paling umum digunakan, terutama jika kita tidak tahu distribusi data atau jika
distribusi tidak mengikuti asumsi normalitas.
 # Z-Score Normalization (Standardization)
def zscore_scaling(series):
return (series - series.mean()) / series.std()

# Applying Z-Score Normalization to the DataFrame

df_norm_zscore = df_norm.apply(zscore_scaling)

# Displaying the DataFrame after Z-Score Normalization

df_norm_zscore
Output:

Keren, kan? Sekarang setiap kolom memiliki mean yang mendekati 0 dan deviasi standar
yang mendekati 1, sesuai dengan yang diharapkan dari Z-Score Normalization. Ini bisa
sangat berguna, terutama ketika kamu menerapkan teknik yang bergantung pada jarak
antar poin, seperti k-NN atau PCA.

Log Transformation

Terkadang, data yang kita miliki sangat condong ke satu sisi atau memiliki banyak outlier.
Dalam kasus-kasus seperti itu, kita bisa menggunakan Log Transformation untuk
menormalkan data. Transformasi ini sangat membantu dalam menjadikan data lebih
"normal" dan mempermudah identifikasi pola.

Mari kita terapkan Log Transformation pada data kita.

Kita akan menambahkan 1 ke setiap elemen untuk menghindari log dari 0 yang tidak
terdefinisi.​
# Log Transformation
def log_transform(series):
return np.log1p(series)
 # Applying Log Transformation to the DataFrame
df_norm_log = df_norm.apply(log_transform)

# Displaying the DataFrame after Log Transformation

df_norm_log

Data kita sekarang telah ditransformasi menggunakan Log Transformation. Seperti yang
bisa kamu lihat, rentang data sekarang menjadi lebih kecil dibandingkan dengan data asli.

Normalisasi data adalah salah satu langkah paling krusial dalam pra-pemrosesan data. Baik
itu Min-Max Scaling, Z-Score Normalization, atau Log Transformation, setiap metode
memiliki keunggulan dan kelemahannya sendiri. Pilihlah yang paling sesuai dengan jenis
data dan masalah yang ingin kamu selesaikan.

3.8 Manipulasi String

Hai! Pernahkah kamu merasa kesulitan saat harus mengolah data teks? Di dunia nyata, kita
seringkali berhadapan dengan data teks yang belum rapi. Mungkin ada kesalahan ketik,
format yang tidak konsisten, atau bahkan teks yang berantakan. Nah, kali ini kita akan
membahas bagaimana mengatasi masalah-masalah tersebut dengan manipulasi string di
Pandas!

1. Dasar-dasar Manipulasi String di Pandas

Sebelum masuk ke detail, kamu perlu tahu dulu bahwa Pandas memiliki akses langsung ke
berbagai metode string melalui atribut .str dari Series atau DataFrame. Artinya, setiap teks
di dalam Series atau kolom DataFrame bisa langsung dimanipulasi dengan mudah.

Misalnya, kita punya data sintetis berikut:

import pandas as pd

data = {
'Nama': ['ALICE', 'Bob', 'Charlie ', ' DAvid', 'eve'],
'Alamat': ['JL. Anggrek 12', 'Jl. Mawar No. 5', 'Jl. Melati, No.
10', 'Jl. Tulip 3A', 'Jl. Sakura 2B']
}
df = pd.DataFrame(data)
df
Output:
Bagaimana kalau kita ingin mengubah semua nama menjadi huruf kecil?
df['Nama'] = df['Nama'].str.lower()
df
Output:

2. Menghilangkan Spasi Berlebih

Spasi ekstra bisa menjadi masalah saat kita membandingkan dua string atau saat kita ingin
mengatur format data. Untungnya, dengan Pandas, kita bisa mudah menghilangkannya.
df['Nama'] = df['Nama'].str.strip()
df
Output:

3. Memecah String

Kadang, kita perlu memecah string menjadi beberapa bagian. Misalnya dari alamat, kita
ingin memisahkan nama jalan dan nomor rumah.
df[['Jalan', 'No']] = df['Alamat'].str.split(',', expand=True)
df
Output:

4. Menggabungkan String

Berlawanan dengan memecah, kita juga sering perlu menggabungkan beberapa string.
df['Info Lengkap'] = df['Nama'] + ' tinggal di ' + df['Alamat']
df
Output:

5. Mengganti Substring

Mungkin kamu menemukan kesalahan dalam data atau ingin mengubah format tertentu.
Misalnya, mengganti "JL." menjadi "Jalan".
df['Alamat'] = df['Alamat'].str.replace('JL.', 'Jalan')
df
Output:
6. Mengecek Ketersediaan Substring

Kadang kita ingin tahu apakah suatu kata atau frase ada dalam string. Misalnya, siapa saja
yang tinggal di Jalan Anggrek?
df[df['Alamat'].str.contains('Anggrek')]
Output:

7. Ekstraksi Menggunakan Ekspresi Reguler

Ekspresi reguler (regex) adalah alat yang sangat kuat untuk pencocokan pola dalam teks.
Dengan Pandas, kita bisa menggunakan regex untuk ekstraksi data.

Misalnya, kita ingin mengekstrak nomor dari alamat:

df['No Rumah'] = df['Alamat'].str.extract('(\d+)')
df
Output:

8. Menghitung Panjang String

Mungkin kamu penasaran, siapa yang memiliki nama paling panjang?

df['Panjang Nama'] = df['Nama'].str.len()
df
Output:
10. Mengubah Format Tanggal

Terkadang, data tanggal yang kamu miliki berada dalam format teks yang berbeda-beda.
Misalnya, "12-01-2023", "12 Jan 2023", atau "Jan 12, 2023". Dengan Pandas, kamu bisa dengan
mudah mengonversinya menjadi format yang kamu inginkan.
tanggal_data = ['12-01-2023', '15 Jan 2023', 'Jan 20, 2023']
df_tanggal = pd.DataFrame({'Tanggal': tanggal_data})

print('Data original:')
display(df_tanggal)
df_tanggal['Tanggal'] = pd.to_datetime(df_tanggal['Tanggal'])
print('\nSetelah Konversi:')
display(df_tanggal)
Output:

11. Membulatkan ke Jumlah Karakter Tertentu

Misalkan kamu hanya ingin menampilkan 5 karakter pertama dari setiap nama. Ini bisa
berguna untuk inisialisasi atau keperluan lainnya.
df['Inisial'] = df['Nama'].str[:5]
df
Output:
12. Mengubah String Menjadi Uppercase atau Capitalize

Ketika ingin menstandardisasi data, mengubah teks menjadi uppercase atau capitalize bisa
jadi pilihan.
df['Nama_Upper'] = df['Nama'].str.upper()
df['Nama_Capitalize'] = df['Nama'].str.capitalize()
df[['Nama','Nama_Upper','Nama_Capitalize']]
Output:

13. Mencari Posisi Substring

Mencari tahu posisi dari suatu kata atau frase dalam string bisa membantu dalam berbagai
kasus. Misalnya, untuk ekstraksi atau analisis lebih lanjut.
posisi = df['Alamat'].str.find('Anggrek')
posisi
Output:

Dengan Pandas, manipulasi string bukan hanya tentang memperbaiki kesalahan atau
kekurangan data, tetapi juga tentang mengubah cara kita melihat dan memahami data
tersebut. Setiap fungsi dan metode yang telah kita pelajari memungkinkan kita untuk
mendekati data dengan cara yang lebih kreatif dan efisien.

3.9 Menggunakan Fungsi Apply dan Map di Pandas

Pandas, sebuah library Python yang kuat untuk analisis dan manipulasi data, memiliki dua
fungsi yang sangat berguna untuk berinteraksi dengan data: apply dan map. Dengan fungsi
ini, kamu dapat dengan mudah menerapkan operasi ke setiap elemen di Series atau
DataFrame.
Pengenalan Fungsi Apply

Fungsi apply adalah salah satu metode yang paling fleksibel dan berguna di Pandas. Dengan
apply, kamu dapat menerapkan fungsi tertentu ke setiap baris atau kolom dari DataFrame.

Contoh Sederhana:
Misalkan kita memiliki DataFrame sederhana dan kita ingin menghitung panjang dari
setiap string di kolom tertentu.

Mari kita generate data sintetis untuk contoh ini:

import pandas as pd

# Membuat data sintetis

df = pd.DataFrame({
'Nama': ['Alice', 'Bob', 'Charlie', 'David'],
'Usia': [25, 30, 35, 40],
})

# Menggunakan fungsi apply untuk menghitung panjang nama

df['Panjang_Nama'] = df['Nama'].apply(len)
df
Output:

Seperti yang kamu lihat, kita telah berhasil menerapkan fungsi len ke setiap entri di kolom
'Nama' untuk menghitung panjangnya. Hasilnya kemudian disimpan dalam kolom baru
bernama 'Panjang_Nama'.

Pengenalan Fungsi Map

Fungsi map adalah metode yang digunakan untuk memetakan sebuah nilai ke nilai lain.
Biasanya digunakan untuk mengganti nilai tertentu dalam Series. Fungsi ini sangat berguna
saat kita ingin mengganti nilai tertentu dalam kolom berdasarkan kamus (dictionary) atau
fungsi tertentu.

Contoh Sederhana:
Misalkan kita ingin mengganti angka usia dalam DataFrame kita dengan kategori usia
('Muda' untuk usia < 30, 'Tua' untuk usia >= 30). Kita dapat menggunakan map untuk tujuan
ini.

Mari kita coba:​

# Mendefinisikan fungsi untuk kategorisasi usia
def kategori_usia(usia):
return 'Muda' if usia < 30 else 'Tua'

# Menggunakan fungsi map untuk mengkategorikan usia

df['Kategori_Usia'] = df['Usia'].map(kategori_usia)
df
Output:

Tada! Kolom 'Kategori_Usia' sekarang menunjukkan kategori usia berdasarkan nilai di

kolom 'Usia'.

Perbedaan Antara Apply dan Map

Meskipun apply dan map tampak serupa, ada perbedaan penting antara keduanya:

Sifat Penerapan:
● apply dapat bekerja pada baris atau kolom DataFrame, sedangkan map hanya
bekerja pada elemen Series.
Keluaran:
● apply bisa menghasilkan Series atau DataFrame, tergantung pada fungsi yang
diterapkan. map, di sisi lain, selalu menghasilkan Series.
Fleksibilitas:
● apply lebih fleksibel dan bisa menerima fungsi lambda, fungsi biasa, atau bahkan
agregasi lain seperti sum atau mean.
● map hanya bisa menerima kamus atau fungsi sederhana.

Mari kita lihat beberapa contoh lanjutan untuk mendapatkan pemahaman yang lebih baik.
Menggunakan Apply dengan Fungsi Lambda

Katakanlah kita ingin menghitung setengah dari usia seseorang. Kita bisa menggunakan
fungsi lambda dengan apply untuk tujuan ini.​
# Menggunakan apply dengan fungsi lambda
df['Setengah_Usia'] = df['Usia'].apply(lambda x: x/2)
df
Output:

Hasilnya, kolom 'Setengah_Usia' sekarang menampilkan setengah dari usia setiap individu.

Menggunakan Map dengan Kamus (dictionary)

Misalkan kita memiliki kamus yang memetakan nama ke hobi favorit mereka. Kita bisa
menggunakan map untuk menambahkan hobi ini ke DataFrame kita.​
# Kamus hobi berdasarkan nama
hobi_kamus = {
'Alice': 'Membaca',
'Bob': 'Bersepeda',
'Charlie': 'Memasak',
'David': 'Menulis'
}

# Menggunakan map dengan kamus

df['Hobi'] = df['Nama'].map(hobi_kamus)
df
Output:

Kolom 'Hobi' sekarang menampilkan hobi masing-masing individu berdasarkan kamus

yang kita berikan.
Menggunakan Apply pada Beberapa Kolom

Salah satu kelebihan dari apply adalah kemampuannya untuk bekerja dengan beberapa
kolom sekaligus. Misalnya, kita ingin membuat kolom baru yang menggabungkan informasi
dari kolom 'Nama' dan 'Usia'.​
# Menggunakan apply pada beberapa kolom
df['Info'] = df.apply(lambda row: f"{row['Nama']} berusia {row['Usia']}
tahun", axis=1)
df
Output:

Seperti yang kamu lihat, dengan menggunakan apply pada axis=1 (yang menunjukkan
operasi sepanjang baris), kita dapat menggabungkan informasi dari beberapa kolom untuk
membuat kolom 'Info'.

Selain menerapkan fungsi langsung, seringkali kita ingin menerapkan operasi berdasarkan
kondisi tertentu. Untuk itu, kita bisa menggabungkan apply atau map dengan fungsi
bersyarat.

Menggunakan Apply dengan Kondisi

Misalkan kita ingin menentukan apakah seseorang adalah seorang "penulis" berdasarkan
hobi mereka. Kita bisa menggunakan apply dengan kondisi untuk tujuan ini.
# Menggunakan apply dengan kondisi
df['Adalah_Penulis'] = df['Hobi'].apply(lambda x: True if x == 'Menulis'
else False)
df
Output:
Kolom 'Adalah_Penulis' sekarang menunjukkan apakah seseorang memiliki hobi menulis
atau tidak.

Menggunakan Map dengan Kamus dan Kondisi

Kadang-kadang, kita mungkin ingin memetakan nilai berdasarkan kamus tetapi juga
memiliki "default" jika nilai tersebut tidak ditemukan dalam kamus. Kita dapat
menggunakan kombinasi map dan fungsi fillna untuk ini.

Misalkan kita ingin menambahkan kolom yang menunjukkan warna favorit seseorang
berdasarkan nama mereka. Tetapi kita hanya tahu warna favorit beberapa orang. Untuk
yang lain, kita ingin menetapkan default "Biru". Mari kita coba.​
# Kamus warna berdasarkan nama
warna_kamus = {
'Alice': 'Merah',
'Charlie': 'Hijau',
}

# Menggunakan map dengan kamus dan mengisi nilai yang hilang dengan
"Biru"
df['Warna_Favorit'] = df['Nama'].map(warna_kamus).fillna('Biru')
df
Output:

Hasilnya, kolom 'Warna_Favorit' sekarang menunjukkan warna favorit setiap individu. Jika
nama mereka tidak ditemukan dalam kamus, maka secara default mereka diberi warna
"Biru".

Penggunaan Gabungan Apply dan Map

Ada situasi di mana kamu mungkin ingin menggunakan apply dan map secara bersamaan.
Misalnya, kamu ingin mengaplikasikan fungsi pada satu kolom tetapi hasilnya bergantung
pada nilai kolom lain.

Misalkan kita ingin menentukan apakah seseorang lebih suka aktivitas di dalam atau di luar
ruangan berdasarkan hobi mereka. Bersepeda adalah aktivitas luar ruangan, sementara
membaca dan menulis adalah aktivitas di dalam ruangan. Mari kita coba.​
# Fungsi untuk menentukan preferensi aktivitas berdasarkan hobi
 def aktivitas_preferensi(row):
outdoor_hobbies = ['Bersepeda']
if row['Hobi'] in outdoor_hobbies:
return 'Luar Ruangan'
else:
return 'Dalam Ruangan'

# Menggunakan apply bersamaan dengan informasi dari kolom lain

df['Preferensi_Aktivitas'] = df.apply(aktivitas_preferensi, axis=1)
df
Output:

Kolom 'Preferensi_Aktivitas' sekarang menunjukkan apakah seseorang lebih suka aktivitas

di dalam atau di luar ruangan berdasarkan hobi mereka.

Dengan memahami dan menguasai apply dan map, kamu dapat dengan cepat dan efisien
mengubah dan memanipulasi data di Pandas. Keduanya memberikan fleksibilitas yang
besar dan memungkinkan untuk transformasi data yang kompleks tanpa harus menulis
banyak kode.

Semakin sering kamu berlatih dengan contoh nyata, semakin mahir kamu dalam
menerapkan teknik-teknik ini dalam situasi sehari-hari. Selalu ingat untuk bereksperimen
dan mencari cara baru untuk memanfaatkan kekuatan kedua fungsi ini!

3.10 Konversi antara DataFrame dan Numpy Array

Pandas dan Numpy adalah dua library Python yang paling sering digunakan dalam analisis
data dan ilmu data. Pandas terutama digunakan untuk manipulasi dan analisis data tabular,
sementara Numpy digunakan untuk operasi matematika dan aljabar linier. Terkadang,
tergantung pada tugas yang kamu lakukan, kamu mungkin perlu mengonversi antara
DataFrame Pandas dan Numpy Array. Di bagian ini, kita akan membahas cara melakukan
konversi tersebut.

Mengapa Perlu Konversi?

Sebelum kita masuk ke bagian teknis, pertanyaan pertama yang mungkin muncul adalah,
"Mengapa kita perlu mengonversi antara kedua jenis struktur data ini?"
Alasannya sederhana:
1. Beberapa algoritma atau library, khususnya yang berfokus pada komputasi numerik
atau pembelajaran mesin, seperti Scikit-learn, mungkin memerlukan input dalam
bentuk Numpy Array.
2. Pandas DataFrame menyediakan lebih banyak fungsionalitas untuk manipulasi data,
seperti menghandle data yang hilang, memberi label pada data, dan lainnya. Jadi,
terkadang lebih mudah untuk memulai dengan DataFrame, melakukan beberapa
prapemrosesan, lalu mengonversinya ke Numpy Array untuk analisis lebih lanjut
atau pemodelan.
Dengan pemahaman dasar ini, mari kita lanjutkan ke bagian teknis.

Konversi DataFrame ke Numpy Array

Untuk mengonversi DataFrame ke Numpy Array, kamu bisa menggunakan metode .values
atau metode .to_numpy() dari DataFrame.

Contoh Sederhana:

Mari kita buat DataFrame sederhana dan konversi ke Numpy Array.

import numpy as np

# Membuat data sintetis

df_example = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
})

# Mengonversi DataFrame ke Numpy Array menggunakan .values

np_array_values = df_example.values

# Mengonversi DataFrame ke Numpy Array menggunakan .to_numpy()

np_array_to_numpy = df_example.to_numpy()

np_array_values, np_array_to_numpy
Output:

Seperti yang kamu lihat, kedua metode tersebut menghasilkan Numpy Array yang sama,
yang merupakan representasi dari DataFrame asli kita.
Konversi Numpy Array ke DataFrame

Sekarang, bagaimana jika kita memiliki Numpy Array dan ingin mengubahnya menjadi
DataFrame? Untuk tujuan ini, kita bisa menggunakan konstruktor pd.DataFrame().

Contoh Sederhana:

Dari Numpy Array yang telah kita buat sebelumnya, mari kita konversi kembali ke
DataFrame.​
# Mengonversi Numpy Array ke DataFrame
df_from_np = pd.DataFrame(np_array_values, columns=['A', 'B', 'C'])
df_from_np
Output:

Kita telah berhasil mengonversi Numpy Array kembali ke DataFrame. Perhatikan bahwa
kita perlu memberikan nama kolom dengan argumen columns saat membuat DataFrame.

Memanipulasi Data Setelah Konversi

Setelah konversi, kamu bebas untuk melakukan manipulasi data dengan kemampuan
penuh dari Pandas atau Numpy, tergantung pada struktur data yang kamu gunakan.

Contoh:

Misalkan kita ingin menambahkan kolom baru ke DataFrame yang kita hasilkan dari
Numpy Array. Kolom baru ini akan berisi penjumlahan dari kolom 'A' dan 'B'. Mari kita coba.​
# Menambahkan kolom baru ke DataFrame
df_from_np['D'] = df_from_np['A'] + df_from_np['B']
df_from_np
Output:
Seperti yang kamu lihat, kita telah berhasil menambahkan kolom baru ke DataFrame.

Perhatikan Indeks saat Mengonversi

Salah satu fitur kunci dari DataFrame adalah indeksnya. Saat kamu mengonversi antara
DataFrame dan Numpy Array, perlu diperhatikan bagaimana indeks ditangani.

Jika DataFrame memiliki indeks kustom, mengonversinya ke Numpy Array hanya akan
mengambil nilai data, bukan indeks. Namun, saat mengonversi kembali ke DataFrame,
indeks default (0, 1, 2,...) akan diterapkan kecuali kamu memberikan indeks kustom.

Contoh:
# Membuat DataFrame dengan indeks kustom
df_custom_index = pd.DataFrame({
'X': [10, 20, 30],
'Y': [40, 50, 60]
}, index=['a', 'b', 'c'])

# Mengonversi ke Numpy Array

np_array_custom = df_custom_index.values

# Mengonversi kembali ke DataFrame tanpa memberikan indeks

df_from_custom_np = pd.DataFrame(np_array_custom, columns=['X', 'Y'])

df_custom_index, df_from_custom_np
Output:

Dari contoh di atas, kamu dapat melihat bahwa DataFrame asli memiliki indeks kustom ('a',
'b', 'c'). Namun, setelah konversi bolak-balik, DataFrame yang dihasilkan memiliki indeks
default (0, 1, 2).
Bab 4. Visualisasi Data dengan Pandas

4.1 Plot Dasar dengan Pandas

Visualisasi data adalah salah satu elemen terpenting dalam analisis data. Grafik dan plot
membuat informasi lebih mudah dipahami dan interpretasi data menjadi lebih intuitif.
Nah, Pandas, selain dikenal sebagai pustaka manipulasi data yang kuat, juga memiliki
kemampuan visualisasi data yang memadai untuk kebutuhan dasar.

Tidak perlu library tambahan, cukup dengan Pandas, kamu sudah bisa membuat berbagai
jenis plot yang menarik. Tertarik? Ayo kita mulai eksplorasi!

Import Library dan Persiapan Data

Sebelum mulai, pastikan kita sudah mengimpor semua library yang dibutuhkan. Untuk
kebutuhan ini, kita hanya memerlukan Pandas dan NumPy untuk membuat data sintetis.
import pandas as pd
import numpy as np

Mari kita buat beberapa data sintetis untuk digunakan dalam contoh plot ini.
# Membuat DataFrame dengan data sintetis
np.random.seed(0)
df = pd.DataFrame({
'A': np.random.randn(100),
'B': np.random.randint(1, 100, 100),
'C': np.random.uniform(0, 1, 100)
})
df
Output:
Plot Sederhana

Salah satu hal yang paling menarik dari Pandas adalah kemampuannya untuk membuat plot
dengan satu baris kode. Ya, satu baris kode!
# Plot kolom 'A'
df['A'].plot()
Output:

Ini akan menghasilkan line plot dari kolom 'A'. Mudah, bukan?

Mengubah Jenis Plot

Pandas mendukung berbagai jenis plot. Kamu bisa mengubah jenis plot dengan
menambahkan parameter kind dalam fungsi plot().
# Membuat histogram dari kolom 'B'
df['B'].plot(kind='hist')
Output:

Menambahkan Judul dan Label

Menambahkan judul dan label sumbu sangat mudah.

df['A'].plot(title='Line Plot Kolom A', xlabel='Index', ylabel='Nilai
A')
Output:

Plot Semua Kolom

Ingin menampilkan semua kolom dalam satu plot? Gampang!

df.plot()
Output:
Ini akan membuat line plot untuk setiap kolom numerik dalam DataFrame.

Subplots: Beberapa Plot dalam Satu Gambar

Saat kita punya beberapa kolom data dan ingin melihat plot mereka bersamaan tapi
terpisah, kita bisa menggunakan subplots.
ax = df.plot(subplots=True, layout=(3,1), figsize=(10, 8),
title='Subplots untuk Setiap Kolom')
Output:
Dalam contoh ini, kita menggunakan parameter subplots=True dan layout=(3,1) untuk
menampilkan plot dari ketiga kolom dalam tiga baris dan satu kolom. Parameter figsize
digunakan untuk menentukan ukuran dari plot.

Menggunakan Parameter style

Kamu bisa juga menambahkan lebih banyak informasi visual dengan menggunakan
parameter style.
df['A'].plot(style='--', title='Garis Putus-Putus untuk Kolom A')
Output:

Dalam contoh ini, kita menggunakan style='--' untuk membuat garis putus-putus dalam plot.

Spesifikasi Warna
Warna dalam plot juga bisa disesuaikan dengan menggunakan parameter color.
df['C'].plot(color='red', title='Plot Kolom C dengan Warna Merah')
Output:
Menyimpan Plot

Jika kamu ingin menyimpan plot yang telah dibuat, gunakan metode savefig dari objek plot.
plot = df['A'].plot(title='Line Plot Kolom A')
plot.figure.savefig('plot.png')

Limit pada Sumbu X dan Y

Kadang kita hanya ingin melihat sebagian data dalam plot. Kita bisa membatasi sumbu
menggunakan xlim dan ylim.
df['A'].plot(xlim=[0, 50], ylim=[-3, 3])
Output:

Menambahkan Grid

Untuk mempermudah membaca plot, kita bisa menambahkan grid.

df['A'].plot(grid=True)
Output:
4.2 Lebih Dalam tentang Grafik Batang dan Histogram
Ah, grafik batang dan histogram, dua alat visualisasi data yang begitu powerful tapi sering
disalahpahami. Banyak orang bahkan bingung membedakan keduanya. Jangan khawatir, di
subab ini, kita akan mengeksplorasi keduanya: dari cara membuatnya hingga kapan harus
menggunakan yang mana. Selamat datang di dunia grafik batang dan histogram!

Sebelumnya, mari kita generate dataframe sintetis untuk arena bermain kita:
# Importing necessary libraries
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Generating synthetic data

np.random.seed(0)
data = {
'Months': ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
'Sep', 'Oct', 'Nov', 'Dec'],
'Sales': np.random.randint(200, 1000, 12),
'Expenses': np.random.randint(100, 500, 12)
}

df = pd.DataFrame(data)
df
Output:
Mengenal Grafik Batang (Bar Chart)

Sebelum kita mulai coding, mari kita pahami apa itu grafik batang. Grafik batang adalah
jenis grafik yang menggunakan bar atau batang vertikal atau horizontal untuk
menunjukkan perbandingan antara dua atau lebih kategori. Misalnya, kamu ingin
mengetahui penjualan dan pengeluaran perusahaan dari Januari hingga Desember.

Grafik Batang Vertikal

Mari kita mulai dengan membuat grafik batang vertikal untuk data penjualan dan
pengeluaran kita.
# Grafik batang vertikal
ax = df.plot(x='Months', y=['Sales', 'Expenses'], kind='bar',
figsize=(12, 6))
plt.title('Monthly Sales and Expenses')
plt.xlabel('Months')
plt.ylabel('Amount in $')
plt.show()
Output:

Tadaa! Inilah grafik batang vertikal kita. Grafik ini menunjukkan penjualan dan
pengeluaran per bulan dari Januari hingga Desember. Dengan satu pandangan, kita sudah
bisa menilai bulan mana yang paling produktif atau bulan mana yang pengeluarannya
cukup besar.
Grafik Batang Horizontal

Nah, bagaimana jika kita ingin membalikkan grafik ini menjadi horizontal? Mudah saja.
Kamu hanya perlu merubah parameter kind menjadi 'barh'.
# Grafik batang horizontal
ax = df.plot(x='Months', y=['Sales', 'Expenses'], kind='barh',
figsize=(12, 6))
plt.title('Monthly Sales and Expenses')
plt.xlabel('Amount in $')
plt.ylabel('Months')
plt.show()
Output:

Dan voila! Inilah grafik batang horizontal kita. Dengan orientasi ini, terkadang lebih mudah
untuk membandingkan data antar kategori jika jumlahnya terlalu banyak.

Grafik Batang Bertumpuk (Stacked Bar Chart)

Salah satu variasi dari grafik batang adalah grafik batang bertumpuk. Di sini, data untuk
beberapa kategori ditumpuk satu di atas yang lainnya. Ini bisa sangat berguna jika kamu
ingin menunjukkan komposisi antara beberapa kategori.
# Membuat grafik batang bertumpuk
ax = df.plot(x='Months', y=['Sales', 'Expenses'], kind='bar',
stacked=True, figsize=(12, 6))
plt.title('Monthly Sales and Expenses (Stacked)')
plt.xlabel('Months')
plt.ylabel('Amount in $')
 plt.show()
Output:

Seperti yang kamu lihat, grafik batang bertumpuk memberikan gambaran tentang
komposisi Sales dan Expenses untuk setiap bulan. Ini bisa sangat berguna ketika kamu
ingin memahami bagaimana dua kategori atau lebih berinteraksi dalam satu grafik.

Histogram: Penghitung Frekuensi Rahasia

Kita sudah cukup familiar dengan grafik batang, tapi bagaimana dengan histogram?
Histogram adalah jenis grafik yang menggambarkan distribusi frekuensi dari suatu set data.
Daripada membandingkan kategori, histogram lebih sering digunakan untuk melihat
bagaimana data terdistribusi dalam suatu kisaran atau interval.

Misalnya, kita ingin mengetahui berapa kali penjualan berada dalam rentang tertentu, kita
bisa menggunakan histogram.
# Membuat histogram untuk kolom 'Sales'
df['Sales'].plot(kind='hist', bins=10, figsize=(12, 6))
plt.title('Sales Distribution')
plt.xlabel('Sales Amount in $')
plt.ylabel('Frequency')
plt.show()
Output:
Bam! Inilah histogram distribusi penjualan kita. Dari grafik ini, kita bisa melihat bahwa
jumlah penjualan yang paling sering terjadi adalah sekitar 600-800 dolar. Ini bisa jadi
informasi penting untuk analisis lebih lanjut, seperti menyiapkan stok atau mengevaluasi
strategi pemasaran.

Histogram dengan Lebih Banyak Bin

Apakah kamu merasa bahwa histogram di atas masih kurang detil? Kita bisa menambahkan
lebih banyak "bin" atau interval untuk mendapatkan gambaran yang lebih jelas.
# Membuat histogram dengan 20 bins
df['Sales'].plot(kind='hist', bins=20, figsize=(12, 6))
plt.title('Sales Distribution')
plt.xlabel('Sales Amount in $')
plt.ylabel('Frequency')
plt.show()
Output:
Keren, kan? Dengan menambahkan lebih banyak "bin", kita mendapatkan gambaran yang
lebih detil tentang distribusi penjualan. Sekarang kita bisa melihat ada beberapa puncak
dan lembah, yang bisa jadi petunjuk untuk analisis lebih lanjut.

Histogram dengan Density Plot

Kamu juga bisa menambahkan density plot atau kurva kepadatan pada histogram untuk
memahami distribusi dengan lebih baik.
# Membuat histogram dengan density plot
ax = df['Sales'].plot(kind='hist', bins=20, density=True, alpha=0.5,
figsize=(12, 6))
df['Sales'].plot(kind='kde', ax=ax)
plt.title('Sales Distribution with Density Plot')
plt.xlabel('Sales Amount in $')
plt.ylabel('Density')
plt.show()
Output:

Tada! Sekarang kamu memiliki histogram yang dilengkapi dengan density plot. Kurva
kepadatan ini memberikan gambaran yang lebih mulus tentang distribusi data. Ini sangat
berguna jika kamu ingin mengetahui bentuk distribusi data tanpa terpengaruh oleh jumlah
bin pada histogram.

Grafik Batang vs Histogram: Kapan Menggunakan yang Mana?

Sebagai penutup, penting untuk memahami kapan sebaiknya menggunakan grafik batang
dan kapan menggunakan histogram.
1. Grafik Batang: Gunakan saat kamu ingin membandingkan beberapa kategori.
Misalnya, penjualan per bulan, per produk, atau per wilayah.
2. Histogram: Gunakan saat kamu ingin memahami distribusi data dalam kisaran atau
interval. Misalnya, umur pelanggan, durasi panggilan, atau rentang harga.
Dengan begitu, kamu akan menjadi lebih pandai dalam memilih alat visualisasi yang tepat
untuk data kamu!

4.3 Lebih Dalam tentang Scatter Plot dan Line Plot

Setelah mempersiapkan data sintetis, kita bisa melanjutkan ke dunia visualisasi yang lebih
kompleks dan menarik: scatter plot dan line plot. Keduanya adalah jenis plot yang sangat
umum digunakan dan mereka masing-masing memiliki kelebihan dan kekurangan. Jadi,
siap untuk menyelami lebih dalam? Ayo kita mulai!

Sebelumnya, mari kita generate dataframe sintetis untuk arena bermain kita:
# Import library yang diperlukan
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Membuat data sintetis

np.random.seed(42)
x_values = np.linspace(0, 10, 100)
y_values = 3 * x_values + 4 + np.random.normal(0, 1, 100)
df_line_scatter = pd.DataFrame({'X': x_values, 'Y': y_values})

df_line_scatter.head()
Output:

Scatter Plot: Titik-titik yang Berbicara

Scatter plot adalah diagram yang menggunakan koordinat kartesius untuk menampilkan
nilai dari dua variabel untuk satu set data. Maksudnya? Sederhananya, scatter plot bisa
memberi kamu gambaran tentang bagaimana dua variabel berhubungan satu sama lain.

Mari kita mulai dengan membuat scatter plot sederhana dari data yang telah kita siapkan.
# Membuat scatter plot sederhana
plt.scatter(df_line_scatter['X'], df_line_scatter['Y'])
plt.title('Simple Scatter Plot')
 plt.xlabel('X values')
plt.ylabel('Y values')
plt.show()
Output:

Tadaa! Inilah scatter plot sederhana yang menunjukkan hubungan antara variabel X dan Y.
Seperti yang bisa kamu lihat, titik-titik cenderung membentuk sebuah garis lurus naik, yang
mengindikasikan adanya hubungan positif antara X dan Y. Dalam kata lain, saat X
bertambah, Y juga ikut bertambah. Ini hanya awal, lho. Scatter plot bisa jauh lebih
kompleks dan informatif dari ini.

Line Plot: Garis yang Menghubungkan

Sekarang, mari kita bicara tentang line plot. Line plot adalah jenis plot yang
menghubungkan titik data individual dengan garis. Ini sangat berguna untuk menampilkan
tren sepanjang waktu. Namun, itu tidak berarti line plot hanya terbatas untuk data waktu;
itu bisa digunakan untuk berbagai jenis data sekuensial.

Membuat line plot tidaklah sulit. Sebenarnya, jika kamu sudah tahu cara membuat scatter
plot, membuat line plot hanyalah selangkah lagi.
# Membuat line plot
plt.plot(df_line_scatter['X'], df_line_scatter['Y'], label='Linear
Relationship')
plt.title('Line Plot')
plt.xlabel('X values')
plt.ylabel('Y values')
plt.legend()
plt.show()
Output:

Kamu lihat? Dengan garis yang menghubungkan setiap titik, sekarang kita bisa lebih mudah
melihat tren atau pola dalam data. Di sini, line plot memperlihatkan hubungan linear antara
variabel X dan Y, yang sejalan dengan apa yang kita lihat di scatter plot.

Kombinasi Scatter Plot dan Line Plot

Hei, bagaimana jika kita ingin yang terbaik dari kedua dunia? Kita bisa, lho!
Mengkombinasikan scatter plot dan line plot dalam satu gambar bisa memberikan kita
kejelasan lebih tentang data. Scatter plot memberi kita titik data asli, sementara line plot
menunjukkan tren atau hubungan antara variabel.
# Mengkombinasikan scatter plot dan line plot
plt.scatter(df_line_scatter['X'], df_line_scatter['Y'], label='Data
Points')
plt.plot(df_line_scatter['X'], df_line_scatter['Y'], label='Linear
Relationship', linestyle='--')
plt.title('Combining Scatter and Line Plot')
plt.xlabel('X values')
plt.ylabel('Y values')
plt.legend()
plt.show()
Output:
Keren, bukan? Dengan menggabungkan scatter plot dan line plot, kita sekarang bisa melihat
bagaimana data point individual mengikuti pola linear yang digambarkan oleh garis. Ini
adalah cara yang efektif untuk menyajikan data dan informasi dalam satu plot.

Scatter Plot dengan Ukuran Variabel

Kadang-kadang, kita ingin menunjukkan lebih banyak informasi dalam scatter plot kita.
Misalnya, apa yang terjadi jika kita punya tiga variabel? Kita bisa menggunakan ukuran titik
di scatter plot untuk menunjukkan nilai dari variabel ketiga.

Mari kita coba dengan data sintetis.

import numpy as np

# Membuat data sintetis

np.random.seed(0)
X = np.linspace(0, 10, 20)
Y = 2 * X + 1 + np.random.normal(0, 1, 20)
Z = np.random.randint(50, 200, 20) # Variabel ketiga untuk ukuran titik

# Membuat scatter plot dengan ukuran variabel

plt.scatter(X, Y, c='blue', s=Z, alpha=0.6, label='Data Points')
plt.title('Scatter Plot with Variable Point Sizes')
plt.xlabel('X values')
plt.ylabel('Y values')
plt.colorbar(label='Size of Points')
plt.legend()
plt.show()
Output:
4.4 Ebook Data Visualization
Untuk mempelajari lebih lanjut tentang cara melakukan Data Visualizations secara lengkap
dan detail, kami merekomendasikan kamu membaca eBook Datasans yaitu Data
Visualization dengan Matplotlib dan Data Visualization dengan Seaborn. Buku ini dirancang
untuk membawa kamu dari pemula hingga mahir dalam seni visualisasi data.

Apa yang Akan Anda Pelajari?

● Konsep dasar visualisasi data.
● Cara menggunakan Matplotlib untuk membuat plot dasar seperti line chart, bar
chart, scatter plot, dll.
● Cara meningkatkan visualisasi kamu dengan Seaborn untuk membuat plot yang
lebih kompleks dan estetis.
● Teknik untuk menyesuaikan dan menyempurnakan visualisasi data kamu agar lebih
menarik dan informatif.
● Studi kasus dan contoh nyata yang menunjukkan kekuatan visualisasi dalam
memecahkan masalah bisnis.
Bab 5. Operasi Lanjutan dengan
Pandas
Pandas adalah salah satu library Python yang paling powerful untuk data analysis dan
manipulation. Dalam bab ini, kamu akan mempelajari berbagai operasi lanjutan yang bisa
dilakukan dengan Pandas untuk membantu kamu dalam analisis data yang lebih kompleks.

5.1 Grouping dan Aggregasi

Penerapan 1: Group By

Gunakan groupby() untuk mengelompokkan data berdasarkan satu atau lebih kolom.
Agregasi bisa dilakukan dengan metode seperti .sum(), .mean(), .max(), .min(), dan lainnya.
import pandas as pd
import numpy as np

# Membuat DataFrame sintetis

df = pd.DataFrame({
'Kategori': np.random.choice(['A', 'B', 'C'], size=10),
'Nilai': np.random.rand(10)
})
print('df:')
display(df)

# Mengelompokkan berdasarkan 'Kategori' dan menghitung rata-rata 'Nilai'

grouped = df.groupby('Kategori').mean()
print('grouped:')
display(grouped)
Output:
Penerapan 2: Aggregasi dengan Berbagai Fungsi

Dapat menerapkan beberapa fungsi agregasi sekaligus menggunakan .agg().

# Mengelompokkan dan menerapkan beberapa fungsi agregasi
aggregated = df.groupby('Kategori').agg(['mean', 'sum', 'count'])
aggregated
Output:

Penerapan 3: Agregasi pada Kolom Tertentu

Gunakan dict di .agg() untuk menentukan fungsi per kolom.

# Mengelompokkan dan menerapkan fungsi yang berbeda untuk kolom yang
berbeda
aggregated = df.groupby('Kategori').agg({'Nilai': ['mean', 'sum']})
aggregated
Output:
Penerapan 4: Group By dengan Custom Function

Bisa juga menerapkan fungsi custom pada hasil group by.

# Mengelompokkan dan menerapkan fungsi custom
def range_func(group):
return group.max() - group.min()

aggregated = df.groupby('Kategori')['Nilai'].agg(range_func)
aggregated
Output:

Penerapan 5: Group By dengan Filter

Gunakan .filter() untuk memfilter grup berdasarkan properti grup.

# Filter grup yang memiliki jumlah data > 2
filtered = df.groupby('Kategori').filter(lambda x: len(x) > 2)
filtered
Output:
5.2 Pivot Table
Penerapan 1: Membuat Pivot Table Sederhana

pivot_table() digunakan untuk membuat tabel rekap data.

pivot_simple = df.pivot_table(values='Nilai', index='Kategori',
aggfunc='mean')
pivot_simple
Output:

Penerapan 2: Menggunakan Fungsi Agregasi Multiple

Bisa menentukan beberapa fungsi agregasi.

pivot_multiple = df.pivot_table(values='Nilai', index='Kategori',
aggfunc=['mean', 'sum'])
pivot_multiple
Output:
Penerapan 3: Pivot dengan Kolom Multi-Index

Bisa membuat pivot table dengan multi-index pada kolom.

df['Subkategori'] = np.random.choice(['X', 'Y', 'Z'], size=10)
pivot_multi_index = df.pivot_table(values='Nilai', index='Kategori',
columns='Subkategori', aggfunc='mean')
pivot_multi_index
Output:

Penerapan 4: Menambahkan Margins (Total)

Menambahkan total keseluruhan di bagian bawah dan samping.

pivot_with_margins = df.pivot_table(values='Nilai', index='Kategori',
aggfunc='mean', margins=True)
pivot_with_margins
Output:

Penerapan 5: Mengisi Nilai NaN dengan Nilai Tertentu

Mengisi nilai NaN dengan nilai tertentu (misal 0).

 pivot_fill_value = df.pivot_table(values='Nilai', index='Kategori',
aggfunc='mean', fill_value=0)
pivot_fill_value
Output:

5.3 Crosstab
Crosstab adalah fungsi di pandas yang memungkinkan kita untuk membuat tabel silang
yang bisa menunjukkan frekuensi dengan cara yang sangat sederhana.

Kita panggil lagi dataframe terakhir dari proses sebelumnya untuk mengingat kembali
bentuknya:
df
Output:

Penerapan 1: Membuat Crosstab Sederhana

Menghitung frekuensi kombinasi dalam dua kolom.

crosstab_simple = pd.crosstab(df['Kategori'], df['Subkategori'])
crosstab_simple
Output:

Penerapan 2: Menambahkan Aggregasi

Menghitung nilai agregat dengan menggunakan nilai kolom ketiga dan fungsi agregasi.

crosstab_agg = pd.crosstab(df['Kategori'], df['Subkategori'],

values=df['Nilai'], aggfunc='mean')
crosstab_agg
Output:

Penerapan 3: Menambahkan Total (Margins)

Menambahkan baris dan kolom total ke crosstab.

Penerapan 4: Normalisasi Crosstab

Normalisasi crosstab untuk mendapatkan proporsi daripada frekuensi.

crosstab_normalized = pd.crosstab(df['Kategori'], df['Subkategori'],
normalize=True)
crosstab_normalized
Output:
Penerapan 5: Crosstab dengan Multiple Columns

Membuat crosstab dengan lebih dari satu kolom pada sumbu indeks atau kolom.
df['AnotherCategory'] = np.random.choice(['L', 'M', 'N'], size=10)
crosstab_multi_col = pd.crosstab([df['Kategori'],
df['AnotherCategory']], df['Subkategori'])
crosstab_multi_col
Output:

5.4 Merging, Joining, dan Concatenating

Operasi ini memungkinkan kita untuk menggabungkan berbagai DataFrame atau Series
dalam berbagai cara.

Sebelumnya mari kita generate 2 dataframe sintetis untuk arena bermain kita:
# Membuat DataFrame lain untuk merge
df = pd.DataFrame({
'Kategori': ['A', 'B', 'C', 'D'],
'Data 1': np.random.rand(4)
})

# Menampilkan DataFrame 1
print("df 1:")
display(df.head())
# Membuat DataFrame lain untuk merge
df2 = pd.DataFrame({
'Kategori': ['C', 'D', 'E', 'F'],
'Data 2': np.random.rand(4)
})

# Menampilkan DataFrame 2
print("df 2:")
display(df2.head())
Output:

Merging

Penerapan 1: Merge Sederhana

merge() digunakan untuk menggabungkan DataFrame berdasarkan kolom kunci.

# Merge sederhana
merged_simple = pd.merge(df, df2, on='Kategori')
merged_simple
Output:
Penerapan 2: Merge dengan How Argument

Mengatur bagaimana operasi gabungan dijalankan (inner, outer, left, right).

# Merge dengan left join
merged_left = pd.merge(df, df2, on='Kategori', how='left')
print('Left Join :')
display(merged_left)

# Merge dengan right join

merged_right = pd.merge(df, df2, on='Kategori', how='right')
print('Right Join :')
display(merged_right)

# Merge dengan outer join

merged_outer = pd.merge(df, df2, on='Kategori', how='outer')
print('Outer Join :')
display(merged_outer)
Output:
Penerapan 3: Merge dengan Indikator

Menambahkan kolom yang menunjukkan sumber setiap baris.

# Merge dengan indikator
merged_indicator = pd.merge(df, df2, on='Kategori', how='outer',
indicator=True)
merged_indicator
Output:

Penerapan 4: Merge Berdasarkan Index

Menggunakan index untuk melakukan merge.

# Merge berdasarkan index
merged_index = pd.merge(df, df2, left_index=True, right_index=True)
merged_index

Penerapan 5: Merge dengan Multiple Keys

Menggunakan lebih dari satu kolom sebagai kunci untuk merge.

# Tambahkan kolom kunci tambahan pada df dan df2 untuk contoh

df['Subkategori'] = pd.Series(['V', 'W', 'X', 'Y'])
df2['Subkategori'] = pd.Series(['X', 'Y', 'Z', 'W'])
# Merge dengan multiple keys
merged_multi_keys = pd.merge(df, df2, on=['Kategori', 'Subkategori'])
merged_multi_keys
Output:
5.5 Time Series Analysis dengan Pandas
Analisis deret waktu dengan Pandas memungkinkan kamu untuk menganalisis dan
memprediksi data yang tergantung pada waktu.

Penerapan 1: Konversi String ke Datetime

Konversikan string ke datetime untuk analisis yang lebih mudah.

import pandas as pd
import numpy as np

# Contoh Penerapan 1: Konversi String ke Datetime

# Membuat data sintetis dengan tanggal sebagai string
np.random.seed(0) # Untuk reproducibility
date_rng = pd.date_range(start='1/1/2022', end='1/08/2022', freq='H')
df_time = pd.DataFrame(date_rng, columns=['date'])
df_time['data'] = np.random.randint(0, 100, size=(len(date_rng)))

# Konversi kolom date dari string ke datetime

df_time['date'] = pd.to_datetime(df_time['date'])

df_time.info() # Periksa tipe data kolom 'date'

df_time.head() # Tampilkan 5 baris pertama
Output:

Output menunjukkan bahwa kita telah berhasil membuat DataFrame dengan kolom date
yang memiliki tipe data datetime64[ns], yang cocok untuk analisis deret waktu.
Penerapan 2: Mengatur Datetime sebagai Index

Sekarang, kita akan melanjutkan dengan Penerapan 2, di mana kita akan mengatur kolom
date sebagai index dari DataFrame. Ini akan memudahkan operasi selanjutnya yang
berkaitan dengan analisis deret waktu. Mari kita lakukan itu sekarang.​
# Penerapan 2: Mengatur Datetime sebagai Index
df_time.set_index('date', inplace=True)

df_time.head() # Tampilkan 5 baris pertama dengan index datetime

Output:

Kolom date kini telah menjadi index dari DataFrame, yang memudahkan kita untuk
melakukan operasi seleksi berdasarkan waktu.

Penerapan 3: Seleksi Berdasarkan Rentang Waktu

Selanjutnya, kita akan melanjutkan dengan Penerapan 3. Kita akan memilih data untuk
tanggal 1 Januari 2022. Mari kita lihat cara melakukannya.​
# Penerapan 3: Seleksi Berdasarkan Rentang Waktu
# Memilih data untuk tanggal 1 Januari 2022
selected_data = df_time['2022-01-01']

selected_data
Output:
Kita telah berhasil memilih data untuk seluruh hari pada 1 Januari 2022. Perhatikan bahwa
ada peringatan yang menyarankan kita untuk menggunakan .loc[] untuk seleksi ini pada
versi Pandas di masa mendatang. Untuk mematuhi praktik terbaik, kita seharusnya
menggunakan df_time.loc['2022-01-01'].

Penerapan 4: Resampling

Berikutnya, kita akan melanjutkan dengan Penerapan 4, di mana kita akan mengubah
frekuensi data menjadi rata-rata harian. Mari kita lakukan itu sekarang.​​
# Penerapan 4: Resampling - Mengubah frekuensi data menjadi rata-rata
harian
resampled_data = df_time.resample('D').mean()

resampled_data
Output:

Dengan menggunakan resampling, kita telah mengubah data menjadi rata-rata harian. Ini
menghasilkan satu nilai rata-rata untuk setiap hari dalam dataset.
Penerapan 5: Rolling dan Expanding

Gunakan rolling dan expanding untuk analisis tren dan volatilitas.

Untuk Penerapan 5, kita akan menunjukkan bagaimana kita dapat menghitung rata-rata
bergerak 3 jam dari data kita. Ini akan membantu kita memahami tren dalam data dalam
interval waktu yang lebih pendek. Mari kita lakukan operasi rolling.​
# Penerapan 5: Rolling - Menghitung rata-rata bergerak 3 jam
rolling_data = df_time.rolling(window=3).mean()

rolling_data.head(10) # Tampilkan 10 baris pertama dari hasil rolling

Output:

5.6 Window Functions dengan Pandas

Dalam analisis data menggunakan Pandas, fungsi window atau fungsi jendela memegang
peranan penting. Fungsi window memungkinkan kita untuk melakukan operasi di dalam
suatu subset dari data. Hal ini berguna, terutama ketika kita bekerja dengan data time series
atau data yang memerlukan perhitungan berdasarkan suatu interval.

Jenis Window Functions

Ada beberapa jenis fungsi window yang sering digunakan:

1. Rolling Window: Operasi dihitung berdasarkan jumlah data tertentu.
2. Expanding Window: Seperti rolling window, namun ukuran window bertambah
secara bertahap.
3. Exponential Weighted Window: Memberi bobot yang berbeda, biasanya lebih berat
pada data yang lebih baru.
Contoh Penerapan Window Functions

Mari kita gunakan data sintetis untuk memahami cara kerja window functions. Pertama,
kita harus mengimpor library Pandas.
import pandas as pd
import numpy as np

Membuat DataFrame Sintetis

# Membuat DataFrame dengan 10 baris data
np.random.seed(0)
data = np.random.randn(10)
tanggal = pd.date_range('20230101', periods=10)
df = pd.DataFrame(data, columns=['Nilai'], index=tanggal)
df
Output:

Rolling Window

Rolling window melakukan kalkulasi berdasarkan jumlah elemen tertentu dalam window.

Sintaks Dasar
df['Nilai_Rolling_Mean_3'] = df['Nilai'].rolling(window=3).mean()
df
Output:
Dalam contoh di atas, kita menghitung rata-rata dari setiap tiga elemen. Jadi, untuk tiga
elemen pertama, kita menghitung rata-rata mereka, lalu bergerak ke elemen kedua, ketiga,
dan keempat, dan seterusnya.

Expanding Window

Expanding window melakukan kalkulasi dari awal sampai elemen saat ini, sehingga
ukurannya bertambah seiring dengan bergeraknya index.

Sintaks Dasar

Dengan expanding(), setiap nilai rata-rata dihitung dari awal sampai baris saat ini.

Exponential Weighted Window

Exponential weighted window memberikan bobot yang lebih besar pada nilai yang lebih
baru.
Sintaks Dasar
df['Nilai_Ewm_Mean_3'] = df['Nilai'].ewm(span=3).mean()
df
Output:

Dalam contoh ini, ewm dengan span=3 memberikan bobot yang lebih besar pada data
terbaru dalam perhitungan rata-rata.

5.7 Querying DataFrame dengan Pandas

Querying DataFrame adalah proses memilih baris atau kolom dari DataFrame berdasarkan
satu atau lebih kondisi. Ini sangat penting dalam analisis data untuk memfilter dan
memanipulasi data sesuai kebutuhan.

Dasar-dasar Querying

Menggunakan [] dan .loc[]

Kita dapat menggunakan operator [] atau metode .loc[] untuk memilih baris berdasarkan
kondisi.

Contoh:
import pandas as pd

# Membuat DataFrame contoh

data = {'nama': ['Ayu', 'Budi', 'Citra', 'Dodi'],
'usia': [23, 30, 22, 25],
'kota': ['Jakarta', 'Bandung', 'Surabaya', 'Yogyakarta']}
 df = pd.DataFrame(data)
df
Output:

# Query menggunakan []
df[df['usia'] > 25]
Output:

df.loc[df['kota'] == 'Bandung']
Output:

Menggunakan .query()

Metode .query() di Pandas memungkinkan kita untuk menulis kondisi querying dalam
bentuk string yang lebih mudah dibaca dan ditulis.

Contoh:
df.query('usia > 25 and kota == "Bandung"')
Output:

Multiple Conditions

Kita bisa menggabungkan beberapa kondisi dalam satu query.

Contoh:
df.query('usia >= 25 and kota != "Jakarta"')
Output:
Menggunakan Variabel dalam Query

Kita dapat memasukkan variabel Python ke dalam query dengan menggunakan @.

Contoh:
batas_usia = 25
df.query('usia > @batas_usia')
Output:

Querying dengan Fungsi String

Pandas menyediakan fungsi untuk string yang bisa digunakan dalam querying, seperti
str.startswith(), str.contains(), dll.

Contoh:
df[df['nama'].str.startswith('B')]
Output:

Tips dan Trik

Menggabungkan .query() dengan Fungsi Lain

Querying sering dikombinasikan dengan fungsi lain seperti .groupby(), .sort_values(), dan
lainnya.

Contoh:
df.query('usia > 25').groupby('kota').mean()
Output:
Menggunakan isin untuk Filtering Berdasarkan List

Ketika ingin memfilter berdasarkan list nilai, gunakan isin.

Contoh:
kota_terpilih = ['Bandung', 'Yogyakarta']
df[df['kota'].isin(kota_terpilih)]
Output:

Menggunakan Conditional Operators

Pandas mendukung operator kondisional standar seperti ==, !=, >, <, >=, dan <= untuk
membuat query yang kompleks.

Contoh:
df[(df['usia'] >= 25) & (df['kota'] != 'Jakarta')]
Output:

Menggunakan .eval()

Metode .eval() sangat berguna untuk evaluasi ekspresi yang kompleks dan bisa
meningkatkan kinerja.

Contoh:
df['total'] = df.eval('usia * 2') # Menambah kolom baru yang merupakan
hasil perhitungan
df
Output:
Indexing dengan .iloc[]

Metode .iloc[] digunakan untuk indexing berdasarkan posisi integer.

Contoh:
df.iloc[0:2] # Mengambil dua baris pertama
Output:

Menggunakan Regular Expressions

Regular expressions (regex) bisa digunakan dalam Pandas untuk query yang memerlukan
pencocokan pola yang lebih kompleks.

Contoh:
import re
df[df['nama'].str.contains('di$', regex=True)] # Nama yang berakhir
dengan 'di'
Output:

Handling Missing Data dalam Queries

Mengelola data yang hilang (missing data) adalah bagian penting dari querying.

Contoh:
df[df['usia'].notna()] # Memilih baris dimana usia tidak null
Output:
Bab 6. IO di Pandas: Memuat dan
Menyimpan Data
6.1 Menyimpan Data dari CSV dengan Pandas
Menyimpan data ke dalam format CSV (Comma-Separated Values) adalah salah satu cara
paling dasar namun efektif dalam pengelolaan data. Format CSV populer karena
kemudahannya dalam berbagi dan kompatibilitas dengan berbagai platform dan aplikasi.

Dasar Menyimpan ke CSV

Pandas menyediakan fungsi .to_csv() untuk menyimpan DataFrame ke dalam file CSV.

Contoh Sederhana
import pandas as pd

# Membuat DataFrame sederhana

data = {'nama': ['Ayu', 'Budi', 'Citra'],
'usia': [23, 30, 22]}
df = pd.DataFrame(data)

# Menyimpan ke CSV
df.to_csv('data_sederhana.csv')

Opsi Saat Menyimpan ke CSV

Pandas memungkinkan berbagai opsi saat menyimpan ke CSV, yang meningkatkan

fleksibilitas.

Menentukan Kolom

Kamu bisa menentukan kolom mana saja yang ingin disimpan.

df.to_csv('hanya_nama.csv', columns=['nama'])

Menghilangkan Index

Secara default, Pandas akan menyimpan index. Kamu bisa memilih untuk tidak
menyimpannya.
df.to_csv('tanpa_index.csv', index=False)
Pemisah Kustom

Kamu dapat menentukan pemisah selain koma (default).

df.to_csv('data_pemisah.tsv', sep='\t') # TSV (Tab-Separated Values)

Encoding Khusus

Jika bekerja dengan data dalam bahasa atau format tertentu, kamu bisa menentukan
encoding.
df.to_csv('data_utf8.csv', encoding='utf-8')

Menyimpan Data Besar

Ketika bekerja dengan set data yang sangat besar, mungkin perlu untuk
mempertimbangkan aspek kinerja dan efisiensi.

Compresi File

Kamu dapat menyimpan data dalam format terkompresi untuk menghemat ruang.
df.to_csv('data_kompresi.zip', compression='zip')

Header Kustom

Kamu dapat menentukan header kustom saat menyimpan ke CSV, terutama berguna jika
kamu ingin mengubah nama kolom saat ekspor.

Contoh:
df.to_csv('data_header_kustom.csv', header=['Nama Lengkap', 'Umur'])

Menyimpan dengan Format Tertentu

Kadang kala, kamu mungkin ingin menyimpan angka dengan format tertentu, seperti
jumlah desimal tertentu.

Contoh:
df.to_csv('data_format.csv', float_format='%.2f')

Menyimpan dengan Mode Append

Jika kamu ingin menambahkan data ke file CSV yang sudah ada, gunakan mode append.
Contoh:
df.to_csv('data_append.csv', mode='a', header=False)

6.2 Membaca Data ke CSV dengan Pandas

Dasar-dasar Membaca CSV

Pandas menggunakan fungsi .read_csv() untuk membaca file CSV dan mengubahnya
menjadi DataFrame.

Contoh Dasar
Kita akan mencoba membaca file tanpa_index.csv yang di subbab sebelumnya telah
disimpan.

import pandas as pd

# Membaca file CSV

df = pd.read_csv('tanpa_index.csv')
df
Output:

Opsi Saat Membaca CSV

Pandas memungkinkan berbagai opsi saat membaca CSV, yang memudahkan penanganan
berbagai kasus.

Menentukan Kolom

Kamu dapat menentukan kolom mana saja yang ingin dimuat.

df = pd.read_csv('tanpa_index.csv', usecols=['nama'])
df
Output:
Mengubah Tipe Data Kolom

Kamu bisa mengubah tipe data kolom saat membaca file.

Menghandle Missing Data

Pandas memungkinkan kamu untuk menentukan cara menangani data yang hilang.
df = pd.read_csv('tanpa_index.csv', na_values=['NA', 'kosong'])
df
Output:

Menggunakan Index Khusus

Kamu dapat menggunakan salah satu kolom dari CSV sebagai index DataFrame.
df = pd.read_csv('tanpa_index.csv', index_col='nama')
df
Output:

Memilih Kolom Saat Membaca

Membatasi kolom yang dimuat dapat mengurangi penggunaan memori.

df = pd.read_csv('tanpa_index.csv', usecols=['usia'])
df
Output:

6.3 Menyimpan Data dari Excel dengan Pandas

Dasar-dasar Menyimpan ke Excel

Pandas menggunakan kelas ExcelWriter dan fungsi .to_excel() untuk menyimpan

DataFrame ke dalam file Excel.

Contoh Dasar
# Membuat DataFrame sederhana
data = {'nama': ['Ayu', 'Budi', 'Citra'],
'usia': [23, 30, 22]}
df = pd.DataFrame(data)

# Menyimpan ke Excel
df.to_excel('contoh_data.xlsx')

Opsi Saat Menyimpan ke Excel

Menentukan Sheet

Kamu dapat menyimpan DataFrame ke dalam sheet tertentu dalam file Excel.
with pd.ExcelWriter('data_multi_sheet.xlsx') as writer:
df.to_excel(writer, sheet_name='Sheet1')
df.to_excel(writer, sheet_name='Sheet2')

Di bab ini, kita telah menjelajahi cara-cara efisien untuk memuat dan menyimpan data
menggunakan Pandas, khususnya melalui format CSV dan Excel yang banyak digunakan
dalam dunia data. Kita telah belajar bagaimana Pandas memudahkan proses membaca data
dari CSV dan Excel dengan berbagai opsi kustomisasi yang dapat disesuaikan dengan
kebutuhan spesifik dataset kita.
Penutup
Kita telah menelusuri seluk-beluk Pandas, sebuah perpustakaan esensial dalam dunia Data
Science. Mulai dari sejarahnya, konsep dasar, aplikasi dalam pembersihan dan visualisasi
data, hingga operasi lanjutan, semuanya telah kita bahas untuk membantu kamu menguasai
Pandas. Kita juga telah melihat bagaimana Pandas digunakan dalam analisis keuangan,
memberikan kamu pemahaman praktis tentang kekuatan alat ini dalam mengolah dan
menganalisis data keuangan.

Sebagai penutup, izinkan saya memberikan beberapa tips dan trik untuk memaksimalkan
pembelajaran kamu:
● Praktek Rutin: Cara terbaik untuk mempelajari Pandas adalah dengan praktik.
Cobalah untuk mengerjakan proyek atau latihan kecil setiap hari.
● Eksplorasi Dataset Nyata: Gunakan dataset dari dunia nyata untuk mendapatkan
pengalaman praktis. Situs seperti Kaggle menyediakan banyak dataset yang bisa
kamu gunakan.
● Bergabung dengan Komunitas: Bergabunglah dengan forum atau grup diskusi
tentang Python dan Pandas. Komunitas seperti Stack Overflow atau Reddit sangat
membantu untuk bertanya dan berbagi pengetahuan.
● Belajar dari Kesalahan: Jangan takut membuat kesalahan. Kesalahan adalah bagian
dari proses belajar dan seringkali merupakan guru terbaik.
● Manfaatkan Sumber Online: Ada banyak sumber belajar online seperti tutorial,
video, dan kursus yang dapat membantu kamu memahami konsep-konsep yang
rumit.
● Eksperimen dengan Proyek Pribadi: Coba aplikasikan Pandas dalam proyek atau ide
pribadi kamu. Ini akan membantu memperdalam pemahaman kamu tentang cara
kerjanya dalam skenario nyata.
● Tetap Update: Dunia data science terus berkembang. Pastikan untuk tetap mengikuti
perkembangan terbaru di Pandas dan teknologi terkait.